mirrors
/
weston
mirror of https://gitlab.freedesktop.org/wayland/weston.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rdp: Add preliminary rdp multihead support 

This sets up monitor layout callbacks, and enables input event translation
between the RDP space and the weston desktop. The RDP backend now uses
a heads changed callback instead of the simple head configurator.

We only allow a single monitor for now, but in the future RAIL will make
use of multi-head.

As a side effect, scaling is now supported in RDP sessions.

It should be noted that due to differences between RDP and wayland
representation of their global coordinate spaces, mixing DPI leads to
RDP monitor layouts that can't properly be represented in weston.

Co-authored-by: Steve Pronovost <spronovo@microsoft.com>
Co-authored-by: Brenton DeGeer <brdegeer@microsoft.com>
Signed-off-by: Hideyuki Nagase <hideyukn@microsoft.com>
Signed-off-by: Steve Pronovost <spronovo@microsoft.com>
Signed-off-by: Brenton DeGeer <brdegeer@microsoft.com>
This commit is contained in:
Hideyuki Nagase 2022-08-09 13:52:51 -05:00 committed by Daniel Stone
parent 8a2d961b92
commit 70b03b2928
6 changed files with 653 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
compositor/main.c
View File

@ -3070,40 +3070,6 @@ load_headless_backend(struct weston_compositor *c,
return 0;
}
static int
rdp_backend_output_configure(struct weston_output *output)
{
struct wet_compositor *compositor = to_wet_compositor(output->compositor);
struct wet_output_config *parsed_options = compositor->parsed_options;
const struct weston_rdp_output_api *api = weston_rdp_output_get_api(output->compositor);
int width = 640;
int height = 480;
assert(parsed_options);
if (!api) {
weston_log("Cannot use weston_rdp_output_api.\n");
return -1;
}
if (parsed_options->width)
width = parsed_options->width;
if (parsed_options->height)
height = parsed_options->height;
weston_output_set_scale(output, 1);
weston_output_set_transform(output, WL_OUTPUT_TRANSFORM_NORMAL);
if (api->output_set_size(output, width, height) < 0) {
weston_log("Cannot configure output \"%s\" using weston_rdp_output_api.\n",
output->name);
return -1;
}
return 0;
}
static void
weston_rdp_backend_config_init(struct weston_rdp_backend_config *config)
{
@ -3124,6 +3090,83 @@ weston_rdp_backend_config_init(struct weston_rdp_backend_config *config)
config->refresh_rate = RDP_DEFAULT_FREQ;
}
static void
rdp_handle_layout(struct weston_compositor *ec)
{
struct wet_compositor *wc = to_wet_compositor(ec);
struct wet_output_config *parsed_options = wc->parsed_options;
const struct weston_rdp_output_api *api = weston_rdp_output_get_api(ec);
struct weston_rdp_monitor config;
struct weston_head *head = NULL;
int width;
int height;
int scale = 1;
while ((head = weston_compositor_iterate_heads(ec, head))) {
struct weston_output *output = head->output;
struct weston_mode new_mode = {};
assert(output);
api->head_get_monitor(head, &config);
width = config.width;
height = config.height;
scale = config.desktop_scale / 100;
/* If these are invalid, the backend is expecting
* us to provide defaults.
*/
width = width ? width : parsed_options->width;
height = height ? height : parsed_options->height;
scale = scale ? scale : parsed_options->scale;
/* Fallback to 640 x 480 if we have nothing to use */
width = width ? width : 640;
height = height ? height : 480;
scale = scale ? scale : 1;
new_mode.width = width;
new_mode.height = height;
api->output_set_mode(output, &new_mode);
weston_output_set_scale(output, scale);
weston_output_set_transform(output,
WL_OUTPUT_TRANSFORM_NORMAL);
weston_output_move(output, config.x, config.y);
}
}
static void
rdp_heads_changed(struct wl_listener *listener, void *arg)
{
struct weston_compositor *compositor = arg;
struct wet_compositor *wet = to_wet_compositor(compositor);
struct weston_head *head = NULL;
while ((head = weston_compositor_iterate_heads(compositor, head))) {
if (head->output)
continue;
struct weston_output *out;
out = weston_compositor_create_output(compositor,
head, head->name);
wet_head_tracker_create(wet, head);
weston_output_attach_head(out, head);
}
rdp_handle_layout(compositor);
while ((head = weston_compositor_iterate_heads(compositor, head))) {
if (!head->output->enabled)
weston_output_enable(head->output);
weston_head_reset_device_changed(head);
}
}
static int
load_rdp_backend(struct weston_compositor *c,
int *argc, char *argv[], struct weston_config *wc,
@ -3133,8 +3176,9 @@ load_rdp_backend(struct weston_compositor *c,
struct weston_config_section *section;
int ret = 0;
bool no_remotefx_codec = false;
struct wet_output_config *parsed_options = wet_init_parsed_options(c);
struct wet_compositor *wet = to_wet_compositor(c);
if (!parsed_options)
return -1;
@ -3151,6 +3195,7 @@ load_rdp_backend(struct weston_compositor *c,
{ WESTON_OPTION_STRING, "rdp4-key", 0, &config.rdp_key },
{ WESTON_OPTION_STRING, "rdp-tls-cert", 0, &config.server_cert },
{ WESTON_OPTION_STRING, "rdp-tls-key", 0, &config.server_key },
{ WESTON_OPTION_INTEGER, "scale", 0, &parsed_options->scale },
{ WESTON_OPTION_BOOLEAN, "force-no-compression", 0, &config.force_no_compression },
{ WESTON_OPTION_BOOLEAN, "no-remotefx-codec", 0, &no_remotefx_codec },
};
@ -3159,12 +3204,15 @@ load_rdp_backend(struct weston_compositor *c,
config.remotefx_codec = !no_remotefx_codec;
config.renderer = renderer;
wet_set_simple_head_configurator(c, rdp_backend_output_configure);
section = weston_config_get_section(wc, "rdp", NULL, NULL);
weston_config_section_get_int(section, "refresh-rate",
&config.refresh_rate,
RDP_DEFAULT_FREQ);
wet->heads_changed_listener.notify = rdp_heads_changed;
weston_compositor_add_heads_changed_listener(c,
&wet->heads_changed_listener);
ret = weston_compositor_load_backend(c, WESTON_BACKEND_RDP,
&config.base);

22
include/libweston/backend-rdp.h
View File

@ -33,16 +33,26 @@ extern "C" {
#include <libweston/libweston.h>
#include <libweston/plugin-registry.h>
#define WESTON_RDP_OUTPUT_API_NAME "weston_rdp_output_api_v1"
#define WESTON_RDP_OUTPUT_API_NAME "weston_rdp_output_api_v2"
#define RDP_DEFAULT_FREQ 60
struct weston_rdp_monitor {
int32_t x;
int32_t y;
int32_t width;
int32_t height;
uint32_t desktop_scale;
};
struct weston_rdp_output_api {
/** Initialize a RDP output with specified width and height.
*
* Returns 0 on success, -1 on failure.
/** Get config from RDP client when connected
*/
int (*output_set_size)(struct weston_output *output,
int width, int height);
void (*head_get_monitor)(struct weston_head *head,
struct weston_rdp_monitor *monitor);
/** Set mode for an output */
void (*output_set_mode)(struct weston_output *base,
struct weston_mode *mode);
};
static inline const struct weston_rdp_output_api *

1
libweston/backend-rdp/meson.build
View File

@ -28,6 +28,7 @@ deps_rdp = [
srcs_rdp = [
'rdp.c',
'rdpclip.c',
'rdpdisp.c',
'rdputil.c',
]

256
libweston/backend-rdp/rdp.c
View File

@ -54,6 +54,9 @@
extern PWtsApiFunctionTable FreeRDP_InitWtsApi(void);
static BOOL
xf_peer_adjust_monitor_layout(freerdp_peer *client);
static struct rdp_output *
rdp_get_first_output(struct rdp_backend *b)
{
@ -378,80 +381,78 @@ ensure_single_mode(struct weston_output *output, struct weston_mode *target)
return new_mode;
}
static int
rdp_switch_mode(struct weston_output *output, struct weston_mode *target_mode)
static void
rdp_output_set_mode(struct weston_output *base, struct weston_mode *mode)
{
struct rdp_output *rdpOutput = container_of(output, struct rdp_output, base);
struct rdp_backend *rdpBackend = to_rdp_backend(output->compositor);
struct rdp_output *rdpOutput = container_of(base, struct rdp_output, base);
struct rdp_backend *b = to_rdp_backend(base->compositor);
struct weston_mode *cur;
struct weston_output *output = base;
struct rdp_peers_item *rdpPeer;
rdpSettings *settings;
pixman_image_t *new_shadow_buffer;
struct weston_mode *local_mode;
assert(output);
mode->refresh = b->rdp_monitor_refresh_rate;
cur = ensure_single_mode(base, mode);
local_mode = ensure_single_mode(output, target_mode);
if (local_mode == output->current_mode)
return 0;
base->current_mode = cur;
base->native_mode = cur;
if (base->enabled) {
weston_renderer_resize_output(output, &(struct weston_size){
.width = output->current_mode->width,
.height = output->current_mode->height }, NULL);
output->current_mode = local_mode;
output->current_mode->flags |= WL_OUTPUT_MODE_CURRENT;
new_shadow_buffer = pixman_image_create_bits(PIXMAN_x8r8g8b8, mode->width,
mode->height, 0, mode->width * 4);
pixman_image_composite32(PIXMAN_OP_SRC, rdpOutput->shadow_surface, 0, new_shadow_buffer,
0, 0, 0, 0, 0, 0, mode->width, mode->height);
pixman_image_unref(rdpOutput->shadow_surface);
rdpOutput->shadow_surface = new_shadow_buffer;
}
weston_renderer_resize_output(output, &(struct weston_size){
.width = output->current_mode->width,
.height = output->current_mode->height }, NULL);
new_shadow_buffer = pixman_image_create_bits(PIXMAN_x8r8g8b8, target_mode->width,
target_mode->height, 0, target_mode->width * 4);
pixman_image_composite32(PIXMAN_OP_SRC, rdpOutput->shadow_surface, 0, new_shadow_buffer,
0, 0, 0, 0, 0, 0, target_mode->width, target_mode->height);
pixman_image_unref(rdpOutput->shadow_surface);
rdpOutput->shadow_surface = new_shadow_buffer;
wl_list_for_each(rdpPeer, &rdpBackend->peers, link) {
/* Apparently settings->DesktopWidth is supposed to be primary only.
* For now we only work with a single monitor, so we don't need to
* check that we're primary here.
*/
wl_list_for_each(rdpPeer, &b->peers, link) {
settings = rdpPeer->peer->context->settings;
if (settings->DesktopWidth == (UINT32)target_mode->width &&
settings->DesktopHeight == (UINT32)target_mode->height)
if (settings->DesktopWidth == (uint32_t)mode->width &&
settings->DesktopHeight == (uint32_t)mode->height)
continue;
if (!settings->DesktopResize) {
/* too bad this peer does not support desktop resize */
weston_log("desktop resize is not allowed\n");
rdpPeer->peer->Close(rdpPeer->peer);
} else {
settings->DesktopWidth = target_mode->width;
settings->DesktopHeight = target_mode->height;
settings->DesktopWidth = mode->width;
settings->DesktopHeight = mode->height;
rdpPeer->peer->context->update->DesktopResize(rdpPeer->peer->context);
}
}
return 0;
}
static int
rdp_output_set_size(struct weston_output *base,
int width, int height)
rdp_output_switch_mode(struct weston_output *base, struct weston_mode *mode)
{
struct rdp_output *output = to_rdp_output(base);
struct rdp_backend *rdpBackend = to_rdp_backend(base->compositor);
struct weston_mode *currentMode;
struct weston_mode initMode;
assert(output);
/* We can only be called once. */
assert(!output->base.current_mode);
initMode.width = width;
initMode.height = height;
initMode.refresh = rdpBackend->rdp_monitor_refresh_rate;
currentMode = ensure_single_mode(&output->base, &initMode);
currentMode->flags |= WL_OUTPUT_MODE_CURRENT;
output->base.current_mode = output->base.native_mode = currentMode;
rdp_output_set_mode(base, mode);
return 0;
}
static void
rdp_head_get_monitor(struct weston_head *base,
struct weston_rdp_monitor *monitor)
{
struct rdp_head *h = to_rdp_head(base);
monitor->x = h->config.x;
monitor->y = h->config.y;
monitor->width = h->config.width;
monitor->height = h->config.height;
monitor->desktop_scale = h->config.attributes.desktopScaleFactor;
}
static int
rdp_output_enable(struct weston_output *base)
{
@ -536,7 +537,7 @@ rdp_output_create(struct weston_compositor *compositor, const char *name)
output->base.start_repaint_loop = rdp_output_start_repaint_loop;
output->base.repaint = rdp_output_repaint;
output->base.switch_mode = rdp_switch_mode;
output->base.switch_mode = rdp_output_switch_mode;
weston_compositor_add_pending_output(&output->base, compositor);
@ -1040,31 +1041,27 @@ xf_peer_activate(freerdp_peer* client)
peerCtx->audio_in_private = b->audio_in_setup(b->compositor, peerCtx->vcm);
}
if (output->base.width != (int)settings->DesktopWidth ||
output->base.height != (int)settings->DesktopHeight)
{
if (b->no_clients_resize) {
/* RDP peers don't dictate their resolution to weston */
/* If we don't allow resize, we need to tell the client to resize itself.
* We still need the xf_peer_adjust_monitor_layout() call to make sure
* we've set up scaling appropriately.
*/
if (b->no_clients_resize) {
struct weston_mode *mode = output->base.current_mode;
if (mode->width != (int)settings->DesktopWidth ||
mode->height != (int)settings->DesktopHeight) {
if (!settings->DesktopResize) {
/* peer does not support desktop resize */
weston_log("%s: client doesn't support resizing, closing connection\n", __FUNCTION__);
weston_log("client doesn't support resizing, closing connection\n");
return FALSE;
} else {
settings->DesktopWidth = output->base.width;
settings->DesktopHeight = output->base.height;
settings->DesktopWidth = mode->width;
settings->DesktopHeight = mode->height;
client->context->update->DesktopResize(client->context);
}
} else {
/* ask weston to adjust size */
struct weston_mode new_mode;
struct weston_mode *target_mode;
new_mode.width = (int)settings->DesktopWidth;
new_mode.height = (int)settings->DesktopHeight;
target_mode = ensure_single_mode(&output->base, &new_mode);
weston_output_mode_set_native(&output->base, target_mode, 1);
output->base.width = new_mode.width;
output->base.height = new_mode.height;
}
} else {
xf_peer_adjust_monitor_layout(client);
}
weston_output = &output->base;
@ -1144,6 +1141,36 @@ xf_peer_post_connect(freerdp_peer *client)
return TRUE;
}
static bool
rdp_translate_and_notify_mouse_position(RdpPeerContext *peerContext, UINT16 x, UINT16 y)
{
struct timespec time;
int sx, sy;
if (!peerContext->item.seat)
return FALSE;
/* (TS_POINTERX_EVENT):The xy-coordinate of the pointer relative to the top-left
* corner of the server's desktop combined all monitors */
/* first, convert the coordinate based on primary monitor's upper-left as (0,0) */
sx = x + peerContext->desktop_left;
sy = y + peerContext->desktop_top;
/* translate client's x/y to the coordinate in weston space. */
/* TODO: to_weston_coordinate() is translate based on where pointer is,
not based-on where/which window underneath. Thus, this doesn't
work when window lays across more than 2 monitors and each monitor has
different scaling. In such case, hit test to that window area on
non primary-resident monitor (surface->output) dosn't work. */
if (to_weston_coordinate(peerContext, &sx, &sy)) {
weston_compositor_get_time(&time);
notify_motion_absolute(peerContext->item.seat, &time, sx, sy);
return TRUE;
}
return FALSE;
}
static void
dump_mouseinput(RdpPeerContext *peerContext, UINT16 flags, UINT16 x, UINT16 y, bool is_ex)
{
@ -1282,7 +1309,6 @@ static BOOL
xf_mouseEvent(rdpInput *input, UINT16 flags, UINT16 x, UINT16 y)
{
RdpPeerContext *peerContext = (RdpPeerContext *)input->context;
struct rdp_output *output;
uint32_t button = 0;
bool need_frame = false;
struct timespec time;
@ -1296,13 +1322,8 @@ xf_mouseEvent(rdpInput *input, UINT16 flags, UINT16 x, UINT16 y)
* the RDP client.
*/
if (!(flags & (PTR_FLAGS_WHEEL | PTR_FLAGS_HWHEEL))) {
output = rdp_get_first_output(peerContext->rdpBackend);
if (x < output->base.width && y < output->base.height) {
weston_compositor_get_time(&time);
notify_motion_absolute(peerContext->item.seat, &time,
x, y);
if (rdp_translate_and_notify_mouse_position(peerContext, x, y))
need_frame = true;
}
}
if (flags & PTR_FLAGS_BUTTON1)
@ -1524,6 +1545,85 @@ xf_suppress_output(rdpContext *context, BYTE allow, const RECTANGLE_16 *area)
return TRUE;
}
static BOOL
xf_peer_adjust_monitor_layout(freerdp_peer *client)
{
RdpPeerContext *peerCtx = (RdpPeerContext *)client->context;
struct rdp_backend *b = peerCtx->rdpBackend;
rdpSettings *settings = client->context->settings;
rdpMonitor *monitors;
unsigned int monitor_count;
BOOL success;
bool fallback = false;
unsigned int i;
rdp_debug(b, "%s:\n", __func__);
rdp_debug(b, " DesktopWidth:%d, DesktopHeight:%d\n", settings->DesktopWidth, settings->DesktopHeight);
rdp_debug(b, " UseMultimon:%d\n", settings->UseMultimon);
rdp_debug(b, " ForceMultimon:%d\n", settings->ForceMultimon);
rdp_debug(b, " MonitorCount:%d\n", settings->MonitorCount);
rdp_debug(b, " HasMonitorAttributes:%d\n", settings->HasMonitorAttributes);
rdp_debug(b, " HiDefRemoteApp:%d\n", settings->HiDefRemoteApp);
if (settings->MonitorCount > 1) {
weston_log("multiple monitor is not supported");
fallback = true;
}
if (b->no_clients_resize)
fallback = true;
if (settings->MonitorCount > RDP_MAX_MONITOR) {
weston_log("Client reports more monitors then expected:(%d)\n",
settings->MonitorCount);
return FALSE;
}
if ((settings->MonitorCount > 0 && settings->MonitorDefArray) && !fallback) {
rdpMonitor *rdp_monitor = settings->MonitorDefArray;
monitor_count = settings->MonitorCount;
monitors = xmalloc(sizeof(*monitors) * monitor_count);
for (i = 0; i < monitor_count; i++) {
monitors[i] = rdp_monitor[i];
if (!settings->HasMonitorAttributes) {
monitors[i].attributes.physicalWidth = 0;
monitors[i].attributes.physicalHeight = 0;
monitors[i].attributes.orientation = ORIENTATION_LANDSCAPE;
monitors[i].attributes.desktopScaleFactor = 100;
monitors[i].attributes.deviceScaleFactor = 100;
}
}
} else {
monitor_count = 1;
monitors = xmalloc(sizeof(*monitors) * monitor_count);
/* when no monitor array provided, generate from desktop settings */
monitors[0].x = 0;
monitors[0].y = 0;
monitors[0].width = settings->DesktopWidth;
monitors[0].height = settings->DesktopHeight;
monitors[0].is_primary = 1;
monitors[0].attributes.physicalWidth = settings->DesktopPhysicalWidth;
monitors[0].attributes.physicalHeight = settings->DesktopPhysicalHeight;
monitors[0].attributes.orientation = settings->DesktopOrientation;
monitors[0].attributes.desktopScaleFactor = settings->DesktopScaleFactor;
monitors[0].attributes.deviceScaleFactor = settings->DeviceScaleFactor;
monitors[0].orig_screen = 0;
if (b->no_clients_resize) {
/* If we're not allowing clients to resize us, set these
* to 0 so the front end knows it needs to make something
* up.
*/
monitors[0].width = 0;
monitors[0].height = 0;
monitors[0].attributes.desktopScaleFactor = 0;
}
}
success = handle_adjust_monitor_layout(client, monitor_count, monitors);
free(monitors);
return success;
}
static int
rdp_peer_init(freerdp_peer *client, struct rdp_backend *b)
{
@ -1576,6 +1676,11 @@ rdp_peer_init(freerdp_peer *client, struct rdp_backend *b)
client->PostConnect = xf_peer_post_connect;
client->Activate = xf_peer_activate;
if (!b->no_clients_resize) {
settings->SupportMonitorLayoutPdu = TRUE;
client->AdjustMonitorsLayout = xf_peer_adjust_monitor_layout;
}
client->context->update->SuppressOutput = (pSuppressOutput)xf_suppress_output;
input = client->context->input;
@ -1648,7 +1753,8 @@ rdp_incoming_peer(freerdp_listener *instance, freerdp_peer *client)
}
static const struct weston_rdp_output_api api = {
rdp_output_set_size,
rdp_head_get_monitor,
rdp_output_set_mode,
};
static struct rdp_backend *

15
libweston/backend-rdp/rdp.h
View File

@ -50,6 +50,7 @@
#include "shared/string-helpers.h"
#define MAX_FREERDP_FDS 32
#define RDP_MAX_MONITOR 16
#define DEFAULT_AXIS_STEP_DISTANCE 10
#define DEFAULT_PIXEL_FORMAT PIXEL_FORMAT_BGRA32
@ -116,6 +117,7 @@ struct rdp_peers_item {
struct rdp_head {
struct weston_head base;
uint32_t index;
bool matched;
rdpMonitor config;
};
@ -162,6 +164,10 @@ struct rdp_peer_context {
struct rdp_clipboard_data_source *clipboard_inflight_client_data_source;
struct wl_listener clipboard_selection_listener;
/* Multiple monitor support (monitor topology) */
int32_t desktop_top, desktop_left;
int32_t desktop_width, desktop_height;
};
typedef struct rdp_peer_context RdpPeerContext;
@ -192,6 +198,15 @@ struct rdp_loop_task {
#define rdp_debug_clipboard_continue(b, ...) \
rdp_debug_print(b->clipboard_debug, true, __VA_ARGS__)
/* rdpdisp.c */
bool
handle_adjust_monitor_layout(freerdp_peer *client,
int monitor_count, rdpMonitor *monitors);
struct weston_output *
to_weston_coordinate(RdpPeerContext *peerContext,
int32_t *x, int32_t *y);
/* rdputil.c */
void
rdp_debug_print(struct weston_log_scope *log_scope, bool cont, char *fmt, ...);

356
libweston/backend-rdp/rdpdisp.c Normal file
View File

@ -0,0 +1,356 @@
/*
* Copyright © 2020 Microsoft
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include "config.h"
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <wchar.h>
#include <strings.h>
#include "rdp.h"
#include "shared/xalloc.h"
static bool
match_primary(struct rdp_backend *rdp, rdpMonitor *a, rdpMonitor *b)
{
if (a->is_primary && b->is_primary)
return true;
return false;
}
static bool
match_dimensions(struct rdp_backend *rdp, rdpMonitor *a, rdpMonitor *b)
{
int scale_a = a->attributes.desktopScaleFactor;
int scale_b = b->attributes.desktopScaleFactor;
if (a->width != b->width ||
a->height != b->height ||
scale_a != scale_b)
return false;
return true;
}
static bool
match_position(struct rdp_backend *rdp, rdpMonitor *a, rdpMonitor *b)
{
if (a->x != b->x ||
a->y != b->y)
return false;
return true;
}
static bool
match_exact(struct rdp_backend *rdp, rdpMonitor *a, rdpMonitor *b)
{
if (match_dimensions(rdp, a, b) &&
match_position(rdp, a, b))
return true;
return false;
}
static bool
match_any(struct rdp_backend *rdp, rdpMonitor *a, rdpMonitor *b)
{
return true;
}
static void
update_head(struct rdp_backend *rdp, struct rdp_head *head, rdpMonitor *config)
{
struct weston_mode mode = {};
int scale;
bool changed = false;
head->matched = true;
scale = config->attributes.desktopScaleFactor / 100;
scale = scale ? scale : 1;
if (!match_position(rdp, &head->config, config))
changed = true;
if (!match_dimensions(rdp, &head->config, config)) {
mode.flags = WL_OUTPUT_MODE_PREFERRED;
mode.width = config->width;
mode.height = config->height;
mode.refresh = rdp->rdp_monitor_refresh_rate;
weston_output_mode_set_native(head->base.output,
&mode, scale);
changed = true;
}
if (changed) {
weston_head_set_device_changed(&head->base);
}
head->config = *config;
}
static void
match_heads(struct rdp_backend *rdp, rdpMonitor *config, uint32_t count,
int *done,
bool (*cmp)(struct rdp_backend *rdp, rdpMonitor *a, rdpMonitor *b))
{
struct weston_head *iter;
struct rdp_head *current;
uint32_t i;
wl_list_for_each(iter, &rdp->compositor->head_list, compositor_link) {
current = to_rdp_head(iter);
if (current->matched)
continue;
for (i = 0; i < count; i++) {
if (*done & (1 << i))
continue;
if (cmp(rdp, &current->config, &config[i])) {
*done |= 1 << i;
update_head(rdp, current, &config[i]);
break;
}
}
}
}
static void
disp_layout_change(freerdp_peer *client, rdpMonitor *config, UINT32 monitorCount)
{
RdpPeerContext *peerCtx = (RdpPeerContext *)client->context;
struct rdp_backend *b = peerCtx->rdpBackend;
struct rdp_head *current;
struct weston_head *iter, *tmp;
pixman_region32_t desktop;
int done = 0;
assert_compositor_thread(b);
pixman_region32_init(&desktop);
/* Prune heads that were never enabled, and flag heads as unmatched */
wl_list_for_each_safe(iter, tmp, &b->compositor->head_list, compositor_link) {
current = to_rdp_head(iter);
if (!iter->output) {
rdp_head_destroy(iter);
continue;
}
current->matched = false;
}
/* We want the primary head to remain primary - it
* should always be rdp-0.
*/
match_heads(b, config, monitorCount, &done, match_primary);
/* Look for any exact match */
match_heads(b, config, monitorCount, &done, match_exact);
/* Match first head with the same dimensions */
match_heads(b, config, monitorCount, &done, match_dimensions);
/* Match head with the same position */
match_heads(b, config, monitorCount, &done, match_position);
/* Pick any available head */
match_heads(b, config, monitorCount, &done, match_any);
/* Destroy any heads we won't be using */
wl_list_for_each_safe(iter, tmp, &b->compositor->head_list, compositor_link) {
current = to_rdp_head(iter);
if (!current->matched)
rdp_head_destroy(iter);
}
for (uint32_t i = 0; i < monitorCount; i++) {
/* accumulate monitor layout */
pixman_region32_union_rect(&desktop, &desktop,
config[i].x,
config[i].y,
config[i].width,
config[i].height);
/* Create new heads for any without matches */
if (!(done & (1 << i)))
rdp_head_create(b->compositor, &config[i]);
}
peerCtx->desktop_left = desktop.extents.x1;
peerCtx->desktop_top = desktop.extents.y1;
peerCtx->desktop_width = desktop.extents.x2 - desktop.extents.x1;
peerCtx->desktop_height = desktop.extents.y2 - desktop.extents.y1;
pixman_region32_fini(&desktop);
}
static bool
disp_sanity_check_layout(RdpPeerContext *peerCtx, rdpMonitor *config, uint32_t count)
{
struct rdp_backend *b = peerCtx->rdpBackend;
uint32_t primaryCount = 0;
uint32_t i;
/* dump client monitor topology */
rdp_debug(b, "%s:---INPUT---\n", __func__);
for (i = 0; i < count; i++) {
int scale = config[i].attributes.desktopScaleFactor / 100;
rdp_debug(b, " rdpMonitor[%d]: x:%d, y:%d, width:%d, height:%d, is_primary:%d\n",
i, config[i].x, config[i].y,
config[i].width, config[i].height,
config[i].is_primary);
rdp_debug(b, " rdpMonitor[%d]: physicalWidth:%d, physicalHeight:%d, orientation:%d\n",
i, config[i].attributes.physicalWidth,
config[i].attributes.physicalHeight,
config[i].attributes.orientation);
rdp_debug(b, " rdpMonitor[%d]: desktopScaleFactor:%d, deviceScaleFactor:%d\n",
i, config[i].attributes.desktopScaleFactor,
config[i].attributes.deviceScaleFactor);
rdp_debug(b, " rdpMonitor[%d]: scale:%d\n",
i, scale);
}
for (i = 0; i < count; i++) {
/* make sure there is only one primary and its position at client */
if (config[i].is_primary) {
/* count number of primary */
if (++primaryCount > 1) {
weston_log("%s: RDP client reported unexpected primary count (%d)\n",
__func__, primaryCount);
return false;
}
/* primary must be at (0,0) in client space */
if (config[i].x != 0 || config[i].y != 0) {
weston_log("%s: RDP client reported primary is not at (0,0) but (%d,%d).\n",
__func__, config[i].x, config[i].y);
return false;
}
}
}
return true;
}
bool
handle_adjust_monitor_layout(freerdp_peer *client, int monitor_count, rdpMonitor *monitors)
{
RdpPeerContext *peerCtx = (RdpPeerContext *)client->context;
if (!disp_sanity_check_layout(peerCtx, monitors, monitor_count))
return true;
disp_layout_change(client, monitors, monitor_count);
return true;
}
static bool
rect_contains(int32_t px, int32_t py, int32_t rx, int32_t ry,
int32_t width, int32_t height)
{
if (px < rx)
return false;
if (py < ry)
return false;
if (px >= rx + width)
return false;
if (py >= ry + height)
return false;
return true;
}
static bool
rdp_head_contains(struct rdp_head *rdp_head, int32_t x, int32_t y)
{
rdpMonitor *config = &rdp_head->config;
/* If we're forcing RDP desktop size then we don't have
* useful information in the monitor structs, but we
* can rely on the output settings in that case.
*/
if (config->width == 0) {
struct weston_head *head = &rdp_head->base;
struct weston_output *output = head->output;
if (!output)
return false;
return rect_contains(x, y, output->x, output->y,
output->width * output->scale,
output->height * output->scale);
}
return rect_contains(x, y, config->x, config->y,
config->width, config->height);
}
/* Input x/y in client space, output x/y in weston space */
struct weston_output *
to_weston_coordinate(RdpPeerContext *peerContext, int32_t *x, int32_t *y)
{
struct rdp_backend *b = peerContext->rdpBackend;
int sx = *x, sy = *y;
struct weston_head *head_iter;
/* First, find which monitor contains this x/y. */
wl_list_for_each(head_iter, &b->compositor->head_list, compositor_link) {
struct rdp_head *head = to_rdp_head(head_iter);
assert(head);
if (rdp_head_contains(head, sx, sy)) {
struct weston_output *output = head->base.output;
float scale = 1.0f / head->base.output->scale;
sx -= head->config.x;
sy -= head->config.y;
/* scale x/y to client output space. */
sx *= scale;
sy *= scale;
/* translate x/y to offset of this output in weston space. */
sx += output->x;
sy += output->y;
rdp_debug_verbose(b, "%s: (x:%d, y:%d) -> (sx:%d, sy:%d) at head:%s\n",
__func__, *x, *y, sx, sy, head->base.name);
*x = sx;
*y = sy;
return output;
}
}
/* x/y is outside of any monitors. */
return NULL;
}