Add files using upload-large-folder tool

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/CMakeLists.txt

@@ -0,0 +1,82 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP SDL Client
+#
+# Copyright 2022 Armin Novak <[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 "sdl2-freerdp")
+
+find_package(SDL2 REQUIRED)
+
+find_package(Threads REQUIRED)
+
+add_subdirectory(dialogs)
+set(SRCS
+    sdl_types.hpp
+    sdl_utils.cpp
+    sdl_utils.hpp
+    sdl_kbd.cpp
+    sdl_kbd.hpp
+    sdl_touch.cpp
+    sdl_touch.hpp
+    sdl_pointer.cpp
+    sdl_pointer.hpp
+    sdl_disp.cpp
+    sdl_disp.hpp
+    sdl_monitor.cpp
+    sdl_monitor.hpp
+    sdl_freerdp.hpp
+    sdl_freerdp.cpp
+    sdl_channels.hpp
+    sdl_channels.cpp
+    sdl_window.hpp
+    sdl_window.cpp
+)
+
+list(
+  APPEND
+  LIBS
+  winpr
+  freerdp
+  freerdp-client
+  Threads::Threads
+  sdl2_client_res
+  sdl2-dialogs
+  sdl-common-aad-view
+  sdl-common-prefs
+)
+
+if(NOT WITH_SDL_LINK_SHARED)
+  list(APPEND LIBS SDL2::SDL2-static)
+  set_target_properties(SDL2::SDL2-static PROPERTIES SYSTEM TRUE)
+else()
+  list(APPEND LIBS SDL2::SDL2)
+  set_target_properties(SDL2::SDL2 PROPERTIES SYSTEM TRUE)
+endif()
+
+addtargetwithresourcefile(${MODULE_NAME} TRUE "${PROJECT_VERSION}" SRCS)
+
+target_link_libraries(${MODULE_NAME} PRIVATE ${LIBS})
+
+set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "Client/SDL")
+
+if(NOT WITH_CLIENT_SDL_VERSIONED)
+  get_target_property(OUT_NAME ${MODULE_NAME} OUTPUT_NAME)
+  string(REPLACE "${MODULE_NAME}" "${PROJECT_NAME}" OUT_NAME "${OUT_NAME}")
+  set_target_properties(${MODULE_NAME} PROPERTIES OUTPUT_NAME ${OUT_NAME})
+endif()
+
+install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT client)
+install_freerdp_desktop("${MODULE_NAME}")
+
+add_subdirectory(man)

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/sdl_channels.hpp

@@ -0,0 +1,29 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client Channels
+ *
+ * Copyright 2022 Armin Novak <[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.
+ */
+
+#pragma once
+
+#include <freerdp/freerdp.h>
+#include <freerdp/client/channels.h>
+
+int sdl_on_channel_connected(freerdp* instance, const char* name, void* pInterface);
+int sdl_on_channel_disconnected(freerdp* instance, const char* name, void* pInterface);
+
+void sdl_OnChannelConnectedEventHandler(void* context, const ChannelConnectedEventArgs* e);
+void sdl_OnChannelDisconnectedEventHandler(void* context, const ChannelDisconnectedEventArgs* e);

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/sdl_disp.hpp

@@ -0,0 +1,82 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Display Control Channel
+ *
+ * Copyright 2023 Armin Novak <[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.
+ */
+#pragma once
+
+#include <freerdp/types.h>
+#include <freerdp/event.h>
+#include <freerdp/client/disp.h>
+
+#include "sdl_types.hpp"
+
+#include <SDL.h>
+
+class sdlDispContext
+{
+
+  public:
+	explicit sdlDispContext(SdlContext* sdl);
+	sdlDispContext(const sdlDispContext& other) = delete;
+	sdlDispContext(sdlDispContext&& other) = delete;
+	~sdlDispContext();
+
+	sdlDispContext& operator=(const sdlDispContext& other) = delete;
+	sdlDispContext& operator=(sdlDispContext&& other) = delete;
+
+	BOOL init(DispClientContext* disp);
+	BOOL uninit(DispClientContext* disp);
+
+#if SDL_VERSION_ATLEAST(2, 0, 10)
+	BOOL handle_display_event(const SDL_DisplayEvent* ev);
+#endif
+
+	BOOL handle_window_event(const SDL_WindowEvent* ev);
+
+  private:
+	UINT DisplayControlCaps(UINT32 maxNumMonitors, UINT32 maxMonitorAreaFactorA,
+	                        UINT32 maxMonitorAreaFactorB);
+	BOOL set_window_resizable();
+
+	BOOL sendResize();
+	BOOL settings_changed();
+	BOOL update_last_sent();
+	UINT sendLayout(const rdpMonitor* monitors, size_t nmonitors);
+
+	BOOL addTimer();
+
+	static UINT DisplayControlCaps(DispClientContext* disp, UINT32 maxNumMonitors,
+	                               UINT32 maxMonitorAreaFactorA, UINT32 maxMonitorAreaFactorB);
+	static void OnActivated(void* context, const ActivatedEventArgs* e);
+	static void OnGraphicsReset(void* context, const GraphicsResetEventArgs* e);
+	static Uint32 SDLCALL OnTimer(Uint32 interval, void* param);
+
+	SdlContext* _sdl = nullptr;
+	DispClientContext* _disp = nullptr;
+	int _lastSentWidth = -1;
+	int _lastSentHeight = -1;
+	UINT64 _lastSentDate = 0;
+	int _targetWidth = -1;
+	int _targetHeight = -1;
+	BOOL _activated = FALSE;
+	BOOL _waitingResize = FALSE;
+	UINT16 _lastSentDesktopOrientation = 0;
+	UINT32 _lastSentDesktopScaleFactor = 0;
+	UINT32 _lastSentDeviceScaleFactor = 0;
+	SDL_TimerID _timer = 0;
+	unsigned _timer_retries = 0;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/sdl_kbd.cpp

@@ -0,0 +1,579 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP SDL keyboard helper
+ *
+ * Copyright 2022 Armin Novak <[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/cast.h>
+
+#include "sdl_kbd.hpp"
+#include "sdl_disp.hpp"
+#include "sdl_freerdp.hpp"
+#include "sdl_utils.hpp"
+#include "sdl_prefs.hpp"
+
+#include <map>
+
+#include <freerdp/utils/string.h>
+#include <freerdp/scancode.h>
+
+#include <freerdp/log.h>
+#define TAG CLIENT_TAG("SDL.kbd")
+
+using scancode_entry_t = struct
+{
+	Uint32 sdl;
+	const char* sdl_name;
+	UINT32 rdp;
+	const char* rdp_name;
+};
+
+#define STR(x) #x
+#define ENTRY(x, y)      \
+	{                    \
+		x, STR(x), y, #y \
+	}
+static const scancode_entry_t map[] = {
+	ENTRY(SDL_SCANCODE_UNKNOWN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_A, RDP_SCANCODE_KEY_A),
+	ENTRY(SDL_SCANCODE_B, RDP_SCANCODE_KEY_B),
+	ENTRY(SDL_SCANCODE_C, RDP_SCANCODE_KEY_C),
+	ENTRY(SDL_SCANCODE_D, RDP_SCANCODE_KEY_D),
+	ENTRY(SDL_SCANCODE_E, RDP_SCANCODE_KEY_E),
+	ENTRY(SDL_SCANCODE_F, RDP_SCANCODE_KEY_F),
+	ENTRY(SDL_SCANCODE_G, RDP_SCANCODE_KEY_G),
+	ENTRY(SDL_SCANCODE_H, RDP_SCANCODE_KEY_H),
+	ENTRY(SDL_SCANCODE_I, RDP_SCANCODE_KEY_I),
+	ENTRY(SDL_SCANCODE_J, RDP_SCANCODE_KEY_J),
+	ENTRY(SDL_SCANCODE_K, RDP_SCANCODE_KEY_K),
+	ENTRY(SDL_SCANCODE_L, RDP_SCANCODE_KEY_L),
+	ENTRY(SDL_SCANCODE_M, RDP_SCANCODE_KEY_M),
+	ENTRY(SDL_SCANCODE_N, RDP_SCANCODE_KEY_N),
+	ENTRY(SDL_SCANCODE_O, RDP_SCANCODE_KEY_O),
+	ENTRY(SDL_SCANCODE_P, RDP_SCANCODE_KEY_P),
+	ENTRY(SDL_SCANCODE_Q, RDP_SCANCODE_KEY_Q),
+	ENTRY(SDL_SCANCODE_R, RDP_SCANCODE_KEY_R),
+	ENTRY(SDL_SCANCODE_S, RDP_SCANCODE_KEY_S),
+	ENTRY(SDL_SCANCODE_T, RDP_SCANCODE_KEY_T),
+	ENTRY(SDL_SCANCODE_U, RDP_SCANCODE_KEY_U),
+	ENTRY(SDL_SCANCODE_V, RDP_SCANCODE_KEY_V),
+	ENTRY(SDL_SCANCODE_W, RDP_SCANCODE_KEY_W),
+	ENTRY(SDL_SCANCODE_X, RDP_SCANCODE_KEY_X),
+	ENTRY(SDL_SCANCODE_Y, RDP_SCANCODE_KEY_Y),
+	ENTRY(SDL_SCANCODE_Z, RDP_SCANCODE_KEY_Z),
+	ENTRY(SDL_SCANCODE_1, RDP_SCANCODE_KEY_1),
+	ENTRY(SDL_SCANCODE_2, RDP_SCANCODE_KEY_2),
+	ENTRY(SDL_SCANCODE_3, RDP_SCANCODE_KEY_3),
+	ENTRY(SDL_SCANCODE_4, RDP_SCANCODE_KEY_4),
+	ENTRY(SDL_SCANCODE_5, RDP_SCANCODE_KEY_5),
+	ENTRY(SDL_SCANCODE_6, RDP_SCANCODE_KEY_6),
+	ENTRY(SDL_SCANCODE_7, RDP_SCANCODE_KEY_7),
+	ENTRY(SDL_SCANCODE_8, RDP_SCANCODE_KEY_8),
+	ENTRY(SDL_SCANCODE_9, RDP_SCANCODE_KEY_9),
+	ENTRY(SDL_SCANCODE_0, RDP_SCANCODE_KEY_0),
+	ENTRY(SDL_SCANCODE_RETURN, RDP_SCANCODE_RETURN),
+	ENTRY(SDL_SCANCODE_ESCAPE, RDP_SCANCODE_ESCAPE),
+	ENTRY(SDL_SCANCODE_BACKSPACE, RDP_SCANCODE_BACKSPACE),
+	ENTRY(SDL_SCANCODE_TAB, RDP_SCANCODE_TAB),
+	ENTRY(SDL_SCANCODE_SPACE, RDP_SCANCODE_SPACE),
+	ENTRY(SDL_SCANCODE_MINUS, RDP_SCANCODE_OEM_MINUS),
+	ENTRY(SDL_SCANCODE_CAPSLOCK, RDP_SCANCODE_CAPSLOCK),
+	ENTRY(SDL_SCANCODE_F1, RDP_SCANCODE_F1),
+	ENTRY(SDL_SCANCODE_F2, RDP_SCANCODE_F2),
+	ENTRY(SDL_SCANCODE_F3, RDP_SCANCODE_F3),
+	ENTRY(SDL_SCANCODE_F4, RDP_SCANCODE_F4),
+	ENTRY(SDL_SCANCODE_F5, RDP_SCANCODE_F5),
+	ENTRY(SDL_SCANCODE_F6, RDP_SCANCODE_F6),
+	ENTRY(SDL_SCANCODE_F7, RDP_SCANCODE_F7),
+	ENTRY(SDL_SCANCODE_F8, RDP_SCANCODE_F8),
+	ENTRY(SDL_SCANCODE_F9, RDP_SCANCODE_F9),
+	ENTRY(SDL_SCANCODE_F10, RDP_SCANCODE_F10),
+	ENTRY(SDL_SCANCODE_F11, RDP_SCANCODE_F11),
+	ENTRY(SDL_SCANCODE_F12, RDP_SCANCODE_F12),
+	ENTRY(SDL_SCANCODE_F13, RDP_SCANCODE_F13),
+	ENTRY(SDL_SCANCODE_F14, RDP_SCANCODE_F14),
+	ENTRY(SDL_SCANCODE_F15, RDP_SCANCODE_F15),
+	ENTRY(SDL_SCANCODE_F16, RDP_SCANCODE_F16),
+	ENTRY(SDL_SCANCODE_F17, RDP_SCANCODE_F17),
+	ENTRY(SDL_SCANCODE_F18, RDP_SCANCODE_F18),
+	ENTRY(SDL_SCANCODE_F19, RDP_SCANCODE_F19),
+	ENTRY(SDL_SCANCODE_F20, RDP_SCANCODE_F20),
+	ENTRY(SDL_SCANCODE_F21, RDP_SCANCODE_F21),
+	ENTRY(SDL_SCANCODE_F22, RDP_SCANCODE_F22),
+	ENTRY(SDL_SCANCODE_F23, RDP_SCANCODE_F23),
+	ENTRY(SDL_SCANCODE_F24, RDP_SCANCODE_F24),
+	ENTRY(SDL_SCANCODE_NUMLOCKCLEAR, RDP_SCANCODE_NUMLOCK),
+	ENTRY(SDL_SCANCODE_KP_DIVIDE, RDP_SCANCODE_DIVIDE),
+	ENTRY(SDL_SCANCODE_KP_MULTIPLY, RDP_SCANCODE_MULTIPLY),
+	ENTRY(SDL_SCANCODE_KP_MINUS, RDP_SCANCODE_SUBTRACT),
+	ENTRY(SDL_SCANCODE_KP_PLUS, RDP_SCANCODE_ADD),
+	ENTRY(SDL_SCANCODE_KP_ENTER, RDP_SCANCODE_RETURN_KP),
+	ENTRY(SDL_SCANCODE_KP_1, RDP_SCANCODE_NUMPAD1),
+	ENTRY(SDL_SCANCODE_KP_2, RDP_SCANCODE_NUMPAD2),
+	ENTRY(SDL_SCANCODE_KP_3, RDP_SCANCODE_NUMPAD3),
+	ENTRY(SDL_SCANCODE_KP_4, RDP_SCANCODE_NUMPAD4),
+	ENTRY(SDL_SCANCODE_KP_5, RDP_SCANCODE_NUMPAD5),
+	ENTRY(SDL_SCANCODE_KP_6, RDP_SCANCODE_NUMPAD6),
+	ENTRY(SDL_SCANCODE_KP_7, RDP_SCANCODE_NUMPAD7),
+	ENTRY(SDL_SCANCODE_KP_8, RDP_SCANCODE_NUMPAD8),
+	ENTRY(SDL_SCANCODE_KP_9, RDP_SCANCODE_NUMPAD9),
+	ENTRY(SDL_SCANCODE_KP_0, RDP_SCANCODE_NUMPAD0),
+	ENTRY(SDL_SCANCODE_KP_PERIOD, RDP_SCANCODE_OEM_PERIOD),
+	ENTRY(SDL_SCANCODE_LCTRL, RDP_SCANCODE_LCONTROL),
+	ENTRY(SDL_SCANCODE_LSHIFT, RDP_SCANCODE_LSHIFT),
+	ENTRY(SDL_SCANCODE_LALT, RDP_SCANCODE_LMENU),
+	ENTRY(SDL_SCANCODE_LGUI, RDP_SCANCODE_LWIN),
+	ENTRY(SDL_SCANCODE_RCTRL, RDP_SCANCODE_RCONTROL),
+	ENTRY(SDL_SCANCODE_RSHIFT, RDP_SCANCODE_RSHIFT),
+	ENTRY(SDL_SCANCODE_RALT, RDP_SCANCODE_RMENU),
+	ENTRY(SDL_SCANCODE_RGUI, RDP_SCANCODE_RWIN),
+	ENTRY(SDL_SCANCODE_MODE, RDP_SCANCODE_APPS),
+	ENTRY(SDL_SCANCODE_MUTE, RDP_SCANCODE_VOLUME_MUTE),
+	ENTRY(SDL_SCANCODE_VOLUMEUP, RDP_SCANCODE_VOLUME_UP),
+	ENTRY(SDL_SCANCODE_VOLUMEDOWN, RDP_SCANCODE_VOLUME_DOWN),
+	ENTRY(SDL_SCANCODE_GRAVE, RDP_SCANCODE_OEM_3),
+	ENTRY(SDL_SCANCODE_COMMA, RDP_SCANCODE_OEM_COMMA),
+	ENTRY(SDL_SCANCODE_PERIOD, RDP_SCANCODE_OEM_PERIOD),
+	ENTRY(SDL_SCANCODE_SLASH, RDP_SCANCODE_OEM_2),
+	ENTRY(SDL_SCANCODE_BACKSLASH, RDP_SCANCODE_OEM_5),
+	ENTRY(SDL_SCANCODE_SCROLLLOCK, RDP_SCANCODE_SCROLLLOCK),
+	ENTRY(SDL_SCANCODE_INSERT, RDP_SCANCODE_INSERT),
+	ENTRY(SDL_SCANCODE_PRINTSCREEN, RDP_SCANCODE_PRINTSCREEN),
+	ENTRY(SDL_SCANCODE_HOME, RDP_SCANCODE_HOME),
+	ENTRY(SDL_SCANCODE_DELETE, RDP_SCANCODE_DELETE),
+	ENTRY(SDL_SCANCODE_RIGHT, RDP_SCANCODE_RIGHT),
+	ENTRY(SDL_SCANCODE_LEFT, RDP_SCANCODE_LEFT),
+	ENTRY(SDL_SCANCODE_DOWN, RDP_SCANCODE_DOWN),
+	ENTRY(SDL_SCANCODE_UP, RDP_SCANCODE_UP),
+	ENTRY(SDL_SCANCODE_SEMICOLON, RDP_SCANCODE_OEM_1),
+	ENTRY(SDL_SCANCODE_PAUSE, RDP_SCANCODE_PAUSE),
+	ENTRY(SDL_SCANCODE_PAGEUP, RDP_SCANCODE_PRIOR),
+	ENTRY(SDL_SCANCODE_END, RDP_SCANCODE_END),
+	ENTRY(SDL_SCANCODE_PAGEDOWN, RDP_SCANCODE_NEXT),
+	ENTRY(SDL_SCANCODE_AUDIONEXT, RDP_SCANCODE_MEDIA_NEXT_TRACK),
+	ENTRY(SDL_SCANCODE_AUDIOPREV, RDP_SCANCODE_MEDIA_PREV_TRACK),
+	ENTRY(SDL_SCANCODE_AUDIOSTOP, RDP_SCANCODE_MEDIA_STOP),
+	ENTRY(SDL_SCANCODE_AUDIOPLAY, RDP_SCANCODE_MEDIA_PLAY_PAUSE),
+	ENTRY(SDL_SCANCODE_AUDIOMUTE, RDP_SCANCODE_VOLUME_MUTE),
+	ENTRY(SDL_SCANCODE_MEDIASELECT, RDP_SCANCODE_LAUNCH_MEDIA_SELECT),
+	ENTRY(SDL_SCANCODE_MAIL, RDP_SCANCODE_LAUNCH_MAIL),
+	ENTRY(SDL_SCANCODE_APP1, RDP_SCANCODE_LAUNCH_APP1),
+	ENTRY(SDL_SCANCODE_APP2, RDP_SCANCODE_LAUNCH_APP2),
+	ENTRY(SDL_SCANCODE_SYSREQ, RDP_SCANCODE_SYSREQ),
+	ENTRY(SDL_SCANCODE_WWW, RDP_SCANCODE_BROWSER_HOME),
+	ENTRY(SDL_SCANCODE_LEFTBRACKET, RDP_SCANCODE_OEM_4),
+	ENTRY(SDL_SCANCODE_RIGHTBRACKET, RDP_SCANCODE_OEM_6),
+	ENTRY(SDL_SCANCODE_APOSTROPHE, RDP_SCANCODE_OEM_7),
+	ENTRY(SDL_SCANCODE_NONUSBACKSLASH, RDP_SCANCODE_OEM_102),
+	ENTRY(SDL_SCANCODE_SLEEP, RDP_SCANCODE_SLEEP),
+	ENTRY(SDL_SCANCODE_EQUALS, RDP_SCANCODE_OEM_PLUS),
+	ENTRY(SDL_SCANCODE_KP_COMMA, RDP_SCANCODE_DECIMAL),
+	ENTRY(SDL_SCANCODE_FIND, RDP_SCANCODE_BROWSER_SEARCH),
+	ENTRY(SDL_SCANCODE_RETURN2, RDP_SCANCODE_RETURN_KP),
+	ENTRY(SDL_SCANCODE_AC_SEARCH, RDP_SCANCODE_BROWSER_SEARCH),
+	ENTRY(SDL_SCANCODE_AC_HOME, RDP_SCANCODE_BROWSER_HOME),
+	ENTRY(SDL_SCANCODE_AC_BACK, RDP_SCANCODE_BROWSER_BACK),
+	ENTRY(SDL_SCANCODE_AC_FORWARD, RDP_SCANCODE_BROWSER_FORWARD),
+	ENTRY(SDL_SCANCODE_AC_STOP, RDP_SCANCODE_BROWSER_STOP),
+
+#if 1 // TODO: unmapped
+	ENTRY(SDL_SCANCODE_NONUSHASH, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_APPLICATION, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_POWER, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_EQUALS, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_EXECUTE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_HELP, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_MENU, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_SELECT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_STOP, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_AGAIN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_UNDO, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CUT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_COPY, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_PASTE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_EQUALSAS400, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL1, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL2, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL3, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL4, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL5, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL6, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL7, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL8, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL9, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG1, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG2, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG3, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG4, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG5, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG6, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG7, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG8, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG9, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_ALTERASE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CANCEL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CLEAR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_PRIOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_SEPARATOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_OUT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_OPER, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CLEARAGAIN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CRSEL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_EXSEL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_00, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_000, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_THOUSANDSSEPARATOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_DECIMALSEPARATOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CURRENCYUNIT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CURRENCYSUBUNIT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_LEFTPAREN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_RIGHTPAREN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_LEFTBRACE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_RIGHTBRACE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_TAB, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_BACKSPACE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_A, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_B, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_C, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_D, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_E, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_F, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_XOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_POWER, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_PERCENT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_LESS, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_GREATER, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_AMPERSAND, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_DBLAMPERSAND, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_VERTICALBAR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_DBLVERTICALBAR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_COLON, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_HASH, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_SPACE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_AT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_EXCLAM, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMSTORE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMRECALL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMCLEAR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMADD, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMSUBTRACT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMMULTIPLY, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMDIVIDE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_PLUSMINUS, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_CLEAR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_CLEARENTRY, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_BINARY, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_OCTAL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_DECIMAL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_HEXADECIMAL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CALCULATOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_COMPUTER, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_AC_REFRESH, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_AC_BOOKMARKS, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_BRIGHTNESSDOWN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_BRIGHTNESSUP, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_DISPLAYSWITCH, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KBDILLUMTOGGLE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KBDILLUMDOWN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KBDILLUMUP, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_EJECT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_AUDIOREWIND, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_AUDIOFASTFORWARD, RDP_SCANCODE_UNKNOWN)
+#endif
+};
+
+static UINT16 sdl_get_kbd_flags()
+{
+	UINT16 flags = 0;
+
+	SDL_Keymod mod = SDL_GetModState();
+	if ((mod & KMOD_NUM) != 0)
+		flags |= KBD_SYNC_NUM_LOCK;
+	if ((mod & KMOD_CAPS) != 0)
+		flags |= KBD_SYNC_CAPS_LOCK;
+#if SDL_VERSION_ATLEAST(2, 0, 18)
+	if ((mod & KMOD_SCROLL) != 0)
+		flags |= KBD_SYNC_SCROLL_LOCK;
+#endif
+
+	// TODO: KBD_SYNC_KANA_LOCK
+
+	return flags;
+}
+
+BOOL sdlInput::keyboard_sync_state()
+{
+	const auto syncFlags = sdl_get_kbd_flags();
+	return freerdp_input_send_synchronize_event(_sdl->context()->input, syncFlags);
+}
+
+BOOL sdlInput::keyboard_focus_in()
+{
+	auto input = _sdl->context()->input;
+	WINPR_ASSERT(input);
+
+	auto syncFlags = sdl_get_kbd_flags();
+	freerdp_input_send_focus_in_event(input, WINPR_ASSERTING_INT_CAST(UINT16, syncFlags));
+
+	/* finish with a mouse pointer position like mstsc.exe if required */
+#if 0
+    if (xfc->remote_app)
+        return;
+
+    if (XQueryPointer(xfc->display, xfc->window->handle, &w, &w, &d, &d, &x, &y, &state))
+    {
+        if ((x >= 0) && (x < xfc->window->width) && (y >= 0) && (y < xfc->window->height))
+        {
+            xf_event_adjust_coordinates(xfc, &x, &y);
+            freerdp_client_send_button_event(&xfc->common, FALSE, PTR_FLAGS_MOVE, x, y);
+        }
+    }
+#endif
+	return TRUE;
+}
+
+/* This function is called to update the keyboard indicator LED */
+BOOL sdlInput::keyboard_set_indicators(rdpContext* context, UINT16 led_flags)
+{
+	WINPR_UNUSED(context);
+
+	int state = KMOD_NONE;
+
+	if ((led_flags & KBD_SYNC_NUM_LOCK) != 0)
+		state |= KMOD_NUM;
+	if ((led_flags & KBD_SYNC_CAPS_LOCK) != 0)
+		state |= KMOD_CAPS;
+#if SDL_VERSION_ATLEAST(2, 0, 18)
+	if ((led_flags & KBD_SYNC_SCROLL_LOCK) != 0)
+		state |= KMOD_SCROLL;
+#endif
+
+	// TODO: KBD_SYNC_KANA_LOCK
+
+	SDL_SetModState(static_cast<SDL_Keymod>(state));
+
+	return TRUE;
+}
+
+/* This function is called to set the IME state */
+BOOL sdlInput::keyboard_set_ime_status(rdpContext* context, UINT16 imeId, UINT32 imeState,
+                                       UINT32 imeConvMode)
+{
+	if (!context)
+		return FALSE;
+
+	WLog_WARN(TAG,
+	          "KeyboardSetImeStatus(unitId=%04" PRIx16 ", imeState=%08" PRIx32
+	          ", imeConvMode=%08" PRIx32 ") ignored",
+	          imeId, imeState, imeConvMode);
+	return TRUE;
+}
+
+uint32_t sdlInput::prefToMask()
+{
+	const std::map<std::string, uint32_t> mapping = {
+		{ "KMOD_LSHIFT", KMOD_LSHIFT },
+		{ "KMOD_RSHIFT", KMOD_RSHIFT },
+		{ "KMOD_LCTRL", KMOD_LCTRL },
+		{ "KMOD_RCTRL", KMOD_RCTRL },
+		{ "KMOD_LALT", KMOD_LALT },
+		{ "KMOD_RALT", KMOD_RALT },
+		{ "KMOD_LGUI", KMOD_LGUI },
+		{ "KMOD_RGUI", KMOD_RGUI },
+		{ "KMOD_NUM", KMOD_NUM },
+		{ "KMOD_CAPS", KMOD_CAPS },
+		{ "KMOD_MODE", KMOD_MODE },
+#if SDL_VERSION_ATLEAST(2, 0, 18)
+		{ "KMOD_SCROLL", KMOD_SCROLL },
+#endif
+		{ "KMOD_CTRL", KMOD_CTRL },
+		{ "KMOD_SHIFT", KMOD_SHIFT },
+		{ "KMOD_ALT", KMOD_ALT },
+		{ "KMOD_GUI", KMOD_GUI }
+	};
+	uint32_t mod = KMOD_NONE;
+	for (const auto& val : SdlPref::instance()->get_array("SDL_KeyModMask", { "KMOD_RSHIFT" }))
+	{
+		auto it = mapping.find(val);
+		if (it != mapping.end())
+		{
+			mod |= it->second;
+		}
+	}
+	return mod;
+}
+
+static Uint32 sdl_scancode_val(const char* scancodeName)
+{
+	for (const auto& cur : map)
+	{
+		if (strcmp(cur.sdl_name, scancodeName) == 0)
+			return cur.sdl;
+	}
+
+	return SDL_SCANCODE_UNKNOWN;
+}
+
+static UINT32 sdl_scancode_to_rdp(Uint32 scancode)
+{
+	UINT32 rdp = RDP_SCANCODE_UNKNOWN;
+
+	for (const auto& cur : map)
+	{
+		if (cur.sdl == scancode)
+		{
+			rdp = cur.rdp;
+			break;
+		}
+	}
+
+#if defined(WITH_DEBUG_SDL_KBD_EVENTS)
+	auto code = static_cast<SDL_Scancode>(scancode);
+	WLog_DBG(TAG, "got %s [0x%08" PRIx32 "] -> [%s]", SDL_GetScancodeName(code), scancode,
+	         freerdp_keyboard_scancode_name(rdp));
+#endif
+	return rdp;
+}
+
+uint32_t sdlInput::prefKeyValue(const std::string& key, uint32_t fallback)
+{
+	auto item = SdlPref::instance()->get_string(key);
+	if (item.empty())
+		return fallback;
+	auto val = sdl_scancode_val(item.c_str());
+	if (val == SDL_SCANCODE_UNKNOWN)
+		return fallback;
+	return val;
+}
+
+std::list<std::string> sdlInput::tokenize(const std::string& data, const std::string& delimiter)
+{
+	size_t lastpos = 0;
+	size_t pos = 0;
+	std::list<std::string> list;
+	while ((pos = data.find(delimiter, lastpos)) != std::string::npos)
+	{
+		auto token = data.substr(lastpos, pos);
+		lastpos = pos + 1;
+		list.push_back(std::move(token));
+	}
+	auto token = data.substr(lastpos);
+	list.push_back(std::move(token));
+	return list;
+}
+
+bool sdlInput::extract(const std::string& token, uint32_t& key, uint32_t& value)
+{
+	return freerdp_extract_key_value(token.c_str(), &key, &value);
+}
+
+BOOL sdlInput::keyboard_handle_event(const SDL_KeyboardEvent* ev)
+{
+	WINPR_ASSERT(ev);
+	const UINT32 rdp_scancode = sdl_scancode_to_rdp(ev->keysym.scancode);
+	const SDL_Keymod mods = SDL_GetModState();
+
+	if ((mods & _hotkeyModmask) == _hotkeyModmask)
+	{
+		if (ev->type == SDL_KEYDOWN)
+		{
+			if (ev->keysym.scancode == _hotkeyFullscreen)
+			{
+				_sdl->update_fullscreen(!_sdl->fullscreen);
+				return TRUE;
+			}
+			if (ev->keysym.scancode == _hotkeyResizable)
+			{
+				_sdl->update_resizeable(!_sdl->resizeable);
+				return TRUE;
+			}
+
+			if (ev->keysym.scancode == _hotkeyGrab)
+			{
+				_sdl->grab_kbd_enabled = !_sdl->grab_kbd_enabled;
+				keyboard_grab(ev->windowID, _sdl->grab_kbd ? SDL_FALSE : SDL_TRUE);
+				return TRUE;
+			}
+			if (ev->keysym.scancode == _hotkeyDisconnect)
+			{
+				freerdp_abort_connect_context(_sdl->context());
+				return TRUE;
+			}
+			if (ev->keysym.scancode == _hotkeyMinimize)
+			{
+				_sdl->update_minimize();
+				return TRUE;
+			}
+		}
+	}
+
+	auto scancode = freerdp_keyboard_remap_key(_remapTable, rdp_scancode);
+	return freerdp_input_send_keyboard_event_ex(_sdl->context()->input, ev->type == SDL_KEYDOWN,
+	                                            ev->repeat, scancode);
+}
+
+BOOL sdlInput::keyboard_grab(Uint32 windowID, SDL_bool enable)
+{
+	auto it = _sdl->windows.find(windowID);
+	if (it == _sdl->windows.end())
+		return FALSE;
+
+	auto status = enable && _sdl->grab_kbd_enabled;
+	_sdl->grab_kbd = status;
+	return it->second.grabKeyboard(status);
+}
+
+BOOL sdlInput::mouse_focus(Uint32 windowID)
+{
+	if (_lastWindowID != windowID)
+	{
+		_lastWindowID = windowID;
+		auto it = _sdl->windows.find(windowID);
+		if (it == _sdl->windows.end())
+			return FALSE;
+
+		it->second.raise();
+	}
+	return TRUE;
+}
+
+BOOL sdlInput::mouse_grab(Uint32 windowID, SDL_bool enable)
+{
+	auto it = _sdl->windows.find(windowID);
+	if (it == _sdl->windows.end())
+		return FALSE;
+	_sdl->grab_mouse = enable;
+	return it->second.grabMouse(enable);
+}
+
+sdlInput::sdlInput(SdlContext* sdl)
+    : _sdl(sdl), _lastWindowID(UINT32_MAX), _hotkeyModmask(prefToMask())
+{
+	auto list =
+	    freerdp_settings_get_string(_sdl->context()->settings, FreeRDP_KeyboardRemappingList);
+	_remapTable = freerdp_keyboard_remap_string_to_list(list);
+	assert(_remapTable);
+	_hotkeyFullscreen = prefKeyValue("SDL_Fullscreen", SDL_SCANCODE_RETURN);
+	_hotkeyResizable = prefKeyValue("SDL_Resizeable", SDL_SCANCODE_R);
+	_hotkeyGrab = prefKeyValue("SDL_Grab", SDL_SCANCODE_G);
+	_hotkeyDisconnect = prefKeyValue("SDL_Disconnect", SDL_SCANCODE_D);
+	_hotkeyMinimize = prefKeyValue("SDL_Minimize", SDL_SCANCODE_M);
+}
+
+sdlInput::~sdlInput()
+{
+	freerdp_keyboard_remap_free(_remapTable);
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/sdl_kbd.hpp

@@ -0,0 +1,77 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client keyboard helper
+ *
+ * Copyright 2022 Armin Novak <[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.
+ */
+
+#pragma once
+
+#include <string>
+#include <map>
+#include <list>
+#include <atomic>
+
+#include <winpr/wtypes.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/locale/keyboard.h>
+#include <SDL.h>
+
+#include "sdl_types.hpp"
+
+class sdlInput
+{
+  public:
+	explicit sdlInput(SdlContext* sdl);
+	sdlInput(const sdlInput& other) = delete;
+	sdlInput(sdlInput&& other) = delete;
+	~sdlInput();
+
+	sdlInput& operator=(const sdlInput& other) = delete;
+	sdlInput& operator=(sdlInput&& other) = delete;
+
+	BOOL keyboard_sync_state();
+	BOOL keyboard_focus_in();
+
+	BOOL keyboard_handle_event(const SDL_KeyboardEvent* ev);
+
+	BOOL keyboard_grab(Uint32 windowID, SDL_bool enable);
+	BOOL mouse_focus(Uint32 windowID);
+	BOOL mouse_grab(Uint32 windowID, SDL_bool enable);
+
+	static BOOL keyboard_set_indicators(rdpContext* context, UINT16 led_flags);
+	static BOOL keyboard_set_ime_status(rdpContext* context, UINT16 imeId, UINT32 imeState,
+	                                    UINT32 imeConvMode);
+
+	static uint32_t prefToMask();
+	static uint32_t prefKeyValue(const std::string& key, uint32_t fallback = SDL_SCANCODE_UNKNOWN);
+
+  private:
+	static std::list<std::string> tokenize(const std::string& data,
+	                                       const std::string& delimiter = ",");
+	static bool extract(const std::string& token, uint32_t& key, uint32_t& value);
+
+	SdlContext* _sdl;
+	Uint32 _lastWindowID;
+
+	// hotkey handling
+	uint32_t _hotkeyModmask; // modifier keys mask
+	uint32_t _hotkeyFullscreen;
+	uint32_t _hotkeyResizable;
+	uint32_t _hotkeyGrab;
+	uint32_t _hotkeyDisconnect;
+	uint32_t _hotkeyMinimize;
+	FREERDP_REMAP_TABLE* _remapTable;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/sdl_window.hpp

@@ -0,0 +1,64 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client
+ *
+ * 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.
+ */
+#pragma once
+
+#include <string>
+#include <SDL.h>
+
+class SdlWindow
+{
+  public:
+	SdlWindow(const std::string& title, Sint32 startupX, Sint32 startupY, Sint32 width,
+	          Sint32 height, Uint32 flags);
+	SdlWindow(const SdlWindow& other) = delete;
+	SdlWindow(SdlWindow&& other) noexcept;
+	~SdlWindow();
+
+	SdlWindow& operator=(const SdlWindow& other) = delete;
+	SdlWindow& operator=(SdlWindow&& other) = delete;
+
+	[[nodiscard]] Uint32 id() const;
+	[[nodiscard]] int displayIndex() const;
+	[[nodiscard]] SDL_Rect rect() const;
+	[[nodiscard]] SDL_Window* window() const;
+
+	[[nodiscard]] Sint32 offsetX() const;
+	void setOffsetX(Sint32 x);
+
+	void setOffsetY(Sint32 y);
+	[[nodiscard]] Sint32 offsetY() const;
+
+	bool grabKeyboard(bool enable);
+	bool grabMouse(bool enable);
+	void setBordered(bool bordered);
+	void raise();
+	void resizeable(bool use);
+	void fullscreen(bool enter);
+	void minimize();
+
+	bool fill(Uint8 r = 0x00, Uint8 g = 0x00, Uint8 b = 0x00, Uint8 a = 0xff);
+	bool blit(SDL_Surface* surface, SDL_Rect src, SDL_Rect& dst);
+	void updateSurface();
+
+  private:
+	SDL_Window* _window = nullptr;
+	Sint32 _offset_x = 0;
+	Sint32 _offset_y = 0;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/CMakeLists.txt

@@ -0,0 +1,75 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP SDL Client
+#
+# Copyright 2024 Armin Novak <[email protected]>
+# Copyright 2024 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.
+set(SRCS
+    sdl_button.hpp
+    sdl_button.cpp
+    sdl_buttons.hpp
+    sdl_buttons.cpp
+    sdl_dialogs.cpp
+    sdl_dialogs.hpp
+    sdl_widget.hpp
+    sdl_widget.cpp
+    sdl_input.hpp
+    sdl_input.cpp
+    sdl_input_widgets.cpp
+    sdl_input_widgets.hpp
+    sdl_select.hpp
+    sdl_select.cpp
+    sdl_selectlist.hpp
+    sdl_selectlist.cpp
+    sdl_connection_dialog.cpp
+    sdl_connection_dialog.hpp
+)
+
+list(APPEND LIBS sdl3_client_res winpr)
+
+if(NOT WITH_SDL_LINK_SHARED)
+  list(APPEND LIBS ${SDL3_STATIC_LIBRARIES})
+else()
+  list(APPEND LIBS ${SDL3_LIBRARIES})
+endif()
+
+macro(find_sdl_component name)
+  find_package(${name} REQUIRED)
+  if(WITH_SDL_LINK_SHARED)
+    list(APPEND LIBS ${name}::${name})
+    set_target_properties(${name}::${name}-shared PROPERTIES SYSTEM TRUE)
+  else()
+    list(APPEND LIBS ${name}::${name}-static)
+    set_target_properties(${name}::${name}-static PROPERTIES SYSTEM TRUE)
+  endif()
+
+endmacro()
+
+find_sdl_component(SDL3_ttf)
+
+option(WITH_SDL_IMAGE_DIALOGS "Build with SDL_image support (recommended)" OFF)
+if(WITH_SDL_IMAGE_DIALOGS)
+  find_sdl_component(SDL3_image)
+  add_compile_definitions(WITH_SDL_IMAGE_DIALOGS)
+endif()
+
+add_subdirectory(res)
+
+add_library(sdl3-dialogs STATIC ${SRCS})
+
+target_link_libraries(sdl3-dialogs PRIVATE ${LIBS})
+
+if(BUILD_TESTING)
+  #	add_subdirectory(test)
+endif()

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/res/sdl3_resource_manager.cpp

@@ -0,0 +1,43 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2023 Armin Novak <[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 "sdl3_resource_manager.hpp"
+#include <iostream>
+#if __has_include(<filesystem>)
+#include <filesystem>
+namespace fs = std::filesystem;
+#elif __has_include(<experimental/filesystem>)
+#include <experimental/filesystem>
+namespace fs = std::experimental::filesystem;
+#else
+#error Could not find system header "<filesystem>" or "<experimental/filesystem>"
+#endif
+
+SDL_IOStream* SDL3ResourceManager::get(const std::string& type, const std::string& id)
+{
+	if (useCompiledResources())
+	{
+		auto d = data(type, id);
+		if (!d)
+			return nullptr;
+
+		return SDL_IOFromConstMem(d->data(), d->size());
+	}
+
+	auto name = filename(type, id);
+	return SDL_IOFromFile(name.c_str(), "rb");
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/res/sdl3_resource_manager.hpp

@@ -0,0 +1,38 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2023 Armin Novak <[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.
+ */
+#pragma once
+
+#include <string>
+#include <map>
+#include <vector>
+#include <SDL3/SDL.h>
+
+#include <res/sdl_resource_manager.hpp>
+
+class SDL3ResourceManager : public SDLResourceManager
+{
+  public:
+	SDL3ResourceManager() = delete;
+	SDL3ResourceManager(const SDL3ResourceManager& other) = delete;
+	SDL3ResourceManager(const SDL3ResourceManager&& other) = delete;
+	~SDL3ResourceManager() = delete;
+	SDL3ResourceManager& operator=(const SDL3ResourceManager& other) = delete;
+	SDL3ResourceManager& operator=(SDL3ResourceManager&& other) = delete;
+
+	static SDL_IOStream* get(const std::string& type, const std::string& id);
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_button.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+
+#include "sdl_widget.hpp"
+
+class SdlButton : public SdlWidget
+{
+  public:
+	SdlButton(SDL_Renderer* renderer, std::string label, int id, const SDL_FRect& rect);
+	SdlButton(SdlButton&& other) noexcept;
+	SdlButton(const SdlButton& other) = delete;
+	~SdlButton() override;
+
+	SdlButton& operator=(const SdlButton& other) = delete;
+	SdlButton& operator=(SdlButton&& other) = delete;
+
+	bool highlight(SDL_Renderer* renderer);
+	bool mouseover(SDL_Renderer* renderer);
+	bool update(SDL_Renderer* renderer);
+
+	[[nodiscard]] int id() const;
+
+  private:
+	std::string _name;
+	int _id;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_buttons.cpp

@@ -0,0 +1,109 @@
+#include <cassert>
+#include <algorithm>
+
+#include "sdl_buttons.hpp"
+
+static const Uint32 hpadding = 10;
+
+SdlButtonList::~SdlButtonList() = default;
+
+bool SdlButtonList::populate(SDL_Renderer* renderer, const std::vector<std::string>& labels,
+                             const std::vector<int>& ids, Sint32 total_width, Sint32 offsetY,
+                             Sint32 width, Sint32 height)
+{
+	assert(renderer);
+	assert(width >= 0);
+	assert(height >= 0);
+	assert(labels.size() == ids.size());
+
+	_list.clear();
+	size_t button_width = ids.size() * (static_cast<size_t>(width) + hpadding) + hpadding;
+	size_t offsetX = static_cast<size_t>(total_width) -
+	                 std::min<size_t>(static_cast<size_t>(total_width), button_width);
+	for (size_t x = 0; x < ids.size(); x++)
+	{
+		const size_t curOffsetX = offsetX + x * (static_cast<size_t>(width) + hpadding);
+		const SDL_FRect rect = { static_cast<float>(curOffsetX), static_cast<float>(offsetY),
+			                     static_cast<float>(width), static_cast<float>(height) };
+		_list.emplace_back(renderer, labels[x], ids[x], rect);
+	}
+	return true;
+}
+
+SdlButton* SdlButtonList::get_selected(const SDL_MouseButtonEvent& button)
+{
+	const auto x = button.x;
+	const auto y = button.y;
+
+	return get_selected(x, y);
+}
+
+SdlButton* SdlButtonList::get_selected(float x, float y)
+{
+	for (auto& btn : _list)
+	{
+		auto r = btn.rect();
+		if ((x >= r.x) && (x <= r.x + r.w) && (y >= r.y) && (y <= r.y + r.h))
+			return &btn;
+	}
+	return nullptr;
+}
+
+bool SdlButtonList::set_highlight_next(bool reset)
+{
+	if (reset)
+		_highlighted = nullptr;
+	else
+	{
+		auto next = _highlight_index++;
+		_highlight_index %= _list.size();
+		auto& element = _list[next];
+		_highlighted = &element;
+	}
+	return true;
+}
+
+bool SdlButtonList::set_highlight(size_t index)
+{
+	if (index >= _list.size())
+	{
+		_highlighted = nullptr;
+		return false;
+	}
+	auto& element = _list[index];
+	_highlighted = &element;
+	_highlight_index = ++index % _list.size();
+	return true;
+}
+
+bool SdlButtonList::set_mouseover(float x, float y)
+{
+	_mouseover = get_selected(x, y);
+	return _mouseover != nullptr;
+}
+
+void SdlButtonList::clear()
+{
+	_list.clear();
+	_mouseover = nullptr;
+	_highlighted = nullptr;
+	_highlight_index = 0;
+}
+
+bool SdlButtonList::update(SDL_Renderer* renderer)
+{
+	assert(renderer);
+
+	for (auto& btn : _list)
+	{
+		if (!btn.update(renderer))
+			return false;
+	}
+
+	if (_highlighted)
+		_highlighted->highlight(renderer);
+
+	if (_mouseover)
+		_mouseover->mouseover(renderer);
+	return true;
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_buttons.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <vector>
+#include <cstdint>
+
+#include "sdl_button.hpp"
+
+class SdlButtonList
+{
+  public:
+	SdlButtonList() = default;
+	SdlButtonList(const SdlButtonList& other) = delete;
+	SdlButtonList(SdlButtonList&& other) = delete;
+	virtual ~SdlButtonList();
+
+	SdlButtonList& operator=(const SdlButtonList& other) = delete;
+	SdlButtonList& operator=(SdlButtonList&& other) = delete;
+
+	bool populate(SDL_Renderer* renderer, const std::vector<std::string>& labels,
+	              const std::vector<int>& ids, Sint32 total_width, Sint32 offsetY, Sint32 width,
+	              Sint32 height);
+
+	bool update(SDL_Renderer* renderer);
+	SdlButton* get_selected(const SDL_MouseButtonEvent& button);
+	SdlButton* get_selected(float x, float y);
+
+	bool set_highlight_next(bool reset = false);
+	bool set_highlight(size_t index);
+	bool set_mouseover(float x, float y);
+
+	void clear();
+
+  private:
+	std::vector<SdlButton> _list;
+	SdlButton* _highlighted = nullptr;
+	size_t _highlight_index = 0;
+	SdlButton* _mouseover = nullptr;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_connection_dialog.cpp

@@ -0,0 +1,537 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[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 <cassert>
+#include <thread>
+
+#include "sdl_connection_dialog.hpp"
+#include "../sdl_utils.hpp"
+#include "../sdl_freerdp.hpp"
+#include "res/sdl3_resource_manager.hpp"
+
+static const SDL_Color backgroundcolor = { 0x38, 0x36, 0x35, 0xff };
+static const SDL_Color textcolor = { 0xd1, 0xcf, 0xcd, 0xff };
+static const SDL_Color infocolor = { 0x43, 0xe0, 0x0f, 0x60 };
+static const SDL_Color warncolor = { 0xcd, 0xca, 0x35, 0x60 };
+static const SDL_Color errorcolor = { 0xf7, 0x22, 0x30, 0x60 };
+
+static const Uint32 vpadding = 5;
+static const Uint32 hpadding = 5;
+
+SDLConnectionDialog::SDLConnectionDialog(rdpContext* context) : _context(context)
+{
+	SDL_Init(SDL_INIT_EVENTS | SDL_INIT_VIDEO);
+	hide();
+}
+
+SDLConnectionDialog::~SDLConnectionDialog()
+{
+	resetTimer();
+	destroyWindow();
+	SDL_Quit();
+}
+
+bool SDLConnectionDialog::visible() const
+{
+	if (!_window || !_renderer)
+		return false;
+
+	auto flags = SDL_GetWindowFlags(_window);
+	return (flags & (SDL_WINDOW_HIDDEN | SDL_WINDOW_MINIMIZED)) == 0;
+}
+
+bool SDLConnectionDialog::setTitle(const char* fmt, ...)
+{
+	std::lock_guard lock(_mux);
+	va_list ap = {};
+	va_start(ap, fmt);
+	_title = print(fmt, ap);
+	va_end(ap);
+
+	return show(MSG_NONE);
+}
+
+bool SDLConnectionDialog::showInfo(const char* fmt, ...)
+{
+	va_list ap = {};
+	va_start(ap, fmt);
+	auto rc = show(MSG_INFO, fmt, ap);
+	va_end(ap);
+	return rc;
+}
+
+bool SDLConnectionDialog::showWarn(const char* fmt, ...)
+{
+	va_list ap = {};
+	va_start(ap, fmt);
+	auto rc = show(MSG_WARN, fmt, ap);
+	va_end(ap);
+	return rc;
+}
+
+bool SDLConnectionDialog::showError(const char* fmt, ...)
+{
+	va_list ap = {};
+	va_start(ap, fmt);
+	auto rc = show(MSG_ERROR, fmt, ap);
+	va_end(ap);
+	if (!rc)
+		return rc;
+	return setTimer();
+}
+
+bool SDLConnectionDialog::show()
+{
+	std::lock_guard lock(_mux);
+	return show(_type_active);
+}
+
+bool SDLConnectionDialog::hide()
+{
+	std::lock_guard lock(_mux);
+	return show(MSG_DISCARD);
+}
+
+bool SDLConnectionDialog::running() const
+{
+	std::lock_guard lock(_mux);
+	return _running;
+}
+
+bool SDLConnectionDialog::update()
+{
+	std::lock_guard lock(_mux);
+	switch (_type)
+	{
+		case MSG_INFO:
+		case MSG_WARN:
+		case MSG_ERROR:
+			_type_active = _type;
+			createWindow();
+			break;
+		case MSG_DISCARD:
+			resetTimer();
+			destroyWindow();
+			break;
+		default:
+			if (_window)
+			{
+				SDL_SetWindowTitle(_window, _title.c_str());
+			}
+			break;
+	}
+	_type = MSG_NONE;
+	return true;
+}
+
+bool SDLConnectionDialog::setModal()
+{
+	if (_window)
+	{
+		auto sdl = get_context(_context);
+		if (sdl->windows.empty())
+			return true;
+
+		auto parent = sdl->windows.begin()->second.window();
+		SDL_SetWindowParent(_window, parent);
+		SDL_SetWindowModal(_window, true);
+		SDL_RaiseWindow(_window);
+	}
+	return true;
+}
+
+bool SDLConnectionDialog::clearWindow(SDL_Renderer* renderer)
+{
+	assert(renderer);
+
+	const int drc = SDL_SetRenderDrawColor(renderer, backgroundcolor.r, backgroundcolor.g,
+	                                       backgroundcolor.b, backgroundcolor.a);
+	if (widget_log_error(drc, "SDL_SetRenderDrawColor"))
+		return false;
+
+	const int rcls = SDL_RenderClear(renderer);
+	return !widget_log_error(rcls, "SDL_RenderClear");
+}
+
+bool SDLConnectionDialog::update(SDL_Renderer* renderer)
+{
+	std::lock_guard lock(_mux);
+	if (!renderer)
+		return false;
+
+	if (!clearWindow(renderer))
+		return false;
+
+	for (auto& btn : _list)
+	{
+		if (!btn.widget.update_text(renderer, _msg, btn.fgcolor, btn.bgcolor))
+			return false;
+	}
+
+	if (!_buttons.update(renderer))
+		return false;
+
+	SDL_RenderPresent(renderer);
+	return true;
+}
+
+bool SDLConnectionDialog::wait(bool ignoreRdpContext)
+{
+	while (running())
+	{
+		if (!ignoreRdpContext)
+		{
+			if (freerdp_shall_disconnect_context(_context))
+				return false;
+		}
+		std::this_thread::yield();
+	}
+	return true;
+}
+
+bool SDLConnectionDialog::handle(const SDL_Event& event)
+{
+	Uint32 windowID = 0;
+	if (_window)
+	{
+		windowID = SDL_GetWindowID(_window);
+	}
+
+	switch (event.type)
+	{
+		case SDL_EVENT_USER_RETRY_DIALOG:
+			return update();
+		case SDL_EVENT_QUIT:
+			resetTimer();
+			destroyWindow();
+			return false;
+		case SDL_EVENT_KEY_DOWN:
+		case SDL_EVENT_KEY_UP:
+			if (visible())
+			{
+				auto& ev = reinterpret_cast<const SDL_KeyboardEvent&>(event);
+				update(_renderer);
+				switch (event.key.key)
+				{
+					case SDLK_RETURN:
+					case SDLK_RETURN2:
+					case SDLK_ESCAPE:
+					case SDLK_KP_ENTER:
+						if (event.type == SDL_EVENT_KEY_UP)
+						{
+							freerdp_abort_event(_context);
+							sdl_push_quit();
+						}
+						break;
+					case SDLK_TAB:
+						_buttons.set_highlight_next();
+						break;
+					default:
+						break;
+				}
+
+				return windowID == ev.windowID;
+			}
+			return false;
+		case SDL_EVENT_MOUSE_MOTION:
+			if (visible())
+			{
+				auto& ev = reinterpret_cast<const SDL_MouseMotionEvent&>(event);
+
+				_buttons.set_mouseover(event.button.x, event.button.y);
+				update(_renderer);
+				return windowID == ev.windowID;
+			}
+			return false;
+		case SDL_EVENT_MOUSE_BUTTON_DOWN:
+		case SDL_EVENT_MOUSE_BUTTON_UP:
+			if (visible())
+			{
+				auto& ev = reinterpret_cast<const SDL_MouseButtonEvent&>(event);
+				update(_renderer);
+
+				auto button = _buttons.get_selected(event.button);
+				if (button)
+				{
+					if (event.type == SDL_EVENT_MOUSE_BUTTON_UP)
+					{
+						freerdp_abort_event(_context);
+						sdl_push_quit();
+					}
+				}
+
+				return windowID == ev.windowID;
+			}
+			return false;
+		case SDL_EVENT_MOUSE_WHEEL:
+			if (visible())
+			{
+				auto& ev = reinterpret_cast<const SDL_MouseWheelEvent&>(event);
+				update(_renderer);
+				return windowID == ev.windowID;
+			}
+			return false;
+		case SDL_EVENT_FINGER_UP:
+		case SDL_EVENT_FINGER_DOWN:
+			if (visible())
+			{
+				auto& ev = reinterpret_cast<const SDL_TouchFingerEvent&>(event);
+				update(_renderer);
+				return windowID == ev.windowID;
+			}
+			return false;
+		default:
+			if ((event.type >= SDL_EVENT_WINDOW_FIRST) && (event.type <= SDL_EVENT_WINDOW_LAST))
+			{
+				auto& ev = reinterpret_cast<const SDL_WindowEvent&>(event);
+				switch (ev.type)
+				{
+					case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
+						if (windowID == ev.windowID)
+						{
+							freerdp_abort_event(_context);
+							sdl_push_quit();
+						}
+						break;
+					default:
+						update(_renderer);
+						setModal();
+						break;
+				}
+
+				return windowID == ev.windowID;
+			}
+			return false;
+	}
+}
+
+bool SDLConnectionDialog::createWindow()
+{
+	destroyWindow();
+
+	const int widget_height = 50;
+	const int widget_width = 600;
+	const int total_height = 300;
+
+	auto rc = SDL_CreateWindowAndRenderer(_title.c_str(), widget_width, total_height,
+	                                      SDL_WINDOW_HIGH_PIXEL_DENSITY | SDL_WINDOW_MOUSE_FOCUS |
+	                                          SDL_WINDOW_INPUT_FOCUS,
+	                                      &_window, &_renderer);
+	if (rc != 0)
+	{
+		widget_log_error(rc, "SDL_CreateWindowAndRenderer");
+		return false;
+	}
+	setModal();
+
+	SDL_Color res_bgcolor;
+	switch (_type_active)
+	{
+		case MSG_INFO:
+			res_bgcolor = infocolor;
+			break;
+		case MSG_WARN:
+			res_bgcolor = warncolor;
+			break;
+		case MSG_ERROR:
+			res_bgcolor = errorcolor;
+			break;
+		case MSG_DISCARD:
+		default:
+			res_bgcolor = backgroundcolor;
+			break;
+	}
+
+#if defined(WITH_SDL_IMAGE_DIALOGS)
+	std::string res_name;
+	switch (_type_active)
+	{
+		case MSG_INFO:
+			res_name = "icon_info.svg";
+			break;
+		case MSG_WARN:
+			res_name = "icon_warning.svg";
+			break;
+		case MSG_ERROR:
+			res_name = "icon_error.svg";
+			break;
+		case MSG_DISCARD:
+		default:
+			res_name = "";
+			break;
+	}
+
+	int height = (total_height - 3ul * vpadding) / 2ul;
+	SDL_FRect iconRect{ hpadding, vpadding, widget_width / 4ul - 2ul * hpadding,
+		                static_cast<float>(height) };
+	widget_cfg_t icon{ textcolor,
+		               res_bgcolor,
+		               { _renderer, iconRect,
+		                 SDL3ResourceManager::get(SDLResourceManager::typeImages(), res_name) } };
+	_list.emplace_back(std::move(icon));
+
+	iconRect.y += static_cast<float>(height);
+
+	widget_cfg_t logo{ textcolor,
+		               backgroundcolor,
+		               { _renderer, iconRect,
+		                 SDL3ResourceManager::get(SDLResourceManager::typeImages(),
+		                                          "FreeRDP_Icon.svg") } };
+	_list.emplace_back(std::move(logo));
+
+	SDL_FRect rect = { widget_width / 4ul, vpadding, widget_width * 3ul / 4ul,
+		               total_height - 3ul * vpadding - widget_height };
+#else
+	SDL_FRect rect = { hpadding, vpadding, widget_width - 2ul * hpadding,
+		               total_height - 2ul * vpadding };
+#endif
+
+	widget_cfg_t w{ textcolor, backgroundcolor, { _renderer, rect, false } };
+	w.widget.set_wrap(true, widget_width);
+	_list.emplace_back(std::move(w));
+	rect.y += widget_height + vpadding;
+
+	const std::vector<int> buttonids = { 1 };
+	const std::vector<std::string> buttonlabels = { "cancel" };
+	_buttons.populate(_renderer, buttonlabels, buttonids, widget_width,
+	                  total_height - widget_height - vpadding,
+	                  static_cast<Sint32>(widget_width / 2), static_cast<Sint32>(widget_height));
+	_buttons.set_highlight(0);
+
+	SDL_ShowWindow(_window);
+	SDL_RaiseWindow(_window);
+
+	return true;
+}
+
+void SDLConnectionDialog::destroyWindow()
+{
+	_buttons.clear();
+	_list.clear();
+	SDL_DestroyRenderer(_renderer);
+	SDL_DestroyWindow(_window);
+	_renderer = nullptr;
+	_window = nullptr;
+}
+
+bool SDLConnectionDialog::show(MsgType type, const char* fmt, va_list ap)
+{
+	std::lock_guard lock(_mux);
+	_msg = print(fmt, ap);
+	return show(type);
+}
+
+bool SDLConnectionDialog::show(MsgType type)
+{
+	_type = type;
+	return sdl_push_user_event(SDL_EVENT_USER_RETRY_DIALOG);
+}
+
+std::string SDLConnectionDialog::print(const char* fmt, va_list ap)
+{
+	int size = -1;
+	std::string res;
+
+	do
+	{
+		res.resize(128);
+		if (size > 0)
+			res.resize(WINPR_ASSERTING_INT_CAST(uint32_t, size));
+
+		va_list copy;
+		va_copy(copy, ap);
+		WINPR_PRAGMA_DIAG_PUSH
+		WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL
+		size = vsnprintf(res.data(), res.size(), fmt, copy);
+		WINPR_PRAGMA_DIAG_POP
+		va_end(copy);
+
+	} while ((size > 0) && (static_cast<size_t>(size) > res.size()));
+
+	return res;
+}
+
+bool SDLConnectionDialog::setTimer(Uint32 timeoutMS)
+{
+	std::lock_guard lock(_mux);
+	resetTimer();
+
+	_timer = SDL_AddTimer(timeoutMS, &SDLConnectionDialog::timeout, this);
+	_running = true;
+	return true;
+}
+
+void SDLConnectionDialog::resetTimer()
+{
+	if (_running)
+		SDL_RemoveTimer(_timer);
+	_running = false;
+}
+
+Uint32 SDLConnectionDialog::timeout(void* pvthis, SDL_TimerID timerID, Uint32 intervalMS)
+{
+	auto self = static_cast<SDLConnectionDialog*>(pvthis);
+	self->hide();
+	self->_running = false;
+	return 0;
+}
+
+SDLConnectionDialogHider::SDLConnectionDialogHider(freerdp* instance)
+    : SDLConnectionDialogHider(get(instance))
+{
+}
+
+SDLConnectionDialogHider::SDLConnectionDialogHider(rdpContext* context)
+    : SDLConnectionDialogHider(get(context))
+{
+}
+
+SDLConnectionDialogHider::SDLConnectionDialogHider(SDLConnectionDialog* dialog) : _dialog(dialog)
+{
+	if (_dialog)
+	{
+		_visible = _dialog->visible();
+		if (_visible)
+		{
+			_dialog->hide();
+		}
+	}
+}
+
+SDLConnectionDialogHider::~SDLConnectionDialogHider()
+{
+	if (_dialog && _visible)
+	{
+		_dialog->show();
+	}
+}
+
+SDLConnectionDialog* SDLConnectionDialogHider::get(freerdp* instance)
+{
+	if (!instance)
+		return nullptr;
+	return get(instance->context);
+}
+
+SDLConnectionDialog* SDLConnectionDialogHider::get(rdpContext* context)
+{
+	auto sdl = get_context(context);
+	if (!sdl)
+		return nullptr;
+	return sdl->connection_dialog.get();
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_connection_dialog.hpp

@@ -0,0 +1,132 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[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.
+ */
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#include <SDL3/SDL.h>
+
+#include <freerdp/freerdp.h>
+
+#include "sdl_widget.hpp"
+#include "sdl_buttons.hpp"
+
+class SDLConnectionDialog
+{
+  public:
+	explicit SDLConnectionDialog(rdpContext* context);
+	SDLConnectionDialog(const SDLConnectionDialog& other) = delete;
+	SDLConnectionDialog(const SDLConnectionDialog&& other) = delete;
+	virtual ~SDLConnectionDialog();
+
+	SDLConnectionDialog& operator=(const SDLConnectionDialog& other) = delete;
+	SDLConnectionDialog& operator=(SDLConnectionDialog& other) = delete;
+
+	bool visible() const;
+
+	bool setTitle(const char* fmt, ...);
+	bool showInfo(const char* fmt, ...);
+	bool showWarn(const char* fmt, ...);
+	bool showError(const char* fmt, ...);
+
+	bool show();
+	bool hide();
+
+	bool running() const;
+	bool wait(bool ignoreRdpContextQuit = false);
+
+	bool handle(const SDL_Event& event);
+
+  private:
+	enum MsgType
+	{
+		MSG_NONE,
+		MSG_INFO,
+		MSG_WARN,
+		MSG_ERROR,
+		MSG_DISCARD
+	};
+
+	bool createWindow();
+	void destroyWindow();
+
+	bool update();
+
+	bool setModal();
+
+	static bool clearWindow(SDL_Renderer* renderer);
+
+	bool update(SDL_Renderer* renderer);
+
+	bool show(MsgType type, const char* fmt, va_list ap);
+	bool show(MsgType type);
+
+	static std::string print(const char* fmt, va_list ap);
+	bool setTimer(Uint32 timeoutMS = 15000);
+	void resetTimer();
+
+	static Uint32 timeout(void* pvthis, SDL_TimerID timerID, Uint32 intervalMS);
+
+	struct widget_cfg_t
+	{
+		SDL_Color fgcolor = {};
+		SDL_Color bgcolor = {};
+		SdlWidget widget;
+	};
+
+	rdpContext* _context = nullptr;
+	SDL_Window* _window = nullptr;
+	SDL_Renderer* _renderer = nullptr;
+	mutable std::mutex _mux;
+	std::string _title;
+	std::string _msg;
+	MsgType _type = MSG_NONE;
+	MsgType _type_active = MSG_NONE;
+	SDL_TimerID _timer = 0;
+	bool _running = false;
+	std::vector<widget_cfg_t> _list;
+	SdlButtonList _buttons;
+};
+
+class SDLConnectionDialogHider
+{
+  public:
+	explicit SDLConnectionDialogHider(freerdp* instance);
+	explicit SDLConnectionDialogHider(rdpContext* context);
+
+	explicit SDLConnectionDialogHider(SDLConnectionDialog* dialog);
+
+	SDLConnectionDialogHider(const SDLConnectionDialogHider& other) = delete;
+	SDLConnectionDialogHider(SDLConnectionDialogHider&& other) = delete;
+	SDLConnectionDialogHider& operator=(const SDLConnectionDialogHider& other) = delete;
+	SDLConnectionDialogHider& operator=(SDLConnectionDialogHider& other) = delete;
+
+	~SDLConnectionDialogHider();
+
+  private:
+	SDLConnectionDialog* get(freerdp* instance);
+	static SDLConnectionDialog* get(rdpContext* context);
+
+	SDLConnectionDialog* _dialog = nullptr;
+	bool _visible = false;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_dialogs.cpp

@@ -0,0 +1,620 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[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 <vector>
+#include <string>
+#include <cassert>
+
+#include <freerdp/log.h>
+#include <freerdp/utils/smartcardlogon.h>
+
+#include <SDL3/SDL.h>
+
+#include "../sdl_freerdp.hpp"
+#include "sdl_dialogs.hpp"
+#include "sdl_input.hpp"
+#include "sdl_input_widgets.hpp"
+#include "sdl_select.hpp"
+#include "sdl_selectlist.hpp"
+
+enum
+{
+	SHOW_DIALOG_ACCEPT_REJECT = 1,
+	SHOW_DIALOG_TIMED_ACCEPT = 2
+};
+
+static const char* type_str_for_flags(UINT32 flags)
+{
+	const char* type = "RDP-Server";
+
+	if (flags & VERIFY_CERT_FLAG_GATEWAY)
+		type = "RDP-Gateway";
+
+	if (flags & VERIFY_CERT_FLAG_REDIRECT)
+		type = "RDP-Redirect";
+	return type;
+}
+
+static BOOL sdl_wait_for_result(rdpContext* context, Uint32 type, SDL_Event* result)
+{
+	const SDL_Event empty = {};
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(result);
+
+	while (!freerdp_shall_disconnect_context(context))
+	{
+		*result = empty;
+		const int rc = SDL_PeepEvents(result, 1, SDL_GETEVENT, type, type);
+		if (rc > 0)
+			return TRUE;
+		Sleep(1);
+	}
+	return FALSE;
+}
+
+static int sdl_show_dialog(rdpContext* context, const char* title, const char* message,
+                           Sint32 flags)
+{
+	SDL_Event event = {};
+
+	if (!sdl_push_user_event(SDL_EVENT_USER_SHOW_DIALOG, title, message, flags))
+		return 0;
+
+	if (!sdl_wait_for_result(context, SDL_EVENT_USER_SHOW_RESULT, &event))
+		return 0;
+
+	return event.user.code;
+}
+
+BOOL sdl_authenticate_ex(freerdp* instance, char** username, char** password, char** domain,
+                         rdp_auth_reason reason)
+{
+	SDL_Event event = {};
+	BOOL res = FALSE;
+
+	SDLConnectionDialogHider hider(instance);
+
+	const char* target = freerdp_settings_get_server_name(instance->context->settings);
+	switch (reason)
+	{
+		case AUTH_NLA:
+			break;
+
+		case AUTH_TLS:
+		case AUTH_RDP:
+		case AUTH_SMARTCARD_PIN: /* in this case password is pin code */
+			if ((*username) && (*password))
+				return TRUE;
+			break;
+		case GW_AUTH_HTTP:
+		case GW_AUTH_RDG:
+		case GW_AUTH_RPC:
+			target =
+			    freerdp_settings_get_string(instance->context->settings, FreeRDP_GatewayHostname);
+			break;
+		default:
+			break;
+	}
+
+	char* title = nullptr;
+	size_t titlesize = 0;
+	winpr_asprintf(&title, &titlesize, "Credentials required for %s", target);
+
+	std::unique_ptr<char, decltype(&free)> guard(title, free);
+	char* u = nullptr;
+	char* d = nullptr;
+	char* p = nullptr;
+
+	assert(username);
+	assert(domain);
+	assert(password);
+
+	u = *username;
+	d = *domain;
+	p = *password;
+
+	if (!sdl_push_user_event(SDL_EVENT_USER_AUTH_DIALOG, title, u, d, p, reason))
+		return res;
+
+	if (!sdl_wait_for_result(instance->context, SDL_EVENT_USER_AUTH_RESULT, &event))
+		return res;
+
+	auto arg = reinterpret_cast<SDL_UserAuthArg*>(event.padding);
+
+	res = arg->result > 0;
+
+	free(*username);
+	free(*domain);
+	free(*password);
+	*username = arg->user;
+	*domain = arg->domain;
+	*password = arg->password;
+
+	return res;
+}
+
+BOOL sdl_choose_smartcard(freerdp* instance, SmartcardCertInfo** cert_list, DWORD count,
+                          DWORD* choice, BOOL gateway)
+{
+	BOOL res = FALSE;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(cert_list);
+	WINPR_ASSERT(choice);
+
+	SDLConnectionDialogHider hider(instance);
+	std::vector<std::string> strlist;
+	std::vector<const char*> list;
+	for (DWORD i = 0; i < count; i++)
+	{
+		const SmartcardCertInfo* cert = cert_list[i];
+		char* reader = ConvertWCharToUtf8Alloc(cert->reader, nullptr);
+		char* container_name = ConvertWCharToUtf8Alloc(cert->containerName, nullptr);
+
+		char* msg = nullptr;
+		size_t len = 0;
+
+		winpr_asprintf(&msg, &len,
+		               "%s\n\tReader: %s\n\tUser: %s@%s\n\tSubject: %s\n\tIssuer: %s\n\tUPN: %s",
+		               container_name, reader, cert->userHint, cert->domainHint, cert->subject,
+		               cert->issuer, cert->upn);
+
+		strlist.emplace_back(msg);
+		free(msg);
+		free(reader);
+		free(container_name);
+
+		auto& m = strlist.back();
+		list.push_back(m.c_str());
+	}
+
+	SDL_Event event = {};
+	const char* title = "Select a logon smartcard certificate";
+	if (gateway)
+		title = "Select a gateway logon smartcard certificate";
+	if (!sdl_push_user_event(SDL_EVENT_USER_SCARD_DIALOG, title, list.data(), count))
+		return res;
+
+	if (!sdl_wait_for_result(instance->context, SDL_EVENT_USER_SCARD_RESULT, &event))
+		return res;
+
+	res = (event.user.code >= 0);
+	*choice = static_cast<DWORD>(event.user.code);
+
+	return res;
+}
+
+SSIZE_T sdl_retry_dialog(freerdp* instance, const char* what, size_t current, void* userarg)
+{
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+	WINPR_ASSERT(what);
+
+	auto sdl = get_context(instance->context);
+	auto settings = instance->context->settings;
+	const BOOL enabled = freerdp_settings_get_bool(settings, FreeRDP_AutoReconnectionEnabled);
+	const size_t delay = freerdp_settings_get_uint32(settings, FreeRDP_TcpConnectTimeout);
+	std::lock_guard<CriticalSection> lock(sdl->critical);
+	if (!sdl->connection_dialog)
+		return WINPR_ASSERTING_INT_CAST(ssize_t, delay);
+
+	sdl->connection_dialog->setTitle("Retry connection to %s",
+	                                 freerdp_settings_get_server_name(instance->context->settings));
+
+	if ((strcmp(what, "arm-transport") != 0) && (strcmp(what, "connection") != 0))
+	{
+		sdl->connection_dialog->showError("Unknown module %s, aborting", what);
+		return -1;
+	}
+
+	if (current == 0)
+	{
+		if (strcmp(what, "arm-transport") == 0)
+			sdl->connection_dialog->showWarn("[%s] Starting your VM. It may take up to 5 minutes",
+			                                 what);
+	}
+
+	if (!enabled)
+	{
+		sdl->connection_dialog->showError(
+		    "Automatic reconnection disabled, terminating. Try to connect again later");
+		return -1;
+	}
+
+	const size_t max = freerdp_settings_get_uint32(settings, FreeRDP_AutoReconnectMaxRetries);
+	if (current >= max)
+	{
+		sdl->connection_dialog->showError(
+		    "[%s] retries exceeded. Your VM failed to start. Try again later or contact your "
+		    "tech support for help if this keeps happening.",
+		    what);
+		return -1;
+	}
+
+	sdl->connection_dialog->showInfo("[%s] retry %" PRIuz "/%" PRIuz ", delaying %" PRIuz
+	                                 "ms before next attempt",
+	                                 what, current, max, delay);
+	return WINPR_ASSERTING_INT_CAST(ssize_t, delay);
+}
+
+BOOL sdl_present_gateway_message(freerdp* instance, UINT32 type, BOOL isDisplayMandatory,
+                                 BOOL isConsentMandatory, size_t length, const WCHAR* wmessage)
+{
+	if (!isDisplayMandatory)
+		return TRUE;
+
+	char* title = nullptr;
+	size_t len = 0;
+	winpr_asprintf(&title, &len, "[gateway]");
+
+	Sint32 flags = 0;
+	if (isConsentMandatory)
+		flags = SHOW_DIALOG_ACCEPT_REJECT;
+	else if (isDisplayMandatory)
+		flags = SHOW_DIALOG_TIMED_ACCEPT;
+	char* message = ConvertWCharNToUtf8Alloc(wmessage, length, nullptr);
+
+	SDLConnectionDialogHider hider(instance);
+	const int rc = sdl_show_dialog(instance->context, title, message, flags);
+	free(title);
+	free(message);
+	return rc > 0;
+}
+
+int sdl_logon_error_info(freerdp* instance, UINT32 data, UINT32 type)
+{
+	int rc = -1;
+	const char* str_data = freerdp_get_logon_error_info_data(data);
+	const char* str_type = freerdp_get_logon_error_info_type(type);
+
+	if (!instance || !instance->context)
+		return -1;
+
+	/* ignore LOGON_MSG_SESSION_CONTINUE message */
+	if (type == LOGON_MSG_SESSION_CONTINUE)
+		return 0;
+
+	SDLConnectionDialogHider hider(instance);
+
+	char* title = nullptr;
+	size_t tlen = 0;
+	winpr_asprintf(&title, &tlen, "[%s] info",
+	               freerdp_settings_get_server_name(instance->context->settings));
+
+	char* message = nullptr;
+	size_t mlen = 0;
+	winpr_asprintf(&message, &mlen, "Logon Error Info %s [%s]", str_data, str_type);
+
+	rc = sdl_show_dialog(instance->context, title, message, SHOW_DIALOG_ACCEPT_REJECT);
+	free(title);
+	free(message);
+	return rc;
+}
+
+static DWORD sdl_show_ceritifcate_dialog(rdpContext* context, const char* title,
+                                         const char* message)
+{
+	SDLConnectionDialogHider hider(context);
+	if (!sdl_push_user_event(SDL_EVENT_USER_CERT_DIALOG, title, message))
+		return 0;
+
+	SDL_Event event = {};
+	if (!sdl_wait_for_result(context, SDL_EVENT_USER_CERT_RESULT, &event))
+		return 0;
+	return static_cast<DWORD>(event.user.code);
+}
+
+static char* sdl_pem_cert(const char* pem)
+{
+	rdpCertificate* cert = freerdp_certificate_new_from_pem(pem);
+	if (!cert)
+		return nullptr;
+
+	char* fp = freerdp_certificate_get_fingerprint(cert);
+	char* start = freerdp_certificate_get_validity(cert, TRUE);
+	char* end = freerdp_certificate_get_validity(cert, FALSE);
+	freerdp_certificate_free(cert);
+
+	char* str = nullptr;
+	size_t slen = 0;
+	winpr_asprintf(&str, &slen,
+	               "Valid from:  %s\n"
+	               "Valid to:    %s\n"
+	               "Thumbprint:  %s\n",
+	               start, end, fp);
+	free(fp);
+	free(start);
+	free(end);
+	return str;
+}
+
+DWORD sdl_verify_changed_certificate_ex(freerdp* instance, const char* host, UINT16 port,
+                                        const char* common_name, const char* subject,
+                                        const char* issuer, const char* new_fingerprint,
+                                        const char* old_subject, const char* old_issuer,
+                                        const char* old_fingerprint, DWORD flags)
+{
+	const char* type = type_str_for_flags(flags);
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+	WINPR_ASSERT(instance->context->settings);
+
+	SDLConnectionDialogHider hider(instance);
+	/* Newer versions of FreeRDP allow exposing the whole PEM by setting
+	 * FreeRDP_CertificateCallbackPreferPEM to TRUE
+	 */
+	char* new_fp_str = nullptr;
+	size_t len = 0;
+	if (flags & VERIFY_CERT_FLAG_FP_IS_PEM)
+		new_fp_str = sdl_pem_cert(new_fingerprint);
+	else
+		winpr_asprintf(&new_fp_str, &len, "Thumbprint:  %s\n", new_fingerprint);
+
+	/* Newer versions of FreeRDP allow exposing the whole PEM by setting
+	 * FreeRDP_CertificateCallbackPreferPEM to TRUE
+	 */
+	char* old_fp_str = nullptr;
+	size_t olen = 0;
+	if (flags & VERIFY_CERT_FLAG_FP_IS_PEM)
+		old_fp_str = sdl_pem_cert(old_fingerprint);
+	else
+		winpr_asprintf(&old_fp_str, &olen, "Thumbprint:  %s\n", old_fingerprint);
+
+	const char* collission_str = "";
+	if (flags & VERIFY_CERT_FLAG_MATCH_LEGACY_SHA1)
+	{
+		collission_str =
+		    "A matching entry with legacy SHA1 was found in local known_hosts2 store.\n"
+		    "If you just upgraded from a FreeRDP version before 2.0 this is expected.\n"
+		    "The hashing algorithm has been upgraded from SHA1 to SHA256.\n"
+		    "All manually accepted certificates must be reconfirmed!\n"
+		    "\n";
+	}
+
+	char* title = nullptr;
+	size_t tlen = 0;
+	winpr_asprintf(&title, &tlen, "Certificate for %s:%" PRIu16 " (%s) has changed", host, port,
+	               type);
+
+	char* message = nullptr;
+	size_t mlen = 0;
+	winpr_asprintf(&message, &mlen,
+	               "New Certificate details:\n"
+	               "Common Name: %s\n"
+	               "Subject:     %s\n"
+	               "Issuer:      %s\n"
+	               "%s\n"
+	               "Old Certificate details:\n"
+	               "Subject:     %s\n"
+	               "Issuer:      %s\n"
+	               "%s\n"
+	               "%s\n"
+	               "The above X.509 certificate does not match the certificate used for previous "
+	               "connections.\n"
+	               "This may indicate that the certificate has been tampered with.\n"
+	               "Please contact the administrator of the RDP server and clarify.\n",
+	               common_name, subject, issuer, new_fp_str, old_subject, old_issuer, old_fp_str,
+	               collission_str);
+
+	const DWORD rc = sdl_show_ceritifcate_dialog(instance->context, title, message);
+	free(title);
+	free(message);
+	free(new_fp_str);
+	free(old_fp_str);
+
+	return rc;
+}
+
+DWORD sdl_verify_certificate_ex(freerdp* instance, const char* host, UINT16 port,
+                                const char* common_name, const char* subject, const char* issuer,
+                                const char* fingerprint, DWORD flags)
+{
+	const char* type = type_str_for_flags(flags);
+
+	/* Newer versions of FreeRDP allow exposing the whole PEM by setting
+	 * FreeRDP_CertificateCallbackPreferPEM to TRUE
+	 */
+	char* fp_str = nullptr;
+	size_t len = 0;
+	if (flags & VERIFY_CERT_FLAG_FP_IS_PEM)
+		fp_str = sdl_pem_cert(fingerprint);
+	else
+		winpr_asprintf(&fp_str, &len, "Thumbprint:  %s\n", fingerprint);
+
+	char* title = nullptr;
+	size_t tlen = 0;
+	winpr_asprintf(&title, &tlen, "New certificate for %s:%" PRIu16 " (%s)", host, port, type);
+
+	char* message = nullptr;
+	size_t mlen = 0;
+	winpr_asprintf(
+	    &message, &mlen,
+	    "Common Name: %s\n"
+	    "Subject:     %s\n"
+	    "Issuer:      %s\n"
+	    "%s\n"
+	    "The above X.509 certificate could not be verified, possibly because you do not have\n"
+	    "the CA certificate in your certificate store, or the certificate has expired.\n"
+	    "Please look at the OpenSSL documentation on how to add a private CA to the store.\n",
+	    common_name, subject, issuer, fp_str);
+
+	SDLConnectionDialogHider hider(instance);
+	const DWORD rc = sdl_show_ceritifcate_dialog(instance->context, title, message);
+	free(fp_str);
+	free(title);
+	free(message);
+	return rc;
+}
+
+BOOL sdl_cert_dialog_show(const char* title, const char* message)
+{
+	int buttonid = -1;
+	enum
+	{
+		BUTTONID_CERT_ACCEPT_PERMANENT = 23,
+		BUTTONID_CERT_ACCEPT_TEMPORARY = 24,
+		BUTTONID_CERT_DENY = 25
+	};
+	const SDL_MessageBoxButtonData buttons[] = {
+		{ 0, BUTTONID_CERT_ACCEPT_PERMANENT, "permanent" },
+		{ SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, BUTTONID_CERT_ACCEPT_TEMPORARY, "temporary" },
+		{ SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, BUTTONID_CERT_DENY, "cancel" }
+	};
+
+	const SDL_MessageBoxData data = { SDL_MESSAGEBOX_WARNING, nullptr, title,  message,
+		                              ARRAYSIZE(buttons),     buttons, nullptr };
+	const int rc = SDL_ShowMessageBox(&data, &buttonid);
+
+	Sint32 value = -1;
+	if (rc < 0)
+		value = 0;
+	else
+	{
+		switch (buttonid)
+		{
+			case BUTTONID_CERT_ACCEPT_PERMANENT:
+				value = 1;
+				break;
+			case BUTTONID_CERT_ACCEPT_TEMPORARY:
+				value = 2;
+				break;
+			default:
+				value = 0;
+				break;
+		}
+	}
+
+	return sdl_push_user_event(SDL_EVENT_USER_CERT_RESULT, value);
+}
+
+BOOL sdl_message_dialog_show(const char* title, const char* message, Sint32 flags)
+{
+	int buttonid = -1;
+	enum
+	{
+		BUTTONID_SHOW_ACCEPT = 24,
+		BUTTONID_SHOW_DENY = 25
+	};
+	const SDL_MessageBoxButtonData buttons[] = {
+		{ SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, BUTTONID_SHOW_ACCEPT, "accept" },
+		{ SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, BUTTONID_SHOW_DENY, "cancel" }
+	};
+
+	const int button_cnt = (flags & SHOW_DIALOG_ACCEPT_REJECT) ? 2 : 1;
+	const SDL_MessageBoxData data = {
+		SDL_MESSAGEBOX_WARNING, nullptr, title, message, button_cnt, buttons, nullptr
+	};
+	const int rc = SDL_ShowMessageBox(&data, &buttonid);
+
+	Sint32 value = -1;
+	if (rc < 0)
+		value = 0;
+	else
+	{
+		switch (buttonid)
+		{
+			case BUTTONID_SHOW_ACCEPT:
+				value = 1;
+				break;
+			default:
+				value = 0;
+				break;
+		}
+	}
+
+	return sdl_push_user_event(SDL_EVENT_USER_SHOW_RESULT, value);
+}
+
+BOOL sdl_auth_dialog_show(const SDL_UserAuthArg* args)
+{
+	std::vector<std::string> auth = { "Username:        ", "Domain:          ",
+		                              "Password:        " };
+	std::vector<std::string> authPin = { "Device:       ", "PIN:        " };
+	std::vector<std::string> gw = { "GatewayUsername: ", "GatewayDomain:   ", "GatewayPassword: " };
+	std::vector<std::string> prompt;
+	Sint32 rc = -1;
+
+	switch (args->result)
+	{
+		case AUTH_SMARTCARD_PIN:
+			prompt = std::move(authPin);
+			break;
+		case AUTH_TLS:
+		case AUTH_RDP:
+		case AUTH_NLA:
+			prompt = std::move(auth);
+			break;
+		case GW_AUTH_HTTP:
+		case GW_AUTH_RDG:
+		case GW_AUTH_RPC:
+			prompt = std::move(gw);
+			break;
+		default:
+			break;
+	}
+
+	std::vector<std::string> result;
+
+	if (!prompt.empty())
+	{
+		std::vector<std::string> initial{ args->user ? args->user : "Smartcard", "" };
+		std::vector<Uint32> flags = { SdlInputWidget::SDL_INPUT_READONLY,
+			                          SdlInputWidget::SDL_INPUT_MASK };
+		if (args->result != AUTH_SMARTCARD_PIN)
+		{
+			initial = { args->user ? args->user : "", args->domain ? args->domain : "",
+				        args->password ? args->password : "" };
+			flags = { 0, 0, SdlInputWidget::SDL_INPUT_MASK };
+		}
+		SdlInputWidgetList ilist(args->title, prompt, initial, flags);
+		rc = ilist.run(result);
+	}
+
+	if ((result.size() < prompt.size()))
+		rc = -1;
+
+	char* user = nullptr;
+	char* domain = nullptr;
+	char* pwd = nullptr;
+	if (rc > 0)
+	{
+		user = _strdup(result[0].c_str());
+		if (args->result == AUTH_SMARTCARD_PIN)
+			pwd = _strdup(result[1].c_str());
+		else
+		{
+			domain = _strdup(result[1].c_str());
+			pwd = _strdup(result[2].c_str());
+		}
+	}
+	return sdl_push_user_event(SDL_EVENT_USER_AUTH_RESULT, user, domain, pwd, rc);
+}
+
+BOOL sdl_scard_dialog_show(const char* title, Sint32 count, const char** list)
+{
+	std::vector<std::string> vlist;
+	vlist.reserve(WINPR_ASSERTING_INT_CAST(size_t, count));
+	for (Sint32 x = 0; x < count; x++)
+		vlist.emplace_back(list[x]);
+	SdlSelectList slist(title, vlist);
+	Sint32 value = slist.run();
+	return sdl_push_user_event(SDL_EVENT_USER_SCARD_RESULT, value);
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_dialogs.hpp

@@ -0,0 +1,53 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[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.
+ */
+
+#pragma once
+
+#include <winpr/wtypes.h>
+#include <freerdp/freerdp.h>
+
+#include "../sdl_types.hpp"
+#include "../sdl_utils.hpp"
+
+BOOL sdl_authenticate_ex(freerdp* instance, char** username, char** password, char** domain,
+                         rdp_auth_reason reason);
+BOOL sdl_choose_smartcard(freerdp* instance, SmartcardCertInfo** cert_list, DWORD count,
+                          DWORD* choice, BOOL gateway);
+
+SSIZE_T sdl_retry_dialog(freerdp* instance, const char* what, size_t current, void* userarg);
+
+DWORD sdl_verify_certificate_ex(freerdp* instance, const char* host, UINT16 port,
+                                const char* common_name, const char* subject, const char* issuer,
+                                const char* fingerprint, DWORD flags);
+
+DWORD sdl_verify_changed_certificate_ex(freerdp* instance, const char* host, UINT16 port,
+                                        const char* common_name, const char* subject,
+                                        const char* issuer, const char* new_fingerprint,
+                                        const char* old_subject, const char* old_issuer,
+                                        const char* old_fingerprint, DWORD flags);
+
+int sdl_logon_error_info(freerdp* instance, UINT32 data, UINT32 type);
+
+BOOL sdl_present_gateway_message(freerdp* instance, UINT32 type, BOOL isDisplayMandatory,
+                                 BOOL isConsentMandatory, size_t length, const WCHAR* message);
+
+BOOL sdl_message_dialog_show(const char* title, const char* message, Sint32 flags);
+BOOL sdl_cert_dialog_show(const char* title, const char* message);
+BOOL sdl_scard_dialog_show(const char* title, Sint32 count, const char** list);
+BOOL sdl_auth_dialog_show(const SDL_UserAuthArg* args);

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_input.cpp

@@ -0,0 +1,178 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[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 "sdl_input.hpp"
+
+#include <cassert>
+
+#include <string>
+#include <utility>
+
+#include <SDL3/SDL.h>
+#include <SDL3_ttf/SDL_ttf.h>
+
+#include "sdl_widget.hpp"
+#include "sdl_button.hpp"
+#include "sdl_buttons.hpp"
+
+static const SDL_Color inputbackgroundcolor = { 0x56, 0x56, 0x56, 0xff };
+static const SDL_Color inputhighlightcolor = { 0x80, 0, 0, 0x60 };
+static const SDL_Color inputmouseovercolor = { 0, 0x80, 0, 0x60 };
+static const SDL_Color inputfontcolor = { 0xd1, 0xcf, 0xcd, 0xff };
+static const SDL_Color labelbackgroundcolor = { 0x56, 0x56, 0x56, 0xff };
+static const SDL_Color labelfontcolor = { 0xd1, 0xcf, 0xcd, 0xff };
+static const Uint32 vpadding = 5;
+static const Uint32 hpadding = 10;
+
+SdlInputWidget::SdlInputWidget(SDL_Renderer* renderer, std::string label, std::string initial,
+                               Uint32 flags, size_t offset, size_t width, size_t height)
+    : _flags(flags), _text(std::move(initial)), _text_label(std::move(label)),
+      _label(renderer,
+             { 0, static_cast<float>(offset * (height + vpadding)), static_cast<float>(width),
+               static_cast<float>(height) },
+             false),
+      _input(renderer,
+             { static_cast<float>(width + hpadding),
+               static_cast<float>(offset * (height + vpadding)), static_cast<float>(width),
+               static_cast<float>(height) },
+             true),
+      _highlight(false), _mouseover(false)
+{
+}
+
+SdlInputWidget::SdlInputWidget(SdlInputWidget&& other) noexcept
+    : _flags(other._flags), _text(std::move(other._text)),
+      _text_label(std::move(other._text_label)), _label(std::move(other._label)),
+      _input(std::move(other._input)), _highlight(other._highlight), _mouseover(other._mouseover)
+{
+}
+
+bool SdlInputWidget::fill_label(SDL_Renderer* renderer, SDL_Color color)
+{
+	if (!_label.fill(renderer, color))
+		return false;
+	return _label.update_text(renderer, _text_label, labelfontcolor);
+}
+
+bool SdlInputWidget::update_label(SDL_Renderer* renderer)
+{
+	return _label.update_text(renderer, _text_label, labelfontcolor, labelbackgroundcolor);
+}
+
+bool SdlInputWidget::set_mouseover(SDL_Renderer* renderer, bool mouseOver)
+{
+	if (readonly())
+		return true;
+	_mouseover = mouseOver;
+	return update_input(renderer);
+}
+
+bool SdlInputWidget::set_highlight(SDL_Renderer* renderer, bool highlight)
+{
+	if (readonly())
+		return true;
+	_highlight = highlight;
+	return update_input(renderer);
+}
+
+bool SdlInputWidget::update_input(SDL_Renderer* renderer)
+{
+	std::vector<SDL_Color> colors = { inputbackgroundcolor };
+	if (_highlight)
+		colors.push_back(inputhighlightcolor);
+	if (_mouseover)
+		colors.push_back(inputmouseovercolor);
+
+	if (!_input.fill(renderer, colors))
+		return false;
+	return update_input(renderer, inputfontcolor);
+}
+
+bool SdlInputWidget::resize_input(size_t size)
+{
+	_text.resize(size);
+
+	return true;
+}
+
+bool SdlInputWidget::set_str(SDL_Renderer* renderer, const std::string& text)
+{
+	if (readonly())
+		return true;
+	_text = text;
+	if (!resize_input(_text.size()))
+		return false;
+	return update_input(renderer);
+}
+
+bool SdlInputWidget::remove_str(SDL_Renderer* renderer, size_t count)
+{
+	if (readonly())
+		return true;
+
+	assert(renderer);
+	if (_text.empty())
+		return true;
+
+	if (!resize_input(_text.size() - count))
+		return false;
+	return update_input(renderer);
+}
+
+bool SdlInputWidget::append_str(SDL_Renderer* renderer, const std::string& text)
+{
+	assert(renderer);
+	if (readonly())
+		return true;
+
+	_text.append(text);
+	if (!resize_input(_text.size()))
+		return false;
+	return update_input(renderer);
+}
+
+const SDL_FRect& SdlInputWidget::input_rect() const
+{
+	return _input.rect();
+}
+
+std::string SdlInputWidget::value() const
+{
+	return _text;
+}
+
+bool SdlInputWidget::readonly() const
+{
+	return (_flags & SDL_INPUT_READONLY) != 0;
+}
+
+bool SdlInputWidget::update_input(SDL_Renderer* renderer, SDL_Color fgcolor)
+{
+	std::string text = _text;
+	if (!text.empty())
+	{
+		if (_flags & SDL_INPUT_MASK)
+		{
+			for (char& x : text)
+				x = '*';
+		}
+	}
+
+	return _input.update_text(renderer, text, fgcolor);
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_input_widgets.cpp

@@ -0,0 +1,295 @@
+#include <cassert>
+#include <algorithm>
+
+#include <winpr/cast.h>
+
+#include "sdl_input_widgets.hpp"
+
+static const Uint32 vpadding = 5;
+
+SdlInputWidgetList::SdlInputWidgetList(const std::string& title,
+                                       const std::vector<std::string>& labels,
+                                       const std::vector<std::string>& initial,
+                                       const std::vector<Uint32>& flags)
+    : _window(nullptr), _renderer(nullptr)
+{
+	assert(labels.size() == initial.size());
+	assert(labels.size() == flags.size());
+	const std::vector<int> buttonids = { INPUT_BUTTON_ACCEPT, INPUT_BUTTON_CANCEL };
+	const std::vector<std::string> buttonlabels = { "accept", "cancel" };
+
+	const size_t widget_width = 300;
+	const size_t widget_heigth = 50;
+
+	const size_t total_width = widget_width + widget_width;
+	const size_t input_height = labels.size() * (widget_heigth + vpadding) + vpadding;
+	const size_t total_height = input_height + widget_heigth;
+	assert(total_width <= INT32_MAX);
+	assert(total_height <= INT32_MAX);
+	auto rc = SDL_CreateWindowAndRenderer(
+	    title.c_str(), total_width, static_cast<int>(total_height),
+	    SDL_WINDOW_HIGH_PIXEL_DENSITY | SDL_WINDOW_MOUSE_FOCUS | SDL_WINDOW_INPUT_FOCUS, &_window,
+	    &_renderer);
+	if (!rc)
+		widget_log_error(rc, "SDL_CreateWindowAndRenderer");
+	else
+	{
+		for (size_t x = 0; x < labels.size(); x++)
+			_list.emplace_back(_renderer, labels[x], initial[x], flags[x], x, widget_width,
+			                   widget_heigth);
+
+		_buttons.populate(_renderer, buttonlabels, buttonids, total_width,
+		                  static_cast<Sint32>(input_height), static_cast<Sint32>(widget_width),
+		                  static_cast<Sint32>(widget_heigth));
+		_buttons.set_highlight(0);
+	}
+}
+
+ssize_t SdlInputWidgetList::next(ssize_t current)
+{
+	size_t iteration = 0;
+	auto val = static_cast<size_t>(current);
+
+	do
+	{
+		if (iteration >= _list.size())
+			return -1;
+
+		if (iteration == 0)
+		{
+			if (current < 0)
+				val = 0;
+			else
+				val++;
+		}
+		else
+			val++;
+		iteration++;
+		val %= _list.size();
+	} while (!valid(static_cast<ssize_t>(val)));
+	return static_cast<ssize_t>(val);
+}
+
+bool SdlInputWidgetList::valid(ssize_t current) const
+{
+	if (current < 0)
+		return false;
+	auto s = static_cast<size_t>(current);
+	if (s >= _list.size())
+		return false;
+	return !_list[s].readonly();
+}
+
+SdlInputWidget* SdlInputWidgetList::get(ssize_t index)
+{
+	if (index < 0)
+		return nullptr;
+	auto s = static_cast<size_t>(index);
+	if (s >= _list.size())
+		return nullptr;
+	return &_list[s];
+}
+
+SdlInputWidgetList::~SdlInputWidgetList()
+{
+	_list.clear();
+	_buttons.clear();
+	SDL_DestroyRenderer(_renderer);
+	SDL_DestroyWindow(_window);
+}
+
+bool SdlInputWidgetList::update(SDL_Renderer* renderer)
+{
+	for (auto& btn : _list)
+	{
+		if (!btn.update_label(renderer))
+			return false;
+		if (!btn.update_input(renderer))
+			return false;
+	}
+
+	return _buttons.update(renderer);
+}
+
+ssize_t SdlInputWidgetList::get_index(const SDL_MouseButtonEvent& button)
+{
+	const auto x = button.x;
+	const auto y = button.y;
+	for (size_t i = 0; i < _list.size(); i++)
+	{
+		auto& cur = _list[i];
+		auto r = cur.input_rect();
+
+		if ((x >= r.x) && (x <= r.x + r.w) && (y >= r.y) && (y <= r.y + r.h))
+			return WINPR_ASSERTING_INT_CAST(ssize_t, i);
+	}
+	return -1;
+}
+
+int SdlInputWidgetList::run(std::vector<std::string>& result)
+{
+	int res = -1;
+	ssize_t LastActiveTextInput = -1;
+	ssize_t CurrentActiveTextInput = next(-1);
+
+	if (!_window || !_renderer)
+		return -2;
+
+	try
+	{
+		bool running = true;
+		std::vector<SDL_Keycode> pressed;
+		while (running)
+		{
+			if (!clear_window(_renderer))
+				throw;
+
+			if (!update(_renderer))
+				throw;
+
+			if (!_buttons.update(_renderer))
+				throw;
+
+			SDL_Event event = {};
+			SDL_WaitEvent(&event);
+			switch (event.type)
+			{
+				case SDL_EVENT_KEY_UP:
+				{
+					auto it = std::remove(pressed.begin(), pressed.end(), event.key.key);
+					pressed.erase(it, pressed.end());
+
+					switch (event.key.key)
+					{
+						case SDLK_BACKSPACE:
+						{
+							auto cur = get(CurrentActiveTextInput);
+							if (cur)
+							{
+								if (!cur->remove_str(_renderer, 1))
+									throw;
+							}
+						}
+						break;
+						case SDLK_TAB:
+							CurrentActiveTextInput = next(CurrentActiveTextInput);
+							break;
+						case SDLK_RETURN:
+						case SDLK_RETURN2:
+						case SDLK_KP_ENTER:
+							running = false;
+							res = INPUT_BUTTON_ACCEPT;
+							break;
+						case SDLK_ESCAPE:
+							running = false;
+							res = INPUT_BUTTON_CANCEL;
+							break;
+						case SDLK_V:
+							if (pressed.size() == 2)
+							{
+								if ((pressed[0] == SDLK_LCTRL) || (pressed[0] == SDLK_RCTRL))
+								{
+									auto cur = get(CurrentActiveTextInput);
+									if (cur)
+									{
+										auto text = SDL_GetClipboardText();
+										cur->set_str(_renderer, text);
+									}
+								}
+							}
+							break;
+						default:
+							break;
+					}
+				}
+				break;
+				case SDL_EVENT_KEY_DOWN:
+					pressed.push_back(event.key.key);
+					break;
+				case SDL_EVENT_TEXT_INPUT:
+				{
+					auto cur = get(CurrentActiveTextInput);
+					if (cur)
+					{
+						if (!cur->append_str(_renderer, event.text.text))
+							throw;
+					}
+				}
+				break;
+				case SDL_EVENT_MOUSE_MOTION:
+				{
+					auto TextInputIndex = get_index(event.button);
+					for (auto& cur : _list)
+					{
+						if (!cur.set_mouseover(_renderer, false))
+							throw;
+					}
+					if (TextInputIndex >= 0)
+					{
+						auto& cur = _list[static_cast<size_t>(TextInputIndex)];
+						if (!cur.set_mouseover(_renderer, true))
+							throw;
+					}
+
+					_buttons.set_mouseover(event.button.x, event.button.y);
+				}
+				break;
+				case SDL_EVENT_MOUSE_BUTTON_DOWN:
+				{
+					auto val = get_index(event.button);
+					if (valid(val))
+						CurrentActiveTextInput = val;
+
+					auto button = _buttons.get_selected(event.button);
+					if (button)
+					{
+						running = false;
+						if (button->id() == INPUT_BUTTON_CANCEL)
+							res = INPUT_BUTTON_CANCEL;
+						else
+							res = INPUT_BUTTON_ACCEPT;
+					}
+				}
+				break;
+				case SDL_EVENT_QUIT:
+					res = INPUT_BUTTON_CANCEL;
+					running = false;
+					break;
+				default:
+					break;
+			}
+
+			if (LastActiveTextInput != CurrentActiveTextInput)
+			{
+				if (CurrentActiveTextInput < 0)
+					SDL_StopTextInput(_window);
+				else
+					SDL_StartTextInput(_window);
+				LastActiveTextInput = CurrentActiveTextInput;
+			}
+
+			for (auto& cur : _list)
+			{
+				if (!cur.set_highlight(_renderer, false))
+					throw;
+			}
+			auto cur = get(CurrentActiveTextInput);
+			if (cur)
+			{
+				if (!cur->set_highlight(_renderer, true))
+					throw;
+			}
+
+			SDL_RenderPresent(_renderer);
+		}
+
+		for (auto& cur : _list)
+			result.push_back(cur.value());
+	}
+	catch (...)
+	{
+		res = -2;
+	}
+
+	return res;
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_input_widgets.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <SDL3/SDL.h>
+
+#include "sdl_input.hpp"
+#include "sdl_buttons.hpp"
+
+class SdlInputWidgetList
+{
+  public:
+	SdlInputWidgetList(const std::string& title, const std::vector<std::string>& labels,
+	                   const std::vector<std::string>& initial, const std::vector<Uint32>& flags);
+	SdlInputWidgetList(const SdlInputWidgetList& other) = delete;
+	SdlInputWidgetList(SdlInputWidgetList&& other) = delete;
+
+	virtual ~SdlInputWidgetList();
+
+	SdlInputWidgetList& operator=(const SdlInputWidgetList& other) = delete;
+	SdlInputWidgetList& operator=(SdlInputWidgetList&& other) = delete;
+
+	int run(std::vector<std::string>& result);
+
+  protected:
+	bool update(SDL_Renderer* renderer);
+	ssize_t get_index(const SDL_MouseButtonEvent& button);
+
+  private:
+	enum
+	{
+		INPUT_BUTTON_ACCEPT = 1,
+		INPUT_BUTTON_CANCEL = -2
+	};
+
+	ssize_t next(ssize_t current);
+	[[nodiscard]] bool valid(ssize_t current) const;
+	SdlInputWidget* get(ssize_t index);
+
+	SDL_Window* _window;
+	SDL_Renderer* _renderer;
+	std::vector<SdlInputWidget> _list;
+	SdlButtonList _buttons;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_select.cpp

@@ -0,0 +1,69 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[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 <cassert>
+
+#include <string>
+#include <utility>
+
+#include <SDL3/SDL.h>
+#include <SDL3_ttf/SDL_ttf.h>
+
+#include "sdl_select.hpp"
+#include "sdl_widget.hpp"
+#include "sdl_button.hpp"
+#include "sdl_buttons.hpp"
+#include "sdl_input_widgets.hpp"
+
+static const SDL_Color labelmouseovercolor = { 0, 0x80, 0, 0x60 };
+static const SDL_Color labelbackgroundcolor = { 0x69, 0x66, 0x63, 0xff };
+static const SDL_Color labelhighlightcolor = { 0xcd, 0xca, 0x35, 0x60 };
+static const SDL_Color labelfontcolor = { 0xd1, 0xcf, 0xcd, 0xff };
+
+SdlSelectWidget::SdlSelectWidget(SDL_Renderer* renderer, std::string label, const SDL_FRect& rect)
+    : SdlWidget(renderer, rect, true), _text(std::move(label)), _mouseover(false), _highlight(false)
+{
+}
+
+SdlSelectWidget::SdlSelectWidget(SdlSelectWidget&& other) noexcept = default;
+
+bool SdlSelectWidget::set_mouseover(SDL_Renderer* renderer, bool mouseOver)
+{
+	_mouseover = mouseOver;
+	return update_text(renderer);
+}
+
+bool SdlSelectWidget::set_highlight(SDL_Renderer* renderer, bool highlight)
+{
+	_highlight = highlight;
+	return update_text(renderer);
+}
+
+bool SdlSelectWidget::update_text(SDL_Renderer* renderer)
+{
+	assert(renderer);
+	std::vector<SDL_Color> colors = { labelbackgroundcolor };
+	if (_highlight)
+		colors.push_back(labelhighlightcolor);
+	if (_mouseover)
+		colors.push_back(labelmouseovercolor);
+	if (!fill(renderer, colors))
+		return false;
+	return SdlWidget::update_text(renderer, _text, labelfontcolor);
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_select.hpp

@@ -0,0 +1,46 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[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.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <SDL3/SDL.h>
+#include "sdl_widget.hpp"
+
+class SdlSelectWidget : public SdlWidget
+{
+  public:
+	SdlSelectWidget(SDL_Renderer* renderer, std::string label, const SDL_FRect& rect);
+	SdlSelectWidget(SdlSelectWidget&& other) noexcept;
+	SdlSelectWidget(const SdlSelectWidget& other) = delete;
+
+	SdlSelectWidget& operator=(const SdlSelectWidget& other) = delete;
+	SdlSelectWidget& operator=(SdlSelectWidget&& other) = delete;
+
+	virtual bool set_mouseover(SDL_Renderer* renderer, bool mouseOver);
+	virtual bool set_highlight(SDL_Renderer* renderer, bool highlight);
+	virtual bool update_text(SDL_Renderer* renderer);
+
+  private:
+	std::string _text;
+	bool _mouseover;
+	bool _highlight;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_selectlist.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <SDL3/SDL.h>
+
+#include "sdl_select.hpp"
+#include "sdl_button.hpp"
+#include "sdl_buttons.hpp"
+
+class SdlSelectList
+{
+  public:
+	SdlSelectList(const std::string& title, const std::vector<std::string>& labels);
+	SdlSelectList(const SdlSelectList& other) = delete;
+	SdlSelectList(SdlSelectList&& other) = delete;
+	virtual ~SdlSelectList();
+
+	SdlSelectList& operator=(const SdlSelectList& other) = delete;
+	SdlSelectList& operator=(SdlSelectList&& other) = delete;
+
+	int run();
+
+  private:
+	enum
+	{
+		INPUT_BUTTON_ACCEPT = 0,
+		INPUT_BUTTON_CANCEL = -2
+	};
+
+	ssize_t get_index(const SDL_MouseButtonEvent& button);
+	bool update_text();
+	void reset_mouseover();
+	void reset_highlight();
+
+	SDL_Window* _window;
+	SDL_Renderer* _renderer;
+	std::vector<SdlSelectWidget> _list;
+	SdlButtonList _buttons;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_widget.cpp

@@ -0,0 +1,320 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[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 <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+
+#include <SDL3/SDL.h>
+#include <SDL3_ttf/SDL_ttf.h>
+
+#include "sdl_widget.hpp"
+#include "../sdl_utils.hpp"
+
+#include "res/sdl3_resource_manager.hpp"
+
+#include <freerdp/log.h>
+
+#if defined(WITH_SDL_IMAGE_DIALOGS)
+#include <SDL3_image/SDL_image.h>
+#endif
+
+#define TAG CLIENT_TAG("SDL.widget")
+
+static const SDL_Color backgroundcolor = { 0x38, 0x36, 0x35, 0xff };
+
+static const Uint32 hpadding = 10;
+
+SdlWidget::SdlWidget(SDL_Renderer* renderer, const SDL_FRect& rect, bool input)
+    : _rect(rect), _input(input)
+{
+	assert(renderer);
+
+	auto ops = SDL3ResourceManager::get(SDLResourceManager::typeFonts(),
+	                                    "OpenSans-VariableFont_wdth,wght.ttf");
+	if (!ops)
+		widget_log_error(-1, "SDLResourceManager::get");
+	else
+	{
+		_font = TTF_OpenFontIO(ops, true, 64);
+		if (!_font)
+			widget_log_error(-1, "TTF_OpenFontRW");
+	}
+}
+
+#if defined(WITH_SDL_IMAGE_DIALOGS)
+SdlWidget::SdlWidget(SDL_Renderer* renderer, const SDL_FRect& rect, SDL_IOStream* ops) : _rect(rect)
+{
+	if (ops)
+	{
+		_image = IMG_LoadTexture_IO(renderer, ops, 1);
+		if (!_image)
+			widget_log_error(-1, "IMG_LoadTexture_IO");
+	}
+}
+#endif
+
+SdlWidget::SdlWidget(SdlWidget&& other) noexcept
+    : _font(other._font), _image(other._image), _rect(other._rect), _input(other._input),
+      _wrap(other._wrap), _text_width(other._text_width)
+{
+	other._font = nullptr;
+	other._image = nullptr;
+}
+
+SDL_Texture* SdlWidget::render_text(SDL_Renderer* renderer, const std::string& text,
+                                    SDL_Color fgcolor, SDL_FRect& src, SDL_FRect& dst)
+{
+	auto surface = TTF_RenderText_Blended(_font, text.c_str(), 0, fgcolor);
+	if (!surface)
+	{
+		widget_log_error(-1, "TTF_RenderText_Blended");
+		return nullptr;
+	}
+
+	auto texture = SDL_CreateTextureFromSurface(renderer, surface);
+	SDL_DestroySurface(surface);
+	if (!texture)
+	{
+		widget_log_error(-1, "SDL_CreateTextureFromSurface");
+		return nullptr;
+	}
+
+	std::unique_ptr<TTF_TextEngine, decltype(&TTF_DestroySurfaceTextEngine)> engine(
+	    TTF_CreateRendererTextEngine(renderer), TTF_DestroySurfaceTextEngine);
+	if (!engine)
+	{
+		widget_log_error(-1, "TTF_CreateRendererTextEngine");
+		return nullptr;
+	}
+
+	std::unique_ptr<TTF_Text, decltype(&TTF_DestroyText)> txt(
+	    TTF_CreateText(engine.get(), _font, text.c_str(), text.size()), TTF_DestroyText);
+
+	if (!txt)
+	{
+		widget_log_error(-1, "TTF_CreateText");
+		return nullptr;
+	}
+	int w = 0;
+	int h = 0;
+	if (!TTF_GetTextSize(txt.get(), &w, &h))
+	{
+		widget_log_error(-1, "TTF_GetTextSize");
+		return nullptr;
+	}
+
+	src.w = static_cast<float>(w);
+	src.h = static_cast<float>(h);
+	/* Do some magic:
+	 * - Add padding before and after text
+	 * - if text is too long only show the last elements
+	 * - if text is too short only update used space
+	 */
+	dst = _rect;
+	dst.x += hpadding;
+	dst.w -= 2 * hpadding;
+	const float scale = dst.h / src.h;
+	const float sws = (src.w) * scale;
+	const float dws = (dst.w) / scale;
+	dst.w = std::min(dst.w, sws);
+	if (src.w > dws)
+	{
+		src.x = src.w - dws;
+		src.w = dws;
+	}
+	return texture;
+}
+
+static float scale(float dw, float dh)
+{
+	const auto scale = dh / dw;
+	const auto dr = dh * scale;
+	return dr;
+}
+
+SDL_Texture* SdlWidget::render_text_wrapped(SDL_Renderer* renderer, const std::string& text,
+                                            SDL_Color fgcolor, SDL_FRect& src, SDL_FRect& dst)
+{
+	assert(_text_width < INT32_MAX);
+
+	auto surface = TTF_RenderText_Blended_Wrapped(_font, text.c_str(), 0, fgcolor,
+	                                              static_cast<int>(_text_width));
+	if (!surface)
+	{
+		widget_log_error(-1, "TTF_RenderText_Blended");
+		return nullptr;
+	}
+
+	src.w = static_cast<float>(surface->w);
+	src.h = static_cast<float>(surface->h);
+
+	auto texture = SDL_CreateTextureFromSurface(renderer, surface);
+	SDL_DestroySurface(surface);
+	if (!texture)
+	{
+		widget_log_error(-1, "SDL_CreateTextureFromSurface");
+		return nullptr;
+	}
+
+	/* Do some magic:
+	 * - Add padding before and after text
+	 * - if text is too long only show the last elements
+	 * - if text is too short only update used space
+	 */
+	dst = _rect;
+	dst.x += hpadding;
+	dst.w -= 2 * hpadding;
+	auto dh = scale(src.w, src.h);
+	dst.h = std::min<float>(dh, dst.h);
+
+	return texture;
+}
+
+SdlWidget::~SdlWidget()
+{
+	TTF_CloseFont(_font);
+	if (_image)
+		SDL_DestroyTexture(_image);
+}
+
+bool SdlWidget::error_ex(bool success, const char* what, const char* file, size_t line,
+                         const char* fkt)
+{
+	if (success)
+	{
+		// Flip SDL3 convention to existing code convention to minimize code changes
+		return false;
+	}
+	static wLog* log = nullptr;
+	if (!log)
+		log = WLog_Get(TAG);
+	// Use -1 as it indicates error similar to SDL2 conventions
+	// sdl_log_error_ex treats any value other than 0 as SDL error
+	return sdl_log_error_ex(-1, log, what, file, line, fkt);
+}
+
+static bool draw_rect(SDL_Renderer* renderer, const SDL_FRect* rect, SDL_Color color)
+{
+	const int drc = SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
+	if (widget_log_error(drc, "SDL_SetRenderDrawColor"))
+		return false;
+
+	const int rc = SDL_RenderFillRect(renderer, rect);
+	return !widget_log_error(rc, "SDL_RenderFillRect");
+}
+
+bool SdlWidget::fill(SDL_Renderer* renderer, SDL_Color color)
+{
+	std::vector<SDL_Color> colors = { color };
+	return fill(renderer, colors);
+}
+
+bool SdlWidget::fill(SDL_Renderer* renderer, const std::vector<SDL_Color>& colors)
+{
+	assert(renderer);
+	SDL_BlendMode mode = SDL_BLENDMODE_INVALID;
+	SDL_GetRenderDrawBlendMode(renderer, &mode);
+	SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
+	for (auto color : colors)
+	{
+		draw_rect(renderer, &_rect, color);
+		SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD);
+	}
+	SDL_SetRenderDrawBlendMode(renderer, mode);
+	return true;
+}
+
+bool SdlWidget::update_text(SDL_Renderer* renderer, const std::string& text, SDL_Color fgcolor,
+                            SDL_Color bgcolor)
+{
+	assert(renderer);
+
+	if (!fill(renderer, bgcolor))
+		return false;
+	return update_text(renderer, text, fgcolor);
+}
+
+bool SdlWidget::wrap() const
+{
+	return _wrap;
+}
+
+bool SdlWidget::set_wrap(bool wrap, size_t width)
+{
+	_wrap = wrap;
+	_text_width = width;
+	return _wrap;
+}
+
+const SDL_FRect& SdlWidget::rect() const
+{
+	return _rect;
+}
+
+bool SdlWidget::update_text(SDL_Renderer* renderer, const std::string& text, SDL_Color fgcolor)
+{
+
+	if (text.empty())
+		return true;
+
+	SDL_FRect src{};
+	SDL_FRect dst{};
+
+	SDL_Texture* texture = nullptr;
+	if (_image)
+	{
+		texture = _image;
+		dst = _rect;
+		auto propId = SDL_GetTextureProperties(_image);
+		auto w = SDL_GetNumberProperty(propId, SDL_PROP_TEXTURE_WIDTH_NUMBER, -1);
+		auto h = SDL_GetNumberProperty(propId, SDL_PROP_TEXTURE_HEIGHT_NUMBER, -1);
+		if (w < 0 || h < 0)
+			widget_log_error(-1, "SDL_GetTextureProperties");
+		src.w = static_cast<float>(w);
+		src.h = static_cast<float>(h);
+	}
+	else if (_wrap)
+		texture = render_text_wrapped(renderer, text, fgcolor, src, dst);
+	else
+		texture = render_text(renderer, text, fgcolor, src, dst);
+	if (!texture)
+		return false;
+
+	const int rc = SDL_RenderTexture(renderer, texture, &src, &dst);
+	if (!_image)
+		SDL_DestroyTexture(texture);
+	if (rc < 0)
+		return !widget_log_error(rc, "SDL_RenderCopy");
+	return true;
+}
+
+bool clear_window(SDL_Renderer* renderer)
+{
+	assert(renderer);
+
+	const int drc = SDL_SetRenderDrawColor(renderer, backgroundcolor.r, backgroundcolor.g,
+	                                       backgroundcolor.b, backgroundcolor.a);
+	if (widget_log_error(drc, "SDL_SetRenderDrawColor"))
+		return false;
+
+	const int rcls = SDL_RenderClear(renderer);
+	return !widget_log_error(rcls, "SDL_RenderClear");
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_widget.hpp

@@ -0,0 +1,88 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[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.
+ */
+
+#pragma once
+
+#include <string>
+
+#include <vector>
+#include <SDL3/SDL.h>
+#include <SDL3_ttf/SDL_ttf.h>
+
+#if defined(_MSC_VER)
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
+#if !defined(HAS_NOEXCEPT)
+#if defined(__clang__)
+#if __has_feature(cxx_noexcept)
+#define HAS_NOEXCEPT
+#endif
+#elif defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 || \
+    defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026
+#define HAS_NOEXCEPT
+#endif
+#endif
+
+#ifndef HAS_NOEXCEPT
+#define noexcept
+#endif
+
+class SdlWidget
+{
+  public:
+	SdlWidget(SDL_Renderer* renderer, const SDL_FRect& rect, bool input);
+	SdlWidget(SDL_Renderer* renderer, const SDL_FRect& rect, SDL_IOStream* ops);
+	SdlWidget(const SdlWidget& other) = delete;
+	SdlWidget(SdlWidget&& other) noexcept;
+	virtual ~SdlWidget();
+
+	SdlWidget& operator=(const SdlWidget& other) = delete;
+	SdlWidget& operator=(SdlWidget&& other) = delete;
+
+	bool fill(SDL_Renderer* renderer, SDL_Color color);
+	bool fill(SDL_Renderer* renderer, const std::vector<SDL_Color>& colors);
+	bool update_text(SDL_Renderer* renderer, const std::string& text, SDL_Color fgcolor);
+	bool update_text(SDL_Renderer* renderer, const std::string& text, SDL_Color fgcolor,
+	                 SDL_Color bgcolor);
+
+	[[nodiscard]] bool wrap() const;
+	bool set_wrap(bool wrap = true, size_t width = 0);
+	[[nodiscard]] const SDL_FRect& rect() const;
+
+#define widget_log_error(res, what) SdlWidget::error_ex(res, what, __FILE__, __LINE__, __func__)
+	static bool error_ex(bool success, const char* what, const char* file, size_t line,
+	                     const char* fkt);
+
+  private:
+	SDL_Texture* render_text(SDL_Renderer* renderer, const std::string& text, SDL_Color fgcolor,
+	                         SDL_FRect& src, SDL_FRect& dst);
+	SDL_Texture* render_text_wrapped(SDL_Renderer* renderer, const std::string& text,
+	                                 SDL_Color fgcolor, SDL_FRect& src, SDL_FRect& dst);
+
+	TTF_Font* _font = nullptr;
+	SDL_Texture* _image = nullptr;
+	SDL_FRect _rect;
+	bool _input = false;
+	bool _wrap = false;
+	size_t _text_width = 0;
+};
+
+bool clear_window(SDL_Renderer* renderer);

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/test/TestSDLDialogs.cpp

@@ -0,0 +1,99 @@
+#include "../sdl_selectlist.hpp"
+#include "../sdl_input_widgets.hpp"
+
+#include <freerdp/api.h>
+#include <winpr/wlog.h>
+
+BOOL sdl_log_error_ex(Uint32 res, wLog* log, const char* what, const char* file, size_t line,
+                      const char* fkt)
+{
+	return FALSE;
+}
+
+static bool test_input_dialog()
+{
+	const auto title = "sometitle";
+	std::vector<std::string> labels;
+	std::vector<std::string> initial;
+	std::vector<Uint32> flags;
+	for (size_t x = 0; x < 12; x++)
+	{
+		labels.push_back("label" + std::to_string(x));
+		initial.push_back(std::to_string(x));
+
+		Uint32 flag = 0;
+		if ((x % 2) != 0)
+			flag |= SdlInputWidget::SDL_INPUT_MASK;
+		if ((x % 3) == 0)
+			flag |= SdlInputWidget::SDL_INPUT_READONLY;
+
+		flags.push_back(flag);
+	}
+	SdlInputWidgetList list{ title, labels, initial, flags };
+	std::vector<std::string> result;
+	auto rc = list.run(result);
+	if (rc < 0)
+	{
+		return false;
+	}
+	if (result.size() != labels.size())
+	{
+		return false;
+	}
+	return true;
+}
+
+static bool test_select_dialog()
+{
+	const auto title = "sometitle";
+	std::vector<std::string> labels;
+	for (size_t x = 0; x < 12; x++)
+	{
+		labels.push_back("label" + std::to_string(x));
+	}
+	SdlSelectList list{ title, labels };
+	auto rc = list.run();
+	if (rc < 0)
+	{
+		return false;
+	}
+	if (static_cast<size_t>(rc) >= labels.size())
+		return false;
+
+	return true;
+}
+
+extern "C"
+{
+	FREERDP_API int TestSDLDialogs(int argc, char* argv[]);
+}
+
+int TestSDLDialogs(int argc, char* argv[])
+{
+	int rc = 0;
+
+	(void)argc;
+	(void)argv;
+
+#if 0
+	SDL_Init(SDL_INIT_VIDEO);
+	try
+	{
+#if 1
+		if (!test_input_dialog())
+			throw -1;
+#endif
+#if 1
+		if (!test_select_dialog())
+			throw -2;
+#endif
+	}
+	catch (int e)
+	{
+		rc = e;
+	}
+	SDL_Quit();
+
+#endif
+	return rc;
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/man/CMakeLists.txt

@@ -0,0 +1,8 @@
+set(DEPS
+    ../../../common/man/freerdp-global-options.1 ../../common/man/sdl-freerdp-config.1
+    ../../../common/man/freerdp-global-envvar.1 ../../../common/man/freerdp-global-config.1
+    ../../common/man/sdl-freerdp-examples.1 ../../../common/man/freerdp-global-links.1
+)
+
+set(VAR_NAMES "VENDOR" "PRODUCT" "VENDOR_PRODUCT" "CMAKE_INSTALL_FULL_SYSCONFDIR")
+generate_and_install_freerdp_man_from_xml(${MODULE_NAME} "1" "${DEPS}" "${VAR_NAMES}")

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/man/sdl3-freerdp.1.in

@@ -0,0 +1,15 @@
+.TH "@MANPAGE_NAME@" "1" "@MAN_TODAY@" "freerdp" "@MANPAGE_NAME@"
+.ie \n(.g .ds Aq \(aq
+.el       .ds Aq '
+.nh
+.ad l
+.SH "NAME"
+@MANPAGE_NAME@ \- FreeRDP SDL client
+.SH "SYNOPSIS"
+.PP
+\fB@MANPAGE_NAME@\fR
+[file] [options] [/v:server[:port]]
+.SH "DESCRIPTION"
+.PP
+\fB@MANPAGE_NAME@\fR
+is an SDL Remote Desktop Protocol (RDP) client which is part of the FreeRDP project\&. An RDP server is built\-in to many editions of Windows\&. Alternative servers included ogon, gnome\-remote\-desktop, xrdp and VRDP (VirtualBox)\&.

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/CMakeLists.txt

@@ -0,0 +1,27 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP SDL Client
+#
+# Copyright 2024 Armin Novak <[email protected]>
+# Copyright 2024 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.
+
+add_subdirectory(aad)
+add_subdirectory(res)
+
+add_library(sdl-common-prefs STATIC sdl_prefs.hpp sdl_prefs.cpp scoped_guard.hpp)
+target_link_libraries(sdl-common-prefs winpr freerdp)
+
+if(BUILD_TESTING_INTERNAL OR BUILD_TESTING)
+  add_subdirectory(test)
+endif()

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/scoped_guard.hpp

@@ -0,0 +1,56 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL ScopeGuard
+ *
+ * Copyright 2024 Armin Novak <[email protected]>
+ * Copyright 2024 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.
+ */
+
+#pragma once
+
+#include <functional>
+
+class ScopeGuard
+{
+  public:
+	template <class Callable> explicit ScopeGuard(Callable&& cleanupFunction)
+	try : f(std::forward<Callable>(cleanupFunction))
+	{
+	}
+	catch (...)
+	{
+		cleanupFunction();
+		throw;
+	}
+
+	~ScopeGuard()
+	{
+		if (f)
+			f();
+	}
+
+	void dismiss() noexcept
+	{
+		f = nullptr;
+	}
+
+	ScopeGuard(const ScopeGuard&) = delete;
+	ScopeGuard(ScopeGuard&& other) noexcept = delete;
+	ScopeGuard& operator=(const ScopeGuard&) = delete;
+	ScopeGuard& operator=(const ScopeGuard&&) = delete;
+
+  private:
+	std::function<void()> f;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/sdl_prefs.cpp

@@ -0,0 +1,199 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Prefs
+ *
+ * Copyright 2022 Armin Novak <[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 <iostream>
+#include <fstream>
+#if __has_include(<filesystem>)
+#include <filesystem>
+#include <utility>
+namespace fs = std::filesystem;
+#elif __has_include(<experimental/filesystem>)
+#include <experimental/filesystem>
+namespace fs = std::experimental::filesystem;
+#else
+#error Could not find system header "<filesystem>" or "<experimental/filesystem>"
+#endif
+
+#include "sdl_prefs.hpp"
+
+#include <winpr/path.h>
+#include <winpr/config.h>
+#include <freerdp/version.h>
+#include <winpr/json.h>
+#include <freerdp/settings.h>
+
+SdlPref::WINPR_JSONPtr SdlPref::get()
+{
+	auto config = get_pref_file();
+
+	std::ifstream ifs(config);
+	std::string content((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
+	return { WINPR_JSON_ParseWithLength(content.c_str(), content.size()), WINPR_JSON_Delete };
+}
+
+WINPR_JSON* SdlPref::get_item(const std::string& key)
+{
+	if (!_config)
+		return nullptr;
+	return WINPR_JSON_GetObjectItem(_config.get(), key.c_str());
+}
+
+std::string SdlPref::item_to_str(WINPR_JSON* item, const std::string& fallback)
+{
+	if (!item || !WINPR_JSON_IsString(item))
+		return fallback;
+	auto str = WINPR_JSON_GetStringValue(item);
+	if (!str)
+		return {};
+	return str;
+}
+
+std::string SdlPref::get_string(const std::string& key, const std::string& fallback)
+{
+	auto item = get_item(key);
+	return item_to_str(item, fallback);
+}
+
+bool SdlPref::get_bool(const std::string& key, bool fallback)
+{
+	auto item = get_item(key);
+	if (!item || !WINPR_JSON_IsBool(item))
+		return fallback;
+	return WINPR_JSON_IsTrue(item);
+}
+
+int64_t SdlPref::get_int(const std::string& key, int64_t fallback)
+{
+	auto item = get_item(key);
+	if (!item || !WINPR_JSON_IsNumber(item))
+		return fallback;
+	auto val = WINPR_JSON_GetNumberValue(item);
+	return static_cast<int64_t>(val);
+}
+
+std::vector<std::string> SdlPref::get_array(const std::string& key,
+                                            const std::vector<std::string>& fallback)
+{
+	auto item = get_item(key);
+	if (!item || !WINPR_JSON_IsArray(item))
+		return fallback;
+
+	std::vector<std::string> values;
+	for (size_t x = 0; x < WINPR_JSON_GetArraySize(item); x++)
+	{
+		auto cur = WINPR_JSON_GetArrayItem(item, x);
+		values.push_back(item_to_str(cur));
+	}
+
+	return values;
+}
+
+void SdlPref::print_config_file_help(int version)
+{
+#if defined(WITH_WINPR_JSON)
+	const std::string url = "https://wiki.libsdl.org/SDL" + std::to_string(version);
+	std::cout << "CONFIGURATION FILE" << std::endl;
+	std::cout << std::endl;
+	std::cout << "  The SDL client supports some user defined configuration options." << std::endl;
+	std::cout << "  Settings are stored in JSON format" << std::endl;
+	std::cout << "  The location is a per user file. Location for current user is "
+	          << SdlPref::instance()->get_pref_file() << std::endl;
+	std::cout
+	    << "  The XDG_CONFIG_HOME environment variable can be used to override the base directory."
+	    << std::endl;
+	std::cout << std::endl;
+	std::cout << "  The following configuration options are supported:" << std::endl;
+	std::cout << std::endl;
+	std::cout << "    SDL_KeyModMask" << std::endl;
+	std::cout << "      Defines the key combination required for SDL client shortcuts."
+	          << std::endl;
+	std::cout << "      Default KMOD_RSHIFT" << std::endl;
+	std::cout << "      An array of SDL_Keymod strings as defined at "
+	             ""
+	          << url << "/SDL_Keymod" << std::endl;
+	std::cout << std::endl;
+	std::cout << "    SDL_Fullscreen" << std::endl;
+	std::cout << "      Toggles client fullscreen state." << std::endl;
+	std::cout << "      Default SDL_SCANCODE_RETURN." << std::endl;
+	std::cout << "      A string as "
+	             "defined at "
+	          << url << "/SDLScancodeLookup" << std::endl;
+	std::cout << std::endl;
+	std::cout << "    SDL_Minimize" << std::endl;
+	std::cout << "      Minimizes client windows." << std::endl;
+	std::cout << "      Default SDL_SCANCODE_M." << std::endl;
+	std::cout << "      A string as "
+	             "defined at "
+	          << url << "/SDLScancodeLookup" << std::endl;
+	std::cout << std::endl;
+	std::cout << "    SDL_Resizeable" << std::endl;
+	std::cout << "      Toggles local window resizeable state." << std::endl;
+	std::cout << "      Default SDL_SCANCODE_R." << std::endl;
+	std::cout << "      A string as "
+	             "defined at "
+	          << url << "/SDLScancodeLookup" << std::endl;
+	std::cout << std::endl;
+	std::cout << "    SDL_Grab" << std::endl;
+	std::cout << "      Toggles keyboard and mouse grab state." << std::endl;
+	std::cout << "      Default SDL_SCANCODE_G." << std::endl;
+	std::cout << "      A string as "
+	             "defined at "
+	          << url << "/SDLScancodeLookup" << std::endl;
+	std::cout << std::endl;
+	std::cout << "    SDL_Disconnect" << std::endl;
+	std::cout << "      Disconnects from the RDP session." << std::endl;
+	std::cout << "      Default SDL_SCANCODE_D." << std::endl;
+	std::cout << "      A string as defined at " << url << "/SDLScancodeLookup" << std::endl;
+#endif
+}
+
+SdlPref::SdlPref(std::string file) : _name(std::move(file)), _config(get())
+{
+}
+
+std::string SdlPref::get_pref_dir()
+{
+	using CStringPtr = std::unique_ptr<char, decltype(&free)>;
+	CStringPtr path(freerdp_settings_get_config_path(), free);
+	if (!path)
+		return {};
+
+	fs::path config{ path.get() };
+	return config.string();
+}
+
+std::string SdlPref::get_default_file()
+{
+	fs::path config{ SdlPref::get_pref_dir() };
+	config /= "sdl-freerdp.json";
+	return config.string();
+}
+
+std::shared_ptr<SdlPref> SdlPref::instance(const std::string& name)
+{
+	static std::shared_ptr<SdlPref> _instance;
+	if (!_instance || (_instance->get_pref_file() != name))
+		_instance.reset(new SdlPref(name));
+	return _instance;
+}
+
+std::string SdlPref::get_pref_file()
+{
+	return _name;
+}

local-test-freerdp-full-01/afc-freerdp/client/X11/cli/xfreerdp.c

@@ -0,0 +1,120 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * X11 Client
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2012 HP Development Company, LLC
+ *
+ * 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/crt.h>
+#include <winpr/synch.h>
+#include <winpr/thread.h>
+
+#include <freerdp/streamdump.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/client/cmdline.h>
+
+#include "../xf_client.h"
+#include "../xfreerdp.h"
+
+static void xfreerdp_print_help(void)
+{
+	printf("Keyboard Shortcuts:\n");
+	printf("\t<Right CTRL>\n");
+	printf("\t\treleases keyboard and mouse grab\n");
+	printf("\t<CTRL>+<ALT>+<Return>\n");
+	printf("\t\ttoggles fullscreen state of the application\n");
+	printf("\t<CTRL>+<ALT>+c\n");
+	printf("\t\ttoggles remote control in a remote assistance session\n");
+	printf("\t<CTRL>+<ALT>+m\n");
+	printf("\t\tminimizes the application\n");
+	printf("\tAction Script\n");
+	printf("\t\tExecutes a predefined script on key press.\n");
+	printf("\t\tShould the script not exist it is ignored.\n");
+	printf("\t\tScripts can be provided at the default location ~/.config/freerdp/action.sh or as "
+	       "command line argument /action:script:<path>\n");
+	printf("\t\tThe script will receive the current key combination as argument.\n");
+	printf("\t\tThe output of the script is parsed for 'key-local' which tells that the script "
+	       "used the key combination, otherwise the combination is forwarded to the remote.\n");
+}
+
+int main(int argc, char* argv[])
+{
+	int rc = 1;
+	int status = 0;
+	HANDLE thread = NULL;
+	xfContext* xfc = NULL;
+	DWORD dwExitCode = 0;
+	rdpContext* context = NULL;
+	rdpSettings* settings = NULL;
+	RDP_CLIENT_ENTRY_POINTS clientEntryPoints = { 0 };
+
+	clientEntryPoints.Size = sizeof(RDP_CLIENT_ENTRY_POINTS);
+	clientEntryPoints.Version = RDP_CLIENT_INTERFACE_VERSION;
+
+	RdpClientEntry(&clientEntryPoints);
+
+	context = freerdp_client_context_new(&clientEntryPoints);
+	if (!context)
+		return 1;
+
+	settings = context->settings;
+	xfc = (xfContext*)context;
+
+	status = freerdp_client_settings_parse_command_line(context->settings, argc, argv, FALSE);
+	if (status)
+	{
+		rc = freerdp_client_settings_command_line_status_print(settings, status, argc, argv);
+
+		if (freerdp_settings_get_bool(settings, FreeRDP_ListMonitors))
+			xf_list_monitors(xfc);
+		else
+		{
+			switch (status)
+			{
+				case COMMAND_LINE_STATUS_PRINT:
+				case COMMAND_LINE_STATUS_PRINT_VERSION:
+				case COMMAND_LINE_STATUS_PRINT_BUILDCONFIG:
+					break;
+				case COMMAND_LINE_STATUS_PRINT_HELP:
+				default:
+					xfreerdp_print_help();
+					break;
+			}
+		}
+		goto out;
+	}
+
+	if (!stream_dump_register_handlers(context, CONNECTION_STATE_MCS_CREATE_REQUEST, FALSE))
+		goto out;
+
+	if (freerdp_client_start(context) != 0)
+		goto out;
+
+	thread = freerdp_client_get_thread(context);
+
+	(void)WaitForSingleObject(thread, INFINITE);
+	GetExitCodeThread(thread, &dwExitCode);
+	rc = xf_exit_code_from_disconnect_reason(dwExitCode);
+
+	freerdp_client_stop(context);
+
+out:
+	freerdp_client_context_free(context);
+
+	return rc;
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/codec/audio.c

@@ -0,0 +1,285 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Audio Formats
+ *
+ * Copyright 2013 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/crt.h>
+
+#include <freerdp/log.h>
+#include <freerdp/codec/audio.h>
+
+#define TAG FREERDP_TAG("codec")
+
+UINT32 audio_format_compute_time_length(const AUDIO_FORMAT* format, size_t size)
+{
+	UINT32 mstime = 0;
+	UINT32 wSamples = 0;
+
+	/**
+	 * [MSDN-AUDIOFORMAT]:
+	 * http://msdn.microsoft.com/en-us/library/ms713497.aspx
+	 */
+
+	if (format->wBitsPerSample)
+	{
+		const size_t samples = (size * 8) / format->wBitsPerSample;
+		WINPR_ASSERT(samples <= UINT32_MAX);
+		wSamples = (UINT32)samples;
+		mstime = (((wSamples * 1000) / format->nSamplesPerSec) / format->nChannels);
+	}
+	else
+	{
+		mstime = 0;
+
+		if (format->wFormatTag == WAVE_FORMAT_GSM610)
+		{
+			UINT16 nSamplesPerBlock = 0;
+
+			if ((format->cbSize == 2) && (format->data))
+			{
+				nSamplesPerBlock = *((UINT16*)format->data);
+				const size_t samples = (size / format->nBlockAlign) * nSamplesPerBlock;
+				WINPR_ASSERT(samples <= UINT32_MAX);
+				wSamples = (UINT32)samples;
+				mstime = (((wSamples * 1000) / format->nSamplesPerSec) / format->nChannels);
+			}
+			else
+			{
+				WLog_ERR(TAG,
+				         "audio_format_compute_time_length: invalid WAVE_FORMAT_GSM610 format");
+			}
+		}
+		else
+		{
+			WLog_ERR(TAG, "audio_format_compute_time_length: unknown format %" PRIu16 "",
+			         format->wFormatTag);
+		}
+	}
+
+	return mstime;
+}
+
+const char* audio_format_get_tag_string(UINT16 wFormatTag)
+{
+	switch (wFormatTag)
+	{
+		case WAVE_FORMAT_PCM:
+			return "WAVE_FORMAT_PCM";
+
+		case WAVE_FORMAT_ADPCM:
+			return "WAVE_FORMAT_ADPCM";
+
+		case WAVE_FORMAT_ALAW:
+			return "WAVE_FORMAT_ALAW";
+
+		case WAVE_FORMAT_MULAW:
+			return "WAVE_FORMAT_MULAW";
+
+		case WAVE_FORMAT_DVI_ADPCM:
+			return "WAVE_FORMAT_DVI_ADPCM";
+
+		case WAVE_FORMAT_GSM610:
+			return "WAVE_FORMAT_GSM610";
+
+		case WAVE_FORMAT_MSG723:
+			return "WAVE_FORMAT_MSG723";
+
+		case WAVE_FORMAT_DSPGROUP_TRUESPEECH:
+			return "WAVE_FORMAT_DSPGROUP_TRUESPEECH	";
+
+		case WAVE_FORMAT_MPEGLAYER3:
+			return "WAVE_FORMAT_MPEGLAYER3";
+
+		case WAVE_FORMAT_WMAUDIO2:
+			return "WAVE_FORMAT_WMAUDIO2";
+
+		case WAVE_FORMAT_AAC_MS:
+			return "WAVE_FORMAT_AAC_MS";
+		default:
+			return "WAVE_FORMAT_UNKNOWN";
+	}
+}
+
+void audio_format_print(wLog* log, DWORD level, const AUDIO_FORMAT* format)
+{
+	WLog_Print(log, level,
+	           "%s:\t wFormatTag: 0x%04" PRIX16 " nChannels: %" PRIu16 " nSamplesPerSec: %" PRIu32
+	           " "
+	           "nAvgBytesPerSec: %" PRIu32 " nBlockAlign: %" PRIu16 " wBitsPerSample: %" PRIu16
+	           " cbSize: %" PRIu16 "",
+	           audio_format_get_tag_string(format->wFormatTag), format->wFormatTag,
+	           format->nChannels, format->nSamplesPerSec, format->nAvgBytesPerSec,
+	           format->nBlockAlign, format->wBitsPerSample, format->cbSize);
+}
+
+void audio_formats_print(wLog* log, DWORD level, const AUDIO_FORMAT* formats, UINT16 count)
+{
+	if (formats)
+	{
+		WLog_Print(log, level, "AUDIO_FORMATS (%" PRIu16 ") ={", count);
+
+		for (UINT32 index = 0; index < count; index++)
+		{
+			const AUDIO_FORMAT* format = &formats[index];
+			WLog_Print(log, level, "\t");
+			audio_format_print(log, level, format);
+		}
+
+		WLog_Print(log, level, "}");
+	}
+}
+
+BOOL audio_format_read(wStream* s, AUDIO_FORMAT* format)
+{
+	if (!s || !format)
+		return FALSE;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 18))
+		return FALSE;
+
+	Stream_Read_UINT16(s, format->wFormatTag);
+	Stream_Read_UINT16(s, format->nChannels);
+	Stream_Read_UINT32(s, format->nSamplesPerSec);
+	Stream_Read_UINT32(s, format->nAvgBytesPerSec);
+	Stream_Read_UINT16(s, format->nBlockAlign);
+	Stream_Read_UINT16(s, format->wBitsPerSample);
+	Stream_Read_UINT16(s, format->cbSize);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, format->cbSize))
+		return FALSE;
+
+	format->data = NULL;
+
+	if (format->cbSize > 0)
+	{
+		format->data = malloc(format->cbSize);
+
+		if (!format->data)
+			return FALSE;
+
+		Stream_Read(s, format->data, format->cbSize);
+	}
+
+	return TRUE;
+}
+
+BOOL audio_format_write(wStream* s, const AUDIO_FORMAT* format)
+{
+	if (!s || !format)
+		return FALSE;
+
+	if (!Stream_EnsureRemainingCapacity(s, 18 + format->cbSize))
+		return FALSE;
+
+	Stream_Write_UINT16(s, format->wFormatTag);      /* wFormatTag (WAVE_FORMAT_PCM) */
+	Stream_Write_UINT16(s, format->nChannels);       /* nChannels */
+	Stream_Write_UINT32(s, format->nSamplesPerSec);  /* nSamplesPerSec */
+	Stream_Write_UINT32(s, format->nAvgBytesPerSec); /* nAvgBytesPerSec */
+	Stream_Write_UINT16(s, format->nBlockAlign);     /* nBlockAlign */
+	Stream_Write_UINT16(s, format->wBitsPerSample);  /* wBitsPerSample */
+	Stream_Write_UINT16(s, format->cbSize);          /* cbSize */
+
+	if (format->cbSize > 0)
+		Stream_Write(s, format->data, format->cbSize);
+
+	return TRUE;
+}
+
+BOOL audio_format_copy(const AUDIO_FORMAT* WINPR_RESTRICT srcFormat,
+                       AUDIO_FORMAT* WINPR_RESTRICT dstFormat)
+{
+	if (!srcFormat || !dstFormat)
+		return FALSE;
+
+	*dstFormat = *srcFormat;
+
+	if (srcFormat->cbSize > 0)
+	{
+		dstFormat->data = malloc(srcFormat->cbSize);
+
+		if (!dstFormat->data)
+			return FALSE;
+
+		memcpy(dstFormat->data, srcFormat->data, dstFormat->cbSize);
+	}
+
+	return TRUE;
+}
+
+BOOL audio_format_compatible(const AUDIO_FORMAT* with, const AUDIO_FORMAT* what)
+{
+	if (!with || !what)
+		return FALSE;
+
+	if (with->wFormatTag != WAVE_FORMAT_UNKNOWN)
+	{
+		if (with->wFormatTag != what->wFormatTag)
+			return FALSE;
+	}
+
+	if (with->nChannels != 0)
+	{
+		if (with->nChannels != what->nChannels)
+			return FALSE;
+	}
+
+	if (with->nSamplesPerSec != 0)
+	{
+		if (with->nSamplesPerSec != what->nSamplesPerSec)
+			return FALSE;
+	}
+
+	if (with->wBitsPerSample != 0)
+	{
+		if (with->wBitsPerSample != what->wBitsPerSample)
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+AUDIO_FORMAT* audio_format_new(void)
+{
+	return audio_formats_new(1);
+}
+
+AUDIO_FORMAT* audio_formats_new(size_t count)
+{
+	return calloc(count, sizeof(AUDIO_FORMAT));
+}
+
+void audio_format_free(AUDIO_FORMAT* format)
+{
+	if (format)
+		free(format->data);
+}
+
+void audio_formats_free(AUDIO_FORMAT* formats, size_t count)
+{
+	if (formats)
+	{
+		for (size_t index = 0; index < count; index++)
+		{
+			AUDIO_FORMAT* format = &formats[index];
+			audio_format_free(format);
+		}
+
+		free(formats);
+	}
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/codec/dsp.h

@@ -0,0 +1,46 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Digital Sound Processing - backend
+ *
+ * Copyright 2018 Armin Novak <[email protected]>
+ * Copyright 2018 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_LIB_CODEC_DSP_H
+#define FREERDP_LIB_CODEC_DSP_H
+
+#include <freerdp/api.h>
+#include <freerdp/codec/audio.h>
+#include <freerdp/codec/dsp.h>
+
+typedef struct
+{
+	ALIGN64 AUDIO_FORMAT format;
+	ALIGN64 BOOL encoder;
+	ALIGN64 wStream* buffer;
+	ALIGN64 wStream* resample;
+	ALIGN64 wStream* channelmix;
+#if defined(WITH_FDK_AAC)
+	ALIGN64 BOOL fdkSetup;
+	ALIGN64 void* fdkAacInstance;
+	ALIGN64 size_t buffersize;
+	ALIGN64 unsigned frames_per_packet;
+#endif
+} FREERDP_DSP_COMMON_CONTEXT;
+
+BOOL freerdp_dsp_common_context_init(FREERDP_DSP_COMMON_CONTEXT* context, BOOL encode);
+void freerdp_dsp_common_context_uninit(FREERDP_DSP_COMMON_CONTEXT* context);
+
+#endif /* FREERDP_LIB_CODEC_DSP_H */

local-test-freerdp-full-01/afc-freerdp/libfreerdp/codec/dsp_fdk_aac.c

@@ -0,0 +1,154 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Digital Sound Processing
+ *
+ * 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 "dsp_fdk_aac.h"
+#include "dsp_fdk_impl.h"
+
+#include <freerdp/log.h>
+#define TAG FREERDP_TAG("dsp.fdk")
+
+static void write_log(unsigned log_level, const char* fmt, ...)
+{
+	wLog* log = WLog_Get(TAG);
+
+	if (WLog_IsLevelActive(log, log_level))
+	{
+		char buffer[1024] = { 0 };
+
+		va_list ap = { 0 };
+		va_start(ap, fmt);
+		vsnprintf(buffer, sizeof(buffer), fmt, ap);
+		va_end(ap);
+
+		WLog_PrintMessage(log, WLOG_MESSAGE_TEXT, log_level, __LINE__, __FILE__, __func__, "%s",
+		                  buffer);
+	}
+}
+
+BOOL fdk_aac_dsp_encode(FREERDP_DSP_COMMON_CONTEXT* context, const AUDIO_FORMAT* srcFormat,
+                        const BYTE* data, size_t length, wStream* out)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(srcFormat);
+
+	if (srcFormat->wFormatTag != WAVE_FORMAT_PCM)
+	{
+		WLog_WARN(TAG, "Feeding %s format data to encoder function, but require %s",
+		          audio_format_get_tag_string(srcFormat->wFormatTag),
+		          audio_format_get_tag_string(WAVE_FORMAT_PCM));
+		return FALSE;
+	}
+
+	if (!context->fdkSetup)
+	{
+		ssize_t rc = fdk_aac_dsp_impl_config(
+		    context->fdkAacInstance, &context->buffersize, context->encoder,
+		    context->format.nSamplesPerSec, context->format.nChannels,
+		    context->format.nAvgBytesPerSec, context->frames_per_packet, write_log);
+		if (rc < 0)
+			return FALSE;
+
+		context->fdkSetup = TRUE;
+	}
+
+	if (!Stream_EnsureRemainingCapacity(out, context->buffersize))
+		return FALSE;
+
+	{
+		const ssize_t encoded =
+		    fdk_aac_dsp_impl_encode(context->fdkAacInstance, data, length, Stream_Pointer(out),
+		                            Stream_GetRemainingCapacity(out), write_log);
+		if (encoded < 0)
+			return FALSE;
+		Stream_Seek(out, (size_t)encoded);
+		return TRUE;
+	}
+}
+
+BOOL fdk_aac_dsp_decode(FREERDP_DSP_COMMON_CONTEXT* context, const AUDIO_FORMAT* srcFormat,
+                        const BYTE* data, size_t length, wStream* out)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(srcFormat);
+
+	if (srcFormat->wFormatTag != WAVE_FORMAT_AAC_MS)
+	{
+		WLog_WARN(TAG, "Feeding %s format data to encoder function, but require %s",
+		          audio_format_get_tag_string(srcFormat->wFormatTag),
+		          audio_format_get_tag_string(WAVE_FORMAT_AAC_MS));
+		return FALSE;
+	}
+
+	if (!context->fdkSetup)
+	{
+		ssize_t rc = fdk_aac_dsp_impl_config(
+		    context->fdkAacInstance, &context->buffersize, context->encoder,
+		    context->format.nSamplesPerSec, context->format.nChannels,
+		    context->format.nAvgBytesPerSec, context->frames_per_packet, write_log);
+		if (rc < 0)
+			return FALSE;
+
+		context->fdkSetup = TRUE;
+	}
+
+	ssize_t rest = 0;
+	do
+	{
+		rest = fdk_aac_dsp_impl_decode_fill(context->fdkAacInstance, data, length, write_log);
+		if (rest < 0)
+		{
+			WLog_WARN(TAG, "DecodeFill() failed");
+			return FALSE;
+		}
+
+		ssize_t ret = -1;
+		do
+		{
+			const size_t expect = context->buffersize;
+			if (!Stream_EnsureRemainingCapacity(out, expect))
+				return FALSE;
+
+			ret = fdk_aac_dsp_impl_decode_read(context->fdkAacInstance, Stream_Pointer(out), expect,
+			                                   write_log);
+			if (ret < 0)
+				return FALSE;
+
+			Stream_Seek(out, (size_t)ret);
+		} while (ret > 0);
+	} while (rest > 0);
+
+	return TRUE;
+}
+
+void fdk_aac_dsp_uninit(FREERDP_DSP_COMMON_CONTEXT* context)
+{
+	WINPR_ASSERT(context);
+
+	fdk_aac_dsp_impl_uninit(&context->fdkAacInstance, context->encoder, write_log);
+}
+
+BOOL fdk_aac_dsp_init(FREERDP_DSP_COMMON_CONTEXT* context, size_t frames_per_packet)
+{
+	WINPR_ASSERT(context);
+	context->fdkSetup = FALSE;
+	WINPR_ASSERT(frames_per_packet <= UINT_MAX);
+	context->frames_per_packet = (unsigned)frames_per_packet;
+	return fdk_aac_dsp_impl_init(&context->fdkAacInstance, context->encoder, write_log);
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/codec/dsp_fdk_impl.h

@@ -0,0 +1,45 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Digital Sound Processing
+ *
+ * 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_DSP_FDK_IMPL_H_
+#define FREERDP_DSP_FDK_IMPL_H_
+
+#include <stdlib.h>
+
+typedef void (*fdk_log_fkt_t)(unsigned log_level, const char* fmt, ...);
+
+int fdk_aac_dsp_impl_init(void** handle, int encoder, fdk_log_fkt_t log);
+void fdk_aac_dsp_impl_uninit(void** handle, int encoder, fdk_log_fkt_t log);
+
+ssize_t fdk_aac_dsp_impl_stream_info(void* handle, int encoder, fdk_log_fkt_t log);
+
+int fdk_aac_dsp_impl_config(void* handle, size_t* pbuffersize, int encoder, unsigned samplerate,
+                            unsigned channels, unsigned bytes_per_second,
+                            unsigned frames_per_packet, fdk_log_fkt_t log);
+
+ssize_t fdk_aac_dsp_impl_decode_fill(void* handle, const void* data, size_t size,
+                                     fdk_log_fkt_t log);
+
+ssize_t fdk_aac_dsp_impl_encode(void* handle, const void* data, size_t size, void* dst,
+                                size_t dstSize, fdk_log_fkt_t log);
+
+ssize_t fdk_aac_dsp_impl_decode_read(void* handle, void* dst, size_t dstSize, fdk_log_fkt_t log);
+
+#endif

local-test-freerdp-full-01/afc-freerdp/libfreerdp/codec/planar.c

@@ -0,0 +1,1797 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP6 Planar Codec
+ *
+ * Copyright 2013 Marc-Andre Moreau <[email protected]>
+ * Copyright 2016 Armin Novak <[email protected]>
+ * Copyright 2016 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/crt.h>
+#include <winpr/wtypes.h>
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+#include <winpr/print.h>
+
+#include <freerdp/primitives.h>
+#include <freerdp/log.h>
+#include <freerdp/codec/bitmap.h>
+#include <freerdp/codec/planar.h>
+
+#define TAG FREERDP_TAG("codec")
+
+#define PLANAR_ALIGN(val, align) \
+	((val) % (align) == 0) ? (val) : ((val) + (align) - (val) % (align))
+
+typedef struct
+{
+	/**
+	 * controlByte:
+	 * [0-3]: nRunLength
+	 * [4-7]: cRawBytes
+	 */
+	BYTE controlByte;
+	BYTE* rawValues;
+} RDP6_RLE_SEGMENT;
+
+typedef struct
+{
+	UINT32 cSegments;
+	RDP6_RLE_SEGMENT* segments;
+} RDP6_RLE_SEGMENTS;
+
+typedef struct
+{
+	/**
+	 * formatHeader:
+	 * [0-2]: Color Loss Level (CLL)
+	 *  [3] : Chroma Subsampling (CS)
+	 *  [4] : Run Length Encoding (RLE)
+	 *  [5] : No Alpha (NA)
+	 * [6-7]: Reserved
+	 */
+	BYTE formatHeader;
+} RDP6_BITMAP_STREAM;
+
+struct S_BITMAP_PLANAR_CONTEXT
+{
+	UINT32 maxWidth;
+	UINT32 maxHeight;
+	UINT32 maxPlaneSize;
+
+	BOOL AllowSkipAlpha;
+	BOOL AllowRunLengthEncoding;
+	BOOL AllowColorSubsampling;
+	BOOL AllowDynamicColorFidelity;
+
+	UINT32 ColorLossLevel;
+
+	BYTE* planes[4];
+	BYTE* planesBuffer;
+
+	BYTE* deltaPlanes[4];
+	BYTE* deltaPlanesBuffer;
+
+	BYTE* rlePlanes[4];
+	BYTE* rlePlanesBuffer;
+
+	BYTE* pTempData;
+	UINT32 nTempStep;
+
+	BOOL bgr;
+	BOOL topdown;
+};
+
+static INLINE UINT32 planar_invert_format(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar, BOOL alpha,
+                                          UINT32 DstFormat)
+{
+
+	if (planar->bgr && alpha)
+	{
+		switch (DstFormat)
+		{
+			case PIXEL_FORMAT_ARGB32:
+				DstFormat = PIXEL_FORMAT_ABGR32;
+				break;
+			case PIXEL_FORMAT_XRGB32:
+				DstFormat = PIXEL_FORMAT_XBGR32;
+				break;
+			case PIXEL_FORMAT_ABGR32:
+				DstFormat = PIXEL_FORMAT_ARGB32;
+				break;
+			case PIXEL_FORMAT_XBGR32:
+				DstFormat = PIXEL_FORMAT_XRGB32;
+				break;
+			case PIXEL_FORMAT_BGRA32:
+				DstFormat = PIXEL_FORMAT_RGBA32;
+				break;
+			case PIXEL_FORMAT_BGRX32:
+				DstFormat = PIXEL_FORMAT_RGBX32;
+				break;
+			case PIXEL_FORMAT_RGBA32:
+				DstFormat = PIXEL_FORMAT_BGRA32;
+				break;
+			case PIXEL_FORMAT_RGBX32:
+				DstFormat = PIXEL_FORMAT_BGRX32;
+				break;
+			case PIXEL_FORMAT_RGB24:
+				DstFormat = PIXEL_FORMAT_BGR24;
+				break;
+			case PIXEL_FORMAT_BGR24:
+				DstFormat = PIXEL_FORMAT_RGB24;
+				break;
+			case PIXEL_FORMAT_RGB16:
+				DstFormat = PIXEL_FORMAT_BGR16;
+				break;
+			case PIXEL_FORMAT_BGR16:
+				DstFormat = PIXEL_FORMAT_RGB16;
+				break;
+			case PIXEL_FORMAT_ARGB15:
+				DstFormat = PIXEL_FORMAT_ABGR15;
+				break;
+			case PIXEL_FORMAT_RGB15:
+				DstFormat = PIXEL_FORMAT_BGR15;
+				break;
+			case PIXEL_FORMAT_ABGR15:
+				DstFormat = PIXEL_FORMAT_ARGB15;
+				break;
+			case PIXEL_FORMAT_BGR15:
+				DstFormat = PIXEL_FORMAT_RGB15;
+				break;
+			default:
+				break;
+		}
+	}
+	return DstFormat;
+}
+
+static INLINE BOOL freerdp_bitmap_planar_compress_plane_rle(const BYTE* WINPR_RESTRICT inPlane,
+                                                            UINT32 width, UINT32 height,
+                                                            BYTE* WINPR_RESTRICT outPlane,
+                                                            UINT32* WINPR_RESTRICT dstSize);
+static INLINE BYTE* freerdp_bitmap_planar_delta_encode_plane(const BYTE* WINPR_RESTRICT inPlane,
+                                                             UINT32 width, UINT32 height,
+                                                             BYTE* WINPR_RESTRICT outPlane);
+
+static INLINE INT32 planar_skip_plane_rle(const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
+                                          UINT32 nWidth, UINT32 nHeight)
+{
+	UINT32 used = 0;
+
+	WINPR_ASSERT(pSrcData);
+
+	for (UINT32 y = 0; y < nHeight; y++)
+	{
+		for (UINT32 x = 0; x < nWidth;)
+		{
+			if (used >= SrcSize)
+			{
+				WLog_ERR(TAG, "planar plane used %" PRIu32 " exceeds SrcSize %" PRIu32, used,
+				         SrcSize);
+				return -1;
+			}
+
+			const uint8_t controlByte = pSrcData[used++];
+			uint32_t nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
+			uint32_t cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
+
+			if (nRunLength == 1)
+			{
+				nRunLength = cRawBytes + 16;
+				cRawBytes = 0;
+			}
+			else if (nRunLength == 2)
+			{
+				nRunLength = cRawBytes + 32;
+				cRawBytes = 0;
+			}
+
+			used += cRawBytes;
+			x += cRawBytes;
+			x += nRunLength;
+
+			if (x > nWidth)
+			{
+				WLog_ERR(TAG, "planar plane x %" PRIu32 " exceeds width %" PRIu32, x, nWidth);
+				return -1;
+			}
+
+			if (used > SrcSize)
+			{
+				WLog_ERR(TAG, "planar plane used %" PRIu32 " exceeds SrcSize %" PRIu32, used,
+				         INT32_MAX);
+				return -1;
+			}
+		}
+	}
+
+	if (used > INT32_MAX)
+	{
+		WLog_ERR(TAG, "planar plane used %" PRIu32 " exceeds SrcSize %" PRIu32, used, SrcSize);
+		return -1;
+	}
+	return (INT32)used;
+}
+
+static inline UINT8 clamp(INT16 val)
+{
+	return (UINT8)val;
+}
+
+static INLINE INT32 planar_decompress_plane_rle_only(const BYTE* WINPR_RESTRICT pSrcData,
+                                                     UINT32 SrcSize, BYTE* WINPR_RESTRICT pDstData,
+                                                     UINT32 nWidth, UINT32 nHeight)
+{
+	BYTE* previousScanline = NULL;
+	const BYTE* srcp = pSrcData;
+
+	WINPR_ASSERT(nHeight <= INT32_MAX);
+	WINPR_ASSERT(nWidth <= INT32_MAX);
+
+	for (UINT32 y = 0; y < nHeight; y++)
+	{
+		BYTE* dstp = &pDstData[1ULL * (y)*nWidth];
+		INT16 pixel = 0;
+		BYTE* currentScanline = dstp;
+
+		for (UINT32 x = 0; x < nWidth;)
+		{
+			BYTE controlByte = *srcp;
+			srcp++;
+
+			if ((srcp - pSrcData) > SrcSize * 1ll)
+			{
+				WLog_ERR(TAG, "error reading input buffer");
+				return -1;
+			}
+
+			UINT32 nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
+			UINT32 cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
+
+			if (nRunLength == 1)
+			{
+				nRunLength = cRawBytes + 16;
+				cRawBytes = 0;
+			}
+			else if (nRunLength == 2)
+			{
+				nRunLength = cRawBytes + 32;
+				cRawBytes = 0;
+			}
+
+			if (((dstp + (cRawBytes + nRunLength)) - currentScanline) > nWidth * 1ll)
+			{
+				WLog_ERR(TAG, "too many pixels in scanline");
+				return -1;
+			}
+
+			if (!previousScanline)
+			{
+				/* first scanline, absolute values */
+				while (cRawBytes > 0)
+				{
+					pixel = *srcp;
+					srcp++;
+					*dstp = clamp(pixel);
+					dstp++;
+					x++;
+					cRawBytes--;
+				}
+
+				while (nRunLength > 0)
+				{
+					*dstp = clamp(pixel);
+					dstp++;
+					x++;
+					nRunLength--;
+				}
+			}
+			else
+			{
+				/* delta values relative to previous scanline */
+				while (cRawBytes > 0)
+				{
+					UINT8 deltaValue = *srcp;
+					srcp++;
+
+					if (deltaValue & 1)
+					{
+						deltaValue = deltaValue >> 1;
+						deltaValue = deltaValue + 1;
+						pixel = WINPR_ASSERTING_INT_CAST(int16_t, -1 * (int16_t)deltaValue);
+					}
+					else
+					{
+						deltaValue = deltaValue >> 1;
+						pixel = WINPR_ASSERTING_INT_CAST(INT16, deltaValue);
+					}
+
+					const INT16 delta =
+					    WINPR_ASSERTING_INT_CAST(int16_t, previousScanline[x] + pixel);
+					*dstp = clamp(delta);
+					dstp++;
+					x++;
+					cRawBytes--;
+				}
+
+				while (nRunLength > 0)
+				{
+					const INT16 deltaValue =
+					    WINPR_ASSERTING_INT_CAST(int16_t, previousScanline[x] + pixel);
+					*dstp = clamp(deltaValue);
+					dstp++;
+					x++;
+					nRunLength--;
+				}
+			}
+		}
+
+		previousScanline = currentScanline;
+	}
+
+	return (INT32)(srcp - pSrcData);
+}
+
+static INLINE INT32 planar_decompress_plane_rle(const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
+                                                BYTE* WINPR_RESTRICT pDstData, UINT32 nDstStep,
+                                                UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
+                                                UINT32 nHeight, UINT32 nChannel, BOOL vFlip)
+{
+	INT32 beg = 0;
+	INT32 end = 0;
+	INT32 inc = 0;
+	BYTE* previousScanline = NULL;
+	const BYTE* srcp = pSrcData;
+
+	WINPR_ASSERT(nHeight <= INT32_MAX);
+	WINPR_ASSERT(nWidth <= INT32_MAX);
+	WINPR_ASSERT(nDstStep <= INT32_MAX);
+
+	previousScanline = NULL;
+
+	if (vFlip)
+	{
+		beg = (INT32)nHeight - 1;
+		end = -1;
+		inc = -1;
+	}
+	else
+	{
+		beg = 0;
+		end = (INT32)nHeight;
+		inc = 1;
+	}
+
+	for (INT32 y = beg; y != end; y += inc)
+	{
+		const intptr_t off = ((1LL * nYDst + y) * nDstStep) + (4LL * nXDst) + nChannel * 1LL;
+		BYTE* dstp = &pDstData[off];
+		BYTE* currentScanline = dstp;
+		INT16 pixel = 0;
+
+		for (INT32 x = 0; x < (INT32)nWidth;)
+		{
+			const BYTE controlByte = *srcp;
+			srcp++;
+
+			if ((srcp - pSrcData) > SrcSize * 1ll)
+			{
+				WLog_ERR(TAG, "error reading input buffer");
+				return -1;
+			}
+
+			UINT32 nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
+			UINT32 cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
+
+			if (nRunLength == 1)
+			{
+				nRunLength = cRawBytes + 16;
+				cRawBytes = 0;
+			}
+			else if (nRunLength == 2)
+			{
+				nRunLength = cRawBytes + 32;
+				cRawBytes = 0;
+			}
+
+			if (((dstp + (cRawBytes + nRunLength)) - currentScanline) > nWidth * 4ll)
+			{
+				WLog_ERR(TAG, "too many pixels in scanline");
+				return -1;
+			}
+
+			if (!previousScanline)
+			{
+				/* first scanline, absolute values */
+				while (cRawBytes > 0)
+				{
+					pixel = *srcp;
+					srcp++;
+					*dstp = WINPR_ASSERTING_INT_CAST(BYTE, pixel);
+					dstp += 4;
+					x++;
+					cRawBytes--;
+				}
+
+				while (nRunLength > 0)
+				{
+					*dstp = WINPR_ASSERTING_INT_CAST(BYTE, pixel);
+					dstp += 4;
+					x++;
+					nRunLength--;
+				}
+			}
+			else
+			{
+				/* delta values relative to previous scanline */
+				while (cRawBytes > 0)
+				{
+					BYTE deltaValue = *srcp;
+					srcp++;
+
+					if (deltaValue & 1)
+					{
+						deltaValue = deltaValue >> 1;
+						deltaValue = deltaValue + 1;
+						pixel = WINPR_ASSERTING_INT_CAST(int16_t, -deltaValue);
+					}
+					else
+					{
+						deltaValue = deltaValue >> 1;
+						pixel = deltaValue;
+					}
+
+					const INT16 delta =
+					    WINPR_ASSERTING_INT_CAST(int16_t, previousScanline[4LL * x] + pixel);
+					*dstp = clamp(delta);
+					dstp += 4;
+					x++;
+					cRawBytes--;
+				}
+
+				while (nRunLength > 0)
+				{
+					const INT16 deltaValue =
+					    WINPR_ASSERTING_INT_CAST(int16_t, pixel + previousScanline[4LL * x]);
+					*dstp = clamp(deltaValue);
+					dstp += 4;
+					x++;
+					nRunLength--;
+				}
+			}
+		}
+
+		previousScanline = currentScanline;
+	}
+
+	return (INT32)(srcp - pSrcData);
+}
+
+static INLINE INT32 planar_set_plane(BYTE bValue, BYTE* pDstData, UINT32 nDstStep, UINT32 nXDst,
+                                     UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, UINT32 nChannel,
+                                     BOOL vFlip)
+{
+	INT32 beg = 0;
+	INT32 end = 0;
+	INT32 inc = 0;
+
+	WINPR_ASSERT(nHeight <= INT32_MAX);
+	WINPR_ASSERT(nWidth <= INT32_MAX);
+	WINPR_ASSERT(nDstStep <= INT32_MAX);
+
+	if (vFlip)
+	{
+		beg = (INT32)nHeight - 1;
+		end = -1;
+		inc = -1;
+	}
+	else
+	{
+		beg = 0;
+		end = (INT32)nHeight;
+		inc = 1;
+	}
+
+	for (INT32 y = beg; y != end; y += inc)
+	{
+		const intptr_t off = ((1LL * nYDst + y) * nDstStep) + (4LL * nXDst) + nChannel * 1LL;
+		BYTE* dstp = &pDstData[off];
+
+		for (INT32 x = 0; x < (INT32)nWidth; ++x)
+		{
+			*dstp = bValue;
+			dstp += 4;
+		}
+	}
+
+	return 0;
+}
+
+static INLINE BOOL writeLine(BYTE** WINPR_RESTRICT ppRgba, UINT32 DstFormat, UINT32 width,
+                             const BYTE** WINPR_RESTRICT ppR, const BYTE** WINPR_RESTRICT ppG,
+                             const BYTE** WINPR_RESTRICT ppB, const BYTE** WINPR_RESTRICT ppA)
+{
+	WINPR_ASSERT(ppRgba);
+	WINPR_ASSERT(ppR);
+	WINPR_ASSERT(ppG);
+	WINPR_ASSERT(ppB);
+
+	switch (DstFormat)
+	{
+		case PIXEL_FORMAT_BGRA32:
+			for (UINT32 x = 0; x < width; x++)
+			{
+				*(*ppRgba)++ = *(*ppB)++;
+				*(*ppRgba)++ = *(*ppG)++;
+				*(*ppRgba)++ = *(*ppR)++;
+				*(*ppRgba)++ = *(*ppA)++;
+			}
+
+			return TRUE;
+
+		case PIXEL_FORMAT_BGRX32:
+			for (UINT32 x = 0; x < width; x++)
+			{
+				*(*ppRgba)++ = *(*ppB)++;
+				*(*ppRgba)++ = *(*ppG)++;
+				*(*ppRgba)++ = *(*ppR)++;
+				*(*ppRgba)++ = 0xFF;
+			}
+
+			return TRUE;
+
+		default:
+			if (ppA)
+			{
+				for (UINT32 x = 0; x < width; x++)
+				{
+					BYTE alpha = *(*ppA)++;
+					UINT32 color =
+					    FreeRDPGetColor(DstFormat, *(*ppR)++, *(*ppG)++, *(*ppB)++, alpha);
+					FreeRDPWriteColor(*ppRgba, DstFormat, color);
+					*ppRgba += FreeRDPGetBytesPerPixel(DstFormat);
+				}
+			}
+			else
+			{
+				const BYTE alpha = 0xFF;
+
+				for (UINT32 x = 0; x < width; x++)
+				{
+					UINT32 color =
+					    FreeRDPGetColor(DstFormat, *(*ppR)++, *(*ppG)++, *(*ppB)++, alpha);
+					FreeRDPWriteColor(*ppRgba, DstFormat, color);
+					*ppRgba += FreeRDPGetBytesPerPixel(DstFormat);
+				}
+			}
+
+			return TRUE;
+	}
+}
+
+static INLINE BOOL planar_decompress_planes_raw(const BYTE* WINPR_RESTRICT pSrcData[4],
+                                                BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
+                                                UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
+                                                UINT32 nWidth, UINT32 nHeight, BOOL vFlip,
+                                                UINT32 totalHeight)
+{
+	INT32 beg = 0;
+	INT32 end = 0;
+	INT32 inc = 0;
+	const BYTE* pR = pSrcData[0];
+	const BYTE* pG = pSrcData[1];
+	const BYTE* pB = pSrcData[2];
+	const BYTE* pA = pSrcData[3];
+	const UINT32 bpp = FreeRDPGetBytesPerPixel(DstFormat);
+
+	if (vFlip)
+	{
+		beg = WINPR_ASSERTING_INT_CAST(int32_t, nHeight - 1);
+		end = -1;
+		inc = -1;
+	}
+	else
+	{
+		beg = 0;
+		end = WINPR_ASSERTING_INT_CAST(int32_t, nHeight);
+		inc = 1;
+	}
+
+	if (nYDst + nHeight > totalHeight)
+	{
+		WLog_ERR(TAG,
+		         "planar plane destination Y %" PRIu32 " + height %" PRIu32
+		         " exceeds totalHeight %" PRIu32,
+		         nYDst, nHeight, totalHeight);
+		return FALSE;
+	}
+
+	if ((nXDst + nWidth) * bpp > nDstStep)
+	{
+		WLog_ERR(TAG,
+		         "planar plane destination (X %" PRIu32 " + width %" PRIu32 ") * bpp %" PRIu32
+		         " exceeds stride %" PRIu32,
+		         nXDst, nWidth, bpp, nDstStep);
+		return FALSE;
+	}
+
+	for (INT32 y = beg; y != end; y += inc)
+	{
+		BYTE* pRGB = NULL;
+
+		if (y > WINPR_ASSERTING_INT_CAST(INT64, nHeight))
+		{
+			WLog_ERR(TAG, "planar plane destination Y %" PRId32 " exceeds height %" PRIu32, y,
+			         nHeight);
+			return FALSE;
+		}
+
+		const intptr_t off = ((1LL * nYDst + y) * nDstStep) + (1LL * nXDst * bpp);
+		pRGB = &pDstData[off];
+
+		if (!writeLine(&pRGB, DstFormat, nWidth, &pR, &pG, &pB, &pA))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL planar_subsample_expand(const BYTE* WINPR_RESTRICT plane, size_t planeLength,
+                                    UINT32 nWidth, UINT32 nHeight, UINT32 nPlaneWidth,
+                                    UINT32 nPlaneHeight, BYTE* WINPR_RESTRICT deltaPlane)
+{
+	size_t pos = 0;
+	WINPR_UNUSED(planeLength);
+
+	WINPR_ASSERT(plane);
+	WINPR_ASSERT(deltaPlane);
+
+	if (nWidth > nPlaneWidth * 2)
+	{
+		WLog_ERR(TAG, "planar subsample width %" PRIu32 " > PlaneWidth %" PRIu32 " * 2", nWidth,
+		         nPlaneWidth);
+		return FALSE;
+	}
+
+	if (nHeight > nPlaneHeight * 2)
+	{
+		WLog_ERR(TAG, "planar subsample height %" PRIu32 " > PlaneHeight %" PRIu32 " * 2", nHeight,
+		         nPlaneHeight);
+		return FALSE;
+	}
+
+	for (size_t y = 0; y < nHeight; y++)
+	{
+		const BYTE* src = plane + y / 2 * nPlaneWidth;
+
+		for (UINT32 x = 0; x < nWidth; x++)
+		{
+			deltaPlane[pos++] = src[x / 2];
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar,
+                       const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize, UINT32 nSrcWidth,
+                       UINT32 nSrcHeight, BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
+                       UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT32 nDstWidth,
+                       UINT32 nDstHeight, BOOL vFlip)
+{
+	BOOL useAlpha = FALSE;
+	INT32 status = 0;
+	INT32 rleSizes[4] = { 0, 0, 0, 0 };
+	UINT32 rawSizes[4] = { 0 };
+	UINT32 rawWidths[4] = { 0 };
+	UINT32 rawHeights[4] = { 0 };
+	const BYTE* planes[4] = { 0 };
+	const UINT32 w = MIN(nSrcWidth, nDstWidth);
+	const UINT32 h = MIN(nSrcHeight, nDstHeight);
+	const primitives_t* prims = primitives_get();
+
+	WINPR_ASSERT(planar);
+	WINPR_ASSERT(prims);
+
+	if (nDstStep <= 0)
+		nDstStep = nDstWidth * FreeRDPGetBytesPerPixel(DstFormat);
+
+	const BYTE* srcp = pSrcData;
+
+	if (!pSrcData)
+	{
+		WLog_ERR(TAG, "Invalid argument pSrcData=NULL");
+		return FALSE;
+	}
+
+	if (!pDstData)
+	{
+		WLog_ERR(TAG, "Invalid argument pDstData=NULL");
+		return FALSE;
+	}
+
+	const BYTE FormatHeader = *srcp++;
+	const BYTE cll = (FormatHeader & PLANAR_FORMAT_HEADER_CLL_MASK);
+	const BYTE cs = (FormatHeader & PLANAR_FORMAT_HEADER_CS) ? TRUE : FALSE;
+	const BYTE rle = (FormatHeader & PLANAR_FORMAT_HEADER_RLE) ? TRUE : FALSE;
+	const BYTE alpha = (FormatHeader & PLANAR_FORMAT_HEADER_NA) ? FALSE : TRUE;
+
+	DstFormat = planar_invert_format(planar, alpha, DstFormat);
+
+	if (alpha)
+		useAlpha = FreeRDPColorHasAlpha(DstFormat);
+
+	// WLog_INFO(TAG, "CLL: %"PRIu32" CS: %"PRIu8" RLE: %"PRIu8" ALPHA: %"PRIu8"", cll, cs, rle,
+	// alpha);
+
+	if (!cll && cs)
+	{
+		WLog_ERR(TAG, "Chroma subsampling requires YCoCg and does not work with RGB data");
+		return FALSE; /* Chroma subsampling requires YCoCg */
+	}
+
+	const UINT32 subWidth = (nSrcWidth / 2) + (nSrcWidth % 2);
+	const UINT32 subHeight = (nSrcHeight / 2) + (nSrcHeight % 2);
+	const UINT32 planeSize = nSrcWidth * nSrcHeight;
+	const UINT32 subSize = subWidth * subHeight;
+
+	if (!cs)
+	{
+		rawSizes[0] = planeSize; /* LumaOrRedPlane */
+		rawWidths[0] = nSrcWidth;
+		rawHeights[0] = nSrcHeight;
+		rawSizes[1] = planeSize; /* OrangeChromaOrGreenPlane */
+		rawWidths[1] = nSrcWidth;
+		rawHeights[1] = nSrcHeight;
+		rawSizes[2] = planeSize; /* GreenChromaOrBluePlane */
+		rawWidths[2] = nSrcWidth;
+		rawHeights[2] = nSrcHeight;
+		rawSizes[3] = planeSize; /* AlphaPlane */
+		rawWidths[3] = nSrcWidth;
+		rawHeights[3] = nSrcHeight;
+	}
+	else /* Chroma Subsampling */
+	{
+		rawSizes[0] = planeSize; /* LumaOrRedPlane */
+		rawWidths[0] = nSrcWidth;
+		rawHeights[0] = nSrcHeight;
+		rawSizes[1] = subSize; /* OrangeChromaOrGreenPlane */
+		rawWidths[1] = subWidth;
+		rawHeights[1] = subHeight;
+		rawSizes[2] = subSize; /* GreenChromaOrBluePlane */
+		rawWidths[2] = subWidth;
+		rawHeights[2] = subHeight;
+		rawSizes[3] = planeSize; /* AlphaPlane */
+		rawWidths[3] = nSrcWidth;
+		rawHeights[3] = nSrcHeight;
+	}
+
+	const size_t diff = WINPR_ASSERTING_INT_CAST(size_t, (intptr_t)(srcp - pSrcData));
+	if (SrcSize < diff)
+	{
+		WLog_ERR(TAG, "Size mismatch %" PRIu32 " < %" PRIuz, SrcSize, diff);
+		return FALSE;
+	}
+
+	if (!rle) /* RAW */
+	{
+
+		UINT32 base = planeSize * 3;
+		if (cs)
+			base = planeSize + planeSize / 2;
+
+		if (alpha)
+		{
+			if ((SrcSize - diff) < (planeSize + base))
+			{
+				WLog_ERR(TAG, "Alpha plane size mismatch %" PRIuz " < %" PRIu32, SrcSize - diff,
+				         (planeSize + base));
+				return FALSE;
+			}
+
+			planes[3] = srcp;                    /* AlphaPlane */
+			planes[0] = planes[3] + rawSizes[3]; /* LumaOrRedPlane */
+			planes[1] = planes[0] + rawSizes[0]; /* OrangeChromaOrGreenPlane */
+			planes[2] = planes[1] + rawSizes[1]; /* GreenChromaOrBluePlane */
+
+			if ((planes[2] + rawSizes[2]) > &pSrcData[SrcSize])
+			{
+				WLog_ERR(TAG, "plane size mismatch %p + %" PRIu32 " > %p", planes[2], rawSizes[2],
+				         &pSrcData[SrcSize]);
+				return FALSE;
+			}
+		}
+		else
+		{
+			if ((SrcSize - diff) < base)
+			{
+				WLog_ERR(TAG, "plane size mismatch %" PRIu32 " < %" PRIu32, SrcSize - diff, base);
+				return FALSE;
+			}
+
+			planes[0] = srcp;                    /* LumaOrRedPlane */
+			planes[1] = planes[0] + rawSizes[0]; /* OrangeChromaOrGreenPlane */
+			planes[2] = planes[1] + rawSizes[1]; /* GreenChromaOrBluePlane */
+
+			if ((planes[2] + rawSizes[2]) > &pSrcData[SrcSize])
+			{
+				WLog_ERR(TAG, "plane size mismatch %p + %" PRIu32 " > %p", planes[2], rawSizes[2],
+				         &pSrcData[SrcSize]);
+				return FALSE;
+			}
+		}
+	}
+	else /* RLE */
+	{
+		if (alpha)
+		{
+			planes[3] = srcp;
+			rleSizes[3] = planar_skip_plane_rle(planes[3], (UINT32)(SrcSize - diff), rawWidths[3],
+			                                    rawHeights[3]); /* AlphaPlane */
+
+			if (rleSizes[3] < 0)
+				return FALSE;
+
+			planes[0] = planes[3] + rleSizes[3];
+		}
+		else
+			planes[0] = srcp;
+
+		const size_t diff0 = WINPR_ASSERTING_INT_CAST(size_t, (intptr_t)(planes[0] - pSrcData));
+		if (SrcSize < diff0)
+		{
+			WLog_ERR(TAG, "Size mismatch %" PRIu32 " < %" PRIuz, SrcSize, diff0);
+			return FALSE;
+		}
+		rleSizes[0] = planar_skip_plane_rle(planes[0], (UINT32)(SrcSize - diff0), rawWidths[0],
+		                                    rawHeights[0]); /* RedPlane */
+
+		if (rleSizes[0] < 0)
+			return FALSE;
+
+		planes[1] = planes[0] + rleSizes[0];
+
+		const size_t diff1 = WINPR_ASSERTING_INT_CAST(size_t, (intptr_t)(planes[1] - pSrcData));
+		if (SrcSize < diff1)
+		{
+			WLog_ERR(TAG, "Size mismatch %" PRIu32 " < %" PRIuz, SrcSize, diff1);
+			return FALSE;
+		}
+		rleSizes[1] = planar_skip_plane_rle(planes[1], (UINT32)(SrcSize - diff1), rawWidths[1],
+		                                    rawHeights[1]); /* GreenPlane */
+
+		if (rleSizes[1] < 1)
+			return FALSE;
+
+		planes[2] = planes[1] + rleSizes[1];
+		const size_t diff2 = WINPR_ASSERTING_INT_CAST(size_t, (intptr_t)(planes[2] - pSrcData));
+		if (SrcSize < diff2)
+		{
+			WLog_ERR(TAG, "Size mismatch %" PRIu32 " < %" PRIuz, SrcSize, diff);
+			return FALSE;
+		}
+		rleSizes[2] = planar_skip_plane_rle(planes[2], (UINT32)(SrcSize - diff2), rawWidths[2],
+		                                    rawHeights[2]); /* BluePlane */
+
+		if (rleSizes[2] < 1)
+			return FALSE;
+	}
+
+	if (!cll) /* RGB */
+	{
+		UINT32 TempFormat = 0;
+		BYTE* pTempData = pDstData;
+		UINT32 nTempStep = nDstStep;
+		UINT32 nTotalHeight = nYDst + nDstHeight;
+
+		if (useAlpha)
+			TempFormat = PIXEL_FORMAT_BGRA32;
+		else
+			TempFormat = PIXEL_FORMAT_BGRX32;
+
+		TempFormat = planar_invert_format(planar, alpha, TempFormat);
+
+		if ((TempFormat != DstFormat) || (nSrcWidth != nDstWidth) || (nSrcHeight != nDstHeight))
+		{
+			pTempData = planar->pTempData;
+			nTempStep = planar->nTempStep;
+			nTotalHeight = planar->maxHeight;
+		}
+
+		if (!rle) /* RAW */
+		{
+			if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep, nXDst,
+			                                  nYDst, nSrcWidth, nSrcHeight, vFlip, nTotalHeight))
+				return FALSE;
+
+			if (alpha)
+				srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
+			else /* NoAlpha */
+				srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
+
+			if ((SrcSize - (srcp - pSrcData)) == 1)
+				srcp++; /* pad */
+		}
+		else /* RLE */
+		{
+			status = planar_decompress_plane_rle(
+			    planes[0], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[0]), pTempData, nTempStep,
+			    nXDst, nYDst, nSrcWidth, nSrcHeight, 2, vFlip); /* RedPlane */
+
+			if (status < 0)
+				return FALSE;
+
+			status = planar_decompress_plane_rle(
+			    planes[1], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[1]), pTempData, nTempStep,
+			    nXDst, nYDst, nSrcWidth, nSrcHeight, 1, vFlip); /* GreenPlane */
+
+			if (status < 0)
+				return FALSE;
+
+			status = planar_decompress_plane_rle(
+			    planes[2], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[2]), pTempData, nTempStep,
+			    nXDst, nYDst, nSrcWidth, nSrcHeight, 0, vFlip); /* BluePlane */
+
+			if (status < 0)
+				return FALSE;
+
+			srcp += rleSizes[0] + rleSizes[1] + rleSizes[2];
+
+			if (useAlpha)
+			{
+				status = planar_decompress_plane_rle(
+				    planes[3], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[3]), pTempData,
+				    nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 3, vFlip); /* AlphaPlane */
+			}
+			else
+				status = planar_set_plane(0xFF, pTempData, nTempStep, nXDst, nYDst, nSrcWidth,
+				                          nSrcHeight, 3, vFlip);
+
+			if (status < 0)
+				return FALSE;
+
+			if (alpha)
+				srcp += rleSizes[3];
+		}
+
+		if (pTempData != pDstData)
+		{
+			if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, w, h,
+			                                   pTempData, TempFormat, nTempStep, nXDst, nYDst, NULL,
+			                                   FREERDP_FLIP_NONE))
+			{
+				WLog_ERR(TAG, "planar image copy failed");
+				return FALSE;
+			}
+		}
+	}
+	else /* YCoCg */
+	{
+		UINT32 TempFormat = 0;
+		BYTE* pTempData = planar->pTempData;
+		UINT32 nTempStep = planar->nTempStep;
+		UINT32 nTotalHeight = planar->maxHeight;
+		BYTE* dst = &pDstData[nXDst * FreeRDPGetBytesPerPixel(DstFormat) + nYDst * nDstStep];
+
+		if (useAlpha)
+			TempFormat = PIXEL_FORMAT_BGRA32;
+		else
+			TempFormat = PIXEL_FORMAT_BGRX32;
+
+		if (!pTempData)
+			return FALSE;
+
+		if (rle) /* RLE encoded data. Decode and handle it like raw data. */
+		{
+			BYTE* rleBuffer[4] = { 0 };
+
+			if (!planar->rlePlanesBuffer)
+				return FALSE;
+
+			rleBuffer[3] = planar->rlePlanesBuffer;  /* AlphaPlane */
+			rleBuffer[0] = rleBuffer[3] + planeSize; /* LumaOrRedPlane */
+			rleBuffer[1] = rleBuffer[0] + planeSize; /* OrangeChromaOrGreenPlane */
+			rleBuffer[2] = rleBuffer[1] + planeSize; /* GreenChromaOrBluePlane */
+			if (useAlpha)
+			{
+				status = planar_decompress_plane_rle_only(
+				    planes[3], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[3]), rleBuffer[3],
+				    rawWidths[3], rawHeights[3]); /* AlphaPlane */
+
+				if (status < 0)
+					return FALSE;
+			}
+
+			if (alpha)
+				srcp += rleSizes[3];
+
+			status = planar_decompress_plane_rle_only(
+			    planes[0], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[0]), rleBuffer[0],
+			    rawWidths[0], rawHeights[0]); /* LumaPlane */
+
+			if (status < 0)
+				return FALSE;
+
+			status = planar_decompress_plane_rle_only(
+			    planes[1], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[1]), rleBuffer[1],
+			    rawWidths[1], rawHeights[1]); /* OrangeChromaPlane */
+
+			if (status < 0)
+				return FALSE;
+
+			status = planar_decompress_plane_rle_only(
+			    planes[2], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[2]), rleBuffer[2],
+			    rawWidths[2], rawHeights[2]); /* GreenChromaPlane */
+
+			if (status < 0)
+				return FALSE;
+
+			planes[0] = rleBuffer[0];
+			planes[1] = rleBuffer[1];
+			planes[2] = rleBuffer[2];
+			planes[3] = rleBuffer[3];
+		}
+
+		/* RAW */
+		{
+			if (cs)
+			{ /* Chroma subsampling for Co and Cg:
+			   * Each pixel contains the value that should be expanded to
+			   * [2x,2y;2x+1,2y;2x+1,2y+1;2x;2y+1] */
+				if (!planar_subsample_expand(planes[1], rawSizes[1], nSrcWidth, nSrcHeight,
+				                             rawWidths[1], rawHeights[1], planar->deltaPlanes[0]))
+					return FALSE;
+
+				planes[1] = planar->deltaPlanes[0];
+				rawSizes[1] = planeSize; /* OrangeChromaOrGreenPlane */
+				rawWidths[1] = nSrcWidth;
+				rawHeights[1] = nSrcHeight;
+
+				if (!planar_subsample_expand(planes[2], rawSizes[2], nSrcWidth, nSrcHeight,
+				                             rawWidths[2], rawHeights[2], planar->deltaPlanes[1]))
+					return FALSE;
+
+				planes[2] = planar->deltaPlanes[1];
+				rawSizes[2] = planeSize; /* GreenChromaOrBluePlane */
+				rawWidths[2] = nSrcWidth;
+				rawHeights[2] = nSrcHeight;
+			}
+
+			if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep, nXDst,
+			                                  nYDst, nSrcWidth, nSrcHeight, vFlip, nTotalHeight))
+				return FALSE;
+
+			if (alpha)
+				srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
+			else /* NoAlpha */
+				srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
+
+			if ((SrcSize - (srcp - pSrcData)) == 1)
+				srcp++; /* pad */
+		}
+
+		WINPR_ASSERT(prims->YCoCgToRGB_8u_AC4R);
+		int rc = prims->YCoCgToRGB_8u_AC4R(
+		    pTempData, WINPR_ASSERTING_INT_CAST(int32_t, nTempStep), dst, DstFormat,
+		    WINPR_ASSERTING_INT_CAST(int32_t, nDstStep), w, h, cll, useAlpha);
+		if (rc != PRIMITIVES_SUCCESS)
+		{
+			WLog_ERR(TAG, "YCoCgToRGB_8u_AC4R failed with %d", rc);
+			return FALSE;
+		}
+	}
+
+	WINPR_UNUSED(srcp);
+	return TRUE;
+}
+
+static INLINE BOOL freerdp_split_color_planes(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar,
+                                              const BYTE* WINPR_RESTRICT data, UINT32 format,
+                                              UINT32 width, UINT32 height, UINT32 scanline,
+                                              BYTE* WINPR_RESTRICT planes[4])
+{
+	WINPR_ASSERT(planar);
+
+	if ((width > INT32_MAX) || (height > INT32_MAX) || (scanline > INT32_MAX))
+		return FALSE;
+
+	if (scanline == 0)
+		scanline = width * FreeRDPGetBytesPerPixel(format);
+
+	if (planar->topdown)
+	{
+		UINT32 k = 0;
+		for (UINT32 i = 0; i < height; i++)
+		{
+			const BYTE* pixel = &data[1ULL * scanline * i];
+
+			for (UINT32 j = 0; j < width; j++)
+			{
+				const UINT32 color = FreeRDPReadColor(pixel, format);
+				pixel += FreeRDPGetBytesPerPixel(format);
+				FreeRDPSplitColor(color, format, &planes[1][k], &planes[2][k], &planes[3][k],
+				                  &planes[0][k], NULL);
+				k++;
+			}
+		}
+	}
+	else
+	{
+		UINT32 k = 0;
+
+		for (INT64 i = (INT64)height - 1; i >= 0; i--)
+		{
+			const BYTE* pixel = &data[1ULL * scanline * (UINT32)i];
+
+			for (UINT32 j = 0; j < width; j++)
+			{
+				const UINT32 color = FreeRDPReadColor(pixel, format);
+				pixel += FreeRDPGetBytesPerPixel(format);
+				FreeRDPSplitColor(color, format, &planes[1][k], &planes[2][k], &planes[3][k],
+				                  &planes[0][k], NULL);
+				k++;
+			}
+		}
+	}
+	return TRUE;
+}
+
+static INLINE UINT32 freerdp_bitmap_planar_write_rle_bytes(const BYTE* WINPR_RESTRICT pInBuffer,
+                                                           UINT32 cRawBytes, UINT32 nRunLength,
+                                                           BYTE* WINPR_RESTRICT pOutBuffer,
+                                                           UINT32 outBufferSize)
+{
+	const BYTE* pInput = NULL;
+	BYTE* pOutput = NULL;
+	BYTE controlByte = 0;
+	UINT32 nBytesToWrite = 0;
+	pInput = pInBuffer;
+	pOutput = pOutBuffer;
+
+	if (!cRawBytes && !nRunLength)
+		return 0;
+
+	if (nRunLength < 3)
+	{
+		cRawBytes += nRunLength;
+		nRunLength = 0;
+	}
+
+	while (cRawBytes)
+	{
+		if (cRawBytes < 16)
+		{
+			if (nRunLength > 15)
+			{
+				if (nRunLength < 18)
+				{
+					controlByte = PLANAR_CONTROL_BYTE(13, cRawBytes);
+					nRunLength -= 13;
+					cRawBytes = 0;
+				}
+				else
+				{
+					controlByte = PLANAR_CONTROL_BYTE(15, cRawBytes);
+					nRunLength -= 15;
+					cRawBytes = 0;
+				}
+			}
+			else
+			{
+				controlByte = PLANAR_CONTROL_BYTE(nRunLength, cRawBytes);
+				nRunLength = 0;
+				cRawBytes = 0;
+			}
+		}
+		else
+		{
+			controlByte = PLANAR_CONTROL_BYTE(0, 15);
+			cRawBytes -= 15;
+		}
+
+		if (outBufferSize < 1)
+			return 0;
+
+		outBufferSize--;
+		*pOutput = controlByte;
+		pOutput++;
+		nBytesToWrite = (controlByte >> 4);
+
+		if (nBytesToWrite)
+		{
+			if (outBufferSize < nBytesToWrite)
+				return 0;
+
+			outBufferSize -= nBytesToWrite;
+			CopyMemory(pOutput, pInput, nBytesToWrite);
+			pOutput += nBytesToWrite;
+			pInput += nBytesToWrite;
+		}
+	}
+
+	while (nRunLength)
+	{
+		if (nRunLength > 47)
+		{
+			if (nRunLength < 50)
+			{
+				controlByte = PLANAR_CONTROL_BYTE(2, 13);
+				nRunLength -= 45;
+			}
+			else
+			{
+				controlByte = PLANAR_CONTROL_BYTE(2, 15);
+				nRunLength -= 47;
+			}
+		}
+		else if (nRunLength > 31)
+		{
+			controlByte = PLANAR_CONTROL_BYTE(2, (nRunLength - 32));
+			nRunLength = 0;
+		}
+		else if (nRunLength > 15)
+		{
+			controlByte = PLANAR_CONTROL_BYTE(1, (nRunLength - 16));
+			nRunLength = 0;
+		}
+		else
+		{
+			controlByte = PLANAR_CONTROL_BYTE(nRunLength, 0);
+			nRunLength = 0;
+		}
+
+		if (outBufferSize < 1)
+			return 0;
+
+		--outBufferSize;
+		*pOutput = controlByte;
+		pOutput++;
+	}
+
+	const intptr_t diff = (pOutput - pOutBuffer);
+	if ((diff < 0) || (diff > UINT32_MAX))
+		return 0;
+	return (UINT32)diff;
+}
+
+static INLINE UINT32 freerdp_bitmap_planar_encode_rle_bytes(const BYTE* WINPR_RESTRICT pInBuffer,
+                                                            UINT32 inBufferSize,
+                                                            BYTE* WINPR_RESTRICT pOutBuffer,
+                                                            UINT32 outBufferSize)
+{
+	BYTE symbol = 0;
+	const BYTE* pInput = NULL;
+	BYTE* pOutput = NULL;
+	const BYTE* pBytes = NULL;
+	UINT32 cRawBytes = 0;
+	UINT32 nRunLength = 0;
+	UINT32 bSymbolMatch = 0;
+	UINT32 nBytesWritten = 0;
+	UINT32 nTotalBytesWritten = 0;
+	symbol = 0;
+	cRawBytes = 0;
+	nRunLength = 0;
+	pInput = pInBuffer;
+	pOutput = pOutBuffer;
+	nTotalBytesWritten = 0;
+
+	if (!outBufferSize)
+		return 0;
+
+	do
+	{
+		if (!inBufferSize)
+			break;
+
+		bSymbolMatch = (symbol == *pInput) ? TRUE : FALSE;
+		symbol = *pInput;
+		pInput++;
+		inBufferSize--;
+
+		if (nRunLength && !bSymbolMatch)
+		{
+			if (nRunLength < 3)
+			{
+				cRawBytes += nRunLength;
+				nRunLength = 0;
+			}
+			else
+			{
+				pBytes = pInput - (cRawBytes + nRunLength + 1);
+				nBytesWritten = freerdp_bitmap_planar_write_rle_bytes(pBytes, cRawBytes, nRunLength,
+				                                                      pOutput, outBufferSize);
+				nRunLength = 0;
+
+				if (!nBytesWritten || (nBytesWritten > outBufferSize))
+					return nRunLength;
+
+				nTotalBytesWritten += nBytesWritten;
+				outBufferSize -= nBytesWritten;
+				pOutput += nBytesWritten;
+				cRawBytes = 0;
+			}
+		}
+
+		nRunLength += bSymbolMatch;
+		cRawBytes += (!bSymbolMatch) ? TRUE : FALSE;
+	} while (outBufferSize);
+
+	if (cRawBytes || nRunLength)
+	{
+		pBytes = pInput - (cRawBytes + nRunLength);
+		nBytesWritten = freerdp_bitmap_planar_write_rle_bytes(pBytes, cRawBytes, nRunLength,
+		                                                      pOutput, outBufferSize);
+
+		if (!nBytesWritten)
+			return 0;
+
+		nTotalBytesWritten += nBytesWritten;
+	}
+
+	if (inBufferSize)
+		return 0;
+
+	return nTotalBytesWritten;
+}
+
+BOOL freerdp_bitmap_planar_compress_plane_rle(const BYTE* WINPR_RESTRICT inPlane, UINT32 width,
+                                              UINT32 height, BYTE* WINPR_RESTRICT outPlane,
+                                              UINT32* WINPR_RESTRICT dstSize)
+{
+	UINT32 index = 0;
+	const BYTE* pInput = NULL;
+	BYTE* pOutput = NULL;
+	UINT32 outBufferSize = 0;
+	UINT32 nBytesWritten = 0;
+	UINT32 nTotalBytesWritten = 0;
+
+	if (!outPlane)
+		return FALSE;
+
+	index = 0;
+	pInput = inPlane;
+	pOutput = outPlane;
+	outBufferSize = *dstSize;
+	nTotalBytesWritten = 0;
+
+	while (outBufferSize)
+	{
+		nBytesWritten =
+		    freerdp_bitmap_planar_encode_rle_bytes(pInput, width, pOutput, outBufferSize);
+
+		if ((!nBytesWritten) || (nBytesWritten > outBufferSize))
+			return FALSE;
+
+		outBufferSize -= nBytesWritten;
+		nTotalBytesWritten += nBytesWritten;
+		pOutput += nBytesWritten;
+		pInput += width;
+		index++;
+
+		if (index >= height)
+			break;
+	}
+
+	*dstSize = nTotalBytesWritten;
+	return TRUE;
+}
+
+static INLINE BOOL freerdp_bitmap_planar_compress_planes_rle(BYTE* WINPR_RESTRICT inPlanes[4],
+                                                             UINT32 width, UINT32 height,
+                                                             BYTE* WINPR_RESTRICT outPlanes,
+                                                             UINT32* WINPR_RESTRICT dstSizes,
+                                                             BOOL skipAlpha)
+{
+	UINT32 outPlanesSize = width * height * 4;
+
+	/* AlphaPlane */
+	if (skipAlpha)
+	{
+		dstSizes[0] = 0;
+	}
+	else
+	{
+		dstSizes[0] = outPlanesSize;
+
+		if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[0], width, height, outPlanes,
+		                                              &dstSizes[0]))
+			return FALSE;
+
+		outPlanes += dstSizes[0];
+		outPlanesSize -= dstSizes[0];
+	}
+
+	/* LumaOrRedPlane */
+	dstSizes[1] = outPlanesSize;
+
+	if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[1], width, height, outPlanes,
+	                                              &dstSizes[1]))
+		return FALSE;
+
+	outPlanes += dstSizes[1];
+	outPlanesSize -= dstSizes[1];
+	/* OrangeChromaOrGreenPlane */
+	dstSizes[2] = outPlanesSize;
+
+	if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[2], width, height, outPlanes,
+	                                              &dstSizes[2]))
+		return FALSE;
+
+	outPlanes += dstSizes[2];
+	outPlanesSize -= dstSizes[2];
+	/* GreenChromeOrBluePlane */
+	dstSizes[3] = outPlanesSize;
+
+	if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[3], width, height, outPlanes,
+	                                              &dstSizes[3]))
+		return FALSE;
+
+	return TRUE;
+}
+
+BYTE* freerdp_bitmap_planar_delta_encode_plane(const BYTE* WINPR_RESTRICT inPlane, UINT32 width,
+                                               UINT32 height, BYTE* WINPR_RESTRICT outPlane)
+{
+	BYTE* outPtr = NULL;
+	const BYTE* srcPtr = NULL;
+	const BYTE* prevLinePtr = NULL;
+
+	if (!outPlane)
+	{
+		if (width * height == 0)
+			return NULL;
+
+		if (!(outPlane = (BYTE*)calloc(height, width)))
+			return NULL;
+	}
+
+	// first line is copied as is
+	CopyMemory(outPlane, inPlane, width);
+	outPtr = outPlane + width;
+	srcPtr = inPlane + width;
+	prevLinePtr = inPlane;
+
+	for (UINT32 y = 1; y < height; y++)
+	{
+		for (UINT32 x = 0; x < width; x++, outPtr++, srcPtr++, prevLinePtr++)
+		{
+			INT32 delta = *srcPtr - *prevLinePtr;
+			BYTE s2c = WINPR_ASSERTING_INT_CAST(
+			    BYTE, (delta >= 0) ? delta : (~((BYTE)(-delta)) + 1) & 0xFF);
+			s2c = WINPR_ASSERTING_INT_CAST(
+			    BYTE,
+			    (s2c >= 0) ? (s2c << 1) & 0xFF : (((UINT32)(~((BYTE)s2c) + 1) << 1) - 1) & 0xFF);
+			*outPtr = s2c;
+		}
+	}
+
+	return outPlane;
+}
+
+static INLINE BOOL freerdp_bitmap_planar_delta_encode_planes(BYTE* WINPR_RESTRICT inPlanes[4],
+                                                             UINT32 width, UINT32 height,
+                                                             BYTE* WINPR_RESTRICT outPlanes[4])
+{
+	for (UINT32 i = 0; i < 4; i++)
+	{
+		outPlanes[i] =
+		    freerdp_bitmap_planar_delta_encode_plane(inPlanes[i], width, height, outPlanes[i]);
+
+		if (!outPlanes[i])
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+BYTE* freerdp_bitmap_compress_planar(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT context,
+                                     const BYTE* WINPR_RESTRICT data, UINT32 format, UINT32 width,
+                                     UINT32 height, UINT32 scanline, BYTE* WINPR_RESTRICT dstData,
+                                     UINT32* WINPR_RESTRICT pDstSize)
+{
+	UINT32 size = 0;
+	BYTE* dstp = NULL;
+	UINT32 planeSize = 0;
+	UINT32 dstSizes[4] = { 0 };
+	BYTE FormatHeader = 0;
+
+	if (!context || !context->rlePlanesBuffer)
+		return NULL;
+
+	if (context->AllowSkipAlpha)
+		FormatHeader |= PLANAR_FORMAT_HEADER_NA;
+
+	planeSize = width * height;
+
+	if (!context->AllowSkipAlpha)
+		format = planar_invert_format(context, TRUE, format);
+
+	if (!freerdp_split_color_planes(context, data, format, width, height, scanline,
+	                                context->planes))
+		return NULL;
+
+	if (context->AllowRunLengthEncoding)
+	{
+		if (!freerdp_bitmap_planar_delta_encode_planes(context->planes, width, height,
+		                                               context->deltaPlanes))
+			return NULL;
+
+		if (!freerdp_bitmap_planar_compress_planes_rle(context->deltaPlanes, width, height,
+		                                               context->rlePlanesBuffer, dstSizes,
+		                                               context->AllowSkipAlpha))
+			return NULL;
+
+		{
+			uint32_t offset = 0;
+			FormatHeader |= PLANAR_FORMAT_HEADER_RLE;
+			context->rlePlanes[0] = &context->rlePlanesBuffer[offset];
+			offset += dstSizes[0];
+			context->rlePlanes[1] = &context->rlePlanesBuffer[offset];
+			offset += dstSizes[1];
+			context->rlePlanes[2] = &context->rlePlanesBuffer[offset];
+			offset += dstSizes[2];
+			context->rlePlanes[3] = &context->rlePlanesBuffer[offset];
+
+#if defined(WITH_DEBUG_CODECS)
+			WLog_DBG(TAG,
+			         "R: [%" PRIu32 "/%" PRIu32 "] G: [%" PRIu32 "/%" PRIu32 "] B: [%" PRIu32
+			         " / %" PRIu32 "] ",
+			         dstSizes[1], planeSize, dstSizes[2], planeSize, dstSizes[3], planeSize);
+#endif
+		}
+	}
+
+	if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+	{
+		if (!context->AllowRunLengthEncoding)
+			return NULL;
+
+		if (context->rlePlanes[0] == NULL)
+			return NULL;
+
+		if (context->rlePlanes[1] == NULL)
+			return NULL;
+
+		if (context->rlePlanes[2] == NULL)
+			return NULL;
+
+		if (context->rlePlanes[3] == NULL)
+			return NULL;
+	}
+
+	if (!dstData)
+	{
+		size = 1;
+
+		if (!(FormatHeader & PLANAR_FORMAT_HEADER_NA))
+		{
+			if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+				size += dstSizes[0];
+			else
+				size += planeSize;
+		}
+
+		if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+			size += (dstSizes[1] + dstSizes[2] + dstSizes[3]);
+		else
+			size += (planeSize * 3);
+
+		if (!(FormatHeader & PLANAR_FORMAT_HEADER_RLE))
+			size++;
+
+		dstData = malloc(size);
+
+		if (!dstData)
+			return NULL;
+
+		*pDstSize = size;
+	}
+
+	dstp = dstData;
+	*dstp = FormatHeader; /* FormatHeader */
+	dstp++;
+
+	/* AlphaPlane */
+
+	if (!(FormatHeader & PLANAR_FORMAT_HEADER_NA))
+	{
+		if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+		{
+			CopyMemory(dstp, context->rlePlanes[0], dstSizes[0]); /* Alpha */
+			dstp += dstSizes[0];
+		}
+		else
+		{
+			CopyMemory(dstp, context->planes[0], planeSize); /* Alpha */
+			dstp += planeSize;
+		}
+	}
+
+	/* LumaOrRedPlane */
+
+	if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+	{
+		CopyMemory(dstp, context->rlePlanes[1], dstSizes[1]); /* Red */
+		dstp += dstSizes[1];
+	}
+	else
+	{
+		CopyMemory(dstp, context->planes[1], planeSize); /* Red */
+		dstp += planeSize;
+	}
+
+	/* OrangeChromaOrGreenPlane */
+
+	if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+	{
+		CopyMemory(dstp, context->rlePlanes[2], dstSizes[2]); /* Green */
+		dstp += dstSizes[2];
+	}
+	else
+	{
+		CopyMemory(dstp, context->planes[2], planeSize); /* Green */
+		dstp += planeSize;
+	}
+
+	/* GreenChromeOrBluePlane */
+
+	if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+	{
+		CopyMemory(dstp, context->rlePlanes[3], dstSizes[3]); /* Blue */
+		dstp += dstSizes[3];
+	}
+	else
+	{
+		CopyMemory(dstp, context->planes[3], planeSize); /* Blue */
+		dstp += planeSize;
+	}
+
+	/* Pad1 (1 byte) */
+
+	if (!(FormatHeader & PLANAR_FORMAT_HEADER_RLE))
+	{
+		*dstp = 0;
+		dstp++;
+	}
+
+	const intptr_t diff = (dstp - dstData);
+	if ((diff < 0) || (diff > UINT32_MAX))
+	{
+		free(dstData);
+		return NULL;
+	}
+	size = (UINT32)diff;
+	*pDstSize = size;
+	return dstData;
+}
+
+BOOL freerdp_bitmap_planar_context_reset(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT context,
+                                         UINT32 width, UINT32 height)
+{
+	if (!context)
+		return FALSE;
+
+	context->bgr = FALSE;
+	context->maxWidth = PLANAR_ALIGN(width, 4);
+	context->maxHeight = PLANAR_ALIGN(height, 4);
+	{
+		const UINT64 tmp = (UINT64)context->maxWidth * context->maxHeight;
+		if (tmp > UINT32_MAX)
+			return FALSE;
+		context->maxPlaneSize = (UINT32)tmp;
+	}
+
+	if (context->maxWidth > UINT32_MAX / 4)
+		return FALSE;
+	context->nTempStep = context->maxWidth * 4;
+
+	memset((void*)context->planes, 0, sizeof(context->planes));
+	memset((void*)context->rlePlanes, 0, sizeof(context->rlePlanes));
+	memset((void*)context->deltaPlanes, 0, sizeof(context->deltaPlanes));
+
+	if (context->maxPlaneSize > 0)
+	{
+		void* tmp = winpr_aligned_recalloc(context->planesBuffer, context->maxPlaneSize, 4, 32);
+		if (!tmp)
+			return FALSE;
+		context->planesBuffer = tmp;
+
+		tmp = winpr_aligned_recalloc(context->pTempData, context->maxPlaneSize, 6, 32);
+		if (!tmp)
+			return FALSE;
+		context->pTempData = tmp;
+
+		tmp = winpr_aligned_recalloc(context->deltaPlanesBuffer, context->maxPlaneSize, 4, 32);
+		if (!tmp)
+			return FALSE;
+		context->deltaPlanesBuffer = tmp;
+
+		tmp = winpr_aligned_recalloc(context->rlePlanesBuffer, context->maxPlaneSize, 4, 32);
+		if (!tmp)
+			return FALSE;
+		context->rlePlanesBuffer = tmp;
+
+		context->planes[0] = &context->planesBuffer[0ULL * context->maxPlaneSize];
+		context->planes[1] = &context->planesBuffer[1ULL * context->maxPlaneSize];
+		context->planes[2] = &context->planesBuffer[2ULL * context->maxPlaneSize];
+		context->planes[3] = &context->planesBuffer[3ULL * context->maxPlaneSize];
+		context->deltaPlanes[0] = &context->deltaPlanesBuffer[0ULL * context->maxPlaneSize];
+		context->deltaPlanes[1] = &context->deltaPlanesBuffer[1ULL * context->maxPlaneSize];
+		context->deltaPlanes[2] = &context->deltaPlanesBuffer[2ULL * context->maxPlaneSize];
+		context->deltaPlanes[3] = &context->deltaPlanesBuffer[3ULL * context->maxPlaneSize];
+	}
+	return TRUE;
+}
+
+BITMAP_PLANAR_CONTEXT* freerdp_bitmap_planar_context_new(DWORD flags, UINT32 maxWidth,
+                                                         UINT32 maxHeight)
+{
+	BITMAP_PLANAR_CONTEXT* context =
+	    (BITMAP_PLANAR_CONTEXT*)winpr_aligned_calloc(1, sizeof(BITMAP_PLANAR_CONTEXT), 32);
+
+	if (!context)
+		return NULL;
+
+	if (flags & PLANAR_FORMAT_HEADER_NA)
+		context->AllowSkipAlpha = TRUE;
+
+	if (flags & PLANAR_FORMAT_HEADER_RLE)
+		context->AllowRunLengthEncoding = TRUE;
+
+	if (flags & PLANAR_FORMAT_HEADER_CS)
+		context->AllowColorSubsampling = TRUE;
+
+	context->ColorLossLevel = flags & PLANAR_FORMAT_HEADER_CLL_MASK;
+
+	if (context->ColorLossLevel)
+		context->AllowDynamicColorFidelity = TRUE;
+
+	if (!freerdp_bitmap_planar_context_reset(context, maxWidth, maxHeight))
+	{
+		WINPR_PRAGMA_DIAG_PUSH
+		WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+		freerdp_bitmap_planar_context_free(context);
+		WINPR_PRAGMA_DIAG_POP
+		return NULL;
+	}
+
+	return context;
+}
+
+void freerdp_bitmap_planar_context_free(BITMAP_PLANAR_CONTEXT* context)
+{
+	if (!context)
+		return;
+
+	winpr_aligned_free(context->pTempData);
+	winpr_aligned_free(context->planesBuffer);
+	winpr_aligned_free(context->deltaPlanesBuffer);
+	winpr_aligned_free(context->rlePlanesBuffer);
+	winpr_aligned_free(context);
+}
+
+void freerdp_planar_switch_bgr(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar, BOOL bgr)
+{
+	WINPR_ASSERT(planar);
+	planar->bgr = bgr;
+}
+
+void freerdp_planar_topdown_image(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar, BOOL topdown)
+{
+	WINPR_ASSERT(planar);
+	planar->topdown = topdown;
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/codec/progressive.c

@@ -0,0 +1,2681 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Progressive Codec Bitmap Compression
+ *
+ * Copyright 2014 Marc-Andre Moreau <[email protected]>
+ * Copyright 2019 Armin Novak <[email protected]>
+ * Copyright 2019 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 <winpr/cast.h>
+#include <winpr/crt.h>
+#include <winpr/print.h>
+#include <winpr/bitstream.h>
+
+#include <freerdp/primitives.h>
+#include <freerdp/codec/color.h>
+#include <freerdp/codec/progressive.h>
+#include <freerdp/codec/region.h>
+#include <freerdp/log.h>
+
+#include "rfx_differential.h"
+#include "rfx_quantization.h"
+#include "rfx_dwt.h"
+#include "rfx_rlgr.h"
+#include "rfx_constants.h"
+#include "rfx_types.h"
+#include "progressive.h"
+
+#define TAG FREERDP_TAG("codec.progressive")
+
+typedef struct
+{
+	BOOL nonLL;
+	wBitStream* srl;
+	wBitStream* raw;
+
+	/* SRL state */
+
+	UINT32 kp;
+	int nz;
+	BOOL mode;
+} RFX_PROGRESSIVE_UPGRADE_STATE;
+
+static INLINE void
+progressive_component_codec_quant_read(wStream* WINPR_RESTRICT s,
+                                       RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT quantVal)
+{
+	BYTE b = 0;
+	Stream_Read_UINT8(s, b);
+	quantVal->LL3 = b & 0x0F;
+	quantVal->HL3 = b >> 4;
+	Stream_Read_UINT8(s, b);
+	quantVal->LH3 = b & 0x0F;
+	quantVal->HH3 = b >> 4;
+	Stream_Read_UINT8(s, b);
+	quantVal->HL2 = b & 0x0F;
+	quantVal->LH2 = b >> 4;
+	Stream_Read_UINT8(s, b);
+	quantVal->HH2 = b & 0x0F;
+	quantVal->HL1 = b >> 4;
+	Stream_Read_UINT8(s, b);
+	quantVal->LH1 = b & 0x0F;
+	quantVal->HH1 = b >> 4;
+}
+
+static INLINE void progressive_rfx_quant_ladd(RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q, int val)
+{
+	q->HL1 += val; /* HL1 */
+	q->LH1 += val; /* LH1 */
+	q->HH1 += val; /* HH1 */
+	q->HL2 += val; /* HL2 */
+	q->LH2 += val; /* LH2 */
+	q->HH2 += val; /* HH2 */
+	q->HL3 += val; /* HL3 */
+	q->LH3 += val; /* LH3 */
+	q->HH3 += val; /* HH3 */
+	q->LL3 += val; /* LL3 */
+}
+
+static INLINE void progressive_rfx_quant_add(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q1,
+                                             const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q2,
+                                             RFX_COMPONENT_CODEC_QUANT* dst)
+{
+	dst->HL1 = q1->HL1 + q2->HL1; /* HL1 */
+	dst->LH1 = q1->LH1 + q2->LH1; /* LH1 */
+	dst->HH1 = q1->HH1 + q2->HH1; /* HH1 */
+	dst->HL2 = q1->HL2 + q2->HL2; /* HL2 */
+	dst->LH2 = q1->LH2 + q2->LH2; /* LH2 */
+	dst->HH2 = q1->HH2 + q2->HH2; /* HH2 */
+	dst->HL3 = q1->HL3 + q2->HL3; /* HL3 */
+	dst->LH3 = q1->LH3 + q2->LH3; /* LH3 */
+	dst->HH3 = q1->HH3 + q2->HH3; /* HH3 */
+	dst->LL3 = q1->LL3 + q2->LL3; /* LL3 */
+}
+
+static INLINE void progressive_rfx_quant_lsub(RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q, int val)
+{
+	q->HL1 -= val; /* HL1 */
+	q->LH1 -= val; /* LH1 */
+	q->HH1 -= val; /* HH1 */
+	q->HL2 -= val; /* HL2 */
+	q->LH2 -= val; /* LH2 */
+	q->HH2 -= val; /* HH2 */
+	q->HL3 -= val; /* HL3 */
+	q->LH3 -= val; /* LH3 */
+	q->HH3 -= val; /* HH3 */
+	q->LL3 -= val; /* LL3 */
+}
+
+static INLINE void progressive_rfx_quant_sub(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q1,
+                                             const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q2,
+                                             RFX_COMPONENT_CODEC_QUANT* dst)
+{
+	dst->HL1 = q1->HL1 - q2->HL1; /* HL1 */
+	dst->LH1 = q1->LH1 - q2->LH1; /* LH1 */
+	dst->HH1 = q1->HH1 - q2->HH1; /* HH1 */
+	dst->HL2 = q1->HL2 - q2->HL2; /* HL2 */
+	dst->LH2 = q1->LH2 - q2->LH2; /* LH2 */
+	dst->HH2 = q1->HH2 - q2->HH2; /* HH2 */
+	dst->HL3 = q1->HL3 - q2->HL3; /* HL3 */
+	dst->LH3 = q1->LH3 - q2->LH3; /* LH3 */
+	dst->HH3 = q1->HH3 - q2->HH3; /* HH3 */
+	dst->LL3 = q1->LL3 - q2->LL3; /* LL3 */
+}
+
+static INLINE BOOL
+progressive_rfx_quant_lcmp_less_equal(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q, int val)
+{
+	if (q->HL1 > val)
+		return FALSE; /* HL1 */
+
+	if (q->LH1 > val)
+		return FALSE; /* LH1 */
+
+	if (q->HH1 > val)
+		return FALSE; /* HH1 */
+
+	if (q->HL2 > val)
+		return FALSE; /* HL2 */
+
+	if (q->LH2 > val)
+		return FALSE; /* LH2 */
+
+	if (q->HH2 > val)
+		return FALSE; /* HH2 */
+
+	if (q->HL3 > val)
+		return FALSE; /* HL3 */
+
+	if (q->LH3 > val)
+		return FALSE; /* LH3 */
+
+	if (q->HH3 > val)
+		return FALSE; /* HH3 */
+
+	if (q->LL3 > val)
+		return FALSE; /* LL3 */
+
+	return TRUE;
+}
+
+static INLINE BOOL
+progressive_rfx_quant_cmp_less_equal(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q1,
+                                     const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q2)
+{
+	if (q1->HL1 > q2->HL1)
+		return FALSE; /* HL1 */
+
+	if (q1->LH1 > q2->LH1)
+		return FALSE; /* LH1 */
+
+	if (q1->HH1 > q2->HH1)
+		return FALSE; /* HH1 */
+
+	if (q1->HL2 > q2->HL2)
+		return FALSE; /* HL2 */
+
+	if (q1->LH2 > q2->LH2)
+		return FALSE; /* LH2 */
+
+	if (q1->HH2 > q2->HH2)
+		return FALSE; /* HH2 */
+
+	if (q1->HL3 > q2->HL3)
+		return FALSE; /* HL3 */
+
+	if (q1->LH3 > q2->LH3)
+		return FALSE; /* LH3 */
+
+	if (q1->HH3 > q2->HH3)
+		return FALSE; /* HH3 */
+
+	if (q1->LL3 > q2->LL3)
+		return FALSE; /* LL3 */
+
+	return TRUE;
+}
+
+static INLINE BOOL
+progressive_rfx_quant_lcmp_greater_equal(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q, int val)
+{
+	if (q->HL1 < val)
+		return FALSE; /* HL1 */
+
+	if (q->LH1 < val)
+		return FALSE; /* LH1 */
+
+	if (q->HH1 < val)
+		return FALSE; /* HH1 */
+
+	if (q->HL2 < val)
+		return FALSE; /* HL2 */
+
+	if (q->LH2 < val)
+		return FALSE; /* LH2 */
+
+	if (q->HH2 < val)
+		return FALSE; /* HH2 */
+
+	if (q->HL3 < val)
+		return FALSE; /* HL3 */
+
+	if (q->LH3 < val)
+		return FALSE; /* LH3 */
+
+	if (q->HH3 < val)
+		return FALSE; /* HH3 */
+
+	if (q->LL3 < val)
+		return FALSE; /* LL3 */
+
+	return TRUE;
+}
+
+static INLINE BOOL
+progressive_rfx_quant_cmp_greater_equal(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q1,
+                                        const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q2)
+{
+	if (q1->HL1 < q2->HL1)
+		return FALSE; /* HL1 */
+
+	if (q1->LH1 < q2->LH1)
+		return FALSE; /* LH1 */
+
+	if (q1->HH1 < q2->HH1)
+		return FALSE; /* HH1 */
+
+	if (q1->HL2 < q2->HL2)
+		return FALSE; /* HL2 */
+
+	if (q1->LH2 < q2->LH2)
+		return FALSE; /* LH2 */
+
+	if (q1->HH2 < q2->HH2)
+		return FALSE; /* HH2 */
+
+	if (q1->HL3 < q2->HL3)
+		return FALSE; /* HL3 */
+
+	if (q1->LH3 < q2->LH3)
+		return FALSE; /* LH3 */
+
+	if (q1->HH3 < q2->HH3)
+		return FALSE; /* HH3 */
+
+	if (q1->LL3 < q2->LL3)
+		return FALSE; /* LL3 */
+
+	return TRUE;
+}
+
+static INLINE BOOL
+progressive_rfx_quant_cmp_equal(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q1,
+                                const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q2)
+{
+	if (q1->HL1 != q2->HL1)
+		return FALSE; /* HL1 */
+
+	if (q1->LH1 != q2->LH1)
+		return FALSE; /* LH1 */
+
+	if (q1->HH1 != q2->HH1)
+		return FALSE; /* HH1 */
+
+	if (q1->HL2 != q2->HL2)
+		return FALSE; /* HL2 */
+
+	if (q1->LH2 != q2->LH2)
+		return FALSE; /* LH2 */
+
+	if (q1->HH2 != q2->HH2)
+		return FALSE; /* HH2 */
+
+	if (q1->HL3 != q2->HL3)
+		return FALSE; /* HL3 */
+
+	if (q1->LH3 != q2->LH3)
+		return FALSE; /* LH3 */
+
+	if (q1->HH3 != q2->HH3)
+		return FALSE; /* HH3 */
+
+	if (q1->LL3 != q2->LL3)
+		return FALSE; /* LL3 */
+
+	return TRUE;
+}
+
+static INLINE BOOL progressive_set_surface_data(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                                UINT16 surfaceId,
+                                                PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT pData)
+{
+	ULONG_PTR key = 0;
+	key = ((ULONG_PTR)surfaceId) + 1;
+
+	if (pData)
+		return HashTable_Insert(progressive->SurfaceContexts, (void*)key, pData);
+
+	HashTable_Remove(progressive->SurfaceContexts, (void*)key);
+	return TRUE;
+}
+
+static INLINE PROGRESSIVE_SURFACE_CONTEXT*
+progressive_get_surface_data(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, UINT16 surfaceId)
+{
+	void* key = (void*)(((ULONG_PTR)surfaceId) + 1);
+
+	if (!progressive)
+		return NULL;
+
+	return HashTable_GetItemValue(progressive->SurfaceContexts, key);
+}
+
+static void progressive_tile_free(RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile)
+{
+	if (tile)
+	{
+		winpr_aligned_free(tile->sign);
+		winpr_aligned_free(tile->current);
+		winpr_aligned_free(tile->data);
+		winpr_aligned_free(tile);
+	}
+}
+
+static void progressive_surface_context_free(void* ptr)
+{
+	PROGRESSIVE_SURFACE_CONTEXT* surface = ptr;
+
+	if (!surface)
+		return;
+
+	if (surface->tiles)
+	{
+		for (size_t index = 0; index < surface->tilesSize; index++)
+		{
+			RFX_PROGRESSIVE_TILE* tile = surface->tiles[index];
+			progressive_tile_free(tile);
+		}
+	}
+
+	winpr_aligned_free((void*)surface->tiles);
+	winpr_aligned_free(surface->updatedTileIndices);
+	winpr_aligned_free(surface);
+}
+
+static INLINE RFX_PROGRESSIVE_TILE* progressive_tile_new(void)
+{
+	RFX_PROGRESSIVE_TILE* tile = winpr_aligned_calloc(1, sizeof(RFX_PROGRESSIVE_TILE), 32);
+	if (!tile)
+		goto fail;
+
+	tile->width = 64;
+	tile->height = 64;
+	tile->stride = 4 * tile->width;
+
+	size_t dataLen = 1ull * tile->stride * tile->height;
+	tile->data = (BYTE*)winpr_aligned_malloc(dataLen, 16);
+	if (!tile->data)
+		goto fail;
+	memset(tile->data, 0xFF, dataLen);
+
+	size_t signLen = (8192ULL + 32ULL) * 3ULL;
+	tile->sign = (BYTE*)winpr_aligned_malloc(signLen, 16);
+	if (!tile->sign)
+		goto fail;
+
+	size_t currentLen = (8192ULL + 32ULL) * 3ULL;
+	tile->current = (BYTE*)winpr_aligned_malloc(currentLen, 16);
+	if (!tile->current)
+		goto fail;
+
+	return tile;
+
+fail:
+	progressive_tile_free(tile);
+	return NULL;
+}
+
+static INLINE BOOL
+progressive_allocate_tile_cache(PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface, size_t min)
+{
+	size_t oldIndex = 0;
+
+	WINPR_ASSERT(surface);
+	WINPR_ASSERT(surface->gridSize > 0);
+
+	if (surface->tiles)
+	{
+		oldIndex = surface->gridSize;
+		while (surface->gridSize < min)
+			surface->gridSize += 1024;
+	}
+
+	void* tmp = winpr_aligned_recalloc((void*)surface->tiles, surface->gridSize,
+	                                   sizeof(RFX_PROGRESSIVE_TILE*), 32);
+	if (!tmp)
+		return FALSE;
+	surface->tilesSize = surface->gridSize;
+	surface->tiles = (RFX_PROGRESSIVE_TILE**)tmp;
+
+	for (size_t x = oldIndex; x < surface->tilesSize; x++)
+	{
+		surface->tiles[x] = progressive_tile_new();
+		if (!surface->tiles[x])
+			return FALSE;
+	}
+
+	tmp =
+	    winpr_aligned_recalloc(surface->updatedTileIndices, surface->gridSize, sizeof(UINT32), 32);
+	if (!tmp)
+		return FALSE;
+
+	surface->updatedTileIndices = tmp;
+
+	return TRUE;
+}
+
+static PROGRESSIVE_SURFACE_CONTEXT* progressive_surface_context_new(UINT16 surfaceId, UINT32 width,
+                                                                    UINT32 height)
+{
+	PROGRESSIVE_SURFACE_CONTEXT* surface = (PROGRESSIVE_SURFACE_CONTEXT*)winpr_aligned_calloc(
+	    1, sizeof(PROGRESSIVE_SURFACE_CONTEXT), 32);
+
+	if (!surface)
+		return NULL;
+
+	surface->id = surfaceId;
+	surface->width = width;
+	surface->height = height;
+	surface->gridWidth = (width + (64 - width % 64)) / 64;
+	surface->gridHeight = (height + (64 - height % 64)) / 64;
+	surface->gridSize = surface->gridWidth * surface->gridHeight;
+
+	if (!progressive_allocate_tile_cache(surface, surface->gridSize))
+	{
+		progressive_surface_context_free(surface);
+		return NULL;
+	}
+
+	return surface;
+}
+
+static INLINE BOOL
+progressive_surface_tile_replace(PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
+                                 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
+                                 const RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile, BOOL upgrade)
+{
+	RFX_PROGRESSIVE_TILE* t = NULL;
+
+	size_t zIdx = 0;
+	if (!surface || !tile)
+		return FALSE;
+
+	zIdx = (tile->yIdx * surface->gridWidth) + tile->xIdx;
+
+	if (zIdx >= surface->tilesSize)
+	{
+		WLog_ERR(TAG, "Invalid zIndex %" PRIuz, zIdx);
+		return FALSE;
+	}
+
+	t = surface->tiles[zIdx];
+
+	t->blockType = tile->blockType;
+	t->blockLen = tile->blockLen;
+	t->quantIdxY = tile->quantIdxY;
+	t->quantIdxCb = tile->quantIdxCb;
+	t->quantIdxCr = tile->quantIdxCr;
+	t->xIdx = tile->xIdx;
+	t->yIdx = tile->yIdx;
+	t->flags = tile->flags;
+	t->quality = tile->quality;
+	t->x = tile->xIdx * t->width;
+	t->y = tile->yIdx * t->height;
+
+	if (upgrade)
+	{
+		t->ySrlLen = tile->ySrlLen;
+		t->yRawLen = tile->yRawLen;
+		t->cbSrlLen = tile->cbSrlLen;
+		t->cbRawLen = tile->cbRawLen;
+		t->crSrlLen = tile->crSrlLen;
+		t->crRawLen = tile->crRawLen;
+		t->ySrlData = tile->ySrlData;
+		t->yRawData = tile->yRawData;
+		t->cbSrlData = tile->cbSrlData;
+		t->cbRawData = tile->cbRawData;
+		t->crSrlData = tile->crSrlData;
+		t->crRawData = tile->crRawData;
+	}
+	else
+	{
+		t->yLen = tile->yLen;
+		t->cbLen = tile->cbLen;
+		t->crLen = tile->crLen;
+		t->tailLen = tile->tailLen;
+		t->yData = tile->yData;
+		t->cbData = tile->cbData;
+		t->crData = tile->crData;
+		t->tailData = tile->tailData;
+	}
+
+	if (region->usedTiles >= region->numTiles)
+	{
+		WLog_ERR(TAG, "Invalid tile count, only expected %" PRIu16 ", got %" PRIu16,
+		         region->numTiles, region->usedTiles);
+		return FALSE;
+	}
+
+	region->tiles[region->usedTiles++] = t;
+	if (!t->dirty)
+	{
+		if (surface->numUpdatedTiles >= surface->gridSize)
+		{
+			if (!progressive_allocate_tile_cache(surface, surface->numUpdatedTiles + 1))
+				return FALSE;
+		}
+
+		surface->updatedTileIndices[surface->numUpdatedTiles++] = (UINT32)zIdx;
+	}
+
+	t->dirty = TRUE;
+	return TRUE;
+}
+
+INT32 progressive_create_surface_context(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                         UINT16 surfaceId, UINT32 width, UINT32 height)
+{
+	PROGRESSIVE_SURFACE_CONTEXT* surface = progressive_get_surface_data(progressive, surfaceId);
+
+	if (!surface)
+	{
+		surface = progressive_surface_context_new(surfaceId, width, height);
+
+		if (!surface)
+			return -1;
+
+		if (!progressive_set_surface_data(progressive, surfaceId, (void*)surface))
+		{
+			progressive_surface_context_free(surface);
+			return -1;
+		}
+	}
+
+	return 1;
+}
+
+int progressive_delete_surface_context(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                       UINT16 surfaceId)
+{
+	progressive_set_surface_data(progressive, surfaceId, NULL);
+
+	return 1;
+}
+
+/*
+ * Band	    Offset      Dimensions  Size
+ *
+ * HL1      0           31x33       1023
+ * LH1      1023        33x31       1023
+ * HH1      2046        31x31       961
+ *
+ * HL2      3007        16x17       272
+ * LH2      3279        17x16       272
+ * HH2      3551        16x16       256
+ *
+ * HL3      3807        8x9         72
+ * LH3      3879        9x8         72
+ * HH3      3951        8x8         64
+ *
+ * LL3      4015        9x9         81
+ */
+
+static INLINE void progressive_rfx_idwt_x(const INT16* WINPR_RESTRICT pLowBand, size_t nLowStep,
+                                          const INT16* WINPR_RESTRICT pHighBand, size_t nHighStep,
+                                          INT16* WINPR_RESTRICT pDstBand, size_t nDstStep,
+                                          size_t nLowCount, size_t nHighCount, size_t nDstCount)
+{
+	INT16 L0 = 0;
+	INT16 H0 = 0;
+	INT16 H1 = 0;
+	INT16 X0 = 0;
+	INT16 X1 = 0;
+	INT16 X2 = 0;
+
+	for (size_t i = 0; i < nDstCount; i++)
+	{
+		const INT16* pL = pLowBand;
+		const INT16* pH = pHighBand;
+		INT16* pX = pDstBand;
+		H0 = *pH++;
+		L0 = *pL++;
+		X0 = WINPR_ASSERTING_INT_CAST(int16_t, L0 - H0);
+		X2 = WINPR_ASSERTING_INT_CAST(int16_t, L0 - H0);
+
+		for (size_t j = 0; j < (nHighCount - 1); j++)
+		{
+			H1 = *pH;
+			pH++;
+			L0 = *pL;
+			pL++;
+			X2 = WINPR_ASSERTING_INT_CAST(int16_t, L0 - ((H0 + H1) / 2));
+			X1 = WINPR_ASSERTING_INT_CAST(int16_t, ((X0 + X2) / 2) + (2 * H0));
+			pX[0] = X0;
+			pX[1] = X1;
+			pX += 2;
+			X0 = X2;
+			H0 = H1;
+		}
+
+		if (nLowCount <= (nHighCount + 1))
+		{
+			if (nLowCount <= nHighCount)
+			{
+				pX[0] = X2;
+				pX[1] = WINPR_ASSERTING_INT_CAST(int16_t, X2 + (2 * H0));
+			}
+			else
+			{
+				L0 = *pL;
+				pL++;
+				X0 = WINPR_ASSERTING_INT_CAST(int16_t, L0 - H0);
+				pX[0] = X2;
+				pX[1] = WINPR_ASSERTING_INT_CAST(int16_t, ((X0 + X2) / 2) + (2 * H0));
+				pX[2] = X0;
+			}
+		}
+		else
+		{
+			L0 = *pL;
+			pL++;
+			X0 = WINPR_ASSERTING_INT_CAST(int16_t, L0 - (H0 / 2));
+			pX[0] = X2;
+			pX[1] = WINPR_ASSERTING_INT_CAST(int16_t, ((X0 + X2) / 2) + (2 * H0));
+			pX[2] = X0;
+			L0 = *pL;
+			pL++;
+			pX[3] = WINPR_ASSERTING_INT_CAST(int16_t, (X0 + L0) / 2);
+		}
+
+		pLowBand += nLowStep;
+		pHighBand += nHighStep;
+		pDstBand += nDstStep;
+	}
+}
+
+static INLINE void progressive_rfx_idwt_y(const INT16* WINPR_RESTRICT pLowBand, size_t nLowStep,
+                                          const INT16* WINPR_RESTRICT pHighBand, size_t nHighStep,
+                                          INT16* WINPR_RESTRICT pDstBand, size_t nDstStep,
+                                          size_t nLowCount, size_t nHighCount, size_t nDstCount)
+{
+	INT16 L0 = 0;
+	INT16 H0 = 0;
+	INT16 H1 = 0;
+	INT16 X0 = 0;
+	INT16 X1 = 0;
+	INT16 X2 = 0;
+
+	for (size_t i = 0; i < nDstCount; i++)
+	{
+		const INT16* pL = pLowBand;
+		const INT16* pH = pHighBand;
+		INT16* pX = pDstBand;
+		H0 = *pH;
+		pH += nHighStep;
+		L0 = *pL;
+		pL += nLowStep;
+		X0 = WINPR_ASSERTING_INT_CAST(int16_t, L0 - H0);
+		X2 = WINPR_ASSERTING_INT_CAST(int16_t, L0 - H0);
+
+		for (size_t j = 0; j < (nHighCount - 1); j++)
+		{
+			H1 = *pH;
+			pH += nHighStep;
+			L0 = *pL;
+			pL += nLowStep;
+			X2 = WINPR_ASSERTING_INT_CAST(int16_t, L0 - ((H0 + H1) / 2));
+			X1 = WINPR_ASSERTING_INT_CAST(int16_t, ((X0 + X2) / 2) + (2 * H0));
+			*pX = X0;
+			pX += nDstStep;
+			*pX = X1;
+			pX += nDstStep;
+			X0 = X2;
+			H0 = H1;
+		}
+
+		if (nLowCount <= (nHighCount + 1))
+		{
+			if (nLowCount <= nHighCount)
+			{
+				*pX = X2;
+				pX += nDstStep;
+				*pX = WINPR_ASSERTING_INT_CAST(int16_t, X2 + (2 * H0));
+			}
+			else
+			{
+				L0 = *pL;
+				X0 = WINPR_ASSERTING_INT_CAST(int16_t, L0 - H0);
+				*pX = X2;
+				pX += nDstStep;
+				*pX = WINPR_ASSERTING_INT_CAST(int16_t, ((X0 + X2) / 2) + (2 * H0));
+				pX += nDstStep;
+				*pX = X0;
+			}
+		}
+		else
+		{
+			L0 = *pL;
+			pL += nLowStep;
+			X0 = WINPR_ASSERTING_INT_CAST(int16_t, L0 - (H0 / 2));
+			*pX = X2;
+			pX += nDstStep;
+			*pX = WINPR_ASSERTING_INT_CAST(int16_t, ((X0 + X2) / 2) + (2 * H0));
+			pX += nDstStep;
+			*pX = X0;
+			pX += nDstStep;
+			L0 = *pL;
+			*pX = WINPR_ASSERTING_INT_CAST(int16_t, (X0 + L0) / 2);
+		}
+
+		pLowBand++;
+		pHighBand++;
+		pDstBand++;
+	}
+}
+
+static INLINE size_t progressive_rfx_get_band_l_count(size_t level)
+{
+	return (64 >> level) + 1;
+}
+
+static INLINE size_t progressive_rfx_get_band_h_count(size_t level)
+{
+	if (level == 1)
+		return (64 >> 1) - 1;
+	else
+		return (64 + (1 << (level - 1))) >> level;
+}
+
+static INLINE void progressive_rfx_dwt_2d_decode_block(INT16* WINPR_RESTRICT buffer,
+                                                       INT16* WINPR_RESTRICT temp, size_t level)
+{
+	size_t nDstStepX = 0;
+	size_t nDstStepY = 0;
+	const INT16* WINPR_RESTRICT HL = NULL;
+	const INT16* WINPR_RESTRICT LH = NULL;
+	const INT16* WINPR_RESTRICT HH = NULL;
+	INT16* WINPR_RESTRICT LL = NULL;
+	INT16* WINPR_RESTRICT L = NULL;
+	INT16* WINPR_RESTRICT H = NULL;
+	INT16* WINPR_RESTRICT LLx = NULL;
+
+	const size_t nBandL = progressive_rfx_get_band_l_count(level);
+	const size_t nBandH = progressive_rfx_get_band_h_count(level);
+	size_t offset = 0;
+
+	HL = &buffer[offset];
+	offset += (nBandH * nBandL);
+	LH = &buffer[offset];
+	offset += (nBandL * nBandH);
+	HH = &buffer[offset];
+	offset += (nBandH * nBandH);
+	LL = &buffer[offset];
+	nDstStepX = (nBandL + nBandH);
+	nDstStepY = (nBandL + nBandH);
+	offset = 0;
+	L = &temp[offset];
+	offset += (nBandL * nDstStepX);
+	H = &temp[offset];
+	LLx = &buffer[0];
+
+	/* horizontal (LL + HL -> L) */
+	progressive_rfx_idwt_x(LL, nBandL, HL, nBandH, L, nDstStepX, nBandL, nBandH, nBandL);
+
+	/* horizontal (LH + HH -> H) */
+	progressive_rfx_idwt_x(LH, nBandL, HH, nBandH, H, nDstStepX, nBandL, nBandH, nBandH);
+
+	/* vertical (L + H -> LL) */
+	progressive_rfx_idwt_y(L, nDstStepX, H, nDstStepX, LLx, nDstStepY, nBandL, nBandH,
+	                       nBandL + nBandH);
+}
+
+void rfx_dwt_2d_extrapolate_decode(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT temp)
+{
+	WINPR_ASSERT(buffer);
+	WINPR_ASSERT(temp);
+	progressive_rfx_dwt_2d_decode_block(&buffer[3807], temp, 3);
+	progressive_rfx_dwt_2d_decode_block(&buffer[3007], temp, 2);
+	progressive_rfx_dwt_2d_decode_block(&buffer[0], temp, 1);
+}
+
+static INLINE int progressive_rfx_dwt_2d_decode(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                                INT16* WINPR_RESTRICT buffer,
+                                                INT16* WINPR_RESTRICT current, BOOL coeffDiff,
+                                                BOOL extrapolate, BOOL reverse)
+{
+	const primitives_t* prims = primitives_get();
+
+	if (!progressive || !buffer || !current)
+		return -1;
+
+	const size_t belements = 4096;
+	const size_t bsize = belements * sizeof(INT16);
+	if (reverse)
+		memcpy(buffer, current, bsize);
+	else if (!coeffDiff)
+		memcpy(current, buffer, bsize);
+	else
+		prims->add_16s_inplace(buffer, current, belements);
+
+	INT16* temp = (INT16*)BufferPool_Take(progressive->bufferPool, -1); /* DWT buffer */
+
+	if (!temp)
+		return -2;
+
+	if (!extrapolate)
+	{
+		progressive->rfx_context->dwt_2d_decode(buffer, temp);
+	}
+	else
+	{
+		WINPR_ASSERT(progressive->rfx_context->dwt_2d_extrapolate_decode);
+		progressive->rfx_context->dwt_2d_extrapolate_decode(buffer, temp);
+	}
+	BufferPool_Return(progressive->bufferPool, temp);
+	return 1;
+}
+
+static INLINE void progressive_rfx_decode_block(const primitives_t* prims,
+                                                INT16* WINPR_RESTRICT buffer, UINT32 length,
+                                                UINT32 shift)
+{
+	if (!shift)
+		return;
+
+	prims->lShiftC_16s_inplace(buffer, shift, length);
+}
+
+static INLINE int progressive_rfx_decode_component(
+    PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+    const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT shift, const BYTE* WINPR_RESTRICT data,
+    UINT32 length, INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT current,
+    INT16* WINPR_RESTRICT sign, BOOL coeffDiff, BOOL subbandDiff, BOOL extrapolate)
+{
+	int status = 0;
+	const primitives_t* prims = primitives_get();
+
+	status = progressive->rfx_context->rlgr_decode(RLGR1, data, length, buffer, 4096);
+
+	if (status < 0)
+		return status;
+
+	CopyMemory(sign, buffer, 4096ULL * 2ULL);
+	if (!extrapolate)
+	{
+		rfx_differential_decode(buffer + 4032, 64);
+		progressive_rfx_decode_block(prims, &buffer[0], 1024, shift->HL1);    /* HL1 */
+		progressive_rfx_decode_block(prims, &buffer[1024], 1024, shift->LH1); /* LH1 */
+		progressive_rfx_decode_block(prims, &buffer[2048], 1024, shift->HH1); /* HH1 */
+		progressive_rfx_decode_block(prims, &buffer[3072], 256, shift->HL2);  /* HL2 */
+		progressive_rfx_decode_block(prims, &buffer[3328], 256, shift->LH2);  /* LH2 */
+		progressive_rfx_decode_block(prims, &buffer[3584], 256, shift->HH2);  /* HH2 */
+		progressive_rfx_decode_block(prims, &buffer[3840], 64, shift->HL3);   /* HL3 */
+		progressive_rfx_decode_block(prims, &buffer[3904], 64, shift->LH3);   /* LH3 */
+		progressive_rfx_decode_block(prims, &buffer[3968], 64, shift->HH3);   /* HH3 */
+		progressive_rfx_decode_block(prims, &buffer[4032], 64, shift->LL3);   /* LL3 */
+	}
+	else
+	{
+		progressive_rfx_decode_block(prims, &buffer[0], 1023, shift->HL1);    /* HL1 */
+		progressive_rfx_decode_block(prims, &buffer[1023], 1023, shift->LH1); /* LH1 */
+		progressive_rfx_decode_block(prims, &buffer[2046], 961, shift->HH1);  /* HH1 */
+		progressive_rfx_decode_block(prims, &buffer[3007], 272, shift->HL2);  /* HL2 */
+		progressive_rfx_decode_block(prims, &buffer[3279], 272, shift->LH2);  /* LH2 */
+		progressive_rfx_decode_block(prims, &buffer[3551], 256, shift->HH2);  /* HH2 */
+		progressive_rfx_decode_block(prims, &buffer[3807], 72, shift->HL3);   /* HL3 */
+		progressive_rfx_decode_block(prims, &buffer[3879], 72, shift->LH3);   /* LH3 */
+		progressive_rfx_decode_block(prims, &buffer[3951], 64, shift->HH3);   /* HH3 */
+		rfx_differential_decode(&buffer[4015], 81);                           /* LL3 */
+		progressive_rfx_decode_block(prims, &buffer[4015], 81, shift->LL3);   /* LL3 */
+	}
+	return progressive_rfx_dwt_2d_decode(progressive, buffer, current, coeffDiff, extrapolate,
+	                                     FALSE);
+}
+
+static INLINE int
+progressive_decompress_tile_first(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                  RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile,
+                                  PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
+                                  const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
+{
+	int rc = 0;
+	BOOL diff = 0;
+	BOOL sub = 0;
+	BOOL extrapolate = 0;
+	BYTE* pBuffer = NULL;
+	INT16* pSign[3];
+	INT16* pSrcDst[3];
+	INT16* pCurrent[3];
+	RFX_COMPONENT_CODEC_QUANT shiftY = { 0 };
+	RFX_COMPONENT_CODEC_QUANT shiftCb = { 0 };
+	RFX_COMPONENT_CODEC_QUANT shiftCr = { 0 };
+	RFX_COMPONENT_CODEC_QUANT* quantY = NULL;
+	RFX_COMPONENT_CODEC_QUANT* quantCb = NULL;
+	RFX_COMPONENT_CODEC_QUANT* quantCr = NULL;
+	RFX_COMPONENT_CODEC_QUANT* quantProgY = NULL;
+	RFX_COMPONENT_CODEC_QUANT* quantProgCb = NULL;
+	RFX_COMPONENT_CODEC_QUANT* quantProgCr = NULL;
+	RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal = NULL;
+	static const prim_size_t roi_64x64 = { 64, 64 };
+	const primitives_t* prims = primitives_get();
+
+	tile->pass = 1;
+	diff = tile->flags & RFX_TILE_DIFFERENCE;
+	sub = context->flags & RFX_SUBBAND_DIFFING;
+	extrapolate = region->flags & RFX_DWT_REDUCE_EXTRAPOLATE;
+
+#if defined(WITH_DEBUG_CODECS)
+	WLog_Print(progressive->log, WLOG_DEBUG,
+	           "ProgressiveTile%s: quantIdx Y: %" PRIu8 " Cb: %" PRIu8 " Cr: %" PRIu8
+	           " xIdx: %" PRIu16 " yIdx: %" PRIu16 " flags: 0x%02" PRIX8 " quality: %" PRIu8
+	           " yLen: %" PRIu16 " cbLen: %" PRIu16 " crLen: %" PRIu16 " tailLen: %" PRIu16 "",
+	           (tile->blockType == PROGRESSIVE_WBT_TILE_FIRST) ? "First" : "Simple",
+	           tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr, tile->xIdx, tile->yIdx,
+	           tile->flags, tile->quality, tile->yLen, tile->cbLen, tile->crLen, tile->tailLen);
+#endif
+
+	if (tile->quantIdxY >= region->numQuant)
+	{
+		WLog_ERR(TAG, "quantIdxY %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxY, region->numQuant);
+		return -1;
+	}
+
+	quantY = &(region->quantVals[tile->quantIdxY]);
+
+	if (tile->quantIdxCb >= region->numQuant)
+	{
+		WLog_ERR(TAG, "quantIdxCb %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCb,
+		         region->numQuant);
+		return -1;
+	}
+
+	quantCb = &(region->quantVals[tile->quantIdxCb]);
+
+	if (tile->quantIdxCr >= region->numQuant)
+	{
+		WLog_ERR(TAG, "quantIdxCr %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCr,
+		         region->numQuant);
+		return -1;
+	}
+
+	quantCr = &(region->quantVals[tile->quantIdxCr]);
+
+	if (tile->quality == 0xFF)
+	{
+		quantProgVal = &(progressive->quantProgValFull);
+	}
+	else
+	{
+		if (tile->quality >= region->numProgQuant)
+		{
+			WLog_ERR(TAG, "quality %" PRIu8 " > numProgQuant %" PRIu8, tile->quality,
+			         region->numProgQuant);
+			return -1;
+		}
+
+		quantProgVal = &(region->quantProgVals[tile->quality]);
+	}
+
+	quantProgY = &(quantProgVal->yQuantValues);
+	quantProgCb = &(quantProgVal->cbQuantValues);
+	quantProgCr = &(quantProgVal->crQuantValues);
+
+	tile->yQuant = *quantY;
+	tile->cbQuant = *quantCb;
+	tile->crQuant = *quantCr;
+	tile->yProgQuant = *quantProgY;
+	tile->cbProgQuant = *quantProgCb;
+	tile->crProgQuant = *quantProgCr;
+
+	progressive_rfx_quant_add(quantY, quantProgY, &(tile->yBitPos));
+	progressive_rfx_quant_add(quantCb, quantProgCb, &(tile->cbBitPos));
+	progressive_rfx_quant_add(quantCr, quantProgCr, &(tile->crBitPos));
+	progressive_rfx_quant_add(quantY, quantProgY, &shiftY);
+	progressive_rfx_quant_lsub(&shiftY, 1); /* -6 + 5 = -1 */
+	progressive_rfx_quant_add(quantCb, quantProgCb, &shiftCb);
+	progressive_rfx_quant_lsub(&shiftCb, 1); /* -6 + 5 = -1 */
+	progressive_rfx_quant_add(quantCr, quantProgCr, &shiftCr);
+	progressive_rfx_quant_lsub(&shiftCr, 1); /* -6 + 5 = -1 */
+
+	pSign[0] = (INT16*)((&tile->sign[((8192 + 32) * 0) + 16])); /* Y/R buffer */
+	pSign[1] = (INT16*)((&tile->sign[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
+	pSign[2] = (INT16*)((&tile->sign[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
+
+	pCurrent[0] = (INT16*)((&tile->current[((8192 + 32) * 0) + 16])); /* Y/R buffer */
+	pCurrent[1] = (INT16*)((&tile->current[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
+	pCurrent[2] = (INT16*)((&tile->current[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
+
+	pBuffer = (BYTE*)BufferPool_Take(progressive->bufferPool, -1);
+	pSrcDst[0] = (INT16*)((&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */
+	pSrcDst[1] = (INT16*)((&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
+	pSrcDst[2] = (INT16*)((&pBuffer[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
+
+	rc = progressive_rfx_decode_component(progressive, &shiftY, tile->yData, tile->yLen, pSrcDst[0],
+	                                      pCurrent[0], pSign[0], diff, sub, extrapolate); /* Y */
+	if (rc < 0)
+		goto fail;
+	rc = progressive_rfx_decode_component(progressive, &shiftCb, tile->cbData, tile->cbLen,
+	                                      pSrcDst[1], pCurrent[1], pSign[1], diff, sub,
+	                                      extrapolate); /* Cb */
+	if (rc < 0)
+		goto fail;
+	rc = progressive_rfx_decode_component(progressive, &shiftCr, tile->crData, tile->crLen,
+	                                      pSrcDst[2], pCurrent[2], pSign[2], diff, sub,
+	                                      extrapolate); /* Cr */
+	if (rc < 0)
+		goto fail;
+
+	const INT16** ptr = WINPR_REINTERPRET_CAST(pSrcDst, INT16**, const INT16**);
+	rc = prims->yCbCrToRGB_16s8u_P3AC4R(ptr, 64 * 2, tile->data, tile->stride, progressive->format,
+	                                    &roi_64x64);
+fail:
+	BufferPool_Return(progressive->bufferPool, pBuffer);
+	return rc;
+}
+
+static INLINE INT16 progressive_rfx_srl_read(RFX_PROGRESSIVE_UPGRADE_STATE* WINPR_RESTRICT state,
+                                             UINT32 numBits)
+{
+	WINPR_ASSERT(state);
+
+	wBitStream* bs = state->srl;
+	WINPR_ASSERT(bs);
+
+	if (state->nz)
+	{
+		state->nz--;
+		return 0;
+	}
+
+	const UINT32 k = state->kp / 8;
+
+	if (!state->mode)
+	{
+		/* zero encoding */
+		const UINT32 bit = (bs->accumulator & 0x80000000) ? 1 : 0;
+		BitStream_Shift(bs, 1);
+
+		if (!bit)
+		{
+			/* '0' bit, nz >= (1 << k), nz = (1 << k) */
+			state->nz = (1 << k);
+			state->kp += 4;
+
+			if (state->kp > 80)
+				state->kp = 80;
+
+			state->nz--;
+			return 0;
+		}
+		else
+		{
+			/* '1' bit, nz < (1 << k), nz = next k bits */
+			state->nz = 0;
+			state->mode = 1; /* unary encoding is next */
+
+			if (k)
+			{
+				bs->mask = ((1 << k) - 1);
+				state->nz =
+				    WINPR_ASSERTING_INT_CAST(int16_t, ((bs->accumulator >> (32u - k)) & bs->mask));
+				BitStream_Shift(bs, k);
+			}
+
+			if (state->nz)
+			{
+				state->nz--;
+				return 0;
+			}
+		}
+	}
+
+	state->mode = 0; /* zero encoding is next */
+	/* unary encoding */
+	/* read sign bit */
+	const UINT32 sign = (bs->accumulator & 0x80000000) ? 1 : 0;
+	BitStream_Shift(bs, 1);
+
+	if (state->kp < 6)
+		state->kp = 0;
+	else
+		state->kp -= 6;
+
+	if (numBits == 1)
+		return sign ? -1 : 1;
+
+	UINT32 mag = 1;
+	const UINT32 max = (1 << numBits) - 1;
+
+	while (mag < max)
+	{
+		const UINT32 bit = (bs->accumulator & 0x80000000) ? 1 : 0;
+		BitStream_Shift(bs, 1);
+
+		if (bit)
+			break;
+
+		mag++;
+	}
+
+	if (mag > INT16_MAX)
+		mag = INT16_MAX;
+	return (INT16)(sign ? -1 * (int)mag : (INT16)mag);
+}
+
+static INLINE int
+progressive_rfx_upgrade_state_finish(RFX_PROGRESSIVE_UPGRADE_STATE* WINPR_RESTRICT state)
+{
+	UINT32 pad = 0;
+	wBitStream* srl = NULL;
+	wBitStream* raw = NULL;
+	if (!state)
+		return -1;
+
+	srl = state->srl;
+	raw = state->raw;
+	/* Read trailing bits from RAW/SRL bit streams */
+	pad = (raw->position % 8) ? (8 - (raw->position % 8)) : 0;
+
+	if (pad)
+		BitStream_Shift(raw, pad);
+
+	pad = (srl->position % 8) ? (8 - (srl->position % 8)) : 0;
+
+	if (pad)
+		BitStream_Shift(srl, pad);
+
+	if (BitStream_GetRemainingLength(srl) == 8)
+		BitStream_Shift(srl, 8);
+
+	return 1;
+}
+
+static INLINE int progressive_rfx_upgrade_block(RFX_PROGRESSIVE_UPGRADE_STATE* WINPR_RESTRICT state,
+                                                INT16* WINPR_RESTRICT buffer,
+                                                INT16* WINPR_RESTRICT sign, UINT32 length,
+                                                UINT32 shift, UINT32 bitPos, UINT32 numBits)
+{
+	if (!numBits)
+		return 1;
+
+	wBitStream* raw = state->raw;
+	int32_t input = 0;
+
+	if (!state->nonLL)
+	{
+		for (UINT32 index = 0; index < length; index++)
+		{
+			raw->mask = ((1 << numBits) - 1);
+			input = (INT16)((raw->accumulator >> (32 - numBits)) & raw->mask);
+			BitStream_Shift(raw, numBits);
+
+			const int32_t shifted = input << shift;
+			const int32_t val = buffer[index] + shifted;
+			const int16_t ival = WINPR_ASSERTING_INT_CAST(int16_t, val);
+			buffer[index] = ival;
+		}
+
+		return 1;
+	}
+
+	for (UINT32 index = 0; index < length; index++)
+	{
+		if (sign[index] > 0)
+		{
+			/* sign > 0, read from raw */
+			raw->mask = ((1 << numBits) - 1);
+			input = (INT16)((raw->accumulator >> (32 - numBits)) & raw->mask);
+			BitStream_Shift(raw, numBits);
+		}
+		else if (sign[index] < 0)
+		{
+			/* sign < 0, read from raw */
+			raw->mask = ((1 << numBits) - 1);
+			input = (INT16)((raw->accumulator >> (32 - numBits)) & raw->mask);
+			BitStream_Shift(raw, numBits);
+			input *= -1;
+		}
+		else
+		{
+			/* sign == 0, read from srl */
+			input = progressive_rfx_srl_read(state, numBits);
+			sign[index] = WINPR_ASSERTING_INT_CAST(int16_t, input);
+		}
+
+		const int32_t val = input << shift;
+		const int32_t ival = buffer[index] + val;
+		buffer[index] = WINPR_ASSERTING_INT_CAST(INT16, ival);
+	}
+
+	return 1;
+}
+
+static INLINE int
+progressive_rfx_upgrade_component(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                  const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT shift,
+                                  const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT bitPos,
+                                  const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT numBits,
+                                  INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT current,
+                                  INT16* WINPR_RESTRICT sign, const BYTE* WINPR_RESTRICT srlData,
+                                  UINT32 srlLen, const BYTE* WINPR_RESTRICT rawData, UINT32 rawLen,
+                                  BOOL coeffDiff, BOOL subbandDiff, BOOL extrapolate)
+{
+	int rc = 0;
+	UINT32 aRawLen = 0;
+	UINT32 aSrlLen = 0;
+	wBitStream s_srl = { 0 };
+	wBitStream s_raw = { 0 };
+	RFX_PROGRESSIVE_UPGRADE_STATE state = { 0 };
+
+	state.kp = 8;
+	state.mode = 0;
+	state.srl = &s_srl;
+	state.raw = &s_raw;
+	BitStream_Attach(state.srl, srlData, srlLen);
+	BitStream_Fetch(state.srl);
+	BitStream_Attach(state.raw, rawData, rawLen);
+	BitStream_Fetch(state.raw);
+
+	state.nonLL = TRUE;
+	rc = progressive_rfx_upgrade_block(&state, &current[0], &sign[0], 1023, shift->HL1, bitPos->HL1,
+	                                   numBits->HL1); /* HL1 */
+	if (rc < 0)
+		return rc;
+	rc = progressive_rfx_upgrade_block(&state, &current[1023], &sign[1023], 1023, shift->LH1,
+	                                   bitPos->LH1, numBits->LH1); /* LH1 */
+	if (rc < 0)
+		return rc;
+	rc = progressive_rfx_upgrade_block(&state, &current[2046], &sign[2046], 961, shift->HH1,
+	                                   bitPos->HH1, numBits->HH1); /* HH1 */
+	if (rc < 0)
+		return rc;
+	rc = progressive_rfx_upgrade_block(&state, &current[3007], &sign[3007], 272, shift->HL2,
+	                                   bitPos->HL2, numBits->HL2); /* HL2 */
+	if (rc < 0)
+		return rc;
+	rc = progressive_rfx_upgrade_block(&state, &current[3279], &sign[3279], 272, shift->LH2,
+	                                   bitPos->LH2, numBits->LH2); /* LH2 */
+	if (rc < 0)
+		return rc;
+	rc = progressive_rfx_upgrade_block(&state, &current[3551], &sign[3551], 256, shift->HH2,
+	                                   bitPos->HH2, numBits->HH2); /* HH2 */
+	if (rc < 0)
+		return rc;
+	rc = progressive_rfx_upgrade_block(&state, &current[3807], &sign[3807], 72, shift->HL3,
+	                                   bitPos->HL3, numBits->HL3); /* HL3 */
+	if (rc < 0)
+		return rc;
+	rc = progressive_rfx_upgrade_block(&state, &current[3879], &sign[3879], 72, shift->LH3,
+	                                   bitPos->LH3, numBits->LH3); /* LH3 */
+	if (rc < 0)
+		return rc;
+	rc = progressive_rfx_upgrade_block(&state, &current[3951], &sign[3951], 64, shift->HH3,
+	                                   bitPos->HH3, numBits->HH3); /* HH3 */
+	if (rc < 0)
+		return rc;
+
+	state.nonLL = FALSE;
+	rc = progressive_rfx_upgrade_block(&state, &current[4015], &sign[4015], 81, shift->LL3,
+	                                   bitPos->LL3, numBits->LL3); /* LL3 */
+	if (rc < 0)
+		return rc;
+	rc = progressive_rfx_upgrade_state_finish(&state);
+	if (rc < 0)
+		return rc;
+	aRawLen = (state.raw->position + 7) / 8;
+	aSrlLen = (state.srl->position + 7) / 8;
+
+	if ((aRawLen != rawLen) || (aSrlLen != srlLen))
+	{
+		int pRawLen = 0;
+		int pSrlLen = 0;
+
+		if (rawLen)
+			pRawLen = (int)((((float)aRawLen) / ((float)rawLen)) * 100.0f);
+
+		if (srlLen)
+			pSrlLen = (int)((((float)aSrlLen) / ((float)srlLen)) * 100.0f);
+
+		WLog_Print(progressive->log, WLOG_WARN,
+		           "RAW: %" PRIu32 "/%" PRIu32 " %d%% (%" PRIu32 "/%" PRIu32 ":%" PRIu32
+		           ")\tSRL: %" PRIu32 "/%" PRIu32 " %d%% (%" PRIu32 "/%" PRIu32 ":%" PRIu32 ")",
+		           aRawLen, rawLen, pRawLen, state.raw->position, rawLen * 8,
+		           (rawLen * 8) - state.raw->position, aSrlLen, srlLen, pSrlLen,
+		           state.srl->position, srlLen * 8, (srlLen * 8) - state.srl->position);
+		return -1;
+	}
+
+	return progressive_rfx_dwt_2d_decode(progressive, buffer, current, coeffDiff, extrapolate,
+	                                     TRUE);
+}
+
+static INLINE int
+progressive_decompress_tile_upgrade(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                    RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile,
+                                    PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
+                                    const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
+{
+	int status = 0;
+	BOOL coeffDiff = 0;
+	BOOL sub = 0;
+	BOOL extrapolate = 0;
+	BYTE* pBuffer = NULL;
+	INT16* pSign[3] = { 0 };
+	INT16* pSrcDst[3] = { 0 };
+	INT16* pCurrent[3] = { 0 };
+	RFX_COMPONENT_CODEC_QUANT shiftY = { 0 };
+	RFX_COMPONENT_CODEC_QUANT shiftCb = { 0 };
+	RFX_COMPONENT_CODEC_QUANT shiftCr = { 0 };
+	RFX_COMPONENT_CODEC_QUANT yBitPos = { 0 };
+	RFX_COMPONENT_CODEC_QUANT cbBitPos = { 0 };
+	RFX_COMPONENT_CODEC_QUANT crBitPos = { 0 };
+	RFX_COMPONENT_CODEC_QUANT yNumBits = { 0 };
+	RFX_COMPONENT_CODEC_QUANT cbNumBits = { 0 };
+	RFX_COMPONENT_CODEC_QUANT crNumBits = { 0 };
+	RFX_COMPONENT_CODEC_QUANT* quantY = NULL;
+	RFX_COMPONENT_CODEC_QUANT* quantCb = NULL;
+	RFX_COMPONENT_CODEC_QUANT* quantCr = NULL;
+	RFX_COMPONENT_CODEC_QUANT* quantProgY = NULL;
+	RFX_COMPONENT_CODEC_QUANT* quantProgCb = NULL;
+	RFX_COMPONENT_CODEC_QUANT* quantProgCr = NULL;
+	RFX_PROGRESSIVE_CODEC_QUANT* quantProg = NULL;
+	static const prim_size_t roi_64x64 = { 64, 64 };
+	const primitives_t* prims = primitives_get();
+
+	coeffDiff = tile->flags & RFX_TILE_DIFFERENCE;
+	sub = context->flags & RFX_SUBBAND_DIFFING;
+	extrapolate = region->flags & RFX_DWT_REDUCE_EXTRAPOLATE;
+
+	tile->pass++;
+
+#if defined(WITH_DEBUG_CODECS)
+	WLog_Print(progressive->log, WLOG_DEBUG,
+	           "ProgressiveTileUpgrade: pass: %" PRIu16 " quantIdx Y: %" PRIu8 " Cb: %" PRIu8
+	           " Cr: %" PRIu8 " xIdx: %" PRIu16 " yIdx: %" PRIu16 " quality: %" PRIu8
+	           " ySrlLen: %" PRIu16 " yRawLen: %" PRIu16 " cbSrlLen: %" PRIu16 " cbRawLen: %" PRIu16
+	           " crSrlLen: %" PRIu16 " crRawLen: %" PRIu16 "",
+	           tile->pass, tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr, tile->xIdx,
+	           tile->yIdx, tile->quality, tile->ySrlLen, tile->yRawLen, tile->cbSrlLen,
+	           tile->cbRawLen, tile->crSrlLen, tile->crRawLen);
+#endif
+
+	if (tile->quantIdxY >= region->numQuant)
+	{
+		WLog_ERR(TAG, "quantIdxY %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxY, region->numQuant);
+		return -1;
+	}
+
+	quantY = &(region->quantVals[tile->quantIdxY]);
+
+	if (tile->quantIdxCb >= region->numQuant)
+	{
+		WLog_ERR(TAG, "quantIdxCb %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCb,
+		         region->numQuant);
+		return -1;
+	}
+
+	quantCb = &(region->quantVals[tile->quantIdxCb]);
+
+	if (tile->quantIdxCr >= region->numQuant)
+	{
+		WLog_ERR(TAG, "quantIdxCr %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCr,
+		         region->numQuant);
+		return -1;
+	}
+
+	quantCr = &(region->quantVals[tile->quantIdxCr]);
+
+	if (tile->quality == 0xFF)
+	{
+		quantProg = &(progressive->quantProgValFull);
+	}
+	else
+	{
+		if (tile->quality >= region->numProgQuant)
+		{
+			WLog_ERR(TAG, "quality %" PRIu8 " > numProgQuant %" PRIu8, tile->quality,
+			         region->numProgQuant);
+			return -1;
+		}
+
+		quantProg = &(region->quantProgVals[tile->quality]);
+	}
+
+	quantProgY = &(quantProg->yQuantValues);
+	quantProgCb = &(quantProg->cbQuantValues);
+	quantProgCr = &(quantProg->crQuantValues);
+
+	if (!progressive_rfx_quant_cmp_equal(quantY, &(tile->yQuant)))
+		WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantY has changed!");
+
+	if (!progressive_rfx_quant_cmp_equal(quantCb, &(tile->cbQuant)))
+		WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantCb has changed!");
+
+	if (!progressive_rfx_quant_cmp_equal(quantCr, &(tile->crQuant)))
+		WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantCr has changed!");
+
+	if (!(context->flags & RFX_SUBBAND_DIFFING))
+		WLog_WARN(TAG, "PROGRESSIVE_BLOCK_CONTEXT::flags & RFX_SUBBAND_DIFFING not set");
+
+	progressive_rfx_quant_add(quantY, quantProgY, &yBitPos);
+	progressive_rfx_quant_add(quantCb, quantProgCb, &cbBitPos);
+	progressive_rfx_quant_add(quantCr, quantProgCr, &crBitPos);
+	progressive_rfx_quant_sub(&(tile->yBitPos), &yBitPos, &yNumBits);
+	progressive_rfx_quant_sub(&(tile->cbBitPos), &cbBitPos, &cbNumBits);
+	progressive_rfx_quant_sub(&(tile->crBitPos), &crBitPos, &crNumBits);
+	progressive_rfx_quant_add(quantY, quantProgY, &shiftY);
+	progressive_rfx_quant_lsub(&shiftY, 1); /* -6 + 5 = -1 */
+	progressive_rfx_quant_add(quantCb, quantProgCb, &shiftCb);
+	progressive_rfx_quant_lsub(&shiftCb, 1); /* -6 + 5 = -1 */
+	progressive_rfx_quant_add(quantCr, quantProgCr, &shiftCr);
+	progressive_rfx_quant_lsub(&shiftCr, 1); /* -6 + 5 = -1 */
+
+	tile->yBitPos = yBitPos;
+	tile->cbBitPos = cbBitPos;
+	tile->crBitPos = crBitPos;
+	tile->yQuant = *quantY;
+	tile->cbQuant = *quantCb;
+	tile->crQuant = *quantCr;
+	tile->yProgQuant = *quantProgY;
+	tile->cbProgQuant = *quantProgCb;
+	tile->crProgQuant = *quantProgCr;
+
+	pSign[0] = (INT16*)((&tile->sign[((8192 + 32) * 0) + 16])); /* Y/R buffer */
+	pSign[1] = (INT16*)((&tile->sign[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
+	pSign[2] = (INT16*)((&tile->sign[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
+
+	pCurrent[0] = (INT16*)((&tile->current[((8192 + 32) * 0) + 16])); /* Y/R buffer */
+	pCurrent[1] = (INT16*)((&tile->current[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
+	pCurrent[2] = (INT16*)((&tile->current[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
+
+	pBuffer = (BYTE*)BufferPool_Take(progressive->bufferPool, -1);
+	pSrcDst[0] = (INT16*)((&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */
+	pSrcDst[1] = (INT16*)((&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
+	pSrcDst[2] = (INT16*)((&pBuffer[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
+
+	status = progressive_rfx_upgrade_component(progressive, &shiftY, quantProgY, &yNumBits,
+	                                           pSrcDst[0], pCurrent[0], pSign[0], tile->ySrlData,
+	                                           tile->ySrlLen, tile->yRawData, tile->yRawLen,
+	                                           coeffDiff, sub, extrapolate); /* Y */
+
+	if (status < 0)
+		goto fail;
+
+	status = progressive_rfx_upgrade_component(progressive, &shiftCb, quantProgCb, &cbNumBits,
+	                                           pSrcDst[1], pCurrent[1], pSign[1], tile->cbSrlData,
+	                                           tile->cbSrlLen, tile->cbRawData, tile->cbRawLen,
+	                                           coeffDiff, sub, extrapolate); /* Cb */
+
+	if (status < 0)
+		goto fail;
+
+	status = progressive_rfx_upgrade_component(progressive, &shiftCr, quantProgCr, &crNumBits,
+	                                           pSrcDst[2], pCurrent[2], pSign[2], tile->crSrlData,
+	                                           tile->crSrlLen, tile->crRawData, tile->crRawLen,
+	                                           coeffDiff, sub, extrapolate); /* Cr */
+
+	if (status < 0)
+		goto fail;
+
+	const INT16** ptr = WINPR_REINTERPRET_CAST(pSrcDst, INT16**, const INT16**);
+	status = prims->yCbCrToRGB_16s8u_P3AC4R(ptr, 64 * 2, tile->data, tile->stride,
+	                                        progressive->format, &roi_64x64);
+fail:
+	BufferPool_Return(progressive->bufferPool, pBuffer);
+	return status;
+}
+
+static INLINE BOOL progressive_tile_read_upgrade(
+    PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, wStream* WINPR_RESTRICT s, UINT16 blockType,
+    UINT32 blockLen, PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
+    PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
+    const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
+{
+	RFX_PROGRESSIVE_TILE tile = { 0 };
+	const size_t expect = 20;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, expect))
+		return FALSE;
+
+	tile.blockType = blockType;
+	tile.blockLen = blockLen;
+	tile.flags = 0;
+
+	Stream_Read_UINT8(s, tile.quantIdxY);
+	Stream_Read_UINT8(s, tile.quantIdxCb);
+	Stream_Read_UINT8(s, tile.quantIdxCr);
+	Stream_Read_UINT16(s, tile.xIdx);
+	Stream_Read_UINT16(s, tile.yIdx);
+	Stream_Read_UINT8(s, tile.quality);
+	Stream_Read_UINT16(s, tile.ySrlLen);
+	Stream_Read_UINT16(s, tile.yRawLen);
+	Stream_Read_UINT16(s, tile.cbSrlLen);
+	Stream_Read_UINT16(s, tile.cbRawLen);
+	Stream_Read_UINT16(s, tile.crSrlLen);
+	Stream_Read_UINT16(s, tile.crRawLen);
+
+	tile.ySrlData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, tile.ySrlLen))
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.ySrlLen);
+		return FALSE;
+	}
+
+	tile.yRawData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, tile.yRawLen))
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.yRawLen);
+		return FALSE;
+	}
+
+	tile.cbSrlData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, tile.cbSrlLen))
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
+		           tile.cbSrlLen);
+		return FALSE;
+	}
+
+	tile.cbRawData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, tile.cbRawLen))
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
+		           tile.cbRawLen);
+		return FALSE;
+	}
+
+	tile.crSrlData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, tile.crSrlLen))
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
+		           tile.crSrlLen);
+		return FALSE;
+	}
+
+	tile.crRawData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, tile.crRawLen))
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
+		           tile.crRawLen);
+		return FALSE;
+	}
+
+	return progressive_surface_tile_replace(surface, region, &tile, TRUE);
+}
+
+static INLINE BOOL progressive_tile_read(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                         BOOL simple, wStream* WINPR_RESTRICT s, UINT16 blockType,
+                                         UINT32 blockLen,
+                                         PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
+                                         PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
+                                         const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
+{
+	RFX_PROGRESSIVE_TILE tile = { 0 };
+	size_t expect = simple ? 16 : 17;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, expect))
+		return FALSE;
+
+	tile.blockType = blockType;
+	tile.blockLen = blockLen;
+
+	Stream_Read_UINT8(s, tile.quantIdxY);
+	Stream_Read_UINT8(s, tile.quantIdxCb);
+	Stream_Read_UINT8(s, tile.quantIdxCr);
+	Stream_Read_UINT16(s, tile.xIdx);
+	Stream_Read_UINT16(s, tile.yIdx);
+	Stream_Read_UINT8(s, tile.flags);
+
+	if (!simple)
+		Stream_Read_UINT8(s, tile.quality);
+	else
+		tile.quality = 0xFF;
+	Stream_Read_UINT16(s, tile.yLen);
+	Stream_Read_UINT16(s, tile.cbLen);
+	Stream_Read_UINT16(s, tile.crLen);
+	Stream_Read_UINT16(s, tile.tailLen);
+
+	tile.yData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, tile.yLen))
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.yLen);
+		return FALSE;
+	}
+
+	tile.cbData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, tile.cbLen))
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.cbLen);
+		return FALSE;
+	}
+
+	tile.crData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, tile.crLen))
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.crLen);
+		return FALSE;
+	}
+
+	tile.tailData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, tile.tailLen))
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.tailLen);
+		return FALSE;
+	}
+
+	return progressive_surface_tile_replace(surface, region, &tile, FALSE);
+}
+
+static void CALLBACK progressive_process_tiles_tile_work_callback(PTP_CALLBACK_INSTANCE instance,
+                                                                  void* context, PTP_WORK work)
+{
+	PROGRESSIVE_TILE_PROCESS_WORK_PARAM* param = (PROGRESSIVE_TILE_PROCESS_WORK_PARAM*)context;
+
+	WINPR_UNUSED(instance);
+	WINPR_UNUSED(work);
+
+	switch (param->tile->blockType)
+	{
+		case PROGRESSIVE_WBT_TILE_SIMPLE:
+		case PROGRESSIVE_WBT_TILE_FIRST:
+			progressive_decompress_tile_first(param->progressive, param->tile, param->region,
+			                                  param->context);
+			break;
+
+		case PROGRESSIVE_WBT_TILE_UPGRADE:
+			progressive_decompress_tile_upgrade(param->progressive, param->tile, param->region,
+			                                    param->context);
+			break;
+		default:
+			WLog_Print(param->progressive->log, WLOG_ERROR, "Invalid block type %04" PRIx16 " (%s)",
+			           param->tile->blockType,
+			           rfx_get_progressive_block_type_string(param->tile->blockType));
+			break;
+	}
+}
+
+static INLINE SSIZE_T progressive_process_tiles(
+    PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, wStream* WINPR_RESTRICT s,
+    PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
+    PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
+    const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
+{
+	int status = 0;
+	size_t end = 0;
+	const size_t start = Stream_GetPosition(s);
+	UINT16 blockType = 0;
+	UINT32 blockLen = 0;
+	UINT32 count = 0;
+	UINT16 close_cnt = 0;
+
+	WINPR_ASSERT(progressive);
+	WINPR_ASSERT(region);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, region->tileDataSize))
+		return -1;
+
+	while ((Stream_GetRemainingLength(s) >= 6) &&
+	       (region->tileDataSize > (Stream_GetPosition(s) - start)))
+	{
+		const size_t pos = Stream_GetPosition(s);
+
+		Stream_Read_UINT16(s, blockType);
+		Stream_Read_UINT32(s, blockLen);
+
+#if defined(WITH_DEBUG_CODECS)
+		WLog_Print(progressive->log, WLOG_DEBUG, "%s",
+		           rfx_get_progressive_block_type_string(blockType));
+#endif
+
+		if (blockLen < 6)
+		{
+			WLog_Print(progressive->log, WLOG_ERROR, "Expected >= %" PRIu32 " remaining %" PRIuz, 6,
+			           blockLen);
+			return -1003;
+		}
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, blockLen - 6))
+			return -1003;
+
+		switch (blockType)
+		{
+			case PROGRESSIVE_WBT_TILE_SIMPLE:
+				if (!progressive_tile_read(progressive, TRUE, s, blockType, blockLen, surface,
+				                           region, context))
+					return -1022;
+				break;
+
+			case PROGRESSIVE_WBT_TILE_FIRST:
+				if (!progressive_tile_read(progressive, FALSE, s, blockType, blockLen, surface,
+				                           region, context))
+					return -1027;
+				break;
+
+			case PROGRESSIVE_WBT_TILE_UPGRADE:
+				if (!progressive_tile_read_upgrade(progressive, s, blockType, blockLen, surface,
+				                                   region, context))
+					return -1032;
+				break;
+			default:
+				WLog_ERR(TAG, "Invalid block type %04" PRIx16 " (%s)", blockType,
+				         rfx_get_progressive_block_type_string(blockType));
+				return -1039;
+		}
+
+		size_t rem = Stream_GetPosition(s);
+		if ((rem - pos) != blockLen)
+		{
+			WLog_Print(progressive->log, WLOG_ERROR,
+			           "Actual block read %" PRIuz " but expected %" PRIu32, rem - pos, blockLen);
+			return -1040;
+		}
+		count++;
+	}
+
+	end = Stream_GetPosition(s);
+	if ((end - start) != region->tileDataSize)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           "Actual total blocks read %" PRIuz " but expected %" PRIu32, end - start,
+		           region->tileDataSize);
+		return -1041;
+	}
+
+	if (count != region->numTiles)
+	{
+		WLog_Print(progressive->log, WLOG_WARN,
+		           "numTiles inconsistency: actual: %" PRIu32 ", expected: %" PRIu16 "\n", count,
+		           region->numTiles);
+		return -1044;
+	}
+
+	for (UINT32 idx = 0; idx < region->numTiles; idx++)
+	{
+		RFX_PROGRESSIVE_TILE* tile = region->tiles[idx];
+		PROGRESSIVE_TILE_PROCESS_WORK_PARAM* param = &progressive->params[idx];
+		param->progressive = progressive;
+		param->region = region;
+		param->context = context;
+		param->tile = tile;
+
+		if (progressive->rfx_context->priv->UseThreads)
+		{
+			progressive->work_objects[idx] =
+			    CreateThreadpoolWork(progressive_process_tiles_tile_work_callback, (void*)param,
+			                         &progressive->rfx_context->priv->ThreadPoolEnv);
+			if (!progressive->work_objects[idx])
+			{
+				WLog_Print(progressive->log, WLOG_ERROR,
+				           "Failed to create ThreadpoolWork for tile %" PRIu32, idx);
+				status = -1;
+				break;
+			}
+
+			SubmitThreadpoolWork(progressive->work_objects[idx]);
+
+			close_cnt = WINPR_ASSERTING_INT_CAST(UINT16, idx + 1);
+		}
+		else
+		{
+			progressive_process_tiles_tile_work_callback(0, param, 0);
+		}
+
+		if (status < 0)
+		{
+			WLog_Print(progressive->log, WLOG_ERROR, "Failed to decompress %s at %" PRIu16,
+			           rfx_get_progressive_block_type_string(tile->blockType), idx);
+			goto fail;
+		}
+	}
+
+	if (progressive->rfx_context->priv->UseThreads)
+	{
+		for (UINT32 idx = 0; idx < close_cnt; idx++)
+		{
+			WaitForThreadpoolWorkCallbacks(progressive->work_objects[idx], FALSE);
+			CloseThreadpoolWork(progressive->work_objects[idx]);
+		}
+	}
+
+fail:
+
+	if (status < 0)
+		return -1;
+
+	return (SSIZE_T)(end - start);
+}
+
+static INLINE SSIZE_T progressive_wb_sync(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                          wStream* WINPR_RESTRICT s, UINT16 blockType,
+                                          UINT32 blockLen)
+{
+	const UINT32 magic = 0xCACCACCA;
+	const UINT16 version = 0x0100;
+	PROGRESSIVE_BLOCK_SYNC sync = { 0 };
+
+	sync.blockType = blockType;
+	sync.blockLen = blockLen;
+
+	if (sync.blockLen != 12)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           "PROGRESSIVE_BLOCK_SYNC::blockLen = 0x%08" PRIx32 " != 0x%08" PRIx32,
+		           sync.blockLen, 12);
+		return -1005;
+	}
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
+		return -1004;
+
+#if defined(WITH_DEBUG_CODECS)
+	WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveSync");
+#endif
+
+	Stream_Read_UINT32(s, sync.magic);
+	Stream_Read_UINT16(s, sync.version);
+
+	if (sync.magic != magic)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           "PROGRESSIVE_BLOCK_SYNC::magic = 0x%08" PRIx32 " != 0x%08" PRIx32, sync.magic,
+		           magic);
+		return -1005;
+	}
+
+	if (sync.version != 0x0100)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           "PROGRESSIVE_BLOCK_SYNC::version = 0x%04" PRIx16 " != 0x%04" PRIu16,
+		           sync.version, version);
+		return -1006;
+	}
+
+	if ((progressive->state & FLAG_WBT_SYNC) != 0)
+		WLog_WARN(TAG, "Duplicate PROGRESSIVE_BLOCK_SYNC, ignoring");
+
+	progressive->state |= FLAG_WBT_SYNC;
+	return 0;
+}
+
+static INLINE SSIZE_T progressive_wb_frame_begin(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                                 wStream* WINPR_RESTRICT s, UINT16 blockType,
+                                                 UINT32 blockLen)
+{
+	PROGRESSIVE_BLOCK_FRAME_BEGIN frameBegin = { 0 };
+
+	frameBegin.blockType = blockType;
+	frameBegin.blockLen = blockLen;
+
+	if (frameBegin.blockLen != 12)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           " RFX_PROGRESSIVE_FRAME_BEGIN::blockLen = 0x%08" PRIx32 " != 0x%08" PRIx32,
+		           frameBegin.blockLen, 12);
+		return -1005;
+	}
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
+		return -1007;
+
+	Stream_Read_UINT32(s, frameBegin.frameIndex);
+	Stream_Read_UINT16(s, frameBegin.regionCount);
+
+#if defined(WITH_DEBUG_CODECS)
+	WLog_Print(progressive->log, WLOG_DEBUG,
+	           "ProgressiveFrameBegin: frameIndex: %" PRIu32 " regionCount: %" PRIu16 "",
+	           frameBegin.frameIndex, frameBegin.regionCount);
+#endif
+
+	/**
+	 * If the number of elements specified by the regionCount field is
+	 * larger than the actual number of elements in the regions field,
+	 * the decoder SHOULD ignore this inconsistency.
+	 */
+
+	if ((progressive->state & FLAG_WBT_FRAME_BEGIN) != 0)
+	{
+		WLog_ERR(TAG, "Duplicate RFX_PROGRESSIVE_FRAME_BEGIN in stream, this is not allowed!");
+		return -1008;
+	}
+
+	if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
+	{
+		WLog_ERR(TAG, "RFX_PROGRESSIVE_FRAME_BEGIN after RFX_PROGRESSIVE_FRAME_END in stream, this "
+		              "is not allowed!");
+		return -1008;
+	}
+
+	progressive->state |= FLAG_WBT_FRAME_BEGIN;
+	return 0;
+}
+
+static INLINE SSIZE_T progressive_wb_frame_end(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                               wStream* WINPR_RESTRICT s, UINT16 blockType,
+                                               UINT32 blockLen)
+{
+	PROGRESSIVE_BLOCK_FRAME_END frameEnd = { 0 };
+
+	frameEnd.blockType = blockType;
+	frameEnd.blockLen = blockLen;
+
+	if (frameEnd.blockLen != 6)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           " RFX_PROGRESSIVE_FRAME_END::blockLen = 0x%08" PRIx32 " != 0x%08" PRIx32,
+		           frameEnd.blockLen, 6);
+		return -1005;
+	}
+
+	if (Stream_GetRemainingLength(s) != 0)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           "ProgressiveFrameEnd short %" PRIuz ", expected %" PRIuz,
+		           Stream_GetRemainingLength(s), 0);
+		return -1008;
+	}
+
+#if defined(WITH_DEBUG_CODECS)
+	WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveFrameEnd");
+#endif
+
+	if ((progressive->state & FLAG_WBT_FRAME_BEGIN) == 0)
+		WLog_WARN(TAG, "RFX_PROGRESSIVE_FRAME_END before RFX_PROGRESSIVE_FRAME_BEGIN, ignoring");
+	if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
+		WLog_WARN(TAG, "Duplicate RFX_PROGRESSIVE_FRAME_END, ignoring");
+
+	progressive->state |= FLAG_WBT_FRAME_END;
+	return 0;
+}
+
+static INLINE SSIZE_T progressive_wb_context(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                             wStream* WINPR_RESTRICT s, UINT16 blockType,
+                                             UINT32 blockLen)
+{
+	PROGRESSIVE_BLOCK_CONTEXT* context = &progressive->context;
+	context->blockType = blockType;
+	context->blockLen = blockLen;
+
+	if (context->blockLen != 10)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           "RFX_PROGRESSIVE_CONTEXT::blockLen = 0x%08" PRIx32 " != 0x%08" PRIx32,
+		           context->blockLen, 10);
+		return -1005;
+	}
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return -1009;
+
+	Stream_Read_UINT8(s, context->ctxId);
+	Stream_Read_UINT16(s, context->tileSize);
+	Stream_Read_UINT8(s, context->flags);
+
+	if (context->ctxId != 0x00)
+		WLog_WARN(TAG, "RFX_PROGRESSIVE_CONTEXT::ctxId != 0x00: %" PRIu8, context->ctxId);
+
+	if (context->tileSize != 64)
+	{
+		WLog_ERR(TAG, "RFX_PROGRESSIVE_CONTEXT::tileSize != 0x40: %" PRIu16, context->tileSize);
+		return -1010;
+	}
+
+	if ((progressive->state & FLAG_WBT_FRAME_BEGIN) != 0)
+		WLog_WARN(TAG, "RFX_PROGRESSIVE_CONTEXT received after RFX_PROGRESSIVE_FRAME_BEGIN");
+	if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
+		WLog_WARN(TAG, "RFX_PROGRESSIVE_CONTEXT received after RFX_PROGRESSIVE_FRAME_END");
+	if ((progressive->state & FLAG_WBT_CONTEXT) != 0)
+		WLog_WARN(TAG, "Duplicate RFX_PROGRESSIVE_CONTEXT received, ignoring.");
+
+#if defined(WITH_DEBUG_CODECS)
+	WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveContext: flags: 0x%02" PRIX8 "",
+	           context->flags);
+#endif
+
+	progressive->state |= FLAG_WBT_CONTEXT;
+	return 0;
+}
+
+static INLINE SSIZE_T progressive_wb_read_region_header(
+    PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, wStream* WINPR_RESTRICT s, UINT16 blockType,
+    UINT32 blockLen, PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region)
+{
+	region->usedTiles = 0;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
+		return -1011;
+
+	region->blockType = blockType;
+	region->blockLen = blockLen;
+	Stream_Read_UINT8(s, region->tileSize);
+	Stream_Read_UINT16(s, region->numRects);
+	Stream_Read_UINT8(s, region->numQuant);
+	Stream_Read_UINT8(s, region->numProgQuant);
+	Stream_Read_UINT8(s, region->flags);
+	Stream_Read_UINT16(s, region->numTiles);
+	Stream_Read_UINT32(s, region->tileDataSize);
+
+	if (region->tileSize != 64)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           "ProgressiveRegion tile size %" PRIu8 ", expected %" PRIuz, region->tileSize,
+		           64);
+		return -1012;
+	}
+
+	if (region->numRects < 1)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, "ProgressiveRegion missing rect count %" PRIu16,
+		           region->numRects);
+		return -1013;
+	}
+
+	if (region->numQuant > 7)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           "ProgressiveRegion quant count too high %" PRIu8 ", expected < %" PRIuz,
+		           region->numQuant, 7);
+		return -1014;
+	}
+
+	const SSIZE_T rc = WINPR_ASSERTING_INT_CAST(SSIZE_T, Stream_GetRemainingLength(s));
+	const SSIZE_T expect = region->numRects * 8ll + region->numQuant * 5ll +
+	                       region->numProgQuant * 16ll + region->tileDataSize;
+	SSIZE_T len = rc;
+	if (expect != rc)
+	{
+		if (len / 8LL < region->numRects)
+		{
+			WLog_Print(progressive->log, WLOG_ERROR,
+			           "ProgressiveRegion data short for region->rects");
+			return -1015;
+		}
+		len -= region->numRects * 8LL;
+
+		if (len / 5LL < region->numQuant)
+		{
+			WLog_Print(progressive->log, WLOG_ERROR,
+			           "ProgressiveRegion data short for region->cQuant");
+			return -1018;
+		}
+		len -= region->numQuant * 5LL;
+
+		if (len / 16LL < region->numProgQuant)
+		{
+			WLog_Print(progressive->log, WLOG_ERROR,
+			           "ProgressiveRegion data short for region->cProgQuant");
+			return -1021;
+		}
+		len -= region->numProgQuant * 16LL;
+
+		if (len < region->tileDataSize * 1ll)
+		{
+			WLog_Print(progressive->log, WLOG_ERROR,
+			           "ProgressiveRegion data short for region->tiles");
+			return -1024;
+		}
+		len -= region->tileDataSize;
+
+		if (len > 0)
+			WLog_Print(progressive->log, WLOG_WARN,
+			           "Unused bytes detected, %" PRIdz " bytes not processed", len);
+	}
+
+	return rc;
+}
+
+static INLINE SSIZE_T progressive_wb_skip_region(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                                 wStream* WINPR_RESTRICT s, UINT16 blockType,
+                                                 UINT32 blockLen)
+{
+	PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region = &progressive->region;
+
+	const SSIZE_T rc =
+	    progressive_wb_read_region_header(progressive, s, blockType, blockLen, region);
+	if (rc < 0)
+		return rc;
+
+	if (!Stream_SafeSeek(s, WINPR_ASSERTING_INT_CAST(size_t, rc)))
+		return -1111;
+
+	return rc;
+}
+
+static INLINE SSIZE_T progressive_wb_region(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                            wStream* WINPR_RESTRICT s, UINT16 blockType,
+                                            UINT32 blockLen,
+                                            PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
+                                            PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region)
+{
+	SSIZE_T rc = -1;
+	UINT16 boxLeft = 0;
+	UINT16 boxTop = 0;
+	UINT16 boxRight = 0;
+	UINT16 boxBottom = 0;
+	UINT16 idxLeft = 0;
+	UINT16 idxTop = 0;
+	UINT16 idxRight = 0;
+	UINT16 idxBottom = 0;
+	const PROGRESSIVE_BLOCK_CONTEXT* context = &progressive->context;
+
+	if ((progressive->state & FLAG_WBT_FRAME_BEGIN) == 0)
+	{
+		WLog_WARN(TAG, "RFX_PROGRESSIVE_REGION before RFX_PROGRESSIVE_FRAME_BEGIN, ignoring");
+		return progressive_wb_skip_region(progressive, s, blockType, blockLen);
+	}
+	if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
+	{
+		WLog_WARN(TAG, "RFX_PROGRESSIVE_REGION after RFX_PROGRESSIVE_FRAME_END, ignoring");
+		return progressive_wb_skip_region(progressive, s, blockType, blockLen);
+	}
+
+	progressive->state |= FLAG_WBT_REGION;
+
+	rc = progressive_wb_read_region_header(progressive, s, blockType, blockLen, region);
+	if (rc < 0)
+		return rc;
+
+	for (UINT16 index = 0; index < region->numRects; index++)
+	{
+		RFX_RECT* rect = &(region->rects[index]);
+		Stream_Read_UINT16(s, rect->x);
+		Stream_Read_UINT16(s, rect->y);
+		Stream_Read_UINT16(s, rect->width);
+		Stream_Read_UINT16(s, rect->height);
+	}
+
+	for (BYTE index = 0; index < region->numQuant; index++)
+	{
+		RFX_COMPONENT_CODEC_QUANT* quantVal = &(region->quantVals[index]);
+		progressive_component_codec_quant_read(s, quantVal);
+
+		if (!progressive_rfx_quant_lcmp_greater_equal(quantVal, 6))
+		{
+			WLog_Print(progressive->log, WLOG_ERROR,
+			           "ProgressiveRegion region->cQuant[%" PRIu32 "] < 6", index);
+			return -1;
+		}
+
+		if (!progressive_rfx_quant_lcmp_less_equal(quantVal, 15))
+		{
+			WLog_Print(progressive->log, WLOG_ERROR,
+			           "ProgressiveRegion region->cQuant[%" PRIu32 "] > 15", index);
+			return -1;
+		}
+	}
+
+	for (BYTE index = 0; index < region->numProgQuant; index++)
+	{
+		RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal = &(region->quantProgVals[index]);
+
+		Stream_Read_UINT8(s, quantProgVal->quality);
+
+		progressive_component_codec_quant_read(s, &(quantProgVal->yQuantValues));
+		progressive_component_codec_quant_read(s, &(quantProgVal->cbQuantValues));
+		progressive_component_codec_quant_read(s, &(quantProgVal->crQuantValues));
+	}
+
+#if defined(WITH_DEBUG_CODECS)
+	WLog_Print(progressive->log, WLOG_DEBUG,
+	           "ProgressiveRegion: numRects: %" PRIu16 " numTiles: %" PRIu16
+	           " tileDataSize: %" PRIu32 " flags: 0x%02" PRIX8 " numQuant: %" PRIu8
+	           " numProgQuant: %" PRIu8 "",
+	           region->numRects, region->numTiles, region->tileDataSize, region->flags,
+	           region->numQuant, region->numProgQuant);
+#endif
+
+	boxLeft = WINPR_ASSERTING_INT_CAST(UINT16, surface->gridWidth);
+	boxTop = WINPR_ASSERTING_INT_CAST(UINT16, surface->gridHeight);
+	boxRight = 0;
+	boxBottom = 0;
+
+	for (UINT16 index = 0; index < region->numRects; index++)
+	{
+		RFX_RECT* rect = &(region->rects[index]);
+		idxLeft = rect->x / 64;
+		idxTop = rect->y / 64;
+		idxRight = (rect->x + rect->width + 63) / 64;
+		idxBottom = (rect->y + rect->height + 63) / 64;
+
+		if (idxLeft < boxLeft)
+			boxLeft = idxLeft;
+
+		if (idxTop < boxTop)
+			boxTop = idxTop;
+
+		if (idxRight > boxRight)
+			boxRight = idxRight;
+
+		if (idxBottom > boxBottom)
+			boxBottom = idxBottom;
+
+#if defined(WITH_DEBUG_CODECS)
+		WLog_Print(progressive->log, WLOG_DEBUG,
+		           "rect[%" PRIu16 "]: x: %" PRIu16 " y: %" PRIu16 " w: %" PRIu16 " h: %" PRIu16 "",
+		           index, rect->x, rect->y, rect->width, rect->height);
+#endif
+	}
+
+	const SSIZE_T res = progressive_process_tiles(progressive, s, region, surface, context);
+	if (res < 0)
+		return -1;
+	return rc;
+}
+
+static INLINE SSIZE_T progressive_parse_block(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                              wStream* WINPR_RESTRICT s,
+                                              PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
+                                              PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region)
+{
+	UINT16 blockType = 0;
+	UINT32 blockLen = 0;
+	SSIZE_T rc = -1;
+	wStream sub = { 0 };
+
+	WINPR_ASSERT(progressive);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
+		return -1;
+
+	Stream_Read_UINT16(s, blockType);
+	Stream_Read_UINT32(s, blockLen);
+
+	if (blockLen < 6)
+	{
+		WLog_WARN(TAG, "Invalid blockLen %" PRIu32 ", expected >= 6", blockLen);
+		return -1;
+	}
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, blockLen - 6))
+		return -1;
+	Stream_StaticConstInit(&sub, Stream_Pointer(s), blockLen - 6);
+	Stream_Seek(s, blockLen - 6);
+
+	switch (blockType)
+	{
+		case PROGRESSIVE_WBT_SYNC:
+			rc = progressive_wb_sync(progressive, &sub, blockType, blockLen);
+			break;
+
+		case PROGRESSIVE_WBT_FRAME_BEGIN:
+			rc = progressive_wb_frame_begin(progressive, &sub, blockType, blockLen);
+			break;
+
+		case PROGRESSIVE_WBT_FRAME_END:
+			rc = progressive_wb_frame_end(progressive, &sub, blockType, blockLen);
+			break;
+
+		case PROGRESSIVE_WBT_CONTEXT:
+			rc = progressive_wb_context(progressive, &sub, blockType, blockLen);
+			break;
+
+		case PROGRESSIVE_WBT_REGION:
+			rc = progressive_wb_region(progressive, &sub, blockType, blockLen, surface, region);
+			break;
+
+		default:
+			WLog_Print(progressive->log, WLOG_ERROR, "Invalid block type %04" PRIx16, blockType);
+			return -1;
+	}
+
+	if (rc < 0)
+		return -1;
+
+	if (Stream_GetRemainingLength(&sub) > 0)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           "block len %" PRIu32 " does not match read data %" PRIuz, blockLen,
+		           blockLen - Stream_GetRemainingLength(&sub));
+		return -1;
+	}
+
+	return rc;
+}
+
+static INLINE BOOL update_tiles(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                                PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
+                                BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStep,
+                                UINT32 nXDst, UINT32 nYDst,
+                                PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
+                                REGION16* WINPR_RESTRICT invalidRegion)
+{
+	BOOL rc = TRUE;
+	REGION16 clippingRects = { 0 };
+	region16_init(&clippingRects);
+
+	for (UINT32 i = 0; i < region->numRects; i++)
+	{
+		RECTANGLE_16 clippingRect = { 0 };
+		const RFX_RECT* rect = &(region->rects[i]);
+
+		clippingRect.left = (UINT16)nXDst + rect->x;
+		clippingRect.top = (UINT16)nYDst + rect->y;
+		clippingRect.right = clippingRect.left + rect->width;
+		clippingRect.bottom = clippingRect.top + rect->height;
+		region16_union_rect(&clippingRects, &clippingRects, &clippingRect);
+	}
+
+	for (UINT32 i = 0; i < surface->numUpdatedTiles; i++)
+	{
+		UINT32 nbUpdateRects = 0;
+		const RECTANGLE_16* updateRects = NULL;
+		RECTANGLE_16 updateRect = { 0 };
+
+		WINPR_ASSERT(surface->updatedTileIndices);
+		const UINT32 index = surface->updatedTileIndices[i];
+
+		WINPR_ASSERT(index < surface->tilesSize);
+		RFX_PROGRESSIVE_TILE* tile = surface->tiles[index];
+		WINPR_ASSERT(tile);
+
+		const UINT32 dl = nXDst + tile->x;
+		updateRect.left = WINPR_ASSERTING_INT_CAST(UINT16, dl);
+
+		const UINT32 dt = nYDst + tile->y;
+		updateRect.top = WINPR_ASSERTING_INT_CAST(UINT16, dt);
+		updateRect.right = updateRect.left + 64;
+		updateRect.bottom = updateRect.top + 64;
+
+		REGION16 updateRegion = { 0 };
+		region16_init(&updateRegion);
+		region16_intersect_rect(&updateRegion, &clippingRects, &updateRect);
+		updateRects = region16_rects(&updateRegion, &nbUpdateRects);
+
+		for (UINT32 j = 0; j < nbUpdateRects; j++)
+		{
+			const RECTANGLE_16* rect = &updateRects[j];
+			if (rect->left < updateRect.left)
+				goto fail;
+			const UINT32 nXSrc = rect->left - updateRect.left;
+			const UINT32 nYSrc = rect->top - updateRect.top;
+			const UINT32 width = rect->right - rect->left;
+			const UINT32 height = rect->bottom - rect->top;
+
+			if (rect->left + width > surface->width)
+				goto fail;
+			if (rect->top + height > surface->height)
+				goto fail;
+			rc = freerdp_image_copy_no_overlap(
+			    pDstData, DstFormat, nDstStep, rect->left, rect->top, width, height, tile->data,
+			    progressive->format, tile->stride, nXSrc, nYSrc, NULL, FREERDP_KEEP_DST_ALPHA);
+			if (!rc)
+				break;
+
+			if (invalidRegion)
+				region16_union_rect(invalidRegion, invalidRegion, rect);
+		}
+
+		region16_uninit(&updateRegion);
+		tile->dirty = FALSE;
+	}
+
+fail:
+	region16_uninit(&clippingRects);
+	return rc;
+}
+
+INT32 progressive_decompress(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                             const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
+                             BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStep,
+                             UINT32 nXDst, UINT32 nYDst, REGION16* WINPR_RESTRICT invalidRegion,
+                             UINT16 surfaceId, UINT32 frameId)
+{
+	INT32 rc = 1;
+
+	WINPR_ASSERT(progressive);
+	PROGRESSIVE_SURFACE_CONTEXT* surface = progressive_get_surface_data(progressive, surfaceId);
+
+	if (!surface)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR, "ProgressiveRegion no surface for %" PRIu16,
+		           surfaceId);
+		return -1001;
+	}
+
+	PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region = &progressive->region;
+	WINPR_ASSERT(region);
+
+	if (surface->frameId != frameId)
+	{
+		surface->frameId = frameId;
+		surface->numUpdatedTiles = 0;
+	}
+
+	wStream ss = { 0 };
+	wStream* s = Stream_StaticConstInit(&ss, pSrcData, SrcSize);
+	WINPR_ASSERT(s);
+
+	switch (DstFormat)
+	{
+		case PIXEL_FORMAT_RGBA32:
+		case PIXEL_FORMAT_RGBX32:
+		case PIXEL_FORMAT_BGRA32:
+		case PIXEL_FORMAT_BGRX32:
+			progressive->format = DstFormat;
+			break;
+		default:
+			progressive->format = PIXEL_FORMAT_XRGB32;
+			break;
+	}
+
+	const size_t start = Stream_GetPosition(s);
+	progressive->state = 0; /* Set state to not initialized */
+	while (Stream_GetRemainingLength(s) > 0)
+	{
+		if (progressive_parse_block(progressive, s, surface, region) < 0)
+			goto fail;
+	}
+
+	const size_t end = Stream_GetPosition(s);
+	if ((end - start) != SrcSize)
+	{
+		WLog_Print(progressive->log, WLOG_ERROR,
+		           "total block len %" PRIuz " does not match read data %" PRIu32, end - start,
+		           SrcSize);
+		rc = -1041;
+		goto fail;
+	}
+
+	if (!update_tiles(progressive, surface, pDstData, DstFormat, nDstStep, nXDst, nYDst, region,
+	                  invalidRegion))
+		return -2002;
+fail:
+	return rc;
+}
+
+BOOL progressive_rfx_write_message_progressive_simple(PROGRESSIVE_CONTEXT* progressive, wStream* s,
+                                                      const RFX_MESSAGE* msg)
+{
+	RFX_CONTEXT* context = NULL;
+
+	WINPR_ASSERT(progressive);
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(msg);
+	context = progressive->rfx_context;
+	return rfx_write_message_progressive_simple(context, s, msg);
+}
+
+int progressive_compress(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
+                         const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize, UINT32 SrcFormat,
+                         UINT32 Width, UINT32 Height, UINT32 ScanLine,
+                         const REGION16* WINPR_RESTRICT invalidRegion,
+                         BYTE** WINPR_RESTRICT ppDstData, UINT32* WINPR_RESTRICT pDstSize)
+{
+	BOOL rc = FALSE;
+	int res = -6;
+	wStream* s = NULL;
+	UINT32 numRects = 0;
+	RFX_RECT* rects = NULL;
+	RFX_MESSAGE* message = NULL;
+
+	if (!progressive || !pSrcData || !ppDstData || !pDstSize)
+	{
+		return -1;
+	}
+
+	if (ScanLine == 0)
+	{
+		switch (SrcFormat)
+		{
+			case PIXEL_FORMAT_ABGR32:
+			case PIXEL_FORMAT_ARGB32:
+			case PIXEL_FORMAT_XBGR32:
+			case PIXEL_FORMAT_XRGB32:
+			case PIXEL_FORMAT_BGRA32:
+			case PIXEL_FORMAT_BGRX32:
+			case PIXEL_FORMAT_RGBA32:
+			case PIXEL_FORMAT_RGBX32:
+				ScanLine = Width * 4;
+				break;
+			default:
+				return -2;
+		}
+	}
+
+	if (SrcSize < Height * ScanLine)
+		return -4;
+
+	if (!invalidRegion)
+	{
+		numRects = (Width + 63) / 64;
+		numRects *= (Height + 63) / 64;
+	}
+	else
+	{
+		const int nr = region16_n_rects(invalidRegion);
+		numRects = WINPR_ASSERTING_INT_CAST(uint32_t, nr);
+	}
+
+	if (numRects == 0)
+		return 0;
+
+	if (!Stream_EnsureRemainingCapacity(progressive->rects, numRects * sizeof(RFX_RECT)))
+		return -5;
+	rects = Stream_BufferAs(progressive->rects, RFX_RECT);
+	if (invalidRegion)
+	{
+		const RECTANGLE_16* region_rects = region16_rects(invalidRegion, NULL);
+		for (UINT32 idx = 0; idx < numRects; idx++)
+		{
+			const RECTANGLE_16* r = &region_rects[idx];
+			RFX_RECT* rect = &rects[idx];
+
+			rect->x = r->left;
+			rect->y = r->top;
+			rect->width = r->right - r->left;
+			rect->height = r->bottom - r->top;
+		}
+	}
+	else
+	{
+		UINT16 x = 0;
+		UINT16 y = 0;
+
+		for (UINT32 i = 0; i < numRects; i++)
+		{
+			RFX_RECT* r = &rects[i];
+			r->x = x;
+			r->y = y;
+
+			WINPR_ASSERT(Width >= x);
+			WINPR_ASSERT(Height >= y);
+			r->width = MIN(64, WINPR_ASSERTING_INT_CAST(UINT16, Width - x));
+			r->height = MIN(64, WINPR_ASSERTING_INT_CAST(UINT16, Height - y));
+
+			if (x + 64 >= Width)
+			{
+				y += 64;
+				x = 0;
+			}
+			else
+				x += 64;
+
+			WINPR_ASSERT(r->x % 64 == 0);
+			WINPR_ASSERT(r->y % 64 == 0);
+			WINPR_ASSERT(r->width <= 64);
+			WINPR_ASSERT(r->height <= 64);
+		}
+	}
+	s = progressive->buffer;
+	Stream_SetPosition(s, 0);
+
+	progressive->rfx_context->mode = RLGR1;
+
+	progressive->rfx_context->width = WINPR_ASSERTING_INT_CAST(UINT16, Width);
+	progressive->rfx_context->height = WINPR_ASSERTING_INT_CAST(UINT16, Height);
+	rfx_context_set_pixel_format(progressive->rfx_context, SrcFormat);
+	message = rfx_encode_message(progressive->rfx_context, rects, numRects, pSrcData, Width, Height,
+	                             ScanLine);
+	if (!message)
+	{
+		WLog_ERR(TAG, "failed to encode rfx message");
+		goto fail;
+	}
+
+	rc = progressive_rfx_write_message_progressive_simple(progressive, s, message);
+	rfx_message_free(progressive->rfx_context, message);
+	if (!rc)
+		goto fail;
+
+	const size_t pos = Stream_GetPosition(s);
+	WINPR_ASSERT(pos <= UINT32_MAX);
+	*pDstSize = (UINT32)pos;
+	*ppDstData = Stream_Buffer(s);
+	res = 1;
+fail:
+	return res;
+}
+
+BOOL progressive_context_reset(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive)
+{
+	if (!progressive)
+		return FALSE;
+
+	return TRUE;
+}
+
+PROGRESSIVE_CONTEXT* progressive_context_new(BOOL Compressor)
+{
+	return progressive_context_new_ex(Compressor, 0);
+}
+
+PROGRESSIVE_CONTEXT* progressive_context_new_ex(BOOL Compressor, UINT32 ThreadingFlags)
+{
+	PROGRESSIVE_CONTEXT* progressive =
+	    (PROGRESSIVE_CONTEXT*)winpr_aligned_calloc(1, sizeof(PROGRESSIVE_CONTEXT), 32);
+
+	if (!progressive)
+		return NULL;
+
+	progressive->Compressor = Compressor;
+	progressive->quantProgValFull.quality = 100;
+	progressive->log = WLog_Get(TAG);
+	if (!progressive->log)
+		goto fail;
+	progressive->rfx_context = rfx_context_new_ex(Compressor, ThreadingFlags);
+	if (!progressive->rfx_context)
+		goto fail;
+	progressive->buffer = Stream_New(NULL, 1024);
+	if (!progressive->buffer)
+		goto fail;
+	progressive->rects = Stream_New(NULL, 1024);
+	if (!progressive->rects)
+		goto fail;
+	progressive->bufferPool = BufferPool_New(TRUE, (8192LL + 32LL) * 3LL, 16);
+	if (!progressive->bufferPool)
+		goto fail;
+	progressive->SurfaceContexts = HashTable_New(TRUE);
+	if (!progressive->SurfaceContexts)
+		goto fail;
+
+	{
+		wObject* obj = HashTable_ValueObject(progressive->SurfaceContexts);
+		WINPR_ASSERT(obj);
+		obj->fnObjectFree = progressive_surface_context_free;
+	}
+	return progressive;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	progressive_context_free(progressive);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void progressive_context_free(PROGRESSIVE_CONTEXT* progressive)
+{
+	if (!progressive)
+		return;
+
+	Stream_Free(progressive->buffer, TRUE);
+	Stream_Free(progressive->rects, TRUE);
+	rfx_context_free(progressive->rfx_context);
+
+	BufferPool_Free(progressive->bufferPool);
+	HashTable_Free(progressive->SurfaceContexts);
+
+	winpr_aligned_free(progressive);
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/codec/rfx_decode.h

@@ -0,0 +1,33 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX Codec Library - Decode
+ *
+ * Copyright 2011 Vic Lee
+ *
+ * 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_LIB_CODEC_RFX_DECODE_H
+#define FREERDP_LIB_CODEC_RFX_DECODE_H
+
+#include <winpr/wtypes.h>
+
+#include <freerdp/codec/rfx.h>
+#include <freerdp/api.h>
+
+/* stride is bytes between rows in the output buffer. */
+FREERDP_LOCAL BOOL rfx_decode_rgb(RFX_CONTEXT* WINPR_RESTRICT context,
+                                  const RFX_TILE* WINPR_RESTRICT tile,
+                                  BYTE* WINPR_RESTRICT rgb_buffer, UINT32 stride);
+
+#endif /* FREERDP_LIB_CODEC_RFX_DECODE_H */

local-test-freerdp-full-01/afc-freerdp/libfreerdp/codec/rfx_dwt.c

@@ -0,0 +1,230 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX Codec Library - DWT
+ *
+ * Copyright 2011 Vic Lee
+ *
+ * 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/assert.h>
+#include <winpr/cast.h>
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "rfx_dwt.h"
+
+static INLINE void rfx_dwt_2d_decode_block(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT idwt,
+                                           size_t subband_width)
+{
+	const size_t total_width = subband_width << 1;
+
+	/* Inverse DWT in horizontal direction, results in 2 sub-bands in L, H order in tmp buffer idwt.
+	 */
+	/* The 4 sub-bands are stored in HL(0), LH(1), HH(2), LL(3) order. */
+	/* The lower part L uses LL(3) and HL(0). */
+	/* The higher part H uses LH(1) and HH(2). */
+
+	const INT16* ll = buffer + subband_width * subband_width * 3;
+	const INT16* hl = buffer;
+	INT16* l_dst = idwt;
+
+	const INT16* lh = buffer + subband_width * subband_width;
+	const INT16* hh = buffer + subband_width * subband_width * 2;
+	INT16* h_dst = idwt + subband_width * subband_width * 2;
+
+	for (size_t y = 0; y < subband_width; y++)
+	{
+		/* Even coefficients */
+		l_dst[0] = WINPR_ASSERTING_INT_CAST(int16_t, ll[0] - ((hl[0] + hl[0] + 1) >> 1));
+		h_dst[0] = WINPR_ASSERTING_INT_CAST(int16_t, lh[0] - ((hh[0] + hh[0] + 1) >> 1));
+		for (size_t n = 1; n < subband_width; n++)
+		{
+			const size_t x = n << 1;
+			l_dst[x] = WINPR_ASSERTING_INT_CAST(int16_t, ll[n] - ((hl[n - 1] + hl[n] + 1) >> 1));
+			h_dst[x] = WINPR_ASSERTING_INT_CAST(int16_t, lh[n] - ((hh[n - 1] + hh[n] + 1) >> 1));
+		}
+
+		/* Odd coefficients */
+		size_t n = 0;
+		for (; n < subband_width - 1; n++)
+		{
+			const size_t x = n << 1;
+
+			const int ld = (hl[n] << 1) + ((l_dst[x] + l_dst[x + 2]) >> 1);
+			const int hd = (hh[n] << 1) + ((h_dst[x] + h_dst[x + 2]) >> 1);
+
+			l_dst[x + 1] = WINPR_ASSERTING_INT_CAST(INT16, ld);
+			h_dst[x + 1] = WINPR_ASSERTING_INT_CAST(INT16, hd);
+		}
+
+		const size_t x = n << 1;
+
+		const int ld = (hl[n] << 1) + (l_dst[x]);
+		const int hd = (hh[n] << 1) + (h_dst[x]);
+		l_dst[x + 1] = WINPR_ASSERTING_INT_CAST(INT16, ld);
+		h_dst[x + 1] = WINPR_ASSERTING_INT_CAST(INT16, hd);
+
+		ll += subband_width;
+		hl += subband_width;
+		l_dst += total_width;
+
+		lh += subband_width;
+		hh += subband_width;
+		h_dst += total_width;
+	}
+
+	/* Inverse DWT in vertical direction, results are stored in original buffer. */
+	for (size_t x = 0; x < total_width; x++)
+	{
+		const INT16* l = idwt + x;
+		const INT16* h = idwt + x + subband_width * total_width;
+		INT16* dst = buffer + x;
+
+		const int dd = *l - ((*h * 2 + 1) >> 1);
+		*dst = WINPR_ASSERTING_INT_CAST(INT16, dd);
+
+		for (size_t n = 1; n < subband_width; n++)
+		{
+			l += total_width;
+			h += total_width;
+
+			/* Even coefficients */
+			const int d2 = *l - ((*(h - total_width) + *h + 1) >> 1);
+			dst[2 * total_width] = WINPR_ASSERTING_INT_CAST(INT16, d2);
+
+			/* Odd coefficients */
+			const int d = (*(h - total_width) << 1) + ((*dst + dst[2 * total_width]) >> 1);
+			dst[total_width] = WINPR_ASSERTING_INT_CAST(INT16, d);
+
+			dst += 2 * total_width;
+		}
+
+		const int d = (*h << 1) + ((*dst * 2) >> 1);
+		dst[total_width] = WINPR_ASSERTING_INT_CAST(INT16, d);
+	}
+}
+
+void rfx_dwt_2d_decode(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT dwt_buffer)
+{
+	WINPR_ASSERT(buffer);
+	WINPR_ASSERT(dwt_buffer);
+
+	rfx_dwt_2d_decode_block(&buffer[3840], dwt_buffer, 8);
+	rfx_dwt_2d_decode_block(&buffer[3072], dwt_buffer, 16);
+	rfx_dwt_2d_decode_block(&buffer[0], dwt_buffer, 32);
+}
+
+static void rfx_dwt_2d_encode_block(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT dwt,
+                                    UINT32 subband_width)
+{
+	INT16* src = NULL;
+	INT16* l = NULL;
+	INT16* h = NULL;
+	INT16* l_src = NULL;
+	INT16* h_src = NULL;
+	INT16* hl = NULL;
+	INT16* lh = NULL;
+	INT16* hh = NULL;
+	INT16* ll = NULL;
+
+	const UINT32 total_width = subband_width << 1;
+
+	/* DWT in vertical direction, results in 2 sub-bands in L, H order in tmp buffer dwt. */
+	for (UINT32 x = 0; x < total_width; x++)
+	{
+		for (UINT32 n = 0; n < subband_width; n++)
+		{
+			UINT32 y = n << 1;
+			l = dwt + 1ULL * n * total_width + x;
+			h = l + 1ULL * subband_width * total_width;
+			src = buffer + 1ULL * y * total_width + x;
+
+			/* H */
+			*h = WINPR_ASSERTING_INT_CAST(
+			    int16_t, (src[total_width] -
+			              ((src[0] + src[n < subband_width - 1 ? 2 * total_width : 0]) >> 1)) >>
+			                 1);
+
+			/* L */
+			*l = WINPR_ASSERTING_INT_CAST(int16_t,
+			                              src[0] + (n == 0 ? *h : (*(h - total_width) + *h) >> 1));
+		}
+	}
+
+	/* DWT in horizontal direction, results in 4 sub-bands in HL(0), LH(1), HH(2), LL(3) order,
+	 * stored in original buffer. */
+	/* The lower part L generates LL(3) and HL(0). */
+	/* The higher part H generates LH(1) and HH(2). */
+
+	ll = buffer + 3ULL * subband_width * subband_width;
+	hl = buffer;
+	l_src = dwt;
+
+	lh = buffer + 1ULL * subband_width * subband_width;
+	hh = buffer + 2ULL * subband_width * subband_width;
+	h_src = dwt + 2ULL * subband_width * subband_width;
+
+	for (size_t y = 0; y < subband_width; y++)
+	{
+		/* L */
+		for (UINT32 n = 0; n < subband_width; n++)
+		{
+			UINT32 x = n << 1;
+
+			/* HL */
+			hl[n] = WINPR_ASSERTING_INT_CAST(
+			    int16_t,
+			    (l_src[x + 1] - ((l_src[x] + l_src[n < subband_width - 1 ? x + 2 : x]) >> 1)) >> 1);
+			/* LL */
+			ll[n] = WINPR_ASSERTING_INT_CAST(
+			    int16_t, l_src[x] + (n == 0 ? hl[n] : (hl[n - 1] + hl[n]) >> 1));
+		}
+
+		/* H */
+		for (UINT32 n = 0; n < subband_width; n++)
+		{
+			UINT32 x = n << 1;
+
+			/* HH */
+			hh[n] = WINPR_ASSERTING_INT_CAST(
+			    int16_t,
+			    (h_src[x + 1] - ((h_src[x] + h_src[n < subband_width - 1 ? x + 2 : x]) >> 1)) >> 1);
+			/* LH */
+			lh[n] = WINPR_ASSERTING_INT_CAST(
+			    int16_t, h_src[x] + (n == 0 ? hh[n] : (hh[n - 1] + hh[n]) >> 1));
+		}
+
+		ll += subband_width;
+		hl += subband_width;
+		l_src += total_width;
+
+		lh += subband_width;
+		hh += subband_width;
+		h_src += total_width;
+	}
+}
+
+void rfx_dwt_2d_encode(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT dwt_buffer)
+{
+	WINPR_ASSERT(buffer);
+	WINPR_ASSERT(dwt_buffer);
+
+	rfx_dwt_2d_encode_block(&buffer[0], dwt_buffer, 32);
+	rfx_dwt_2d_encode_block(&buffer[3072], dwt_buffer, 16);
+	rfx_dwt_2d_encode_block(&buffer[3840], dwt_buffer, 8);
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/codec/rfx_quantization.h

@@ -0,0 +1,31 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX Codec Library - Quantization
+ *
+ * Copyright 2011 Vic Lee
+ *
+ * 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_LIB_CODEC_RFX_QUANTIZATION_H
+#define FREERDP_LIB_CODEC_RFX_QUANTIZATION_H
+
+#include <freerdp/codec/rfx.h>
+#include <freerdp/api.h>
+
+FREERDP_LOCAL void rfx_quantization_decode(INT16* WINPR_RESTRICT buffer,
+                                           const UINT32* WINPR_RESTRICT quantization_values);
+FREERDP_LOCAL void rfx_quantization_encode(INT16* WINPR_RESTRICT buffer,
+                                           const UINT32* WINPR_RESTRICT quantization_values);
+
+#endif /* FREERDP_LIB_CODEC_RFX_QUANTIZATION_H */

local-test-freerdp-full-01/afc-freerdp/libfreerdp/codec/rfx_types.h

@@ -0,0 +1,184 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX Codec Library
+ *
+ * Copyright 2011 Vic Lee
+ *
+ * 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_LIB_CODEC_RFX_TYPES_H
+#define FREERDP_LIB_CODEC_RFX_TYPES_H
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+#include <winpr/pool.h>
+#include <winpr/wlog.h>
+#include <winpr/collections.h>
+
+#include <freerdp/codec/rfx.h>
+#include <freerdp/log.h>
+#include <freerdp/utils/profiler.h>
+
+#define RFX_TAG FREERDP_TAG("codec.rfx")
+#ifdef WITH_DEBUG_RFX
+#define DEBUG_RFX(...) WLog_DBG(RFX_TAG, __VA_ARGS__)
+#else
+#define DEBUG_RFX(...) \
+	do                 \
+	{                  \
+	} while (0)
+#endif
+
+#define RFX_DECODED_SYNC 0x00000001
+#define RFX_DECODED_CONTEXT 0x00000002
+#define RFX_DECODED_VERSIONS 0x00000004
+#define RFX_DECODED_CHANNELS 0x00000008
+#define RFX_DECODED_HEADERS 0x0000000F
+
+typedef enum
+{
+	RFX_STATE_INITIAL,
+	RFX_STATE_SERVER_UNINITIALIZED,
+	RFX_STATE_SEND_HEADERS,
+	RFX_STATE_SEND_FRAME_DATA,
+	RFX_STATE_FRAME_DATA_SENT,
+	RFX_STATE_FINAL
+} RFX_STATE;
+
+typedef struct S_RFX_TILE_COMPOSE_WORK_PARAM RFX_TILE_COMPOSE_WORK_PARAM;
+
+typedef struct S_RFX_CONTEXT_PRIV RFX_CONTEXT_PRIV;
+struct S_RFX_CONTEXT_PRIV
+{
+	wLog* log;
+	wObjectPool* TilePool;
+
+	BOOL UseThreads;
+	PTP_WORK* workObjects;
+	RFX_TILE_COMPOSE_WORK_PARAM* tileWorkParams;
+
+	DWORD MinThreadCount;
+	DWORD MaxThreadCount;
+
+	PTP_POOL ThreadPool;
+	TP_CALLBACK_ENVIRON ThreadPoolEnv;
+
+	wBufferPool* BufferPool;
+
+	/* profilers */
+	PROFILER_DEFINE(prof_rfx_decode_rgb)
+	PROFILER_DEFINE(prof_rfx_decode_component)
+	PROFILER_DEFINE(prof_rfx_rlgr_decode)
+	PROFILER_DEFINE(prof_rfx_differential_decode)
+	PROFILER_DEFINE(prof_rfx_quantization_decode)
+	PROFILER_DEFINE(prof_rfx_dwt_2d_decode)
+	PROFILER_DEFINE(prof_rfx_ycbcr_to_rgb)
+
+	PROFILER_DEFINE(prof_rfx_encode_rgb)
+	PROFILER_DEFINE(prof_rfx_encode_component)
+	PROFILER_DEFINE(prof_rfx_rlgr_encode)
+	PROFILER_DEFINE(prof_rfx_differential_encode)
+	PROFILER_DEFINE(prof_rfx_quantization_encode)
+	PROFILER_DEFINE(prof_rfx_dwt_2d_encode)
+	PROFILER_DEFINE(prof_rfx_rgb_to_ycbcr)
+	PROFILER_DEFINE(prof_rfx_encode_format_rgb)
+};
+
+struct S_RFX_MESSAGE
+{
+	UINT32 frameIdx;
+
+	/**
+	 * The rects array represents the updated region of the frame. The UI
+	 * requires to clip drawing destination base on the union of the rects.
+	 */
+	UINT16 numRects;
+	RFX_RECT* rects;
+
+	/**
+	 * The tiles array represents the actual frame data. Each tile is always
+	 * 64x64. Note that only pixels inside the updated region (represented as
+	 * rects described above) are valid. Pixels outside of the region may
+	 * contain arbitrary data.
+	 */
+	UINT16 numTiles;
+	size_t allocatedTiles;
+	RFX_TILE** tiles;
+
+	UINT16 numQuant;
+	UINT32* quantVals;
+
+	UINT32 tilesDataSize;
+
+	BOOL freeArray;
+};
+
+struct S_RFX_MESSAGE_LIST
+{
+	struct S_RFX_MESSAGE* list;
+	size_t count;
+	RFX_CONTEXT* context;
+};
+
+struct S_RFX_CONTEXT
+{
+	RFX_STATE state;
+
+	BOOL encoder;
+	UINT16 flags;
+	UINT16 properties;
+	UINT16 width;
+	UINT16 height;
+	RLGR_MODE mode;
+	UINT32 version;
+	UINT32 codec_id;
+	UINT32 codec_version;
+	UINT32 pixel_format;
+	BYTE bits_per_pixel;
+
+	/* color palette allocated by the application */
+	const BYTE* palette;
+
+	/* temporary data within a frame */
+	UINT32 frameIdx;
+	BYTE numQuant;
+	UINT32* quants;
+	BYTE quantIdxY;
+	BYTE quantIdxCb;
+	BYTE quantIdxCr;
+
+	/* decoded header blocks */
+	UINT32 decodedHeaderBlocks;
+	UINT16 expectedDataBlockType;
+	struct S_RFX_MESSAGE currentMessage;
+
+	/* routines */
+	void (*quantization_decode)(INT16* WINPR_RESTRICT buffer,
+	                            const UINT32* WINPR_RESTRICT quantization_values);
+	void (*quantization_encode)(INT16* WINPR_RESTRICT buffer,
+	                            const UINT32* WINPR_RESTRICT quantization_values);
+	void (*dwt_2d_decode)(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT dwt_buffer);
+	void (*dwt_2d_extrapolate_decode)(INT16* WINPR_RESTRICT src, INT16* WINPR_RESTRICT temp);
+	void (*dwt_2d_encode)(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT dwt_buffer);
+	int (*rlgr_decode)(RLGR_MODE mode, const BYTE* WINPR_RESTRICT data, UINT32 data_size,
+	                   INT16* WINPR_RESTRICT buffer, UINT32 buffer_size);
+	int (*rlgr_encode)(RLGR_MODE mode, const INT16* WINPR_RESTRICT data, UINT32 data_size,
+	                   BYTE* WINPR_RESTRICT buffer, UINT32 buffer_size);
+
+	/* private definitions */
+	RFX_CONTEXT_PRIV* priv;
+};
+
+#endif /* FREERDP_LIB_CODEC_RFX_TYPES_H */

local-test-freerdp-full-01/afc-freerdp/libfreerdp/gdi/CMakeLists.txt

@@ -0,0 +1,34 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# libfreerdp-gdi 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 "freerdp-gdi")
+set(MODULE_PREFIX "FREERDP_GDI")
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+option(WITH_GFX_FRAME_DUMP "Dump GFX commands to directory" OFF)
+if(WITH_GFX_FRAME_DUMP)
+  freerdp_definition_add(WITH_GFX_FRAME_DUMP)
+endif()
+
+file(GLOB ${MODULE_PREFIX}_SRCS LIST_DIRECTORIES false RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} CONFIGURE_DEPENDS "*.[ch]")
+
+freerdp_module_add(${${MODULE_PREFIX}_SRCS})
+
+if(BUILD_TESTING_INTERNAL)
+  add_subdirectory(test)
+endif()

local-test-freerdp-full-01/afc-freerdp/libfreerdp/gdi/bitmap.c

@@ -0,0 +1,678 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * GDI Bitmap Functions
+ *
+ * Copyright 2010-2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2016 Armin Novak <[email protected]>
+ * Copyright 2016 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 <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <freerdp/api.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/gdi/gdi.h>
+#include <freerdp/codec/color.h>
+
+#include <freerdp/gdi/region.h>
+#include <freerdp/gdi/bitmap.h>
+#include <freerdp/log.h>
+#include <freerdp/gdi/shape.h>
+
+#include "brush.h"
+#include "clipping.h"
+#include "../gdi/gdi.h"
+
+#define TAG FREERDP_TAG("gdi.bitmap")
+
+/**
+ * Get pixel at the given coordinates. msdn{dd144909}
+ * @param hdc device context
+ * @param nXPos pixel x position
+ * @param nYPos pixel y position
+ * @return pixel color
+ */
+
+UINT32 gdi_GetPixel(HGDI_DC hdc, UINT32 nXPos, UINT32 nYPos)
+{
+	HGDI_BITMAP hBmp = (HGDI_BITMAP)hdc->selectedObject;
+	BYTE* data =
+	    &(hBmp->data[(nYPos * hBmp->scanline) + nXPos * FreeRDPGetBytesPerPixel(hBmp->format)]);
+	return FreeRDPReadColor(data, hBmp->format);
+}
+
+BYTE* gdi_GetPointer(HGDI_BITMAP hBmp, UINT32 X, UINT32 Y)
+{
+	UINT32 bpp = FreeRDPGetBytesPerPixel(hBmp->format);
+	return &hBmp->data[(Y * WINPR_ASSERTING_INT_CAST(uint32_t, hBmp->width) * bpp) + X * bpp];
+}
+
+/**
+ * Set pixel at the given coordinates. msdn{dd145078}
+ *
+ * @param hBmp device context
+ * @param X pixel x position
+ * @param Y pixel y position
+ * @param crColor new pixel color
+ * @return the color written
+ */
+
+static INLINE UINT32 gdi_SetPixelBmp(HGDI_BITMAP hBmp, UINT32 X, UINT32 Y, UINT32 crColor)
+{
+	BYTE* p = &hBmp->data[(Y * hBmp->scanline) + X * FreeRDPGetBytesPerPixel(hBmp->format)];
+	FreeRDPWriteColor(p, hBmp->format, crColor);
+	return crColor;
+}
+
+UINT32 gdi_SetPixel(HGDI_DC hdc, UINT32 X, UINT32 Y, UINT32 crColor)
+{
+	HGDI_BITMAP hBmp = (HGDI_BITMAP)hdc->selectedObject;
+	return gdi_SetPixelBmp(hBmp, X, Y, crColor);
+}
+
+/**
+ * Create a new bitmap with the given width, height, color format and pixel buffer. msdn{dd183485}
+ *
+ * @param nWidth width
+ * @param nHeight height
+ * @param format the color format used
+ * @param data pixel buffer
+ * @return new bitmap
+ */
+
+HGDI_BITMAP gdi_CreateBitmap(UINT32 nWidth, UINT32 nHeight, UINT32 format, BYTE* data)
+{
+	return gdi_CreateBitmapEx(nWidth, nHeight, format, 0, data, winpr_aligned_free);
+}
+
+/**
+ * Create a new bitmap with the given width, height, color format and pixel buffer. msdn{dd183485}
+ *
+ * @param nWidth width
+ * @param nHeight height
+ * @param format the color format used
+ * @param data pixel buffer
+ * @param fkt_free The function used for deallocation of the buffer, NULL for none.
+ * @return new bitmap
+ */
+
+HGDI_BITMAP gdi_CreateBitmapEx(UINT32 nWidth, UINT32 nHeight, UINT32 format, UINT32 stride,
+                               BYTE* data, void (*fkt_free)(void*))
+{
+	HGDI_BITMAP hBitmap = (HGDI_BITMAP)calloc(1, sizeof(GDI_BITMAP));
+
+	if (!hBitmap)
+		return NULL;
+
+	hBitmap->objectType = GDIOBJECT_BITMAP;
+	hBitmap->format = format;
+
+	if (stride > 0)
+		hBitmap->scanline = stride;
+	else
+		hBitmap->scanline = nWidth * FreeRDPGetBytesPerPixel(hBitmap->format);
+
+	hBitmap->width = WINPR_ASSERTING_INT_CAST(int, nWidth);
+	hBitmap->height = WINPR_ASSERTING_INT_CAST(int, nHeight);
+	hBitmap->data = data;
+	hBitmap->free = fkt_free;
+	return hBitmap;
+}
+
+/**
+ * Create a new bitmap of the given width and height compatible with the current device context.
+ * msdn{dd183488}
+ *
+ * @param hdc device context
+ * @param nWidth width
+ * @param nHeight height
+ *
+ * @return new bitmap
+ */
+
+HGDI_BITMAP gdi_CreateCompatibleBitmap(HGDI_DC hdc, UINT32 nWidth, UINT32 nHeight)
+{
+	HGDI_BITMAP hBitmap = (HGDI_BITMAP)calloc(1, sizeof(GDI_BITMAP));
+
+	if (!hBitmap)
+		return NULL;
+
+	hBitmap->objectType = GDIOBJECT_BITMAP;
+	hBitmap->format = hdc->format;
+	WINPR_ASSERT(nWidth <= INT32_MAX);
+	hBitmap->width = (INT32)nWidth;
+
+	WINPR_ASSERT(nHeight <= INT32_MAX);
+	hBitmap->height = (INT32)nHeight;
+
+	size_t size = 1ull * nWidth * nHeight * FreeRDPGetBytesPerPixel(hBitmap->format);
+	hBitmap->data = winpr_aligned_malloc(size, 16);
+	hBitmap->free = winpr_aligned_free;
+
+	if (!hBitmap->data)
+	{
+		free(hBitmap);
+		return NULL;
+	}
+
+	/* Initialize with 0xff */
+	memset(hBitmap->data, 0xff, size);
+	hBitmap->scanline = nWidth * FreeRDPGetBytesPerPixel(hBitmap->format);
+	return hBitmap;
+}
+
+static BOOL op_not(UINT32* stack, const UINT32* stackp)
+{
+	if (!stack || !stackp)
+		return FALSE;
+
+	if (*stackp < 1)
+		return FALSE;
+
+	stack[(*stackp) - 1] = ~stack[(*stackp) - 1];
+	return TRUE;
+}
+
+static BOOL op_and(UINT32* stack, UINT32* stackp)
+{
+	if (!stack || !stackp)
+		return FALSE;
+
+	if (*stackp < 2)
+		return FALSE;
+
+	(*stackp)--;
+	stack[(*stackp) - 1] &= stack[(*stackp)];
+	return TRUE;
+}
+
+static BOOL op_or(UINT32* stack, UINT32* stackp)
+{
+	if (!stack || !stackp)
+		return FALSE;
+
+	if (*stackp < 2)
+		return FALSE;
+
+	(*stackp)--;
+	stack[(*stackp) - 1] |= stack[(*stackp)];
+	return TRUE;
+}
+
+static BOOL op_xor(UINT32* stack, UINT32* stackp)
+{
+	if (!stack || !stackp)
+		return FALSE;
+
+	if (*stackp < 2)
+		return FALSE;
+
+	(*stackp)--;
+	stack[(*stackp) - 1] ^= stack[(*stackp)];
+	return TRUE;
+}
+
+static UINT32 process_rop(UINT32 src, UINT32 dst, UINT32 pat, const char* rop, UINT32 format)
+{
+	UINT32 stack[10] = { 0 };
+	UINT32 stackp = 0;
+
+	while (*rop != '\0')
+	{
+		char op = *rop++;
+
+		switch (op)
+		{
+			case '0':
+				stack[stackp++] = FreeRDPGetColor(format, 0, 0, 0, 0xFF);
+				break;
+
+			case '1':
+				stack[stackp++] = FreeRDPGetColor(format, 0xFF, 0xFF, 0xFF, 0xFF);
+				break;
+
+			case 'D':
+				stack[stackp++] = dst;
+				break;
+
+			case 'S':
+				stack[stackp++] = src;
+				break;
+
+			case 'P':
+				stack[stackp++] = pat;
+				break;
+
+			case 'x':
+				op_xor(stack, &stackp);
+				break;
+
+			case 'a':
+				op_and(stack, &stackp);
+				break;
+
+			case 'o':
+				op_or(stack, &stackp);
+				break;
+
+			case 'n':
+				op_not(stack, &stackp);
+				break;
+
+			default:
+				break;
+		}
+	}
+
+	return stack[0];
+}
+
+static INLINE BOOL BitBlt_write(HGDI_DC hdcDest, HGDI_DC hdcSrc, INT32 nXDest, INT32 nYDest,
+                                INT32 nXSrc, INT32 nYSrc, INT32 x, INT32 y, BOOL useSrc,
+                                BOOL usePat, UINT32 style, const char* rop,
+                                const gdiPalette* palette)
+{
+	UINT32 dstColor = 0;
+	UINT32 colorA = 0;
+	UINT32 colorB = 0;
+	UINT32 colorC = 0;
+	const INT32 dstX = nXDest + x;
+	const INT32 dstY = nYDest + y;
+	BYTE* dstp = gdi_get_bitmap_pointer(hdcDest, dstX, dstY);
+
+	if (!dstp)
+	{
+		WLog_ERR(TAG, "dstp=%p", (const void*)dstp);
+		return FALSE;
+	}
+
+	colorA = FreeRDPReadColor(dstp, hdcDest->format);
+
+	if (useSrc)
+	{
+		const BYTE* srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc + x, nYSrc + y);
+
+		if (!srcp)
+		{
+			WLog_ERR(TAG, "srcp=%p", (const void*)srcp);
+			return FALSE;
+		}
+
+		colorC = FreeRDPReadColor(srcp, hdcSrc->format);
+		colorC = FreeRDPConvertColor(colorC, hdcSrc->format, hdcDest->format, palette);
+	}
+
+	if (usePat)
+	{
+		switch (style)
+		{
+			case GDI_BS_SOLID:
+				colorB = hdcDest->brush->color;
+				break;
+
+			case GDI_BS_HATCHED:
+			case GDI_BS_PATTERN:
+			{
+				const BYTE* patp =
+				    gdi_get_brush_pointer(hdcDest, WINPR_ASSERTING_INT_CAST(uint32_t, nXDest + x),
+				                          WINPR_ASSERTING_INT_CAST(uint32_t, nYDest + y));
+
+				if (!patp)
+				{
+					WLog_ERR(TAG, "patp=%p", (const void*)patp);
+					return FALSE;
+				}
+
+				colorB = FreeRDPReadColor(patp, hdcDest->format);
+			}
+			break;
+
+			default:
+				break;
+		}
+	}
+
+	dstColor = process_rop(colorC, colorA, colorB, rop, hdcDest->format);
+	return FreeRDPWriteColor(dstp, hdcDest->format, dstColor);
+}
+
+static BOOL adjust_src_coordinates(HGDI_DC hdcSrc, INT32 nWidth, INT32 nHeight, INT32* px,
+                                   INT32* py)
+{
+	HGDI_BITMAP hSrcBmp = NULL;
+	INT32 nXSrc = 0;
+	INT32 nYSrc = 0;
+
+	if (!hdcSrc || (nWidth < 0) || (nHeight < 0) || !px || !py)
+		return FALSE;
+
+	hSrcBmp = (HGDI_BITMAP)hdcSrc->selectedObject;
+	nXSrc = *px;
+	nYSrc = *py;
+
+	if (!hSrcBmp)
+		return FALSE;
+
+	if (nYSrc < 0)
+	{
+		nYSrc = 0;
+		nHeight = nHeight + nYSrc;
+	}
+
+	if ((nXSrc) < 0)
+	{
+		nXSrc = 0;
+		nWidth = nWidth + nXSrc;
+	}
+
+	if (hSrcBmp->width < (nXSrc + nWidth))
+		nXSrc = hSrcBmp->width - nWidth;
+
+	if (hSrcBmp->height < (nYSrc + nHeight))
+		nYSrc = hSrcBmp->height - nHeight;
+
+	if ((nXSrc < 0) || (nYSrc < 0))
+		return FALSE;
+
+	*px = nXSrc;
+	*py = nYSrc;
+	return TRUE;
+}
+
+static BOOL adjust_src_dst_coordinates(HGDI_DC hdcDest, INT32* pnXSrc, INT32* pnYSrc, INT32* pnXDst,
+                                       INT32* pnYDst, INT32* pnWidth, INT32* pnHeight)
+{
+	HGDI_BITMAP hDstBmp = NULL;
+	volatile INT32 diffX = 0;
+	volatile INT32 diffY = 0;
+	volatile INT32 nXSrc = 0;
+	volatile INT32 nYSrc = 0;
+	volatile INT32 nXDst = 0;
+	volatile INT32 nYDst = 0;
+	volatile INT32 nWidth = 0;
+	volatile INT32 nHeight = 0;
+
+	if (!hdcDest || !pnXSrc || !pnYSrc || !pnXDst || !pnYDst || !pnWidth || !pnHeight)
+		return FALSE;
+
+	hDstBmp = (HGDI_BITMAP)hdcDest->selectedObject;
+	nXSrc = *pnXSrc;
+	nYSrc = *pnYSrc;
+	nXDst = *pnXDst;
+	nYDst = *pnYDst;
+	nWidth = *pnWidth;
+	nHeight = *pnHeight;
+
+	if (!hDstBmp)
+		return FALSE;
+
+	if (nXDst < 0)
+	{
+		nXSrc -= nXDst;
+		nWidth += nXDst;
+		nXDst = 0;
+	}
+
+	if (nYDst < 0)
+	{
+		nYSrc -= nYDst;
+		nHeight += nYDst;
+		nYDst = 0;
+	}
+
+	diffX = hDstBmp->width - nXDst - nWidth;
+
+	if (diffX < 0)
+		nWidth += diffX;
+
+	diffY = hDstBmp->height - nYDst - nHeight;
+
+	if (diffY < 0)
+		nHeight += diffY;
+
+	if ((nXDst < 0) || (nYDst < 0) || (nWidth < 0) || (nHeight < 0))
+	{
+		nXDst = 0;
+		nYDst = 0;
+		nWidth = 0;
+		nHeight = 0;
+	}
+
+	*pnXSrc = nXSrc;
+	*pnYSrc = nYSrc;
+	*pnXDst = nXDst;
+	*pnYDst = nYDst;
+	*pnWidth = nWidth;
+	*pnHeight = nHeight;
+	return TRUE;
+}
+
+static BOOL BitBlt_process(HGDI_DC hdcDest, INT32 nXDest, INT32 nYDest, INT32 nWidth, INT32 nHeight,
+                           HGDI_DC hdcSrc, INT32 nXSrc, INT32 nYSrc, const char* rop,
+                           const gdiPalette* palette)
+{
+	UINT32 style = 0;
+	BOOL useSrc = FALSE;
+	BOOL usePat = FALSE;
+	const char* iter = rop;
+
+	while (*iter != '\0')
+	{
+		switch (*iter++)
+		{
+			case 'P':
+				usePat = TRUE;
+				break;
+
+			case 'S':
+				useSrc = TRUE;
+				break;
+
+			default:
+				break;
+		}
+	}
+
+	if (!hdcDest)
+		return FALSE;
+
+	if (!adjust_src_dst_coordinates(hdcDest, &nXSrc, &nYSrc, &nXDest, &nYDest, &nWidth, &nHeight))
+		return FALSE;
+
+	if (useSrc && !hdcSrc)
+		return FALSE;
+
+	if (useSrc)
+	{
+		if (!adjust_src_coordinates(hdcSrc, nWidth, nHeight, &nXSrc, &nYSrc))
+			return FALSE;
+	}
+
+	if (usePat)
+	{
+		style = gdi_GetBrushStyle(hdcDest);
+
+		switch (style)
+		{
+			case GDI_BS_SOLID:
+			case GDI_BS_HATCHED:
+			case GDI_BS_PATTERN:
+				break;
+
+			default:
+				WLog_ERR(TAG, "Invalid brush!!");
+				return FALSE;
+		}
+	}
+
+	if ((nXDest > nXSrc) && (nYDest > nYSrc))
+	{
+		for (INT32 y = nHeight - 1; y >= 0; y--)
+		{
+			for (INT32 x = nWidth - 1; x >= 0; x--)
+			{
+				if (!BitBlt_write(hdcDest, hdcSrc, nXDest, nYDest, nXSrc, nYSrc, x, y, useSrc,
+				                  usePat, style, rop, palette))
+					return FALSE;
+			}
+		}
+	}
+	else if (nXDest > nXSrc)
+	{
+		for (INT32 y = 0; y < nHeight; y++)
+		{
+			for (INT32 x = nWidth - 1; x >= 0; x--)
+			{
+				if (!BitBlt_write(hdcDest, hdcSrc, nXDest, nYDest, nXSrc, nYSrc, x, y, useSrc,
+				                  usePat, style, rop, palette))
+					return FALSE;
+			}
+		}
+	}
+	else if (nYDest > nYSrc)
+	{
+		for (INT32 y = nHeight - 1; y >= 0; y--)
+		{
+			for (INT32 x = 0; x < nWidth; x++)
+			{
+				if (!BitBlt_write(hdcDest, hdcSrc, nXDest, nYDest, nXSrc, nYSrc, x, y, useSrc,
+				                  usePat, style, rop, palette))
+					return FALSE;
+			}
+		}
+	}
+	else
+	{
+		for (INT32 y = 0; y < nHeight; y++)
+		{
+			for (INT32 x = 0; x < nWidth; x++)
+			{
+				if (!BitBlt_write(hdcDest, hdcSrc, nXDest, nYDest, nXSrc, nYSrc, x, y, useSrc,
+				                  usePat, style, rop, palette))
+					return FALSE;
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+/**
+ * Perform a bit blit operation on the given pixel buffers.
+ * msdn{dd183370}
+ *
+ * @param hdcDest destination device context
+ * @param nXDest destination x1
+ * @param nYDest destination y1
+ * @param nWidth width
+ * @param nHeight height
+ * @param hdcSrc source device context
+ * @param nXSrc source x1
+ * @param nYSrc source y1
+ * @param rop raster operation code
+ * @return 0 on failure, non-zero otherwise
+ */
+BOOL gdi_BitBlt(HGDI_DC hdcDest, INT32 nXDest, INT32 nYDest, INT32 nWidth, INT32 nHeight,
+                HGDI_DC hdcSrc, INT32 nXSrc, INT32 nYSrc, DWORD rop, const gdiPalette* palette)
+{
+	HGDI_BITMAP hSrcBmp = NULL;
+	HGDI_BITMAP hDstBmp = NULL;
+
+	if (!hdcDest)
+		return FALSE;
+
+	if (!gdi_ClipCoords(hdcDest, &nXDest, &nYDest, &nWidth, &nHeight, &nXSrc, &nYSrc))
+		return TRUE;
+
+	/* Check which ROP should be performed.
+	 * Some specific ROP are used heavily and are resource intensive,
+	 * add optimized versions for these here.
+	 *
+	 * For all others fall back to the generic implementation.
+	 */
+	switch (rop)
+	{
+		case GDI_SRCCOPY:
+			if (!hdcSrc)
+				return FALSE;
+
+			if (!adjust_src_dst_coordinates(hdcDest, &nXSrc, &nYSrc, &nXDest, &nYDest, &nWidth,
+			                                &nHeight))
+				return FALSE;
+
+			if (!adjust_src_coordinates(hdcSrc, nWidth, nHeight, &nXSrc, &nYSrc))
+				return FALSE;
+
+			hSrcBmp = (HGDI_BITMAP)hdcSrc->selectedObject;
+			hDstBmp = (HGDI_BITMAP)hdcDest->selectedObject;
+
+			if (!hSrcBmp || !hDstBmp)
+				return FALSE;
+
+			if (!freerdp_image_copy(
+			        hDstBmp->data, hDstBmp->format, hDstBmp->scanline,
+			        WINPR_ASSERTING_INT_CAST(UINT32, nXDest),
+			        WINPR_ASSERTING_INT_CAST(UINT32, nYDest),
+			        WINPR_ASSERTING_INT_CAST(UINT32, nWidth),
+			        WINPR_ASSERTING_INT_CAST(UINT32, nHeight), hSrcBmp->data, hSrcBmp->format,
+			        hSrcBmp->scanline, WINPR_ASSERTING_INT_CAST(UINT32, nXSrc),
+			        WINPR_ASSERTING_INT_CAST(UINT32, nYSrc), palette, FREERDP_FLIP_NONE))
+				return FALSE;
+
+			break;
+
+		case GDI_DSTCOPY:
+			hSrcBmp = (HGDI_BITMAP)hdcDest->selectedObject;
+			hDstBmp = (HGDI_BITMAP)hdcDest->selectedObject;
+
+			if (!adjust_src_dst_coordinates(hdcDest, &nXSrc, &nYSrc, &nXDest, &nYDest, &nWidth,
+			                                &nHeight))
+				return FALSE;
+
+			if (!adjust_src_coordinates(hdcDest, nWidth, nHeight, &nXSrc, &nYSrc))
+				return FALSE;
+
+			if (!hSrcBmp || !hDstBmp)
+				return FALSE;
+
+			if (!freerdp_image_copy(
+			        hDstBmp->data, hDstBmp->format, hDstBmp->scanline,
+			        WINPR_ASSERTING_INT_CAST(UINT32, nXDest),
+			        WINPR_ASSERTING_INT_CAST(UINT32, nYDest),
+			        WINPR_ASSERTING_INT_CAST(UINT32, nWidth),
+			        WINPR_ASSERTING_INT_CAST(UINT32, nHeight), hSrcBmp->data, hSrcBmp->format,
+			        hSrcBmp->scanline, WINPR_ASSERTING_INT_CAST(UINT32, nXSrc),
+			        WINPR_ASSERTING_INT_CAST(UINT32, nYSrc), palette, FREERDP_FLIP_NONE))
+				return FALSE;
+
+			break;
+
+		default:
+			if (!BitBlt_process(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc,
+			                    gdi_rop_to_string(rop), palette))
+				return FALSE;
+
+			break;
+	}
+
+	if (!gdi_InvalidateRegion(hdcDest, nXDest, nYDest, nWidth, nHeight))
+		return FALSE;
+
+	return TRUE;
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/gdi/brush.h

@@ -0,0 +1,53 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * GDI Brush Functions
+ *
+ * Copyright 2010-2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2016 Armin Novak <[email protected]>
+ * Copyright 2016 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_LIB_GDI_BRUSH_H
+#define FREERDP_LIB_GDI_BRUSH_H
+
+#include <winpr/cast.h>
+
+#include <freerdp/api.h>
+#include <freerdp/gdi/gdi.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_LOCAL const char* gdi_rop_to_string(UINT32 code);
+
+	FREERDP_LOCAL HGDI_BRUSH gdi_CreateSolidBrush(UINT32 crColor);
+	FREERDP_LOCAL HGDI_BRUSH gdi_CreatePatternBrush(HGDI_BITMAP hbmp);
+	FREERDP_LOCAL HGDI_BRUSH gdi_CreateHatchBrush(HGDI_BITMAP hbmp);
+
+	static INLINE UINT32 gdi_GetBrushStyle(HGDI_DC hdc)
+	{
+		if (!hdc || !hdc->brush)
+			return GDI_BS_NULL;
+
+		return WINPR_ASSERTING_INT_CAST(UINT32, hdc->brush->style);
+	}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_LIB_GDI_BRUSH_H */

local-test-freerdp-full-01/afc-freerdp/libfreerdp/gdi/dc.c

@@ -0,0 +1,258 @@
+/*
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * GDI Device Context Functions
+ *
+ * Copyright 2010-2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2016 Armin Novak <[email protected]>
+ * Copyright 2016 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.
+ */
+
+/* Device Context Functions: http://msdn.microsoft.com/en-us/library/dd183554 */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/gdi/gdi.h>
+
+#include <freerdp/gdi/region.h>
+
+#include <freerdp/gdi/dc.h>
+
+/**
+ * @brief Get the current device context (a new one is created each time).
+ * msdn{dd144871}
+ *
+ * @return current device context
+ */
+
+HGDI_DC gdi_GetDC(void)
+{
+	HGDI_DC hDC = (HGDI_DC)calloc(1, sizeof(GDI_DC));
+
+	if (!hDC)
+		return NULL;
+
+	hDC->format = PIXEL_FORMAT_XRGB32;
+	hDC->drawMode = GDI_R2_BLACK;
+	hDC->clip = gdi_CreateRectRgn(0, 0, 0, 0);
+
+	if (!hDC->clip)
+	{
+		free(hDC);
+		return NULL;
+	}
+
+	hDC->clip->null = TRUE;
+	hDC->hwnd = NULL;
+	return hDC;
+}
+
+/**
+ * @brief Create a device context.
+ * msdn{dd144871}
+ *
+ * @return new device context
+ */
+
+HGDI_DC gdi_CreateDC(UINT32 format)
+{
+	HGDI_DC hDC = NULL;
+
+	if (!(hDC = (HGDI_DC)calloc(1, sizeof(GDI_DC))))
+		return NULL;
+
+	hDC->drawMode = GDI_R2_BLACK;
+
+	if (!(hDC->clip = gdi_CreateRectRgn(0, 0, 0, 0)))
+		goto fail;
+
+	hDC->clip->null = TRUE;
+	hDC->hwnd = NULL;
+	hDC->format = format;
+
+	if (!(hDC->hwnd = (HGDI_WND)calloc(1, sizeof(GDI_WND))))
+		goto fail;
+
+	if (!(hDC->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0)))
+		goto fail;
+
+	hDC->hwnd->invalid->null = TRUE;
+	hDC->hwnd->count = 32;
+
+	if (!(hDC->hwnd->cinvalid = (HGDI_RGN)calloc(hDC->hwnd->count, sizeof(GDI_RGN))))
+		goto fail;
+
+	hDC->hwnd->ninvalid = 0;
+	return hDC;
+fail:
+	gdi_DeleteDC(hDC);
+	return NULL;
+}
+
+/**
+ * @brief Create a new device context compatible with the given device context.
+ * msdn{dd183489}
+ * @param hdc device context
+ * @return new compatible device context
+ */
+
+HGDI_DC gdi_CreateCompatibleDC(HGDI_DC hdc)
+{
+	HGDI_DC hDC = (HGDI_DC)calloc(1, sizeof(GDI_DC));
+
+	if (!hDC)
+		return NULL;
+
+	if (!(hDC->clip = gdi_CreateRectRgn(0, 0, 0, 0)))
+	{
+		free(hDC);
+		return NULL;
+	}
+
+	hDC->clip->null = TRUE;
+	hDC->format = hdc->format;
+	hDC->drawMode = hdc->drawMode;
+	hDC->hwnd = NULL;
+	return hDC;
+}
+
+/**
+ * @brief Select a GDI object in the current device context.
+ * msdn{dd162957}
+ *
+ * @param hdc device context
+ * @param hgdiobject new selected GDI object
+ * @return previous selected GDI object
+ */
+
+HGDIOBJECT gdi_SelectObject(HGDI_DC hdc, HGDIOBJECT hgdiobject)
+{
+	HGDIOBJECT previousSelectedObject = hdc->selectedObject;
+
+	if (hgdiobject == NULL)
+		return NULL;
+
+	if (hgdiobject->objectType == GDIOBJECT_BITMAP)
+	{
+		hdc->selectedObject = hgdiobject;
+	}
+	else if (hgdiobject->objectType == GDIOBJECT_PEN)
+	{
+		previousSelectedObject = (HGDIOBJECT)hdc->pen;
+		hdc->pen = (HGDI_PEN)hgdiobject;
+	}
+	else if (hgdiobject->objectType == GDIOBJECT_BRUSH)
+	{
+		previousSelectedObject = (HGDIOBJECT)hdc->brush;
+		hdc->brush = (HGDI_BRUSH)hgdiobject;
+	}
+	else if (hgdiobject->objectType == GDIOBJECT_REGION)
+	{
+		hdc->selectedObject = hgdiobject;
+		previousSelectedObject = (HGDIOBJECT)COMPLEXREGION;
+	}
+	else if (hgdiobject->objectType == GDIOBJECT_RECT)
+	{
+		hdc->selectedObject = hgdiobject;
+		previousSelectedObject = (HGDIOBJECT)SIMPLEREGION;
+	}
+	else
+	{
+		/* Unknown GDI Object Type */
+		return NULL;
+	}
+
+	return previousSelectedObject;
+}
+
+/**
+ * @brief Delete a GDI object.
+ * msdn{dd183539}
+ * @param hgdiobject GDI object
+ * @return nonzero if successful, 0 otherwise
+ */
+
+BOOL gdi_DeleteObject(HGDIOBJECT hgdiobject)
+{
+	if (!hgdiobject)
+		return FALSE;
+
+	if (hgdiobject->objectType == GDIOBJECT_BITMAP)
+	{
+		HGDI_BITMAP hBitmap = (HGDI_BITMAP)hgdiobject;
+
+		if (hBitmap->data && hBitmap->free)
+		{
+			hBitmap->free(hBitmap->data);
+			hBitmap->data = NULL;
+		}
+
+		free(hBitmap);
+	}
+	else if (hgdiobject->objectType == GDIOBJECT_PEN)
+	{
+		HGDI_PEN hPen = (HGDI_PEN)hgdiobject;
+		free(hPen);
+	}
+	else if (hgdiobject->objectType == GDIOBJECT_BRUSH)
+	{
+		HGDI_BRUSH hBrush = (HGDI_BRUSH)hgdiobject;
+		free(hBrush);
+	}
+	else if (hgdiobject->objectType == GDIOBJECT_REGION)
+	{
+		free(hgdiobject);
+	}
+	else if (hgdiobject->objectType == GDIOBJECT_RECT)
+	{
+		free(hgdiobject);
+	}
+	else
+	{
+		/* Unknown GDI Object Type */
+		free(hgdiobject);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+/**
+ * @brief Delete device context.
+ * msdn{dd183533}
+ * @param hdc device context
+ * @return nonzero if successful, 0 otherwise
+ */
+
+BOOL gdi_DeleteDC(HGDI_DC hdc)
+{
+	if (hdc)
+	{
+		if (hdc->hwnd)
+		{
+			free(hdc->hwnd->cinvalid);
+			free(hdc->hwnd->invalid);
+			free(hdc->hwnd);
+		}
+
+		free(hdc->clip);
+		free(hdc);
+	}
+
+	return TRUE;
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/gdi/gfx.c

@@ -0,0 +1,1967 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * GDI Graphics Pipeline
+ *
+ * Copyright 2014 Marc-Andre Moreau <[email protected]>
+ * Copyright 2016 Armin Novak <[email protected]>
+ * Copyright 2016 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 "../core/update.h"
+
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+
+#include <freerdp/api.h>
+#include <freerdp/log.h>
+#include <freerdp/gdi/gfx.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/utils/gfx.h>
+#include <math.h>
+
+#define TAG FREERDP_TAG("gdi")
+
+static BOOL is_rect_valid(const RECTANGLE_16* rect, size_t width, size_t height)
+{
+	if (!rect)
+		return FALSE;
+	if ((rect->left > rect->right) || (rect->right > width))
+		return FALSE;
+	if ((rect->top > rect->bottom) || (rect->bottom > height))
+		return FALSE;
+	return TRUE;
+}
+
+static BOOL is_within_surface(const gdiGfxSurface* surface, const RDPGFX_SURFACE_COMMAND* cmd)
+{
+	RECTANGLE_16 rect;
+	if (!surface || !cmd)
+		return FALSE;
+	rect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
+	rect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
+	rect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
+	rect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
+	if (!is_rect_valid(&rect, surface->width, surface->height))
+	{
+		WLog_ERR(TAG,
+		         "Command rect %" PRIu32 "x%" PRIu32 "-%" PRIu32 "x%" PRIu32
+		         " not within bounds of %" PRIu32 "x%" PRIu32,
+		         rect.left, rect.top, cmd->width, cmd->height, surface->width, surface->height);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static DWORD gfx_align_scanline(DWORD widthInBytes, DWORD alignment)
+{
+	const UINT32 align = alignment;
+	const UINT32 pad = align - (widthInBytes % alignment);
+	UINT32 scanline = widthInBytes;
+
+	if (align != pad)
+		scanline += pad;
+
+	return scanline;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_ResetGraphics(RdpgfxClientContext* context,
+                              const RDPGFX_RESET_GRAPHICS_PDU* resetGraphics)
+{
+	UINT rc = ERROR_INTERNAL_ERROR;
+	UINT16 count = 0;
+	UINT32 DesktopWidth = 0;
+	UINT32 DesktopHeight = 0;
+	UINT16* pSurfaceIds = NULL;
+	rdpGdi* gdi = NULL;
+	rdpUpdate* update = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(resetGraphics);
+
+	gdi = (rdpGdi*)context->custom;
+	WINPR_ASSERT(gdi);
+
+	update = gdi->context->update;
+	WINPR_ASSERT(update);
+
+	settings = gdi->context->settings;
+	WINPR_ASSERT(settings);
+	EnterCriticalSection(&context->mux);
+	DesktopWidth = resetGraphics->width;
+	DesktopHeight = resetGraphics->height;
+
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, DesktopWidth))
+		goto fail;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, DesktopHeight))
+		goto fail;
+
+	if (update)
+	{
+		WINPR_ASSERT(update->DesktopResize);
+		update->DesktopResize(gdi->context);
+	}
+
+	WINPR_ASSERT(context->GetSurfaceIds);
+	context->GetSurfaceIds(context, &pSurfaceIds, &count);
+
+	for (UINT32 index = 0; index < count; index++)
+	{
+		WINPR_ASSERT(context->GetSurfaceData);
+		gdiGfxSurface* surface =
+		    (gdiGfxSurface*)context->GetSurfaceData(context, pSurfaceIds[index]);
+
+		if (!surface)
+			continue;
+
+		memset(surface->data, 0xFF, (size_t)surface->scanline * surface->height);
+		region16_clear(&surface->invalidRegion);
+	}
+
+	free(pSurfaceIds);
+
+	if (!freerdp_settings_get_bool(gdi->context->settings, FreeRDP_DeactivateClientDecoding))
+	{
+		const UINT32 width = (UINT32)MAX(0, gdi->width);
+		const UINT32 height = (UINT32)MAX(0, gdi->height);
+
+		if (!freerdp_client_codecs_reset(
+		        context->codecs, freerdp_settings_get_codecs_flags(settings), width, height))
+		{
+			goto fail;
+		}
+		if (!freerdp_client_codecs_reset(
+		        gdi->context->codecs, freerdp_settings_get_codecs_flags(settings), width, height))
+		{
+			goto fail;
+		}
+	}
+
+	rc = CHANNEL_RC_OK;
+fail:
+	LeaveCriticalSection(&context->mux);
+	return rc;
+}
+
+static UINT gdi_OutputUpdate(rdpGdi* gdi, gdiGfxSurface* surface)
+{
+	UINT rc = ERROR_INTERNAL_ERROR;
+	UINT32 surfaceX = 0;
+	UINT32 surfaceY = 0;
+	RECTANGLE_16 surfaceRect;
+	const RECTANGLE_16* rects = NULL;
+	UINT32 nbRects = 0;
+	rdpUpdate* update = NULL;
+
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(gdi->context);
+	WINPR_ASSERT(surface);
+
+	update = gdi->context->update;
+	WINPR_ASSERT(update);
+
+	if (gdi->suppressOutput)
+		return CHANNEL_RC_OK;
+
+	surfaceX = surface->outputOriginX;
+	surfaceY = surface->outputOriginY;
+	surfaceRect.left = 0;
+	surfaceRect.top = 0;
+	surfaceRect.right = (UINT16)MIN(UINT16_MAX, surface->mappedWidth);
+	surfaceRect.bottom = (UINT16)MIN(UINT16_MAX, surface->mappedHeight);
+	region16_intersect_rect(&(surface->invalidRegion), &(surface->invalidRegion), &surfaceRect);
+	const double sx = surface->outputTargetWidth / (double)surface->mappedWidth;
+	const double sy = surface->outputTargetHeight / (double)surface->mappedHeight;
+
+	if (!(rects = region16_rects(&surface->invalidRegion, &nbRects)) || !nbRects)
+		return CHANNEL_RC_OK;
+
+	if (!update_begin_paint(update))
+		goto fail;
+
+	for (UINT32 i = 0; i < nbRects; i++)
+	{
+		const UINT32 nXSrc = rects[i].left;
+		const UINT32 nYSrc = rects[i].top;
+		const UINT32 nXDst = (UINT32)MIN(surfaceX + nXSrc * sx, gdi->width - 1);
+		const UINT32 nYDst = (UINT32)MIN(surfaceY + nYSrc * sy, gdi->height - 1);
+		const UINT32 swidth = rects[i].right - rects[i].left;
+		const UINT32 sheight = rects[i].bottom - rects[i].top;
+		const UINT32 dwidth = MIN((UINT32)(swidth * sx), (UINT32)gdi->width - nXDst);
+		const UINT32 dheight = MIN((UINT32)(sheight * sy), (UINT32)gdi->height - nYDst);
+
+		if (!freerdp_image_scale(gdi->primary_buffer, gdi->dstFormat, gdi->stride, nXDst, nYDst,
+		                         dwidth, dheight, surface->data, surface->format, surface->scanline,
+		                         nXSrc, nYSrc, swidth, sheight))
+		{
+			rc = CHANNEL_RC_NULL_DATA;
+			goto fail;
+		}
+
+		gdi_InvalidateRegion(gdi->primary->hdc, (INT32)nXDst, (INT32)nYDst, (INT32)dwidth,
+		                     (INT32)dheight);
+	}
+
+	rc = CHANNEL_RC_OK;
+fail:
+
+	if (!update_end_paint(update))
+		rc = ERROR_INTERNAL_ERROR;
+
+	region16_clear(&(surface->invalidRegion));
+	return rc;
+}
+
+static UINT gdi_WindowUpdate(RdpgfxClientContext* context, gdiGfxSurface* surface)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(surface);
+	return IFCALLRESULT(CHANNEL_RC_OK, context->UpdateWindowFromSurface, context, surface);
+}
+
+static UINT gdi_UpdateSurfaces(RdpgfxClientContext* context)
+{
+	UINT16 count = 0;
+	UINT status = ERROR_INTERNAL_ERROR;
+	UINT16* pSurfaceIds = NULL;
+	rdpGdi* gdi = NULL;
+
+	WINPR_ASSERT(context);
+
+	gdi = (rdpGdi*)context->custom;
+	WINPR_ASSERT(gdi);
+
+	EnterCriticalSection(&context->mux);
+
+	WINPR_ASSERT(context->GetSurfaceIds);
+	context->GetSurfaceIds(context, &pSurfaceIds, &count);
+	status = CHANNEL_RC_OK;
+
+	for (UINT32 index = 0; index < count; index++)
+	{
+		WINPR_ASSERT(context->GetSurfaceData);
+		gdiGfxSurface* surface =
+		    (gdiGfxSurface*)context->GetSurfaceData(context, pSurfaceIds[index]);
+
+		if (!surface)
+			continue;
+
+		/* Already handled in UpdateSurfaceArea callbacks */
+		if (context->UpdateSurfaceArea)
+		{
+			if (surface->handleInUpdateSurfaceArea)
+				continue;
+		}
+
+		if (surface->outputMapped)
+			status = gdi_OutputUpdate(gdi, surface);
+		else if (surface->windowMapped)
+			status = gdi_WindowUpdate(context, surface);
+
+		if (status != CHANNEL_RC_OK)
+			break;
+	}
+
+	free(pSurfaceIds);
+	LeaveCriticalSection(&context->mux);
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_StartFrame(RdpgfxClientContext* context, const RDPGFX_START_FRAME_PDU* startFrame)
+{
+	rdpGdi* gdi = NULL;
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(startFrame);
+
+	gdi = (rdpGdi*)context->custom;
+	WINPR_ASSERT(gdi);
+	gdi->inGfxFrame = TRUE;
+	gdi->frameId = startFrame->frameId;
+	return CHANNEL_RC_OK;
+}
+
+static UINT gdi_call_update_surfaces(RdpgfxClientContext* context)
+{
+	WINPR_ASSERT(context);
+	return IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaces, context);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_EndFrame(RdpgfxClientContext* context, const RDPGFX_END_FRAME_PDU* endFrame)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(endFrame);
+
+	rdpGdi* gdi = (rdpGdi*)context->custom;
+	WINPR_ASSERT(gdi);
+	const UINT status = gdi_call_update_surfaces(context);
+	gdi->inGfxFrame = FALSE;
+	return status;
+}
+
+static UINT gdi_interFrameUpdate(rdpGdi* gdi, RdpgfxClientContext* context)
+{
+	WINPR_ASSERT(gdi);
+	UINT status = CHANNEL_RC_OK;
+	if (!gdi->inGfxFrame)
+		status = gdi_call_update_surfaces(context);
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceCommand_Uncompressed(rdpGdi* gdi, RdpgfxClientContext* context,
+                                            const RDPGFX_SURFACE_COMMAND* cmd)
+{
+	UINT status = CHANNEL_RC_OK;
+	gdiGfxSurface* surface = NULL;
+	RECTANGLE_16 invalidRect;
+	DWORD bpp = 0;
+	size_t size = 0;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(cmd);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface =
+	    (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
+
+	if (!surface)
+	{
+		WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
+		return ERROR_NOT_FOUND;
+	}
+
+	if (!is_within_surface(surface, cmd))
+		return ERROR_INVALID_DATA;
+
+	bpp = FreeRDPGetBytesPerPixel(cmd->format);
+	size = 1ull * bpp * cmd->width * cmd->height;
+	if (cmd->length < size)
+	{
+		WLog_ERR(TAG, "Not enough data, got %" PRIu32 ", expected %" PRIuz, cmd->length, size);
+		return ERROR_INVALID_DATA;
+	}
+
+	if (!freerdp_image_copy_no_overlap(surface->data, surface->format, surface->scanline, cmd->left,
+	                                   cmd->top, cmd->width, cmd->height, cmd->data, cmd->format, 0,
+	                                   0, 0, NULL, FREERDP_FLIP_NONE))
+		return ERROR_INTERNAL_ERROR;
+
+	invalidRect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
+	invalidRect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
+	invalidRect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
+	invalidRect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
+	region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
+	status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId, 1,
+	                      &invalidRect);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	status = gdi_interFrameUpdate(gdi, context);
+
+fail:
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceCommand_RemoteFX(rdpGdi* gdi, RdpgfxClientContext* context,
+                                        const RDPGFX_SURFACE_COMMAND* cmd)
+{
+	UINT status = ERROR_INTERNAL_ERROR;
+	gdiGfxSurface* surface = NULL;
+	REGION16 invalidRegion;
+	const RECTANGLE_16* rects = NULL;
+	UINT32 nrRects = 0;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(cmd);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface =
+	    (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
+
+	if (!surface)
+	{
+		WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
+		return ERROR_NOT_FOUND;
+	}
+
+	WINPR_ASSERT(surface->codecs);
+	rfx_context_set_pixel_format(surface->codecs->rfx, cmd->format);
+	region16_init(&invalidRegion);
+
+	if (!rfx_process_message(surface->codecs->rfx, cmd->data, cmd->length, cmd->left, cmd->top,
+	                         surface->data, surface->format, surface->scanline, surface->height,
+	                         &invalidRegion))
+	{
+		WLog_ERR(TAG, "Failed to process RemoteFX message");
+		goto fail;
+	}
+
+	rects = region16_rects(&invalidRegion, &nrRects);
+	status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
+	                      nrRects, rects);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	for (UINT32 x = 0; x < nrRects; x++)
+		region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &rects[x]);
+
+	status = gdi_interFrameUpdate(gdi, context);
+
+fail:
+	region16_uninit(&invalidRegion);
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceCommand_ClearCodec(rdpGdi* gdi, RdpgfxClientContext* context,
+                                          const RDPGFX_SURFACE_COMMAND* cmd)
+{
+	INT32 rc = 0;
+	UINT status = CHANNEL_RC_OK;
+	gdiGfxSurface* surface = NULL;
+	RECTANGLE_16 invalidRect;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(cmd);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface =
+	    (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
+
+	if (!surface)
+	{
+		WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
+		return ERROR_NOT_FOUND;
+	}
+
+	WINPR_ASSERT(surface->codecs);
+	rc = clear_decompress(surface->codecs->clear, cmd->data, cmd->length, cmd->width, cmd->height,
+	                      surface->data, surface->format, surface->scanline, cmd->left, cmd->top,
+	                      surface->width, surface->height, &gdi->palette);
+
+	if (rc < 0)
+	{
+		WLog_ERR(TAG, "clear_decompress failure: %" PRId32 "", rc);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	invalidRect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
+	invalidRect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
+	invalidRect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
+	invalidRect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
+	region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
+	status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId, 1,
+	                      &invalidRect);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	status = gdi_interFrameUpdate(gdi, context);
+
+fail:
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceCommand_Planar(rdpGdi* gdi, RdpgfxClientContext* context,
+                                      const RDPGFX_SURFACE_COMMAND* cmd)
+{
+	UINT status = CHANNEL_RC_OK;
+	BYTE* DstData = NULL;
+	gdiGfxSurface* surface = NULL;
+	RECTANGLE_16 invalidRect;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(cmd);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface =
+	    (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
+
+	if (!surface)
+	{
+		WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
+		return ERROR_NOT_FOUND;
+	}
+
+	DstData = surface->data;
+
+	if (!is_within_surface(surface, cmd))
+		return ERROR_INVALID_DATA;
+
+	if (!planar_decompress(surface->codecs->planar, cmd->data, cmd->length, cmd->width, cmd->height,
+	                       DstData, surface->format, surface->scanline, cmd->left, cmd->top,
+	                       cmd->width, cmd->height, FALSE))
+		return ERROR_INTERNAL_ERROR;
+
+	invalidRect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
+	invalidRect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
+	invalidRect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
+	invalidRect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
+	region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
+	status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId, 1,
+	                      &invalidRect);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	status = gdi_interFrameUpdate(gdi, context);
+
+fail:
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceCommand_AVC420(rdpGdi* gdi, RdpgfxClientContext* context,
+                                      const RDPGFX_SURFACE_COMMAND* cmd)
+{
+#ifdef WITH_GFX_H264
+	INT32 rc = 0;
+	UINT status = CHANNEL_RC_OK;
+	gdiGfxSurface* surface = NULL;
+	RDPGFX_H264_METABLOCK* meta = NULL;
+	RDPGFX_AVC420_BITMAP_STREAM* bs = NULL;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(cmd);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface =
+	    (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
+
+	if (!surface)
+	{
+		WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
+		return ERROR_NOT_FOUND;
+	}
+
+	if (!surface->h264)
+	{
+		surface->h264 = h264_context_new(FALSE);
+
+		if (!surface->h264)
+		{
+			WLog_ERR(TAG, "unable to create h264 context");
+			return ERROR_NOT_ENOUGH_MEMORY;
+		}
+
+		if (!h264_context_reset(surface->h264, surface->width, surface->height))
+			return ERROR_INTERNAL_ERROR;
+	}
+
+	if (!surface->h264)
+		return ERROR_NOT_SUPPORTED;
+
+	bs = (RDPGFX_AVC420_BITMAP_STREAM*)cmd->extra;
+
+	if (!bs)
+		return ERROR_INTERNAL_ERROR;
+
+	meta = &(bs->meta);
+	rc = avc420_decompress(surface->h264, bs->data, bs->length, surface->data, surface->format,
+	                       surface->scanline, surface->width, surface->height, meta->regionRects,
+	                       meta->numRegionRects);
+
+	if (rc < 0)
+	{
+		WLog_WARN(TAG, "avc420_decompress failure: %" PRId32 ", ignoring update.", rc);
+		return CHANNEL_RC_OK;
+	}
+
+	for (UINT32 i = 0; i < meta->numRegionRects; i++)
+	{
+		region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
+		                    &(meta->regionRects[i]));
+	}
+
+	status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
+	                      meta->numRegionRects, meta->regionRects);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	status = gdi_interFrameUpdate(gdi, context);
+
+fail:
+	return status;
+#else
+	return ERROR_NOT_SUPPORTED;
+#endif
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceCommand_AVC444(rdpGdi* gdi, RdpgfxClientContext* context,
+                                      const RDPGFX_SURFACE_COMMAND* cmd)
+{
+#ifdef WITH_GFX_H264
+	INT32 rc = 0;
+	UINT status = CHANNEL_RC_OK;
+	gdiGfxSurface* surface = NULL;
+	RDPGFX_AVC444_BITMAP_STREAM* bs = NULL;
+	RDPGFX_AVC420_BITMAP_STREAM* avc1 = NULL;
+	RDPGFX_H264_METABLOCK* meta1 = NULL;
+	RDPGFX_AVC420_BITMAP_STREAM* avc2 = NULL;
+	RDPGFX_H264_METABLOCK* meta2 = NULL;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(cmd);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface =
+	    (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
+
+	if (!surface)
+	{
+		WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
+		return ERROR_NOT_FOUND;
+	}
+
+	if (!surface->h264)
+	{
+		surface->h264 = h264_context_new(FALSE);
+
+		if (!surface->h264)
+		{
+			WLog_ERR(TAG, "unable to create h264 context");
+			return ERROR_NOT_ENOUGH_MEMORY;
+		}
+
+		if (!h264_context_reset(surface->h264, surface->width, surface->height))
+			return ERROR_INTERNAL_ERROR;
+	}
+
+	if (!surface->h264)
+		return ERROR_NOT_SUPPORTED;
+
+	bs = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;
+
+	if (!bs)
+		return ERROR_INTERNAL_ERROR;
+
+	avc1 = &bs->bitstream[0];
+	avc2 = &bs->bitstream[1];
+	meta1 = &avc1->meta;
+	meta2 = &avc2->meta;
+	rc = avc444_decompress(surface->h264, bs->LC, meta1->regionRects, meta1->numRegionRects,
+	                       avc1->data, avc1->length, meta2->regionRects, meta2->numRegionRects,
+	                       avc2->data, avc2->length, surface->data, surface->format,
+	                       surface->scanline, surface->width, surface->height, cmd->codecId);
+
+	if (rc < 0)
+	{
+		WLog_WARN(TAG, "avc444_decompress failure: %" PRIu32 ", ignoring update.", status);
+		return CHANNEL_RC_OK;
+	}
+
+	for (UINT32 i = 0; i < meta1->numRegionRects; i++)
+	{
+		region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
+		                    &(meta1->regionRects[i]));
+	}
+
+	status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
+	                      meta1->numRegionRects, meta1->regionRects);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	for (UINT32 i = 0; i < meta2->numRegionRects; i++)
+	{
+		region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
+		                    &(meta2->regionRects[i]));
+	}
+
+	status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
+	                      meta2->numRegionRects, meta2->regionRects);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	status = gdi_interFrameUpdate(gdi, context);
+
+fail:
+	return status;
+#else
+	return ERROR_NOT_SUPPORTED;
+#endif
+}
+
+static BOOL gdi_apply_alpha(BYTE* data, UINT32 format, UINT32 stride, RECTANGLE_16* rect,
+                            UINT32 startOffsetX, UINT32 count, BYTE a)
+{
+	UINT32 written = 0;
+	BOOL first = TRUE;
+	const UINT32 bpp = FreeRDPGetBytesPerPixel(format);
+	WINPR_ASSERT(rect);
+
+	for (size_t y = rect->top; y < rect->bottom; y++)
+	{
+		BYTE* line = &data[y * stride];
+
+		for (size_t x = first ? rect->left + startOffsetX : rect->left; x < rect->right; x++)
+		{
+			BYTE r = 0;
+			BYTE g = 0;
+			BYTE b = 0;
+
+			if (written == count)
+				return TRUE;
+
+			BYTE* src = &line[x * bpp];
+			UINT32 color = FreeRDPReadColor(src, format);
+			FreeRDPSplitColor(color, format, &r, &g, &b, NULL, NULL);
+			color = FreeRDPGetColor(format, r, g, b, a);
+			FreeRDPWriteColor(src, format, color);
+			written++;
+		}
+
+		first = FALSE;
+	}
+
+	return TRUE;
+}
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceCommand_Alpha(rdpGdi* gdi, RdpgfxClientContext* context,
+                                     const RDPGFX_SURFACE_COMMAND* cmd)
+{
+	UINT status = CHANNEL_RC_OK;
+	UINT16 alphaSig = 0;
+	UINT16 compressed = 0;
+	gdiGfxSurface* surface = NULL;
+	RECTANGLE_16 invalidRect;
+	wStream buffer;
+	wStream* s = NULL;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(cmd);
+
+	s = Stream_StaticConstInit(&buffer, cmd->data, cmd->length);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return ERROR_INVALID_DATA;
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface =
+	    (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
+
+	if (!surface)
+	{
+		WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
+		return ERROR_NOT_FOUND;
+	}
+
+	if (!is_within_surface(surface, cmd))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT16(s, alphaSig);
+	Stream_Read_UINT16(s, compressed);
+
+	if (alphaSig != 0x414C)
+		return ERROR_INVALID_DATA;
+
+	if (compressed == 0)
+	{
+		if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, cmd->height, cmd->width))
+			return ERROR_INVALID_DATA;
+
+		for (size_t y = cmd->top; y < cmd->top + cmd->height; y++)
+		{
+			BYTE* line = &surface->data[y * surface->scanline];
+
+			for (size_t x = cmd->left; x < cmd->left + cmd->width; x++)
+			{
+				UINT32 color = 0;
+				BYTE r = 0;
+				BYTE g = 0;
+				BYTE b = 0;
+				BYTE a = 0;
+				BYTE* src = &line[x * FreeRDPGetBytesPerPixel(surface->format)];
+				Stream_Read_UINT8(s, a);
+				color = FreeRDPReadColor(src, surface->format);
+				FreeRDPSplitColor(color, surface->format, &r, &g, &b, NULL, NULL);
+				color = FreeRDPGetColor(surface->format, r, g, b, a);
+				FreeRDPWriteColor(src, surface->format, color);
+			}
+		}
+	}
+	else
+	{
+		UINT32 startOffsetX = 0;
+		RECTANGLE_16 rect = { 0 };
+		rect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
+		rect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
+		rect.right = (UINT16)MIN(UINT16_MAX, cmd->left + cmd->width);
+		rect.bottom = (UINT16)MIN(UINT16_MAX, cmd->top + cmd->height);
+
+		while (rect.top < rect.bottom)
+		{
+			UINT32 count = 0;
+			BYTE a = 0;
+
+			if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
+				return ERROR_INVALID_DATA;
+
+			Stream_Read_UINT8(s, a);
+			Stream_Read_UINT8(s, count);
+
+			if (count >= 0xFF)
+			{
+				if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
+					return ERROR_INVALID_DATA;
+
+				Stream_Read_UINT16(s, count);
+
+				if (count >= 0xFFFF)
+				{
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+						return ERROR_INVALID_DATA;
+
+					Stream_Read_UINT32(s, count);
+				}
+			}
+
+			if (!gdi_apply_alpha(surface->data, surface->format, surface->scanline, &rect,
+			                     startOffsetX, count, a))
+				return ERROR_INTERNAL_ERROR;
+
+			startOffsetX += count;
+
+			while (startOffsetX >= cmd->width)
+			{
+				startOffsetX -= cmd->width;
+				rect.top++;
+			}
+		}
+	}
+
+	invalidRect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
+	invalidRect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
+	invalidRect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
+	invalidRect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
+	region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
+	status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId, 1,
+	                      &invalidRect);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	status = gdi_interFrameUpdate(gdi, context);
+
+fail:
+	return status;
+}
+
+#if defined(WITH_GFX_FRAME_DUMP)
+static void dump_cmd(const RDPGFX_SURFACE_COMMAND* cmd, UINT32 frameId)
+{
+	static UINT64 xxx = 0;
+	const char* path = "/tmp/dump/";
+	WINPR_ASSERT(cmd);
+	char fname[1024] = { 0 };
+
+	snprintf(fname, sizeof(fname), "%s/%08" PRIx64 ".raw", path, xxx++);
+	FILE* fp = fopen(fname, "w");
+	if (!fp)
+		return;
+	(void)fprintf(fp, "frameid: %" PRIu32 "\n", frameId);
+	(void)fprintf(fp, "surfaceId: %" PRIu32 "\n", cmd->surfaceId);
+	(void)fprintf(fp, "codecId: %" PRIu32 "\n", cmd->codecId);
+	(void)fprintf(fp, "contextId: %" PRIu32 "\n", cmd->contextId);
+	(void)fprintf(fp, "format: %" PRIu32 "\n", cmd->format);
+	(void)fprintf(fp, "left: %" PRIu32 "\n", cmd->left);
+	(void)fprintf(fp, "top: %" PRIu32 "\n", cmd->top);
+	(void)fprintf(fp, "right: %" PRIu32 "\n", cmd->right);
+	(void)fprintf(fp, "bottom: %" PRIu32 "\n", cmd->bottom);
+	(void)fprintf(fp, "width: %" PRIu32 "\n", cmd->width);
+	(void)fprintf(fp, "height: %" PRIu32 "\n", cmd->height);
+	(void)fprintf(fp, "length: %" PRIu32 "\n", cmd->length);
+
+	char* bdata = crypto_base64_encode_ex(cmd->data, cmd->length, FALSE);
+	(void)fprintf(fp, "data: %s\n", bdata);
+	free(bdata);
+	fclose(fp);
+}
+#endif
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceCommand_Progressive(rdpGdi* gdi, RdpgfxClientContext* context,
+                                           const RDPGFX_SURFACE_COMMAND* cmd)
+{
+	INT32 rc = 0;
+	UINT status = CHANNEL_RC_OK;
+	gdiGfxSurface* surface = NULL;
+	REGION16 invalidRegion;
+	const RECTANGLE_16* rects = NULL;
+	UINT32 nrRects = 0;
+	/**
+	 * Note: Since this comes via a Wire-To-Surface-2 PDU the
+	 * cmd's top/left/right/bottom/width/height members are always zero!
+	 * The update region is determined during decompression.
+	 */
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(cmd);
+	const UINT16 surfaceId = (UINT16)MIN(UINT16_MAX, cmd->surfaceId);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceId);
+
+	if (!surface)
+	{
+		WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
+		return ERROR_NOT_FOUND;
+	}
+
+	if (!is_within_surface(surface, cmd))
+		return ERROR_INVALID_DATA;
+
+	WINPR_ASSERT(surface->codecs);
+	rc = progressive_create_surface_context(surface->codecs->progressive, surfaceId, surface->width,
+	                                        surface->height);
+
+	if (rc < 0)
+	{
+		WLog_ERR(TAG, "progressive_create_surface_context failure: %" PRId32 "", rc);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	region16_init(&invalidRegion);
+
+	rc = progressive_decompress(surface->codecs->progressive, cmd->data, cmd->length, surface->data,
+	                            surface->format, surface->scanline, cmd->left, cmd->top,
+	                            &invalidRegion, surfaceId, gdi->frameId);
+
+	if (rc < 0)
+	{
+		WLog_ERR(TAG, "progressive_decompress failure: %" PRId32 "", rc);
+		region16_uninit(&invalidRegion);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	rects = region16_rects(&invalidRegion, &nrRects);
+	status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
+	                      nrRects, rects);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	for (UINT32 x = 0; x < nrRects; x++)
+		region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &rects[x]);
+
+	region16_uninit(&invalidRegion);
+
+	status = gdi_interFrameUpdate(gdi, context);
+
+fail:
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceCommand(RdpgfxClientContext* context, const RDPGFX_SURFACE_COMMAND* cmd)
+{
+	UINT status = CHANNEL_RC_OK;
+	rdpGdi* gdi = NULL;
+
+	if (!context || !cmd)
+		return ERROR_INVALID_PARAMETER;
+
+	gdi = (rdpGdi*)context->custom;
+
+	EnterCriticalSection(&context->mux);
+	const UINT16 codecId = WINPR_ASSERTING_INT_CAST(UINT16, cmd->codecId);
+	WLog_Print(gdi->log, WLOG_TRACE,
+	           "surfaceId=%" PRIu32 ", codec=%s [%" PRIu32 "], contextId=%" PRIu32 ", format=%s, "
+	           "left=%" PRIu32 ", top=%" PRIu32 ", right=%" PRIu32 ", bottom=%" PRIu32
+	           ", width=%" PRIu32 ", height=%" PRIu32 " "
+	           "length=%" PRIu32 ", data=%p, extra=%p",
+	           cmd->surfaceId, rdpgfx_get_codec_id_string(codecId), cmd->codecId, cmd->contextId,
+	           FreeRDPGetColorFormatName(cmd->format), cmd->left, cmd->top, cmd->right, cmd->bottom,
+	           cmd->width, cmd->height, cmd->length, (void*)cmd->data, (void*)cmd->extra);
+#if defined(WITH_GFX_FRAME_DUMP)
+	dump_cmd(cmd, gdi->frameId);
+#endif
+
+	switch (codecId)
+	{
+		case RDPGFX_CODECID_UNCOMPRESSED:
+			status = gdi_SurfaceCommand_Uncompressed(gdi, context, cmd);
+			break;
+
+		case RDPGFX_CODECID_CAVIDEO:
+			status = gdi_SurfaceCommand_RemoteFX(gdi, context, cmd);
+			break;
+
+		case RDPGFX_CODECID_CLEARCODEC:
+			status = gdi_SurfaceCommand_ClearCodec(gdi, context, cmd);
+			break;
+
+		case RDPGFX_CODECID_PLANAR:
+			status = gdi_SurfaceCommand_Planar(gdi, context, cmd);
+			break;
+
+		case RDPGFX_CODECID_AVC420:
+			status = gdi_SurfaceCommand_AVC420(gdi, context, cmd);
+			break;
+
+		case RDPGFX_CODECID_AVC444v2:
+		case RDPGFX_CODECID_AVC444:
+			status = gdi_SurfaceCommand_AVC444(gdi, context, cmd);
+			break;
+
+		case RDPGFX_CODECID_ALPHA:
+			status = gdi_SurfaceCommand_Alpha(gdi, context, cmd);
+			break;
+
+		case RDPGFX_CODECID_CAPROGRESSIVE:
+			status = gdi_SurfaceCommand_Progressive(gdi, context, cmd);
+			break;
+
+		case RDPGFX_CODECID_CAPROGRESSIVE_V2:
+			WLog_WARN(TAG, "SurfaceCommand %s [0x%08" PRIX16 "] not implemented",
+			          rdpgfx_get_codec_id_string(codecId), codecId);
+			break;
+
+		default:
+			WLog_WARN(TAG, "Invalid SurfaceCommand %s [0x%08" PRIX16 "]",
+			          rdpgfx_get_codec_id_string(codecId), codecId);
+			break;
+	}
+
+	LeaveCriticalSection(&context->mux);
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+gdi_DeleteEncodingContext(RdpgfxClientContext* context,
+                          const RDPGFX_DELETE_ENCODING_CONTEXT_PDU* deleteEncodingContext)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(deleteEncodingContext);
+	WINPR_UNUSED(context);
+	WINPR_UNUSED(deleteEncodingContext);
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_CreateSurface(RdpgfxClientContext* context,
+                              const RDPGFX_CREATE_SURFACE_PDU* createSurface)
+{
+	UINT rc = ERROR_INTERNAL_ERROR;
+	gdiGfxSurface* surface = NULL;
+	rdpGdi* gdi = NULL;
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(createSurface);
+	gdi = (rdpGdi*)context->custom;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(gdi->context);
+	EnterCriticalSection(&context->mux);
+	surface = (gdiGfxSurface*)calloc(1, sizeof(gdiGfxSurface));
+
+	if (!surface)
+		goto fail;
+
+	if (!freerdp_settings_get_bool(gdi->context->settings, FreeRDP_DeactivateClientDecoding))
+	{
+		WINPR_ASSERT(context->codecs);
+		surface->codecs = context->codecs;
+
+		if (!surface->codecs)
+		{
+			free(surface);
+			goto fail;
+		}
+	}
+
+	surface->surfaceId = createSurface->surfaceId;
+	surface->width = gfx_align_scanline(createSurface->width, 16);
+	surface->height = gfx_align_scanline(createSurface->height, 16);
+	surface->mappedWidth = createSurface->width;
+	surface->mappedHeight = createSurface->height;
+	surface->outputTargetWidth = createSurface->width;
+	surface->outputTargetHeight = createSurface->height;
+
+	switch (createSurface->pixelFormat)
+	{
+		case GFX_PIXEL_FORMAT_ARGB_8888:
+			surface->format = PIXEL_FORMAT_BGRA32;
+			break;
+
+		case GFX_PIXEL_FORMAT_XRGB_8888:
+			surface->format = PIXEL_FORMAT_BGRX32;
+			break;
+
+		default:
+			free(surface);
+			goto fail;
+	}
+
+	surface->scanline = gfx_align_scanline(surface->width * 4UL, 16);
+	surface->data = (BYTE*)winpr_aligned_malloc(1ull * surface->scanline * surface->height, 16);
+
+	if (!surface->data)
+	{
+		free(surface);
+		goto fail;
+	}
+
+	memset(surface->data, 0xFF, (size_t)surface->scanline * surface->height);
+	region16_init(&surface->invalidRegion);
+
+	WINPR_ASSERT(context->SetSurfaceData);
+	rc = context->SetSurfaceData(context, surface->surfaceId, (void*)surface);
+fail:
+	LeaveCriticalSection(&context->mux);
+	return rc;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_DeleteSurface(RdpgfxClientContext* context,
+                              const RDPGFX_DELETE_SURFACE_PDU* deleteSurface)
+{
+	UINT rc = CHANNEL_RC_OK;
+	UINT res = ERROR_INTERNAL_ERROR;
+	rdpCodecs* codecs = NULL;
+	gdiGfxSurface* surface = NULL;
+	EnterCriticalSection(&context->mux);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface = (gdiGfxSurface*)context->GetSurfaceData(context, deleteSurface->surfaceId);
+
+	if (surface)
+	{
+		if (surface->windowMapped)
+			rc = IFCALLRESULT(CHANNEL_RC_OK, context->UnmapWindowForSurface, context,
+			                  surface->windowId);
+
+#ifdef WITH_GFX_H264
+		h264_context_free(surface->h264);
+#endif
+		region16_uninit(&surface->invalidRegion);
+		codecs = surface->codecs;
+		winpr_aligned_free(surface->data);
+		free(surface);
+	}
+
+	WINPR_ASSERT(context->SetSurfaceData);
+	res = context->SetSurfaceData(context, deleteSurface->surfaceId, NULL);
+	if (res)
+		rc = res;
+
+	if (codecs && codecs->progressive)
+		progressive_delete_surface_context(codecs->progressive, deleteSurface->surfaceId);
+
+	LeaveCriticalSection(&context->mux);
+	return rc;
+}
+
+static BOOL intersect_rect(const RECTANGLE_16* rect, const gdiGfxSurface* surface,
+                           RECTANGLE_16* prect)
+{
+	WINPR_ASSERT(rect);
+	WINPR_ASSERT(surface);
+	WINPR_ASSERT(prect);
+
+	if (rect->left > rect->right)
+		return FALSE;
+	if (rect->left > surface->width)
+		return FALSE;
+	if (rect->top > rect->bottom)
+		return FALSE;
+	if (rect->top > surface->height)
+		return FALSE;
+	prect->left = rect->left;
+	prect->top = rect->top;
+
+	prect->right = MIN(rect->right, WINPR_ASSERTING_INT_CAST(UINT16, surface->width));
+	prect->bottom = MIN(rect->bottom, WINPR_ASSERTING_INT_CAST(UINT16, surface->height));
+	return TRUE;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SolidFill(RdpgfxClientContext* context, const RDPGFX_SOLID_FILL_PDU* solidFill)
+{
+	UINT status = ERROR_INTERNAL_ERROR;
+	BYTE a = 0xff;
+	RECTANGLE_16 invalidRect = { 0 };
+	rdpGdi* gdi = (rdpGdi*)context->custom;
+
+	EnterCriticalSection(&context->mux);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	gdiGfxSurface* surface = (gdiGfxSurface*)context->GetSurfaceData(context, solidFill->surfaceId);
+
+	if (!surface)
+		goto fail;
+
+	const BYTE b = solidFill->fillPixel.B;
+	const BYTE g = solidFill->fillPixel.G;
+	const BYTE r = solidFill->fillPixel.R;
+
+#if 0
+	/* [MS-RDPEGFX] 3.3.5.4 Processing an RDPGFX_SOLIDFILL_PDU message
+	 * https://learn.microsoft.com/en-us/windows/win32/gdi/binary-raster-operations
+	 *
+	 * this sounds like the alpha value is always ignored.
+	 */
+	if (FreeRDPColorHasAlpha(surface->format))
+		a = solidFill->fillPixel.XA;
+#endif
+
+	const UINT32 color = FreeRDPGetColor(surface->format, r, g, b, a);
+
+	for (UINT16 index = 0; index < solidFill->fillRectCount; index++)
+	{
+		const RECTANGLE_16* rect = &(solidFill->fillRects[index]);
+
+		if (!intersect_rect(rect, surface, &invalidRect))
+			goto fail;
+
+		const UINT32 nWidth = invalidRect.right - invalidRect.left;
+		const UINT32 nHeight = invalidRect.bottom - invalidRect.top;
+
+		if (!freerdp_image_fill(surface->data, surface->format, surface->scanline, invalidRect.left,
+		                        invalidRect.top, nWidth, nHeight, color))
+			goto fail;
+
+		region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
+	}
+
+	status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
+	                      solidFill->fillRectCount, solidFill->fillRects);
+
+	if (status != CHANNEL_RC_OK)
+		goto fail;
+
+	LeaveCriticalSection(&context->mux);
+
+	return gdi_interFrameUpdate(gdi, context);
+fail:
+	LeaveCriticalSection(&context->mux);
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceToSurface(RdpgfxClientContext* context,
+                                 const RDPGFX_SURFACE_TO_SURFACE_PDU* surfaceToSurface)
+{
+	UINT status = ERROR_INTERNAL_ERROR;
+	BOOL sameSurface = 0;
+	UINT32 nWidth = 0;
+	UINT32 nHeight = 0;
+	const RECTANGLE_16* rectSrc = NULL;
+	RECTANGLE_16 invalidRect;
+	gdiGfxSurface* surfaceSrc = NULL;
+	gdiGfxSurface* surfaceDst = NULL;
+	rdpGdi* gdi = (rdpGdi*)context->custom;
+	EnterCriticalSection(&context->mux);
+	rectSrc = &(surfaceToSurface->rectSrc);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surfaceSrc = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToSurface->surfaceIdSrc);
+	sameSurface =
+	    (surfaceToSurface->surfaceIdSrc == surfaceToSurface->surfaceIdDest) ? TRUE : FALSE;
+
+	if (!sameSurface)
+		surfaceDst =
+		    (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToSurface->surfaceIdDest);
+	else
+		surfaceDst = surfaceSrc;
+
+	if (!surfaceSrc || !surfaceDst)
+		goto fail;
+
+	if (!is_rect_valid(rectSrc, surfaceSrc->width, surfaceSrc->height))
+		goto fail;
+
+	nWidth = rectSrc->right - rectSrc->left;
+	nHeight = rectSrc->bottom - rectSrc->top;
+
+	for (UINT16 index = 0; index < surfaceToSurface->destPtsCount; index++)
+	{
+		const RDPGFX_POINT16* destPt = &surfaceToSurface->destPts[index];
+		const RECTANGLE_16 rect = { destPt->x, destPt->y,
+			                        (UINT16)MIN(UINT16_MAX, destPt->x + nWidth),
+			                        (UINT16)MIN(UINT16_MAX, destPt->y + nHeight) };
+		if (!is_rect_valid(&rect, surfaceDst->width, surfaceDst->height))
+			goto fail;
+
+		if (!freerdp_image_copy(surfaceDst->data, surfaceDst->format, surfaceDst->scanline,
+		                        destPt->x, destPt->y, nWidth, nHeight, surfaceSrc->data,
+		                        surfaceSrc->format, surfaceSrc->scanline, rectSrc->left,
+		                        rectSrc->top, NULL, FREERDP_FLIP_NONE))
+			goto fail;
+
+		invalidRect = rect;
+		region16_union_rect(&surfaceDst->invalidRegion, &surfaceDst->invalidRegion, &invalidRect);
+		status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context,
+		                      surfaceDst->surfaceId, 1, &invalidRect);
+
+		if (status != CHANNEL_RC_OK)
+			goto fail;
+	}
+
+	LeaveCriticalSection(&context->mux);
+
+	return gdi_interFrameUpdate(gdi, context);
+fail:
+	LeaveCriticalSection(&context->mux);
+	return status;
+}
+
+static void gdi_GfxCacheEntryFree(gdiGfxCacheEntry* entry)
+{
+	if (!entry)
+		return;
+	free(entry->data);
+	free(entry);
+}
+
+static gdiGfxCacheEntry* gdi_GfxCacheEntryNew(UINT64 cacheKey, UINT32 width, UINT32 height,
+                                              UINT32 format)
+{
+	gdiGfxCacheEntry* cacheEntry = (gdiGfxCacheEntry*)calloc(1, sizeof(gdiGfxCacheEntry));
+	if (!cacheEntry)
+		goto fail;
+
+	cacheEntry->cacheKey = cacheKey;
+	cacheEntry->width = width;
+	cacheEntry->height = height;
+	cacheEntry->format = format;
+	cacheEntry->scanline = gfx_align_scanline(cacheEntry->width * 4, 16);
+
+	if ((cacheEntry->width > 0) && (cacheEntry->height > 0))
+	{
+		cacheEntry->data = (BYTE*)calloc(cacheEntry->height, cacheEntry->scanline);
+
+		if (!cacheEntry->data)
+			goto fail;
+	}
+	return cacheEntry;
+fail:
+	gdi_GfxCacheEntryFree(cacheEntry);
+	return NULL;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_SurfaceToCache(RdpgfxClientContext* context,
+                               const RDPGFX_SURFACE_TO_CACHE_PDU* surfaceToCache)
+{
+	const RECTANGLE_16* rect = NULL;
+	gdiGfxSurface* surface = NULL;
+	gdiGfxCacheEntry* cacheEntry = NULL;
+	UINT rc = ERROR_INTERNAL_ERROR;
+	EnterCriticalSection(&context->mux);
+	rect = &(surfaceToCache->rectSrc);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToCache->surfaceId);
+
+	if (!surface)
+		goto fail;
+
+	if (!is_rect_valid(rect, surface->width, surface->height))
+		goto fail;
+
+	cacheEntry = gdi_GfxCacheEntryNew(surfaceToCache->cacheKey, (UINT32)(rect->right - rect->left),
+	                                  (UINT32)(rect->bottom - rect->top), surface->format);
+
+	if (!cacheEntry)
+		goto fail;
+
+	if (!cacheEntry->data)
+		goto fail;
+
+	if (!freerdp_image_copy_no_overlap(cacheEntry->data, cacheEntry->format, cacheEntry->scanline,
+	                                   0, 0, cacheEntry->width, cacheEntry->height, surface->data,
+	                                   surface->format, surface->scanline, rect->left, rect->top,
+	                                   NULL, FREERDP_FLIP_NONE))
+		goto fail;
+
+	RDPGFX_EVICT_CACHE_ENTRY_PDU evict = { surfaceToCache->cacheSlot };
+	WINPR_ASSERT(context->EvictCacheEntry);
+	context->EvictCacheEntry(context, &evict);
+
+	WINPR_ASSERT(context->SetCacheSlotData);
+	rc = context->SetCacheSlotData(context, surfaceToCache->cacheSlot, (void*)cacheEntry);
+fail:
+	if (rc != CHANNEL_RC_OK)
+		gdi_GfxCacheEntryFree(cacheEntry);
+	LeaveCriticalSection(&context->mux);
+	return rc;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_CacheToSurface(RdpgfxClientContext* context,
+                               const RDPGFX_CACHE_TO_SURFACE_PDU* cacheToSurface)
+{
+	UINT status = ERROR_INTERNAL_ERROR;
+	gdiGfxSurface* surface = NULL;
+	gdiGfxCacheEntry* cacheEntry = NULL;
+	RECTANGLE_16 invalidRect;
+	rdpGdi* gdi = (rdpGdi*)context->custom;
+
+	EnterCriticalSection(&context->mux);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface = (gdiGfxSurface*)context->GetSurfaceData(context, cacheToSurface->surfaceId);
+
+	WINPR_ASSERT(context->GetCacheSlotData);
+	cacheEntry = (gdiGfxCacheEntry*)context->GetCacheSlotData(context, cacheToSurface->cacheSlot);
+
+	if (!surface || !cacheEntry)
+		goto fail;
+
+	for (UINT16 index = 0; index < cacheToSurface->destPtsCount; index++)
+	{
+		const RDPGFX_POINT16* destPt = &cacheToSurface->destPts[index];
+		const RECTANGLE_16 rect = { destPt->x, destPt->y,
+			                        (UINT16)MIN(UINT16_MAX, destPt->x + cacheEntry->width),
+			                        (UINT16)MIN(UINT16_MAX, destPt->y + cacheEntry->height) };
+
+		if (rectangle_is_empty(&rect))
+			continue;
+
+		if (!is_rect_valid(&rect, surface->width, surface->height))
+			goto fail;
+
+		if (!freerdp_image_copy_no_overlap(surface->data, surface->format, surface->scanline,
+		                                   destPt->x, destPt->y, cacheEntry->width,
+		                                   cacheEntry->height, cacheEntry->data, cacheEntry->format,
+		                                   cacheEntry->scanline, 0, 0, NULL, FREERDP_FLIP_NONE))
+			goto fail;
+
+		invalidRect = rect;
+		region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &invalidRect);
+		status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context,
+		                      surface->surfaceId, 1, &invalidRect);
+
+		if (status != CHANNEL_RC_OK)
+			goto fail;
+	}
+
+	LeaveCriticalSection(&context->mux);
+
+	return gdi_interFrameUpdate(gdi, context);
+
+fail:
+	LeaveCriticalSection(&context->mux);
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_CacheImportReply(RdpgfxClientContext* context,
+                                 const RDPGFX_CACHE_IMPORT_REPLY_PDU* cacheImportReply)
+{
+	UINT16 count = 0;
+	const UINT16* slots = NULL;
+	UINT error = CHANNEL_RC_OK;
+
+	slots = cacheImportReply->cacheSlots;
+	count = cacheImportReply->importedEntriesCount;
+
+	for (UINT16 index = 0; index < count; index++)
+	{
+		UINT16 cacheSlot = slots[index];
+
+		if (cacheSlot == 0)
+			continue;
+
+		WINPR_ASSERT(context->GetCacheSlotData);
+		gdiGfxCacheEntry* cacheEntry =
+		    (gdiGfxCacheEntry*)context->GetCacheSlotData(context, cacheSlot);
+
+		if (cacheEntry)
+			continue;
+
+		cacheEntry = gdi_GfxCacheEntryNew(cacheSlot, 0, 0, PIXEL_FORMAT_BGRX32);
+
+		if (!cacheEntry)
+			return ERROR_INTERNAL_ERROR;
+
+		WINPR_ASSERT(context->SetCacheSlotData);
+		error = context->SetCacheSlotData(context, cacheSlot, (void*)cacheEntry);
+
+		if (error)
+		{
+			WLog_ERR(TAG, "CacheImportReply: SetCacheSlotData failed with error %" PRIu32 "",
+			         error);
+			gdi_GfxCacheEntryFree(cacheEntry);
+			break;
+		}
+	}
+
+	return error;
+}
+
+static UINT gdi_ImportCacheEntry(RdpgfxClientContext* context, UINT16 cacheSlot,
+                                 const PERSISTENT_CACHE_ENTRY* importCacheEntry)
+{
+	UINT error = ERROR_INTERNAL_ERROR;
+	gdiGfxCacheEntry* cacheEntry = NULL;
+
+	if (cacheSlot == 0)
+		return CHANNEL_RC_OK;
+
+	cacheEntry = gdi_GfxCacheEntryNew(importCacheEntry->key64, importCacheEntry->width,
+	                                  importCacheEntry->height, PIXEL_FORMAT_BGRX32);
+
+	if (!cacheEntry)
+		goto fail;
+
+	if (!freerdp_image_copy_no_overlap(cacheEntry->data, cacheEntry->format, cacheEntry->scanline,
+	                                   0, 0, cacheEntry->width, cacheEntry->height,
+	                                   importCacheEntry->data, PIXEL_FORMAT_BGRX32, 0, 0, 0, NULL,
+	                                   FREERDP_FLIP_NONE))
+		goto fail;
+
+	RDPGFX_EVICT_CACHE_ENTRY_PDU evict = { cacheSlot };
+	WINPR_ASSERT(context->EvictCacheEntry);
+	error = context->EvictCacheEntry(context, &evict);
+	if (error != CHANNEL_RC_OK)
+		goto fail;
+
+	WINPR_ASSERT(context->SetCacheSlotData);
+	error = context->SetCacheSlotData(context, cacheSlot, (void*)cacheEntry);
+
+fail:
+	if (error)
+	{
+		gdi_GfxCacheEntryFree(cacheEntry);
+		WLog_ERR(TAG, "ImportCacheEntry: SetCacheSlotData failed with error %" PRIu32 "", error);
+	}
+
+	return error;
+}
+
+static UINT gdi_ExportCacheEntry(RdpgfxClientContext* context, UINT16 cacheSlot,
+                                 PERSISTENT_CACHE_ENTRY* exportCacheEntry)
+{
+	gdiGfxCacheEntry* cacheEntry = NULL;
+
+	WINPR_ASSERT(context->GetCacheSlotData);
+	cacheEntry = (gdiGfxCacheEntry*)context->GetCacheSlotData(context, cacheSlot);
+
+	if (cacheEntry)
+	{
+		exportCacheEntry->key64 = cacheEntry->cacheKey;
+		exportCacheEntry->width = (UINT16)MIN(UINT16_MAX, cacheEntry->width);
+		exportCacheEntry->height = (UINT16)MIN(UINT16_MAX, cacheEntry->height);
+		exportCacheEntry->size = cacheEntry->width * cacheEntry->height * 4;
+		exportCacheEntry->flags = 0;
+		exportCacheEntry->data = cacheEntry->data;
+		return CHANNEL_RC_OK;
+	}
+
+	return ERROR_NOT_FOUND;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_EvictCacheEntry(RdpgfxClientContext* context,
+                                const RDPGFX_EVICT_CACHE_ENTRY_PDU* evictCacheEntry)
+{
+	gdiGfxCacheEntry* cacheEntry = NULL;
+	UINT rc = ERROR_NOT_FOUND;
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(evictCacheEntry);
+
+	EnterCriticalSection(&context->mux);
+
+	WINPR_ASSERT(context->GetCacheSlotData);
+	cacheEntry = (gdiGfxCacheEntry*)context->GetCacheSlotData(context, evictCacheEntry->cacheSlot);
+
+	gdi_GfxCacheEntryFree(cacheEntry);
+
+	WINPR_ASSERT(context->SetCacheSlotData);
+	rc = context->SetCacheSlotData(context, evictCacheEntry->cacheSlot, NULL);
+	LeaveCriticalSection(&context->mux);
+	return rc;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_MapSurfaceToOutput(RdpgfxClientContext* context,
+                                   const RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU* surfaceToOutput)
+{
+	UINT rc = ERROR_INTERNAL_ERROR;
+	gdiGfxSurface* surface = NULL;
+	EnterCriticalSection(&context->mux);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToOutput->surfaceId);
+
+	if (!surface)
+		goto fail;
+
+	if (surface->windowMapped)
+	{
+		WLog_WARN(TAG, "surface already windowMapped when trying to set outputMapped");
+		goto fail;
+	}
+
+	surface->outputMapped = TRUE;
+	surface->outputOriginX = surfaceToOutput->outputOriginX;
+	surface->outputOriginY = surfaceToOutput->outputOriginY;
+	surface->outputTargetWidth = surface->mappedWidth;
+	surface->outputTargetHeight = surface->mappedHeight;
+	region16_clear(&surface->invalidRegion);
+	rc = CHANNEL_RC_OK;
+fail:
+	LeaveCriticalSection(&context->mux);
+	return rc;
+}
+
+static UINT
+gdi_MapSurfaceToScaledOutput(RdpgfxClientContext* context,
+                             const RDPGFX_MAP_SURFACE_TO_SCALED_OUTPUT_PDU* surfaceToOutput)
+{
+	UINT rc = ERROR_INTERNAL_ERROR;
+	gdiGfxSurface* surface = NULL;
+	EnterCriticalSection(&context->mux);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToOutput->surfaceId);
+
+	if (!surface)
+		goto fail;
+
+	if (surface->windowMapped)
+	{
+		WLog_WARN(TAG, "surface already windowMapped when trying to set outputMapped");
+		goto fail;
+	}
+
+	surface->outputMapped = TRUE;
+	surface->outputOriginX = surfaceToOutput->outputOriginX;
+	surface->outputOriginY = surfaceToOutput->outputOriginY;
+	surface->outputTargetWidth = surfaceToOutput->targetWidth;
+	surface->outputTargetHeight = surfaceToOutput->targetHeight;
+	region16_clear(&surface->invalidRegion);
+	rc = CHANNEL_RC_OK;
+fail:
+	LeaveCriticalSection(&context->mux);
+	return rc;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT gdi_MapSurfaceToWindow(RdpgfxClientContext* context,
+                                   const RDPGFX_MAP_SURFACE_TO_WINDOW_PDU* surfaceToWindow)
+{
+	UINT rc = ERROR_INTERNAL_ERROR;
+	gdiGfxSurface* surface = NULL;
+	EnterCriticalSection(&context->mux);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToWindow->surfaceId);
+
+	if (!surface)
+		goto fail;
+
+	if (surface->outputMapped)
+	{
+		WLog_WARN(TAG, "surface already outputMapped when trying to set windowMapped");
+		goto fail;
+	}
+
+	if (surface->windowMapped)
+	{
+		if (surface->windowId != surfaceToWindow->windowId)
+		{
+			WLog_WARN(TAG, "surface windowId mismatch, has %" PRIu64 ", expected %" PRIu64,
+			          surface->windowId, surfaceToWindow->windowId);
+			goto fail;
+		}
+	}
+	surface->windowMapped = TRUE;
+
+	surface->windowId = surfaceToWindow->windowId;
+	surface->mappedWidth = surfaceToWindow->mappedWidth;
+	surface->mappedHeight = surfaceToWindow->mappedHeight;
+	surface->outputTargetWidth = surfaceToWindow->mappedWidth;
+	surface->outputTargetHeight = surfaceToWindow->mappedHeight;
+	rc = IFCALLRESULT(CHANNEL_RC_OK, context->MapWindowForSurface, context,
+	                  surfaceToWindow->surfaceId, surfaceToWindow->windowId);
+fail:
+	LeaveCriticalSection(&context->mux);
+	return rc;
+}
+
+static UINT
+gdi_MapSurfaceToScaledWindow(RdpgfxClientContext* context,
+                             const RDPGFX_MAP_SURFACE_TO_SCALED_WINDOW_PDU* surfaceToWindow)
+{
+	UINT rc = ERROR_INTERNAL_ERROR;
+	gdiGfxSurface* surface = NULL;
+	EnterCriticalSection(&context->mux);
+
+	WINPR_ASSERT(context->GetSurfaceData);
+	surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToWindow->surfaceId);
+
+	if (!surface)
+		goto fail;
+
+	if (surface->outputMapped)
+	{
+		WLog_WARN(TAG, "surface already outputMapped when trying to set windowMapped");
+		goto fail;
+	}
+
+	if (surface->windowMapped)
+	{
+		if (surface->windowId != surfaceToWindow->windowId)
+		{
+			WLog_WARN(TAG, "surface windowId mismatch, has %" PRIu64 ", expected %" PRIu64,
+			          surface->windowId, surfaceToWindow->windowId);
+			goto fail;
+		}
+	}
+	surface->windowMapped = TRUE;
+
+	surface->windowId = surfaceToWindow->windowId;
+	surface->mappedWidth = surfaceToWindow->mappedWidth;
+	surface->mappedHeight = surfaceToWindow->mappedHeight;
+	surface->outputTargetWidth = surfaceToWindow->targetWidth;
+	surface->outputTargetHeight = surfaceToWindow->targetHeight;
+	rc = IFCALLRESULT(CHANNEL_RC_OK, context->MapWindowForSurface, context,
+	                  surfaceToWindow->surfaceId, surfaceToWindow->windowId);
+fail:
+	LeaveCriticalSection(&context->mux);
+	return rc;
+}
+
+BOOL gdi_graphics_pipeline_init(rdpGdi* gdi, RdpgfxClientContext* gfx)
+{
+	return gdi_graphics_pipeline_init_ex(gdi, gfx, NULL, NULL, NULL);
+}
+
+BOOL gdi_graphics_pipeline_init_ex(rdpGdi* gdi, RdpgfxClientContext* gfx,
+                                   pcRdpgfxMapWindowForSurface map,
+                                   pcRdpgfxUnmapWindowForSurface unmap,
+                                   pcRdpgfxUpdateSurfaceArea update)
+{
+	if (!gdi || !gfx || !gdi->context || !gdi->context->settings)
+		return FALSE;
+
+	rdpContext* context = gdi->context;
+	rdpSettings* settings = context->settings;
+
+	gdi->gfx = gfx;
+	gfx->custom = (void*)gdi;
+	gfx->ResetGraphics = gdi_ResetGraphics;
+	gfx->StartFrame = gdi_StartFrame;
+	gfx->EndFrame = gdi_EndFrame;
+	gfx->SurfaceCommand = gdi_SurfaceCommand;
+	gfx->DeleteEncodingContext = gdi_DeleteEncodingContext;
+	gfx->CreateSurface = gdi_CreateSurface;
+	gfx->DeleteSurface = gdi_DeleteSurface;
+	gfx->SolidFill = gdi_SolidFill;
+	gfx->SurfaceToSurface = gdi_SurfaceToSurface;
+	gfx->SurfaceToCache = gdi_SurfaceToCache;
+	gfx->CacheToSurface = gdi_CacheToSurface;
+	gfx->CacheImportReply = gdi_CacheImportReply;
+	gfx->ImportCacheEntry = gdi_ImportCacheEntry;
+	gfx->ExportCacheEntry = gdi_ExportCacheEntry;
+	gfx->EvictCacheEntry = gdi_EvictCacheEntry;
+	gfx->MapSurfaceToOutput = gdi_MapSurfaceToOutput;
+	gfx->MapSurfaceToWindow = gdi_MapSurfaceToWindow;
+	gfx->MapSurfaceToScaledOutput = gdi_MapSurfaceToScaledOutput;
+	gfx->MapSurfaceToScaledWindow = gdi_MapSurfaceToScaledWindow;
+	gfx->UpdateSurfaces = gdi_UpdateSurfaces;
+	gfx->MapWindowForSurface = map;
+	gfx->UnmapWindowForSurface = unmap;
+	gfx->UpdateSurfaceArea = update;
+
+	if (!freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding))
+	{
+		const UINT32 w = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+		const UINT32 h = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+		const UINT32 flags = freerdp_settings_get_uint32(settings, FreeRDP_ThreadingFlags);
+
+		gfx->codecs = freerdp_client_codecs_new(flags);
+		if (!gfx->codecs)
+			return FALSE;
+		if (!freerdp_client_codecs_prepare(gfx->codecs, FREERDP_CODEC_ALL, w, h))
+			return FALSE;
+	}
+	InitializeCriticalSection(&gfx->mux);
+	PROFILER_CREATE(gfx->SurfaceProfiler, "GFX-PROFILER")
+
+	/**
+	 * gdi->graphicsReset will be removed in FreeRDP v3 from public headers,
+	 * since the EGFX Reset Graphics PDU seems to be optional.
+	 * There are still some clients that expect and check it and therefore
+	 * we simply initialize it with TRUE here for now.
+	 */
+	gdi->graphicsReset = TRUE;
+	if (freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding))
+	{
+		gfx->UpdateSurfaceArea = NULL;
+		gfx->UpdateSurfaces = NULL;
+		gfx->SurfaceCommand = NULL;
+	}
+
+	return TRUE;
+}
+
+void gdi_graphics_pipeline_uninit(rdpGdi* gdi, RdpgfxClientContext* gfx)
+{
+	if (gdi)
+		gdi->gfx = NULL;
+
+	if (!gfx)
+		return;
+
+	gfx->custom = NULL;
+	freerdp_client_codecs_free(gfx->codecs);
+	gfx->codecs = NULL;
+	DeleteCriticalSection(&gfx->mux);
+	PROFILER_PRINT_HEADER
+	PROFILER_PRINT(gfx->SurfaceProfiler)
+	PROFILER_PRINT_FOOTER
+	PROFILER_FREE(gfx->SurfaceProfiler)
+}
+
+const char* rdpgfx_caps_version_str(UINT32 capsVersion)
+{
+	switch (capsVersion)
+	{
+		case RDPGFX_CAPVERSION_8:
+			return "RDPGFX_CAPVERSION_8";
+		case RDPGFX_CAPVERSION_81:
+			return "RDPGFX_CAPVERSION_81";
+		case RDPGFX_CAPVERSION_10:
+			return "RDPGFX_CAPVERSION_10";
+		case RDPGFX_CAPVERSION_101:
+			return "RDPGFX_CAPVERSION_101";
+		case RDPGFX_CAPVERSION_102:
+			return "RDPGFX_CAPVERSION_102";
+		case RDPGFX_CAPVERSION_103:
+			return "RDPGFX_CAPVERSION_103";
+		case RDPGFX_CAPVERSION_104:
+			return "RDPGFX_CAPVERSION_104";
+		case RDPGFX_CAPVERSION_105:
+			return "RDPGFX_CAPVERSION_105";
+		case RDPGFX_CAPVERSION_106:
+			return "RDPGFX_CAPVERSION_106";
+		case RDPGFX_CAPVERSION_106_ERR:
+			return "RDPGFX_CAPVERSION_106_ERR";
+		case RDPGFX_CAPVERSION_107:
+			return "RDPGFX_CAPVERSION_107";
+		default:
+			return "RDPGFX_CAPVERSION_UNKNOWN";
+	}
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/gdi/line.c

@@ -0,0 +1,316 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * GDI Line Functions
+ *
+ * Copyright 2010-2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2016 Armin Novak <[email protected]>
+ * Copyright 2016 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 <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <winpr/assert.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/gdi/gdi.h>
+#include <freerdp/gdi/pen.h>
+#include <freerdp/gdi/bitmap.h>
+#include <freerdp/gdi/region.h>
+
+#include "drawing.h"
+#include "clipping.h"
+#include "line.h"
+
+static BOOL gdi_rop_color(INT32 rop, BYTE* pixelPtr, UINT32 pen, UINT32 format)
+{
+	WINPR_ASSERT(pixelPtr);
+	const UINT32 srcPixel = FreeRDPReadColor(pixelPtr, format);
+	UINT32 dstPixel = 0;
+
+	switch (rop)
+	{
+		case GDI_R2_BLACK: /* LineTo_BLACK */
+			dstPixel = FreeRDPGetColor(format, 0, 0, 0, 0xFF);
+			break;
+
+		case GDI_R2_NOTMERGEPEN: /* LineTo_NOTMERGEPEN */
+			dstPixel = ~(srcPixel | pen);
+			break;
+
+		case GDI_R2_MASKNOTPEN: /* LineTo_MASKNOTPEN */
+			dstPixel = srcPixel & ~pen;
+			break;
+
+		case GDI_R2_NOTCOPYPEN: /* LineTo_NOTCOPYPEN */
+			dstPixel = ~pen;
+			break;
+
+		case GDI_R2_MASKPENNOT: /* LineTo_MASKPENNOT */
+			dstPixel = pen & ~srcPixel;
+			break;
+
+		case GDI_R2_NOT: /* LineTo_NOT */
+			dstPixel = ~srcPixel;
+			break;
+
+		case GDI_R2_XORPEN: /* LineTo_XORPEN */
+			dstPixel = srcPixel ^ pen;
+			break;
+
+		case GDI_R2_NOTMASKPEN: /* LineTo_NOTMASKPEN */
+			dstPixel = ~(srcPixel & pen);
+			break;
+
+		case GDI_R2_MASKPEN: /* LineTo_MASKPEN */
+			dstPixel = srcPixel & pen;
+			break;
+
+		case GDI_R2_NOTXORPEN: /* LineTo_NOTXORPEN */
+			dstPixel = ~(srcPixel ^ pen);
+			break;
+
+		case GDI_R2_NOP: /* LineTo_NOP */
+			dstPixel = srcPixel;
+			break;
+
+		case GDI_R2_MERGENOTPEN: /* LineTo_MERGENOTPEN */
+			dstPixel = srcPixel | ~pen;
+			break;
+
+		case GDI_R2_COPYPEN: /* LineTo_COPYPEN */
+			dstPixel = pen;
+			break;
+
+		case GDI_R2_MERGEPENNOT: /* LineTo_MERGEPENNOT */
+			dstPixel = srcPixel | ~pen;
+			break;
+
+		case GDI_R2_MERGEPEN: /* LineTo_MERGEPEN */
+			dstPixel = srcPixel | pen;
+			break;
+
+		case GDI_R2_WHITE: /* LineTo_WHITE */
+			dstPixel = FreeRDPGetColor(format, 0xFF, 0xFF, 0xFF, 0xFF);
+			break;
+
+		default:
+			return FALSE;
+	}
+
+	return FreeRDPWriteColor(pixelPtr, format, dstPixel);
+}
+
+BOOL gdi_LineTo(HGDI_DC hdc, INT32 nXEnd, INT32 nYEnd)
+{
+	INT32 e2 = 0;
+	UINT32 pen = 0;
+
+	WINPR_ASSERT(hdc);
+	const INT32 rop2 = gdi_GetROP2(hdc);
+
+	const INT32 x1 = hdc->pen->posX;
+	const INT32 y1 = hdc->pen->posY;
+	const INT32 x2 = WINPR_ASSERTING_INT_CAST(int32_t, nXEnd);
+	const INT32 y2 = WINPR_ASSERTING_INT_CAST(int32_t, nYEnd);
+	const INT32 dx = (x1 > x2) ? x1 - x2 : x2 - x1;
+	const INT32 dy = (y1 > y2) ? y1 - y2 : y2 - y1;
+	const INT32 sx = (x1 < x2) ? 1 : -1;
+	const INT32 sy = (y1 < y2) ? 1 : -1;
+	INT32 e = dx - dy;
+	INT32 x = x1;
+	INT32 y = y1;
+
+	WINPR_ASSERT(hdc->clip);
+	INT32 bx1 = 0;
+	INT32 by1 = 0;
+	INT32 bx2 = 0;
+	INT32 by2 = 0;
+	if (hdc->clip->null)
+	{
+		bx1 = (x1 < x2) ? x1 : x2;
+		by1 = (y1 < y2) ? y1 : y2;
+		bx2 = (x1 > x2) ? x1 : x2;
+		by2 = (y1 > y2) ? y1 : y2;
+	}
+	else
+	{
+		bx1 = hdc->clip->x;
+		by1 = hdc->clip->y;
+		bx2 = bx1 + hdc->clip->w - 1;
+		by2 = by1 + hdc->clip->h - 1;
+	}
+
+	HGDI_BITMAP bmp = (HGDI_BITMAP)hdc->selectedObject;
+	WINPR_ASSERT(bmp);
+
+	bx1 = MAX(bx1, 0);
+	by1 = MAX(by1, 0);
+	bx2 = MIN(bx2, bmp->width - 1);
+	by2 = MIN(by2, bmp->height - 1);
+
+	if (!gdi_InvalidateRegion(hdc, bx1, by1, bx2 - bx1 + 1, by2 - by1 + 1))
+		return FALSE;
+
+	pen = gdi_GetPenColor(hdc->pen, bmp->format);
+
+	while (1)
+	{
+		if (!(x == x2 && y == y2))
+		{
+			if ((x >= bx1 && x <= bx2) && (y >= by1 && y <= by2))
+			{
+				BYTE* pixel = gdi_GetPointer(bmp, WINPR_ASSERTING_INT_CAST(uint32_t, x),
+				                             WINPR_ASSERTING_INT_CAST(uint32_t, y));
+				WINPR_ASSERT(pixel);
+				gdi_rop_color(rop2, pixel, pen, bmp->format);
+			}
+		}
+		else
+		{
+			break;
+		}
+
+		e2 = 2 * e;
+
+		if (e2 > -dy)
+		{
+			e -= dy;
+			x += sx;
+		}
+
+		if (e2 < dx)
+		{
+			e += dx;
+			y += sy;
+		}
+	}
+
+	return TRUE;
+}
+
+/**
+ * Draw one or more straight lines
+ * @param hdc device context
+ * @param lppt array of points
+ * @param cCount number of points
+ * @return nonzero on success, 0 otherwise
+ */
+BOOL gdi_PolylineTo(HGDI_DC hdc, GDI_POINT* lppt, DWORD cCount)
+{
+	WINPR_ASSERT(hdc);
+	WINPR_ASSERT(lppt || (cCount == 0));
+
+	for (DWORD i = 0; i < cCount; i++)
+	{
+		if (!gdi_LineTo(hdc, lppt[i].x, lppt[i].y))
+			return FALSE;
+
+		if (!gdi_MoveToEx(hdc, lppt[i].x, lppt[i].y, NULL))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+/**
+ * Draw one or more straight lines
+ * @param hdc device context
+ * @param lppt array of points
+ * @param cPoints number of points
+ * @return nonzero on success, 0 otherwise
+ */
+BOOL gdi_Polyline(HGDI_DC hdc, GDI_POINT* lppt, UINT32 cPoints)
+{
+	WINPR_ASSERT(hdc);
+	WINPR_ASSERT(lppt || (cPoints == 0));
+
+	if (cPoints > 0)
+	{
+		GDI_POINT pt = { 0 };
+
+		if (!gdi_MoveToEx(hdc, lppt[0].x, lppt[0].y, &pt))
+			return FALSE;
+
+		for (UINT32 i = 0; i < cPoints; i++)
+		{
+			if (!gdi_LineTo(hdc, lppt[i].x, lppt[i].y))
+				return FALSE;
+
+			if (!gdi_MoveToEx(hdc, lppt[i].x, lppt[i].y, NULL))
+				return FALSE;
+		}
+
+		if (!gdi_MoveToEx(hdc, pt.x, pt.y, NULL))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+/**
+ * Draw multiple series of connected line segments
+ * @param hdc device context
+ * @param lppt array of points
+ * @param lpdwPolyPoints array of numbers of points per series
+ * @param cCount count of entries in lpdwPolyPoints
+ * @return nonzero on success, 0 otherwise
+ */
+BOOL gdi_PolyPolyline(HGDI_DC hdc, GDI_POINT* lppt, const UINT32* lpdwPolyPoints, DWORD cCount)
+{
+	DWORD j = 0;
+
+	WINPR_ASSERT(hdc);
+	WINPR_ASSERT(lppt || (cCount == 0));
+	WINPR_ASSERT(lpdwPolyPoints || (cCount == 0));
+
+	for (DWORD i = 0; i < cCount; i++)
+	{
+		const UINT32 cPoints = lpdwPolyPoints[i];
+
+		if (!gdi_Polyline(hdc, &lppt[j], cPoints))
+			return FALSE;
+
+		j += cPoints;
+	}
+
+	return TRUE;
+}
+
+/**
+ * Move pen from the current device context to a new position.
+ * @param hdc device context
+ * @param X x position
+ * @param Y y position
+ * @return nonzero on success, 0 otherwise
+ */
+
+BOOL gdi_MoveToEx(HGDI_DC hdc, INT32 X, INT32 Y, HGDI_POINT lpPoint)
+{
+	WINPR_ASSERT(hdc);
+
+	if (lpPoint != NULL)
+	{
+		lpPoint->x = hdc->pen->posX;
+		lpPoint->y = hdc->pen->posY;
+	}
+
+	hdc->pen->posX = X;
+	hdc->pen->posY = Y;
+	return TRUE;
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/gdi/shape.c

@@ -0,0 +1,299 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * GDI Shape Functions
+ *
+ * Copyright 2010-2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2016 Armin Novak <[email protected]>
+ * Copyright 2016 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 <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/gdi/gdi.h>
+
+#include <freerdp/gdi/bitmap.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/gdi/shape.h>
+
+#include <freerdp/log.h>
+
+#include "clipping.h"
+#include "../gdi/gdi.h"
+
+#define TAG FREERDP_TAG("gdi.shape")
+
+static void Ellipse_Bresenham(HGDI_DC hdc, int x1, int y1, int x2, int y2)
+{
+	INT32 e = 0;
+	INT32 e2 = 0;
+	INT32 dx = 0;
+	INT32 dy = 0;
+	INT32 a = 0;
+	INT32 b = 0;
+	INT32 c = 0;
+	a = (x1 < x2) ? x2 - x1 : x1 - x2;
+	b = (y1 < y2) ? y2 - y1 : y1 - y2;
+	c = b & 1;
+	dx = 4 * (1 - a) * b * b;
+	dy = 4 * (c + 1) * a * a;
+	e = dx + dy + c * a * a;
+
+	if (x1 > x2)
+	{
+		x1 = x2;
+		x2 += a;
+	}
+
+	if (y1 > y2)
+		y1 = y2;
+
+	y1 += (b + 1) / 2;
+	y2 = y1 - c;
+	a *= 8 * a;
+	c = 8 * b * b;
+
+	do
+	{
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(UINT32, x2),
+		             WINPR_ASSERTING_INT_CAST(UINT32, y1), 0);
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(UINT32, x1),
+		             WINPR_ASSERTING_INT_CAST(UINT32, y1), 0);
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(UINT32, x1),
+		             WINPR_ASSERTING_INT_CAST(UINT32, y2), 0);
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(UINT32, x2),
+		             WINPR_ASSERTING_INT_CAST(UINT32, y2), 0);
+		e2 = 2 * e;
+
+		if (e2 >= dx)
+		{
+			x1++;
+			x2--;
+			e += dx += c;
+		}
+
+		if (e2 <= dy)
+		{
+			y1++;
+			y2--;
+			e += dy += a;
+		}
+	} while (x1 <= x2);
+
+	while (y1 - y2 < b)
+	{
+		y1++;
+		y2--;
+
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(uint32_t, x1 - 1),
+		             WINPR_ASSERTING_INT_CAST(uint32_t, y1), 0);
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(uint32_t, x1 - 1),
+		             WINPR_ASSERTING_INT_CAST(uint32_t, y2), 0);
+	}
+}
+
+/**
+ * Draw an ellipse
+ * msdn{dd162510}
+ *
+ * @param hdc device context
+ * @param nLeftRect x1
+ * @param nTopRect y1
+ * @param nRightRect x2
+ * @param nBottomRect y2
+ *
+ * @return nonzero if successful, 0 otherwise
+ */
+BOOL gdi_Ellipse(HGDI_DC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect)
+{
+	Ellipse_Bresenham(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
+	return TRUE;
+}
+
+/**
+ * Fill a rectangle with the given brush.
+ * msdn{dd162719}
+ *
+ * @param hdc device context
+ * @param rect rectangle
+ * @param hbr brush
+ *
+ * @return nonzero if successful, 0 otherwise
+ */
+
+BOOL gdi_FillRect(HGDI_DC hdc, const HGDI_RECT rect, HGDI_BRUSH hbr)
+{
+	UINT32 color = 0;
+	UINT32 dstColor = 0;
+	BOOL monochrome = FALSE;
+	INT32 nXDest = 0;
+	INT32 nYDest = 0;
+	INT32 nWidth = 0;
+	INT32 nHeight = 0;
+	const BYTE* srcp = NULL;
+	DWORD formatSize = 0;
+	gdi_RectToCRgn(rect, &nXDest, &nYDest, &nWidth, &nHeight);
+
+	if (!hdc || !hbr)
+		return FALSE;
+
+	if (!gdi_ClipCoords(hdc, &nXDest, &nYDest, &nWidth, &nHeight, NULL, NULL))
+		return TRUE;
+
+	switch (hbr->style)
+	{
+		case GDI_BS_SOLID:
+			color = hbr->color;
+
+			for (INT32 x = 0; x < nWidth; x++)
+			{
+				BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest + x, nYDest);
+
+				if (dstp)
+					FreeRDPWriteColor(dstp, hdc->format, color);
+			}
+
+			srcp = gdi_get_bitmap_pointer(hdc, nXDest, nYDest);
+			formatSize = FreeRDPGetBytesPerPixel(hdc->format);
+
+			for (INT32 y = 1; y < nHeight; y++)
+			{
+				BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest, nYDest + y);
+				memcpy(dstp, srcp, 1ull * WINPR_ASSERTING_INT_CAST(size_t, nWidth) * formatSize);
+			}
+
+			break;
+
+		case GDI_BS_HATCHED:
+		case GDI_BS_PATTERN:
+			monochrome = (hbr->pattern->format == PIXEL_FORMAT_MONO);
+			formatSize = FreeRDPGetBytesPerPixel(hbr->pattern->format);
+
+			for (INT32 y = 0; y < nHeight; y++)
+			{
+				for (INT32 x = 0; x < nWidth; x++)
+				{
+					const size_t yOffset =
+					    ((1ULL * WINPR_ASSERTING_INT_CAST(size_t, nYDest) +
+					      WINPR_ASSERTING_INT_CAST(size_t, y)) *
+					     WINPR_ASSERTING_INT_CAST(size_t, hbr->pattern->width) %
+					     WINPR_ASSERTING_INT_CAST(size_t, hbr->pattern->height)) *
+					    formatSize;
+					const size_t xOffset = ((1ULL * WINPR_ASSERTING_INT_CAST(size_t, nXDest) +
+					                         WINPR_ASSERTING_INT_CAST(size_t, x)) %
+					                        WINPR_ASSERTING_INT_CAST(size_t, hbr->pattern->width)) *
+					                       formatSize;
+					const BYTE* patp = &hbr->pattern->data[yOffset + xOffset];
+
+					if (monochrome)
+					{
+						if (*patp == 0)
+							dstColor = hdc->bkColor;
+						else
+							dstColor = hdc->textColor;
+					}
+					else
+					{
+						dstColor = FreeRDPReadColor(patp, hbr->pattern->format);
+						dstColor =
+						    FreeRDPConvertColor(dstColor, hbr->pattern->format, hdc->format, NULL);
+					}
+
+					BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest + x, nYDest + y);
+					if (dstp)
+						FreeRDPWriteColor(dstp, hdc->format, dstColor);
+				}
+			}
+
+			break;
+
+		default:
+			break;
+	}
+
+	if (!gdi_InvalidateRegion(hdc, nXDest, nYDest, nWidth, nHeight))
+		return FALSE;
+
+	return TRUE;
+}
+
+/**
+ * Draw a polygon
+ * msdn{dd162814}
+ * @param hdc device context
+ * @param lpPoints array of points
+ * @param nCount number of points
+ * @return nonzero if successful, 0 otherwise
+ */
+BOOL gdi_Polygon(HGDI_DC hdc, GDI_POINT* lpPoints, int nCount)
+{
+	WLog_ERR(TAG, "Not implemented!");
+	return FALSE;
+}
+
+/**
+ * Draw a series of closed polygons
+ * msdn{dd162818}
+ * @param hdc device context
+ * @param lpPoints array of series of points
+ * @param lpPolyCounts array of number of points in each series
+ * @param nCount count of number of points in lpPolyCounts
+ * @return nonzero if successful, 0 otherwise
+ */
+BOOL gdi_PolyPolygon(HGDI_DC hdc, GDI_POINT* lpPoints, int* lpPolyCounts, int nCount)
+{
+	WLog_ERR(TAG, "Not implemented!");
+	return FALSE;
+}
+
+BOOL gdi_Rectangle(HGDI_DC hdc, INT32 nXDst, INT32 nYDst, INT32 nWidth, INT32 nHeight)
+{
+	UINT32 color = 0;
+
+	if (!gdi_ClipCoords(hdc, &nXDst, &nYDst, &nWidth, &nHeight, NULL, NULL))
+		return TRUE;
+
+	color = hdc->textColor;
+
+	for (INT32 y = 0; y < nHeight; y++)
+	{
+		BYTE* dstLeft = gdi_get_bitmap_pointer(hdc, nXDst, nYDst + y);
+		BYTE* dstRight = gdi_get_bitmap_pointer(hdc, nXDst + nWidth - 1, nYDst + y);
+
+		if (dstLeft)
+			FreeRDPWriteColor(dstLeft, hdc->format, color);
+
+		if (dstRight)
+			FreeRDPWriteColor(dstRight, hdc->format, color);
+	}
+
+	for (INT32 x = 0; x < nWidth; x++)
+	{
+		BYTE* dstTop = gdi_get_bitmap_pointer(hdc, nXDst + x, nYDst);
+		BYTE* dstBottom = gdi_get_bitmap_pointer(hdc, nXDst + x, nYDst + nHeight - 1);
+
+		if (dstTop)
+			FreeRDPWriteColor(dstTop, hdc->format, color);
+
+		if (dstBottom)
+			FreeRDPWriteColor(dstBottom, hdc->format, color);
+	}
+
+	return FALSE;
+}

local-test-freerdp-full-01/afc-freerdp/libfreerdp/gdi/video.c

@@ -0,0 +1,210 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Video Optimized Remoting Virtual Channel Extension for X11
+ *
+ * Copyright 2017 David Fort <[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 "../core/update.h"
+
+#include <winpr/assert.h>
+
+#include <freerdp/client/geometry.h>
+#include <freerdp/client/video.h>
+#include <freerdp/gdi/gdi.h>
+#include <freerdp/gdi/video.h>
+#include <freerdp/gdi/region.h>
+
+void gdi_video_geometry_init(rdpGdi* gdi, GeometryClientContext* geom)
+{
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(geom);
+
+	gdi->geometry = geom;
+
+	if (gdi->video)
+	{
+		VideoClientContext* video = gdi->video;
+
+		WINPR_ASSERT(video);
+		WINPR_ASSERT(video->setGeometry);
+		video->setGeometry(video, gdi->geometry);
+	}
+}
+
+void gdi_video_geometry_uninit(rdpGdi* gdi, GeometryClientContext* geom)
+{
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(geom);
+	WINPR_UNUSED(gdi);
+	WINPR_UNUSED(geom);
+}
+
+static VideoSurface* gdiVideoCreateSurface(VideoClientContext* video, UINT32 x, UINT32 y,
+                                           UINT32 width, UINT32 height)
+{
+	return VideoClient_CreateCommonContext(sizeof(VideoSurface), x, y, width, height);
+}
+
+static BOOL gdiVideoShowSurface(VideoClientContext* video, const VideoSurface* surface,
+                                UINT32 destinationWidth, UINT32 destinationHeight)
+{
+	BOOL rc = FALSE;
+	rdpGdi* gdi = NULL;
+	rdpUpdate* update = NULL;
+
+	WINPR_ASSERT(video);
+	WINPR_ASSERT(surface);
+
+	gdi = (rdpGdi*)video->custom;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(gdi->context);
+
+	update = gdi->context->update;
+	WINPR_ASSERT(update);
+
+	if (!update_begin_paint(update))
+		goto fail;
+
+	if ((gdi->width < 0) || (gdi->height < 0))
+		goto fail;
+	else
+	{
+		const UINT32 nXSrc = surface->x;
+		const UINT32 nYSrc = surface->y;
+		const UINT32 nXDst = nXSrc;
+		const UINT32 nYDst = nYSrc;
+		const UINT32 width = (destinationWidth + surface->x < (UINT32)gdi->width)
+		                         ? destinationWidth
+		                         : (UINT32)gdi->width - surface->x;
+		const UINT32 height = (destinationHeight + surface->y < (UINT32)gdi->height)
+		                          ? destinationHeight
+		                          : (UINT32)gdi->height - surface->y;
+
+		WINPR_ASSERT(gdi->primary_buffer);
+		WINPR_ASSERT(gdi->primary);
+		WINPR_ASSERT(gdi->primary->hdc);
+
+		if (!freerdp_image_scale(gdi->primary_buffer, gdi->primary->hdc->format, gdi->stride, nXDst,
+		                         nYDst, width, height, surface->data, surface->format,
+		                         surface->scanline, 0, 0, surface->w, surface->h))
+			goto fail;
+
+		if ((nXDst > INT32_MAX) || (nYDst > INT32_MAX) || (width > INT32_MAX) ||
+		    (height > INT32_MAX))
+			goto fail;
+
+		gdi_InvalidateRegion(gdi->primary->hdc, (INT32)nXDst, (INT32)nYDst, (INT32)width,
+		                     (INT32)height);
+	}
+
+	rc = TRUE;
+fail:
+
+	if (!update_end_paint(update))
+		return FALSE;
+
+	return rc;
+}
+
+static BOOL gdiVideoDeleteSurface(VideoClientContext* video, VideoSurface* surface)
+{
+	WINPR_UNUSED(video);
+	VideoClient_DestroyCommonContext(surface);
+	return TRUE;
+}
+
+void gdi_video_control_init(rdpGdi* gdi, VideoClientContext* video)
+{
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(video);
+
+	gdi->video = video;
+	video->custom = gdi;
+	video->createSurface = gdiVideoCreateSurface;
+	video->showSurface = gdiVideoShowSurface;
+	video->deleteSurface = gdiVideoDeleteSurface;
+	video->setGeometry(video, gdi->geometry);
+}
+
+void gdi_video_control_uninit(rdpGdi* gdi, VideoClientContext* video)
+{
+	WINPR_ASSERT(gdi);
+	gdi->video = NULL;
+}
+
+static void gdi_video_timer(void* context, const TimerEventArgs* timer)
+{
+	rdpContext* ctx = (rdpContext*)context;
+	rdpGdi* gdi = NULL;
+
+	WINPR_ASSERT(ctx);
+	WINPR_ASSERT(timer);
+
+	gdi = ctx->gdi;
+
+	if (gdi && gdi->video)
+		gdi->video->timer(gdi->video, timer->now);
+}
+
+void gdi_video_data_init(rdpGdi* gdi, VideoClientContext* video)
+{
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(gdi->context);
+	PubSub_SubscribeTimer(gdi->context->pubSub, gdi_video_timer);
+}
+
+void gdi_video_data_uninit(rdpGdi* gdi, VideoClientContext* context)
+{
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(gdi->context);
+	PubSub_UnsubscribeTimer(gdi->context->pubSub, gdi_video_timer);
+}
+
+VideoSurface* VideoClient_CreateCommonContext(size_t size, UINT32 x, UINT32 y, UINT32 w, UINT32 h)
+{
+	VideoSurface* ret = NULL;
+
+	WINPR_ASSERT(size >= sizeof(VideoSurface));
+
+	ret = calloc(1, size);
+	if (!ret)
+		return NULL;
+
+	ret->format = PIXEL_FORMAT_BGRX32;
+	ret->x = x;
+	ret->y = y;
+	ret->w = w;
+	ret->h = h;
+	ret->alignedWidth = ret->w + 32 - ret->w % 16;
+	ret->alignedHeight = ret->h + 32 - ret->h % 16;
+
+	ret->scanline = ret->alignedWidth * FreeRDPGetBytesPerPixel(ret->format);
+	ret->data = winpr_aligned_malloc(1ull * ret->scanline * ret->alignedHeight, 64);
+	if (!ret->data)
+		goto fail;
+	return ret;
+fail:
+	VideoClient_DestroyCommonContext(ret);
+	return NULL;
+}
+
+void VideoClient_DestroyCommonContext(VideoSurface* surface)
+{
+	if (!surface)
+		return;
+	winpr_aligned_free(surface->data);
+	free(surface);
+}