Add files using upload-large-folder tool

local-test-freerdp-full-01/afc-freerdp/docs/mingw-example/build_ia32.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+export ARCH=i686
+. ./_build.sh

local-test-freerdp-full-01/afc-freerdp/docs/mingw-example/toolchain/meson/aarch64.txt

@@ -0,0 +1,15 @@
+[binaries]
+c = 'aarch64-w64-mingw32-gcc'
+cpp = 'aarch64-w64-mingw32-g++'
+ar = 'aarch64-w64-mingw32-ar'
+ld = 'aarch64-w64-mingw32-ld'
+strip = 'aarch64-w64-mingw32-strip'
+
+[host_machine]
+system = 'windows'
+cpu_family = 'aarch64'
+cpu = 'native'
+endian = 'little'
+
+[properties]
+platform = 'generic_aarch64'

local-test-freerdp-full-01/afc-freerdp/server/Mac/CMakeLists.txt

@@ -0,0 +1,77 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP Mac OS X Server cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <[email protected]>
+#
+# 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.
+
+set(MODULE_NAME "mfreerdp-server")
+set(MODULE_PREFIX "FREERDP_SERVER_MAC")
+
+find_library(AUDIO_TOOL AudioToolbox)
+find_library(CORE_AUDIO CoreAudio)
+find_library(CORE_VIDEO CoreVideo)
+find_library(APP_SERVICES ApplicationServices)
+find_library(IOKIT IOKit)
+find_library(IOSURFACE IOSurface)
+find_library(CARBON Carbon)
+
+set(${MODULE_PREFIX}_SRCS
+    mfreerdp.c
+    mfreerdp.h
+    mf_interface.c
+    mf_interface.h
+    mf_event.c
+    mf_event.h
+    mf_peer.c
+    mf_peer.h
+    mf_info.c
+    mf_info.h
+    mf_input.c
+    mf_input.h
+    mf_mountain_lion.c
+    mf_mountain_lion.h
+)
+
+if(CHANNEL_AUDIN_SERVER)
+  set(${MODULE_PREFIX}_SRCS ${${MODULE_PREFIX}_SRCS} mf_audin.c mf_audin.h)
+endif()
+
+if(CHANNEL_RDPSND_SERVER)
+  set(${MODULE_PREFIX}_SRCS ${${MODULE_PREFIX}_SRCS} mf_rdpsnd.c mf_rdpsnd.h)
+
+endif()
+
+add_executable(${MODULE_NAME} ${${MODULE_PREFIX}_SRCS})
+if(WITH_BINARY_VERSIONING)
+  set_target_properties(${MODULE_NAME} PROPERTIES OUTPUT_NAME "${MODULE_NAME}${FREERDP_API_VERSION}")
+endif()
+
+set(${MODULE_PREFIX}_LIBS
+    ${${MODULE_PREFIX}_LIBS}
+    freerdp-server
+    ${AUDIO_TOOL}
+    ${CORE_AUDIO}
+    ${CORE_VIDEO}
+    ${APP_SERVICES}
+    ${IOKIT}
+    ${IOSURFACE}
+    ${CARBON}
+)
+
+set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} winpr freerdp)
+
+target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
+install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "Server/Mac")

local-test-freerdp-full-01/afc-freerdp/server/Mac/ModuleOptions.cmake

@@ -0,0 +1,3 @@
+set(FREERDP_SERVER_NAME "mfreerdp-server")
+set(FREERDP_SERVER_PLATFORM "X11")
+set(FREERDP_SERVER_VENDOR "FreeRDP")

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_audin.c

@@ -0,0 +1,64 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Mac OS X Server (Audio Input)
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[email protected]>
+ * Copyright 2023 Pascal Nowack <[email protected]>
+ *
+ * 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/config.h>
+
+#include "mfreerdp.h"
+
+#include "mf_audin.h"
+#include "mf_interface.h"
+
+#include <freerdp/server/server-common.h>
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("mac")
+
+static UINT mf_peer_audin_data(audin_server_context* audin, const SNDIN_DATA* data)
+{
+	/* TODO: Implement */
+	WINPR_ASSERT(audin);
+	WINPR_ASSERT(data);
+
+	WLog_WARN(TAG, "not implemented");
+	WLog_DBG(TAG, "receive %" PRIdz " bytes.", Stream_Length(data->Data));
+	return CHANNEL_RC_OK;
+}
+
+BOOL mf_peer_audin_init(mfPeerContext* context)
+{
+	WINPR_ASSERT(context);
+
+	context->audin = audin_server_context_new(context->vcm);
+	context->audin->rdpcontext = &context->_p;
+	context->audin->userdata = context;
+
+	context->audin->Data = mf_peer_audin_data;
+
+	return audin_server_set_formats(context->audin, -1, NULL);
+}
+
+void mf_peer_audin_uninit(mfPeerContext* context)
+{
+	WINPR_ASSERT(context);
+
+	audin_server_context_free(context->audin);
+	context->audin = NULL;
+}

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_audin.h

@@ -0,0 +1,33 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Mac OS X Server (Audio Input)
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2013 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_MAC_AUDIN_H
+#define FREERDP_SERVER_MAC_AUDIN_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/listener.h>
+
+#include "mf_types.h"
+#include "mfreerdp.h"
+
+BOOL mf_peer_audin_init(mfPeerContext* context);
+void mf_peer_audin_uninit(mfPeerContext* context);
+
+#endif /* FREERDP_SERVER_MAC_AUDIN_H */

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_event.c

@@ -0,0 +1,219 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * OS X Server Event Handling
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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/config.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "mf_event.h"
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("mac")
+
+static int mf_is_event_set(mfEventQueue* event_queue)
+{
+	fd_set rfds;
+	int num_set;
+	struct timeval time = { 0 };
+
+	FD_ZERO(&rfds);
+	FD_SET(event_queue->pipe_fd[0], &rfds);
+	num_set = select(event_queue->pipe_fd[0] + 1, &rfds, 0, 0, &time);
+
+	return (num_set == 1);
+}
+
+static void mf_signal_event(mfEventQueue* event_queue)
+{
+	int length;
+
+	length = write(event_queue->pipe_fd[1], "sig", 4);
+
+	if (length != 4)
+		WLog_ERR(TAG, "mf_signal_event: error");
+}
+
+static void mf_set_event(mfEventQueue* event_queue)
+{
+	int length;
+
+	length = write(event_queue->pipe_fd[1], "sig", 4);
+
+	if (length != 4)
+		WLog_ERR(TAG, "mf_set_event: error");
+}
+
+static void mf_clear_events(mfEventQueue* event_queue)
+{
+	int length;
+
+	while (mf_is_event_set(event_queue))
+	{
+		length = read(event_queue->pipe_fd[0], &length, 4);
+
+		if (length != 4)
+			WLog_ERR(TAG, "mf_clear_event: error");
+	}
+}
+
+static void mf_clear_event(mfEventQueue* event_queue)
+{
+	int length;
+
+	length = read(event_queue->pipe_fd[0], &length, 4);
+
+	if (length != 4)
+		WLog_ERR(TAG, "mf_clear_event: error");
+}
+
+void mf_event_push(mfEventQueue* event_queue, mfEvent* event)
+{
+	pthread_mutex_lock(&(event_queue->mutex));
+
+	if (event_queue->count >= event_queue->size)
+	{
+		event_queue->size *= 2;
+		event_queue->events =
+		    (mfEvent**)realloc((void*)event_queue->events, sizeof(mfEvent*) * event_queue->size);
+	}
+
+	event_queue->events[(event_queue->count)++] = event;
+
+	pthread_mutex_unlock(&(event_queue->mutex));
+
+	mf_set_event(event_queue);
+}
+
+mfEvent* mf_event_peek(mfEventQueue* event_queue)
+{
+	mfEvent* event;
+
+	pthread_mutex_lock(&(event_queue->mutex));
+
+	if (event_queue->count < 1)
+		event = NULL;
+	else
+		event = event_queue->events[0];
+
+	pthread_mutex_unlock(&(event_queue->mutex));
+
+	return event;
+}
+
+mfEvent* mf_event_pop(mfEventQueue* event_queue)
+{
+	mfEvent* event;
+
+	pthread_mutex_lock(&(event_queue->mutex));
+
+	if (event_queue->count < 1)
+		return NULL;
+
+	/* remove event signal */
+	mf_clear_event(event_queue);
+
+	event = event_queue->events[0];
+	(event_queue->count)--;
+
+	memmove(&event_queue->events[0], &event_queue->events[1], event_queue->count * sizeof(void*));
+
+	pthread_mutex_unlock(&(event_queue->mutex));
+
+	return event;
+}
+
+mfEventRegion* mf_event_region_new(int x, int y, int width, int height)
+{
+	mfEventRegion* event_region = malloc(sizeof(mfEventRegion));
+
+	if (event_region != NULL)
+	{
+		event_region->x = x;
+		event_region->y = y;
+		event_region->width = width;
+		event_region->height = height;
+	}
+
+	return event_region;
+}
+
+void mf_event_region_free(mfEventRegion* event_region)
+{
+	free(event_region);
+}
+
+mfEvent* mf_event_new(int type)
+{
+	mfEvent* event = malloc(sizeof(mfEvent));
+	if (!event)
+		return NULL;
+	event->type = type;
+	return event;
+}
+
+void mf_event_free(mfEvent* event)
+{
+	free(event);
+}
+
+mfEventQueue* mf_event_queue_new()
+{
+	mfEventQueue* event_queue = malloc(sizeof(mfEventQueue));
+
+	if (event_queue != NULL)
+	{
+		event_queue->pipe_fd[0] = -1;
+		event_queue->pipe_fd[1] = -1;
+
+		event_queue->size = 16;
+		event_queue->count = 0;
+		event_queue->events = (mfEvent**)malloc(sizeof(mfEvent*) * event_queue->size);
+
+		if (pipe(event_queue->pipe_fd) < 0)
+		{
+			free(event_queue);
+			return NULL;
+		}
+
+		pthread_mutex_init(&(event_queue->mutex), NULL);
+	}
+
+	return event_queue;
+}
+
+void mf_event_queue_free(mfEventQueue* event_queue)
+{
+	if (event_queue->pipe_fd[0] != -1)
+	{
+		close(event_queue->pipe_fd[0]);
+		event_queue->pipe_fd[0] = -1;
+	}
+
+	if (event_queue->pipe_fd[1] != -1)
+	{
+		close(event_queue->pipe_fd[1]);
+		event_queue->pipe_fd[1] = -1;
+	}
+
+	pthread_mutex_destroy(&(event_queue->mutex));
+}

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_event.h

@@ -0,0 +1,75 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * OS X Server Event Handling
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_MAC_EVENT_H
+#define FREERDP_SERVER_MAC_EVENT_H
+
+typedef struct mf_event mfEvent;
+typedef struct mf_event_queue mfEventQueue;
+typedef struct mf_event_region mfEventRegion;
+
+#include <pthread.h>
+#include "mfreerdp.h"
+
+//#include "mf_peer.h"
+
+enum mf_event_type
+{
+	FREERDP_SERVER_MAC_EVENT_TYPE_REGION,
+	FREERDP_SERVER_MAC_EVENT_TYPE_FRAME_TICK
+};
+
+struct mf_event
+{
+	int type;
+};
+
+struct mf_event_queue
+{
+	int size;
+	int count;
+	int pipe_fd[2];
+	mfEvent** events;
+	pthread_mutex_t mutex;
+};
+
+struct mf_event_region
+{
+	int type;
+
+	int x;
+	int y;
+	int width;
+	int height;
+};
+
+void mf_event_push(mfEventQueue* event_queue, mfEvent* event);
+mfEvent* mf_event_peek(mfEventQueue* event_queue);
+mfEvent* mf_event_pop(mfEventQueue* event_queue);
+
+mfEventRegion* mf_event_region_new(int x, int y, int width, int height);
+void mf_event_region_free(mfEventRegion* event_region);
+
+mfEvent* mf_event_new(int type);
+void mf_event_free(mfEvent* event);
+
+mfEventQueue* mf_event_queue_new(void);
+void mf_event_queue_free(mfEventQueue* event_queue);
+
+#endif /* FREERDP_SERVER_MAC_EVENT_H */

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_info.c

@@ -0,0 +1,231 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Client
+ * FreeRDP Mac OS X Server
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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/config.h>
+
+#include <stdlib.h>
+#include <errno.h>
+
+#include "mf_info.h"
+#include "mf_mountain_lion.h"
+
+#define MF_INFO_DEFAULT_FPS 30
+#define MF_INFO_MAXPEERS 32
+
+static mfInfo* mfInfoInstance = NULL;
+
+int mf_info_lock(mfInfo* mfi)
+{
+	int status = pthread_mutex_lock(&mfi->mutex);
+
+	switch (status)
+	{
+		case 0:
+			return TRUE;
+			break;
+
+		default:
+			return -1;
+			break;
+	}
+
+	return 1;
+}
+
+int mf_info_try_lock(mfInfo* mfi, UINT32 ms)
+{
+	int status = pthread_mutex_trylock(&mfi->mutex);
+
+	switch (status)
+	{
+		case 0:
+			return TRUE;
+			break;
+
+		case EBUSY:
+			return FALSE;
+			break;
+
+		default:
+			return -1;
+			break;
+	}
+
+	return 1;
+}
+
+int mf_info_unlock(mfInfo* mfi)
+{
+	int status = pthread_mutex_unlock(&mfi->mutex);
+
+	switch (status)
+	{
+		case 0:
+			return TRUE;
+			break;
+
+		default:
+			return -1;
+			break;
+	}
+
+	return 1;
+}
+
+static mfInfo* mf_info_init(void)
+{
+	mfInfo* mfi;
+
+	mfi = (mfInfo*)calloc(1, sizeof(mfInfo));
+
+	if (mfi != NULL)
+	{
+		pthread_mutex_init(&mfi->mutex, NULL);
+
+		mfi->peers = (freerdp_peer**)calloc(MF_INFO_MAXPEERS, sizeof(freerdp_peer*));
+		if (!mfi->peers)
+		{
+			free(mfi);
+			return NULL;
+		}
+
+		mfi->framesPerSecond = MF_INFO_DEFAULT_FPS;
+		mfi->input_disabled = FALSE;
+	}
+
+	return mfi;
+}
+
+mfInfo* mf_info_get_instance(void)
+{
+	if (mfInfoInstance == NULL)
+		mfInfoInstance = mf_info_init();
+
+	return mfInfoInstance;
+}
+
+void mf_info_peer_register(mfInfo* mfi, mfPeerContext* context)
+{
+	if (mf_info_lock(mfi) > 0)
+	{
+		int peerId;
+
+		if (mfi->peerCount == MF_INFO_MAXPEERS)
+		{
+			mf_info_unlock(mfi);
+			return;
+		}
+
+		context->info = mfi;
+
+		if (mfi->peerCount == 0)
+		{
+			mf_mlion_display_info(&mfi->servscreen_width, &mfi->servscreen_height, &mfi->scale);
+			mf_mlion_screen_updates_init();
+			mf_mlion_start_getting_screen_updates();
+		}
+
+		peerId = 0;
+
+		for (int i = 0; i < MF_INFO_MAXPEERS; ++i)
+		{
+			// empty index will be our peer id
+			if (mfi->peers[i] == NULL)
+			{
+				peerId = i;
+				break;
+			}
+		}
+
+		mfi->peers[peerId] = ((rdpContext*)context)->peer;
+		mfi->peers[peerId]->pId = peerId;
+		mfi->peerCount++;
+
+		mf_info_unlock(mfi);
+	}
+}
+
+void mf_info_peer_unregister(mfInfo* mfi, mfPeerContext* context)
+{
+	if (mf_info_lock(mfi) > 0)
+	{
+		int peerId;
+
+		peerId = ((rdpContext*)context)->peer->pId;
+		mfi->peers[peerId] = NULL;
+		mfi->peerCount--;
+
+		if (mfi->peerCount == 0)
+			mf_mlion_stop_getting_screen_updates();
+
+		mf_info_unlock(mfi);
+	}
+}
+
+BOOL mf_info_have_updates(mfInfo* mfi)
+{
+	if (mfi->framesWaiting == 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+void mf_info_update_changes(mfInfo* mfi)
+{
+}
+
+void mf_info_find_invalid_region(mfInfo* mfi)
+{
+	mf_mlion_get_dirty_region(&mfi->invalid);
+}
+
+void mf_info_clear_invalid_region(mfInfo* mfi)
+{
+	mf_mlion_clear_dirty_region();
+	mfi->invalid.height = 0;
+	mfi->invalid.width = 0;
+}
+
+void mf_info_invalidate_full_screen(mfInfo* mfi)
+{
+	mfi->invalid.x = 0;
+	mfi->invalid.y = 0;
+	mfi->invalid.height = mfi->servscreen_height;
+	mfi->invalid.width = mfi->servscreen_width;
+}
+
+BOOL mf_info_have_invalid_region(mfInfo* mfi)
+{
+	if (mfi->invalid.width * mfi->invalid.height == 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+void mf_info_getScreenData(mfInfo* mfi, long* width, long* height, BYTE** pBits, int* pitch)
+{
+	*width = mfi->invalid.width / mfi->scale;
+	*height = mfi->invalid.height / mfi->scale;
+	*pitch = mfi->servscreen_width * mfi->scale * 4;
+
+	mf_mlion_get_pixelData(mfi->invalid.x / mfi->scale, mfi->invalid.y / mfi->scale, *width,
+	                       *height, pBits);
+
+	*pBits = *pBits + (mfi->invalid.x * 4) + (*pitch * mfi->invalid.y);
+}

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_info.h

@@ -0,0 +1,49 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Mac OS X Server
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_MAC_INFO_H
+#define FREERDP_SERVER_MAC_INFO_H
+
+#define FREERDP_SERVER_MAC_INFO_DEFAULT_FPS 1
+#define FREERDP_SERVER_MAC_INFO_MAXPEERS 1
+
+#include <winpr/wtypes.h>
+#include <freerdp/codec/rfx.h>
+
+#include "mf_interface.h"
+
+int mf_info_lock(mfInfo* mfi);
+int mf_info_try_lock(mfInfo* mfi, UINT32 ms);
+int mf_info_unlock(mfInfo* mfi);
+
+mfInfo* mf_info_get_instance(void);
+void mf_info_peer_register(mfInfo* mfi, mfPeerContext* context);
+void mf_info_peer_unregister(mfInfo* mfi, mfPeerContext* context);
+
+BOOL mf_info_have_updates(mfInfo* mfi);
+void mf_info_update_changes(mfInfo* mfi);
+void mf_info_find_invalid_region(mfInfo* mfi);
+void mf_info_clear_invalid_region(mfInfo* mfi);
+void mf_info_invalidate_full_screen(mfInfo* mfi);
+BOOL mf_info_have_invalid_region(mfInfo* mfi);
+void mf_info_getScreenData(mfInfo* mfi, long* width, long* height, BYTE** pBits, int* pitch);
+// BOOL CALLBACK mf_info_monEnumCB(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM
+// dwData);
+
+#endif /* FREERDP_SERVER_MAC_INFO_H */

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_input.h

@@ -0,0 +1,36 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Mac OS X Server (Input)
+ *
+ * Copyright 2013 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_MAC_INPUT_H
+#define FREERDP_SERVER_MAC_INPUT_H
+
+#include "mf_interface.h"
+
+BOOL mf_input_keyboard_event(rdpInput* input, UINT16 flags, UINT8 code);
+BOOL mf_input_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
+BOOL mf_input_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+BOOL mf_input_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+
+// dummy versions
+BOOL mf_input_keyboard_event_dummy(rdpInput* input, UINT16 flags, UINT16 code);
+BOOL mf_input_unicode_keyboard_event_dummy(rdpInput* input, UINT16 flags, UINT16 code);
+BOOL mf_input_mouse_event_dummy(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+BOOL mf_input_extended_mouse_event_dummy(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+
+#endif /* FREERDP_SERVER_MAC_INPUT_H */

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_interface.h

@@ -0,0 +1,106 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Client
+ * FreeRDP Mac OS X Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_MAC_INTERFACE_H
+#define FREERDP_SERVER_MAC_INTERFACE_H
+
+#include <pthread.h>
+
+#include <freerdp/config.h>
+#include <freerdp/codec/rfx.h>
+#include <freerdp/codec/nsc.h>
+#include <freerdp/listener.h>
+#include <freerdp/freerdp.h>
+
+#include <winpr/crt.h>
+
+#ifdef WITH_SERVER_CHANNELS
+#include <freerdp/channels/wtsvc.h>
+#endif
+
+#ifdef CHANNEL_RDPSND_SERVER
+#include <freerdp/server/rdpsnd.h>
+#include "mf_rdpsnd.h"
+#endif
+
+#ifdef CHANNEL_AUDIN_SERVER
+#include <freerdp/server/audin.h>
+#include "mf_audin.h"
+#endif
+
+#include "mf_types.h"
+
+struct mf_peer_context
+{
+	rdpContext _p;
+
+	mfInfo* info;
+	wStream* s;
+	BOOL activated;
+	UINT32 frame_id;
+	BOOL audin_open;
+	RFX_CONTEXT* rfx_context;
+	NSC_CONTEXT* nsc_context;
+
+#ifdef WITH_SERVER_CHANNELS
+	HANDLE vcm;
+#endif
+
+#ifdef CHANNEL_AUDIN_SERVER
+	audin_server_context* audin;
+#endif
+
+#ifdef CHANNEL_RDPSND_SERVER
+	RdpsndServerContext* rdpsnd;
+#endif
+};
+
+struct mf_info
+{
+	// STREAM* s;
+
+	// screen and monitor info
+	UINT32 screenID;
+	UINT32 virtscreen_width;
+	UINT32 virtscreen_height;
+	UINT32 servscreen_width;
+	UINT32 servscreen_height;
+	UINT32 servscreen_xoffset;
+	UINT32 servscreen_yoffset;
+
+	int bitsPerPixel;
+	int peerCount;
+	int activePeerCount;
+	int framesPerSecond;
+	freerdp_peer** peers;
+	unsigned int framesWaiting;
+	UINT32 scale;
+
+	RFX_RECT invalid;
+	pthread_mutex_t mutex;
+
+	BOOL mouse_down_left;
+	BOOL mouse_down_right;
+	BOOL mouse_down_other;
+	BOOL input_disabled;
+	BOOL force_all_disconnect;
+};
+
+#endif /* FREERDP_SERVER_MAC_INTERFACE_H */

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_mountain_lion.c

@@ -0,0 +1,269 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * OS X Server Event Handling
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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 <dispatch/dispatch.h>
+#include <CoreGraphics/CoreGraphics.h>
+#include <CoreVideo/CoreVideo.h>
+#include <IOKit/IOKitLib.h>
+#include <IOSurface/IOSurface.h>
+
+#include "mf_mountain_lion.h"
+
+dispatch_semaphore_t region_sem;
+dispatch_semaphore_t data_sem;
+dispatch_queue_t screen_update_q;
+CGDisplayStreamRef stream;
+
+CGDisplayStreamUpdateRef lastUpdate = NULL;
+
+BYTE* localBuf = NULL;
+
+BOOL ready = FALSE;
+
+void (^streamHandler)(CGDisplayStreamFrameStatus, uint64_t, IOSurfaceRef,
+                      CGDisplayStreamUpdateRef) = ^(CGDisplayStreamFrameStatus status,
+                                                    uint64_t displayTime, IOSurfaceRef frameSurface,
+                                                    CGDisplayStreamUpdateRef updateRef) {
+  dispatch_semaphore_wait(region_sem, DISPATCH_TIME_FOREVER);
+
+  // may need to move this down
+  if (ready == TRUE)
+  {
+
+	  RFX_RECT rect;
+	  unsigned long offset_beg;
+	  unsigned long stride;
+
+	  rect.x = 0;
+	  rect.y = 0;
+	  rect.width = 0;
+	  rect.height = 0;
+	  mf_mlion_peek_dirty_region(&rect);
+
+	  // lock surface
+	  IOSurfaceLock(frameSurface, kIOSurfaceLockReadOnly, NULL);
+	  // get pointer
+	  void* baseAddress = IOSurfaceGetBaseAddress(frameSurface);
+	  // copy region
+
+	  stride = IOSurfaceGetBytesPerRow(frameSurface);
+	  // memcpy(localBuf, baseAddress + offset_beg, surflen);
+	  for (int i = 0; i < rect.height; i++)
+	  {
+		  offset_beg = (stride * (rect.y + i) + (rect.x * 4));
+		  memcpy(localBuf + offset_beg, baseAddress + offset_beg, rect.width * 4);
+	  }
+
+	  // unlock surface
+	  IOSurfaceUnlock(frameSurface, kIOSurfaceLockReadOnly, NULL);
+
+	  ready = FALSE;
+	  dispatch_semaphore_signal(data_sem);
+  }
+
+  if (status != kCGDisplayStreamFrameStatusFrameComplete)
+  {
+	  switch (status)
+	  {
+		  case kCGDisplayStreamFrameStatusFrameIdle:
+			  break;
+
+		  case kCGDisplayStreamFrameStatusStopped:
+			  break;
+
+		  case kCGDisplayStreamFrameStatusFrameBlank:
+			  break;
+
+		  default:
+			  break;
+	  }
+  }
+  else if (lastUpdate == NULL)
+  {
+	  CFRetain(updateRef);
+	  lastUpdate = updateRef;
+  }
+  else
+  {
+	  CGDisplayStreamUpdateRef tmpRef;
+	  tmpRef = lastUpdate;
+	  lastUpdate = CGDisplayStreamUpdateCreateMergedUpdate(tmpRef, updateRef);
+	  CFRelease(tmpRef);
+  }
+
+  dispatch_semaphore_signal(region_sem);
+};
+
+int mf_mlion_display_info(UINT32* disp_width, UINT32* disp_height, UINT32* scale)
+{
+	CGDirectDisplayID display_id;
+
+	display_id = CGMainDisplayID();
+
+	CGDisplayModeRef mode = CGDisplayCopyDisplayMode(display_id);
+
+	size_t pixelWidth = CGDisplayModeGetPixelWidth(mode);
+	// size_t pixelHeight = CGDisplayModeGetPixelHeight(mode);
+
+	size_t wide = CGDisplayPixelsWide(display_id);
+	size_t high = CGDisplayPixelsHigh(display_id);
+
+	CGDisplayModeRelease(mode);
+
+	*disp_width = wide;  // pixelWidth;
+	*disp_height = high; // pixelHeight;
+	*scale = pixelWidth / wide;
+
+	return 0;
+}
+
+int mf_mlion_screen_updates_init()
+{
+	CGDirectDisplayID display_id;
+
+	display_id = CGMainDisplayID();
+
+	screen_update_q = dispatch_queue_create("mfreerdp.server.screenUpdate", NULL);
+
+	region_sem = dispatch_semaphore_create(1);
+	data_sem = dispatch_semaphore_create(1);
+
+	UINT32 pixelWidth;
+	UINT32 pixelHeight;
+	UINT32 scale;
+
+	mf_mlion_display_info(&pixelWidth, &pixelHeight, &scale);
+
+	localBuf = malloc(pixelWidth * pixelHeight * 4);
+	if (!localBuf)
+		return -1;
+
+	CFDictionaryRef opts;
+
+	void* keys[2];
+	void* values[2];
+
+	keys[0] = (void*)kCGDisplayStreamShowCursor;
+	values[0] = (void*)kCFBooleanFalse;
+
+	opts = CFDictionaryCreate(kCFAllocatorDefault, (const void**)keys, (const void**)values, 1,
+	                          NULL, NULL);
+
+	stream = CGDisplayStreamCreateWithDispatchQueue(display_id, pixelWidth, pixelHeight, 'BGRA',
+	                                                opts, screen_update_q, streamHandler);
+
+	CFRelease(opts);
+
+	return 0;
+}
+
+int mf_mlion_start_getting_screen_updates()
+{
+	CGError err;
+
+	err = CGDisplayStreamStart(stream);
+
+	if (err != kCGErrorSuccess)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+int mf_mlion_stop_getting_screen_updates()
+{
+	CGError err;
+
+	err = CGDisplayStreamStop(stream);
+
+	if (err != kCGErrorSuccess)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+int mf_mlion_get_dirty_region(RFX_RECT* invalid)
+{
+	dispatch_semaphore_wait(region_sem, DISPATCH_TIME_FOREVER);
+
+	if (lastUpdate != NULL)
+	{
+		mf_mlion_peek_dirty_region(invalid);
+	}
+
+	dispatch_semaphore_signal(region_sem);
+
+	return 0;
+}
+
+int mf_mlion_peek_dirty_region(RFX_RECT* invalid)
+{
+	size_t num_rects;
+	CGRect dirtyRegion;
+
+	const CGRect* rects =
+	    CGDisplayStreamUpdateGetRects(lastUpdate, kCGDisplayStreamUpdateDirtyRects, &num_rects);
+
+	if (num_rects == 0)
+	{
+		return 0;
+	}
+
+	dirtyRegion = *rects;
+	for (size_t i = 0; i < num_rects; i++)
+	{
+		dirtyRegion = CGRectUnion(dirtyRegion, *(rects + i));
+	}
+
+	invalid->x = dirtyRegion.origin.x;
+	invalid->y = dirtyRegion.origin.y;
+	invalid->height = dirtyRegion.size.height;
+	invalid->width = dirtyRegion.size.width;
+
+	return 0;
+}
+
+int mf_mlion_clear_dirty_region()
+{
+	dispatch_semaphore_wait(region_sem, DISPATCH_TIME_FOREVER);
+
+	CFRelease(lastUpdate);
+	lastUpdate = NULL;
+
+	dispatch_semaphore_signal(region_sem);
+
+	return 0;
+}
+
+int mf_mlion_get_pixelData(long x, long y, long width, long height, BYTE** pxData)
+{
+	dispatch_semaphore_wait(region_sem, DISPATCH_TIME_FOREVER);
+	ready = TRUE;
+	dispatch_semaphore_wait(data_sem, DISPATCH_TIME_FOREVER);
+	dispatch_semaphore_signal(region_sem);
+
+	// this second wait allows us to block until data is copied... more on this later
+	dispatch_semaphore_wait(data_sem, DISPATCH_TIME_FOREVER);
+	*pxData = localBuf;
+	dispatch_semaphore_signal(data_sem);
+
+	return 0;
+}

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_mountain_lion.h

@@ -0,0 +1,38 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * OS X Server Event Handling
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_MAC_MLION_H
+#define FREERDP_SERVER_MAC_MLION_H
+
+#include <freerdp/codec/rfx.h>
+
+int mf_mlion_display_info(UINT32* disp_width, UINT32* dispHeight, UINT32* scale);
+
+int mf_mlion_screen_updates_init(void);
+
+int mf_mlion_start_getting_screen_updates(void);
+int mf_mlion_stop_getting_screen_updates(void);
+
+int mf_mlion_get_dirty_region(RFX_RECT* invalid);
+int mf_mlion_peek_dirty_region(RFX_RECT* invalid);
+int mf_mlion_clear_dirty_region(void);
+
+int mf_mlion_get_pixelData(long x, long y, long width, long height, BYTE** pxData);
+
+#endif /* FREERDP_SERVER_MAC_MLION_H */

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_peer.c

@@ -0,0 +1,485 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Client
+ * FreeRDP Mac OS X Server
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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/config.h>
+
+#include <freerdp/listener.h>
+#include <freerdp/codec/rfx.h>
+#include <winpr/stream.h>
+#include <freerdp/peer.h>
+#include <freerdp/codec/color.h>
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+
+#include "mf_peer.h"
+#include "mf_info.h"
+#include "mf_input.h"
+#include "mf_event.h"
+#include "mf_rdpsnd.h"
+#include "mf_audin.h"
+
+#include <mach/clock.h>
+#include <mach/mach.h>
+#include <dispatch/dispatch.h>
+
+#include "OpenGL/OpenGL.h"
+#include "OpenGL/gl.h"
+
+#include "CoreVideo/CoreVideo.h"
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("mac")
+
+// refactor these
+static int info_last_sec = 0;
+static int info_last_nsec = 0;
+
+static dispatch_source_t info_timer;
+static dispatch_queue_t info_queue;
+
+static mfEventQueue* info_event_queue;
+
+static CGLContextObj glContext;
+static CGContextRef bmp;
+static CGImageRef img;
+
+static void mf_peer_context_free(freerdp_peer* client, rdpContext* context);
+
+static BOOL mf_peer_get_fds(freerdp_peer* client, void** rfds, int* rcount)
+{
+	if (info_event_queue->pipe_fd[0] == -1)
+		return TRUE;
+
+	rfds[*rcount] = (void*)(long)info_event_queue->pipe_fd[0];
+	(*rcount)++;
+	return TRUE;
+}
+
+static void mf_peer_rfx_update(freerdp_peer* client)
+{
+	// check
+	mfInfo* mfi = mf_info_get_instance();
+	mf_info_find_invalid_region(mfi);
+
+	if (mf_info_have_invalid_region(mfi) == false)
+	{
+		return;
+	}
+
+	long width;
+	long height;
+	int pitch;
+	BYTE* dataBits = NULL;
+	mf_info_getScreenData(mfi, &width, &height, &dataBits, &pitch);
+	mf_info_clear_invalid_region(mfi);
+	// encode
+	wStream* s;
+	RFX_RECT rect;
+	rdpUpdate* update;
+	mfPeerContext* mfp;
+	SURFACE_BITS_COMMAND cmd = { 0 };
+
+	WINPR_ASSERT(client);
+
+	mfp = (mfPeerContext*)client->context;
+	WINPR_ASSERT(mfp);
+
+	update = client->context->update;
+	WINPR_ASSERT(update);
+
+	s = mfp->s;
+	WINPR_ASSERT(s);
+
+	Stream_Clear(s);
+	Stream_SetPosition(s, 0);
+	UINT32 x = mfi->invalid.x / mfi->scale;
+	UINT32 y = mfi->invalid.y / mfi->scale;
+	rect.x = 0;
+	rect.y = 0;
+	rect.width = width;
+	rect.height = height;
+
+	rfx_context_reset(mfp->rfx_context, mfi->servscreen_width, mfi->servscreen_height);
+
+	if (!(rfx_compose_message(mfp->rfx_context, s, &rect, 1, (BYTE*)dataBits, rect.width,
+	                          rect.height, pitch)))
+	{
+		return;
+	}
+
+	cmd.destLeft = x;
+	cmd.destTop = y;
+	cmd.destRight = x + rect.width;
+	cmd.destBottom = y + rect.height;
+	cmd.bmp.bpp = 32;
+	cmd.bmp.codecID = 3;
+	cmd.bmp.width = rect.width;
+	cmd.bmp.height = rect.height;
+	cmd.bmp.bitmapDataLength = Stream_GetPosition(s);
+	cmd.bmp.bitmapData = Stream_Buffer(s);
+	// send
+	update->SurfaceBits(update->context, &cmd);
+	// clean up... maybe?
+}
+
+static BOOL mf_peer_check_fds(freerdp_peer* client)
+{
+	mfPeerContext* context = (mfPeerContext*)client->context;
+	mfEvent* event;
+
+	if (context->activated == FALSE)
+		return TRUE;
+
+	event = mf_event_peek(info_event_queue);
+
+	if (event != NULL)
+	{
+		if (event->type == FREERDP_SERVER_MAC_EVENT_TYPE_REGION)
+		{
+		}
+		else if (event->type == FREERDP_SERVER_MAC_EVENT_TYPE_FRAME_TICK)
+		{
+			event = mf_event_pop(info_event_queue);
+			mf_peer_rfx_update(client);
+			mf_event_free(event);
+		}
+	}
+
+	return TRUE;
+}
+
+/* Called when we have a new peer connecting */
+static BOOL mf_peer_context_new(freerdp_peer* client, rdpContext* context)
+{
+	rdpSettings* settings;
+	mfPeerContext* peer = (mfPeerContext*)context;
+
+	WINPR_ASSERT(client);
+	WINPR_ASSERT(context);
+
+	settings = context->settings;
+	WINPR_ASSERT(settings);
+
+	if (!(peer->info = mf_info_get_instance()))
+		return FALSE;
+
+	if (!(peer->rfx_context = rfx_context_new_ex(
+	          TRUE, freerdp_settings_get_uint32(settings, FreeRDP_ThreadingFlags))))
+		goto fail;
+
+	rfx_context_reset(peer->rfx_context,
+	                  freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
+	                  freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
+	rfx_context_set_mode(peer->rfx_context, RLGR3);
+	rfx_context_set_pixel_format(peer->rfx_context, PIXEL_FORMAT_BGRA32);
+
+	if (!(peer->s = Stream_New(NULL, 0xFFFF)))
+		goto fail;
+
+	peer->vcm = WTSOpenServerA((LPSTR)client->context);
+
+	if (!peer->vcm || (peer->vcm == INVALID_HANDLE_VALUE))
+		goto fail;
+
+	mf_info_peer_register(peer->info, peer);
+	return TRUE;
+fail:
+	mf_peer_context_free(client, context);
+	return FALSE;
+}
+
+/* Called after a peer disconnects */
+static void mf_peer_context_free(freerdp_peer* client, rdpContext* context)
+{
+	mfPeerContext* peer = (mfPeerContext*)context;
+	if (context)
+	{
+		mf_info_peer_unregister(peer->info, peer);
+		dispatch_suspend(info_timer);
+		Stream_Free(peer->s, TRUE);
+		rfx_context_free(peer->rfx_context);
+		// nsc_context_free(peer->nsc_context);
+#ifdef CHANNEL_AUDIN_SERVER
+
+		mf_peer_audin_uninit(peer);
+
+#endif
+#ifdef CHANNEL_RDPSND_SERVER
+		mf_peer_rdpsnd_stop();
+
+		if (peer->rdpsnd)
+			rdpsnd_server_context_free(peer->rdpsnd);
+
+#endif
+		WTSCloseServer(peer->vcm);
+	}
+}
+
+/* Called when a new client connects */
+static BOOL mf_peer_init(freerdp_peer* client)
+{
+	client->ContextSize = sizeof(mfPeerContext);
+	client->ContextNew = mf_peer_context_new;
+	client->ContextFree = mf_peer_context_free;
+
+	if (!freerdp_peer_context_new(client))
+		return FALSE;
+
+	info_event_queue = mf_event_queue_new();
+	info_queue = dispatch_queue_create("FreeRDP.update.timer", DISPATCH_QUEUE_SERIAL);
+	info_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, info_queue);
+
+	if (info_timer)
+	{
+		// DEBUG_WARN( "created timer\n");
+		dispatch_source_set_timer(info_timer, DISPATCH_TIME_NOW, 42ull * NSEC_PER_MSEC,
+		                          100ull * NSEC_PER_MSEC);
+		dispatch_source_set_event_handler(info_timer, ^{
+		  // DEBUG_WARN( "dispatch\n");
+		  mfEvent* event = mf_event_new(FREERDP_SERVER_MAC_EVENT_TYPE_FRAME_TICK);
+		  mf_event_push(info_event_queue, (mfEvent*)event);
+		});
+		dispatch_resume(info_timer);
+	}
+
+	return TRUE;
+}
+
+static BOOL mf_peer_post_connect(freerdp_peer* client)
+{
+	mfInfo* mfi = mf_info_get_instance();
+
+	WINPR_ASSERT(client);
+
+	mfPeerContext* context = (mfPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	rdpSettings* settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	mfi->scale = 1;
+	// mfi->servscreen_width = 2880 / mfi->scale;
+	// mfi->servscreen_height = 1800 / mfi->scale;
+	UINT32 bitsPerPixel = 32;
+
+	if ((freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) != mfi->servscreen_width) ||
+	    (freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) != mfi->servscreen_height))
+	{
+	}
+
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, mfi->servscreen_width))
+		return FALSE;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, mfi->servscreen_height))
+		return FALSE;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, bitsPerPixel))
+		return FALSE;
+
+	WINPR_ASSERT(client->context->update);
+	WINPR_ASSERT(client->context->update->DesktopResize);
+	client->context->update->DesktopResize(client->context);
+
+	mfi->mouse_down_left = FALSE;
+	mfi->mouse_down_right = FALSE;
+	mfi->mouse_down_other = FALSE;
+#ifdef CHANNEL_RDPSND_SERVER
+
+	if (WTSVirtualChannelManagerIsChannelJoined(context->vcm, "rdpsnd"))
+	{
+		mf_peer_rdpsnd_init(context); /* Audio Output */
+	}
+
+#endif
+	/* Dynamic Virtual Channels */
+#ifdef CHANNEL_AUDIN_SERVER
+	mf_peer_audin_init(context); /* Audio Input */
+#endif
+	return TRUE;
+}
+
+static BOOL mf_peer_activate(freerdp_peer* client)
+{
+	WINPR_ASSERT(client);
+
+	mfPeerContext* context = (mfPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	rdpSettings* settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	rfx_context_reset(context->rfx_context,
+	                  freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
+	                  freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
+	context->activated = TRUE;
+	return TRUE;
+}
+
+static BOOL mf_peer_synchronize_event(rdpInput* input, UINT32 flags)
+{
+	return TRUE;
+}
+
+static BOOL mf_peer_keyboard_event(rdpInput* input, UINT16 flags, UINT8 code)
+{
+	bool state_down = FALSE;
+
+	if (flags == KBD_FLAGS_DOWN)
+	{
+		state_down = TRUE;
+	}
+	return TRUE;
+}
+
+static BOOL mf_peer_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+{
+	return FALSE;
+}
+
+static BOOL mf_peer_suppress_output(rdpContext* context, BYTE allow, const RECTANGLE_16* area)
+{
+	return FALSE;
+}
+
+static void* mf_peer_main_loop(void* arg)
+{
+	mfPeerContext* context;
+	rdpSettings* settings;
+	rdpInput* input;
+	rdpUpdate* update;
+	freerdp_peer* client = (freerdp_peer*)arg;
+
+	if (!mf_peer_init(client))
+		goto fail;
+
+	const mf_server_info* info = client->ContextExtra;
+	WINPR_ASSERT(info);
+
+	WINPR_ASSERT(client->context);
+
+	settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	/* Initialize the real server settings here */
+	rdpPrivateKey* key = freerdp_key_new_from_file(info->key);
+	if (!key)
+		goto fail;
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerRsaKey, key, 1))
+		goto fail;
+	rdpCertificate* cert = freerdp_certificate_new_from_file(info->cert);
+	if (!cert)
+		goto fail;
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerCertificate, cert, 1))
+		goto fail;
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, FALSE))
+		goto fail;
+	if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteFxCodec, TRUE))
+		goto fail;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32))
+		goto fail;
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_SuppressOutput, TRUE))
+		goto fail;
+	if (!freerdp_settings_set_bool(settings, FreeRDP_RefreshRect, FALSE))
+		goto fail;
+
+	client->PostConnect = mf_peer_post_connect;
+	client->Activate = mf_peer_activate;
+
+	input = client->context->input;
+	WINPR_ASSERT(input);
+
+	input->SynchronizeEvent = mf_peer_synchronize_event;
+	input->KeyboardEvent = mf_input_keyboard_event; // mf_peer_keyboard_event;
+	input->UnicodeKeyboardEvent = mf_peer_unicode_keyboard_event;
+	input->MouseEvent = mf_input_mouse_event;
+	input->ExtendedMouseEvent = mf_input_extended_mouse_event;
+
+	update = client->context->update;
+	WINPR_ASSERT(update);
+
+	// update->RefreshRect = mf_peer_refresh_rect;
+	update->SuppressOutput = mf_peer_suppress_output;
+
+	WINPR_ASSERT(client->Initialize);
+	const BOOL rc = client->Initialize(client);
+	if (!rc)
+		goto fail;
+	context = (mfPeerContext*)client->context;
+
+	while (1)
+	{
+		DWORD status;
+		HANDLE handles[MAXIMUM_WAIT_OBJECTS] = { 0 };
+		DWORD count = client->GetEventHandles(client, handles, ARRAYSIZE(handles));
+
+		if ((count == 0) || (count == MAXIMUM_WAIT_OBJECTS))
+		{
+			WLog_ERR(TAG, "Failed to get FreeRDP file descriptor");
+			break;
+		}
+
+		handles[count++] = WTSVirtualChannelManagerGetEventHandle(context->vcm);
+
+		status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
+		if (status == WAIT_FAILED)
+		{
+			WLog_ERR(TAG, "WaitForMultipleObjects failed");
+			break;
+		}
+
+		if (client->CheckFileDescriptor(client) != TRUE)
+		{
+			break;
+		}
+
+		if ((mf_peer_check_fds(client)) != TRUE)
+		{
+			break;
+		}
+
+		if (WTSVirtualChannelManagerCheckFileDescriptor(context->vcm) != TRUE)
+		{
+			break;
+		}
+	}
+
+	client->Disconnect(client);
+	freerdp_peer_context_free(client);
+fail:
+	freerdp_peer_free(client);
+	return NULL;
+}
+
+BOOL mf_peer_accepted(freerdp_listener* instance, freerdp_peer* client)
+{
+	pthread_t th;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(client);
+
+	client->ContextExtra = instance->info;
+	if (pthread_create(&th, 0, mf_peer_main_loop, client) == 0)
+	{
+		pthread_detach(th);
+		return TRUE;
+	}
+
+	return FALSE;
+}

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_peer.h

@@ -0,0 +1,33 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Mac OS X Server
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_MAC_PEER_H
+#define FREERDP_SERVER_MAC_PEER_H
+
+#include "mf_interface.h"
+
+typedef struct
+{
+	const char* cert;
+	const char* key;
+} mf_server_info;
+
+BOOL mf_peer_accepted(freerdp_listener* instance, freerdp_peer* client);
+
+#endif /* FREERDP_SERVER_MAC_PEER_H */

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_rdpsnd.c

@@ -0,0 +1,200 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Mac OS X Server (Audio Output)
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[email protected]>
+ *
+ * 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/config.h>
+
+#include <freerdp/server/rdpsnd.h>
+
+#include "mf_info.h"
+#include "mf_rdpsnd.h"
+#include "mf_interface.h"
+
+#include <winpr/sysinfo.h>
+#include <freerdp/server/server-common.h>
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("mac")
+
+AQRecorderState recorderState;
+
+static void mf_peer_rdpsnd_activated(RdpsndServerContext* context)
+{
+	OSStatus status;
+	BOOL formatAgreed = FALSE;
+	AUDIO_FORMAT* agreedFormat = NULL;
+	// we should actually loop through the list of client formats here
+	// and see if we can send the client something that it supports...
+	WLog_DBG(TAG, "Client supports the following %d formats: ", context->num_client_formats);
+
+	int i = 0;
+	for (; i < context->num_client_formats; i++)
+	{
+		/* TODO: improve the way we agree on a format */
+		for (int j = 0; j < context->num_server_formats; j++)
+		{
+			if ((context->client_formats[i].wFormatTag == context->server_formats[j].wFormatTag) &&
+			    (context->client_formats[i].nChannels == context->server_formats[j].nChannels) &&
+			    (context->client_formats[i].nSamplesPerSec ==
+			     context->server_formats[j].nSamplesPerSec))
+			{
+				WLog_DBG(TAG, "agreed on format!");
+				formatAgreed = TRUE;
+				agreedFormat = (AUDIO_FORMAT*)&context->server_formats[j];
+				break;
+			}
+		}
+
+		if (formatAgreed == TRUE)
+			break;
+	}
+
+	if (formatAgreed == FALSE)
+	{
+		WLog_DBG(TAG, "Could not agree on a audio format with the server");
+		return;
+	}
+
+	context->SelectFormat(context, i);
+	context->SetVolume(context, 0x7FFF, 0x7FFF);
+
+	switch (agreedFormat->wFormatTag)
+	{
+		case WAVE_FORMAT_ALAW:
+			recorderState.dataFormat.mFormatID = kAudioFormatDVIIntelIMA;
+			break;
+
+		case WAVE_FORMAT_PCM:
+			recorderState.dataFormat.mFormatID = kAudioFormatLinearPCM;
+			break;
+
+		default:
+			recorderState.dataFormat.mFormatID = kAudioFormatLinearPCM;
+			break;
+	}
+
+	recorderState.dataFormat.mSampleRate = agreedFormat->nSamplesPerSec;
+	recorderState.dataFormat.mFormatFlags =
+	    kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
+	recorderState.dataFormat.mBytesPerPacket = 4;
+	recorderState.dataFormat.mFramesPerPacket = 1;
+	recorderState.dataFormat.mBytesPerFrame = 4;
+	recorderState.dataFormat.mChannelsPerFrame = agreedFormat->nChannels;
+	recorderState.dataFormat.mBitsPerChannel = agreedFormat->wBitsPerSample;
+	recorderState.snd_context = context;
+	status =
+	    AudioQueueNewInput(&recorderState.dataFormat, mf_peer_rdpsnd_input_callback, &recorderState,
+	                       NULL, kCFRunLoopCommonModes, 0, &recorderState.queue);
+
+	if (status != noErr)
+	{
+		WLog_DBG(TAG, "Failed to create a new Audio Queue. Status code: %" PRId32 "", status);
+	}
+
+	UInt32 dataFormatSize = sizeof(recorderState.dataFormat);
+	AudioQueueGetProperty(recorderState.queue, kAudioConverterCurrentInputStreamDescription,
+	                      &recorderState.dataFormat, &dataFormatSize);
+	mf_rdpsnd_derive_buffer_size(recorderState.queue, &recorderState.dataFormat, 0.05,
+	                             &recorderState.bufferByteSize);
+
+	for (size_t x = 0; x < SND_NUMBUFFERS; ++x)
+	{
+		AudioQueueAllocateBuffer(recorderState.queue, recorderState.bufferByteSize,
+		                         &recorderState.buffers[x]);
+		AudioQueueEnqueueBuffer(recorderState.queue, recorderState.buffers[x], 0, NULL);
+	}
+
+	recorderState.currentPacket = 0;
+	recorderState.isRunning = true;
+	AudioQueueStart(recorderState.queue, NULL);
+}
+
+BOOL mf_peer_rdpsnd_init(mfPeerContext* context)
+{
+	context->rdpsnd = rdpsnd_server_context_new(context->vcm);
+	context->rdpsnd->rdpcontext = &context->_p;
+	context->rdpsnd->data = context;
+	context->rdpsnd->num_server_formats =
+	    server_rdpsnd_get_formats(&context->rdpsnd->server_formats);
+
+	if (context->rdpsnd->num_server_formats > 0)
+		context->rdpsnd->src_format = &context->rdpsnd->server_formats[0];
+
+	context->rdpsnd->Activated = mf_peer_rdpsnd_activated;
+	context->rdpsnd->Initialize(context->rdpsnd, TRUE);
+	return TRUE;
+}
+
+BOOL mf_peer_rdpsnd_stop(void)
+{
+	recorderState.isRunning = false;
+	AudioQueueStop(recorderState.queue, true);
+	return TRUE;
+}
+
+void mf_peer_rdpsnd_input_callback(void* inUserData, AudioQueueRef inAQ,
+                                   AudioQueueBufferRef inBuffer, const AudioTimeStamp* inStartTime,
+                                   UInt32 inNumberPacketDescriptions,
+                                   const AudioStreamPacketDescription* inPacketDescs)
+{
+	OSStatus status;
+	AQRecorderState* rState;
+	rState = inUserData;
+
+	if (inNumberPacketDescriptions == 0 && rState->dataFormat.mBytesPerPacket != 0)
+	{
+		inNumberPacketDescriptions =
+		    inBuffer->mAudioDataByteSize / rState->dataFormat.mBytesPerPacket;
+	}
+
+	if (rState->isRunning == 0)
+	{
+		return;
+	}
+
+	rState->snd_context->SendSamples(rState->snd_context, inBuffer->mAudioData,
+	                                 inBuffer->mAudioDataByteSize / 4,
+	                                 (UINT16)(GetTickCount() & 0xffff));
+	status = AudioQueueEnqueueBuffer(rState->queue, inBuffer, 0, NULL);
+
+	if (status != noErr)
+	{
+		WLog_DBG(TAG, "AudioQueueEnqueueBuffer() returned status = %" PRId32 "", status);
+	}
+}
+
+void mf_rdpsnd_derive_buffer_size(AudioQueueRef audioQueue,
+                                  AudioStreamBasicDescription* ASBDescription, Float64 seconds,
+                                  UInt32* outBufferSize)
+{
+	static const int maxBufferSize = 0x50000;
+	int maxPacketSize = ASBDescription->mBytesPerPacket;
+
+	if (maxPacketSize == 0)
+	{
+		UInt32 maxVBRPacketSize = sizeof(maxPacketSize);
+		AudioQueueGetProperty(audioQueue, kAudioQueueProperty_MaximumOutputPacketSize,
+		                      // in Mac OS X v10.5, instead use
+		                      //   kAudioConverterPropertyMaximumOutputPacketSize
+		                      &maxPacketSize, &maxVBRPacketSize);
+	}
+
+	Float64 numBytesForTime = ASBDescription->mSampleRate * maxPacketSize * seconds;
+	*outBufferSize = (UInt32)(numBytesForTime < maxBufferSize ? numBytesForTime : maxBufferSize);
+}

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_rdpsnd.h

@@ -0,0 +1,58 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Mac OS X Server (Audio Output)
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_MAC_RDPSND_H
+#define FREERDP_SERVER_MAC_RDPSND_H
+
+#include <CoreAudio/CoreAudio.h>
+#include <AudioToolbox/AudioToolbox.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/listener.h>
+#include <freerdp/server/rdpsnd.h>
+
+#include "mf_types.h"
+#include "mfreerdp.h"
+
+void mf_rdpsnd_derive_buffer_size(AudioQueueRef audioQueue,
+                                  AudioStreamBasicDescription* ASBDescription, Float64 seconds,
+                                  UInt32* outBufferSize);
+
+void mf_peer_rdpsnd_input_callback(void* inUserData, AudioQueueRef inAQ,
+                                   AudioQueueBufferRef inBuffer, const AudioTimeStamp* inStartTime,
+                                   UInt32 inNumberPacketDescriptions,
+                                   const AudioStreamPacketDescription* inPacketDescs);
+
+#define SND_NUMBUFFERS 3
+typedef struct
+{
+	AudioStreamBasicDescription dataFormat;
+	AudioQueueRef queue;
+	AudioQueueBufferRef buffers[SND_NUMBUFFERS];
+	AudioFileID audioFile;
+	UInt32 bufferByteSize;
+	SInt64 currentPacket;
+	bool isRunning;
+	RdpsndServerContext* snd_context;
+} AQRecorderState;
+
+BOOL mf_peer_rdpsnd_init(mfPeerContext* context);
+BOOL mf_peer_rdpsnd_stop(void);
+
+#endif /* FREERDP_SERVER_MAC_RDPSND_H */

local-test-freerdp-full-01/afc-freerdp/server/Mac/mf_types.h

@@ -0,0 +1,33 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Client
+ * FreeRDP Mac OS X Server
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ * Copyright 2023 Thincast Technologies GmbH
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_MAC_TYPES_H
+#define FREERDP_SERVER_MAC_TYPES_H
+
+#include <pthread.h>
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+
+typedef struct mf_info mfInfo;
+typedef struct mf_peer_context mfPeerContext;
+
+#endif /* FREERDP_SERVER_MAC_TYPES_H */

local-test-freerdp-full-01/afc-freerdp/server/Mac/mfreerdp.c

@@ -0,0 +1,108 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Mac OS X Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <pthread.h>
+#include <signal.h>
+#include <sys/time.h>
+
+#include <CoreGraphics/CGEvent.h>
+
+#include <winpr/crt.h>
+#include <winpr/wtsapi.h>
+#include <winpr/assert.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/constants.h>
+#include <freerdp/channels/wtsvc.h>
+#include <freerdp/channels/channels.h>
+#include <freerdp/server/server-common.h>
+
+#include "mfreerdp.h"
+#include "mf_peer.h"
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("mac")
+
+static void mf_server_main_loop(freerdp_listener* instance)
+{
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->GetEventHandles);
+	WINPR_ASSERT(instance->CheckFileDescriptor);
+
+	while (1)
+	{
+		DWORD status;
+		HANDLE handles[MAXIMUM_WAIT_OBJECTS] = { 0 };
+		DWORD count = instance->GetEventHandles(instance, handles, ARRAYSIZE(handles));
+
+		if (count == 0)
+		{
+			WLog_ERR(TAG, "Failed to get FreeRDP file descriptor");
+			break;
+		}
+
+		status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
+		if (status == WAIT_FAILED)
+		{
+			WLog_ERR(TAG, "WaitForMultipleObjects failed");
+			break;
+		}
+
+		if (instance->CheckFileDescriptor(instance) != TRUE)
+		{
+			break;
+		}
+	}
+
+	instance->Close(instance);
+}
+
+int main(int argc, char* argv[])
+{
+	freerdp_server_warn_unmaintained(argc, argv);
+	mf_server_info info = { .key = "server.key", .cert = "server.crt" };
+
+	freerdp_listener* instance;
+
+	signal(SIGPIPE, SIG_IGN);
+
+	WTSRegisterWtsApiFunctionTable(FreeRDP_InitWtsApi());
+
+	if (!(instance = freerdp_listener_new()))
+		return 1;
+
+	instance->info = &info;
+	instance->PeerAccepted = mf_peer_accepted;
+
+	if (instance->Open(instance, NULL, 3389))
+	{
+		mf_server_main_loop(instance);
+	}
+
+	freerdp_listener_free(instance);
+
+	return 0;
+}

local-test-freerdp-full-01/afc-freerdp/server/Mac/mfreerdp.h

@@ -0,0 +1,28 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Mac OS X Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_MAC_FREERDP_H
+#define FREERDP_SERVER_MAC_FREERDP_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/listener.h>
+#include <freerdp/codec/rfx.h>
+
+#endif /* FREERDP_SERVER_MAC_FREERDP_H */

local-test-freerdp-full-01/afc-freerdp/server/Sample/CMakeLists.txt

@@ -0,0 +1,63 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP Sample Server cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <[email protected]>
+#
+# 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.
+
+set(MODULE_NAME "sfreerdp-server")
+set(MODULE_PREFIX "FREERDP_SERVER_SAMPLE")
+
+set(SRCS
+    sfreerdp.c
+    sfreerdp.h
+    sf_audin.c
+    sf_audin.h
+    sf_rdpsnd.c
+    sf_rdpsnd.h
+    sf_encomsp.c
+    sf_encomsp.h
+)
+
+if(CHANNEL_AINPUT_SERVER)
+  list(APPEND SRCS sf_ainput.c sf_ainput.h)
+endif()
+
+option(SAMPLE_USE_VENDOR_PRODUCT_CONFIG_DIR "Use <vendor>/<product> path for resources" OFF)
+set(SAMPLE_RESOURCE_ROOT ${CMAKE_INSTALL_FULL_DATAROOTDIR})
+if(SAMPLE_USE_VENDOR_PRODUCT_CONFIG_DIR)
+  string(APPEND SAMPLE_RESOURCE_ROOT "/${VENDOR}")
+endif()
+string(APPEND SAMPLE_RESOURCE_ROOT "/${PRODUCT}")
+
+if(WITH_RESOURCE_VERSIONING)
+  string(APPEND SAMPLE_RESOURCE_ROOT "${FREERDP_VERSION_MAJOR}")
+endif()
+string(APPEND SAMPLE_RESOURCE_ROOT "/images")
+
+set(SAMPLE_ICONS test_icon.bmp test_icon.png test_icon.jpg test_icon.webp)
+install(FILES ${SAMPLE_ICONS} DESTINATION ${SAMPLE_RESOURCE_ROOT})
+
+# We need this in runtime path for TestConnect
+file(COPY test_icon.bmp DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
+addtargetwithresourcefile(${MODULE_NAME} TRUE "${FREERDP_VERSION}" SRCS)
+
+target_compile_definitions(${MODULE_NAME} PRIVATE SAMPLE_RESOURCE_ROOT="${SAMPLE_RESOURCE_ROOT}")
+list(APPEND LIBS freerdp-server)
+list(APPEND LIBS winpr freerdp)
+
+target_link_libraries(${MODULE_NAME} ${LIBS})
+install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT server)
+
+set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "Server/Sample")

local-test-freerdp-full-01/afc-freerdp/server/Sample/ModuleOptions.cmake

@@ -0,0 +1,3 @@
+set(FREERDP_SERVER_NAME "sfreerdp-server")
+set(FREERDP_SERVER_PLATFORM "Sample")
+set(FREERDP_SERVER_VENDOR "FreeRDP")

local-test-freerdp-full-01/afc-freerdp/server/Sample/sf_ainput.c

@@ -0,0 +1,92 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Sample Server (Advanced Input)
+ *
+ * Copyright 2022 Armin Novak <[email protected]>
+ * Copyright 2022 Thincast Technologies GmbH
+ *
+ * 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/config.h>
+
+#include <winpr/assert.h>
+
+#include "sfreerdp.h"
+
+#include "sf_ainput.h"
+
+#include <freerdp/server/server-common.h>
+#include <freerdp/server/ainput.h>
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("sample.ainput")
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT sf_peer_ainput_mouse_event(ainput_server_context* context, UINT64 timestamp,
+                                       UINT64 flags, INT32 x, INT32 y)
+{
+	/* TODO: Implement */
+	WINPR_ASSERT(context);
+
+	WLog_WARN(TAG, "not implemented: 0x%08" PRIx64 ", 0x%08" PRIx64 ", %" PRId32 "x%" PRId32,
+	          timestamp, flags, x, y);
+	return CHANNEL_RC_OK;
+}
+
+void sf_peer_ainput_init(testPeerContext* context)
+{
+	WINPR_ASSERT(context);
+
+	context->ainput = ainput_server_context_new(context->vcm);
+	WINPR_ASSERT(context->ainput);
+
+	context->ainput->rdpcontext = &context->_p;
+	context->ainput->data = context;
+
+	context->ainput->MouseEvent = sf_peer_ainput_mouse_event;
+}
+
+BOOL sf_peer_ainput_start(testPeerContext* context)
+{
+	if (!context || !context->ainput || !context->ainput->Open)
+		return FALSE;
+
+	return context->ainput->Open(context->ainput) == CHANNEL_RC_OK;
+}
+
+BOOL sf_peer_ainput_stop(testPeerContext* context)
+{
+	if (!context || !context->ainput || !context->ainput->Close)
+		return FALSE;
+
+	return context->ainput->Close(context->ainput) == CHANNEL_RC_OK;
+}
+
+BOOL sf_peer_ainput_running(testPeerContext* context)
+{
+	if (!context || !context->ainput || !context->ainput->IsOpen)
+		return FALSE;
+
+	return context->ainput->IsOpen(context->ainput);
+}
+
+void sf_peer_ainput_uninit(testPeerContext* context)
+{
+	ainput_server_context_free(context->ainput);
+}

local-test-freerdp-full-01/afc-freerdp/server/Sample/sf_ainput.h

@@ -0,0 +1,37 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Sample Server (Advanced Input)
+ *
+ * Copyright 2022 Armin Novak <[email protected]>
+ * Copyright 2022 Thincast Technologies GmbH
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_SAMPLE_SF_AINPUT_H
+#define FREERDP_SERVER_SAMPLE_SF_AINPUT_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/listener.h>
+#include <freerdp/server/ainput.h>
+
+#include "sfreerdp.h"
+
+void sf_peer_ainput_init(testPeerContext* context);
+void sf_peer_ainput_uninit(testPeerContext* context);
+
+BOOL sf_peer_ainput_running(testPeerContext* context);
+BOOL sf_peer_ainput_start(testPeerContext* context);
+BOOL sf_peer_ainput_stop(testPeerContext* context);
+
+#endif /* FREERDP_SERVER_SAMPLE_SF_AINPUT_H */

local-test-freerdp-full-01/afc-freerdp/server/Sample/sf_audin.c

@@ -0,0 +1,112 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Sample Server (Audio Input)
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[email protected]>
+ * Copyright 2023 Pascal Nowack <[email protected]>
+ *
+ * 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/config.h>
+
+#include <winpr/assert.h>
+
+#include "sfreerdp.h"
+
+#include "sf_audin.h"
+
+#include <freerdp/server/server-common.h>
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("sample")
+
+#if defined(CHANNEL_AUDIN_SERVER)
+
+static UINT sf_peer_audin_data(audin_server_context* audin, const SNDIN_DATA* data)
+{
+	/* TODO: Implement */
+	WINPR_ASSERT(audin);
+	WINPR_ASSERT(data);
+
+	WLog_WARN(TAG, "not implemented");
+	WLog_DBG(TAG, "receive %" PRIdz " bytes.", Stream_Length(data->Data));
+	return CHANNEL_RC_OK;
+}
+
+#endif
+
+BOOL sf_peer_audin_init(testPeerContext* context)
+{
+	WINPR_ASSERT(context);
+#if defined(CHANNEL_AUDIN_SERVER)
+	context->audin = audin_server_context_new(context->vcm);
+	WINPR_ASSERT(context->audin);
+
+	context->audin->rdpcontext = &context->_p;
+	context->audin->userdata = context;
+
+	context->audin->Data = sf_peer_audin_data;
+
+	return audin_server_set_formats(context->audin, -1, NULL);
+#else
+	return TRUE;
+#endif
+}
+
+BOOL sf_peer_audin_start(testPeerContext* context)
+{
+#if defined(CHANNEL_AUDIN_SERVER)
+	if (!context || !context->audin || !context->audin->Open)
+		return FALSE;
+
+	return context->audin->Open(context->audin);
+#else
+	return FALSE;
+#endif
+}
+
+BOOL sf_peer_audin_stop(testPeerContext* context)
+{
+#if defined(CHANNEL_AUDIN_SERVER)
+	if (!context || !context->audin || !context->audin->Close)
+		return FALSE;
+
+	return context->audin->Close(context->audin);
+#else
+	return FALSE;
+#endif
+}
+
+BOOL sf_peer_audin_running(testPeerContext* context)
+{
+#if defined(CHANNEL_AUDIN_SERVER)
+	if (!context || !context->audin || !context->audin->IsOpen)
+		return FALSE;
+
+	return context->audin->IsOpen(context->audin);
+#else
+	return FALSE;
+#endif
+}
+
+void sf_peer_audin_uninit(testPeerContext* context)
+{
+	WINPR_ASSERT(context);
+
+#if defined(CHANNEL_AUDIN_SERVER)
+	audin_server_context_free(context->audin);
+	context->audin = NULL;
+#endif
+}

local-test-freerdp-full-01/afc-freerdp/server/Sample/sf_audin.h

@@ -0,0 +1,35 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Sample Server (Audio Input)
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_SAMPLE_SF_AUDIN_H
+#define FREERDP_SERVER_SAMPLE_SF_AUDIN_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/listener.h>
+
+#include "sfreerdp.h"
+
+BOOL sf_peer_audin_init(testPeerContext* context);
+void sf_peer_audin_uninit(testPeerContext* context);
+
+BOOL sf_peer_audin_running(testPeerContext* context);
+BOOL sf_peer_audin_start(testPeerContext* context);
+BOOL sf_peer_audin_stop(testPeerContext* context);
+
+#endif /* FREERDP_SERVER_SAMPLE_SF_AUDIN_H */

local-test-freerdp-full-01/afc-freerdp/server/Sample/sf_encomsp.c

@@ -0,0 +1,43 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Sample Server (Lync Multiparty)
+ *
+ * Copyright 2014 Marc-Andre Moreau <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[email protected]>
+ *
+ * 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/config.h>
+
+#include <winpr/assert.h>
+
+#include "sf_encomsp.h"
+
+BOOL sf_peer_encomsp_init(testPeerContext* context)
+{
+	WINPR_ASSERT(context);
+
+	context->encomsp = encomsp_server_context_new(context->vcm);
+	if (!context->encomsp)
+		return FALSE;
+
+	context->encomsp->rdpcontext = &context->_p;
+
+	WINPR_ASSERT(context->encomsp->Start);
+	if (context->encomsp->Start(context->encomsp) != CHANNEL_RC_OK)
+		return FALSE;
+
+	return TRUE;
+}

local-test-freerdp-full-01/afc-freerdp/server/Sample/sf_encomsp.h

@@ -0,0 +1,31 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Sample Server (Lync Multiparty)
+ *
+ * Copyright 2014 Marc-Andre Moreau <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_SAMPLE_SF_ENCOMSP_H
+#define FREERDP_SERVER_SAMPLE_SF_ENCOMSP_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/listener.h>
+#include <freerdp/server/encomsp.h>
+
+#include "sfreerdp.h"
+
+BOOL sf_peer_encomsp_init(testPeerContext* context);
+
+#endif /* FREERDP_SERVER_SAMPLE_SF_ENCOMSP_H */

local-test-freerdp-full-01/afc-freerdp/server/Sample/sf_rdpsnd.c

@@ -0,0 +1,62 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Sample Server (Audio Output)
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[email protected]>
+ *
+ * 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/config.h>
+
+#include <winpr/assert.h>
+
+#include "sf_rdpsnd.h"
+
+#include <freerdp/server/server-common.h>
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("sample")
+
+static void sf_peer_rdpsnd_activated(RdpsndServerContext* context)
+{
+	WINPR_UNUSED(context);
+	WINPR_ASSERT(context);
+	WLog_DBG(TAG, "RDPSND Activated");
+}
+
+BOOL sf_peer_rdpsnd_init(testPeerContext* context)
+{
+	WINPR_ASSERT(context);
+
+	context->rdpsnd = rdpsnd_server_context_new(context->vcm);
+	WINPR_ASSERT(context->rdpsnd);
+	context->rdpsnd->rdpcontext = &context->_p;
+	context->rdpsnd->data = context;
+	context->rdpsnd->num_server_formats =
+	    server_rdpsnd_get_formats(&context->rdpsnd->server_formats);
+
+	if (context->rdpsnd->num_server_formats > 0)
+		context->rdpsnd->src_format = &context->rdpsnd->server_formats[0];
+
+	context->rdpsnd->Activated = sf_peer_rdpsnd_activated;
+
+	WINPR_ASSERT(context->rdpsnd->Initialize);
+	if (context->rdpsnd->Initialize(context->rdpsnd, TRUE) != CHANNEL_RC_OK)
+	{
+		return FALSE;
+	}
+
+	return TRUE;
+}

local-test-freerdp-full-01/afc-freerdp/server/Sample/sf_rdpsnd.h

@@ -0,0 +1,31 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Sample Server (Audio Output)
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_SAMPLE_SF_RDPSND_H
+#define FREERDP_SERVER_SAMPLE_SF_RDPSND_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/listener.h>
+#include <freerdp/server/rdpsnd.h>
+
+#include "sfreerdp.h"
+
+BOOL sf_peer_rdpsnd_init(testPeerContext* context);
+
+#endif /* FREERDP_SERVER_SAMPLE_SF_RDPSND_H */

local-test-freerdp-full-01/afc-freerdp/server/Sample/sfreerdp.c

@@ -0,0 +1,1472 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Test Server
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2011 Vic Lee
+ * Copyright 2014 Norbert Federa <[email protected]>
+ *
+ * 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/config.h>
+
+#include <errno.h>
+#include <signal.h>
+
+#include <winpr/winpr.h>
+#include <winpr/crt.h>
+#include <winpr/cast.h>
+#include <winpr/assert.h>
+#include <winpr/ssl.h>
+#include <winpr/synch.h>
+#include <winpr/file.h>
+#include <winpr/string.h>
+#include <winpr/path.h>
+#include <winpr/image.h>
+#include <winpr/winsock.h>
+
+#include <freerdp/streamdump.h>
+#include <freerdp/transport_io.h>
+
+#include <freerdp/channels/wtsvc.h>
+#include <freerdp/channels/channels.h>
+#include <freerdp/channels/drdynvc.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/constants.h>
+#include <freerdp/server/rdpsnd.h>
+#include <freerdp/settings.h>
+
+#include "sf_ainput.h"
+#include "sf_audin.h"
+#include "sf_rdpsnd.h"
+#include "sf_encomsp.h"
+
+#include "sfreerdp.h"
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("sample")
+
+#define SAMPLE_SERVER_USE_CLIENT_RESOLUTION 1
+#define SAMPLE_SERVER_DEFAULT_WIDTH 1024
+#define SAMPLE_SERVER_DEFAULT_HEIGHT 768
+
+struct server_info
+{
+	BOOL test_dump_rfx_realtime;
+	const char* test_pcap_file;
+	const char* replay_dump;
+	const char* cert;
+	const char* key;
+};
+
+static void test_peer_context_free(freerdp_peer* client, rdpContext* ctx)
+{
+	testPeerContext* context = (testPeerContext*)ctx;
+
+	WINPR_UNUSED(client);
+
+	if (context)
+	{
+		winpr_image_free(context->image, TRUE);
+		if (context->debug_channel_thread)
+		{
+			WINPR_ASSERT(context->stopEvent);
+			(void)SetEvent(context->stopEvent);
+			(void)WaitForSingleObject(context->debug_channel_thread, INFINITE);
+			(void)CloseHandle(context->debug_channel_thread);
+		}
+
+		Stream_Free(context->s, TRUE);
+		free(context->bg_data);
+		rfx_context_free(context->rfx_context);
+		nsc_context_free(context->nsc_context);
+
+		if (context->debug_channel)
+			(void)WTSVirtualChannelClose(context->debug_channel);
+
+		sf_peer_audin_uninit(context);
+
+#if defined(CHANNEL_AINPUT_SERVER)
+		sf_peer_ainput_uninit(context);
+#endif
+
+		rdpsnd_server_context_free(context->rdpsnd);
+		encomsp_server_context_free(context->encomsp);
+
+		WTSCloseServer(context->vcm);
+	}
+}
+
+static BOOL test_peer_context_new(freerdp_peer* client, rdpContext* ctx)
+{
+	testPeerContext* context = (testPeerContext*)ctx;
+
+	WINPR_ASSERT(client);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(ctx->settings);
+
+	context->image = winpr_image_new();
+	if (!context->image)
+		goto fail;
+	if (!(context->rfx_context = rfx_context_new_ex(
+	          TRUE, freerdp_settings_get_uint32(ctx->settings, FreeRDP_ThreadingFlags))))
+		goto fail;
+
+	if (!rfx_context_reset(context->rfx_context, SAMPLE_SERVER_DEFAULT_WIDTH,
+	                       SAMPLE_SERVER_DEFAULT_HEIGHT))
+		goto fail;
+
+	const UINT32 rlgr = freerdp_settings_get_uint32(ctx->settings, FreeRDP_RemoteFxRlgrMode);
+	rfx_context_set_mode(context->rfx_context, rlgr);
+
+	if (!(context->nsc_context = nsc_context_new()))
+		goto fail;
+
+	if (!(context->s = Stream_New(NULL, 65536)))
+		goto fail;
+
+	context->icon_x = UINT32_MAX;
+	context->icon_y = UINT32_MAX;
+	context->vcm = WTSOpenServerA((LPSTR)client->context);
+
+	if (!context->vcm || context->vcm == INVALID_HANDLE_VALUE)
+		goto fail;
+
+	return TRUE;
+fail:
+	test_peer_context_free(client, ctx);
+	return FALSE;
+}
+
+static BOOL test_peer_init(freerdp_peer* client)
+{
+	WINPR_ASSERT(client);
+
+	client->ContextSize = sizeof(testPeerContext);
+	client->ContextNew = test_peer_context_new;
+	client->ContextFree = test_peer_context_free;
+	return freerdp_peer_context_new(client);
+}
+
+static wStream* test_peer_stream_init(testPeerContext* context)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(context->s);
+
+	Stream_Clear(context->s);
+	Stream_SetPosition(context->s, 0);
+	return context->s;
+}
+
+static void test_peer_begin_frame(freerdp_peer* client)
+{
+	rdpUpdate* update = NULL;
+	SURFACE_FRAME_MARKER fm = { 0 };
+	testPeerContext* context = NULL;
+
+	WINPR_ASSERT(client);
+	WINPR_ASSERT(client->context);
+
+	update = client->context->update;
+	WINPR_ASSERT(update);
+
+	context = (testPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	fm.frameAction = SURFACECMD_FRAMEACTION_BEGIN;
+	fm.frameId = context->frame_id;
+	WINPR_ASSERT(update->SurfaceFrameMarker);
+	update->SurfaceFrameMarker(update->context, &fm);
+}
+
+static void test_peer_end_frame(freerdp_peer* client)
+{
+	rdpUpdate* update = NULL;
+	SURFACE_FRAME_MARKER fm = { 0 };
+	testPeerContext* context = NULL;
+
+	WINPR_ASSERT(client);
+
+	context = (testPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	update = client->context->update;
+	WINPR_ASSERT(update);
+
+	fm.frameAction = SURFACECMD_FRAMEACTION_END;
+	fm.frameId = context->frame_id;
+	WINPR_ASSERT(update->SurfaceFrameMarker);
+	update->SurfaceFrameMarker(update->context, &fm);
+	context->frame_id++;
+}
+
+static BOOL stream_surface_bits_supported(const rdpSettings* settings)
+{
+	const UINT32 supported =
+	    freerdp_settings_get_uint32(settings, FreeRDP_SurfaceCommandsSupported);
+	return ((supported & SURFCMDS_STREAM_SURFACE_BITS) != 0);
+}
+
+static BOOL test_peer_draw_background(freerdp_peer* client)
+{
+	size_t size = 0;
+	wStream* s = NULL;
+	RFX_RECT rect;
+	BYTE* rgb_data = NULL;
+	const rdpSettings* settings = NULL;
+	rdpUpdate* update = NULL;
+	SURFACE_BITS_COMMAND cmd = { 0 };
+	testPeerContext* context = NULL;
+	BOOL ret = FALSE;
+	const UINT32 colorFormat = PIXEL_FORMAT_RGB24;
+	const size_t bpp = FreeRDPGetBytesPerPixel(colorFormat);
+
+	WINPR_ASSERT(client);
+	context = (testPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	update = client->context->update;
+	WINPR_ASSERT(update);
+
+	const BOOL RemoteFxCodec = freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec);
+	if (!RemoteFxCodec && !freerdp_settings_get_bool(settings, FreeRDP_NSCodec))
+		return FALSE;
+
+	WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) <= UINT16_MAX);
+	WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) <= UINT16_MAX);
+
+	s = test_peer_stream_init(context);
+	rect.x = 0;
+	rect.y = 0;
+	rect.width = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+	rect.height = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+	size = bpp * rect.width * rect.height;
+
+	if (!(rgb_data = malloc(size)))
+	{
+		WLog_ERR(TAG, "Problem allocating memory");
+		return FALSE;
+	}
+
+	memset(rgb_data, 0xA0, size);
+
+	if (RemoteFxCodec && stream_surface_bits_supported(settings))
+	{
+		WLog_DBG(TAG, "Using RemoteFX codec");
+		rfx_context_set_pixel_format(context->rfx_context, colorFormat);
+
+		WINPR_ASSERT(bpp <= UINT16_MAX);
+		if (!rfx_compose_message(context->rfx_context, s, &rect, 1, rgb_data, rect.width,
+		                         rect.height, (UINT32)(bpp * rect.width)))
+		{
+			goto out;
+		}
+
+		const UINT32 RemoteFxCodecId =
+		    freerdp_settings_get_uint32(settings, FreeRDP_RemoteFxCodecId);
+		WINPR_ASSERT(RemoteFxCodecId <= UINT16_MAX);
+		cmd.bmp.codecID = (UINT16)RemoteFxCodecId;
+		cmd.cmdType = CMDTYPE_STREAM_SURFACE_BITS;
+	}
+	else
+	{
+		WLog_DBG(TAG, "Using NSCodec");
+		nsc_context_set_parameters(context->nsc_context, NSC_COLOR_FORMAT, colorFormat);
+
+		WINPR_ASSERT(bpp <= UINT16_MAX);
+		nsc_compose_message(context->nsc_context, s, rgb_data, rect.width, rect.height,
+		                    (UINT32)(bpp * rect.width));
+		const UINT32 NSCodecId = freerdp_settings_get_uint32(settings, FreeRDP_NSCodecId);
+		WINPR_ASSERT(NSCodecId <= UINT16_MAX);
+		cmd.bmp.codecID = (UINT16)NSCodecId;
+		cmd.cmdType = CMDTYPE_SET_SURFACE_BITS;
+	}
+
+	cmd.destLeft = 0;
+	cmd.destTop = 0;
+	cmd.destRight = rect.width;
+	cmd.destBottom = rect.height;
+	cmd.bmp.bpp = 32;
+	cmd.bmp.flags = 0;
+	cmd.bmp.width = rect.width;
+	cmd.bmp.height = rect.height;
+	WINPR_ASSERT(Stream_GetPosition(s) <= UINT32_MAX);
+	cmd.bmp.bitmapDataLength = (UINT32)Stream_GetPosition(s);
+	cmd.bmp.bitmapData = Stream_Buffer(s);
+	test_peer_begin_frame(client);
+	update->SurfaceBits(update->context, &cmd);
+	test_peer_end_frame(client);
+	ret = TRUE;
+out:
+	free(rgb_data);
+	return ret;
+}
+
+static int open_icon(wImage* img)
+{
+	char* paths[] = { SAMPLE_RESOURCE_ROOT, "." };
+	const char* names[] = { "test_icon.webp", "test_icon.png", "test_icon.jpg", "test_icon.bmp" };
+
+	for (size_t x = 0; x < ARRAYSIZE(paths); x++)
+	{
+		const char* path = paths[x];
+		if (!winpr_PathFileExists(path))
+			continue;
+
+		for (size_t y = 0; y < ARRAYSIZE(names); y++)
+		{
+			const char* name = names[y];
+			char* file = GetCombinedPath(path, name);
+			int rc = winpr_image_read(img, file);
+			free(file);
+			if (rc > 0)
+				return rc;
+		}
+	}
+	WLog_ERR(TAG, "Unable to open test icon");
+	return -1;
+}
+
+static BOOL test_peer_load_icon(freerdp_peer* client)
+{
+	testPeerContext* context = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(client);
+
+	context = (testPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	if (!freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec) &&
+	    !freerdp_settings_get_bool(settings, FreeRDP_NSCodec))
+	{
+		WLog_ERR(TAG, "Client doesn't support RemoteFX or NSCodec");
+		return FALSE;
+	}
+
+	int rc = open_icon(context->image);
+	if (rc <= 0)
+		goto out_fail;
+
+	/* background with same size, which will be used to erase the icon from old position */
+	if (!(context->bg_data = calloc(context->image->height, 3ULL * context->image->width)))
+		goto out_fail;
+
+	memset(context->bg_data, 0xA0, 3ULL * context->image->height * context->image->width);
+	return TRUE;
+out_fail:
+	context->bg_data = NULL;
+	return FALSE;
+}
+
+static void test_peer_draw_icon(freerdp_peer* client, UINT32 x, UINT32 y)
+{
+	wStream* s = NULL;
+	RFX_RECT rect;
+	rdpUpdate* update = NULL;
+	rdpSettings* settings = NULL;
+	SURFACE_BITS_COMMAND cmd = { 0 };
+	testPeerContext* context = NULL;
+
+	WINPR_ASSERT(client);
+
+	context = (testPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	update = client->context->update;
+	WINPR_ASSERT(update);
+
+	settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_DumpRemoteFx))
+		return;
+
+	if (context->image->width < 1 || !context->activated)
+		return;
+
+	rect.x = 0;
+	rect.y = 0;
+
+	rect.width = WINPR_ASSERTING_INT_CAST(UINT16, context->image->width);
+	rect.height = WINPR_ASSERTING_INT_CAST(UINT16, context->image->height);
+
+	const UINT32 w = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+	const UINT32 h = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+	if (context->icon_x + context->image->width > w)
+		return;
+	if (context->icon_y + context->image->height > h)
+		return;
+	if (x + context->image->width > w)
+		return;
+	if (y + context->image->height > h)
+		return;
+
+	test_peer_begin_frame(client);
+
+	const BOOL RemoteFxCodec = freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec);
+	if (RemoteFxCodec && stream_surface_bits_supported(settings))
+	{
+		const UINT32 RemoteFxCodecId =
+		    freerdp_settings_get_uint32(settings, FreeRDP_RemoteFxCodecId);
+		WINPR_ASSERT(RemoteFxCodecId <= UINT16_MAX);
+		cmd.bmp.codecID = (UINT16)RemoteFxCodecId;
+		cmd.cmdType = CMDTYPE_STREAM_SURFACE_BITS;
+	}
+	else
+	{
+		const UINT32 NSCodecId = freerdp_settings_get_uint32(settings, FreeRDP_NSCodecId);
+		WINPR_ASSERT(NSCodecId <= UINT16_MAX);
+		cmd.bmp.codecID = (UINT16)NSCodecId;
+		cmd.cmdType = CMDTYPE_SET_SURFACE_BITS;
+	}
+
+	if (context->icon_x != UINT32_MAX)
+	{
+		const UINT32 colorFormat = PIXEL_FORMAT_RGB24;
+		const UINT32 bpp = FreeRDPGetBytesPerPixel(colorFormat);
+		s = test_peer_stream_init(context);
+
+		if (RemoteFxCodec)
+		{
+			rfx_context_set_pixel_format(context->rfx_context, colorFormat);
+			rfx_compose_message(context->rfx_context, s, &rect, 1, context->bg_data, rect.width,
+			                    rect.height, rect.width * bpp);
+		}
+		else
+		{
+			nsc_context_set_parameters(context->nsc_context, NSC_COLOR_FORMAT, colorFormat);
+			nsc_compose_message(context->nsc_context, s, context->bg_data, rect.width, rect.height,
+			                    rect.width * bpp);
+		}
+
+		cmd.destLeft = context->icon_x;
+		cmd.destTop = context->icon_y;
+		cmd.destRight = context->icon_x + rect.width;
+		cmd.destBottom = context->icon_y + rect.height;
+		cmd.bmp.bpp = 32;
+		cmd.bmp.flags = 0;
+		cmd.bmp.width = rect.width;
+		cmd.bmp.height = rect.height;
+		cmd.bmp.bitmapDataLength = (UINT32)Stream_GetPosition(s);
+		cmd.bmp.bitmapData = Stream_Buffer(s);
+		WINPR_ASSERT(update->SurfaceBits);
+		update->SurfaceBits(update->context, &cmd);
+	}
+
+	s = test_peer_stream_init(context);
+
+	{
+		const UINT32 colorFormat =
+		    context->image->bitsPerPixel > 24 ? PIXEL_FORMAT_BGRA32 : PIXEL_FORMAT_BGR24;
+
+		if (RemoteFxCodec)
+		{
+			rfx_context_set_pixel_format(context->rfx_context, colorFormat);
+			rfx_compose_message(context->rfx_context, s, &rect, 1, context->image->data, rect.width,
+			                    rect.height, context->image->scanline);
+		}
+		else
+		{
+			nsc_context_set_parameters(context->nsc_context, NSC_COLOR_FORMAT, colorFormat);
+			nsc_compose_message(context->nsc_context, s, context->image->data, rect.width,
+			                    rect.height, context->image->scanline);
+		}
+	}
+
+	cmd.destLeft = x;
+	cmd.destTop = y;
+	cmd.destRight = x + rect.width;
+	cmd.destBottom = y + rect.height;
+	cmd.bmp.bpp = 32;
+	cmd.bmp.width = rect.width;
+	cmd.bmp.height = rect.height;
+	cmd.bmp.bitmapDataLength = (UINT32)Stream_GetPosition(s);
+	cmd.bmp.bitmapData = Stream_Buffer(s);
+	WINPR_ASSERT(update->SurfaceBits);
+	update->SurfaceBits(update->context, &cmd);
+	context->icon_x = x;
+	context->icon_y = y;
+	test_peer_end_frame(client);
+}
+
+static BOOL test_sleep_tsdiff(UINT32* old_sec, UINT32* old_usec, UINT32 new_sec, UINT32 new_usec)
+{
+	INT64 sec = 0;
+	INT64 usec = 0;
+
+	WINPR_ASSERT(old_sec);
+	WINPR_ASSERT(old_usec);
+
+	if ((*old_sec == 0) && (*old_usec == 0))
+	{
+		*old_sec = new_sec;
+		*old_usec = new_usec;
+		return TRUE;
+	}
+
+	sec = new_sec - *old_sec;
+	usec = new_usec - *old_usec;
+
+	if ((sec < 0) || ((sec == 0) && (usec < 0)))
+	{
+		WLog_ERR(TAG, "Invalid time stamp detected.");
+		return FALSE;
+	}
+
+	*old_sec = new_sec;
+	*old_usec = new_usec;
+
+	while (usec < 0)
+	{
+		usec += 1000000;
+		sec--;
+	}
+
+	if (sec > 0)
+		Sleep((DWORD)sec * 1000);
+
+	if (usec > 0)
+		USleep((DWORD)usec);
+
+	return TRUE;
+}
+
+static BOOL tf_peer_dump_rfx(freerdp_peer* client)
+{
+	BOOL rc = FALSE;
+	wStream* s = NULL;
+	UINT32 prev_seconds = 0;
+	UINT32 prev_useconds = 0;
+	rdpUpdate* update = NULL;
+	rdpPcap* pcap_rfx = NULL;
+	pcap_record record = { 0 };
+	struct server_info* info = NULL;
+
+	WINPR_ASSERT(client);
+	WINPR_ASSERT(client->context);
+
+	info = client->ContextExtra;
+	WINPR_ASSERT(info);
+
+	s = Stream_New(NULL, 512);
+
+	if (!s)
+		return FALSE;
+
+	update = client->context->update;
+	WINPR_ASSERT(update);
+
+	pcap_rfx = pcap_open(info->test_pcap_file, FALSE);
+	if (!pcap_rfx)
+		goto fail;
+
+	prev_seconds = prev_useconds = 0;
+
+	while (pcap_has_next_record(pcap_rfx))
+	{
+		if (!pcap_get_next_record_header(pcap_rfx, &record))
+			break;
+
+		if (!Stream_EnsureCapacity(s, record.length))
+			break;
+
+		record.data = Stream_Buffer(s);
+		pcap_get_next_record_content(pcap_rfx, &record);
+		Stream_SetPosition(s, Stream_Capacity(s));
+
+		if (info->test_dump_rfx_realtime &&
+		    test_sleep_tsdiff(&prev_seconds, &prev_useconds, record.header.ts_sec,
+		                      record.header.ts_usec) == FALSE)
+			break;
+
+		WINPR_ASSERT(update->SurfaceCommand);
+		update->SurfaceCommand(update->context, s);
+
+		WINPR_ASSERT(client->CheckFileDescriptor);
+		if (client->CheckFileDescriptor(client) != TRUE)
+			break;
+	}
+
+	rc = TRUE;
+fail:
+	Stream_Free(s, TRUE);
+	pcap_close(pcap_rfx);
+	return rc;
+}
+
+static DWORD WINAPI tf_debug_channel_thread_func(LPVOID arg)
+{
+	void* fd = NULL;
+	void* buffer = NULL;
+	DWORD BytesReturned = 0;
+	ULONG written = 0;
+	testPeerContext* context = (testPeerContext*)arg;
+
+	WINPR_ASSERT(context);
+	if (WTSVirtualChannelQuery(context->debug_channel, WTSVirtualFileHandle, &buffer,
+	                           &BytesReturned) == TRUE)
+	{
+		fd = *((void**)buffer);
+		WTSFreeMemory(buffer);
+
+		if (!(context->event = CreateWaitObjectEvent(NULL, TRUE, FALSE, fd)))
+			return 0;
+	}
+
+	wStream* s = Stream_New(NULL, 4096);
+	if (!s)
+		goto fail;
+
+	if (!WTSVirtualChannelWrite(context->debug_channel, (PCHAR) "test1", 5, &written))
+		goto fail;
+
+	while (1)
+	{
+		DWORD status = 0;
+		DWORD nCount = 0;
+		HANDLE handles[MAXIMUM_WAIT_OBJECTS] = { 0 };
+
+		handles[nCount++] = context->event;
+		handles[nCount++] = freerdp_abort_event(&context->_p);
+		handles[nCount++] = context->stopEvent;
+		status = WaitForMultipleObjects(nCount, handles, FALSE, INFINITE);
+		switch (status)
+		{
+			case WAIT_OBJECT_0:
+				break;
+			default:
+				goto fail;
+		}
+
+		Stream_SetPosition(s, 0);
+
+		if (WTSVirtualChannelRead(context->debug_channel, 0, Stream_BufferAs(s, char),
+		                          (ULONG)Stream_Capacity(s), &BytesReturned) == FALSE)
+		{
+			if (BytesReturned == 0)
+				break;
+
+			if (!Stream_EnsureRemainingCapacity(s, BytesReturned))
+				break;
+
+			if (WTSVirtualChannelRead(context->debug_channel, 0, Stream_BufferAs(s, char),
+			                          (ULONG)Stream_Capacity(s), &BytesReturned) == FALSE)
+			{
+				/* should not happen */
+				break;
+			}
+		}
+
+		Stream_SetPosition(s, BytesReturned);
+		WLog_DBG(TAG, "got %" PRIu32 " bytes", BytesReturned);
+	}
+fail:
+	Stream_Free(s, TRUE);
+	return 0;
+}
+
+static BOOL tf_peer_post_connect(freerdp_peer* client)
+{
+	testPeerContext* context = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(client);
+
+	context = (testPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	/**
+	 * This callback is called when the entire connection sequence is done, i.e. we've received the
+	 * Font List PDU from the client and sent out the Font Map PDU.
+	 * The server may start sending graphics output and receiving keyboard/mouse input after this
+	 * callback returns.
+	 */
+	WLog_DBG(TAG, "Client %s is activated (osMajorType %" PRIu32 " osMinorType %" PRIu32 ")",
+	         client->local ? "(local)" : client->hostname,
+	         freerdp_settings_get_uint32(settings, FreeRDP_OsMajorType),
+	         freerdp_settings_get_uint32(settings, FreeRDP_OsMinorType));
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_AutoLogonEnabled))
+	{
+		const char* Username = freerdp_settings_get_string(settings, FreeRDP_Username);
+		const char* Domain = freerdp_settings_get_string(settings, FreeRDP_Domain);
+		WLog_DBG(TAG, " and wants to login automatically as %s\\%s", Domain ? Domain : "",
+		         Username);
+		/* A real server may perform OS login here if NLA is not executed previously. */
+	}
+
+	WLog_DBG(TAG, "");
+	WLog_DBG(TAG, "Client requested desktop: %" PRIu32 "x%" PRIu32 "x%" PRIu32 "",
+	         freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
+	         freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight),
+	         freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth));
+#if (SAMPLE_SERVER_USE_CLIENT_RESOLUTION == 1)
+
+	if (!rfx_context_reset(context->rfx_context,
+	                       freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
+	                       freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
+		return FALSE;
+
+	WLog_DBG(TAG, "Using resolution requested by client.");
+#else
+	client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) =
+	    context->rfx_context->width;
+	client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) =
+	    context->rfx_context->height;
+	WLog_DBG(TAG, "Resizing client to %" PRIu32 "x%" PRIu32 "",
+	         client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
+	         client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
+	client->update->DesktopResize(client->update->context);
+#endif
+
+	/* A real server should tag the peer as activated here and start sending updates in main loop.
+	 */
+	if (!test_peer_load_icon(client))
+	{
+		WLog_DBG(TAG, "Unable to load icon");
+		return FALSE;
+	}
+
+	if (WTSVirtualChannelManagerIsChannelJoined(context->vcm, "rdpdbg"))
+	{
+		context->debug_channel = WTSVirtualChannelOpen(context->vcm, WTS_CURRENT_SESSION, "rdpdbg");
+
+		if (context->debug_channel != NULL)
+		{
+			WLog_DBG(TAG, "Open channel rdpdbg.");
+
+			if (!(context->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
+			{
+				WLog_ERR(TAG, "Failed to create stop event");
+				return FALSE;
+			}
+
+			if (!(context->debug_channel_thread =
+			          CreateThread(NULL, 0, tf_debug_channel_thread_func, (void*)context, 0, NULL)))
+			{
+				WLog_ERR(TAG, "Failed to create debug channel thread");
+				(void)CloseHandle(context->stopEvent);
+				context->stopEvent = NULL;
+				return FALSE;
+			}
+		}
+	}
+
+	if (WTSVirtualChannelManagerIsChannelJoined(context->vcm, RDPSND_CHANNEL_NAME))
+	{
+		sf_peer_rdpsnd_init(context); /* Audio Output */
+	}
+
+	if (WTSVirtualChannelManagerIsChannelJoined(context->vcm, ENCOMSP_SVC_CHANNEL_NAME))
+	{
+		sf_peer_encomsp_init(context); /* Lync Multiparty */
+	}
+
+	/* Dynamic Virtual Channels */
+	sf_peer_audin_init(context); /* Audio Input */
+
+#if defined(CHANNEL_AINPUT_SERVER)
+	sf_peer_ainput_init(context);
+#endif
+
+	/* Return FALSE here would stop the execution of the peer main loop. */
+	return TRUE;
+}
+
+static BOOL tf_peer_activate(freerdp_peer* client)
+{
+	testPeerContext* context = NULL;
+	struct server_info* info = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(client);
+
+	context = (testPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	info = client->ContextExtra;
+	WINPR_ASSERT(info);
+
+	context->activated = TRUE;
+	// PACKET_COMPR_TYPE_8K;
+	// PACKET_COMPR_TYPE_64K;
+	// PACKET_COMPR_TYPE_RDP6;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_CompressionLevel, PACKET_COMPR_TYPE_RDP8))
+		return FALSE;
+
+	if (info->test_pcap_file != NULL)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DumpRemoteFx, TRUE))
+			return FALSE;
+
+		if (!tf_peer_dump_rfx(client))
+			return FALSE;
+	}
+	else
+		test_peer_draw_background(client);
+
+	return TRUE;
+}
+
+static BOOL tf_peer_synchronize_event(rdpInput* input, UINT32 flags)
+{
+	WINPR_UNUSED(input);
+	WINPR_ASSERT(input);
+	WLog_DBG(TAG, "Client sent a synchronize event (flags:0x%" PRIX32 ")", flags);
+	return TRUE;
+}
+
+static BOOL tf_peer_keyboard_event(rdpInput* input, UINT16 flags, UINT8 code)
+{
+	freerdp_peer* client = NULL;
+	rdpUpdate* update = NULL;
+	rdpContext* context = NULL;
+	testPeerContext* tcontext = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(input);
+
+	context = input->context;
+	WINPR_ASSERT(context);
+
+	client = context->peer;
+	WINPR_ASSERT(client);
+
+	settings = context->settings;
+	WINPR_ASSERT(settings);
+
+	update = context->update;
+	WINPR_ASSERT(update);
+
+	tcontext = (testPeerContext*)context;
+	WINPR_ASSERT(tcontext);
+
+	WLog_DBG(TAG, "Client sent a keyboard event (flags:0x%04" PRIX16 " code:0x%04" PRIX8 ")", flags,
+	         code);
+
+	if (((flags & KBD_FLAGS_RELEASE) == 0) && (code == RDP_SCANCODE_KEY_G)) /* 'g' key */
+	{
+		if (freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) != 800)
+		{
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, 800))
+				return FALSE;
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, 600))
+				return FALSE;
+		}
+		else
+		{
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth,
+			                                 SAMPLE_SERVER_DEFAULT_WIDTH))
+				return FALSE;
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight,
+			                                 SAMPLE_SERVER_DEFAULT_HEIGHT))
+				return FALSE;
+		}
+
+		if (!rfx_context_reset(tcontext->rfx_context,
+		                       freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
+		                       freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
+			return FALSE;
+
+		WINPR_ASSERT(update->DesktopResize);
+		update->DesktopResize(update->context);
+		tcontext->activated = FALSE;
+	}
+	else if (((flags & KBD_FLAGS_RELEASE) == 0) && code == RDP_SCANCODE_KEY_C) /* 'c' key */
+	{
+		if (tcontext->debug_channel)
+		{
+			ULONG written = 0;
+			if (!WTSVirtualChannelWrite(tcontext->debug_channel, (PCHAR) "test2", 5, &written))
+				return FALSE;
+		}
+	}
+	else if (((flags & KBD_FLAGS_RELEASE) == 0) && code == RDP_SCANCODE_KEY_X) /* 'x' key */
+	{
+		WINPR_ASSERT(client->Close);
+		client->Close(client);
+	}
+	else if (((flags & KBD_FLAGS_RELEASE) == 0) && code == RDP_SCANCODE_KEY_R) /* 'r' key */
+	{
+		tcontext->audin_open = !tcontext->audin_open;
+	}
+#if defined(CHANNEL_AINPUT_SERVER)
+	else if (((flags & KBD_FLAGS_RELEASE) == 0) && code == RDP_SCANCODE_KEY_I) /* 'i' key */
+	{
+		tcontext->ainput_open = !tcontext->ainput_open;
+	}
+#endif
+	else if (((flags & KBD_FLAGS_RELEASE) == 0) && code == RDP_SCANCODE_KEY_S) /* 's' key */
+	{
+	}
+
+	return TRUE;
+}
+
+static BOOL tf_peer_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+{
+	WINPR_UNUSED(input);
+	WINPR_ASSERT(input);
+
+	WLog_DBG(TAG,
+	         "Client sent a unicode keyboard event (flags:0x%04" PRIX16 " code:0x%04" PRIX16 ")",
+	         flags, code);
+	return TRUE;
+}
+
+static BOOL tf_peer_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+{
+	WINPR_UNUSED(flags);
+	WINPR_ASSERT(input);
+	WINPR_ASSERT(input->context);
+
+	// WLog_DBG(TAG, "Client sent a mouse event (flags:0x%04"PRIX16" pos:%"PRIu16",%"PRIu16")",
+	// flags, x, y);
+	test_peer_draw_icon(input->context->peer, x + 10, y);
+	return TRUE;
+}
+
+static BOOL tf_peer_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+{
+	WINPR_UNUSED(flags);
+	WINPR_ASSERT(input);
+	WINPR_ASSERT(input->context);
+
+	// WLog_DBG(TAG, "Client sent an extended mouse event (flags:0x%04"PRIX16"
+	// pos:%"PRIu16",%"PRIu16")", flags, x, y);
+	test_peer_draw_icon(input->context->peer, x + 10, y);
+	return TRUE;
+}
+
+static BOOL tf_peer_refresh_rect(rdpContext* context, BYTE count, const RECTANGLE_16* areas)
+{
+	WINPR_UNUSED(context);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(areas || (count == 0));
+
+	WLog_DBG(TAG, "Client requested to refresh:");
+
+	for (BYTE i = 0; i < count; i++)
+	{
+		WLog_DBG(TAG, "  (%" PRIu16 ", %" PRIu16 ") (%" PRIu16 ", %" PRIu16 ")", areas[i].left,
+		         areas[i].top, areas[i].right, areas[i].bottom);
+	}
+
+	return TRUE;
+}
+
+static BOOL tf_peer_suppress_output(rdpContext* context, BYTE allow, const RECTANGLE_16* area)
+{
+	WINPR_UNUSED(context);
+
+	if (allow > 0)
+	{
+		WINPR_ASSERT(area);
+		WLog_DBG(TAG,
+		         "Client restore output (%" PRIu16 ", %" PRIu16 ") (%" PRIu16 ", %" PRIu16 ").",
+		         area->left, area->top, area->right, area->bottom);
+	}
+	else
+	{
+		WLog_DBG(TAG, "Client minimized and suppress output.");
+	}
+
+	return TRUE;
+}
+
+static int hook_peer_write_pdu(rdpTransport* transport, wStream* s)
+{
+	UINT64 ts = 0;
+	wStream* ls = NULL;
+	UINT64 last_ts = 0;
+	const struct server_info* info = NULL;
+	freerdp_peer* client = NULL;
+	testPeerContext* peerCtx = NULL;
+	size_t offset = 0;
+	UINT32 flags = 0;
+	rdpContext* context = transport_get_context(transport);
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(s);
+
+	client = context->peer;
+	WINPR_ASSERT(client);
+
+	peerCtx = (testPeerContext*)client->context;
+	WINPR_ASSERT(peerCtx);
+	WINPR_ASSERT(peerCtx->io.WritePdu);
+
+	info = client->ContextExtra;
+	WINPR_ASSERT(info);
+
+	/* Let the client authenticate.
+	 * After that is done, we stop the normal operation and send
+	 * a previously recorded session PDU by PDU to the client.
+	 *
+	 * This is fragile and the connecting client needs to use the same
+	 * configuration as the one that recorded the session!
+	 */
+	WINPR_ASSERT(info);
+	CONNECTION_STATE state = freerdp_get_state(context);
+	if (state < CONNECTION_STATE_NEGO)
+		return peerCtx->io.WritePdu(transport, s);
+
+	ls = Stream_New(NULL, 4096);
+	if (!ls)
+		goto fail;
+
+	while (stream_dump_get(context, &flags, ls, &offset, &ts) > 0)
+	{
+		int rc = 0;
+		/* Skip messages from client. */
+		if (flags & STREAM_MSG_SRV_TX)
+		{
+			if ((last_ts > 0) && (ts > last_ts))
+			{
+				UINT64 diff = ts - last_ts;
+				while (diff > 0)
+				{
+					UINT32 d = diff > UINT32_MAX ? UINT32_MAX : (UINT32)diff;
+					diff -= d;
+					Sleep(d);
+				}
+			}
+			last_ts = ts;
+			rc = peerCtx->io.WritePdu(transport, ls);
+			if (rc < 0)
+				goto fail;
+		}
+		Stream_SetPosition(ls, 0);
+	}
+
+fail:
+	Stream_Free(ls, TRUE);
+	return -1;
+}
+
+static DWORD WINAPI test_peer_mainloop(LPVOID arg)
+{
+	BOOL rc = 0;
+	DWORD error = CHANNEL_RC_OK;
+	HANDLE handles[MAXIMUM_WAIT_OBJECTS] = { 0 };
+	DWORD count = 0;
+	DWORD status = 0;
+	testPeerContext* context = NULL;
+	struct server_info* info = NULL;
+	rdpSettings* settings = NULL;
+	rdpInput* input = NULL;
+	rdpUpdate* update = NULL;
+	freerdp_peer* client = (freerdp_peer*)arg;
+
+	WINPR_ASSERT(client);
+
+	info = client->ContextExtra;
+	WINPR_ASSERT(info);
+
+	if (!test_peer_init(client))
+	{
+		freerdp_peer_free(client);
+		return 0;
+	}
+
+	/* Initialize the real server settings here */
+	WINPR_ASSERT(client->context);
+	settings = client->context->settings;
+	WINPR_ASSERT(settings);
+	if (info->replay_dump)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_TransportDumpReplay, TRUE) ||
+		    !freerdp_settings_set_string(settings, FreeRDP_TransportDumpFile, info->replay_dump))
+			goto fail;
+	}
+
+	rdpPrivateKey* key = freerdp_key_new_from_file(info->key);
+	if (!key)
+		goto fail;
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerRsaKey, key, 1))
+		goto fail;
+	rdpCertificate* cert = freerdp_certificate_new_from_file(info->cert);
+	if (!cert)
+		goto fail;
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerCertificate, cert, 1))
+		goto fail;
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, TRUE))
+		goto fail;
+	if (!freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, TRUE))
+		goto fail;
+	if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, FALSE))
+		goto fail;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_EncryptionLevel,
+	                                 ENCRYPTION_LEVEL_CLIENT_COMPATIBLE))
+		goto fail;
+	/*  ENCRYPTION_LEVEL_HIGH; */
+	/*  ENCRYPTION_LEVEL_LOW; */
+	/*  ENCRYPTION_LEVEL_FIPS; */
+	if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteFxCodec, TRUE))
+		goto fail;
+	if (!freerdp_settings_set_bool(settings, FreeRDP_NSCodec, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32))
+		goto fail;
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_SuppressOutput, TRUE))
+		goto fail;
+	if (!freerdp_settings_set_bool(settings, FreeRDP_RefreshRect, TRUE))
+		goto fail;
+
+	client->PostConnect = tf_peer_post_connect;
+	client->Activate = tf_peer_activate;
+
+	WINPR_ASSERT(client->context);
+	input = client->context->input;
+	WINPR_ASSERT(input);
+
+	input->SynchronizeEvent = tf_peer_synchronize_event;
+	input->KeyboardEvent = tf_peer_keyboard_event;
+	input->UnicodeKeyboardEvent = tf_peer_unicode_keyboard_event;
+	input->MouseEvent = tf_peer_mouse_event;
+	input->ExtendedMouseEvent = tf_peer_extended_mouse_event;
+
+	update = client->context->update;
+	WINPR_ASSERT(update);
+
+	update->RefreshRect = tf_peer_refresh_rect;
+	update->SuppressOutput = tf_peer_suppress_output;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_MultifragMaxRequestSize,
+	                                 0xFFFFFF /* FIXME */))
+		goto fail;
+
+	WINPR_ASSERT(client->Initialize);
+	rc = client->Initialize(client);
+	if (!rc)
+		goto fail;
+
+	context = (testPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	if (info->replay_dump)
+	{
+		const rdpTransportIo* cb = freerdp_get_io_callbacks(client->context);
+		rdpTransportIo replay;
+
+		WINPR_ASSERT(cb);
+		replay = *cb;
+		context->io = *cb;
+		replay.WritePdu = hook_peer_write_pdu;
+		freerdp_set_io_callbacks(client->context, &replay);
+	}
+
+	WLog_INFO(TAG, "We've got a client %s", client->local ? "(local)" : client->hostname);
+
+	while (error == CHANNEL_RC_OK)
+	{
+		count = 0;
+		{
+			WINPR_ASSERT(client->GetEventHandles);
+			DWORD tmp = client->GetEventHandles(client, &handles[count], 32 - count);
+
+			if (tmp == 0)
+			{
+				WLog_ERR(TAG, "Failed to get FreeRDP transport event handles");
+				break;
+			}
+
+			count += tmp;
+		}
+
+		HANDLE channelHandle = WTSVirtualChannelManagerGetEventHandle(context->vcm);
+		handles[count++] = channelHandle;
+		status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
+
+		if (status == WAIT_FAILED)
+		{
+			WLog_ERR(TAG, "WaitForMultipleObjects failed (errno: %d)", errno);
+			break;
+		}
+
+		WINPR_ASSERT(client->CheckFileDescriptor);
+		if (client->CheckFileDescriptor(client) != TRUE)
+			break;
+
+		if (WaitForSingleObject(channelHandle, 0) != WAIT_OBJECT_0)
+			continue;
+
+		if (WTSVirtualChannelManagerCheckFileDescriptor(context->vcm) != TRUE)
+			break;
+
+		/* Handle dynamic virtual channel initializations */
+		if (WTSVirtualChannelManagerIsChannelJoined(context->vcm, DRDYNVC_SVC_CHANNEL_NAME))
+		{
+			switch (WTSVirtualChannelManagerGetDrdynvcState(context->vcm))
+			{
+				case DRDYNVC_STATE_NONE:
+					break;
+
+				case DRDYNVC_STATE_INITIALIZED:
+					break;
+
+				case DRDYNVC_STATE_READY:
+
+					/* Here is the correct state to start dynamic virtual channels */
+					if (sf_peer_audin_running(context) != context->audin_open)
+					{
+						if (!sf_peer_audin_running(context))
+							sf_peer_audin_start(context);
+						else
+							sf_peer_audin_stop(context);
+					}
+
+#if defined(CHANNEL_AINPUT_SERVER)
+					if (sf_peer_ainput_running(context) != context->ainput_open)
+					{
+						if (!sf_peer_ainput_running(context))
+							sf_peer_ainput_start(context);
+						else
+							sf_peer_ainput_stop(context);
+					}
+#endif
+
+					break;
+
+				case DRDYNVC_STATE_FAILED:
+				default:
+					break;
+			}
+		}
+	}
+
+	WLog_INFO(TAG, "Client %s disconnected.", client->local ? "(local)" : client->hostname);
+
+	WINPR_ASSERT(client->Disconnect);
+	client->Disconnect(client);
+fail:
+	freerdp_peer_context_free(client);
+	freerdp_peer_free(client);
+	return error;
+}
+
+static BOOL test_peer_accepted(freerdp_listener* instance, freerdp_peer* client)
+{
+	HANDLE hThread = NULL;
+	struct server_info* info = NULL;
+
+	WINPR_UNUSED(instance);
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(client);
+
+	info = instance->info;
+	client->ContextExtra = info;
+
+	if (!(hThread = CreateThread(NULL, 0, test_peer_mainloop, (void*)client, 0, NULL)))
+		return FALSE;
+
+	(void)CloseHandle(hThread);
+	return TRUE;
+}
+
+static void test_server_mainloop(freerdp_listener* instance)
+{
+	HANDLE handles[32] = { 0 };
+	DWORD count = 0;
+	DWORD status = 0;
+
+	WINPR_ASSERT(instance);
+	while (1)
+	{
+		WINPR_ASSERT(instance->GetEventHandles);
+		count = instance->GetEventHandles(instance, handles, 32);
+
+		if (0 == count)
+		{
+			WLog_ERR(TAG, "Failed to get FreeRDP event handles");
+			break;
+		}
+
+		status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
+
+		if (WAIT_FAILED == status)
+		{
+			WLog_ERR(TAG, "select failed");
+			break;
+		}
+
+		WINPR_ASSERT(instance->CheckFileDescriptor);
+		if (instance->CheckFileDescriptor(instance) != TRUE)
+		{
+			WLog_ERR(TAG, "Failed to check FreeRDP file descriptor");
+			break;
+		}
+	}
+
+	WINPR_ASSERT(instance->Close);
+	instance->Close(instance);
+}
+
+static const struct
+{
+	const char spcap[7];
+	const char sfast[7];
+	const char sport[7];
+	const char slocal_only[13];
+	const char scert[7];
+	const char skey[6];
+} options = { "--pcap=", "--fast", "--port=", "--local-only", "--cert=", "--key=" };
+
+WINPR_PRAGMA_DIAG_PUSH
+WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL
+WINPR_ATTR_FORMAT_ARG(2, 0)
+static void print_entry(FILE* fp, WINPR_FORMAT_ARG const char* fmt, const char* what, size_t size)
+{
+	char buffer[32] = { 0 };
+	strncpy(buffer, what, MIN(size, sizeof(buffer) - 1));
+	(void)fprintf(fp, fmt, buffer);
+}
+WINPR_PRAGMA_DIAG_POP
+
+static int usage(const char* app, const char* invalid)
+{
+	FILE* fp = stdout;
+
+	(void)fprintf(fp, "Invalid argument '%s'\n", invalid);
+	(void)fprintf(fp, "Usage: %s <arg>[ <arg> ...]\n", app);
+	(void)fprintf(fp, "Arguments:\n");
+	print_entry(fp, "\t%s<pcap file>\n", options.spcap, sizeof(options.spcap));
+	print_entry(fp, "\t%s<cert file>\n", options.scert, sizeof(options.scert));
+	print_entry(fp, "\t%s<key file>\n", options.skey, sizeof(options.skey));
+	print_entry(fp, "\t%s\n", options.sfast, sizeof(options.sfast));
+	print_entry(fp, "\t%s<port>\n", options.sport, sizeof(options.sport));
+	print_entry(fp, "\t%s\n", options.slocal_only, sizeof(options.slocal_only));
+	return -1;
+}
+
+int main(int argc, char* argv[])
+{
+	int rc = -1;
+	BOOL started = FALSE;
+	WSADATA wsaData = { 0 };
+	freerdp_listener* instance = NULL;
+	char* file = NULL;
+	char name[MAX_PATH] = { 0 };
+	long port = 3389;
+	BOOL localOnly = FALSE;
+	struct server_info info = { 0 };
+	const char* app = argv[0];
+
+	info.test_dump_rfx_realtime = TRUE;
+
+	errno = 0;
+
+	for (int i = 1; i < argc; i++)
+	{
+		char* arg = argv[i];
+
+		if (strncmp(arg, options.sfast, sizeof(options.sfast)) == 0)
+			info.test_dump_rfx_realtime = FALSE;
+		else if (strncmp(arg, options.sport, sizeof(options.sport)) == 0)
+		{
+			const char* sport = &arg[sizeof(options.sport)];
+			port = strtol(sport, NULL, 10);
+
+			if ((port < 1) || (port > UINT16_MAX) || (errno != 0))
+				return usage(app, arg);
+		}
+		else if (strncmp(arg, options.slocal_only, sizeof(options.slocal_only)) == 0)
+			localOnly = TRUE;
+		else if (strncmp(arg, options.spcap, sizeof(options.spcap)) == 0)
+		{
+			info.test_pcap_file = &arg[sizeof(options.spcap)];
+			if (!winpr_PathFileExists(info.test_pcap_file))
+				return usage(app, arg);
+		}
+		else if (strncmp(arg, options.scert, sizeof(options.scert)) == 0)
+		{
+			info.cert = &arg[sizeof(options.scert)];
+			if (!winpr_PathFileExists(info.cert))
+				return usage(app, arg);
+		}
+		else if (strncmp(arg, options.skey, sizeof(options.skey)) == 0)
+		{
+			info.key = &arg[sizeof(options.skey)];
+			if (!winpr_PathFileExists(info.key))
+				return usage(app, arg);
+		}
+		else
+			return usage(app, arg);
+	}
+
+	WTSRegisterWtsApiFunctionTable(FreeRDP_InitWtsApi());
+	winpr_InitializeSSL(WINPR_SSL_INIT_DEFAULT);
+	instance = freerdp_listener_new();
+
+	if (!instance)
+		return -1;
+
+	if (!info.cert)
+		info.cert = "server.crt";
+	if (!info.key)
+		info.key = "server.key";
+
+	instance->info = (void*)&info;
+	instance->PeerAccepted = test_peer_accepted;
+
+	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
+		goto fail;
+
+	/* Open the server socket and start listening. */
+	(void)sprintf_s(name, sizeof(name), "tfreerdp-server.%ld", port);
+	file = GetKnownSubPath(KNOWN_PATH_TEMP, name);
+
+	if (!file)
+		goto fail;
+
+	if (localOnly)
+	{
+		WINPR_ASSERT(instance->OpenLocal);
+		started = instance->OpenLocal(instance, file);
+	}
+	else
+	{
+		WINPR_ASSERT(instance->Open);
+		started = instance->Open(instance, NULL, (UINT16)port);
+	}
+
+	if (started)
+	{
+		/* Entering the server main loop. In a real server the listener can be run in its own
+		 * thread. */
+		test_server_mainloop(instance);
+	}
+
+	rc = 0;
+fail:
+	free(file);
+	freerdp_listener_free(instance);
+	WSACleanup();
+	return rc;
+}

local-test-freerdp-full-01/afc-freerdp/server/Sample/sfreerdp.h

@@ -0,0 +1,76 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Sample Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_SAMPLE_SFREERDP_SERVER_H
+#define FREERDP_SERVER_SAMPLE_SFREERDP_SERVER_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/listener.h>
+#include <freerdp/codec/rfx.h>
+#include <freerdp/codec/nsc.h>
+#include <freerdp/channels/wtsvc.h>
+#if defined(CHANNEL_AINPUT_SERVER)
+#include <freerdp/server/ainput.h>
+#endif
+#if defined(CHANNEL_AUDIN_SERVER)
+#include <freerdp/server/audin.h>
+#endif
+#include <freerdp/server/rdpsnd.h>
+#include <freerdp/server/encomsp.h>
+#include <freerdp/transport_io.h>
+
+#include <winpr/crt.h>
+#include <winpr/synch.h>
+#include <winpr/thread.h>
+#include <winpr/image.h>
+
+struct test_peer_context
+{
+	rdpContext _p;
+
+	RFX_CONTEXT* rfx_context;
+	NSC_CONTEXT* nsc_context;
+	wStream* s;
+	BYTE* bg_data;
+	UINT32 icon_x;
+	UINT32 icon_y;
+	BOOL activated;
+	HANDLE event;
+	HANDLE stopEvent;
+	HANDLE vcm;
+	void* debug_channel;
+	HANDLE debug_channel_thread;
+#if defined(CHANNEL_AUDIN_SERVER)
+	audin_server_context* audin;
+#endif
+	BOOL audin_open;
+#if defined(CHANNEL_AINPUT_SERVER)
+	ainput_server_context* ainput;
+	BOOL ainput_open;
+#endif
+	UINT32 frame_id;
+	RdpsndServerContext* rdpsnd;
+	EncomspServerContext* encomsp;
+
+	rdpTransportIo io;
+	wImage* image;
+};
+typedef struct test_peer_context testPeerContext;
+
+#endif /* FREERDP_SERVER_SAMPLE_SFREERDP_SERVER_H */

local-test-freerdp-full-01/afc-freerdp/server/Windows/CMakeLists.txt

@@ -0,0 +1,82 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP Windows Server cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <[email protected]>
+#
+# 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.
+
+set(MODULE_NAME "wfreerdp-server")
+set(MODULE_PREFIX "FREERDP_SERVER_WINDOWS")
+
+include(WarnUnmaintained)
+warn_unmaintained(${MODULE_NAME})
+
+include_directories(.)
+
+set(${MODULE_PREFIX}_SRCS
+    wf_update.c
+    wf_update.h
+    wf_dxgi.c
+    wf_dxgi.h
+    wf_input.c
+    wf_input.h
+    wf_interface.c
+    wf_interface.h
+    wf_mirage.c
+    wf_mirage.h
+    wf_peer.c
+    wf_peer.h
+    wf_settings.c
+    wf_settings.h
+    wf_info.c
+    wf_info.h
+)
+
+if(CHANNEL_RDPSND AND NOT WITH_RDPSND_DSOUND)
+  set(${MODULE_PREFIX}_SRCS ${${MODULE_PREFIX}_SRCS} wf_rdpsnd.c wf_rdpsnd.h wf_wasapi.c wf_wasapi.h)
+endif()
+
+if(CHANNEL_RDPSND AND WITH_RDPSND_DSOUND)
+  set(${MODULE_PREFIX}_SRCS ${${MODULE_PREFIX}_SRCS} wf_rdpsnd.c wf_rdpsnd.h wf_directsound.c wf_directsound.h)
+endif()
+
+if(WITH_SERVER_INTERFACE)
+  addtargetwithresourcefile(${MODULE_NAME} FALSE "${FREERDP_VERSION}" ${MODULE_PREFIX}_SRCS)
+  target_include_directories(${MODULE_NAME} INTERFACE $<INSTALL_INTERFACE:include>)
+else()
+  list(APPEND ${MODULE_PREFIX}_SRCS cli/wfreerdp.c cli/wfreerdp.h)
+  addtargetwithresourcefile(${MODULE_NAME} TRUE "${FREERDP_VERSION}" ${MODULE_PREFIX}_SRCS)
+endif()
+
+if(NOT CMAKE_WINDOWS_VERSION STREQUAL "WINXP")
+  set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} d3d11 dxgi)
+endif()
+
+set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} dsound)
+set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} freerdp-server freerdp)
+
+target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
+
+if(WITH_SERVER_INTERFACE)
+  install(TARGETS ${MODULE_NAME} COMPONENT libraries ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  )
+else()
+  install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT server)
+endif()
+
+if(WITH_SERVER_INTERFACE)
+  add_subdirectory(cli)
+endif()
+
+set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "Server/Windows")

local-test-freerdp-full-01/afc-freerdp/server/Windows/ModuleOptions.cmake

@@ -0,0 +1,3 @@
+set(FREERDP_SERVER_NAME "wfreerdp-server")
+set(FREERDP_SERVER_PLATFORM "Windows")
+set(FREERDP_SERVER_VENDOR "FreeRDP")

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_directsound.c

@@ -0,0 +1,219 @@
+#include "wf_directsound.h"
+#include "wf_interface.h"
+#include "wf_info.h"
+#include "wf_rdpsnd.h"
+
+#include <winpr/windows.h>
+
+#define INITGUID
+#include <initguid.h>
+#include <objbase.h>
+
+#define CINTERFACE 1
+#include <mmsystem.h>
+#include <dsound.h>
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("windows")
+
+IDirectSoundCapture8* cap;
+IDirectSoundCaptureBuffer8* capBuf;
+DSCBUFFERDESC dscbd;
+DWORD lastPos;
+wfPeerContext* latestPeer;
+
+int wf_rdpsnd_set_latest_peer(wfPeerContext* peer)
+{
+	latestPeer = peer;
+	return 0;
+}
+
+int wf_directsound_activate(RdpsndServerContext* context)
+{
+	HRESULT hr;
+	wfInfo* wfi;
+	HANDLE hThread;
+
+	LPDIRECTSOUNDCAPTUREBUFFER pDSCB;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+	{
+		WLog_ERR(TAG, "Failed to wfi instance");
+		return 1;
+	}
+	WLog_DBG(TAG, "RDPSND (direct sound) Activated");
+	hr = DirectSoundCaptureCreate8(NULL, &cap, NULL);
+
+	if (FAILED(hr))
+	{
+		WLog_ERR(TAG, "Failed to create sound capture device");
+		return 1;
+	}
+
+	WLog_INFO(TAG, "Created sound capture device");
+	dscbd.dwSize = sizeof(DSCBUFFERDESC);
+	dscbd.dwFlags = 0;
+	dscbd.dwBufferBytes = wfi->agreed_format->nAvgBytesPerSec;
+	dscbd.dwReserved = 0;
+	dscbd.lpwfxFormat = wfi->agreed_format;
+	dscbd.dwFXCount = 0;
+	dscbd.lpDSCFXDesc = NULL;
+
+	hr = cap->lpVtbl->CreateCaptureBuffer(cap, &dscbd, &pDSCB, NULL);
+
+	if (FAILED(hr))
+	{
+		WLog_ERR(TAG, "Failed to create capture buffer");
+	}
+
+	WLog_INFO(TAG, "Created capture buffer");
+	hr = pDSCB->lpVtbl->QueryInterface(pDSCB, &IID_IDirectSoundCaptureBuffer8, (LPVOID*)&capBuf);
+	if (FAILED(hr))
+	{
+		WLog_ERR(TAG, "Failed to QI capture buffer");
+	}
+	WLog_INFO(TAG, "Created IDirectSoundCaptureBuffer8");
+	pDSCB->lpVtbl->Release(pDSCB);
+	lastPos = 0;
+
+	if (!(hThread = CreateThread(NULL, 0, wf_rdpsnd_directsound_thread, latestPeer, 0, NULL)))
+	{
+		WLog_ERR(TAG, "Failed to create direct sound thread");
+		return 1;
+	}
+	(void)CloseHandle(hThread);
+
+	return 0;
+}
+
+static DWORD WINAPI wf_rdpsnd_directsound_thread(LPVOID lpParam)
+{
+	HRESULT hr;
+	DWORD beg = 0;
+	DWORD end = 0;
+	DWORD diff, rate;
+	wfPeerContext* context;
+	wfInfo* wfi;
+
+	VOID* pbCaptureData = NULL;
+	DWORD dwCaptureLength = 0;
+	VOID* pbCaptureData2 = NULL;
+	DWORD dwCaptureLength2 = 0;
+	VOID* pbPlayData = NULL;
+	DWORD dwReadPos = 0;
+	LONG lLockSize = 0;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+	{
+		WLog_ERR(TAG, "Failed get instance");
+		return 1;
+	}
+
+	context = (wfPeerContext*)lpParam;
+	rate = 1000 / 24;
+	WLog_INFO(TAG, "Trying to start capture");
+	hr = capBuf->lpVtbl->Start(capBuf, DSCBSTART_LOOPING);
+	if (FAILED(hr))
+	{
+		WLog_ERR(TAG, "Failed to start capture");
+	}
+	WLog_INFO(TAG, "Capture started");
+
+	while (1)
+	{
+
+		end = GetTickCount();
+		diff = end - beg;
+
+		if (diff < rate)
+		{
+			Sleep(rate - diff);
+		}
+
+		beg = GetTickCount();
+
+		if (wf_rdpsnd_lock() > 0)
+		{
+			// check for main exit condition
+			if (wfi->snd_stop == TRUE)
+			{
+				wf_rdpsnd_unlock();
+				break;
+			}
+
+			hr = capBuf->lpVtbl->GetCurrentPosition(capBuf, NULL, &dwReadPos);
+			if (FAILED(hr))
+			{
+				WLog_ERR(TAG, "Failed to get read pos");
+				wf_rdpsnd_unlock();
+				break;
+			}
+
+			lLockSize = dwReadPos - lastPos; // dscbd.dwBufferBytes;
+			if (lLockSize < 0)
+				lLockSize += dscbd.dwBufferBytes;
+
+			// WLog_DBG(TAG, "Last, read, lock = [%"PRIu32", %"PRIu32", %"PRId32"]\n", lastPos,
+			// dwReadPos, lLockSize);
+
+			if (lLockSize == 0)
+			{
+				wf_rdpsnd_unlock();
+				continue;
+			}
+
+			hr = capBuf->lpVtbl->Lock(capBuf, lastPos, lLockSize, &pbCaptureData, &dwCaptureLength,
+			                          &pbCaptureData2, &dwCaptureLength2, 0L);
+			if (FAILED(hr))
+			{
+				WLog_ERR(TAG, "Failed to lock sound capture buffer");
+				wf_rdpsnd_unlock();
+				break;
+			}
+
+			// fwrite(pbCaptureData, 1, dwCaptureLength, pFile);
+			// fwrite(pbCaptureData2, 1, dwCaptureLength2, pFile);
+
+			// FIXME: frames = bytes/(bytespersample * channels)
+
+			context->rdpsnd->SendSamples(context->rdpsnd, pbCaptureData, dwCaptureLength / 4,
+			                             (UINT16)(beg & 0xffff));
+			context->rdpsnd->SendSamples(context->rdpsnd, pbCaptureData2, dwCaptureLength2 / 4,
+			                             (UINT16)(beg & 0xffff));
+
+			hr = capBuf->lpVtbl->Unlock(capBuf, pbCaptureData, dwCaptureLength, pbCaptureData2,
+			                            dwCaptureLength2);
+			if (FAILED(hr))
+			{
+				WLog_ERR(TAG, "Failed to unlock sound capture buffer");
+				wf_rdpsnd_unlock();
+				return 0;
+			}
+
+			// TODO keep track of location in buffer
+			lastPos += dwCaptureLength;
+			lastPos %= dscbd.dwBufferBytes;
+			lastPos += dwCaptureLength2;
+			lastPos %= dscbd.dwBufferBytes;
+
+			wf_rdpsnd_unlock();
+		}
+	}
+
+	WLog_INFO(TAG, "Trying to stop sound capture");
+	hr = capBuf->lpVtbl->Stop(capBuf);
+	if (FAILED(hr))
+	{
+		WLog_ERR(TAG, "Failed to stop capture");
+	}
+
+	WLog_INFO(TAG, "Capture stopped");
+	capBuf->lpVtbl->Release(capBuf);
+	cap->lpVtbl->Release(cap);
+
+	lastPos = 0;
+
+	return 0;
+}

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_directsound.h

@@ -0,0 +1,13 @@
+#ifndef FREERDP_SERVER_WIN_DSOUND_H
+#define FREERDP_SERVER_WIN_DSOUND_H
+
+#include <freerdp/server/rdpsnd.h>
+#include "wf_interface.h"
+
+int wf_rdpsnd_set_latest_peer(wfPeerContext* peer);
+
+int wf_directsound_activate(RdpsndServerContext* context);
+
+DWORD WINAPI wf_rdpsnd_directsound_thread(LPVOID lpParam);
+
+#endif /* FREERDP_SERVER_WIN_DSOUND_H */

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_dxgi.c

@@ -0,0 +1,486 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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/config.h>
+
+#include "wf_interface.h"
+
+#ifdef WITH_DXGI_1_2
+
+#define CINTERFACE
+
+#include <D3D11.h>
+#include <dxgi1_2.h>
+
+#include <tchar.h>
+#include "wf_dxgi.h"
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("windows")
+
+/* Driver types supported */
+D3D_DRIVER_TYPE DriverTypes[] = {
+	D3D_DRIVER_TYPE_HARDWARE,
+	D3D_DRIVER_TYPE_WARP,
+	D3D_DRIVER_TYPE_REFERENCE,
+};
+UINT NumDriverTypes = ARRAYSIZE(DriverTypes);
+
+/* Feature levels supported */
+D3D_FEATURE_LEVEL FeatureLevels[] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
+	                                  D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_1 };
+
+UINT NumFeatureLevels = ARRAYSIZE(FeatureLevels);
+
+D3D_FEATURE_LEVEL FeatureLevel;
+
+ID3D11Device* gDevice = NULL;
+ID3D11DeviceContext* gContext = NULL;
+IDXGIOutputDuplication* gOutputDuplication = NULL;
+ID3D11Texture2D* gAcquiredDesktopImage = NULL;
+
+IDXGISurface* surf;
+ID3D11Texture2D* sStage;
+
+DXGI_OUTDUPL_FRAME_INFO FrameInfo;
+
+int wf_dxgi_init(wfInfo* wfi)
+{
+	gAcquiredDesktopImage = NULL;
+
+	if (wf_dxgi_createDevice(wfi) != 0)
+	{
+		return 1;
+	}
+
+	if (wf_dxgi_getDuplication(wfi) != 0)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+int wf_dxgi_createDevice(wfInfo* wfi)
+{
+	HRESULT status;
+	UINT DriverTypeIndex;
+
+	for (DriverTypeIndex = 0; DriverTypeIndex < NumDriverTypes; ++DriverTypeIndex)
+	{
+		status = D3D11CreateDevice(NULL, DriverTypes[DriverTypeIndex], NULL, 0, FeatureLevels,
+		                           NumFeatureLevels, D3D11_SDK_VERSION, &gDevice, &FeatureLevel,
+		                           &gContext);
+		if (SUCCEEDED(status))
+			break;
+
+		WLog_INFO(TAG, "D3D11CreateDevice returned [%ld] for Driver Type %d", status,
+		          DriverTypes[DriverTypeIndex]);
+	}
+
+	if (FAILED(status))
+	{
+		WLog_ERR(TAG, "Failed to create device in InitializeDx");
+		return 1;
+	}
+
+	return 0;
+}
+
+int wf_dxgi_getDuplication(wfInfo* wfi)
+{
+	HRESULT status;
+	UINT dTop, i = 0;
+	DXGI_OUTPUT_DESC desc = { 0 };
+	IDXGIOutput* pOutput;
+	IDXGIDevice* DxgiDevice = NULL;
+	IDXGIAdapter* DxgiAdapter = NULL;
+	IDXGIOutput* DxgiOutput = NULL;
+	IDXGIOutput1* DxgiOutput1 = NULL;
+
+	status = gDevice->lpVtbl->QueryInterface(gDevice, &IID_IDXGIDevice, (void**)&DxgiDevice);
+
+	if (FAILED(status))
+	{
+		WLog_ERR(TAG, "Failed to get QI for DXGI Device");
+		return 1;
+	}
+
+	status = DxgiDevice->lpVtbl->GetParent(DxgiDevice, &IID_IDXGIAdapter, (void**)&DxgiAdapter);
+	DxgiDevice->lpVtbl->Release(DxgiDevice);
+	DxgiDevice = NULL;
+
+	if (FAILED(status))
+	{
+		WLog_ERR(TAG, "Failed to get parent DXGI Adapter");
+		return 1;
+	}
+
+	pOutput = NULL;
+
+	while (DxgiAdapter->lpVtbl->EnumOutputs(DxgiAdapter, i, &pOutput) != DXGI_ERROR_NOT_FOUND)
+	{
+		DXGI_OUTPUT_DESC* pDesc = &desc;
+
+		status = pOutput->lpVtbl->GetDesc(pOutput, pDesc);
+
+		if (FAILED(status))
+		{
+			WLog_ERR(TAG, "Failed to get description");
+			return 1;
+		}
+
+		WLog_INFO(TAG, "Output %u: [%s] [%d]", i, pDesc->DeviceName, pDesc->AttachedToDesktop);
+
+		if (pDesc->AttachedToDesktop)
+			dTop = i;
+
+		pOutput->lpVtbl->Release(pOutput);
+		++i;
+	}
+
+	dTop = wfi->screenID;
+
+	status = DxgiAdapter->lpVtbl->EnumOutputs(DxgiAdapter, dTop, &DxgiOutput);
+	DxgiAdapter->lpVtbl->Release(DxgiAdapter);
+	DxgiAdapter = NULL;
+
+	if (FAILED(status))
+	{
+		WLog_ERR(TAG, "Failed to get output");
+		return 1;
+	}
+
+	status =
+	    DxgiOutput->lpVtbl->QueryInterface(DxgiOutput, &IID_IDXGIOutput1, (void**)&DxgiOutput1);
+	DxgiOutput->lpVtbl->Release(DxgiOutput);
+	DxgiOutput = NULL;
+
+	if (FAILED(status))
+	{
+		WLog_ERR(TAG, "Failed to get IDXGIOutput1");
+		return 1;
+	}
+
+	status =
+	    DxgiOutput1->lpVtbl->DuplicateOutput(DxgiOutput1, (IUnknown*)gDevice, &gOutputDuplication);
+	DxgiOutput1->lpVtbl->Release(DxgiOutput1);
+	DxgiOutput1 = NULL;
+
+	if (FAILED(status))
+	{
+		if (status == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE)
+		{
+			WLog_ERR(
+			    TAG,
+			    "There is already the maximum number of applications using the Desktop Duplication "
+			    "API running, please close one of those applications and then try again.");
+			return 1;
+		}
+
+		WLog_ERR(TAG, "Failed to get duplicate output. Status = %ld", status);
+		return 1;
+	}
+
+	return 0;
+}
+
+int wf_dxgi_cleanup(wfInfo* wfi)
+{
+	if (wfi->framesWaiting > 0)
+	{
+		wf_dxgi_releasePixelData(wfi);
+	}
+
+	if (gAcquiredDesktopImage)
+	{
+		gAcquiredDesktopImage->lpVtbl->Release(gAcquiredDesktopImage);
+		gAcquiredDesktopImage = NULL;
+	}
+
+	if (gOutputDuplication)
+	{
+		gOutputDuplication->lpVtbl->Release(gOutputDuplication);
+		gOutputDuplication = NULL;
+	}
+
+	if (gContext)
+	{
+		gContext->lpVtbl->Release(gContext);
+		gContext = NULL;
+	}
+
+	if (gDevice)
+	{
+		gDevice->lpVtbl->Release(gDevice);
+		gDevice = NULL;
+	}
+
+	return 0;
+}
+
+int wf_dxgi_nextFrame(wfInfo* wfi, UINT timeout)
+{
+	HRESULT status = 0;
+	UINT i = 0;
+	UINT DataBufferSize = 0;
+	BYTE* DataBuffer = NULL;
+	IDXGIResource* DesktopResource = NULL;
+
+	if (wfi->framesWaiting > 0)
+	{
+		wf_dxgi_releasePixelData(wfi);
+	}
+
+	if (gAcquiredDesktopImage)
+	{
+		gAcquiredDesktopImage->lpVtbl->Release(gAcquiredDesktopImage);
+		gAcquiredDesktopImage = NULL;
+	}
+
+	status = gOutputDuplication->lpVtbl->AcquireNextFrame(gOutputDuplication, timeout, &FrameInfo,
+	                                                      &DesktopResource);
+
+	if (status == DXGI_ERROR_WAIT_TIMEOUT)
+	{
+		return 1;
+	}
+
+	if (FAILED(status))
+	{
+		if (status == DXGI_ERROR_ACCESS_LOST)
+		{
+			WLog_ERR(TAG, "Failed to acquire next frame with status=%ld", status);
+			WLog_ERR(TAG, "Trying to reinitialize due to ACCESS LOST...");
+
+			if (gAcquiredDesktopImage)
+			{
+				gAcquiredDesktopImage->lpVtbl->Release(gAcquiredDesktopImage);
+				gAcquiredDesktopImage = NULL;
+			}
+
+			if (gOutputDuplication)
+			{
+				gOutputDuplication->lpVtbl->Release(gOutputDuplication);
+				gOutputDuplication = NULL;
+			}
+
+			wf_dxgi_getDuplication(wfi);
+
+			return 1;
+		}
+		else
+		{
+			WLog_ERR(TAG, "Failed to acquire next frame with status=%ld", status);
+			status = gOutputDuplication->lpVtbl->ReleaseFrame(gOutputDuplication);
+
+			if (FAILED(status))
+			{
+				WLog_ERR(TAG, "Failed to release frame with status=%ld", status);
+			}
+
+			return 1;
+		}
+	}
+
+	status = DesktopResource->lpVtbl->QueryInterface(DesktopResource, &IID_ID3D11Texture2D,
+	                                                 (void**)&gAcquiredDesktopImage);
+	DesktopResource->lpVtbl->Release(DesktopResource);
+	DesktopResource = NULL;
+
+	if (FAILED(status))
+	{
+		return 1;
+	}
+
+	wfi->framesWaiting = FrameInfo.AccumulatedFrames;
+
+	if (FrameInfo.AccumulatedFrames == 0)
+	{
+		status = gOutputDuplication->lpVtbl->ReleaseFrame(gOutputDuplication);
+
+		if (FAILED(status))
+		{
+			WLog_ERR(TAG, "Failed to release frame with status=%ld", status);
+		}
+	}
+
+	return 0;
+}
+
+int wf_dxgi_getPixelData(wfInfo* wfi, BYTE** data, int* pitch, RECT* invalid)
+{
+	HRESULT status;
+	D3D11_BOX Box;
+	DXGI_MAPPED_RECT mappedRect;
+	D3D11_TEXTURE2D_DESC tDesc;
+
+	tDesc.Width = (invalid->right - invalid->left);
+	tDesc.Height = (invalid->bottom - invalid->top);
+	tDesc.MipLevels = 1;
+	tDesc.ArraySize = 1;
+	tDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+	tDesc.SampleDesc.Count = 1;
+	tDesc.SampleDesc.Quality = 0;
+	tDesc.Usage = D3D11_USAGE_STAGING;
+	tDesc.BindFlags = 0;
+	tDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+	tDesc.MiscFlags = 0;
+
+	Box.top = invalid->top;
+	Box.left = invalid->left;
+	Box.right = invalid->right;
+	Box.bottom = invalid->bottom;
+	Box.front = 0;
+	Box.back = 1;
+
+	status = gDevice->lpVtbl->CreateTexture2D(gDevice, &tDesc, NULL, &sStage);
+
+	if (FAILED(status))
+	{
+		WLog_ERR(TAG, "Failed to create staging surface");
+		exit(1);
+		return 1;
+	}
+
+	gContext->lpVtbl->CopySubresourceRegion(gContext, (ID3D11Resource*)sStage, 0, 0, 0, 0,
+	                                        (ID3D11Resource*)gAcquiredDesktopImage, 0, &Box);
+
+	status = sStage->lpVtbl->QueryInterface(sStage, &IID_IDXGISurface, (void**)&surf);
+
+	if (FAILED(status))
+	{
+		WLog_ERR(TAG, "Failed to QI staging surface");
+		exit(1);
+		return 1;
+	}
+
+	surf->lpVtbl->Map(surf, &mappedRect, DXGI_MAP_READ);
+
+	if (FAILED(status))
+	{
+		WLog_ERR(TAG, "Failed to map staging surface");
+		exit(1);
+		return 1;
+	}
+
+	*data = mappedRect.pBits;
+	*pitch = mappedRect.Pitch;
+
+	return 0;
+}
+
+int wf_dxgi_releasePixelData(wfInfo* wfi)
+{
+	HRESULT status;
+
+	surf->lpVtbl->Unmap(surf);
+	surf->lpVtbl->Release(surf);
+	surf = NULL;
+	sStage->lpVtbl->Release(sStage);
+	sStage = NULL;
+
+	status = gOutputDuplication->lpVtbl->ReleaseFrame(gOutputDuplication);
+
+	if (FAILED(status))
+	{
+		WLog_ERR(TAG, "Failed to release frame");
+		return 1;
+	}
+
+	wfi->framesWaiting = 0;
+
+	return 0;
+}
+
+int wf_dxgi_getInvalidRegion(RECT* invalid)
+{
+	HRESULT status;
+	UINT dirty;
+	UINT BufSize;
+	RECT* pRect;
+	BYTE* DirtyRects;
+	UINT DataBufferSize = 0;
+	BYTE* DataBuffer = NULL;
+
+	if (FrameInfo.AccumulatedFrames == 0)
+	{
+		return 1;
+	}
+
+	if (FrameInfo.TotalMetadataBufferSize)
+	{
+
+		if (FrameInfo.TotalMetadataBufferSize > DataBufferSize)
+		{
+			if (DataBuffer)
+			{
+				free(DataBuffer);
+				DataBuffer = NULL;
+			}
+
+			DataBuffer = (BYTE*)malloc(FrameInfo.TotalMetadataBufferSize);
+
+			if (!DataBuffer)
+			{
+				DataBufferSize = 0;
+				WLog_ERR(TAG, "Failed to allocate memory for metadata");
+				exit(1);
+			}
+
+			DataBufferSize = FrameInfo.TotalMetadataBufferSize;
+		}
+
+		BufSize = FrameInfo.TotalMetadataBufferSize;
+
+		status = gOutputDuplication->lpVtbl->GetFrameMoveRects(
+		    gOutputDuplication, BufSize, (DXGI_OUTDUPL_MOVE_RECT*)DataBuffer, &BufSize);
+
+		if (FAILED(status))
+		{
+			WLog_ERR(TAG, "Failed to get frame move rects");
+			return 1;
+		}
+
+		DirtyRects = DataBuffer + BufSize;
+		BufSize = FrameInfo.TotalMetadataBufferSize - BufSize;
+
+		status = gOutputDuplication->lpVtbl->GetFrameDirtyRects(gOutputDuplication, BufSize,
+		                                                        (RECT*)DirtyRects, &BufSize);
+
+		if (FAILED(status))
+		{
+			WLog_ERR(TAG, "Failed to get frame dirty rects");
+			return 1;
+		}
+		dirty = BufSize / sizeof(RECT);
+
+		pRect = (RECT*)DirtyRects;
+
+		for (UINT i = 0; i < dirty; ++i)
+		{
+			UnionRect(invalid, invalid, pRect);
+			++pRect;
+		}
+	}
+
+	return 0;
+}
+
+#endif

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_dxgi.h

@@ -0,0 +1,41 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_WIN_DXGI_H
+#define FREERDP_SERVER_WIN_DXGI_H
+
+#include "wf_interface.h"
+
+int wf_dxgi_init(wfInfo* context);
+
+int wf_dxgi_createDevice(wfInfo* context);
+
+int wf_dxgi_getDuplication(wfInfo* context);
+
+int wf_dxgi_cleanup(wfInfo* context);
+
+int wf_dxgi_nextFrame(wfInfo* context, UINT timeout);
+
+int wf_dxgi_getPixelData(wfInfo* context, BYTE** data, int* pitch, RECT* invalid);
+
+int wf_dxgi_releasePixelData(wfInfo* context);
+
+int wf_dxgi_getInvalidRegion(RECT* invalid);
+
+#endif /* FREERDP_SERVER_WIN_DXGI_H */

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_info.c

@@ -0,0 +1,402 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Client
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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/config.h>
+
+#include <stdlib.h>
+
+#include <freerdp/build-config.h>
+
+#include <winpr/tchar.h>
+#include <winpr/windows.h>
+
+#include "wf_info.h"
+#include "wf_update.h"
+#include "wf_mirage.h"
+#include "wf_dxgi.h"
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("windows")
+
+#define SERVER_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING "\\Server"
+
+static wfInfo* wfInfoInstance = NULL;
+static int _IDcount = 0;
+
+BOOL wf_info_lock(wfInfo* wfi)
+{
+	DWORD dRes;
+	dRes = WaitForSingleObject(wfi->mutex, INFINITE);
+
+	switch (dRes)
+	{
+		case WAIT_ABANDONED:
+		case WAIT_OBJECT_0:
+			return TRUE;
+
+		case WAIT_TIMEOUT:
+			return FALSE;
+
+		case WAIT_FAILED:
+			WLog_ERR(TAG, "wf_info_lock failed with 0x%08lX", GetLastError());
+			return FALSE;
+	}
+
+	return FALSE;
+}
+
+BOOL wf_info_try_lock(wfInfo* wfi, DWORD dwMilliseconds)
+{
+	DWORD dRes;
+	dRes = WaitForSingleObject(wfi->mutex, dwMilliseconds);
+
+	switch (dRes)
+	{
+		case WAIT_ABANDONED:
+		case WAIT_OBJECT_0:
+			return TRUE;
+
+		case WAIT_TIMEOUT:
+			return FALSE;
+
+		case WAIT_FAILED:
+			WLog_ERR(TAG, "wf_info_try_lock failed with 0x%08lX", GetLastError());
+			return FALSE;
+	}
+
+	return FALSE;
+}
+
+BOOL wf_info_unlock(wfInfo* wfi)
+{
+	if (!ReleaseMutex(wfi->mutex))
+	{
+		WLog_ERR(TAG, "wf_info_unlock failed with 0x%08lX", GetLastError());
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+wfInfo* wf_info_init()
+{
+	wfInfo* wfi;
+	wfi = (wfInfo*)calloc(1, sizeof(wfInfo));
+
+	if (wfi != NULL)
+	{
+		HKEY hKey;
+		LONG status;
+		DWORD dwType;
+		DWORD dwSize;
+		DWORD dwValue;
+		wfi->mutex = CreateMutex(NULL, FALSE, NULL);
+
+		if (wfi->mutex == NULL)
+		{
+			WLog_ERR(TAG, "CreateMutex error: %lu", GetLastError());
+			free(wfi);
+			return NULL;
+		}
+
+		wfi->updateSemaphore = CreateSemaphore(NULL, 0, 32, NULL);
+
+		if (!wfi->updateSemaphore)
+		{
+			WLog_ERR(TAG, "CreateSemaphore error: %lu", GetLastError());
+			(void)CloseHandle(wfi->mutex);
+			free(wfi);
+			return NULL;
+		}
+
+		wfi->updateThread = CreateThread(NULL, 0, wf_update_thread, wfi, CREATE_SUSPENDED, NULL);
+
+		if (!wfi->updateThread)
+		{
+			WLog_ERR(TAG, "Failed to create update thread");
+			(void)CloseHandle(wfi->mutex);
+			(void)CloseHandle(wfi->updateSemaphore);
+			free(wfi);
+			return NULL;
+		}
+
+		wfi->peers =
+		    (freerdp_peer**)calloc(FREERDP_SERVER_WIN_INFO_MAXPEERS, sizeof(freerdp_peer*));
+
+		if (!wfi->peers)
+		{
+			WLog_ERR(TAG, "Failed to allocate memory for peer");
+			(void)CloseHandle(wfi->mutex);
+			(void)CloseHandle(wfi->updateSemaphore);
+			(void)CloseHandle(wfi->updateThread);
+			free(wfi);
+			return NULL;
+		}
+
+		// Set FPS
+		wfi->framesPerSecond = FREERDP_SERVER_WIN_INFO_DEFAULT_FPS;
+		status =
+		    RegOpenKeyExA(HKEY_LOCAL_MACHINE, SERVER_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
+
+		if (status == ERROR_SUCCESS)
+		{
+			if (RegQueryValueEx(hKey, _T("FramesPerSecond"), NULL, &dwType, (BYTE*)&dwValue,
+			                    &dwSize) == ERROR_SUCCESS)
+				wfi->framesPerSecond = dwValue;
+		}
+
+		RegCloseKey(hKey);
+		// Set input toggle
+		wfi->input_disabled = FALSE;
+		status =
+		    RegOpenKeyExA(HKEY_LOCAL_MACHINE, SERVER_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
+
+		if (status == ERROR_SUCCESS)
+		{
+			if (RegQueryValueEx(hKey, _T("DisableInput"), NULL, &dwType, (BYTE*)&dwValue,
+			                    &dwSize) == ERROR_SUCCESS)
+			{
+				if (dwValue != 0)
+					wfi->input_disabled = TRUE;
+			}
+		}
+
+		RegCloseKey(hKey);
+	}
+
+	return wfi;
+}
+
+wfInfo* wf_info_get_instance()
+{
+	if (wfInfoInstance == NULL)
+		wfInfoInstance = wf_info_init();
+
+	return wfInfoInstance;
+}
+
+BOOL wf_info_peer_register(wfInfo* wfi, wfPeerContext* context)
+{
+	int peerId = 0;
+
+	if (!wfi || !context)
+		return FALSE;
+
+	if (!wf_info_lock(wfi))
+		return FALSE;
+
+	if (wfi->peerCount == FREERDP_SERVER_WIN_INFO_MAXPEERS)
+		goto fail_peer_count;
+
+	context->info = wfi;
+
+	if (!(context->updateEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
+		goto fail_update_event;
+
+	// get the offset of the top left corner of selected screen
+	EnumDisplayMonitors(NULL, NULL, wf_info_monEnumCB, 0);
+	_IDcount = 0;
+#ifdef WITH_DXGI_1_2
+
+	if (wfi->peerCount == 0)
+		if (wf_dxgi_init(wfi) != 0)
+			goto fail_driver_init;
+
+#else
+
+	if (!wf_mirror_driver_activate(wfi))
+		goto fail_driver_init;
+
+#endif
+
+	// look through the array of peers until an empty slot
+	for (int i = 0; i < FREERDP_SERVER_WIN_INFO_MAXPEERS; ++i)
+	{
+		// empty index will be our peer id
+		if (wfi->peers[i] == NULL)
+		{
+			peerId = i;
+			break;
+		}
+	}
+
+	wfi->peers[peerId] = ((rdpContext*)context)->peer;
+	wfi->peers[peerId]->pId = peerId;
+	wfi->peerCount++;
+	WLog_INFO(TAG, "Registering Peer: id=%d #=%d", peerId, wfi->peerCount);
+	wf_info_unlock(wfi);
+	wfreerdp_server_peer_callback_event(peerId, FREERDP_SERVER_WIN_SRV_CALLBACK_EVENT_CONNECT);
+	return TRUE;
+fail_driver_init:
+	(void)CloseHandle(context->updateEvent);
+	context->updateEvent = NULL;
+fail_update_event:
+fail_peer_count:
+	context->socketClose = TRUE;
+	wf_info_unlock(wfi);
+	return FALSE;
+}
+
+void wf_info_peer_unregister(wfInfo* wfi, wfPeerContext* context)
+{
+	if (wf_info_lock(wfi))
+	{
+		int peerId;
+		peerId = ((rdpContext*)context)->peer->pId;
+		wfi->peers[peerId] = NULL;
+		wfi->peerCount--;
+		(void)CloseHandle(context->updateEvent);
+		WLog_INFO(TAG, "Unregistering Peer: id=%d, #=%d", peerId, wfi->peerCount);
+#ifdef WITH_DXGI_1_2
+
+		if (wfi->peerCount == 0)
+			wf_dxgi_cleanup(wfi);
+
+#endif
+		wf_info_unlock(wfi);
+		wfreerdp_server_peer_callback_event(peerId,
+		                                    FREERDP_SERVER_WIN_SRV_CALLBACK_EVENT_DISCONNECT);
+	}
+}
+
+BOOL wf_info_have_updates(wfInfo* wfi)
+{
+#ifdef WITH_DXGI_1_2
+
+	if (wfi->framesWaiting == 0)
+		return FALSE;
+
+#else
+
+	if (wfi->nextUpdate == wfi->lastUpdate)
+		return FALSE;
+
+#endif
+	return TRUE;
+}
+
+void wf_info_update_changes(wfInfo* wfi)
+{
+#ifdef WITH_DXGI_1_2
+	wf_dxgi_nextFrame(wfi, wfi->framesPerSecond * 1000);
+#else
+	GETCHANGESBUF* buf;
+	buf = (GETCHANGESBUF*)wfi->changeBuffer;
+	wfi->nextUpdate = buf->buffer->counter;
+#endif
+}
+
+void wf_info_find_invalid_region(wfInfo* wfi)
+{
+#ifdef WITH_DXGI_1_2
+	wf_dxgi_getInvalidRegion(&wfi->invalid);
+#else
+	GETCHANGESBUF* buf;
+	buf = (GETCHANGESBUF*)wfi->changeBuffer;
+
+	for (ULONG i = wfi->lastUpdate; i != wfi->nextUpdate; i = (i + 1) % MAXCHANGES_BUF)
+	{
+		LPRECT lpR = &buf->buffer->pointrect[i].rect;
+
+		// need to make sure we only get updates from the selected screen
+		if ((lpR->left >= wfi->servscreen_xoffset) &&
+		    (lpR->right <= (wfi->servscreen_xoffset + wfi->servscreen_width)) &&
+		    (lpR->top >= wfi->servscreen_yoffset) &&
+		    (lpR->bottom <= (wfi->servscreen_yoffset + wfi->servscreen_height)))
+		{
+			UnionRect(&wfi->invalid, &wfi->invalid, lpR);
+		}
+		else
+		{
+			continue;
+		}
+	}
+
+#endif
+
+	if (wfi->invalid.left < 0)
+		wfi->invalid.left = 0;
+
+	if (wfi->invalid.top < 0)
+		wfi->invalid.top = 0;
+
+	if (wfi->invalid.right >= wfi->servscreen_width)
+		wfi->invalid.right = wfi->servscreen_width - 1;
+
+	if (wfi->invalid.bottom >= wfi->servscreen_height)
+		wfi->invalid.bottom = wfi->servscreen_height - 1;
+
+	// WLog_DBG(TAG, "invalid region: (%"PRId32", %"PRId32"), (%"PRId32", %"PRId32")",
+	// wfi->invalid.left, wfi->invalid.top, wfi->invalid.right, wfi->invalid.bottom);
+}
+
+void wf_info_clear_invalid_region(wfInfo* wfi)
+{
+	wfi->lastUpdate = wfi->nextUpdate;
+	SetRectEmpty(&wfi->invalid);
+}
+
+void wf_info_invalidate_full_screen(wfInfo* wfi)
+{
+	SetRect(&wfi->invalid, 0, 0, wfi->servscreen_width, wfi->servscreen_height);
+}
+
+BOOL wf_info_have_invalid_region(wfInfo* wfi)
+{
+	return IsRectEmpty(&wfi->invalid);
+}
+
+void wf_info_getScreenData(wfInfo* wfi, long* width, long* height, BYTE** pBits, int* pitch)
+{
+	*width = (wfi->invalid.right - wfi->invalid.left);
+	*height = (wfi->invalid.bottom - wfi->invalid.top);
+#ifdef WITH_DXGI_1_2
+	wf_dxgi_getPixelData(wfi, pBits, pitch, &wfi->invalid);
+#else
+	{
+		long offset;
+		GETCHANGESBUF* changes;
+		changes = (GETCHANGESBUF*)wfi->changeBuffer;
+		*width += 1;
+		*height += 1;
+		offset = (4 * wfi->invalid.left) + (wfi->invalid.top * wfi->virtscreen_width * 4);
+		*pBits = ((BYTE*)(changes->Userbuffer)) + offset;
+		*pitch = wfi->virtscreen_width * 4;
+	}
+#endif
+}
+
+BOOL CALLBACK wf_info_monEnumCB(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor,
+                                LPARAM dwData)
+{
+	wfInfo* wfi;
+	wfi = wf_info_get_instance();
+
+	if (!wfi)
+		return FALSE;
+
+	if (_IDcount == wfi->screenID)
+	{
+		wfi->servscreen_xoffset = lprcMonitor->left;
+		wfi->servscreen_yoffset = lprcMonitor->top;
+	}
+
+	_IDcount++;
+	return TRUE;
+}

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_info.h

@@ -0,0 +1,46 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_WIN_INFO_H
+#define FREERDP_SERVER_WIN_INFO_H
+
+#include "wf_interface.h"
+
+#define FREERDP_SERVER_WIN_INFO_DEFAULT_FPS 24
+#define FREERDP_SERVER_WIN_INFO_MAXPEERS 32
+
+BOOL wf_info_lock(wfInfo* wfi);
+BOOL wf_info_try_lock(wfInfo* wfi, DWORD dwMilliseconds);
+BOOL wf_info_unlock(wfInfo* wfi);
+
+wfInfo* wf_info_get_instance(void);
+BOOL wf_info_peer_register(wfInfo* wfi, wfPeerContext* context);
+void wf_info_peer_unregister(wfInfo* wfi, wfPeerContext* context);
+
+BOOL wf_info_have_updates(wfInfo* wfi);
+void wf_info_update_changes(wfInfo* wfi);
+void wf_info_find_invalid_region(wfInfo* wfi);
+void wf_info_clear_invalid_region(wfInfo* wfi);
+void wf_info_invalidate_full_screen(wfInfo* wfi);
+BOOL wf_info_have_invalid_region(wfInfo* wfi);
+void wf_info_getScreenData(wfInfo* wfi, long* width, long* height, BYTE** pBits, int* pitch);
+BOOL CALLBACK wf_info_monEnumCB(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor,
+                                LPARAM dwData);
+
+#endif /* FREERDP_SERVER_WIN_INFO_H */

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_input.c

@@ -0,0 +1,223 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ *
+ * 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/config.h>
+
+#include <winpr/windows.h>
+
+#include "wf_input.h"
+#include "wf_info.h"
+
+BOOL wf_peer_keyboard_event(rdpInput* input, UINT16 flags, UINT8 code)
+{
+	INPUT keyboard_event;
+	WINPR_UNUSED(input);
+	keyboard_event.type = INPUT_KEYBOARD;
+	keyboard_event.u.ki.wVk = 0;
+	keyboard_event.u.ki.wScan = code;
+	keyboard_event.u.ki.dwFlags = KEYEVENTF_SCANCODE;
+	keyboard_event.u.ki.dwExtraInfo = 0;
+	keyboard_event.u.ki.time = 0;
+
+	if (flags & KBD_FLAGS_RELEASE)
+		keyboard_event.u.ki.dwFlags |= KEYEVENTF_KEYUP;
+
+	if (flags & KBD_FLAGS_EXTENDED)
+		keyboard_event.u.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
+
+	SendInput(1, &keyboard_event, sizeof(INPUT));
+	return TRUE;
+}
+
+BOOL wf_peer_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+{
+	INPUT keyboard_event;
+	WINPR_UNUSED(input);
+	keyboard_event.type = INPUT_KEYBOARD;
+	keyboard_event.u.ki.wVk = 0;
+	keyboard_event.u.ki.wScan = code;
+	keyboard_event.u.ki.dwFlags = KEYEVENTF_UNICODE;
+	keyboard_event.u.ki.dwExtraInfo = 0;
+	keyboard_event.u.ki.time = 0;
+
+	if (flags & KBD_FLAGS_RELEASE)
+		keyboard_event.u.ki.dwFlags |= KEYEVENTF_KEYUP;
+
+	SendInput(1, &keyboard_event, sizeof(INPUT));
+	return TRUE;
+}
+
+BOOL wf_peer_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+{
+	INPUT mouse_event = { 0 };
+	float width, height;
+	WINPR_UNUSED(input);
+
+	WINPR_ASSERT(input);
+	mouse_event.type = INPUT_MOUSE;
+
+	if (flags & PTR_FLAGS_WHEEL)
+	{
+		mouse_event.u.mi.dwFlags = MOUSEEVENTF_WHEEL;
+		mouse_event.u.mi.mouseData = flags & WheelRotationMask;
+
+		if (flags & PTR_FLAGS_WHEEL_NEGATIVE)
+			mouse_event.u.mi.mouseData *= -1;
+
+		SendInput(1, &mouse_event, sizeof(INPUT));
+	}
+	else
+	{
+		wfInfo* wfi;
+		wfi = wf_info_get_instance();
+
+		if (!wfi)
+			return FALSE;
+
+		// width and height of primary screen (even in multimon setups
+		width = (float)GetSystemMetrics(SM_CXSCREEN);
+		height = (float)GetSystemMetrics(SM_CYSCREEN);
+		x += wfi->servscreen_xoffset;
+		y += wfi->servscreen_yoffset;
+		mouse_event.u.mi.dx = (LONG)((float)x * (65535.0f / width));
+		mouse_event.u.mi.dy = (LONG)((float)y * (65535.0f / height));
+		mouse_event.u.mi.dwFlags = MOUSEEVENTF_ABSOLUTE;
+
+		if (flags & PTR_FLAGS_MOVE)
+		{
+			mouse_event.u.mi.dwFlags |= MOUSEEVENTF_MOVE;
+			SendInput(1, &mouse_event, sizeof(INPUT));
+		}
+
+		mouse_event.u.mi.dwFlags = MOUSEEVENTF_ABSOLUTE;
+
+		if (flags & PTR_FLAGS_BUTTON1)
+		{
+			if (flags & PTR_FLAGS_DOWN)
+				mouse_event.u.mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
+			else
+				mouse_event.u.mi.dwFlags |= MOUSEEVENTF_LEFTUP;
+
+			SendInput(1, &mouse_event, sizeof(INPUT));
+		}
+		else if (flags & PTR_FLAGS_BUTTON2)
+		{
+			if (flags & PTR_FLAGS_DOWN)
+				mouse_event.u.mi.dwFlags |= MOUSEEVENTF_RIGHTDOWN;
+			else
+				mouse_event.u.mi.dwFlags |= MOUSEEVENTF_RIGHTUP;
+
+			SendInput(1, &mouse_event, sizeof(INPUT));
+		}
+		else if (flags & PTR_FLAGS_BUTTON3)
+		{
+			if (flags & PTR_FLAGS_DOWN)
+				mouse_event.u.mi.dwFlags |= MOUSEEVENTF_MIDDLEDOWN;
+			else
+				mouse_event.u.mi.dwFlags |= MOUSEEVENTF_MIDDLEUP;
+
+			SendInput(1, &mouse_event, sizeof(INPUT));
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL wf_peer_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+{
+	if ((flags & PTR_XFLAGS_BUTTON1) || (flags & PTR_XFLAGS_BUTTON2))
+	{
+		INPUT mouse_event = { 0 };
+		mouse_event.type = INPUT_MOUSE;
+
+		if (flags & PTR_FLAGS_MOVE)
+		{
+			float width, height;
+			wfInfo* wfi;
+			wfi = wf_info_get_instance();
+
+			if (!wfi)
+				return FALSE;
+
+			// width and height of primary screen (even in multimon setups
+			width = (float)GetSystemMetrics(SM_CXSCREEN);
+			height = (float)GetSystemMetrics(SM_CYSCREEN);
+			x += wfi->servscreen_xoffset;
+			y += wfi->servscreen_yoffset;
+			mouse_event.u.mi.dx = (LONG)((float)x * (65535.0f / width));
+			mouse_event.u.mi.dy = (LONG)((float)y * (65535.0f / height));
+			mouse_event.u.mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE;
+			SendInput(1, &mouse_event, sizeof(INPUT));
+		}
+
+		mouse_event.u.mi.dx = mouse_event.u.mi.dy = mouse_event.u.mi.dwFlags = 0;
+
+		if (flags & PTR_XFLAGS_DOWN)
+			mouse_event.u.mi.dwFlags |= MOUSEEVENTF_XDOWN;
+		else
+			mouse_event.u.mi.dwFlags |= MOUSEEVENTF_XUP;
+
+		if (flags & PTR_XFLAGS_BUTTON1)
+			mouse_event.u.mi.mouseData = XBUTTON1;
+		else if (flags & PTR_XFLAGS_BUTTON2)
+			mouse_event.u.mi.mouseData = XBUTTON2;
+
+		SendInput(1, &mouse_event, sizeof(INPUT));
+	}
+	else
+	{
+		wf_peer_mouse_event(input, flags, x, y);
+	}
+
+	return TRUE;
+}
+
+BOOL wf_peer_keyboard_event_dummy(rdpInput* input, UINT16 flags, UINT8 code)
+{
+	WINPR_UNUSED(input);
+	WINPR_UNUSED(flags);
+	WINPR_UNUSED(code);
+	return TRUE;
+}
+
+BOOL wf_peer_unicode_keyboard_event_dummy(rdpInput* input, UINT16 flags, UINT16 code)
+{
+	WINPR_UNUSED(input);
+	WINPR_UNUSED(flags);
+	WINPR_UNUSED(code);
+	return TRUE;
+}
+
+BOOL wf_peer_mouse_event_dummy(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+{
+	WINPR_UNUSED(input);
+	WINPR_UNUSED(flags);
+	WINPR_UNUSED(x);
+	WINPR_UNUSED(y);
+	return TRUE;
+}
+
+BOOL wf_peer_extended_mouse_event_dummy(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+{
+	WINPR_UNUSED(input);
+	WINPR_UNUSED(flags);
+	WINPR_UNUSED(x);
+	WINPR_UNUSED(y);
+	return TRUE;
+}

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_input.h

@@ -0,0 +1,36 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_WIN_INPUT_H
+#define FREERDP_SERVER_WIN_INPUT_H
+
+#include "wf_interface.h"
+
+BOOL wf_peer_keyboard_event(rdpInput* input, UINT16 flags, UINT8 code);
+BOOL wf_peer_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
+BOOL wf_peer_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+BOOL wf_peer_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+
+// dummy versions
+BOOL wf_peer_keyboard_event_dummy(rdpInput* input, UINT16 flags, UINT8 code);
+BOOL wf_peer_unicode_keyboard_event_dummy(rdpInput* input, UINT16 flags, UINT16 code);
+BOOL wf_peer_mouse_event_dummy(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+BOOL wf_peer_extended_mouse_event_dummy(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+
+#endif /* FREERDP_SERVER_WIN_INPUT_H */

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_interface.c

@@ -0,0 +1,341 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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/config.h>
+
+#include <winpr/tchar.h>
+#include <winpr/windows.h>
+#include <winpr/winsock.h>
+#include <winpr/assert.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/listener.h>
+#include <freerdp/constants.h>
+#include <freerdp/channels/wtsvc.h>
+#include <freerdp/channels/channels.h>
+#include <freerdp/build-config.h>
+
+#include "wf_peer.h"
+#include "wf_settings.h"
+#include "wf_info.h"
+
+#include "wf_interface.h"
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("windows")
+
+#define SERVER_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING "\\Server"
+
+static cbCallback cbEvent = NULL;
+
+int get_screen_info(int id, _TCHAR* name, size_t length, int* width, int* height, int* bpp)
+{
+	DISPLAY_DEVICE dd = { 0 };
+
+	dd.cb = sizeof(DISPLAY_DEVICE);
+
+	if (EnumDisplayDevices(NULL, id, &dd, 0) != 0)
+	{
+		HDC dc;
+
+		if (name != NULL)
+			_stprintf_s(name, length, _T("%s (%s)"), dd.DeviceName, dd.DeviceString);
+
+		dc = CreateDC(dd.DeviceName, NULL, NULL, NULL);
+		*width = GetDeviceCaps(dc, HORZRES);
+		*height = GetDeviceCaps(dc, VERTRES);
+		*bpp = GetDeviceCaps(dc, BITSPIXEL);
+		// ReleaseDC(NULL, dc);
+		DeleteDC(dc);
+	}
+	else
+	{
+		return 0;
+	}
+
+	return 1;
+}
+
+void set_screen_id(int id)
+{
+	wfInfo* wfi;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+		return;
+	wfi->screenID = id;
+
+	return;
+}
+
+static DWORD WINAPI wf_server_main_loop(LPVOID lpParam)
+{
+	freerdp_listener* instance;
+	wfInfo* wfi;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+	{
+		WLog_ERR(TAG, "Failed to get instance");
+		return -1;
+	}
+
+	wfi->force_all_disconnect = FALSE;
+
+	instance = (freerdp_listener*)lpParam;
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->GetEventHandles);
+	WINPR_ASSERT(instance->CheckFileDescriptor);
+
+	while (wfi->force_all_disconnect == FALSE)
+	{
+		DWORD status;
+		HANDLE handles[MAXIMUM_WAIT_OBJECTS] = { 0 };
+		DWORD count = instance->GetEventHandles(instance, handles, ARRAYSIZE(handles));
+
+		if (count == 0)
+		{
+			WLog_ERR(TAG, "Failed to get FreeRDP file descriptor");
+			break;
+		}
+
+		status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
+		if (status == WAIT_FAILED)
+		{
+			WLog_ERR(TAG, "WaitForMultipleObjects failed");
+			break;
+		}
+
+		if (instance->CheckFileDescriptor(instance) != TRUE)
+		{
+			WLog_ERR(TAG, "Failed to check FreeRDP file descriptor");
+			break;
+		}
+	}
+
+	WLog_INFO(TAG, "wf_server_main_loop terminating");
+	instance->Close(instance);
+
+	return 0;
+}
+
+BOOL wfreerdp_server_start(wfServer* server)
+{
+	freerdp_listener* instance;
+
+	server->instance = freerdp_listener_new();
+	server->instance->PeerAccepted = wf_peer_accepted;
+	instance = server->instance;
+
+	wf_settings_read_dword(HKEY_LOCAL_MACHINE, SERVER_KEY, _T("DefaultPort"), &server->port);
+
+	if (!instance->Open(instance, NULL, (UINT16)server->port))
+		return FALSE;
+
+	if (!(server->thread = CreateThread(NULL, 0, wf_server_main_loop, (void*)instance, 0, NULL)))
+		return FALSE;
+
+	return TRUE;
+}
+
+BOOL wfreerdp_server_stop(wfServer* server)
+{
+	wfInfo* wfi;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+		return FALSE;
+	WLog_INFO(TAG, "Stopping server");
+	wfi->force_all_disconnect = TRUE;
+	server->instance->Close(server->instance);
+	return TRUE;
+}
+
+wfServer* wfreerdp_server_new()
+{
+	WSADATA wsaData;
+	wfServer* server;
+
+	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
+		return NULL;
+
+	server = (wfServer*)calloc(1, sizeof(wfServer));
+
+	if (server)
+	{
+		server->port = 3389;
+	}
+
+	WTSRegisterWtsApiFunctionTable(FreeRDP_InitWtsApi());
+
+	cbEvent = NULL;
+
+	return server;
+}
+
+void wfreerdp_server_free(wfServer* server)
+{
+	free(server);
+
+	WSACleanup();
+}
+
+BOOL wfreerdp_server_is_running(wfServer* server)
+{
+	DWORD tStatus;
+	BOOL bRet;
+
+	bRet = GetExitCodeThread(server->thread, &tStatus);
+	if (bRet == 0)
+	{
+		WLog_ERR(TAG, "Error in call to GetExitCodeThread");
+		return FALSE;
+	}
+
+	if (tStatus == STILL_ACTIVE)
+		return TRUE;
+	return FALSE;
+}
+
+UINT32 wfreerdp_server_num_peers()
+{
+	wfInfo* wfi;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+		return -1;
+	return wfi->peerCount;
+}
+
+UINT32 wfreerdp_server_get_peer_hostname(int pId, wchar_t* dstStr)
+{
+	wfInfo* wfi;
+	freerdp_peer* peer;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+		return 0;
+	peer = wfi->peers[pId];
+
+	if (peer)
+	{
+		UINT32 sLen;
+
+		sLen = strnlen_s(peer->hostname, 50);
+		swprintf(dstStr, 50, L"%hs", peer->hostname);
+		return sLen;
+	}
+	else
+	{
+		WLog_WARN(TAG, "nonexistent peer id=%d", pId);
+		return 0;
+	}
+}
+
+BOOL wfreerdp_server_peer_is_local(int pId)
+{
+	wfInfo* wfi;
+	freerdp_peer* peer;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+		return FALSE;
+	peer = wfi->peers[pId];
+
+	if (peer)
+	{
+		return peer->local;
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+BOOL wfreerdp_server_peer_is_connected(int pId)
+{
+	wfInfo* wfi;
+	freerdp_peer* peer;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+		return FALSE;
+	peer = wfi->peers[pId];
+
+	if (peer)
+	{
+		return peer->connected;
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+BOOL wfreerdp_server_peer_is_activated(int pId)
+{
+	wfInfo* wfi;
+	freerdp_peer* peer;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+		return FALSE;
+	peer = wfi->peers[pId];
+
+	if (peer)
+	{
+		return peer->activated;
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+BOOL wfreerdp_server_peer_is_authenticated(int pId)
+{
+	wfInfo* wfi;
+	freerdp_peer* peer;
+
+	wfi = wf_info_get_instance();
+	if (!wfi)
+		return FALSE;
+	peer = wfi->peers[pId];
+
+	if (peer)
+	{
+		return peer->authenticated;
+	}
+	else
+	{
+		return FALSE;
+	}
+}
+
+void wfreerdp_server_register_callback_event(cbCallback cb)
+{
+	cbEvent = cb;
+}
+
+void wfreerdp_server_peer_callback_event(int pId, UINT32 eType)
+{
+	if (cbEvent)
+		cbEvent(pId, eType);
+}

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_interface.h

@@ -0,0 +1,140 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Client
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_WIN_INTERFACE_H
+#define FREERDP_SERVER_WIN_INTERFACE_H
+
+#include <winpr/windows.h>
+
+#include <freerdp/api.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/listener.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/codec/rfx.h>
+
+#include <freerdp/server/rdpsnd.h>
+
+#if _WIN32_WINNT >= 0x0602
+#define WITH_DXGI_1_2 1
+#endif
+
+#define FREERDP_SERVER_WIN_SRV_CALLBACK_EVENT_CONNECT 1
+#define FREERDP_SERVER_WIN_SRV_CALLBACK_EVENT_DISCONNECT 2
+#define FREERDP_SERVER_WIN_SRV_CALLBACK_EVENT_ACTIVATE 4
+#define FREERDP_SERVER_WIN_SRV_CALLBACK_EVENT_AUTH 8
+
+typedef struct wf_info wfInfo;
+typedef struct wf_peer_context wfPeerContext;
+
+struct wf_info
+{
+	wStream* s;
+
+	// screen and monitor info
+	int screenID;
+	int virtscreen_width;
+	int virtscreen_height;
+	int servscreen_width;
+	int servscreen_height;
+	int servscreen_xoffset;
+	int servscreen_yoffset;
+
+	int frame_idx;
+	int bitsPerPixel;
+	HDC driverDC;
+	int peerCount;
+	int activePeerCount;
+	void* changeBuffer;
+	int framesPerSecond;
+	LPTSTR deviceKey;
+	TCHAR deviceName[32];
+	freerdp_peer** peers;
+	BOOL mirrorDriverActive;
+	UINT framesWaiting;
+
+	HANDLE snd_mutex;
+	BOOL snd_stop;
+	AUDIO_FORMAT* agreed_format;
+
+	RECT invalid;
+	HANDLE mutex;
+	BOOL updatePending;
+	HANDLE updateEvent;
+	HANDLE updateThread;
+	HANDLE updateSemaphore;
+	RFX_CONTEXT* rfx_context;
+	unsigned long lastUpdate;
+	unsigned long nextUpdate;
+	SURFACE_BITS_COMMAND cmd;
+
+	BOOL input_disabled;
+	BOOL force_all_disconnect;
+};
+
+struct wf_peer_context
+{
+	rdpContext _p;
+
+	wfInfo* info;
+	int frame_idx;
+	HANDLE updateEvent;
+	BOOL socketClose;
+	HANDLE socketEvent;
+	HANDLE socketThread;
+	HANDLE socketSemaphore;
+
+	HANDLE vcm;
+	RdpsndServerContext* rdpsnd;
+};
+
+struct wf_server
+{
+	DWORD port;
+	HANDLE thread;
+	freerdp_listener* instance;
+};
+typedef struct wf_server wfServer;
+
+typedef void(__stdcall* cbCallback)(int, UINT32);
+
+FREERDP_API int get_screen_info(int id, _TCHAR* name, size_t length, int* w, int* h, int* b);
+FREERDP_API void set_screen_id(int id);
+
+FREERDP_API BOOL wfreerdp_server_start(wfServer* server);
+FREERDP_API BOOL wfreerdp_server_stop(wfServer* server);
+
+FREERDP_API wfServer* wfreerdp_server_new(void);
+FREERDP_API void wfreerdp_server_free(wfServer* server);
+
+FREERDP_API BOOL wfreerdp_server_is_running(wfServer* server);
+
+FREERDP_API UINT32 wfreerdp_server_num_peers(void);
+FREERDP_API UINT32 wfreerdp_server_get_peer_hostname(int pId, wchar_t* dstStr);
+FREERDP_API BOOL wfreerdp_server_peer_is_local(int pId);
+FREERDP_API BOOL wfreerdp_server_peer_is_connected(int pId);
+FREERDP_API BOOL wfreerdp_server_peer_is_activated(int pId);
+FREERDP_API BOOL wfreerdp_server_peer_is_authenticated(int pId);
+
+FREERDP_API void wfreerdp_server_register_callback_event(cbCallback cb);
+
+void wfreerdp_server_peer_callback_event(int pId, UINT32 eType);
+
+#endif /* FREERDP_SERVER_WIN_INTERFACE_H */

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_mirage.c

@@ -0,0 +1,361 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2012-2013 Corey Clayton <[email protected]>
+ *
+ * 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 <winpr/tchar.h>
+#include <winpr/windows.h>
+
+#include "wf_mirage.h"
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("Windows.mirror")
+
+#define DEVICE_KEY_PREFIX _T("\\Registry\\Machine\\")
+/*
+This function will iterate over the loaded display devices until it finds
+the mirror device we want to load. If found, it will then copy the registry
+key corresponding to the device to the wfi and returns TRUE. Otherwise
+the function returns FALSE.
+*/
+BOOL wf_mirror_driver_find_display_device(wfInfo* wfi)
+{
+	BOOL result;
+	BOOL devFound;
+	DWORD deviceNumber;
+	DISPLAY_DEVICE deviceInfo;
+	devFound = FALSE;
+	deviceNumber = 0;
+	deviceInfo.cb = sizeof(deviceInfo);
+
+	while (result = EnumDisplayDevices(NULL, deviceNumber, &deviceInfo, 0))
+	{
+		if (_tcscmp(deviceInfo.DeviceString, _T("Mirage Driver")) == 0)
+		{
+			int deviceKeyLength;
+			int deviceKeyPrefixLength;
+			deviceKeyPrefixLength = _tcslen(DEVICE_KEY_PREFIX);
+
+			if (_tcsnicmp(deviceInfo.DeviceKey, DEVICE_KEY_PREFIX, deviceKeyPrefixLength) == 0)
+			{
+				deviceKeyLength = _tcslen(deviceInfo.DeviceKey) - deviceKeyPrefixLength;
+				wfi->deviceKey = (LPTSTR)malloc((deviceKeyLength + 1) * sizeof(TCHAR));
+
+				if (!wfi->deviceKey)
+					return FALSE;
+
+				_tcsncpy_s(wfi->deviceKey, deviceKeyLength + 1,
+				           &deviceInfo.DeviceKey[deviceKeyPrefixLength], deviceKeyLength);
+			}
+
+			_tcsncpy_s(wfi->deviceName, 32, deviceInfo.DeviceName, _tcslen(deviceInfo.DeviceName));
+			return TRUE;
+		}
+
+		deviceNumber++;
+	}
+
+	return FALSE;
+}
+
+/**
+ * This function will attempt to access the the windows registry using the device
+ * key stored in the current wfi. It will attempt to read the value of the
+ * "Attach.ToDesktop" subkey and will return TRUE if the value is already set to
+ * val. If unable to read the subkey, this function will return FALSE. If the
+ * subkey is not set to val it will then attempt to set it to val and return TRUE. If
+ * unsuccessful or an unexpected value is encountered, the function returns
+ * FALSE.
+ */
+
+BOOL wf_mirror_driver_display_device_attach(wfInfo* wfi, DWORD mode)
+{
+	HKEY hKey;
+	LONG status;
+	DWORD dwType;
+	DWORD dwSize;
+	DWORD dwValue;
+	status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, wfi->deviceKey, 0, KEY_ALL_ACCESS | KEY_WOW64_64KEY,
+	                      &hKey);
+
+	if (status != ERROR_SUCCESS)
+	{
+		WLog_DBG(TAG, "Error opening RegKey: status=0x%08lX", status);
+
+		if (status == ERROR_ACCESS_DENIED)
+			WLog_DBG(TAG, "access denied. Do you have admin privileges?");
+
+		return FALSE;
+	}
+
+	dwSize = sizeof(DWORD);
+	status = RegQueryValueEx(hKey, _T("Attach.ToDesktop"), NULL, &dwType, (BYTE*)&dwValue, &dwSize);
+
+	if (status != ERROR_SUCCESS)
+	{
+		WLog_DBG(TAG, "Error querying RegKey: status=0x%08lX", status);
+
+		if (status == ERROR_ACCESS_DENIED)
+			WLog_DBG(TAG, "access denied. Do you have admin privileges?");
+
+		return FALSE;
+	}
+
+	if (dwValue ^ mode) // only if we want to change modes
+	{
+		dwValue = mode;
+		dwSize = sizeof(DWORD);
+		status = RegSetValueEx(hKey, _T("Attach.ToDesktop"), 0, REG_DWORD, (BYTE*)&dwValue, dwSize);
+
+		if (status != ERROR_SUCCESS)
+		{
+			WLog_DBG(TAG, "Error writing registry key: %ld", status);
+
+			if (status == ERROR_ACCESS_DENIED)
+				WLog_DBG(TAG, "access denied. Do you have admin privileges?");
+
+			WLog_DBG(TAG, "");
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+void wf_mirror_driver_print_display_change_status(LONG status)
+{
+	TCHAR disp_change[64];
+
+	switch (status)
+	{
+		case DISP_CHANGE_SUCCESSFUL:
+			_tcscpy(disp_change, _T("DISP_CHANGE_SUCCESSFUL"));
+			break;
+
+		case DISP_CHANGE_BADDUALVIEW:
+			_tcscpy(disp_change, _T("DISP_CHANGE_BADDUALVIEW"));
+			break;
+
+		case DISP_CHANGE_BADFLAGS:
+			_tcscpy(disp_change, _T("DISP_CHANGE_BADFLAGS"));
+			break;
+
+		case DISP_CHANGE_BADMODE:
+			_tcscpy(disp_change, _T("DISP_CHANGE_BADMODE"));
+			break;
+
+		case DISP_CHANGE_BADPARAM:
+			_tcscpy(disp_change, _T("DISP_CHANGE_BADPARAM"));
+			break;
+
+		case DISP_CHANGE_FAILED:
+			_tcscpy(disp_change, _T("DISP_CHANGE_FAILED"));
+			break;
+
+		case DISP_CHANGE_NOTUPDATED:
+			_tcscpy(disp_change, _T("DISP_CHANGE_NOTUPDATED"));
+			break;
+
+		case DISP_CHANGE_RESTART:
+			_tcscpy(disp_change, _T("DISP_CHANGE_RESTART"));
+			break;
+
+		default:
+			_tcscpy(disp_change, _T("DISP_CHANGE_UNKNOWN"));
+			break;
+	}
+
+	if (status != DISP_CHANGE_SUCCESSFUL)
+		WLog_ERR(TAG, "ChangeDisplaySettingsEx() failed with %s (%ld)", disp_change, status);
+	else
+		WLog_INFO(TAG, "ChangeDisplaySettingsEx() succeeded with %s (%ld)", disp_change, status);
+}
+
+/**
+ * This function will attempt to apply the currently configured display settings
+ * in the registry to the display driver. It will return TRUE if successful
+ * otherwise it returns FALSE.
+ * If mode is MIRROR_UNLOAD then the the driver will be asked to remove itself.
+ */
+
+BOOL wf_mirror_driver_update(wfInfo* wfi, int mode)
+{
+	BOOL status;
+	DWORD* extHdr;
+	WORD drvExtraSaved;
+	DEVMODE* deviceMode;
+	LONG disp_change_status;
+	DWORD dmf_devmodewext_magic_sig = 0xDF20C0DE;
+
+	if ((mode != MIRROR_LOAD) && (mode != MIRROR_UNLOAD))
+	{
+		WLog_DBG(TAG, "Invalid mirror mode!");
+		return FALSE;
+	}
+
+	deviceMode = (DEVMODE*)malloc(sizeof(DEVMODE) + EXT_DEVMODE_SIZE_MAX);
+
+	if (!deviceMode)
+		return FALSE;
+
+	deviceMode->dmDriverExtra = 2 * sizeof(DWORD);
+	extHdr = (DWORD*)((BYTE*)&deviceMode + sizeof(DEVMODE));
+	extHdr[0] = dmf_devmodewext_magic_sig;
+	extHdr[1] = 0;
+	drvExtraSaved = deviceMode->dmDriverExtra;
+	memset(deviceMode, 0, sizeof(DEVMODE) + EXT_DEVMODE_SIZE_MAX);
+	deviceMode->dmSize = sizeof(DEVMODE);
+	deviceMode->dmDriverExtra = drvExtraSaved;
+
+	if (mode == MIRROR_LOAD)
+	{
+		wfi->virtscreen_width = GetSystemMetrics(SM_CXVIRTUALSCREEN);
+		wfi->virtscreen_height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
+		deviceMode->dmPelsWidth = wfi->virtscreen_width;
+		deviceMode->dmPelsHeight = wfi->virtscreen_height;
+		deviceMode->dmBitsPerPel = wfi->bitsPerPixel;
+		deviceMode->u.s2.dmPosition.x = wfi->servscreen_xoffset;
+		deviceMode->u.s2.dmPosition.y = wfi->servscreen_yoffset;
+	}
+
+	deviceMode->dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_POSITION;
+	_tcsncpy_s(deviceMode->dmDeviceName, 32, wfi->deviceName, _tcslen(wfi->deviceName));
+	disp_change_status =
+	    ChangeDisplaySettingsEx(wfi->deviceName, deviceMode, NULL, CDS_UPDATEREGISTRY, NULL);
+	status = (disp_change_status == DISP_CHANGE_SUCCESSFUL) ? TRUE : FALSE;
+
+	if (!status)
+		wf_mirror_driver_print_display_change_status(disp_change_status);
+
+	return status;
+}
+
+BOOL wf_mirror_driver_map_memory(wfInfo* wfi)
+{
+	int status;
+	wfi->driverDC = CreateDC(wfi->deviceName, NULL, NULL, NULL);
+
+	if (wfi->driverDC == NULL)
+	{
+		WLog_ERR(TAG, "Could not create device driver context!");
+		{
+			LPVOID lpMsgBuf;
+			DWORD dw = GetLastError();
+			FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+			                  FORMAT_MESSAGE_IGNORE_INSERTS,
+			              NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0,
+			              NULL);
+			// Display the error message and exit the process
+			WLog_ERR(TAG, "CreateDC failed on device [%s] with error %lu: %s", wfi->deviceName, dw,
+			         lpMsgBuf);
+			LocalFree(lpMsgBuf);
+		}
+		return FALSE;
+	}
+
+	wfi->changeBuffer = calloc(1, sizeof(GETCHANGESBUF));
+
+	if (!wfi->changeBuffer)
+		return FALSE;
+
+	status = ExtEscape(wfi->driverDC, dmf_esc_usm_pipe_map, 0, 0, sizeof(GETCHANGESBUF),
+	                   (LPSTR)wfi->changeBuffer);
+
+	if (status <= 0)
+	{
+		WLog_ERR(TAG, "Failed to map shared memory from the driver! code %d", status);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+/* Unmap the shared memory and release the DC */
+
+BOOL wf_mirror_driver_cleanup(wfInfo* wfi)
+{
+	int status;
+	status = ExtEscape(wfi->driverDC, dmf_esc_usm_pipe_unmap, sizeof(GETCHANGESBUF),
+	                   (LPSTR)wfi->changeBuffer, 0, 0);
+
+	if (status <= 0)
+	{
+		WLog_ERR(TAG, "Failed to unmap shared memory from the driver! code %d", status);
+	}
+
+	if (wfi->driverDC != NULL)
+	{
+		status = DeleteDC(wfi->driverDC);
+
+		if (status == 0)
+		{
+			WLog_ERR(TAG, "Failed to release DC!");
+		}
+	}
+
+	free(wfi->changeBuffer);
+	return TRUE;
+}
+
+BOOL wf_mirror_driver_activate(wfInfo* wfi)
+{
+	if (!wfi->mirrorDriverActive)
+	{
+		WLog_DBG(TAG, "Activating Mirror Driver");
+
+		if (wf_mirror_driver_find_display_device(wfi) == FALSE)
+		{
+			WLog_DBG(TAG, "Could not find dfmirage mirror driver! Is it installed?");
+			return FALSE;
+		}
+
+		if (wf_mirror_driver_display_device_attach(wfi, 1) == FALSE)
+		{
+			WLog_DBG(TAG, "Could not attach display device!");
+			return FALSE;
+		}
+
+		if (wf_mirror_driver_update(wfi, MIRROR_LOAD) == FALSE)
+		{
+			WLog_DBG(TAG, "could not update system with new display settings!");
+			return FALSE;
+		}
+
+		if (wf_mirror_driver_map_memory(wfi) == FALSE)
+		{
+			WLog_DBG(TAG, "Unable to map memory for mirror driver!");
+			return FALSE;
+		}
+
+		wfi->mirrorDriverActive = TRUE;
+	}
+
+	return TRUE;
+}
+
+void wf_mirror_driver_deactivate(wfInfo* wfi)
+{
+	if (wfi->mirrorDriverActive)
+	{
+		WLog_DBG(TAG, "Deactivating Mirror Driver");
+		wf_mirror_driver_cleanup(wfi);
+		wf_mirror_driver_display_device_attach(wfi, 0);
+		wf_mirror_driver_update(wfi, MIRROR_UNLOAD);
+		wfi->mirrorDriverActive = FALSE;
+	}
+}

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_mirage.h

@@ -0,0 +1,219 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2012-2013 Corey Clayton <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_SERVER_WIN_MIRAGE_H
+#define FREERDP_SERVER_WIN_MIRAGE_H
+
+#include "wf_interface.h"
+
+enum
+{
+	MIRROR_LOAD = 0,
+	MIRROR_UNLOAD = 1
+};
+
+enum
+{
+	DMF_ESCAPE_BASE_1_VB = 1030,
+	DMF_ESCAPE_BASE_2_VB = 1026,
+	DMF_ESCAPE_BASE_3_VB = 24
+};
+
+#ifdef _WIN64
+
+#define CLIENT_64BIT 0x8000
+
+enum
+{
+	DMF_ESCAPE_BASE_1 = CLIENT_64BIT | DMF_ESCAPE_BASE_1_VB,
+	DMF_ESCAPE_BASE_2 = CLIENT_64BIT | DMF_ESCAPE_BASE_2_VB,
+	DMF_ESCAPE_BASE_3 = CLIENT_64BIT | DMF_ESCAPE_BASE_3_VB,
+};
+
+#else
+
+enum
+{
+	DMF_ESCAPE_BASE_1 = DMF_ESCAPE_BASE_1_VB,
+	DMF_ESCAPE_BASE_2 = DMF_ESCAPE_BASE_2_VB,
+	DMF_ESCAPE_BASE_3 = DMF_ESCAPE_BASE_3_VB,
+};
+
+#endif
+
+typedef enum
+{
+	dmf_esc_qry_ver_info = DMF_ESCAPE_BASE_2 + 0,
+	dmf_esc_usm_pipe_map = DMF_ESCAPE_BASE_1 + 0,
+	dmf_esc_usm_pipe_unmap = DMF_ESCAPE_BASE_1 + 1,
+	dmf_esc_test = DMF_ESCAPE_BASE_1 + 20,
+	dmf_esc_usm_pipe_mapping_test = DMF_ESCAPE_BASE_1 + 21,
+	dmf_esc_pointer_shape_get = DMF_ESCAPE_BASE_3,
+
+} dmf_escape;
+
+#define CLIP_LIMIT 50
+#define MAXCHANGES_BUF 20000
+
+typedef enum
+{
+	dmf_dfo_IGNORE = 0,
+	dmf_dfo_FROM_SCREEN = 1,
+	dmf_dfo_FROM_DIB = 2,
+	dmf_dfo_TO_SCREEN = 3,
+	dmf_dfo_SCREEN_SCREEN = 11,
+	dmf_dfo_BLIT = 12,
+	dmf_dfo_SOLIDFILL = 13,
+	dmf_dfo_BLEND = 14,
+	dmf_dfo_TRANS = 15,
+	dmf_dfo_PLG = 17,
+	dmf_dfo_TEXTOUT = 18,
+	dmf_dfo_Ptr_Shape = 19,
+	dmf_dfo_Ptr_Engage = 48,
+	dmf_dfo_Ptr_Avert = 49,
+	dmf_dfn_assert_on = 64,
+	dmf_dfn_assert_off = 65,
+} dmf_UpdEvent;
+
+#define NOCACHE 1
+#define OLDCACHE 2
+#define NEWCACHE 3
+
+typedef struct
+{
+	ULONG type;
+	RECT rect;
+#ifndef DFMIRAGE_LEAN
+	RECT origrect;
+	POINT point;
+	ULONG color;
+	ULONG refcolor;
+#endif
+} CHANGES_RECORD;
+
+typedef CHANGES_RECORD* PCHANGES_RECORD;
+
+typedef struct
+{
+	ULONG counter;
+	CHANGES_RECORD pointrect[MAXCHANGES_BUF];
+} CHANGES_BUF;
+
+#define EXT_DEVMODE_SIZE_MAX 3072
+#define DMF_PIPE_SEC_SIZE_DEFAULT ALIGN64K(sizeof(CHANGES_BUF))
+
+typedef struct
+{
+	CHANGES_BUF* buffer;
+	PVOID Userbuffer;
+} GETCHANGESBUF;
+
+#define dmf_sprb_ERRORMASK 0x07FF
+#define dmf_sprb_STRICTSESSION_AFF 0x1FFF
+
+typedef enum
+{
+	dmf_sprb_internal_error = 0x0001,
+	dmf_sprb_miniport_gen_error = 0x0004,
+	dmf_sprb_memory_alloc_failed = 0x0008,
+	dmf_sprb_pipe_buff_overflow = 0x0010,
+	dmf_sprb_pipe_buff_insufficient = 0x0020,
+	dmf_sprb_pipe_not_ready = 0x0040,
+	dmf_sprb_gdi_err = 0x0100,
+	dmf_sprb_owner_died = 0x0400,
+	dmf_sprb_tgtwnd_gone = 0x0800,
+	dmf_sprb_pdev_detached = 0x2000,
+} dmf_session_prob_status;
+
+#define DMF_ESC_RET_FAILF 0x80000000
+#define DMF_ESC_RET_SSTMASK 0x0000FFFF
+#define DMF_ESC_RET_IMMMASK 0x7FFF0000
+
+typedef enum
+{
+	dmf_escret_generic_ok = 0x00010000,
+	dmf_escret_bad_state = 0x00100000,
+	dmf_escret_access_denied = 0x00200000,
+	dmf_escret_bad_buffer_size = 0x00400000,
+	dmf_escret_internal_err = 0x00800000,
+	dmf_escret_out_of_memory = 0x02000000,
+	dmf_escret_already_connected = 0x04000000,
+	dmf_escret_oh_boy_too_late = 0x08000000,
+	dmf_escret_bad_window = 0x10000000,
+	dmf_escret_drv_ver_higher = 0x20000000,
+	dmf_escret_drv_ver_lower = 0x40000000,
+} dmf_esc_retcode;
+
+typedef struct
+{
+	ULONG cbSize;
+	ULONG app_actual_version;
+	ULONG display_minreq_version;
+	ULONG connect_options;
+} Esc_dmf_Qvi_IN;
+
+enum
+{
+	esc_qvi_prod_name_max = 16,
+};
+
+#define ESC_QVI_PROD_MIRAGE "MIRAGE"
+#define ESC_QVI_PROD_QUASAR "QUASAR"
+
+typedef struct
+{
+	ULONG cbSize;
+	ULONG display_actual_version;
+	ULONG miniport_actual_version;
+	ULONG app_minreq_version;
+	ULONG display_buildno;
+	ULONG miniport_buildno;
+	char prod_name[esc_qvi_prod_name_max];
+} Esc_dmf_Qvi_OUT;
+
+typedef struct
+{
+	ULONG cbSize;
+	char* pDstBmBuf;
+	ULONG nDstBmBufSize;
+} Esc_dmf_pointer_shape_get_IN;
+
+typedef struct
+{
+	ULONG cbSize;
+	POINTL BmSize;
+	char* pMaskBm;
+	ULONG nMaskBmSize;
+	char* pColorBm;
+	ULONG nColorBmSize;
+	char* pColorBmPal;
+	ULONG nColorBmPalEntries;
+} Esc_dmf_pointer_shape_get_OUT;
+
+BOOL wf_mirror_driver_find_display_device(wfInfo* wfi);
+BOOL wf_mirror_driver_display_device_attach(wfInfo* wfi, DWORD mode);
+BOOL wf_mirror_driver_update(wfInfo* wfi, int mode);
+BOOL wf_mirror_driver_map_memory(wfInfo* wfi);
+BOOL wf_mirror_driver_cleanup(wfInfo* wfi);
+
+BOOL wf_mirror_driver_activate(wfInfo* wfi);
+void wf_mirror_driver_deactivate(wfInfo* wfi);
+
+#endif /* FREERDP_SERVER_WIN_MIRAGE_H */

local-test-freerdp-full-01/afc-freerdp/server/Windows/wf_peer.c

@@ -0,0 +1,414 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Client
+ * FreeRDP Windows Server
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ * Copyright 2012 Corey Clayton <[email protected]>
+ *
+ * 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/config.h>
+
+#include <winpr/assert.h>
+#include <winpr/tchar.h>
+#include <winpr/stream.h>
+#include <winpr/windows.h>
+
+#include <freerdp/listener.h>
+#include <freerdp/codec/rfx.h>
+#include <freerdp/build-config.h>
+#include <freerdp/crypto/certificate.h>
+
+#include "wf_info.h"
+#include "wf_input.h"
+#include "wf_mirage.h"
+#include "wf_update.h"
+#include "wf_settings.h"
+#include "wf_rdpsnd.h"
+
+#include "wf_peer.h"
+#include <freerdp/peer.h>
+
+#include <freerdp/log.h>
+#define TAG SERVER_TAG("windows")
+
+#define SERVER_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING
+
+static DWORD WINAPI wf_peer_main_loop(LPVOID lpParam);
+
+static BOOL wf_peer_context_new(freerdp_peer* client, rdpContext* ctx)
+{
+	wfPeerContext* context = (wfPeerContext*)ctx;
+	WINPR_ASSERT(context);
+
+	if (!(context->info = wf_info_get_instance()))
+		return FALSE;
+
+	context->vcm = WTSOpenServerA((LPSTR)client->context);
+
+	if (!context->vcm || context->vcm == INVALID_HANDLE_VALUE)
+		return FALSE;
+
+	if (!wf_info_peer_register(context->info, context))
+	{
+		WTSCloseServer(context->vcm);
+		context->vcm = NULL;
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void wf_peer_context_free(freerdp_peer* client, rdpContext* ctx)
+{
+	wfPeerContext* context = (wfPeerContext*)ctx;
+	WINPR_ASSERT(context);
+
+	wf_info_peer_unregister(context->info, context);
+
+	if (context->rdpsnd)
+	{
+		wf_rdpsnd_lock();
+		context->info->snd_stop = TRUE;
+		rdpsnd_server_context_free(context->rdpsnd);
+		wf_rdpsnd_unlock();
+	}
+
+	WTSCloseServer(context->vcm);
+}
+
+static BOOL wf_peer_init(freerdp_peer* client)
+{
+	client->ContextSize = sizeof(wfPeerContext);
+	client->ContextNew = wf_peer_context_new;
+	client->ContextFree = wf_peer_context_free;
+	return freerdp_peer_context_new(client);
+}
+
+static BOOL wf_peer_post_connect(freerdp_peer* client)
+{
+	wfInfo* wfi;
+	rdpSettings* settings;
+	wfPeerContext* context;
+
+	WINPR_ASSERT(client);
+
+	context = (wfPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	wfi = context->info;
+	WINPR_ASSERT(wfi);
+
+	settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	if ((get_screen_info(wfi->screenID, NULL, 0, &wfi->servscreen_width, &wfi->servscreen_height,
+	                     &wfi->bitsPerPixel) == 0) ||
+	    (wfi->servscreen_width == 0) || (wfi->servscreen_height == 0) || (wfi->bitsPerPixel == 0))
+	{
+		WLog_ERR(TAG, "postconnect: error getting screen info for screen %d", wfi->screenID);
+		WLog_ERR(TAG, "\t%dx%dx%d", wfi->servscreen_height, wfi->servscreen_width,
+		         wfi->bitsPerPixel);
+		return FALSE;
+	}
+
+	if ((freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) != wfi->servscreen_width) ||
+	    (freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) != wfi->servscreen_height))
+	{
+		/*
+		WLog_DBG(TAG, "Client requested resolution %"PRIu32"x%"PRIu32", but will resize to %dx%d",
+		    freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
+		freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight), wfi->servscreen_width,
+		wfi->servscreen_height);
+		    */
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, wfi->servscreen_width) ||
+		    !freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, wfi->servscreen_height) ||
+		    !freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, wfi->bitsPerPixel))
+			return FALSE;
+
+		WINPR_ASSERT(client->context->update);
+		WINPR_ASSERT(client->context->update->DesktopResize);
+		client->context->update->DesktopResize(client->context);
+	}
+
+	if (WTSVirtualChannelManagerIsChannelJoined(context->vcm, "rdpsnd"))
+	{
+		wf_peer_rdpsnd_init(context); /* Audio Output */
+	}
+
+	return TRUE;
+}
+
+static BOOL wf_peer_activate(freerdp_peer* client)
+{
+	wfInfo* wfi;
+	wfPeerContext* context = (wfPeerContext*)client->context;
+	wfi = context->info;
+	client->activated = TRUE;
+	wf_update_peer_activate(wfi, context);
+	wfreerdp_server_peer_callback_event(((rdpContext*)context)->peer->pId,
+	                                    FREERDP_SERVER_WIN_SRV_CALLBACK_EVENT_ACTIVATE);
+	return TRUE;
+}
+
+static BOOL wf_peer_logon(freerdp_peer* client, const SEC_WINNT_AUTH_IDENTITY* identity,
+                          BOOL automatic)
+{
+	wfreerdp_server_peer_callback_event(((rdpContext*)client->context)->peer->pId,
+	                                    FREERDP_SERVER_WIN_SRV_CALLBACK_EVENT_AUTH);
+	return TRUE;
+}
+
+static BOOL wf_peer_synchronize_event(rdpInput* input, UINT32 flags)
+{
+	return TRUE;
+}
+
+BOOL wf_peer_accepted(freerdp_listener* instance, freerdp_peer* client)
+{
+	HANDLE hThread;
+
+	if (!(hThread = CreateThread(NULL, 0, wf_peer_main_loop, client, 0, NULL)))
+		return FALSE;
+
+	(void)CloseHandle(hThread);
+	return TRUE;
+}
+
+static DWORD WINAPI wf_peer_socket_listener(LPVOID lpParam)
+{
+	wfPeerContext* context;
+	freerdp_peer* client = (freerdp_peer*)lpParam;
+
+	WINPR_ASSERT(client);
+	WINPR_ASSERT(client->GetEventHandles);
+	WINPR_ASSERT(client->CheckFileDescriptor);
+
+	context = (wfPeerContext*)client->context;
+	WINPR_ASSERT(context);
+
+	while (1)
+	{
+		DWORD status;
+		HANDLE handles[MAXIMUM_WAIT_OBJECTS] = { 0 };
+		DWORD count = client->GetEventHandles(client, handles, ARRAYSIZE(handles));
+
+		if (count == 0)
+		{
+			WLog_ERR(TAG, "Failed to get FreeRDP file descriptor");
+			break;
+		}
+
+		status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
+		if (status == WAIT_FAILED)
+		{
+			WLog_ERR(TAG, "WaitForMultipleObjects failed");
+			break;
+		}
+
+		(void)SetEvent(context->socketEvent);
+		(void)WaitForSingleObject(context->socketSemaphore, INFINITE);
+
+		if (context->socketClose)
+			break;
+	}
+
+	return 0;
+}
+
+static BOOL wf_peer_read_settings(freerdp_peer* client)
+{
+	rdpSettings* settings;
+
+	WINPR_ASSERT(client);
+	WINPR_ASSERT(client->context);
+
+	settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	char* CertificateFile = NULL;
+	if (!wf_settings_read_string_ascii(HKEY_LOCAL_MACHINE, SERVER_KEY, _T("CertificateFile"),
+	                                   &(CertificateFile)))
+		CertificateFile = _strdup("server.crt");
+
+	rdpCertificate* cert = freerdp_certificate_new_from_file(CertificateFile);
+	free(CertificateFile);
+	if (!cert)
+		return FALSE;
+
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerCertificate, cert, 1))
+		return FALSE;
+
+	char* PrivateKeyFile = NULL;
+	if (!wf_settings_read_string_ascii(HKEY_LOCAL_MACHINE, SERVER_KEY, _T("PrivateKeyFile"),
+	                                   &(PrivateKeyFile)))
+		PrivateKeyFile = _strdup("server.key");
+
+	rdpPrivateKey* key = freerdp_key_new_from_file(PrivateKeyFile);
+	free(PrivateKeyFile);
+
+	if (!key)
+		return FALSE;
+
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerRsaKey, key, 1))
+		return FALSE;
+
+	return TRUE;
+}
+
+DWORD WINAPI wf_peer_main_loop(LPVOID lpParam)
+{
+	wfInfo* wfi;
+	DWORD nCount;
+	DWORD status;
+	HANDLE handles[32];
+	rdpSettings* settings;
+	wfPeerContext* context;
+	freerdp_peer* client = (freerdp_peer*)lpParam;
+
+	if (!wf_peer_init(client))
+		goto fail_peer_init;
+
+	WINPR_ASSERT(client->context);
+
+	settings = client->context->settings;
+	WINPR_ASSERT(settings);
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteFxCodec, TRUE))
+		goto fail_peer_init;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32))
+		goto fail_peer_init;
+	if (!freerdp_settings_set_bool(settings, FreeRDP_NSCodec, FALSE))
+		goto fail_peer_init;
+	if (!freerdp_settings_set_bool(settings, FreeRDP_JpegCodec, FALSE))
+		goto fail_peer_init;
+
+	if (!wf_peer_read_settings(client))
+		goto fail_peer_init;
+
+	client->PostConnect = wf_peer_post_connect;
+	client->Activate = wf_peer_activate;
+	client->Logon = wf_peer_logon;
+
+	WINPR_ASSERT(client->context->input);
+	client->context->input->SynchronizeEvent = wf_peer_synchronize_event;
+	client->context->input->KeyboardEvent = wf_peer_keyboard_event;
+	client->context->input->UnicodeKeyboardEvent = wf_peer_unicode_keyboard_event;
+	client->context->input->MouseEvent = wf_peer_mouse_event;
+	client->context->input->ExtendedMouseEvent = wf_peer_extended_mouse_event;
+
+	WINPR_ASSERT(client->Initialize);
+	if (!client->Initialize(client))
+		goto fail_client_initialize;
+
+	context = (wfPeerContext*)client->context;
+
+	if (context->socketClose)
+		goto fail_socked_closed;
+
+	wfi = context->info;
+
+	if (wfi->input_disabled)
+	{
+		WLog_INFO(TAG, "client input is disabled");
+		client->context->input->KeyboardEvent = wf_peer_keyboard_event_dummy;
+		client->context->input->UnicodeKeyboardEvent = wf_peer_unicode_keyboard_event_dummy;
+		client->context->input->MouseEvent = wf_peer_mouse_event_dummy;
+		client->context->input->ExtendedMouseEvent = wf_peer_extended_mouse_event_dummy;
+	}
+
+	if (!(context->socketEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
+		goto fail_socket_event;
+
+	if (!(context->socketSemaphore = CreateSemaphore(NULL, 0, 1, NULL)))
+		goto fail_socket_semaphore;
+
+	if (!(context->socketThread = CreateThread(NULL, 0, wf_peer_socket_listener, client, 0, NULL)))
+		goto fail_socket_thread;
+
+	WLog_INFO(TAG, "We've got a client %s", client->local ? "(local)" : client->hostname);
+	nCount = 0;
+	handles[nCount++] = context->updateEvent;
+	handles[nCount++] = context->socketEvent;
+
+	while (1)
+	{
+		status = WaitForMultipleObjects(nCount, handles, FALSE, INFINITE);
+
+		if ((status == WAIT_FAILED) || (status == WAIT_TIMEOUT))
+		{
+			WLog_ERR(TAG, "WaitForMultipleObjects failed");
+			break;
+		}
+
+		if (WaitForSingleObject(context->updateEvent, 0) == 0)
+		{
+			if (client->activated)
+				wf_update_peer_send(wfi, context);
+
+			(void)ResetEvent(context->updateEvent);
+			ReleaseSemaphore(wfi->updateSemaphore, 1, NULL);
+		}
+
+		if (WaitForSingleObject(context->socketEvent, 0) == 0)
+		{
+			if (client->CheckFileDescriptor(client) != TRUE)
+			{
+				WLog_ERR(TAG, "Failed to check peer file descriptor");
+				context->socketClose = TRUE;
+			}
+
+			(void)ResetEvent(context->socketEvent);
+			ReleaseSemaphore(context->socketSemaphore, 1, NULL);
+
+			if (context->socketClose)
+				break;
+		}
+
+		// force disconnect
+		if (wfi->force_all_disconnect == TRUE)
+		{
+			WLog_INFO(TAG, "Forcing Disconnect -> ");
+			break;
+		}
+
+		/* FIXME: we should wait on this, instead of calling it every time */
+		if (WTSVirtualChannelManagerCheckFileDescriptor(context->vcm) != TRUE)
+			break;
+	}
+
+	WLog_INFO(TAG, "Client %s disconnected.", client->local ? "(local)" : client->hostname);
+
+	if (WaitForSingleObject(context->updateEvent, 0) == 0)
+	{
+		(void)ResetEvent(context->updateEvent);
+		ReleaseSemaphore(wfi->updateSemaphore, 1, NULL);
+	}
+
+	wf_update_peer_deactivate(wfi, context);
+	client->Disconnect(client);
+fail_socket_thread:
+	(void)CloseHandle(context->socketSemaphore);
+	context->socketSemaphore = NULL;
+fail_socket_semaphore:
+	(void)CloseHandle(context->socketEvent);
+	context->socketEvent = NULL;
+fail_socket_event:
+fail_socked_closed:
+fail_client_initialize:
+	freerdp_peer_context_free(client);
+fail_peer_init:
+	freerdp_peer_free(client);
+	return 0;
+}