FreeRDP
Loading...
Searching...
No Matches
wlfreerdp.c
1
22#include <math.h>
23#include <stdio.h>
24#include <errno.h>
25#include <locale.h>
26#include <float.h>
27
28#include <winpr/sysinfo.h>
29#include <winpr/cast.h>
30
31#include <freerdp/client/cmdline.h>
32#include <freerdp/channels/channels.h>
33#include <freerdp/gdi/gdi.h>
34#include <freerdp/client.h>
35#include <freerdp/utils/signal.h>
36#include <freerdp/locale/keyboard.h>
37
38#include <linux/input.h>
39
40#include <uwac/uwac.h>
41
42#include "wlfreerdp.h"
43#include "wlf_input.h"
44#include "wlf_cliprdr.h"
45#include "wlf_disp.h"
46#include "wlf_channels.h"
47#include "wlf_pointer.h"
48
49#define TAG CLIENT_TAG("wayland")
50
51static BOOL wl_update_buffer(wlfContext* context_w, INT32 ix, INT32 iy, INT32 iw, INT32 ih)
52{
53 BOOL res = FALSE;
54 rdpGdi* gdi = nullptr;
55 char* data = nullptr;
56 UwacSize geometry = WINPR_C_ARRAY_INIT;
57 size_t stride = 0;
58 UwacReturnCode rc = UWAC_ERROR_INTERNAL;
59 RECTANGLE_16 area = WINPR_C_ARRAY_INIT;
60
61 if (!context_w)
62 return FALSE;
63
64 if ((ix < 0) || (iy < 0) || (iw < 0) || (ih < 0))
65 return FALSE;
66
67 EnterCriticalSection(&context_w->critical);
68 UINT32 x = WINPR_ASSERTING_INT_CAST(UINT16, ix);
69 UINT32 y = WINPR_ASSERTING_INT_CAST(UINT16, iy);
70 UINT32 w = WINPR_ASSERTING_INT_CAST(UINT16, iw);
71 UINT32 h = WINPR_ASSERTING_INT_CAST(UINT16, ih);
72 rc = UwacWindowGetDrawingBufferGeometry(context_w->window, &geometry, &stride);
73 data = UwacWindowGetDrawingBuffer(context_w->window);
74
75 if (!data || (rc != UWAC_SUCCESS))
76 goto fail;
77
78 gdi = context_w->common.context.gdi;
79
80 if (!gdi)
81 goto fail;
82
83 /* Ignore output if the surface size does not match. */
84 if (((INT64)x > geometry.width) || ((INT64)y > geometry.height))
85 {
86 res = TRUE;
87 goto fail;
88 }
89
90 area.left = WINPR_ASSERTING_INT_CAST(UINT16, x);
91 area.top = WINPR_ASSERTING_INT_CAST(UINT16, y);
92 area.right = WINPR_ASSERTING_INT_CAST(UINT16, x + w);
93 area.bottom = WINPR_ASSERTING_INT_CAST(UINT16, y + h);
94
95 if (!wlf_copy_image(
96 gdi->primary_buffer, gdi->stride, WINPR_ASSERTING_INT_CAST(size_t, gdi->width),
97 WINPR_ASSERTING_INT_CAST(size_t, gdi->height), data, stride,
98 WINPR_ASSERTING_INT_CAST(size_t, geometry.width),
99 WINPR_ASSERTING_INT_CAST(size_t, geometry.height), &area,
100 freerdp_settings_get_bool(context_w->common.context.settings, FreeRDP_SmartSizing)))
101 goto fail;
102
103 if (!wlf_scale_coordinates(&context_w->common.context, &x, &y, FALSE))
104 goto fail;
105
106 if (!wlf_scale_coordinates(&context_w->common.context, &w, &h, FALSE))
107 goto fail;
108
109 if (UwacWindowAddDamage(context_w->window, x, y, w, h) != UWAC_SUCCESS)
110 goto fail;
111
112 if (UwacWindowSubmitBuffer(context_w->window, false) != UWAC_SUCCESS)
113 goto fail;
114
115 res = TRUE;
116fail:
117 LeaveCriticalSection(&context_w->critical);
118 return res;
119}
120
121static BOOL wl_end_paint(rdpContext* context)
122{
123 if (!context || !context->gdi || !context->gdi->primary)
124 return FALSE;
125
126 rdpGdi* gdi = context->gdi;
127 HGDI_DC hdc = gdi->primary->hdc;
128 WINPR_ASSERT(hdc);
129 if (!hdc->hwnd)
130 return TRUE;
131
132 HGDI_WND hwnd = hdc->hwnd;
133 WINPR_ASSERT(hwnd->invalid || (hwnd->ninvalid == 0));
134
135 if (hwnd->invalid->null)
136 return TRUE;
137
138 const INT32 x = hwnd->invalid->x;
139 const INT32 y = hwnd->invalid->y;
140 const INT32 w = hwnd->invalid->w;
141 const INT32 h = hwnd->invalid->h;
142 wlfContext* context_w = (wlfContext*)context;
143 if (!wl_update_buffer(context_w, x, y, w, h))
144 {
145 return FALSE;
146 }
147
148 hwnd->invalid->null = TRUE;
149 hwnd->ninvalid = 0;
150 return TRUE;
151}
152
153static BOOL wl_refresh_display(wlfContext* context)
154{
155 rdpGdi* gdi = nullptr;
156
157 if (!context || !context->common.context.gdi)
158 return FALSE;
159
160 gdi = context->common.context.gdi;
161 return wl_update_buffer(context, 0, 0, gdi->width, gdi->height);
162}
163
164static BOOL wl_resize_display(rdpContext* context)
165{
166 wlfContext* wlc = (wlfContext*)context;
167 rdpGdi* gdi = context->gdi;
168 rdpSettings* settings = context->settings;
169
170 if (!gdi_resize(gdi, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
171 freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
172 return FALSE;
173
174 return wl_refresh_display(wlc);
175}
176
177static BOOL wl_pre_connect(freerdp* instance)
178{
179 rdpSettings* settings = nullptr;
180 wlfContext* context = nullptr;
181 const UwacOutput* output = nullptr;
182 UwacSize resolution;
183
184 if (!instance)
185 return FALSE;
186
187 context = (wlfContext*)instance->context;
188 WINPR_ASSERT(context);
189
190 settings = instance->context->settings;
191 WINPR_ASSERT(settings);
192
193 if (!freerdp_settings_set_bool(settings, FreeRDP_CertificateCallbackPreferPEM, TRUE))
194 return FALSE;
195
196 if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMajorType, OSMAJORTYPE_UNIX))
197 return FALSE;
198 if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMinorType, OSMINORTYPE_NATIVE_WAYLAND))
199 return FALSE;
200 if (PubSub_SubscribeChannelConnected(instance->context->pubSub,
201 wlf_OnChannelConnectedEventHandler) < 0)
202 return FALSE;
203 if (PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
204 wlf_OnChannelDisconnectedEventHandler) < 0)
205 return FALSE;
206
207 if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
208 {
209 // Use the resolution of the first display output
210 output = UwacDisplayGetOutput(context->display, 0);
211
212 if ((output != nullptr) && (UwacOutputGetResolution(output, &resolution) == UWAC_SUCCESS))
213 {
214 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth,
215 (UINT32)resolution.width))
216 return FALSE;
217 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight,
218 (UINT32)resolution.height))
219 return FALSE;
220 }
221 else
222 {
223 WLog_WARN(TAG, "Failed to get output resolution! Check your display settings");
224 }
225 }
226
227 return TRUE;
228}
229
230static BOOL wl_post_connect(freerdp* instance)
231{
232 if (!instance || !instance->context)
233 return FALSE;
234
235 wlfContext* context = (wlfContext*)instance->context;
236 WINPR_ASSERT(context);
237
238 rdpSettings* settings = instance->context->settings;
239 WINPR_ASSERT(settings);
240
241 const char* title = "FreeRDP";
242 const char* wtitle = freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
243 if (wtitle)
244 title = wtitle;
245
246 const char* app_id = "wlfreerdp";
247 const char* wmclass = freerdp_settings_get_string(settings, FreeRDP_WmClass);
248 if (wmclass)
249 app_id = wmclass;
250
251 if (!gdi_init(instance, PIXEL_FORMAT_BGRA32))
252 return FALSE;
253
254 rdpGdi* gdi = instance->context->gdi;
255
256 if (!gdi || (gdi->width < 0) || (gdi->height < 0))
257 return FALSE;
258
259 if (!wlf_register_pointer(instance->context->graphics))
260 return FALSE;
261
262 UINT32 w = (UINT32)gdi->width;
263 UINT32 h = (UINT32)gdi->height;
264
265 if (freerdp_settings_get_bool(settings, FreeRDP_SmartSizing) && !context->fullscreen)
266 {
267 const UINT32 sw = freerdp_settings_get_uint32(settings, FreeRDP_SmartSizingWidth);
268 if (sw > 0)
269 w = sw;
270
271 const UINT32 sh = freerdp_settings_get_uint32(settings, FreeRDP_SmartSizingHeight);
272 if (sh > 0)
273 h = sh;
274 }
275
276 context->window = UwacCreateWindowShm(context->display, w, h, WL_SHM_FORMAT_XRGB8888);
277
278 if (!context->window)
279 return FALSE;
280
281 UwacWindowSetFullscreenState(
282 context->window, nullptr,
283 freerdp_settings_get_bool(instance->context->settings, FreeRDP_Fullscreen));
284 UwacWindowSetTitle(context->window, title);
285 UwacWindowSetAppId(context->window, app_id);
286 UwacWindowSetOpaqueRegion(context->window, 0, 0, w, h);
287 instance->context->update->EndPaint = wl_end_paint;
288 instance->context->update->DesktopResize = wl_resize_display;
289 const char* KeyboardRemappingList =
290 freerdp_settings_get_string(instance->context->settings, FreeRDP_KeyboardRemappingList);
291
292 context->remap_table = freerdp_keyboard_remap_string_to_list(KeyboardRemappingList);
293 if (!context->remap_table)
294 return FALSE;
295
296 if (!(context->disp = wlf_disp_new(context)))
297 return FALSE;
298
299 context->clipboard = wlf_clipboard_new(context);
300
301 if (!context->clipboard)
302 return FALSE;
303
304 return wl_refresh_display(context);
305}
306
307static void wl_post_disconnect(freerdp* instance)
308{
309 if (!instance)
310 return;
311
312 if (!instance->context)
313 return;
314
315 wlfContext* context = (wlfContext*)instance->context;
316 gdi_free(instance);
317 wlf_clipboard_free(context->clipboard);
318 wlf_disp_free(context->disp);
319
320 if (context->window)
321 UwacDestroyWindow(&context->window);
322 freerdp_keyboard_remap_free(context->remap_table);
323 context->remap_table = nullptr;
324}
325
326static BOOL handle_uwac_events(freerdp* instance, UwacDisplay* display)
327{
328 UwacEvent event;
329 wlfContext* context = nullptr;
330
331 if (UwacDisplayDispatch(display, 1) < 0)
332 return FALSE;
333
334 context = (wlfContext*)instance->context;
335
336 while (UwacHasEvent(display))
337 {
338 if (UwacNextEvent(display, &event) != UWAC_SUCCESS)
339 return FALSE;
340
341 /*printf("UWAC event type %d\n", event.type);*/
342 switch (event.type)
343 {
344 case UWAC_EVENT_NEW_SEAT:
345 context->seat = event.seat_new.seat;
346 break;
347
348 case UWAC_EVENT_REMOVED_SEAT:
349 context->seat = nullptr;
350 break;
351
352 case UWAC_EVENT_FRAME_DONE:
353 {
354 EnterCriticalSection(&context->critical);
355 UwacReturnCode r = UwacWindowSubmitBuffer(context->window, false);
356 LeaveCriticalSection(&context->critical);
357 if (r != UWAC_SUCCESS)
358 return FALSE;
359 }
360 break;
361
362 case UWAC_EVENT_POINTER_ENTER:
363 if (!wlf_handle_pointer_enter(instance, &event.mouse_enter_leave))
364 return FALSE;
365
366 break;
367
368 case UWAC_EVENT_POINTER_MOTION:
369 if (!wlf_handle_pointer_motion(instance, &event.mouse_motion))
370 return FALSE;
371
372 break;
373
374 case UWAC_EVENT_POINTER_BUTTONS:
375 if (!wlf_handle_pointer_buttons(instance, &event.mouse_button))
376 return FALSE;
377
378 break;
379
380 case UWAC_EVENT_POINTER_AXIS:
381 if (!wlf_handle_pointer_axis(instance, &event.mouse_axis))
382 return FALSE;
383 break;
384
385 case UWAC_EVENT_POINTER_AXIS_DISCRETE:
386 if (!wlf_handle_pointer_axis_discrete(instance, &event.mouse_axis))
387 return FALSE;
388 break;
389
390 case UWAC_EVENT_POINTER_FRAME:
391 if (!wlf_handle_pointer_frame(instance, &event.mouse_frame))
392 return FALSE;
393 break;
394 case UWAC_EVENT_POINTER_SOURCE:
395 if (!wlf_handle_pointer_source(instance, &event.mouse_source))
396 return FALSE;
397 break;
398
399 case UWAC_EVENT_KEY:
400 if (!wlf_handle_key(instance, &event.key))
401 return FALSE;
402
403 break;
404
405 case UWAC_EVENT_TOUCH_UP:
406 if (!wlf_handle_touch_up(instance, &event.touchUp))
407 return FALSE;
408
409 break;
410
411 case UWAC_EVENT_TOUCH_DOWN:
412 if (!wlf_handle_touch_down(instance, &event.touchDown))
413 return FALSE;
414
415 break;
416
417 case UWAC_EVENT_TOUCH_MOTION:
418 if (!wlf_handle_touch_motion(instance, &event.touchMotion))
419 return FALSE;
420
421 break;
422
423 case UWAC_EVENT_KEYBOARD_ENTER:
424 if (freerdp_settings_get_bool(instance->context->settings, FreeRDP_GrabKeyboard))
425 UwacSeatInhibitShortcuts(event.keyboard_enter_leave.seat, true);
426
427 if (!wlf_keyboard_enter(instance, &event.keyboard_enter_leave))
428 return FALSE;
429
430 break;
431
432 case UWAC_EVENT_KEYBOARD_MODIFIERS:
433 if (!wlf_keyboard_modifiers(instance, &event.keyboard_modifiers))
434 return FALSE;
435
436 break;
437
438 case UWAC_EVENT_CONFIGURE:
439 if (!wlf_disp_handle_configure(context->disp, event.configure.width,
440 event.configure.height))
441 return FALSE;
442
443 if (!wl_refresh_display(context))
444 return FALSE;
445
446 break;
447
448 case UWAC_EVENT_CLIPBOARD_AVAILABLE:
449 case UWAC_EVENT_CLIPBOARD_OFFER:
450 case UWAC_EVENT_CLIPBOARD_SELECT:
451 if (!wlf_cliprdr_handle_event(context->clipboard, &event.clipboard))
452 return FALSE;
453
454 break;
455
456 case UWAC_EVENT_CLOSE:
457 context->closed = TRUE;
458
459 break;
460
461 default:
462 break;
463 }
464 }
465
466 return TRUE;
467}
468
469static BOOL handle_window_events(freerdp* instance)
470{
471 return instance != nullptr;
472}
473
474static int wlfreerdp_run(freerdp* instance)
475{
476 wlfContext* context = nullptr;
477 HANDLE handles[MAXIMUM_WAIT_OBJECTS] = WINPR_C_ARRAY_INIT;
478 DWORD status = WAIT_ABANDONED;
479
480 if (!instance)
481 return -1;
482
483 context = (wlfContext*)instance->context;
484
485 if (!context)
486 return -1;
487
488 if (!freerdp_connect(instance))
489 {
490 WLog_Print(context->log, WLOG_ERROR, "Failed to connect");
491 return -1;
492 }
493
494 while (!freerdp_shall_disconnect_context(instance->context))
495 {
496 DWORD count = 0;
497 handles[count++] = context->displayHandle;
498 count += freerdp_get_event_handles(instance->context, &handles[count],
499 ARRAYSIZE(handles) - count);
500
501 if (count <= 2)
502 {
503 WLog_Print(context->log, WLOG_ERROR, "Failed to get FreeRDP file descriptor");
504 break;
505 }
506
507 status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
508
509 if (WAIT_FAILED == status)
510 {
511 WLog_Print(context->log, WLOG_ERROR, "WaitForMultipleObjects failed");
512 break;
513 }
514
515 if (!handle_uwac_events(instance, context->display))
516 {
517 WLog_Print(context->log, WLOG_ERROR, "error handling UWAC events");
518 break;
519 }
520
521 if (context->closed)
522 {
523 WLog_Print(context->log, WLOG_INFO, "Closed from Wayland");
524 break;
525 }
526
527 if (freerdp_check_event_handles(instance->context) != TRUE)
528 {
529 if (client_auto_reconnect_ex(instance, handle_window_events))
530 continue;
531 else
532 {
533 /*
534 * Indicate an unsuccessful connection attempt if reconnect
535 * did not succeed and no other error was specified.
536 */
537 if (freerdp_error_info(instance) == 0)
538 status = 42;
539 }
540
541 if (freerdp_get_last_error(instance->context) == FREERDP_ERROR_SUCCESS)
542 WLog_Print(context->log, WLOG_ERROR, "Failed to check FreeRDP file descriptor");
543
544 break;
545 }
546 }
547
548 freerdp_disconnect(instance);
549 return WINPR_ASSERTING_INT_CAST(int, status);
550}
551
552static BOOL wlf_client_global_init(void)
553{
554 // NOLINTNEXTLINE(concurrency-mt-unsafe)
555 (void)setlocale(LC_ALL, "");
556
557 return (freerdp_handle_signals() == 0);
558}
559
560static void wlf_client_global_uninit(void)
561{
562}
563
564static int wlf_logon_error_info(freerdp* instance, UINT32 data, UINT32 type)
565{
566 wlfContext* wlf = nullptr;
567 const char* str_data = freerdp_get_logon_error_info_data(data);
568 const char* str_type = freerdp_get_logon_error_info_type(type);
569
570 if (!instance || !instance->context)
571 return -1;
572
573 wlf = (wlfContext*)instance->context;
574 WLog_Print(wlf->log, WLOG_INFO, "Logon Error Info %s [%s]", str_data, str_type);
575 return 1;
576}
577
578static void wlf_client_free(freerdp* instance, rdpContext* context)
579{
580 wlfContext* wlf = (wlfContext*)instance->context;
581
582 if (!context)
583 return;
584
585 if (wlf->display)
586 UwacCloseDisplay(&wlf->display);
587
588 if (wlf->displayHandle)
589 (void)CloseHandle(wlf->displayHandle);
590 ArrayList_Free(wlf->events);
591 DeleteCriticalSection(&wlf->critical);
592}
593
594static void* uwac_event_clone(const void* val)
595{
596 UwacEvent* copy = nullptr;
597 const UwacEvent* ev = (const UwacEvent*)val;
598
599 copy = calloc(1, sizeof(UwacEvent));
600 if (!copy)
601 return nullptr;
602 *copy = *ev;
603 return copy;
604}
605
606static BOOL wlf_client_new(freerdp* instance, rdpContext* context)
607{
608 wObject* obj = nullptr;
609 UwacReturnCode status = UWAC_ERROR_INTERNAL;
610 wlfContext* wfl = (wlfContext*)context;
611
612 if (!instance || !context)
613 return FALSE;
614
615 instance->PreConnect = wl_pre_connect;
616 instance->PostConnect = wl_post_connect;
617 instance->PostDisconnect = wl_post_disconnect;
618 instance->LogonErrorInfo = wlf_logon_error_info;
619 wfl->log = WLog_Get(TAG);
620 wfl->display = UwacOpenDisplay(nullptr, &status);
621
622 if (!wfl->display || (status != UWAC_SUCCESS) || !wfl->log)
623 return FALSE;
624
625 wfl->displayHandle = CreateFileDescriptorEvent(nullptr, FALSE, FALSE,
626 UwacDisplayGetFd(wfl->display), WINPR_FD_READ);
627
628 if (!wfl->displayHandle)
629 return FALSE;
630
631 wfl->events = ArrayList_New(FALSE);
632 if (!wfl->events)
633 return FALSE;
634
635 obj = ArrayList_Object(wfl->events);
636 obj->fnObjectNew = uwac_event_clone;
637 obj->fnObjectFree = free;
638
639 InitializeCriticalSection(&wfl->critical);
640
641 return TRUE;
642}
643
644static int wfl_client_start(rdpContext* context)
645{
646 WINPR_UNUSED(context);
647 return 0;
648}
649
650static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
651{
652 WINPR_ASSERT(pEntryPoints);
653 ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
654 pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION;
655 pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
656 pEntryPoints->GlobalInit = wlf_client_global_init;
657 pEntryPoints->GlobalUninit = wlf_client_global_uninit;
658 pEntryPoints->ContextSize = sizeof(wlfContext);
659 pEntryPoints->ClientNew = wlf_client_new;
660 pEntryPoints->ClientFree = wlf_client_free;
661 pEntryPoints->ClientStart = wfl_client_start;
662 pEntryPoints->ClientStop = freerdp_client_common_stop;
663 return 0;
664}
665
666int main(int argc, char* argv[])
667{
668 int rc = -1;
669 int status = 0;
670 RDP_CLIENT_ENTRY_POINTS clientEntryPoints;
671 rdpContext* context = nullptr;
672 rdpSettings* settings = nullptr;
673 wlfContext* wlc = nullptr;
674
675 freerdp_client_warn_deprecated(argc, argv);
676
677 RdpClientEntry(&clientEntryPoints);
678 context = freerdp_client_context_new(&clientEntryPoints);
679 if (!context)
680 goto fail;
681 wlc = (wlfContext*)context;
682 settings = context->settings;
683
684 status = freerdp_client_settings_parse_command_line(settings, argc, argv, FALSE);
685 if (status)
686 {
687 rc = freerdp_client_settings_command_line_status_print(settings, status, argc, argv);
688
689 if (freerdp_settings_get_bool(settings, FreeRDP_ListMonitors))
690 wlf_list_monitors(wlc);
691
692 goto fail;
693 }
694
695 if (freerdp_client_start(context) != 0)
696 goto fail;
697
698 rc = wlfreerdp_run(context->instance);
699
700 if (freerdp_client_stop(context) != 0)
701 rc = -1;
702
703fail:
704 freerdp_client_context_free(context);
705 return rc;
706}
707
708BOOL wlf_copy_image(const void* src, size_t srcStride, size_t srcWidth, size_t srcHeight, void* dst,
709 size_t dstStride, size_t dstWidth, size_t dstHeight, const RECTANGLE_16* area,
710 BOOL scale)
711{
712 BOOL rc = FALSE;
713
714 if (!src || !dst || !area)
715 return FALSE;
716
717 if (scale)
718 {
719 WINPR_ASSERT(dstStride <= UINT32_MAX);
720 WINPR_ASSERT(dstWidth <= UINT32_MAX);
721 WINPR_ASSERT(dstHeight <= UINT32_MAX);
722 WINPR_ASSERT(srcStride <= UINT32_MAX);
723 WINPR_ASSERT(srcWidth <= UINT32_MAX);
724 WINPR_ASSERT(srcHeight <= UINT32_MAX);
725 return freerdp_image_scale(dst, PIXEL_FORMAT_BGRA32, (UINT32)dstStride, 0, 0,
726 (UINT32)dstWidth, (UINT32)dstHeight, src, PIXEL_FORMAT_BGRA32,
727 (UINT32)srcStride, 0, 0, (UINT32)srcWidth, (UINT32)srcHeight);
728 }
729 else
730 {
731 const size_t baseSrcOffset = 1ULL * area->top * srcStride + 4ULL * area->left;
732 const size_t baseDstOffset = 1ULL * area->top * dstStride + 4ULL * area->left;
733 const size_t width = MIN((size_t)area->right - area->left, dstWidth - area->left);
734 const size_t height = MIN((size_t)area->bottom - area->top, dstHeight - area->top);
735 const BYTE* psrc = (const BYTE*)src;
736 BYTE* pdst = (BYTE*)dst;
737
738 for (size_t i = 0; i < height; i++)
739 {
740 const size_t srcOffset = i * srcStride + baseSrcOffset;
741 const size_t dstOffset = i * dstStride + baseDstOffset;
742 memcpy(&pdst[dstOffset], &psrc[srcOffset], width * 4);
743 }
744
745 rc = TRUE;
746 }
747
748 return rc;
749}
750
751BOOL wlf_scale_coordinates(rdpContext* context, UINT32* px, UINT32* py, BOOL fromLocalToRDP)
752{
753 wlfContext* wlf = (wlfContext*)context;
754 UwacSize geometry = WINPR_C_ARRAY_INIT;
755
756 if (!context || !px || !py || !context->gdi)
757 return FALSE;
758
759 if (!freerdp_settings_get_bool(context->settings, FreeRDP_SmartSizing))
760 return TRUE;
761
762 rdpGdi* gdi = context->gdi;
763
764 if (UwacWindowGetDrawingBufferGeometry(wlf->window, &geometry, nullptr) != UWAC_SUCCESS)
765 return FALSE;
766
767 const double sx = 1.0 * geometry.width / (double)gdi->width;
768 const double sy = 1.0 * geometry.height / (double)gdi->height;
769
770 if (!fromLocalToRDP)
771 {
772 *px *= (UINT32)lround(sx);
773 *py *= (UINT32)lround(sy);
774 }
775 else
776 {
777 *px /= (UINT32)lround(sx);
778 *py /= (UINT32)lround(sy);
779 }
780
781 return TRUE;
782}
freerdp_settings_set_uint32
FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 val)
Sets a UINT32 settings value.
freerdp_settings_set_bool
FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL val)
Sets a BOOL settings value.
freerdp_settings_get_string
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
GDI_DC
Definition include/freerdp/gdi/gdi.h:458
GDI_WND
Definition include/freerdp/gdi/gdi.h:449
RECTANGLE_16
Definition types.h:109
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:58
wObject::fnObjectNew
OBJECT_NEW_FN fnObjectNew
Definition collections.h:53