47#include <linux/input-event-codes.h>
49#include <spa/param/audio/format-utils.h>
50#include <spa/param/video/format-utils.h>
51#include <spa/param/buffers.h>
52#include <spa/buffer/meta.h>
54#include <winpr/assert.h>
56#include <winpr/collections.h>
57#include <winpr/input.h>
58#include <winpr/interlocked.h>
59#include <winpr/path.h>
60#include <winpr/synch.h>
61#include <winpr/sysinfo.h>
63#include <freerdp/server/server-common.h>
64#include <freerdp/codec/audio.h>
65#include <freerdp/codec/color.h>
66#include <freerdp/codec/dsp.h>
67#include <freerdp/codec/region.h>
68#include <freerdp/log.h>
71#include <security/pam_appl.h>
74#include "mutter_shadow.h"
76#define TAG SERVER_TAG("shadow.mutter")
78#define DC_NAME "org.gnome.Mutter.DisplayConfig"
79#define DC_PATH "/org/gnome/Mutter/DisplayConfig"
80#define RD_NAME "org.gnome.Mutter.RemoteDesktop"
81#define RD_PATH "/org/gnome/Mutter/RemoteDesktop"
82#define RD_SESSION_IFACE "org.gnome.Mutter.RemoteDesktop.Session"
83#define SC_NAME "org.gnome.Mutter.ScreenCast"
84#define SC_PATH "/org/gnome/Mutter/ScreenCast"
85#define SC_SESSION_IFACE "org.gnome.Mutter.ScreenCast.Session"
86#define SC_STREAM_IFACE "org.gnome.Mutter.ScreenCast.Stream"
89#define MUTTER_CURSOR_MODE_EMBEDDED 1u
90#define MUTTER_CURSOR_MODE_METADATA 2u
91#define MUTTER_VIRTUAL_ENV "FREERDP_SHADOW_MUTTER_VIRTUAL"
93#define MUTTER_DAMAGE_CHECK_ENV "FREERDP_SHADOW_MUTTER_DAMAGE_CHECK"
94#define MUTTER_CHECK_TILE 64
95#define SCREEN_SAVER_NAME "org.gnome.ScreenSaver"
96#define SCREEN_SAVER_PATH "/org/gnome/ScreenSaver"
100static BOOL mutter_virtual_size(UINT32* width, UINT32* height)
103 WINPR_ASSERT(height);
109 const char* env = getenv(MUTTER_VIRTUAL_ENV);
115 char* next =
nullptr;
116 unsigned long w = strtoul(env, &next, 0);
117 if ((errno != 0) || (w < 64) || (w > 8192))
119 if (!next || (*next !=
'x'))
122 unsigned long h = strtoul(&next[1],
nullptr, 0);
123 if ((errno != 0) || (h < 64) || (h > 8192))
126 *width = WINPR_ASSERTING_INT_CAST(UINT32, w);
127 *height = WINPR_ASSERTING_INT_CAST(UINT32, h);
133#define MUTTER_CURSOR_META_SIZE(width, height) \
134 (sizeof(struct spa_meta_cursor) + sizeof(struct spa_meta_bitmap) + 4ull * (width) * (height))
135#define MUTTER_CURSOR_META_MAX 384u
138#define MUTTER_SHADOW_CURSOR_MAX 96u
142#define MUTTER_SHADOW_CURSOR_QUIET_MS 500u
145#define MUTTER_MAX_DAMAGE 16u
149#define MUTTER_NAME_TIMEOUT_MS 10000u
150#define MUTTER_STREAM_TIMEOUT_MS 5000u
151#define MUTTER_FORMAT_TIMEOUT_MS 5000u
153#define MUTTER_STREAM_GONE_GRACE_MS 250u
156#define MUTTER_MSG_CLIPBOARD_OFFER 0x10001
157#define MUTTER_MSG_CLIPBOARD_READ 0x10002
158#define MUTTER_MSG_CLIPBOARD_PROVIDE 0x10003
159#define MUTTER_MSG_CLIPBOARD_WRITE_DONE 0x10004
161#define MUTTER_CLIPBOARD_STALL_MS 5000
162#define MUTTER_CLIPBOARD_CALL_USEC (2ull * 1000ull * 1000ull)
164#define MUTTER_CLIPBOARD_MAX_MIMES 64
173#define MUTTER_AUDIO_RATE 48000u
174#define MUTTER_AUDIO_CHANNELS 2u
175#define MUTTER_AUDIO_FRAME_BYTES (MUTTER_AUDIO_CHANNELS * 2ull)
177#define MUTTER_AUDIO_MESSAGE_FRAMES (MUTTER_AUDIO_RATE / 50u)
179#define MUTTER_AUDIO_LOG_MS 5000u
181#define MUTTER_MSG_VIRTUAL_SIZE 0x10005
182#define MUTTER_MSG_UNLOCK 0x10006
185#define MUTTER_VIRTUAL_SIZE_WAIT_MS 1000
189#define MUTTER_MOD_LOCK (1u << 1)
190#define MUTTER_MOD_NUM (1u << 4)
196 char connector[MUTTER_SHADOW_CONNECTOR_SIZE];
209 char connector[MUTTER_SHADOW_CONNECTOR_SIZE];
212static const AUDIO_FORMAT mutter_audio_offered_formats[] = {
213 { WAVE_FORMAT_OPUS, MUTTER_AUDIO_CHANNELS, MUTTER_AUDIO_RATE, 12000, 1, 16, 0,
nullptr },
214 { WAVE_FORMAT_PCM, MUTTER_AUDIO_CHANNELS, MUTTER_AUDIO_RATE,
215 (MUTTER_AUDIO_RATE * MUTTER_AUDIO_FRAME_BYTES), MUTTER_AUDIO_FRAME_BYTES, 16, 0,
nullptr },
223static BOOL mutter_wait_for_name(sd_bus* bus,
const char* name, UINT64 timeoutMs)
228 const UINT64 start = GetTickCount64();
233 sd_bus_error err = SD_BUS_ERROR_NULL;
234 sd_bus_message* reply =
nullptr;
238 sd_bus_call_method(bus,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
239 "org.freedesktop.DBus",
"NameHasOwner", &err, &reply,
"s", name);
241 (called >= 0) && (sd_bus_message_read(reply,
"b", &hasOwner) >= 0) && hasOwner;
242 sd_bus_message_unref(reply);
243 sd_bus_error_free(&err);
247 if (GetTickCount64() - start > timeoutMs)
251 WLog_INFO(TAG,
"waiting for %s on the session bus", name);
260static BOOL mutter_call_for_path(sd_bus* bus, sd_bus_message* call,
const char* what,
char** out)
267 sd_bus_error err = SD_BUS_ERROR_NULL;
268 sd_bus_message* reply =
nullptr;
269 const char* path =
nullptr;
271 const int called = sd_bus_call(bus, call, 0, &err, &reply);
274 char buffer[128] = WINPR_C_ARRAY_INIT;
275 WLog_ERR(TAG,
"%s failed: %s", what,
276 err.message ? err.message : winpr_strerror(-called, buffer,
sizeof(buffer)));
277 sd_bus_error_free(&err);
281 if ((sd_bus_message_read(reply,
"o", &path) >= 0) && path)
282 *out = _strdup(path);
283 sd_bus_message_unref(reply);
284 return *out !=
nullptr;
290static BOOL mutter_read_dict(sd_bus_message* msg,
const char* key,
char type,
void* value)
296 const char contents[2] = { type,
'\0' };
298 if (sd_bus_message_enter_container(msg,
'a',
"{sv}") < 0)
303 const int entered = sd_bus_message_enter_container(msg,
'e',
"sv");
309 const char* name =
nullptr;
310 if (sd_bus_message_read(msg,
"s", &name) < 0)
312 if (name && (strcmp(name, key) == 0))
314 if (sd_bus_message_read(msg,
"v", contents, value) < 0)
317 else if (sd_bus_message_skip(msg,
"v") < 0)
320 if (sd_bus_message_exit_container(msg) < 0)
324 return sd_bus_message_exit_container(msg) >= 0;
330static BOOL mutter_read_monitor(sd_bus_message* reply, MUTTER_MODE* mode, BOOL* more)
336 const int entered = sd_bus_message_enter_container(reply,
'r',
"(ssss)a(siiddada{sv})a{sv}");
339 *more = (entered > 0);
343 const char* connector =
nullptr;
344 if (sd_bus_message_read(reply,
"(ssss)", &connector,
nullptr,
nullptr,
nullptr) < 0)
346 (void)_snprintf(mode->connector,
sizeof(mode->connector),
"%s", connector ? connector :
"");
348 if (sd_bus_message_enter_container(reply,
'a',
"(siiddada{sv})") < 0)
352 const int modeEntered = sd_bus_message_enter_container(reply,
'r',
"siiddada{sv}");
355 if (modeEntered == 0)
361 if ((sd_bus_message_read(reply,
"siidd",
nullptr, &width, &height,
nullptr,
nullptr) < 0) ||
362 (sd_bus_message_skip(reply,
"ad") < 0) ||
363 !mutter_read_dict(reply,
"is-current",
'b', ¤t) ||
364 (sd_bus_message_exit_container(reply) < 0))
370 mode->height = height;
374 return (sd_bus_message_exit_container(reply) >= 0) &&
375 (sd_bus_message_skip(reply,
"a{sv}") >= 0) &&
376 (sd_bus_message_exit_container(reply) >= 0);
382static BOOL mutter_read_logical(sd_bus_message* reply, MUTTER_LOGICAL* logical, BOOL* more)
385 WINPR_ASSERT(logical);
388 const int entered = sd_bus_message_enter_container(reply,
'r',
"iiduba(ssss)a{sv}");
391 *more = (entered > 0);
398 uint32_t transform = 0;
400 if ((sd_bus_message_read(reply,
"iidub", &x, &y, &scale, &transform, &primary) < 0) ||
401 (sd_bus_message_enter_container(reply,
'a',
"(ssss)") < 0))
404 const char* connector =
nullptr;
407 const char* name =
nullptr;
408 const int read = sd_bus_message_read(reply,
"(ssss)", &name,
nullptr,
nullptr,
nullptr);
419 logical->scale = (scale > 0.0) ? scale : 1.0;
420 logical->transform = transform;
421 logical->primary = primary;
422 (void)_snprintf(logical->connector,
sizeof(logical->connector),
"%s",
423 connector ? connector :
"");
425 return (sd_bus_message_exit_container(reply) >= 0) &&
426 (sd_bus_message_skip(reply,
"a{sv}") >= 0) &&
427 (sd_bus_message_exit_container(reply) >= 0);
433static BOOL mutter_read_state(sd_bus_message* reply, MUTTER_MODE* modes,
size_t* nmodes,
434 MUTTER_LOGICAL* logical,
size_t* nlogical, uint32_t* layoutMode)
438 WINPR_ASSERT(nmodes);
439 WINPR_ASSERT(logical);
440 WINPR_ASSERT(nlogical);
441 WINPR_ASSERT(layoutMode);
443 if ((sd_bus_message_read(reply,
"u",
nullptr) < 0) ||
444 (sd_bus_message_enter_container(reply,
'a',
"((ssss)a(siiddada{sv})a{sv})") < 0))
448 MUTTER_MODE mode = WINPR_C_ARRAY_INIT;
450 if (!mutter_read_monitor(reply, &mode, &more))
454 if (*nmodes < MUTTER_SHADOW_MAX_MONITORS)
455 modes[(*nmodes)++] = mode;
457 if ((sd_bus_message_exit_container(reply) < 0) ||
458 (sd_bus_message_enter_container(reply,
'a',
"(iiduba(ssss)a{sv})") < 0))
463 MUTTER_LOGICAL entry = WINPR_C_ARRAY_INIT;
465 if (!mutter_read_logical(reply, &entry, &more))
469 if (*nlogical < MUTTER_SHADOW_MAX_MONITORS)
470 logical[(*nlogical)++] = entry;
472 if (sd_bus_message_exit_container(reply) < 0)
475 return mutter_read_dict(reply,
"layout-mode",
'u', layoutMode);
481static UINT32 mutter_list_monitors(sd_bus* bus,
MONITOR_DEF* monitors,
482 char (*connectors)[MUTTER_SHADOW_CONNECTOR_SIZE], UINT32 max)
485 WINPR_ASSERT(monitors);
487 sd_bus_error err = SD_BUS_ERROR_NULL;
488 sd_bus_message* reply =
nullptr;
489 MUTTER_MODE modes[MUTTER_SHADOW_MAX_MONITORS] = WINPR_C_ARRAY_INIT;
490 MUTTER_LOGICAL logical[MUTTER_SHADOW_MAX_MONITORS] = WINPR_C_ARRAY_INIT;
493 uint32_t layoutMode = 1;
497 sd_bus_call_method(bus, DC_NAME, DC_PATH, DC_NAME,
"GetCurrentState", &err, &reply,
"");
500 char buffer[128] = WINPR_C_ARRAY_INIT;
501 WLog_WARN(TAG,
"GetCurrentState failed: %s",
502 err.message ? err.message : winpr_strerror(-called, buffer,
sizeof(buffer)));
503 sd_bus_error_free(&err);
507 const BOOL parsed = mutter_read_state(reply, modes, &nmodes, logical, &nlogical, &layoutMode);
508 sd_bus_message_unref(reply);
510 WLog_WARN(TAG,
"GetCurrentState: unexpected reply");
513 for (
int pass = 0; pass < 2; pass++)
515 for (
size_t x = 0; (x < nlogical) && (count < max); x++)
517 if ((pass == 0) != (logical[x].primary != 0))
522 for (
size_t m = 0; m < nmodes; m++)
524 if (strcmp(modes[m].connector, logical[x].connector) == 0)
526 width = modes[m].width;
527 height = modes[m].height;
530 if ((width <= 0) || (height <= 0))
534 if (logical[x].transform & 1)
536 const INT32 tmp = width;
542 width = (INT32)(width / logical[x].scale + 0.5);
543 height = (INT32)(height / logical[x].scale + 0.5);
547 monitor->left = logical[x].x;
548 monitor->top = logical[x].y;
549 monitor->right = logical[x].x + width - 1;
550 monitor->bottom = logical[x].y + height - 1;
551 monitor->flags = logical[x].primary ? 1 : 0;
553 (void)_snprintf(connectors[count], MUTTER_SHADOW_CONNECTOR_SIZE,
"%s",
554 logical[x].connector);
563static UINT32 mutter_shadow_enum_monitors(
MONITOR_DEF* monitors, UINT32 maxMonitors)
565 WINPR_ASSERT(monitors);
569 if ((maxMonitors > 0) && mutter_virtual_size(&width, &height))
572 monitors[0] = (
MONITOR_DEF){ 0, 0, (INT32)width - 1, (INT32)height - 1, 1 };
576 sd_bus* bus =
nullptr;
577 const int opened = sd_bus_open_user(&bus);
580 char buffer[128] = WINPR_C_ARRAY_INIT;
581 WLog_WARN(TAG,
"cannot connect to the session bus: %s",
582 winpr_strerror(-opened, buffer,
sizeof(buffer)));
586 const UINT32 count = mutter_list_monitors(bus, monitors,
nullptr, maxMonitors);
587 WLog_DBG(TAG,
"%" PRIu32
" monitors", count);
588 sd_bus_flush_close_unref(bus);
593static int mutter_on_stream_added(sd_bus_message* msg,
void* data,
594 WINPR_ATTR_UNUSED sd_bus_error* err)
596 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
598 WINPR_ASSERT(mutter);
601 if (sd_bus_message_read(msg,
"u", &node) >= 0)
603 mutter->nodeId = node;
604 mutter->haveNode = TRUE;
605 WLog_DBG(TAG,
"PipeWire node %" PRIu32, mutter->nodeId);
606 if (mutter->awaitNode)
608 mutter->awaitNode = FALSE;
609 mutter->reconnect = TRUE;
616static int mutter_on_closed(WINPR_ATTR_UNUSED sd_bus_message* msg,
void* data,
617 WINPR_ATTR_UNUSED sd_bus_error* err)
619 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
620 WINPR_ASSERT(mutter);
622 mutter->closed = TRUE;
628static int mutter_on_name_owner_changed(sd_bus_message* msg,
void* data,
629 WINPR_ATTR_UNUSED sd_bus_error* err)
631 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
633 WINPR_ASSERT(mutter);
635 const char* name =
nullptr;
636 const char* oldOwner =
nullptr;
637 const char* newOwner =
nullptr;
638 if ((sd_bus_message_read(msg,
"sss", &name, &oldOwner, &newOwner) >= 0) && newOwner &&
639 (newOwner[0] ==
'\0'))
641 mutter->shellGone = TRUE;
642 mutter->closed = TRUE;
648static void mutter_read_stream_parameters(mutterShadowSubsystem* mutter)
650 WINPR_ASSERT(mutter);
652 sd_bus_error err = SD_BUS_ERROR_NULL;
653 sd_bus_message* reply =
nullptr;
654 const char* mappingId =
nullptr;
656 const int got = sd_bus_get_property(mutter->bus, SC_NAME, mutter->streamPath, SC_STREAM_IFACE,
657 "Parameters", &err, &reply,
"a{sv}");
660 char buffer[128] = WINPR_C_ARRAY_INIT;
661 WLog_DBG(TAG,
"no stream parameters: %s",
662 err.message ? err.message : winpr_strerror(-got, buffer,
sizeof(buffer)));
663 sd_bus_error_free(&err);
667 if (mutter_read_dict(reply,
"mapping-id",
's', (
void*)(&mappingId)) && mappingId)
670 char* copy = _strdup(mappingId);
671 EnterCriticalSection(&mutter->eiLock);
672 free(mutter->mappingId);
673 mutter->mappingId = copy;
674 LeaveCriticalSection(&mutter->eiLock);
676 sd_bus_message_unref(reply);
689static BOOL mutter_record_monitor(mutterShadowSubsystem* mutter,
const char* connector)
691 WINPR_ASSERT(mutter);
692 WINPR_ASSERT(connector);
694 sd_bus_message* call =
nullptr;
697 if (mutter->virtualMonitor)
701 if ((sd_bus_message_new_method_call(mutter->bus, &call, SC_NAME, mutter->scSessionPath,
702 SC_SESSION_IFACE,
"RecordVirtual") < 0) ||
703 (sd_bus_message_append(call,
"a{sv}", 1,
"cursor-mode",
"u",
704 (uint32_t)MUTTER_CURSOR_MODE_METADATA) < 0))
706 WLog_DBG(TAG,
"ScreenCast.Session.RecordVirtual(%" PRIu32
"x%" PRIu32
")",
707 mutter->virtualWidth, mutter->virtualHeight);
708 if (!mutter_call_for_path(mutter->bus, call,
"ScreenCast.Session.RecordVirtual",
709 &mutter->streamPath))
714 if ((sd_bus_message_new_method_call(mutter->bus, &call, SC_NAME, mutter->scSessionPath,
715 SC_SESSION_IFACE,
"RecordMonitor") < 0) ||
716 (sd_bus_message_append(call,
"sa{sv}", connector, 1,
"cursor-mode",
"u",
717 (uint32_t)MUTTER_CURSOR_MODE_EMBEDDED) < 0))
719 WLog_DBG(TAG,
"ScreenCast.Session.RecordMonitor('%s')", connector);
720 if (!mutter_call_for_path(mutter->bus, call,
"ScreenCast.Session.RecordMonitor",
721 &mutter->streamPath))
725 if (sd_bus_match_signal(mutter->bus, &mutter->streamAddedSlot, SC_NAME, mutter->streamPath,
726 SC_STREAM_IFACE,
"PipeWireStreamAdded", mutter_on_stream_added,
729 WLog_ERR(TAG,
"cannot watch the stream's signals");
734 sd_bus_message_unref(call);
737static void mutter_clipboard_enable(mutterShadowSubsystem* mutter);
740static BOOL mutter_setup_sessions(mutterShadowSubsystem* mutter,
const char* connector)
742 WINPR_ASSERT(mutter);
743 WINPR_ASSERT(connector);
745 sd_bus_error err = SD_BUS_ERROR_NULL;
746 sd_bus_message* call =
nullptr;
747 sd_bus_message* reply =
nullptr;
748 char* sessionId =
nullptr;
752 if (sd_bus_message_new_method_call(mutter->bus, &call, RD_NAME, RD_PATH, RD_NAME,
753 "CreateSession") < 0)
755 WLog_DBG(TAG,
"RemoteDesktop.CreateSession");
756 if (!mutter_call_for_path(mutter->bus, call,
"RemoteDesktop.CreateSession",
757 &mutter->rdSessionPath))
759 call = sd_bus_message_unref(call);
761 const int gotId = sd_bus_get_property_string(mutter->bus, RD_NAME, mutter->rdSessionPath,
762 RD_SESSION_IFACE,
"SessionId", &err, &sessionId);
765 char buffer[128] = WINPR_C_ARRAY_INIT;
766 WLog_ERR(TAG,
"no SessionId: %s",
767 err.message ? err.message : winpr_strerror(-gotId, buffer,
sizeof(buffer)));
772 if ((sd_bus_message_new_method_call(mutter->bus, &call, SC_NAME, SC_PATH, SC_NAME,
773 "CreateSession") < 0) ||
774 (sd_bus_message_append(call,
"a{sv}", 1,
"remote-desktop-session-id",
"s", sessionId) < 0))
776 WLog_DBG(TAG,
"ScreenCast.CreateSession");
777 if (!mutter_call_for_path(mutter->bus, call,
"ScreenCast.CreateSession",
778 &mutter->scSessionPath))
780 call = sd_bus_message_unref(call);
783 if (!mutter_record_monitor(mutter, connector))
786 if ((sd_bus_match_signal(mutter->bus, &mutter->closedSlot, RD_NAME, mutter->rdSessionPath,
787 RD_SESSION_IFACE,
"Closed", mutter_on_closed, mutter) < 0) ||
788 (sd_bus_add_match(mutter->bus, &mutter->ownerSlot,
789 "type='signal',sender='org.freedesktop.DBus',"
790 "path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',"
791 "member='NameOwnerChanged',arg0='" RD_NAME
"'",
792 mutter_on_name_owner_changed, mutter) < 0))
794 WLog_ERR(TAG,
"cannot watch the stream's signals");
799 WLog_DBG(TAG,
"RemoteDesktop.Session.Start");
800 const int started = sd_bus_call_method(mutter->bus, RD_NAME, mutter->rdSessionPath,
801 RD_SESSION_IFACE,
"Start", &err,
nullptr,
"");
804 char buffer[128] = WINPR_C_ARRAY_INIT;
805 WLog_ERR(TAG,
"RemoteDesktop.Session.Start failed: %s",
806 err.message ? err.message : winpr_strerror(-started, buffer,
sizeof(buffer)));
809 mutter->started = TRUE;
811 const UINT64 start = GetTickCount64();
812 while (!mutter->haveNode)
814 const int processed = sd_bus_process(mutter->bus,
nullptr);
819 if (GetTickCount64() - start > MUTTER_STREAM_TIMEOUT_MS)
821 WLog_ERR(TAG,
"Mutter announced no PipeWire stream");
824 (void)sd_bus_wait(mutter->bus, 100ull * 1000ull);
826 mutter_read_stream_parameters(mutter);
830 const int connected =
831 sd_bus_call_method(mutter->bus, RD_NAME, mutter->rdSessionPath, RD_SESSION_IFACE,
832 "ConnectToEIS", &err, &reply,
"a{sv}", 0);
833 if ((connected < 0) || (sd_bus_message_read(reply,
"h", &fd) < 0))
835 WLog_WARN(TAG,
"ConnectToEIS failed: %s: the clients can only watch",
836 err.message ? err.message :
"bad reply");
841 fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
842 mutter->ei = ei_new_sender(mutter);
845 ei_configure_name(mutter->ei,
"FreeRDP shadow server");
846 if (ei_setup_backend_fd(mutter->ei, fd) != 0)
848 WLog_WARN(TAG,
"libei setup failed: the clients can only watch");
849 mutter->ei = ei_unref(mutter->ei);
856 mutter_clipboard_enable(mutter);
860 sd_bus_error_free(&err);
861 sd_bus_message_unref(reply);
862 sd_bus_message_unref(call);
871static void mutter_cursor_msg_free(UINT32
id, SHADOW_MSG_OUT* msg)
873 if (msg && (
id == SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE_ID))
876 free(shape->xorMaskData);
877 free(shape->andMaskData);
883static UINT32 mutter_cursor_hash(
const BYTE* pixels, UINT32 width, UINT32 height, UINT32 xHot,
886 WINPR_ASSERT(pixels);
889 UINT32 hash = 2166136261u;
890 const UINT32 header[] = { width, height, xHot, yHot };
891 const BYTE* parts[] = { (
const BYTE*)header, pixels };
892 const size_t sizes[] = {
sizeof(header), 4ull * width * height };
893 for (
size_t p = 0; p < ARRAYSIZE(parts); p++)
895 for (
size_t x = 0; x < sizes[p]; x++)
904static void mutter_cursor_send_shape(mutterShadowSubsystem* mutter,
const BYTE* pixels,
905 UINT32 width, UINT32 height, UINT32 xHot, UINT32 yHot)
907 WINPR_ASSERT(mutter);
908 WINPR_ASSERT(pixels);
910 const UINT32 hash = mutter_cursor_hash(pixels, width, height, xHot, yHot);
911 WLog_DBG(TAG,
"pointer shape %" PRIu32
"x%" PRIu32
", resend %d", width, height,
912 mutter->cursorResend);
913 if (mutter->cursorKnown && !mutter->cursorResend && (hash == mutter->cursorHash))
924 msg->height = height;
926 if (shadow_subsystem_pointer_convert_alpha_pointer_data_to_format(pixels, PIXEL_FORMAT_RGBA32,
927 TRUE, width, height, msg) < 0)
933 msg->common.Free = mutter_cursor_msg_free;
934 if (shadow_client_boardcast_msg(mutter->common.server,
nullptr,
935 SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE_ID, &msg->common,
938 mutter->cursorHash = hash;
939 mutter->cursorKnown = TRUE;
940 mutter->cursorResend = FALSE;
944static void mutter_cursor_send_position(mutterShadowSubsystem* mutter, INT32 x, INT32 y)
946 WINPR_ASSERT(mutter);
948 if ((x == mutter->cursorX) && (y == mutter->cursorY))
954 EnterCriticalSection(&mutter->eiLock);
955 const UINT64 input = mutter->pointerInput;
956 LeaveCriticalSection(&mutter->eiLock);
957 if (GetTickCount64() - input < MUTTER_SHADOW_CURSOR_QUIET_MS)
960 if ((x < 0) || (y < 0) || ((UINT32)x >= mutter->width) || ((UINT32)y >= mutter->height))
963 mutter->common.pointerX = (UINT32)x;
964 mutter->common.pointerY = (UINT32)y;
970 msg->xPos = (UINT32)x;
971 msg->yPos = (UINT32)y;
972 msg->common.Free = mutter_cursor_msg_free;
974 if (shadow_client_boardcast_msg(mutter->common.server,
nullptr,
975 SHADOW_MSG_OUT_POINTER_POSITION_UPDATE_ID, &msg->common,
977 WLog_DBG(TAG,
"the pointer position was not sent");
982static void mutter_cursor_remember(mutterShadowSubsystem* mutter,
const BYTE* pixels, UINT32 width,
983 UINT32 height, UINT32 xHot, UINT32 yHot)
985 WINPR_ASSERT(mutter);
986 WINPR_ASSERT(pixels);
988 const size_t size = 4ull * width * height;
989 BYTE* copy = malloc(size);
992 memcpy(copy, pixels, size);
994 free(mutter->cursorPixels);
995 mutter->cursorPixels = copy;
996 mutter->cursorWidth = width;
997 mutter->cursorHeight = height;
998 mutter->cursorXHot = xHot;
999 mutter->cursorYHot = yHot;
1004static void mutter_cursor_send_default(mutterShadowSubsystem* mutter)
1006 static const char*
const arrow[] = {
"X ",
"XX ",
"X.X ",
"X..X ",
1007 "X...X ",
"X....X ",
"X.....X ",
"X......X ",
1008 "X.......X ",
"X........X ",
"X.....XXXXX",
"X..X..X ",
1009 "X.X X..X ",
"XX X..X ",
"X X..X ",
" X..X ",
1014 ARROW_HEIGHT = ARRAYSIZE(arrow)
1016 BYTE pixels[4ull * ARROW_WIDTH * ARROW_HEIGHT] = WINPR_C_ARRAY_INIT;
1017 for (
size_t y = 0; y < ARROW_HEIGHT; y++)
1019 for (
size_t x = 0; x < ARROW_WIDTH; x++)
1021 BYTE* pixel = &pixels[4ull * (y * ARROW_WIDTH + x)];
1022 if (arrow[y][x] ==
' ')
1024 const BYTE value = (arrow[y][x] ==
'.') ? 0xff : 0x00;
1025 pixel[0] = pixel[1] = pixel[2] = value;
1029 mutter_cursor_send_shape(mutter, pixels, ARROW_WIDTH, ARROW_HEIGHT, 0, 0);
1033static void mutter_cursor_update(mutterShadowSubsystem* mutter,
struct spa_buffer* buf)
1035 WINPR_ASSERT(mutter);
1038 struct spa_meta* meta = spa_buffer_find_meta(buf, SPA_META_Cursor);
1039 if (!meta || (meta->size <
sizeof(
struct spa_meta_cursor)))
1042 const struct spa_meta_cursor* mc = (
const struct spa_meta_cursor*)meta->data;
1046 if (mc->bitmap_offset != 0)
1048 if ((
size_t)mc->bitmap_offset +
sizeof(
struct spa_meta_bitmap) > meta->size)
1051 const struct spa_meta_bitmap* mb =
1052 SPA_PTROFF(mc, mc->bitmap_offset,
const struct spa_meta_bitmap);
1053 if ((mb->format == 0) || (mb->offset == 0) || (mb->size.width == 0) ||
1054 (mb->size.height == 0))
1057 const BYTE transparent[4] = WINPR_C_ARRAY_INIT;
1058 mutter_cursor_remember(mutter, transparent, 1, 1, 0, 0);
1059 mutter_cursor_send_shape(mutter, transparent, 1, 1, 0, 0);
1063 const UINT32 width = mb->size.width;
1064 const UINT32 height = mb->size.height;
1065 const UINT32 stride = (mb->stride > 0) ? (UINT32)mb->stride : width * 4;
1066 if ((mb->format != SPA_VIDEO_FORMAT_RGBA) || (width > MUTTER_CURSOR_META_MAX) ||
1067 (height > MUTTER_CURSOR_META_MAX) || (stride < width * 4) ||
1068 ((
size_t)mc->bitmap_offset + mb->offset + (
size_t)stride * height > meta->size))
1071 "unusable pointer bitmap (format %" PRIu32
", %" PRIu32
"x%" PRIu32
")",
1072 mb->format, width, height);
1076 const BYTE* src = SPA_PTROFF(mb, mb->offset,
const BYTE);
1079 const UINT32 side = MAX(width, height);
1080 const UINT32 scaled = MIN(side, MUTTER_SHADOW_CURSOR_MAX);
1081 const UINT32 outW = MAX(1, width * scaled / side);
1082 const UINT32 outH = MAX(1, height * scaled / side);
1083 BYTE* pixels = calloc(4ull * outW, outH);
1086 for (UINT32 y = 0; y < outH; y++)
1088 const BYTE* row = src + (size_t)(y * side / scaled) * stride;
1089 for (UINT32 x = 0; x < outW; x++)
1090 memcpy(&pixels[4ull * (y * outW + x)], &row[4ull * (x * side / scaled)],
1094 MIN((UINT32)MAX(mc->hotspot.x, 0) * scaled / side, outW - 1);
1096 MIN((UINT32)MAX(mc->hotspot.y, 0) * scaled / side, outH - 1);
1097 mutter_cursor_remember(mutter, pixels, outW, outH, xHot, yHot);
1098 mutter_cursor_send_shape(mutter, pixels, outW, outH, xHot, yHot);
1105 mutter_cursor_send_position(mutter, mc->position.x, mc->position.y);
1112static void mutter_set_monitor_size(mutterShadowSubsystem* mutter)
1114 WINPR_ASSERT(mutter);
1116 rdpShadowSubsystem* subsystem = &mutter->common;
1117 MONITOR_DEF* monitor = &subsystem->monitors[subsystem->selectedMonitor];
1120 monitor->right = monitor->left + (INT32)mutter->width - 1;
1121 monitor->bottom = monitor->top + (INT32)mutter->height - 1;
1123 MONITOR_DEF* virtualScreen = &subsystem->virtualScreen;
1124 *virtualScreen = subsystem->monitors[0];
1125 for (UINT32 x = 1; x < subsystem->numMonitors; x++)
1128 virtualScreen->left = MIN(virtualScreen->left, m->left);
1129 virtualScreen->top = MIN(virtualScreen->top, m->top);
1130 virtualScreen->right = MAX(virtualScreen->right, m->right);
1131 virtualScreen->bottom = MAX(virtualScreen->bottom, m->bottom);
1133 virtualScreen->flags = 1;
1136static void mutter_on_param_changed(
void* data, uint32_t
id,
const struct spa_pod* param)
1138 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
1139 WINPR_ASSERT(mutter);
1141 struct spa_video_info_raw info = WINPR_C_ARRAY_INIT;
1142 uint8_t podBuffer[1024] = WINPR_C_ARRAY_INIT;
1143 struct spa_pod_builder b = SPA_POD_BUILDER_INIT(podBuffer,
sizeof(podBuffer));
1144 const struct spa_pod* params[4] = WINPR_C_ARRAY_INIT;
1146 if (!param || (
id != SPA_PARAM_Format))
1148 if (spa_format_video_raw_parse(param, &info) < 0)
1150 WLog_ERR(TAG,
"cannot parse the stream format");
1154 const BOOL sized = mutter->haveFormat;
1155 const BOOL changed = (info.size.width != mutter->width) || (info.size.height != mutter->height);
1156 mutter->width = info.size.width;
1157 mutter->height = info.size.height;
1159 (info.format == SPA_VIDEO_FORMAT_BGRA) ? PIXEL_FORMAT_BGRA32 : PIXEL_FORMAT_BGRX32;
1160 mutter->haveFormat = TRUE;
1161 mutter->fullPaint = TRUE;
1162 WLog_INFO(TAG,
"stream: %" PRIu32
"x%" PRIu32
" %s", mutter->width, mutter->height,
1163 (info.format == SPA_VIDEO_FORMAT_BGRA) ?
"BGRA" :
"BGRx");
1165 if (sized && changed)
1168 mutter_set_monitor_size(mutter);
1169 if (!shadow_screen_resize(mutter->common.server->screen))
1170 WLog_ERR(TAG,
"cannot resize the screen to %" PRIu32
"x%" PRIu32, mutter->width,
1174 WINPR_PRAGMA_DIAG_PUSH
1175 WINPR_PRAGMA_DIAG(
"-Wgnu-statement-expression-from-macro-expansion")
1177 const int32_t stride = (int32_t)mutter->width * 4;
1178 params[0] = spa_pod_builder_add_object(
1179 &b, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers, SPA_PARAM_BUFFERS_buffers,
1180 SPA_POD_CHOICE_RANGE_Int(4, 2, 16), SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
1181 SPA_PARAM_BUFFERS_size, SPA_POD_Int(stride * (int32_t)mutter->height),
1182 SPA_PARAM_BUFFERS_stride, SPA_POD_Int(stride), SPA_PARAM_BUFFERS_dataType,
1183 SPA_POD_CHOICE_FLAGS_Int((1 << SPA_DATA_MemFd) | (1 << SPA_DATA_MemPtr)));
1184 params[1] = spa_pod_builder_add_object(&b, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
1185 SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
1186 SPA_PARAM_META_size,
1187 SPA_POD_Int(sizeof(struct spa_meta_header)));
1188 params[2] = spa_pod_builder_add_object(
1189 &b, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta, SPA_PARAM_META_type,
1190 SPA_POD_Id(SPA_META_VideoDamage), SPA_PARAM_META_size,
1191 SPA_POD_CHOICE_RANGE_Int(sizeof(struct spa_meta_region) * MUTTER_MAX_DAMAGE,
1192 sizeof(struct spa_meta_region),
1193 sizeof(struct spa_meta_region) * MUTTER_MAX_DAMAGE));
1194 params[3] = spa_pod_builder_add_object(
1195 &b, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta, SPA_PARAM_META_type,
1196 SPA_POD_Id(SPA_META_Cursor), SPA_PARAM_META_size,
1197 SPA_POD_CHOICE_RANGE_Int(
1198 MUTTER_CURSOR_META_SIZE(64, 64), MUTTER_CURSOR_META_SIZE(1, 1),
1199 MUTTER_CURSOR_META_SIZE(MUTTER_CURSOR_META_MAX, MUTTER_CURSOR_META_MAX)));
1200 WINPR_PRAGMA_DIAG_POP
1203 pw_stream_update_params(mutter->stream, params, ARRAYSIZE(params));
1207static
void mutter_copy_rect(mutterShadowSubsystem* mutter, rdpShadowSurface* surface,
1208 const BYTE* src, UINT32 stride, INT32 x, INT32 y, INT32 width,
1211 WINPR_ASSERT(mutter);
1212 WINPR_ASSERT(surface);
1215 const INT32 maxW = (INT32)MIN(mutter->width, surface->width);
1216 const INT32 maxH = (INT32)MIN(mutter->height, surface->height);
1217 const INT32 left = MAX(x, 0);
1218 const INT32 top = MAX(y, 0);
1219 const INT32 right = MIN(x + width, maxW);
1220 const INT32 bottom = MIN(y + height, maxH);
1221 if ((right <= left) || (bottom <= top))
1224 if (!freerdp_image_copy_no_overlap(surface->data, surface->format, surface->scanline,
1225 (UINT32)left, (UINT32)top, (UINT32)(right - left),
1226 (UINT32)(bottom - top), src, mutter->format, stride,
1227 (UINT32)left, (UINT32)top,
nullptr, FREERDP_FLIP_NONE))
1229 WLog_ERR(TAG,
"cannot copy the frame to the surface");
1232 const RECTANGLE_16 rect = { (UINT16)left, (UINT16)top, (UINT16)right, (UINT16)bottom };
1233 if (!region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &rect))
1234 WLog_ERR(TAG,
"cannot mark the changed region");
1242static UINT32 mutter_repair_missed_damage(mutterShadowSubsystem* mutter, rdpShadowSurface* surface,
1243 const BYTE* src, UINT32 stride)
1245 WINPR_ASSERT(mutter);
1246 WINPR_ASSERT(surface);
1249 const UINT32 width = MIN(mutter->width, surface->width);
1250 const UINT32 height = MIN(mutter->height, surface->height);
1253 const BOOL sameFormat = (mutter->format == surface->format);
1256 for (UINT32 ty = 0; ty < height; ty += MUTTER_CHECK_TILE)
1258 const UINT32 th = MIN(MUTTER_CHECK_TILE, height - ty);
1259 for (UINT32 tx = 0; tx < width; tx += MUTTER_CHECK_TILE)
1261 const UINT32 tw = MIN(MUTTER_CHECK_TILE, width - tx);
1263 for (UINT32 y = ty; (y < ty + th) && !dirty; y++)
1265 const BYTE* a = &src[1ull * y * stride + 4ull * tx];
1266 const BYTE* b = &surface->data[1ull * y * surface->scanline + 4ull * tx];
1268 dirty = (memcmp(a, b, 4ull * tw) != 0);
1271 for (UINT32 x = 0; (x < tw) && !dirty; x++)
1272 dirty = (memcmp(&a[4ull * x], &b[4ull * x], 3) != 0);
1277 mutter_copy_rect(mutter, surface, src, stride, (INT32)tx, (INT32)ty, (INT32)tw,
1287static void mutter_damage_stats(mutterShadowSubsystem* mutter, UINT32 tiles)
1289 WINPR_ASSERT(mutter);
1291 mutter->damageFrames++;
1292 mutter->damageTiles += tiles;
1293 if ((tiles > 0) && !mutter->damageMissSeen)
1295 mutter->damageMissSeen = TRUE;
1297 "Mutter left changes out of its damage: %" PRIu32
1298 " tile(s) copied, the check stays on (" MUTTER_DAMAGE_CHECK_ENV
1302 const UINT64 now = GetTickCount64();
1303 if (now - mutter->damageLogged >= 5000)
1305 WLog_DBG(TAG,
"damage check: %" PRIu64
" tile(s) Mutter left out, in %" PRIu64
" frame(s)",
1306 mutter->damageTiles, mutter->damageFrames);
1307 mutter->damageTiles = 0;
1308 mutter->damageFrames = 0;
1309 mutter->damageLogged = now;
1313static void mutter_on_process(
void* data)
1315 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
1316 WINPR_ASSERT(mutter);
1318 rdpShadowServer* server = mutter->common.server;
1319 if (!server || !server->surface)
1321 rdpShadowSurface* surface = server->surface;
1322 BOOL painted = FALSE;
1323 struct pw_buffer* pb =
nullptr;
1326 while ((pb = pw_stream_dequeue_buffer(mutter->stream)) !=
nullptr)
1328 struct spa_buffer* buf = pb->buffer;
1329 struct spa_data* d = &buf->datas[0];
1331 mutter_cursor_update(mutter, buf);
1333 const struct spa_meta_header* h =
1334 spa_buffer_find_meta_data(buf, SPA_META_Header,
sizeof(
struct spa_meta_header));
1335 if ((h && (h->flags & SPA_META_HEADER_FLAG_CORRUPTED)) || !d->data || !d->chunk ||
1336 (d->chunk->size == 0))
1339 (void)pw_stream_queue_buffer(mutter->stream, pb);
1343 const BYTE* src = (
const BYTE*)d->data + d->chunk->offset;
1344 const UINT32 stride = (d->chunk->stride > 0) ? (UINT32)d->chunk->stride : mutter->width * 4;
1346 EnterCriticalSection(&surface->lock);
1347 struct spa_meta* dm = spa_buffer_find_meta(buf, SPA_META_VideoDamage);
1348 if (!dm || mutter->fullPaint)
1350 mutter_copy_rect(mutter, surface, src, stride, 0, 0, (INT32)mutter->width,
1351 (INT32)mutter->height);
1352 mutter->fullPaint = FALSE;
1356 struct spa_meta_region* r =
nullptr;
1357 spa_meta_for_each(r, dm)
1359 if (!spa_meta_region_is_valid(r))
1361 mutter_copy_rect(mutter, surface, src, stride, r->region.position.x,
1362 r->region.position.y, (INT32)r->region.size.width,
1363 (INT32)r->region.size.height);
1365 if (mutter->damageCheck)
1366 mutter_damage_stats(mutter,
1367 mutter_repair_missed_damage(mutter, surface, src, stride));
1369 LeaveCriticalSection(&surface->lock);
1371 (void)pw_stream_queue_buffer(mutter->stream, pb);
1381 if (ArrayList_Count(server->clients) > 0)
1382 shadow_subsystem_frame_update(&mutter->common);
1384 EnterCriticalSection(&surface->lock);
1385 region16_clear(&surface->invalidRegion);
1386 LeaveCriticalSection(&surface->lock);
1389static void mutter_on_state_changed(WINPR_ATTR_UNUSED
void* data,
1390 WINPR_ATTR_UNUSED
enum pw_stream_state old,
1391 enum pw_stream_state state,
const char* error)
1393 WLog_DBG(TAG,
"stream %s%s%s", pw_stream_state_as_string(state), error ?
": " :
"",
1394 error ? error :
"");
1397static const struct pw_stream_events mutter_stream_events = {
1398 PW_VERSION_STREAM_EVENTS,
1399 .state_changed = mutter_on_state_changed,
1400 .param_changed = mutter_on_param_changed,
1401 .process = mutter_on_process,
1404static void mutter_on_core_error(WINPR_ATTR_UNUSED
void* data, uint32_t
id,
1405 WINPR_ATTR_UNUSED
int seq, WINPR_ATTR_UNUSED
int res,
1406 const char* message)
1408 WLog_ERR(TAG,
"PipeWire error on %" PRIu32
": %s",
id, message);
1411static const struct pw_core_events mutter_core_events = {
1412 PW_VERSION_CORE_EVENTS,
1413 .error = mutter_on_core_error,
1419static void mutter_on_global_remove(
void* data, uint32_t
id)
1421 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
1422 WINPR_ASSERT(mutter);
1424 if (mutter->haveNode && (
id == mutter->nodeId))
1426 mutter->haveNode = FALSE;
1427 mutter->streamGone = TRUE;
1428 mutter->streamGoneAt = GetTickCount64();
1432static const struct pw_registry_events mutter_registry_events = {
1433 PW_VERSION_REGISTRY_EVENTS,
1434 .global_remove = mutter_on_global_remove,
1438static BOOL mutter_stream_connect_node(mutterShadowSubsystem* mutter);
1441static BOOL mutter_connect_stream(mutterShadowSubsystem* mutter)
1443 WINPR_ASSERT(mutter);
1445 pw_init(
nullptr,
nullptr);
1446 mutter->loop = pw_loop_new(
nullptr);
1449 mutter->context = pw_context_new(mutter->loop,
nullptr, 0);
1450 if (!mutter->context)
1453 mutter->core = pw_context_connect(mutter->context,
nullptr, 0);
1456 char buffer[128] = WINPR_C_ARRAY_INIT;
1457 WLog_ERR(TAG,
"cannot connect to PipeWire: %s",
1458 winpr_strerror(errno, buffer,
sizeof(buffer)));
1461 pw_core_add_listener(mutter->core, &mutter->coreListener, &mutter_core_events, mutter);
1463 mutter->registry = pw_core_get_registry(mutter->core, PW_VERSION_REGISTRY, 0);
1464 if (!mutter->registry)
1466 pw_registry_add_listener(mutter->registry, &mutter->registryListener, &mutter_registry_events,
1469 if (!mutter_stream_connect_node(mutter))
1473 const UINT64 start = GetTickCount64();
1474 while (!mutter->haveFormat)
1476 if (GetTickCount64() - start > MUTTER_FORMAT_TIMEOUT_MS)
1478 WLog_ERR(TAG,
"the stream got no format");
1481 pw_loop_enter(mutter->loop);
1482 (void)pw_loop_iterate(mutter->loop, 100);
1483 pw_loop_leave(mutter->loop);
1490static const struct spa_pod* mutter_stream_format(
struct spa_pod_builder* b,
1491 const struct spa_rectangle* size)
1493 const struct spa_rectangle minSize = SPA_RECTANGLE(1, 1);
1494 const struct spa_rectangle maxSize = SPA_RECTANGLE(8192, 8192);
1495 const struct spa_fraction rate = SPA_FRACTION(0, 1);
1496 const struct spa_fraction maxRate = SPA_FRACTION(60, 1);
1497 const struct spa_fraction minRate = SPA_FRACTION(1, 1);
1499 WINPR_PRAGMA_DIAG_PUSH
1500 WINPR_PRAGMA_DIAG(
"-Wgnu-statement-expression-from-macro-expansion")
1503 WINPR_PRAGMA_DIAG_PUSH
1504 WINPR_PRAGMA_DIAG(
"-Wgnu-statement-expression-from-macro-expansion")
1505 return spa_pod_builder_add_object(
1506 b, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat, SPA_FORMAT_mediaType,
1507 SPA_POD_Id(SPA_MEDIA_TYPE_video), SPA_FORMAT_mediaSubtype,
1508 SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw), SPA_FORMAT_VIDEO_format,
1509 SPA_POD_CHOICE_ENUM_Id(3, SPA_VIDEO_FORMAT_BGRx, SPA_VIDEO_FORMAT_BGRx,
1510 SPA_VIDEO_FORMAT_BGRA),
1511 SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle(size, &minSize, &maxSize),
1512 SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&rate), SPA_FORMAT_VIDEO_maxFramerate,
1513 SPA_POD_CHOICE_RANGE_Fraction(&maxRate, &minRate, &maxRate));
1514 WINPR_PRAGMA_DIAG_POP
1520static BOOL mutter_stream_connect_node(mutterShadowSubsystem* mutter)
1522 WINPR_ASSERT(mutter);
1523 WINPR_ASSERT(mutter->core);
1526 pw_stream_destroy(mutter->stream);
1528 pw_stream_new(mutter->core,
"FreeRDP shadow server",
1529 pw_properties_new(PW_KEY_MEDIA_TYPE,
"Video", PW_KEY_MEDIA_CATEGORY,
1530 "Capture", PW_KEY_MEDIA_ROLE,
"Screen",
nullptr));
1531 if (!mutter->stream)
1533 pw_stream_add_listener(mutter->stream, &mutter->streamListener, &mutter_stream_events, mutter);
1535 uint8_t podBuffer[1024] = WINPR_C_ARRAY_INIT;
1536 struct spa_pod_builder b = SPA_POD_BUILDER_INIT(podBuffer,
sizeof(podBuffer));
1538 const struct spa_rectangle size =
1539 mutter->virtualMonitor ? SPA_RECTANGLE(mutter->virtualWidth, mutter->virtualHeight)
1540 : SPA_RECTANGLE(1920, 1080);
1541 const struct spa_pod* params[] = { mutter_stream_format(&b, &size) };
1543 if (pw_stream_connect(
1544 mutter->stream, PW_DIRECTION_INPUT, mutter->nodeId,
1545 (
enum pw_stream_flags)(PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS), params,
1546 ARRAYSIZE(params)) < 0)
1548 WLog_ERR(TAG,
"pw_stream_connect failed");
1556static void mutter_virtual_resize(mutterShadowSubsystem* mutter, UINT32 width, UINT32 height)
1558 WINPR_ASSERT(mutter);
1560 if (!mutter->stream)
1563 mutter->virtualWidth = width;
1564 mutter->virtualHeight = height;
1566 uint8_t podBuffer[1024] = WINPR_C_ARRAY_INIT;
1567 struct spa_pod_builder b = SPA_POD_BUILDER_INIT(podBuffer,
sizeof(podBuffer));
1568 const struct spa_rectangle size = SPA_RECTANGLE(width, height);
1569 const struct spa_pod* params[] = { mutter_stream_format(&b, &size) };
1570 if (pw_stream_update_params(mutter->stream, params, ARRAYSIZE(params)) < 0)
1571 WLog_WARN(TAG,
"cannot ask for %" PRIu32
"x%" PRIu32, width, height);
1578static void mutter_audio_msg_free(WINPR_ATTR_UNUSED UINT32
id, SHADOW_MSG_OUT* msg)
1587static void mutter_audio_post(mutterShadowSubsystem* mutter,
wStream* s)
1589 WINPR_ASSERT(mutter);
1592 const size_t size = Stream_GetPosition(s);
1593 Stream_ResetPosition(s);
1597 rdpShadowServer* server = mutter->common.server;
1598 if (!server || !server->clients || (ArrayList_Count(server->clients) == 0))
1605 msg->buf = malloc(size);
1612 memcpy(msg->buf, Stream_Buffer(s), size);
1613 mutter->audioMessages++;
1614 msg->common.Free = mutter_audio_msg_free;
1615 msg->audio_format = &mutter->audioSourceFormat;
1616 msg->nFrames = size / MUTTER_AUDIO_FRAME_BYTES;
1617 msg->wTimestamp = (UINT16)(GetTickCount64() & 0xFFFF);
1619 if (shadow_client_boardcast_msg(server,
nullptr, SHADOW_MSG_OUT_AUDIO_OUT_SAMPLES_ID,
1620 &msg->common,
nullptr) < 0)
1621 WLog_DBG(TAG,
"sound: a message was not sent");
1624static void mutter_audio_stats(mutterShadowSubsystem* mutter,
size_t frames)
1626 WINPR_ASSERT(mutter);
1628 const UINT64 now = GetTickCount64();
1629 if (mutter->audioLogged == 0)
1631 WLog_INFO(TAG,
"sound: capturing what the default sink plays");
1632 mutter->audioLogged = now;
1634 else if (now - mutter->audioLogged >= MUTTER_AUDIO_LOG_MS)
1637 "sound: %" PRIu64
" frames captured, %" PRIu64
1638 " messages sent, peak %.3f in the last %" PRIu64
" ms",
1639 mutter->audioFrames, mutter->audioMessages, (
double)mutter->audioPeak,
1640 now - mutter->audioLogged);
1641 mutter->audioFrames = 0;
1642 mutter->audioMessages = 0;
1643 mutter->audioPeak = 0.0f;
1644 mutter->audioLogged = now;
1646 mutter->audioFrames += frames;
1649static void mutter_on_audio_process(
void* data)
1651 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)data;
1652 WINPR_ASSERT(mutter);
1654 struct pw_buffer* pb =
nullptr;
1656 while ((pb = pw_stream_dequeue_buffer(mutter->audio)) !=
nullptr)
1658 const struct spa_data* d = &pb->buffer->datas[0];
1659 if (d->data && d->chunk && (d->chunk->size > 0) &&
1660 ((
size_t)d->chunk->offset + d->chunk->size <= d->maxsize))
1662 const BYTE* bdata = d->data;
1663 const BYTE* offset = &bdata[d->chunk->offset];
1664 const INT16* samples = WINPR_PACKED_ALIGN_CAST(
const INT16*, offset);
1665 const size_t frames = d->chunk->size / MUTTER_AUDIO_FRAME_BYTES;
1666 mutter_audio_stats(mutter, frames);
1668 wStream* s = mutter->audioStream;
1669 for (
size_t f = 0; f < frames; f++)
1671 for (
size_t c = 0; c < MUTTER_AUDIO_CHANNELS; c++)
1673 const INT16 value = samples[f * MUTTER_AUDIO_CHANNELS + c];
1675 MAX(mutter->audioPeak, fabsf((
float)value / (
float)INT16_MAX));
1676 Stream_Write_INT16(s, value);
1679 if (Stream_GetPosition(s) >= MUTTER_AUDIO_MESSAGE_FRAMES * MUTTER_AUDIO_FRAME_BYTES)
1680 mutter_audio_post(mutter, s);
1683 (void)pw_stream_queue_buffer(mutter->audio, pb);
1687static const struct pw_stream_events mutter_audio_events = {
1688 PW_VERSION_STREAM_EVENTS,
1689 .process = mutter_on_audio_process,
1696static BOOL mutter_audio_init(mutterShadowSubsystem* mutter)
1698 WINPR_ASSERT(mutter);
1700 uint8_t podBuffer[1024] = WINPR_C_ARRAY_INIT;
1701 struct spa_pod_builder b = SPA_POD_BUILDER_INIT(podBuffer,
sizeof(podBuffer));
1703 AUDIO_FORMAT* formats = audio_formats_new(ARRAYSIZE(mutter_audio_offered_formats));
1708 for (
size_t x = 0; x < ARRAYSIZE(mutter_audio_offered_formats); x++)
1710 const AUDIO_FORMAT* format = &mutter_audio_offered_formats[x];
1711 if (freerdp_dsp_supports_format(format, TRUE))
1712 formats[count++] = *format;
1715 mutter->audioStream =
1716 Stream_New(
nullptr, MUTTER_AUDIO_MESSAGE_FRAMES * MUTTER_AUDIO_FRAME_BYTES);
1717 if (!mutter->audioStream || (count == 0))
1721 pw_stream_new(mutter->core,
"FreeRDP shadow server sound",
1722 pw_properties_new(PW_KEY_MEDIA_TYPE,
"Audio", PW_KEY_MEDIA_CATEGORY,
1723 "Capture", PW_KEY_MEDIA_ROLE,
"Screen",
1724 PW_KEY_STREAM_CAPTURE_SINK,
"true",
nullptr));
1727 pw_stream_add_listener(mutter->audio, &mutter->audioListener, &mutter_audio_events, mutter);
1729 struct spa_audio_info_raw info = WINPR_C_ARRAY_INIT;
1730 info.format = SPA_AUDIO_FORMAT_S16_LE;
1731 info.rate = MUTTER_AUDIO_RATE;
1732 info.channels = MUTTER_AUDIO_CHANNELS;
1733 info.position[0] = SPA_AUDIO_CHANNEL_FL;
1734 info.position[1] = SPA_AUDIO_CHANNEL_FR;
1735 const struct spa_pod* params[] = { spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat,
1739 if (pw_stream_connect(mutter->audio, PW_DIRECTION_INPUT, PW_ID_ANY,
1740 (
enum pw_stream_flags)(PW_STREAM_FLAG_AUTOCONNECT |
1741 PW_STREAM_FLAG_MAP_BUFFERS |
1742 PW_STREAM_FLAG_INACTIVE),
1743 params, ARRAYSIZE(params)) < 0)
1746 mutter->common.rdpsndFormats = formats;
1747 mutter->common.nRdpsndFormats = count;
1752 pw_stream_destroy(mutter->audio);
1753 mutter->audio =
nullptr;
1754 Stream_Free(mutter->audioStream, TRUE);
1755 mutter->audioStream =
nullptr;
1756 audio_formats_free(formats, ARRAYSIZE(mutter_audio_offered_formats));
1760static void mutter_audio_uninit(mutterShadowSubsystem* mutter)
1762 WINPR_ASSERT(mutter);
1765 pw_stream_destroy(mutter->audio);
1766 mutter->audio =
nullptr;
1767 mutter->audioActive = FALSE;
1768 audio_formats_free(mutter->common.rdpsndFormats, mutter->common.nRdpsndFormats);
1769 mutter->common.rdpsndFormats =
nullptr;
1770 mutter->common.nRdpsndFormats = 0;
1771 Stream_Free(mutter->audioStream, TRUE);
1772 mutter->audioStream =
nullptr;
1776static void mutter_audio_follow_clients(mutterShadowSubsystem* mutter)
1778 WINPR_ASSERT(mutter);
1783 const BOOL active = InterlockedCompareExchange(&mutter->clients, 0, 0) > 0;
1784 if (active == mutter->audioActive)
1787 if (pw_stream_set_active(mutter->audio, active) < 0)
1789 WLog_WARN(TAG,
"sound: cannot %s the capture", active ?
"start" :
"stop");
1792 mutter->audioActive = active;
1794 Stream_ResetPosition(mutter->audioStream);
1795 WLog_DBG(TAG,
"sound: capture %s", active ?
"started" :
"stopped");
1803static void mutter_process_ei_events(mutterShadowSubsystem* mutter)
1805 WINPR_ASSERT(mutter);
1807 struct ei_event* e =
nullptr;
1809 ei_dispatch(mutter->ei);
1810 while ((e = ei_get_event(mutter->ei)) !=
nullptr)
1812 struct ei_device* dev = ei_event_get_device(e);
1814 switch (ei_event_get_type(e))
1816 case EI_EVENT_SEAT_ADDED:
1817 ei_seat_bind_capabilities(ei_event_get_seat(e), EI_DEVICE_CAP_POINTER_ABSOLUTE,
1818 EI_DEVICE_CAP_KEYBOARD, EI_DEVICE_CAP_BUTTON,
1819 EI_DEVICE_CAP_SCROLL,
nullptr);
1821 case EI_EVENT_DEVICE_ADDED:
1822 if (ei_device_has_capability(dev, EI_DEVICE_CAP_KEYBOARD) && !mutter->keyboard)
1824 mutter->keyboard = ei_device_ref(dev);
1825 WLog_DBG(TAG,
"libei keyboard '%s'", ei_device_get_name(dev));
1827 if (ei_device_has_capability(dev, EI_DEVICE_CAP_POINTER_ABSOLUTE) &&
1830 mutter->pointer = ei_device_ref(dev);
1831 WLog_DBG(TAG,
"libei pointer '%s'", ei_device_get_name(dev));
1834 case EI_EVENT_DEVICE_RESUMED:
1835 ei_device_start_emulating(dev, ++mutter->sequence);
1836 if (dev == mutter->keyboard)
1837 mutter->keyboardReady = TRUE;
1838 if (dev == mutter->pointer)
1839 mutter->pointerReady = TRUE;
1841 case EI_EVENT_DEVICE_PAUSED:
1842 if (dev == mutter->keyboard)
1843 mutter->keyboardReady = FALSE;
1844 if (dev == mutter->pointer)
1845 mutter->pointerReady = FALSE;
1847 case EI_EVENT_DEVICE_REMOVED:
1848 if (dev == mutter->keyboard)
1850 mutter->keyboard = ei_device_unref(mutter->keyboard);
1851 mutter->keyboardReady = FALSE;
1853 if (dev == mutter->pointer)
1855 mutter->pointer = ei_device_unref(mutter->pointer);
1856 mutter->pointerReady = FALSE;
1859 case EI_EVENT_KEYBOARD_MODIFIERS:
1860 mutter->lockedMods = ei_event_keyboard_get_xkb_mods_locked(e);
1861 mutter->lockedModsKnown = TRUE;
1862 WLog_DBG(TAG,
"keyboard: locked modifiers 0x%08" PRIx32, mutter->lockedMods);
1864 case EI_EVENT_DISCONNECT:
1865 WLog_WARN(TAG,
"libei disconnected: the clients can only watch");
1875static void mutter_key(mutterShadowSubsystem* mutter, uint32_t code, BOOL down)
1877 WINPR_ASSERT(mutter);
1879 if (!mutter->keyboard || !mutter->keyboardReady)
1882 ei_device_keyboard_key(mutter->keyboard, code, down);
1883 ei_device_frame(mutter->keyboard, ei_now(mutter->ei));
1888 if (down && (code == KEY_CAPSLOCK))
1889 mutter->lockedMods ^= MUTTER_MOD_LOCK;
1890 if (down && (code == KEY_NUMLOCK))
1891 mutter->lockedMods ^= MUTTER_MOD_NUM;
1895static BOOL mutter_shadow_input_synchronize_event(rdpShadowSubsystem* subsystem,
1896 rdpShadowClient* client, UINT32 flags)
1898 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
1899 if (!mutter || !client)
1902 EnterCriticalSection(&mutter->eiLock);
1903 WLog_DBG(TAG,
"synchronize: client caps %d num %d, session %s 0x%08" PRIx32,
1904 (flags & KBD_SYNC_CAPS_LOCK) ? 1 : 0, (flags & KBD_SYNC_NUM_LOCK) ? 1 : 0,
1905 mutter->lockedModsKnown ?
"locked" :
"unknown", mutter->lockedMods);
1906 if (mutter->ei && mutter->lockedModsKnown)
1909 const BOOL caps = (flags & KBD_SYNC_CAPS_LOCK) != 0;
1910 const BOOL num = (flags & KBD_SYNC_NUM_LOCK) != 0;
1911 if (caps != ((mutter->lockedMods & MUTTER_MOD_LOCK) != 0))
1913 mutter_key(mutter, KEY_CAPSLOCK, TRUE);
1914 mutter_key(mutter, KEY_CAPSLOCK, FALSE);
1916 if (num != ((mutter->lockedMods & MUTTER_MOD_NUM) != 0))
1918 mutter_key(mutter, KEY_NUMLOCK, TRUE);
1919 mutter_key(mutter, KEY_NUMLOCK, FALSE);
1922 LeaveCriticalSection(&mutter->eiLock);
1927static BOOL mutter_shadow_input_keyboard_event(rdpShadowSubsystem* subsystem,
1928 rdpShadowClient* client, UINT16 flags, UINT8 code)
1930 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
1931 if (!mutter || !client)
1934 DWORD scancode = code;
1935 if (flags & KBD_FLAGS_EXTENDED)
1938 DWORD vkcode = GetVirtualKeyCodeFromVirtualScanCode(scancode, WINPR_KBD_TYPE_IBM_ENHANCED);
1939 if (flags & KBD_FLAGS_EXTENDED)
1942 const DWORD keycode = GetKeycodeFromVirtualKeyCode(vkcode, WINPR_KEYCODE_TYPE_EVDEV);
1945 WLog_DBG(TAG,
"no key for scancode 0x%04" PRIx32, scancode);
1950 const BOOL down = (flags & KBD_FLAGS_RELEASE) == 0;
1952 EnterCriticalSection(&mutter->eiLock);
1954 mutter_key(mutter, keycode, down);
1955 LeaveCriticalSection(&mutter->eiLock);
1960static BOOL mutter_shadow_input_unicode_keyboard_event(rdpShadowSubsystem* subsystem,
1961 rdpShadowClient* client, UINT16 flags,
1964 if (!subsystem || !client)
1968 WLog_DBG(TAG,
"unicode key U+%04" PRIX16
" (flags 0x%04" PRIx16
") not supported", code, flags);
1974static void mutter_pointer_move(mutterShadowSubsystem* mutter, UINT16 x, UINT16 y)
1976 WINPR_ASSERT(mutter);
1978 struct ei_region* region =
nullptr;
1979 struct ei_region* first =
nullptr;
1981 for (
size_t index = 0;; index++)
1983 struct ei_region* r = ei_device_get_region(mutter->pointer, index);
1988 const char*
id = ei_region_get_mapping_id(r);
1989 if (mutter->mappingId &&
id && (strcmp(
id, mutter->mappingId) == 0))
1998 mutter->pointerInput = GetTickCount64();
2001 if (region && (mutter->width > 0) && (mutter->height > 0))
2003 px = ei_region_get_x(region) + (double)x * ei_region_get_width(region) / mutter->width;
2004 py = ei_region_get_y(region) + (double)y * ei_region_get_height(region) / mutter->height;
2007 "pointer %" PRIu16
",%" PRIu16
" -> %.1f,%.1f (region %s %" PRIu32
",%" PRIu32
2008 " %" PRIu32
"x%" PRIu32
")",
2010 region ? (ei_region_get_mapping_id(region) ? ei_region_get_mapping_id(region) :
"-")
2012 region ? ei_region_get_x(region) : 0, region ? ei_region_get_y(region) : 0,
2013 region ? ei_region_get_width(region) : 0, region ? ei_region_get_height(region) : 0);
2014 ei_device_pointer_motion_absolute(mutter->pointer, px, py);
2015 ei_device_frame(mutter->pointer, ei_now(mutter->ei));
2019static void mutter_pointer_button(mutterShadowSubsystem* mutter, uint32_t button, BOOL down)
2021 WINPR_ASSERT(mutter);
2023 if (!ei_device_has_capability(mutter->pointer, EI_DEVICE_CAP_BUTTON))
2025 ei_device_button_button(mutter->pointer, button, down);
2026 ei_device_frame(mutter->pointer, ei_now(mutter->ei));
2030static void mutter_pointer_wheel(mutterShadowSubsystem* mutter, UINT16 flags, BOOL horizontal)
2032 WINPR_ASSERT(mutter);
2034 if (!ei_device_has_capability(mutter->pointer, EI_DEVICE_CAP_SCROLL))
2037 INT32 value = flags & 0xFF;
2038 if (flags & PTR_FLAGS_WHEEL_NEGATIVE)
2044 ei_device_scroll_discrete(mutter->pointer, value, 0);
2046 ei_device_scroll_discrete(mutter->pointer, 0, -value);
2047 ei_device_frame(mutter->pointer, ei_now(mutter->ei));
2051static BOOL mutter_shadow_input_mouse_event(rdpShadowSubsystem* subsystem, rdpShadowClient* client,
2052 UINT16 flags, UINT16 x, UINT16 y)
2054 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
2055 if (!mutter || !client)
2058 EnterCriticalSection(&mutter->eiLock);
2059 if (mutter->ei && mutter->pointer && mutter->pointerReady)
2061 if (flags & PTR_FLAGS_WHEEL)
2062 mutter_pointer_wheel(mutter, flags, FALSE);
2063 else if (flags & PTR_FLAGS_HWHEEL)
2064 mutter_pointer_wheel(mutter, flags, TRUE);
2068 mutter_pointer_move(mutter, x, y);
2070 const BOOL down = (flags & PTR_FLAGS_DOWN) != 0;
2071 if (flags & PTR_FLAGS_BUTTON1)
2072 mutter_pointer_button(mutter, BTN_LEFT, down);
2073 else if (flags & PTR_FLAGS_BUTTON2)
2074 mutter_pointer_button(mutter, BTN_RIGHT, down);
2075 else if (flags & PTR_FLAGS_BUTTON3)
2076 mutter_pointer_button(mutter, BTN_MIDDLE, down);
2079 LeaveCriticalSection(&mutter->eiLock);
2084static BOOL mutter_shadow_input_extended_mouse_event(rdpShadowSubsystem* subsystem,
2085 rdpShadowClient* client, UINT16 flags,
2088 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
2089 if (!mutter || !client)
2092 EnterCriticalSection(&mutter->eiLock);
2093 if (mutter->ei && mutter->pointer && mutter->pointerReady)
2095 mutter_pointer_move(mutter, x, y);
2097 const BOOL down = (flags & PTR_XFLAGS_DOWN) != 0;
2098 if ((flags & PTR_XFLAGS_BUTTON1) != 0)
2099 mutter_pointer_button(mutter, BTN_SIDE, down);
2100 else if ((flags & PTR_XFLAGS_BUTTON2) != 0)
2101 mutter_pointer_button(mutter, BTN_EXTRA, down);
2103 LeaveCriticalSection(&mutter->eiLock);
2115 const char* password;
2116} MUTTER_SHADOW_PAM_DATA;
2119static int mutter_shadow_pam_conv(
int num_msg,
const struct pam_message** msg,
2120 struct pam_response** resp,
void* appdata_ptr)
2122 const MUTTER_SHADOW_PAM_DATA* data = (
const MUTTER_SHADOW_PAM_DATA*)appdata_ptr;
2124 if ((num_msg <= 0) || !msg || !resp || !data)
2125 return PAM_CONV_ERR;
2127 struct pam_response* response = calloc((
size_t)num_msg,
sizeof(
struct pam_response));
2131 for (
int index = 0; index < num_msg; index++)
2133 const char* answer =
nullptr;
2134 switch (msg[index]->msg_style)
2136 case PAM_PROMPT_ECHO_ON:
2137 answer = data->user;
2139 case PAM_PROMPT_ECHO_OFF:
2140 answer = data->password;
2146 response[index].resp = _strdup(answer);
2147 if (!response[index].resp)
2149 for (
int x = 0; x < index; x++)
2150 free(response[x].resp);
2163static int mutter_shadow_pam_authenticate(WINPR_ATTR_UNUSED rdpShadowSubsystem* subsystem,
2164 WINPR_ATTR_UNUSED rdpShadowClient* client,
2165 const char* user, WINPR_ATTR_UNUSED
const char* domain,
2166 const char* password)
2168 if (!user || !password)
2171 struct passwd pbuffer = WINPR_C_ARRAY_INIT;
2172 struct passwd* owner =
nullptr;
2175 long buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
2178 char* buf = calloc((
size_t)buflen,
sizeof(
char));
2181 WLog_ERR(TAG,
"login as '%s' refused: no memory for the session's account", user);
2184 const int rc = getpwuid_r(getuid(), &pbuffer, buf, (
size_t)buflen, &owner);
2187 char msg[128] = WINPR_C_ARRAY_INIT;
2188 WLog_ERR(TAG,
"login as '%s' refused: the session's account: %s", user,
2189 winpr_strerror(rc, msg,
sizeof(msg)));
2193 if (!owner || !owner->pw_name || (strcmp(owner->pw_name, user) != 0))
2195 WLog_ERR(TAG,
"login as '%s' refused: this session belongs to '%s'", user,
2196 (owner && owner->pw_name) ? owner->pw_name :
"?");
2201 MUTTER_SHADOW_PAM_DATA data = { .user = user, .password = password };
2202 const struct pam_conv conv = { .conv = mutter_shadow_pam_conv, .appdata_ptr = &data };
2203 pam_handle_t* handle =
nullptr;
2206 const char* service =
2207 winpr_PathFileExists(
"/etc/pam.d/freerdp-shadow") ?
"freerdp-shadow" :
"login";
2208 int status = pam_start(service, user, &conv, &handle);
2209 if (status != PAM_SUCCESS)
2211 WLog_ERR(TAG,
"pam_start(%s) failure: %s", service, pam_strerror(handle, status));
2216 status = pam_authenticate(handle, 0);
2217 if (status == PAM_SUCCESS)
2218 status = pam_acct_mgmt(handle, 0);
2219 if (status != PAM_SUCCESS)
2220 WLog_ERR(TAG,
"login as '%s' failed: %s", user, pam_strerror(handle, status));
2222 pam_end(handle, status);
2224 return (status == PAM_SUCCESS) ? 1 : -1;
2232static void mutter_shadow_refresh(mutterShadowSubsystem* mutter)
2234 WINPR_ASSERT(mutter);
2238 mutter->fullPaint = TRUE;
2239 mutter->cursorResend = TRUE;
2242 if (!mutter->virtualMonitor)
2244 static const BYTE clear[4] = { 0 };
2245 mutter_cursor_send_shape(mutter, clear, 1, 1, 0, 0);
2247 else if (mutter->cursorPixels)
2248 mutter_cursor_send_shape(mutter, mutter->cursorPixels, mutter->cursorWidth,
2249 mutter->cursorHeight, mutter->cursorXHot, mutter->cursorYHot);
2251 mutter_cursor_send_default(mutter);
2253 rdpShadowServer* server = mutter->common.server;
2254 rdpShadowSurface* surface = server ? server->surface :
nullptr;
2258 EnterCriticalSection(&surface->lock);
2259 const RECTANGLE_16 all = { 0, 0, (UINT16)surface->width, (UINT16)surface->height };
2260 if (!region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &all))
2261 WLog_ERR(TAG,
"cannot mark the screen changed");
2262 LeaveCriticalSection(&surface->lock);
2265 if (ArrayList_Count(server->clients) > 0)
2266 shadow_subsystem_frame_update(&mutter->common);
2268 EnterCriticalSection(&surface->lock);
2269 region16_clear(&surface->invalidRegion);
2270 LeaveCriticalSection(&surface->lock);
2287} mutterClipboardJob;
2289static void mutter_clipboard_job_free(mutterClipboardJob* job)
2295 for (
char** mime = job->mimes; *mime; mime++)
2298 free((
void*)job->mimes);
2302 (void)close(job->fd);
2306WINPR_ATTR_MALLOC(mutter_clipboard_job_free, 1)
2307static mutterClipboardJob* mutter_clipboard_job_new(
void)
2309 mutterClipboardJob* job = calloc(1,
sizeof(mutterClipboardJob));
2315static void mutter_clipboard_message_free(wMessage* message)
2317 WINPR_ASSERT(message);
2318 mutter_clipboard_job_free(message->context);
2322static BOOL mutter_clipboard_post(wMessageQueue* queue, UINT32
id, mutterClipboardJob* job)
2324 WINPR_ASSERT(queue);
2327 wMessage message = WINPR_C_ARRAY_INIT;
2328 message.context = job;
2330 message.Free = mutter_clipboard_message_free;
2331 if (MessageQueue_Dispatch(queue, &message))
2333 mutter_clipboard_job_free(job);
2339static BOOL mutter_clipboard_offer(rdpShadowSubsystem* subsystem,
const char*
const* mimeTypes,
2342 WINPR_ASSERT(subsystem);
2343 WINPR_ASSERT(subsystem->MsgPipe);
2345 mutterClipboardJob* job = mutter_clipboard_job_new();
2349 job->mimes = (
char**)calloc(count + 1,
sizeof(
char*));
2352 for (
size_t x = 0; x < count; x++)
2354 job->mimes[x] = _strdup(mimeTypes[x]);
2358 return mutter_clipboard_post(subsystem->MsgPipe->In, MUTTER_MSG_CLIPBOARD_OFFER, job);
2361 mutter_clipboard_job_free(job);
2366static BOOL mutter_clipboard_read(rdpShadowSubsystem* subsystem,
const char* mimeType)
2368 WINPR_ASSERT(subsystem);
2369 WINPR_ASSERT(subsystem->MsgPipe);
2370 WINPR_ASSERT(mimeType);
2372 mutterClipboardJob* job = mutter_clipboard_job_new();
2376 job->mime = _strdup(mimeType);
2379 mutter_clipboard_job_free(job);
2382 return mutter_clipboard_post(subsystem->MsgPipe->In, MUTTER_MSG_CLIPBOARD_READ, job);
2386static BOOL mutter_clipboard_provide(rdpShadowSubsystem* subsystem, UINT32 request,
2387 const BYTE* data,
size_t size)
2389 WINPR_ASSERT(subsystem);
2390 WINPR_ASSERT(subsystem->MsgPipe);
2392 mutterClipboardJob* job = mutter_clipboard_job_new();
2396 job->serial = request;
2399 job->data = malloc(size);
2402 mutter_clipboard_job_free(job);
2405 memcpy(job->data, data, size);
2409 return mutter_clipboard_post(subsystem->MsgPipe->In, MUTTER_MSG_CLIPBOARD_PROVIDE, job);
2414static int mutter_clipboard_call_for_fd(mutterShadowSubsystem* mutter,
const char* method,
2415 const char* types, ...)
2417 WINPR_ASSERT(mutter);
2419 sd_bus_error err = SD_BUS_ERROR_NULL;
2420 sd_bus_message* call =
nullptr;
2421 sd_bus_message* reply =
nullptr;
2424 if (sd_bus_message_new_method_call(mutter->bus, &call, RD_NAME, mutter->rdSessionPath,
2425 RD_SESSION_IFACE, method) < 0)
2428 va_list ap = WINPR_C_ARRAY_INIT;
2429 va_start(ap, types);
2430 const int appended = sd_bus_message_appendv(call, types, ap);
2433 if ((appended >= 0) &&
2434 (sd_bus_call(mutter->bus, call, MUTTER_CLIPBOARD_CALL_USEC, &err, &reply) >= 0) &&
2435 (sd_bus_message_read(reply,
"h", &fd) >= 0))
2436 fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2439 WLog_WARN(TAG,
"clipboard: %s failed: %s", method, err.message ? err.message :
"bad reply");
2443 sd_bus_error_free(&err);
2444 sd_bus_message_unref(reply);
2445 sd_bus_message_unref(call);
2449static void mutter_clipboard_write_done(mutterShadowSubsystem* mutter, UINT32 serial, BOOL ok)
2451 WINPR_ASSERT(mutter);
2454 sd_bus_call_method(mutter->bus, RD_NAME, mutter->rdSessionPath, RD_SESSION_IFACE,
2455 "SelectionWriteDone",
nullptr,
nullptr,
"ub", serial, ok ? 1 : 0);
2458 char buffer[128] = WINPR_C_ARRAY_INIT;
2459 WLog_WARN(TAG,
"clipboard: SelectionWriteDone failed: %s",
2460 winpr_strerror(-rc, buffer,
sizeof(buffer)));
2465static void mutter_clipboard_set_selection(mutterShadowSubsystem* mutter,
2466 const mutterClipboardJob* job)
2468 WINPR_ASSERT(mutter);
2470 WINPR_ASSERT(job->mimes);
2472 sd_bus_error err = SD_BUS_ERROR_NULL;
2473 sd_bus_message* call =
nullptr;
2476 int rc = sd_bus_message_new_method_call(mutter->bus, &call, RD_NAME, mutter->rdSessionPath,
2477 RD_SESSION_IFACE,
"SetSelection");
2479 rc = sd_bus_message_open_container(call,
'a',
"{sv}");
2480 if ((rc >= 0) && job->mimes[0])
2482 rc = sd_bus_message_open_container(call,
'e',
"sv");
2484 rc = sd_bus_message_append(call,
"s",
"mime-types");
2486 rc = sd_bus_message_open_container(call,
'v',
"as");
2488 rc = sd_bus_message_append_strv(call, job->mimes);
2490 rc = sd_bus_message_close_container(call);
2492 rc = sd_bus_message_close_container(call);
2495 rc = sd_bus_message_close_container(call);
2497 rc = sd_bus_call(mutter->bus, call, MUTTER_CLIPBOARD_CALL_USEC, &err,
nullptr);
2500 char buffer[128] = WINPR_C_ARRAY_INIT;
2501 WLog_WARN(TAG,
"clipboard: SetSelection failed: %s",
2502 err.message ? err.message : winpr_strerror(-rc, buffer,
sizeof(buffer)));
2505 sd_bus_error_free(&err);
2506 sd_bus_message_unref(call);
2510static void mutter_clipboard_start_read(mutterShadowSubsystem* mutter, wMessage* message)
2512 WINPR_ASSERT(mutter);
2513 WINPR_ASSERT(message);
2515 mutterClipboardJob* job = message->context;
2518 job->fd = mutter_clipboard_call_for_fd(mutter,
"SelectionRead",
"s", job->mime);
2519 if ((job->fd >= 0) && mutter->clipboardJobs)
2521 message->Free =
nullptr;
2522 if (mutter_clipboard_post(mutter->clipboardJobs, MUTTER_MSG_CLIPBOARD_READ, job))
2525 if (!shadow_clipboard_session_data(mutter->common.server,
nullptr, 0))
2526 WLog_DBG(TAG,
"clipboard: no read was waiting");
2530static void mutter_clipboard_start_write(mutterShadowSubsystem* mutter, wMessage* message)
2532 WINPR_ASSERT(mutter);
2533 WINPR_ASSERT(message);
2535 mutterClipboardJob* job = message->context;
2540 job->fd = mutter_clipboard_call_for_fd(mutter,
"SelectionWrite",
"u", job->serial);
2541 if ((job->fd >= 0) && mutter->clipboardJobs)
2543 const UINT32 serial = job->serial;
2544 message->Free =
nullptr;
2545 if (mutter_clipboard_post(mutter->clipboardJobs, MUTTER_MSG_CLIPBOARD_PROVIDE, job))
2547 mutter_clipboard_write_done(mutter, serial, FALSE);
2551 mutter_clipboard_write_done(mutter, job->serial, FALSE);
2556static short mutter_clipboard_wait(mutterShadowSubsystem* mutter,
int fd,
short events)
2558 WINPR_ASSERT(mutter);
2560 struct pollfd fds[2] = { { fd, events, 0 },
2561 { GetEventFileDescriptor(mutter->stopEvent), POLLIN, 0 } };
2565 ready = poll(fds, ARRAYSIZE(fds), MUTTER_CLIPBOARD_STALL_MS);
2566 }
while ((ready < 0) && (errno == EINTR));
2568 if ((ready <= 0) || (fds[1].revents != 0))
2570 return fds[0].revents;
2575static BOOL mutter_clipboard_read_all(mutterShadowSubsystem* mutter, mutterClipboardJob* job)
2577 WINPR_ASSERT(mutter);
2580 if (fcntl(job->fd, F_SETFL, fcntl(job->fd, F_GETFL) | O_NONBLOCK) < 0)
2583 size_t capacity = 0;
2586 if (job->size + 4096 > capacity)
2588 const size_t wanted = capacity ? capacity * 2 : 64ull * 1024ull;
2589 if (wanted > SHADOW_CLIPBOARD_MAX_SIZE)
2591 WLog_WARN(TAG,
"clipboard: the selection is too large");
2594 BYTE* grown = realloc(job->data, wanted);
2601 if (mutter_clipboard_wait(mutter, job->fd, POLLIN) == 0)
2604 const ssize_t got = read(job->fd, &job->data[job->size], capacity - job->size);
2608 job->size += (size_t)got;
2609 else if ((errno != EAGAIN) && (errno != EINTR))
2616static BOOL mutter_clipboard_write_all(mutterShadowSubsystem* mutter, mutterClipboardJob* job)
2618 WINPR_ASSERT(mutter);
2621 if (fcntl(job->fd, F_SETFL, fcntl(job->fd, F_GETFL) | O_NONBLOCK) < 0)
2625 while (done < job->size)
2627 if (mutter_clipboard_wait(mutter, job->fd, POLLOUT) == 0)
2630 const ssize_t put = write(job->fd, &job->data[done], job->size - done);
2632 done += (size_t)put;
2633 else if ((errno != EAGAIN) && (errno != EINTR))
2640static DWORD WINAPI mutter_clipboard_thread(LPVOID arg)
2642 mutterShadowSubsystem* mutter = arg;
2643 WINPR_ASSERT(mutter);
2645 while (MessageQueue_Wait(mutter->clipboardJobs))
2647 wMessage message = WINPR_C_ARRAY_INIT;
2648 if (!MessageQueue_Peek(mutter->clipboardJobs, &message, TRUE))
2650 if (message.id == WMQ_QUIT)
2653 mutterClipboardJob* job = message.context;
2656 if (message.id == MUTTER_MSG_CLIPBOARD_READ)
2658 const BOOL ok = mutter_clipboard_read_all(mutter, job);
2660 WLog_WARN(TAG,
"clipboard: reading %s failed", job->mime);
2661 if (!shadow_clipboard_session_data(mutter->common.server, ok ? job->data :
nullptr,
2663 WLog_DBG(TAG,
"clipboard: no read was waiting");
2664 mutter_clipboard_job_free(job);
2668 job->ok = mutter_clipboard_write_all(mutter, job);
2670 WLog_WARN(TAG,
"clipboard: writing to the session failed");
2671 (void)close(job->fd);
2673 if (!mutter_clipboard_post(mutter->common.MsgPipe->In, MUTTER_MSG_CLIPBOARD_WRITE_DONE,
2675 WLog_WARN(TAG,
"clipboard: cannot finish a transfer");
2685static size_t mutter_clipboard_read_mimes(sd_bus_message* msg,
2686 const char* mimes[MUTTER_CLIPBOARD_MAX_MIMES])
2690 const char* contents =
nullptr;
2692 if ((sd_bus_message_peek_type(msg, &type, &contents) <= 0) || !contents)
2695 const BOOL inStruct = contents[0] ==
'(';
2696 if ((strcmp(contents,
"as") != 0) && (strcmp(contents,
"(as)") != 0))
2698 (void)sd_bus_message_skip(msg,
"v");
2703 if (sd_bus_message_enter_container(msg,
'v', contents) <= 0)
2705 if (inStruct && (sd_bus_message_enter_container(msg,
'r',
"as") <= 0))
2707 if (sd_bus_message_enter_container(msg,
'a',
"s") > 0)
2709 const char* mime =
nullptr;
2710 while (sd_bus_message_read(msg,
"s", &mime) > 0)
2712 if (count < MUTTER_CLIPBOARD_MAX_MIMES)
2713 mimes[count++] = mime;
2715 (void)sd_bus_message_exit_container(msg);
2718 (void)sd_bus_message_exit_container(msg);
2719 (void)sd_bus_message_exit_container(msg);
2724static int mutter_on_selection_owner_changed(sd_bus_message* msg,
void* data,
2725 WINPR_ATTR_UNUSED sd_bus_error* err)
2727 mutterShadowSubsystem* mutter = data;
2728 WINPR_ASSERT(mutter);
2730 const char* mimes[MUTTER_CLIPBOARD_MAX_MIMES] = WINPR_C_ARRAY_INIT;
2732 int sessionIsOwner = 0;
2734 if (sd_bus_message_enter_container(msg,
'a',
"{sv}") <= 0)
2736 while (sd_bus_message_enter_container(msg,
'e',
"sv") > 0)
2738 const char* key =
nullptr;
2739 if (sd_bus_message_read(msg,
"s", &key) < 0)
2742 if (strcmp(key,
"mime-types") == 0)
2743 count = mutter_clipboard_read_mimes(msg, mimes);
2744 else if (strcmp(key,
"session-is-owner") == 0)
2745 (void)sd_bus_message_read(msg,
"v",
"b", &sessionIsOwner);
2747 (
void)sd_bus_message_skip(msg,
"v");
2748 (void)sd_bus_message_exit_container(msg);
2755 WLog_DBG(TAG,
"clipboard: the session offers %" PRIuz
" mime types", count);
2756 if (!shadow_clipboard_session_changed(mutter->common.server, mimes, count))
2757 WLog_WARN(TAG,
"clipboard: cannot announce the session's clipboard");
2762static int mutter_on_selection_transfer(sd_bus_message* msg,
void* data,
2763 WINPR_ATTR_UNUSED sd_bus_error* err)
2765 mutterShadowSubsystem* mutter = data;
2766 WINPR_ASSERT(mutter);
2768 const char* mime =
nullptr;
2769 uint32_t serial = 0;
2770 if (sd_bus_message_read(msg,
"su", &mime, &serial) < 0)
2773 if (!shadow_clipboard_session_request(mutter->common.server, serial, mime))
2774 mutter_clipboard_write_done(mutter, serial, FALSE);
2779static void mutter_clipboard_enable(mutterShadowSubsystem* mutter)
2781 WINPR_ASSERT(mutter);
2783 sd_bus_error err = SD_BUS_ERROR_NULL;
2784 if ((sd_bus_match_signal(mutter->bus, &mutter->selectionOwnerSlot, RD_NAME,
2785 mutter->rdSessionPath, RD_SESSION_IFACE,
"SelectionOwnerChanged",
2786 mutter_on_selection_owner_changed, mutter) < 0) ||
2787 (sd_bus_match_signal(mutter->bus, &mutter->selectionTransferSlot, RD_NAME,
2788 mutter->rdSessionPath, RD_SESSION_IFACE,
"SelectionTransfer",
2789 mutter_on_selection_transfer, mutter) < 0))
2790 WLog_WARN(TAG,
"cannot watch the session's clipboard: no clipboard");
2795 sd_bus_call_method(mutter->bus, RD_NAME, mutter->rdSessionPath, RD_SESSION_IFACE,
2796 "EnableClipboard", &err,
nullptr,
"a{sv}", 0);
2799 char buffer[128] = WINPR_C_ARRAY_INIT;
2800 WLog_WARN(TAG,
"EnableClipboard failed: %s: no clipboard",
2801 err.message ? err.message : winpr_strerror(-enabled, buffer,
sizeof(buffer)));
2805 mutter->clipboardEnabled = TRUE;
2806 mutter->common.ClipboardOffer = mutter_clipboard_offer;
2807 mutter->common.ClipboardRead = mutter_clipboard_read;
2808 mutter->common.ClipboardProvide = mutter_clipboard_provide;
2811 sd_bus_error_free(&err);
2817static void mutter_unlock_screen(mutterShadowSubsystem* mutter)
2819 WINPR_ASSERT(mutter);
2821 sd_bus_error err = SD_BUS_ERROR_NULL;
2822 sd_bus_message* reply =
nullptr;
2824 int rc = sd_bus_call_method(mutter->bus, SCREEN_SAVER_NAME, SCREEN_SAVER_PATH,
2825 SCREEN_SAVER_NAME,
"GetActive", &err, &reply,
"");
2827 rc = sd_bus_message_read(reply,
"b", &locked);
2828 sd_bus_message_unref(reply);
2830 if ((rc >= 0) && locked)
2832 rc = sd_bus_call_method(mutter->bus, SCREEN_SAVER_NAME, SCREEN_SAVER_PATH,
2833 SCREEN_SAVER_NAME,
"SetActive", &err,
nullptr,
"b", 0);
2835 WLog_INFO(TAG,
"the login unlocked the session");
2839 char buffer[128] = WINPR_C_ARRAY_INIT;
2840 WLog_WARN(TAG,
"the screen stays as it is: %s",
2841 err.message ? err.message : winpr_strerror(-rc, buffer,
sizeof(buffer)));
2843 sd_bus_error_free(&err);
2846static void mutter_shadow_process_message(mutterShadowSubsystem* mutter, wMessage* message)
2848 WINPR_ASSERT(mutter);
2849 WINPR_ASSERT(message);
2851 switch (message->id)
2853 case SHADOW_MSG_IN_REFRESH_REQUEST_ID:
2854 mutter_shadow_refresh(mutter);
2857 case MUTTER_MSG_CLIPBOARD_OFFER:
2858 mutter_clipboard_set_selection(mutter, message->context);
2861 case MUTTER_MSG_CLIPBOARD_READ:
2862 mutter_clipboard_start_read(mutter, message);
2865 case MUTTER_MSG_CLIPBOARD_PROVIDE:
2866 mutter_clipboard_start_write(mutter, message);
2869 case MUTTER_MSG_CLIPBOARD_WRITE_DONE:
2871 const mutterClipboardJob* job = message->context;
2873 mutter_clipboard_write_done(mutter, job->serial, job->ok);
2877 case MUTTER_MSG_VIRTUAL_SIZE:
2878 mutter_virtual_resize(mutter, (UINT32)(
size_t)message->wParam,
2879 (UINT32)(
size_t)message->lParam);
2882 case MUTTER_MSG_UNLOCK:
2883 mutter_unlock_screen(mutter);
2887 WLog_ERR(TAG,
"Unknown message id: %" PRIu32
"", message->id);
2892 message->Free(message);
2897static void mutter_record_again(mutterShadowSubsystem* mutter)
2899 WINPR_ASSERT(mutter);
2901 mutter->streamGone = FALSE;
2902 const char* connector = mutter->connectors[mutter->common.selectedMonitor];
2903 WLog_INFO(TAG,
"Mutter ended the stream of %s (its layout changed): recording it again",
2904 connector[0] ? connector :
"the primary monitor");
2906 mutter->streamAddedSlot = sd_bus_slot_unref(mutter->streamAddedSlot);
2907 free(mutter->streamPath);
2908 mutter->streamPath =
nullptr;
2910 sd_bus_error err = SD_BUS_ERROR_NULL;
2912 if (mutter_record_monitor(mutter, connector))
2914 mutter->awaitNode = TRUE;
2915 started = sd_bus_call_method(mutter->bus, SC_NAME, mutter->streamPath, SC_STREAM_IFACE,
2916 "Start", &err,
nullptr,
"");
2919 char buffer[128] = WINPR_C_ARRAY_INIT;
2920 WLog_ERR(TAG,
"ScreenCast.Stream.Start failed: %s",
2921 err.message ? err.message : winpr_strerror(-started, buffer,
sizeof(buffer)));
2924 sd_bus_error_free(&err);
2930 mutter->awaitNode = FALSE;
2931 while (sd_bus_process(mutter->bus,
nullptr) > 0)
2934 if (!mutter->closed)
2935 mutter->monitorGone = TRUE;
2936 mutter->closed = TRUE;
2941static void mutter_reconnect(mutterShadowSubsystem* mutter)
2943 WINPR_ASSERT(mutter);
2945 mutter->reconnect = FALSE;
2946 if (!mutter_stream_connect_node(mutter))
2948 mutter->monitorGone = TRUE;
2949 mutter->closed = TRUE;
2952 mutter_read_stream_parameters(mutter);
2953 mutter->fullPaint = TRUE;
2954 WLog_INFO(TAG,
"sharing again from PipeWire node %" PRIu32, mutter->nodeId);
2958static DWORD WINAPI mutter_shadow_subsystem_thread(LPVOID arg)
2960 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)arg;
2961 WINPR_ASSERT(mutter);
2964 HANDLE events[6] = WINPR_C_ARRAY_INIT;
2967 HANDLE busEvent = CreateFileDescriptorEventA(
nullptr, FALSE, FALSE, sd_bus_get_fd(mutter->bus),
2969 HANDLE pwEvent = CreateFileDescriptorEventA(
nullptr, FALSE, FALSE, pw_loop_get_fd(mutter->loop),
2971 HANDLE eiEvent = mutter->ei ? CreateFileDescriptorEventA(
nullptr, FALSE, FALSE,
2972 ei_get_fd(mutter->ei), WINPR_FD_READ)
2974 if (!busEvent || !pwEvent || (mutter->ei && !eiEvent))
2976 WLog_ERR(TAG,
"cannot wait on the session's connections");
2980 events[count++] = mutter->stopEvent;
2981 events[count++] = MessageQueue_Event(MsgPipe->In);
2982 events[count++] = mutter->clientsEvent;
2983 events[count++] = busEvent;
2984 events[count++] = pwEvent;
2986 events[count++] = eiEvent;
2992 uint64_t usec = UINT64_MAX;
2993 DWORD timeout = 1000;
2994 if ((sd_bus_get_timeout(mutter->bus, &usec) >= 0) && (usec != UINT64_MAX))
2996 struct timespec ts = WINPR_C_ARRAY_INIT;
2997 (void)clock_gettime(CLOCK_MONOTONIC, &ts);
2998 const uint64_t now = (uint64_t)ts.tv_sec * 1000000ull + (uint64_t)ts.tv_nsec / 1000ull;
2999 const uint64_t waitMs = (usec > now) ? (usec - now + 999) / 1000 : 0;
3000 timeout = (DWORD)MIN(waitMs, 1000);
3002 if (mutter->streamGone)
3003 timeout = MIN(timeout, 50);
3005 const DWORD status = WaitForMultipleObjects(count, events, FALSE, timeout);
3006 if ((status == WAIT_FAILED) || (WaitForSingleObject(mutter->stopEvent, 0) == WAIT_OBJECT_0))
3009 while (sd_bus_process(mutter->bus,
nullptr) > 0)
3012 (void)sd_bus_flush(mutter->bus);
3013 if (mutter->closed && !mutter->closedLogged)
3019 if (mutter->shellGone)
3020 WLog_WARN(TAG,
"GNOME Shell left the session: the server ends");
3021 else if (mutter->monitorGone)
3022 WLog_WARN(TAG,
"the shared monitor is gone: the server ends");
3024 WLog_WARN(TAG,
"the GNOME session stopped the sharing (its user did, or GNOME "
3025 "Shell is ending): the server ends");
3026 mutter->closedLogged = TRUE;
3027 if (mutter->common.server)
3028 (void)SetEvent(mutter->common.server->StopEvent);
3031 if (WaitForSingleObject(mutter->clientsEvent, 0) == WAIT_OBJECT_0)
3034 (void)ResetEvent(mutter->clientsEvent);
3035 mutter_audio_follow_clients(mutter);
3038 pw_loop_enter(mutter->loop);
3039 (void)pw_loop_iterate(mutter->loop, 0);
3040 pw_loop_leave(mutter->loop);
3044 if (mutter->streamGone && !mutter->closed &&
3045 (GetTickCount64() - mutter->streamGoneAt >= MUTTER_STREAM_GONE_GRACE_MS))
3046 mutter_record_again(mutter);
3047 if (mutter->reconnect && !mutter->closed)
3048 mutter_reconnect(mutter);
3052 EnterCriticalSection(&mutter->eiLock);
3053 mutter_process_ei_events(mutter);
3054 LeaveCriticalSection(&mutter->eiLock);
3057 wMessage message = WINPR_C_ARRAY_INIT;
3058 while (MessageQueue_Peek(MsgPipe->In, &message, TRUE))
3060 if (message.id == WMQ_QUIT)
3062 mutter_shadow_process_message(mutter, &message);
3068 (void)CloseHandle(busEvent);
3070 (void)CloseHandle(pwEvent);
3072 (void)CloseHandle(eiEvent);
3078static BOOL mutter_shadow_client_resize(rdpShadowSubsystem* subsystem, rdpShadowClient* client,
3079 UINT32 width, UINT32 height);
3082static int mutter_shadow_subsystem_init(rdpShadowSubsystem* subsystem)
3084 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3085 WINPR_ASSERT(mutter);
3087 const int opened = sd_bus_open_user(&mutter->bus);
3090 char buffer[128] = WINPR_C_ARRAY_INIT;
3092 "cannot connect to the session bus: %s (start the server inside the GNOME "
3093 "session, as its user)",
3094 winpr_strerror(-opened, buffer,
sizeof(buffer)));
3098 if (!mutter_wait_for_name(mutter->bus, RD_NAME, MUTTER_NAME_TIMEOUT_MS))
3100 WLog_ERR(TAG,
"%s is not on the session bus: is this a GNOME session?", RD_NAME);
3105 mutter->virtualMonitor = mutter_virtual_size(&mutter->virtualWidth, &mutter->virtualHeight);
3109 const char* check = getenv(MUTTER_DAMAGE_CHECK_ENV);
3110 mutter->damageCheck = !check || (strcmp(check,
"0") != 0);
3111 if (!mutter->damageCheck)
3112 WLog_INFO(TAG,
"the check for changes Mutter left out of its damage is off");
3114 if (mutter->virtualMonitor)
3116 mutter->common.ClientResize = mutter_shadow_client_resize;
3118 subsystem->monitors[0] = (
MONITOR_DEF){ 0, 0, (INT32)mutter->virtualWidth - 1,
3119 (INT32)mutter->virtualHeight - 1, 1 };
3120 mutter->connectors[0][0] =
'\0';
3125 WLog_DBG(TAG,
"DisplayConfig.GetCurrentState");
3126 count = mutter_list_monitors(mutter->bus, subsystem->monitors, mutter->connectors,
3127 MUTTER_SHADOW_MAX_MONITORS);
3132 WLog_WARN(TAG,
"no monitor layout from Mutter: sharing the primary monitor");
3133 subsystem->monitors[0] = (
MONITOR_DEF){ 0, 0, 0, 0, 1 };
3134 mutter->connectors[0][0] =
'\0';
3137 subsystem->numMonitors = count;
3138 if (subsystem->selectedMonitor >= count)
3139 subsystem->selectedMonitor = 0;
3141 const char* connector = mutter->connectors[subsystem->selectedMonitor];
3142 if (!mutter_setup_sessions(mutter, connector))
3144 if (!mutter_connect_stream(mutter))
3147 mutter_set_monitor_size(mutter);
3149 if (!mutter_audio_init(mutter))
3150 WLog_WARN(TAG,
"sound: no capture of the default sink: no sound");
3156 if (subsystem->server)
3157 subsystem->server->ShowMouseCursor = TRUE;
3159 if (mutter->virtualMonitor)
3160 WLog_INFO(TAG,
"sharing a virtual monitor of its own: %" PRIu32
"x%" PRIu32
", input %s",
3161 mutter->width, mutter->height, mutter->ei ?
"through libei" :
"off");
3164 "sharing monitor %s (%" PRIu32
" of %" PRIu32
"): %" PRIu32
"x%" PRIu32
3166 connector[0] ? connector :
"(primary)", subsystem->selectedMonitor, count,
3167 mutter->width, mutter->height, mutter->ei ?
"through libei" :
"off");
3172static int mutter_shadow_subsystem_uninit(rdpShadowSubsystem* subsystem)
3174 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3178 mutter_audio_uninit(mutter);
3180 pw_stream_destroy(mutter->stream);
3181 mutter->stream =
nullptr;
3182 if (mutter->registry)
3184 spa_hook_remove(&mutter->registryListener);
3185 pw_proxy_destroy((
struct pw_proxy*)mutter->registry);
3187 mutter->registry =
nullptr;
3189 pw_core_disconnect(mutter->core);
3190 mutter->core =
nullptr;
3191 if (mutter->context)
3192 pw_context_destroy(mutter->context);
3193 mutter->context =
nullptr;
3195 pw_loop_destroy(mutter->loop);
3196 mutter->loop =
nullptr;
3198 EnterCriticalSection(&mutter->eiLock);
3199 mutter->keyboard = ei_device_unref(mutter->keyboard);
3200 mutter->pointer = ei_device_unref(mutter->pointer);
3201 mutter->ei = ei_unref(mutter->ei);
3202 mutter->keyboardReady = FALSE;
3203 mutter->pointerReady = FALSE;
3204 LeaveCriticalSection(&mutter->eiLock);
3208 if (mutter->started && !mutter->closed && mutter->rdSessionPath)
3209 (void)sd_bus_call_method(mutter->bus, RD_NAME, mutter->rdSessionPath, RD_SESSION_IFACE,
3210 "Stop",
nullptr,
nullptr,
"");
3211 mutter->streamAddedSlot = sd_bus_slot_unref(mutter->streamAddedSlot);
3212 mutter->closedSlot = sd_bus_slot_unref(mutter->closedSlot);
3213 mutter->ownerSlot = sd_bus_slot_unref(mutter->ownerSlot);
3214 mutter->selectionOwnerSlot = sd_bus_slot_unref(mutter->selectionOwnerSlot);
3215 mutter->selectionTransferSlot = sd_bus_slot_unref(mutter->selectionTransferSlot);
3216 mutter->bus = sd_bus_flush_close_unref(mutter->bus);
3218 mutter->started = FALSE;
3220 free(mutter->rdSessionPath);
3221 mutter->rdSessionPath =
nullptr;
3222 free(mutter->scSessionPath);
3223 mutter->scSessionPath =
nullptr;
3224 free(mutter->streamPath);
3225 mutter->streamPath =
nullptr;
3226 free(mutter->mappingId);
3227 mutter->mappingId =
nullptr;
3232static int mutter_shadow_subsystem_start(rdpShadowSubsystem* subsystem)
3234 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3235 if (!mutter || !mutter->bus || !mutter->loop)
3238 (void)ResetEvent(mutter->stopEvent);
3239 if (mutter->clipboardEnabled)
3241 mutter->clipboardJobs = MessageQueue_New(
nullptr);
3242 if (mutter->clipboardJobs)
3243 mutter->clipboardThread =
3244 CreateThread(
nullptr, 0, mutter_clipboard_thread, mutter, 0,
nullptr);
3245 if (!mutter->clipboardThread)
3247 WLog_ERR(TAG,
"Failed to create the clipboard thread");
3252 mutter->thread = CreateThread(
nullptr, 0, mutter_shadow_subsystem_thread, mutter, 0,
nullptr);
3253 if (!mutter->thread)
3255 WLog_ERR(TAG,
"Failed to create thread");
3262static int mutter_shadow_subsystem_stop(rdpShadowSubsystem* subsystem)
3264 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3270 (void)SetEvent(mutter->stopEvent);
3271 (void)WaitForSingleObject(mutter->thread, INFINITE);
3272 (void)CloseHandle(mutter->thread);
3273 mutter->thread =
nullptr;
3276 if (mutter->clipboardThread)
3278 (void)SetEvent(mutter->stopEvent);
3279 if (!MessageQueue_PostQuit(mutter->clipboardJobs, 0))
3280 WLog_WARN(TAG,
"cannot stop the clipboard thread");
3281 (void)WaitForSingleObject(mutter->clipboardThread, INFINITE);
3282 (void)CloseHandle(mutter->clipboardThread);
3283 mutter->clipboardThread =
nullptr;
3285 MessageQueue_Free(mutter->clipboardJobs);
3286 mutter->clipboardJobs =
nullptr;
3294static UINT32 mutter_virtual_side(UINT32 side, UINT32 least)
3296 return MIN(MAX(side, least), 8192) & ~1u;
3300static BOOL mutter_virtual_request(mutterShadowSubsystem* mutter, UINT32 width, UINT32 height)
3302 WINPR_ASSERT(mutter);
3303 WINPR_ASSERT(mutter->common.MsgPipe);
3304 return MessageQueue_Post(mutter->common.MsgPipe->In,
nullptr, MUTTER_MSG_VIRTUAL_SIZE,
3305 (
void*)(
size_t)width, (
void*)(
size_t)height);
3308static void mutter_virtual_follow_client(mutterShadowSubsystem* mutter, rdpShadowClient* client)
3310 WINPR_ASSERT(mutter);
3311 WINPR_ASSERT(client);
3313 const rdpSettings* settings = client->context.settings;
3314 const UINT32 width =
3316 const UINT32 height =
3319 if ((width == mutter->width) && (height == mutter->height))
3322 if (!mutter_virtual_request(mutter, width, height))
3325 const UINT64 end = GetTickCount64() + MUTTER_VIRTUAL_SIZE_WAIT_MS;
3326 while ((GetTickCount64() < end) && ((mutter->width != width) || (mutter->height != height)))
3329 "the virtual monitor for a %" PRIu32
"x%" PRIu32
" client is %" PRIu32
"x%" PRIu32,
3330 width, height, mutter->width, mutter->height);
3336static BOOL mutter_shadow_client_resize(rdpShadowSubsystem* subsystem, rdpShadowClient* client,
3337 UINT32 width, UINT32 height)
3339 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3340 WINPR_ASSERT(mutter);
3342 const void* newest = InterlockedCompareExchangePointer(&mutter->sizeClient,
nullptr,
nullptr);
3343 if (newest && (newest != client))
3346 WLog_INFO(TAG,
"the client asks for %" PRIu32
"x%" PRIu32, width, height);
3347 return mutter_virtual_request(mutter, mutter_virtual_side(width, 320),
3348 mutter_virtual_side(height, 200));
3354static void mutter_wake_screen(mutterShadowSubsystem* mutter)
3356 WINPR_ASSERT(mutter);
3358 if ((mutter->width == 0) || (mutter->height == 0))
3362 const UINT32 x = MIN(mutter->common.pointerX, MIN(mutter->width, UINT16_MAX + 1u) - 1u);
3363 const UINT32 y = MIN(mutter->common.pointerY, MIN(mutter->height, UINT16_MAX + 1u) - 1u);
3365 EnterCriticalSection(&mutter->eiLock);
3366 if (mutter->ei && mutter->pointer && mutter->pointerReady)
3367 mutter_pointer_move(mutter, (UINT16)x, (UINT16)y);
3368 LeaveCriticalSection(&mutter->eiLock);
3372static BOOL mutter_shadow_client_connect(rdpShadowSubsystem* subsystem, rdpShadowClient* client)
3374 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3375 WINPR_ASSERT(mutter);
3378 mutter->cursorResend = TRUE;
3379 (void)InterlockedIncrement(&mutter->clients);
3380 (void)SetEvent(mutter->clientsEvent);
3381 void* older =
nullptr;
3384 older = mutter->sizeClient;
3385 }
while (InterlockedCompareExchangePointer(&mutter->sizeClient, client, older) != older);
3386 if (mutter->virtualMonitor)
3387 mutter_virtual_follow_client(mutter, client);
3388 if (client->mayInteract)
3390 mutter_wake_screen(mutter);
3391 if (mutter->virtualMonitor && mutter->common.server->authentication &&
3392 !MessageQueue_Post(mutter->common.MsgPipe->In,
nullptr, MUTTER_MSG_UNLOCK,
nullptr,
3394 WLog_WARN(TAG,
"cannot ask for the session to unlock");
3399static void mutter_shadow_client_disconnect(rdpShadowSubsystem* subsystem, rdpShadowClient* client)
3401 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3402 WINPR_ASSERT(mutter);
3404 (void)InterlockedCompareExchangePointer(&mutter->sizeClient,
nullptr, client);
3405 (void)InterlockedDecrement(&mutter->clients);
3406 (void)SetEvent(mutter->clientsEvent);
3409static void mutter_shadow_subsystem_free(rdpShadowSubsystem* subsystem)
3411 mutterShadowSubsystem* mutter = (mutterShadowSubsystem*)subsystem;
3415 if (mutter_shadow_subsystem_stop(subsystem) < 0)
3416 WLog_WARN(TAG,
"the subsystem thread did not stop");
3417 if (mutter_shadow_subsystem_uninit(subsystem) < 0)
3418 WLog_WARN(TAG,
"the subsystem was not uninitialized");
3419 DeleteCriticalSection(&mutter->eiLock);
3420 if (mutter->stopEvent)
3421 (void)CloseHandle(mutter->stopEvent);
3422 if (mutter->clientsEvent)
3423 (void)CloseHandle(mutter->clientsEvent);
3424 free(mutter->cursorPixels);
3429static rdpShadowSubsystem* mutter_shadow_subsystem_new(
void)
3431 mutterShadowSubsystem* mutter = calloc(1,
sizeof(mutterShadowSubsystem));
3435 if (!InitializeCriticalSectionAndSpinCount(&mutter->eiLock, 4000))
3441 mutter->stopEvent = CreateEvent(
nullptr, TRUE, FALSE,
nullptr);
3444 mutter->clientsEvent = CreateEvent(
nullptr, TRUE, FALSE,
nullptr);
3445 if (!mutter->stopEvent || !mutter->clientsEvent)
3447 mutter_shadow_subsystem_free(&mutter->common);
3451 mutter->cursorX = -1;
3452 mutter->cursorY = -1;
3453 mutter->audioSourceFormat.wFormatTag = WAVE_FORMAT_PCM;
3454 mutter->audioSourceFormat.nChannels = MUTTER_AUDIO_CHANNELS;
3455 mutter->audioSourceFormat.nSamplesPerSec = MUTTER_AUDIO_RATE;
3456 mutter->audioSourceFormat.nAvgBytesPerSec = MUTTER_AUDIO_RATE * MUTTER_AUDIO_FRAME_BYTES;
3457 mutter->audioSourceFormat.nBlockAlign = MUTTER_AUDIO_FRAME_BYTES;
3458 mutter->audioSourceFormat.wBitsPerSample = 16;
3459 mutter->common.SynchronizeEvent = mutter_shadow_input_synchronize_event;
3460 mutter->common.KeyboardEvent = mutter_shadow_input_keyboard_event;
3461 mutter->common.UnicodeKeyboardEvent = mutter_shadow_input_unicode_keyboard_event;
3462 mutter->common.MouseEvent = mutter_shadow_input_mouse_event;
3463 mutter->common.ExtendedMouseEvent = mutter_shadow_input_extended_mouse_event;
3464 mutter->common.ClientConnect = mutter_shadow_client_connect;
3465 mutter->common.ClientDisconnect = mutter_shadow_client_disconnect;
3467 mutter->common.Authenticate = mutter_shadow_pam_authenticate;
3469 return &mutter->common;
3472FREERDP_ENTRY_POINT(WINPR_ATTR_NODISCARD
const char* MutterShadowSubsystemName(
void))
3478 WINPR_ATTR_NODISCARD
int MutterShadowSubsystemEntry(RDP_SHADOW_ENTRY_POINTS* pEntryPoints))
3480 WINPR_ASSERT(pEntryPoints);
3482 pEntryPoints->New = mutter_shadow_subsystem_new;
3483 pEntryPoints->Free = mutter_shadow_subsystem_free;
3484 pEntryPoints->Init = mutter_shadow_subsystem_init;
3485 pEntryPoints->Uninit = mutter_shadow_subsystem_uninit;
3486 pEntryPoints->Start = mutter_shadow_subsystem_start;
3487 pEntryPoints->Stop = mutter_shadow_subsystem_stop;
3488 pEntryPoints->EnumMonitors = mutter_shadow_enum_monitors;
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.