Skip to content

Commit 3e6d9cb

Browse files
matte-schwartzmatte-schwartz
committed
layer: identify 32-bit and 64-bit layer logs
Leave some breadcrumbs to figure out whether the logs we're getting come from the 32-bit or 64-bit layer. ARM/aarch64 and FreeBSD logs will appear without a bit suffix.
1 parent eda2256 commit 3e6d9cb

File tree

2 files changed

+73
-47
lines changed

2 files changed

+73
-47
lines changed

Diff for: ‎layer/VkLayer_FROG_gamescope_wsi.cpp

+53-40
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,19 @@
2424

2525
#include "../src/messagey.h"
2626

27+
// For layer logging.
28+
#if __linux__
29+
#if __x86_64__
30+
#define WSI_LAYER_INFO "[Gamescope WSI 64-bit] "
31+
#elif __i386__
32+
#define WSI_LAYER_INFO "[Gamescope WSI 32-bit] "
33+
#else
34+
#define WSI_LAYER_INFO "[Gamescope WSI] "
35+
#endif
36+
#else
37+
#define WSI_LAYER_INFO "[Gamescope WSI] "
38+
#endif
39+
2740
using namespace std::literals;
2841

2942
namespace GamescopeWSILayer {
@@ -150,17 +163,17 @@ namespace GamescopeWSILayer {
150163
static uint32_t getMinImageCount() {
151164
static uint32_t s_minImageCount = []() -> uint32_t {
152165
if (auto minCount = parseEnv<uint32_t>("GAMESCOPE_WSI_MIN_IMAGE_COUNT")) {
153-
fprintf(stderr, "[Gamescope WSI] minImageCount overridden by GAMESCOPE_WSI_MIN_IMAGE_COUNT: %u\n", *minCount);
166+
fprintf(stderr, WSI_LAYER_INFO "minImageCount overridden by GAMESCOPE_WSI_MIN_IMAGE_COUNT: %u\n", *minCount);
154167
return *minCount;
155168
}
156169

157170
if (auto minCount = parseEnv<uint32_t>("vk_wsi_override_min_image_count")) {
158-
fprintf(stderr, "[Gamescope WSI] minImageCount overridden by vk_wsi_override_min_image_count: %u\n", *minCount);
171+
fprintf(stderr, WSI_LAYER_INFO "minImageCount overridden by vk_wsi_override_min_image_count: %u\n", *minCount);
159172
return *minCount;
160173
}
161174

162175
if (auto minCount = parseEnv<uint32_t>("vk_x11_override_min_image_count")) {
163-
fprintf(stderr, "[Gamescope WSI] minImageCount overridden by vk_x11_override_min_image_count: %u\n", *minCount);
176+
fprintf(stderr, WSI_LAYER_INFO "minImageCount overridden by vk_x11_override_min_image_count: %u\n", *minCount);
164177
return *minCount;
165178
}
166179

@@ -233,13 +246,13 @@ namespace GamescopeWSILayer {
233246
{
234247
const char *mesaExecutableEnv = getenv("MESA_DRICONF_EXECUTABLE_OVERRIDE");
235248
if (mesaExecutableEnv && *mesaExecutableEnv) {
236-
fprintf(stderr, "[Gamescope WSI] Executable name overriden by MESA_DRICONF_EXECUTABLE_OVERRIDE: %s\n", mesaExecutableEnv);
249+
fprintf(stderr, WSI_LAYER_INFO "Executable name overriden by MESA_DRICONF_EXECUTABLE_OVERRIDE: %s\n", mesaExecutableEnv);
237250
return mesaExecutableEnv;
238251
}
239252

240253
const char *mesaProcessName = getenv("MESA_PROCESS_NAME");
241254
if (mesaProcessName && *mesaProcessName) {
242-
fprintf(stderr, "[Gamescope WSI] Executable name overriden by MESA_PROCESS_NAME: %s\n", mesaExecutableEnv);
255+
fprintf(stderr, WSI_LAYER_INFO "Executable name overriden by MESA_PROCESS_NAME: %s\n", mesaExecutableEnv);
243256
return mesaProcessName;
244257
}
245258

@@ -250,7 +263,7 @@ namespace GamescopeWSILayer {
250263
free(programNameCStr);
251264
}
252265

253-
fprintf(stderr, "[Gamescope WSI] Executable name: %s\n", name.c_str());
266+
fprintf(stderr, WSI_LAYER_INFO "Executable name: %s\n", name.c_str());
254267
return name;
255268
}();
256269

@@ -435,15 +448,15 @@ namespace GamescopeWSILayer {
435448
auto largestObscuringWindowSize = xcb::getLargestObscuringChildWindowSize(connection, window);
436449
auto toplevelWindow = xcb::getToplevelWindow(connection, window);
437450
if (!rect || !largestObscuringWindowSize || !toplevelWindow) {
438-
fprintf(stderr, "[Gamescope WSI] canBypassXWayland: failed to get window info for window 0x%x.\n", window);
451+
fprintf(stderr, WSI_LAYER_INFO "canBypassXWayland: failed to get window info for window 0x%x.\n", window);
439452
return false;
440453
}
441454

442455
cachedWindowRect = *rect;
443456

444457
auto toplevelRect = xcb::getWindowRect(connection, *toplevelWindow);
445458
if (!toplevelRect) {
446-
fprintf(stderr, "[Gamescope WSI] canBypassXWayland: failed to get window info for window 0x%x.\n", window);
459+
fprintf(stderr, WSI_LAYER_INFO "canBypassXWayland: failed to get window info for window 0x%x.\n", window);
447460
return false;
448461
}
449462

@@ -459,7 +472,7 @@ namespace GamescopeWSILayer {
459472
// (There can be dummy composite redirect windows and whatever.)
460473
if (largestObscuringWindowSize->width > 1 || largestObscuringWindowSize->height > 1) {
461474
#if GAMESCOPE_WSI_BYPASS_DEBUG
462-
fprintf(stderr, "[Gamescope WSI] Largest obscuring window size: %u %u\n", largestObscuringWindowSize->width, largestObscuringWindowSize->height);
475+
fprintf(stderr, WSI_LAYER_INFO "Largest obscuring window size: %u %u\n", largestObscuringWindowSize->width, largestObscuringWindowSize->height);
463476
#endif
464477
return false;
465478
}
@@ -475,7 +488,7 @@ namespace GamescopeWSILayer {
475488
iabs(int32_t(toplevelRect->extent.width) - int32_t(rect->extent.width)) > 2 ||
476489
iabs(int32_t(toplevelRect->extent.height) - int32_t(rect->extent.height)) > 2) {
477490
#if GAMESCOPE_WSI_BYPASS_DEBUG
478-
fprintf(stderr, "[Gamescope WSI] Not within 1px margin of error. Offset: %d %d Extent: %u %u vs %u %u\n",
491+
fprintf(stderr, WSI_LAYER_INFO "Not within 1px margin of error. Offset: %d %d Extent: %u %u vs %u %u\n",
479492
rect->offset.x, rect->offset.y,
480493
toplevelRect->extent.width, toplevelRect->extent.height,
481494
rect->extent.width, rect->extent.height);
@@ -547,7 +560,7 @@ namespace GamescopeWSILayer {
547560
std::unique_lock lock(*swapchain->presentTimingMutex);
548561
swapchain->refreshCycle = (uint64_t(refresh_cycle_hi) << 32) | refresh_cycle_lo;
549562
}
550-
fprintf(stderr, "[Gamescope WSI] Swapchain recieved new refresh cycle: %.2fms\n", swapchain->refreshCycle / 1'000'000.0);
563+
fprintf(stderr, WSI_LAYER_INFO "Swapchain recieved new refresh cycle: %.2fms\n", swapchain->refreshCycle / 1'000'000.0);
551564
},
552565

553566
.retired = [](
@@ -557,7 +570,7 @@ namespace GamescopeWSILayer {
557570
{
558571
swapchain->retired = true;
559572
}
560-
fprintf(stderr, "[Gamescope WSI] Swapchain retired\n");
573+
fprintf(stderr, WSI_LAYER_INFO "Swapchain retired\n");
561574
},
562575
};
563576

@@ -596,20 +609,20 @@ namespace GamescopeWSILayer {
596609

597610
wl_display *display = wl_display_connect(gamescopeWaylandSocket());
598611
if (!display) {
599-
fprintf(stderr, "[Gamescope WSI] Failed to connect to gamescope socket: %s. Bypass layer will be unavailable.\n", gamescopeWaylandSocket());
612+
fprintf(stderr, WSI_LAYER_INFO "Failed to connect to gamescope socket: %s. Bypass layer will be unavailable.\n", gamescopeWaylandSocket());
600613
return result;
601614
}
602615

603616
{
604617
if (pCreateInfo->pApplicationInfo) {
605-
fprintf(stderr, "[Gamescope WSI] Application info:\n");
618+
fprintf(stderr, WSI_LAYER_INFO "Application info:\n");
606619
fprintf(stderr, " pApplicationName: %s\n", pCreateInfo->pApplicationInfo->pApplicationName);
607620
fprintf(stderr, " applicationVersion: %u\n", pCreateInfo->pApplicationInfo->applicationVersion);
608621
fprintf(stderr, " pEngineName: %s\n", pCreateInfo->pApplicationInfo->pEngineName);
609622
fprintf(stderr, " engineVersion: %u\n", pCreateInfo->pApplicationInfo->engineVersion);
610623
fprintf(stderr, " apiVersion: %u\n", pCreateInfo->pApplicationInfo->apiVersion);
611624
} else {
612-
fprintf(stderr, "[Gamescope WSI] No application info given.\n");
625+
fprintf(stderr, WSI_LAYER_INFO "No application info given.\n");
613626
}
614627
}
615628

@@ -663,7 +676,7 @@ namespace GamescopeWSILayer {
663676
vkroots::ChainPatcher<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT>
664677
maintenance1Patcher(&deviceCreateInfo, [&](VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *pMaintenance1)
665678
{
666-
fprintf(stderr, "[Gamescope WSI] Forcing on VK_EXT_swapchain_maintenance1.\n");
679+
fprintf(stderr, WSI_LAYER_INFO "Forcing on VK_EXT_swapchain_maintenance1.\n");
667680
pMaintenance1->swapchainMaintenance1 = VK_TRUE;
668681
return true;
669682
});
@@ -735,7 +748,7 @@ namespace GamescopeWSILayer {
735748

736749
GamescopeWaylandObjects waylandObjects = GamescopeWaylandObjects::get(pCreateInfo->display);
737750
if (!waylandObjects.valid()) {
738-
fprintf(stderr, "[Gamescope WSI] Failed to get Wayland objects\n");
751+
fprintf(stderr, WSI_LAYER_INFO "Failed to get Wayland objects\n");
739752
return VK_ERROR_SURFACE_LOST_KHR;
740753
}
741754

@@ -975,17 +988,17 @@ namespace GamescopeWSILayer {
975988
xcb_window_t window,
976989
const VkAllocationCallbacks* pAllocator,
977990
VkSurfaceKHR* pSurface) {
978-
fprintf(stderr, "[Gamescope WSI] Creating Gamescope surface: xid: 0x%x\n", window);
991+
fprintf(stderr, WSI_LAYER_INFO "Creating Gamescope surface: xid: 0x%x\n", window);
979992

980993
GamescopeWaylandObjects waylandObjects = GamescopeWaylandObjects::get(gamescopeInstance->display);
981994
if (!waylandObjects.valid()) {
982-
fprintf(stderr, "[Gamescope WSI] Failed to get Wayland objects\n");
995+
fprintf(stderr, WSI_LAYER_INFO "Failed to get Wayland objects\n");
983996
return VK_ERROR_SURFACE_LOST_KHR;
984997
}
985998

986999
wl_surface* waylandSurface = wl_compositor_create_surface(waylandObjects.compositor);
9871000
if (!waylandSurface) {
988-
fprintf(stderr, "[Gamescope WSI] Failed to create wayland surface - xid: 0x%x\n", window);
1001+
fprintf(stderr, WSI_LAYER_INFO "Failed to create wayland surface - xid: 0x%x\n", window);
9891002
return VK_ERROR_SURFACE_LOST_KHR;
9901003
}
9911004

@@ -1009,7 +1022,7 @@ namespace GamescopeWSILayer {
10091022

10101023
VkResult result = pDispatch->CreateWaylandSurfaceKHR(instance, &waylandCreateInfo, pAllocator, pSurface);
10111024
if (result != VK_SUCCESS) {
1012-
fprintf(stderr, "[Gamescope WSI] Failed to create Vulkan wayland surface - vr: %s xid: 0x%x\n", vkroots::helpers::enumString(result), window);
1025+
fprintf(stderr, WSI_LAYER_INFO "Failed to create Vulkan wayland surface - vr: %s xid: 0x%x\n", vkroots::helpers::enumString(result), window);
10131026
return result;
10141027
}
10151028

@@ -1023,11 +1036,11 @@ namespace GamescopeWSILayer {
10231036
VkSurfaceKHR fallbackSurface = VK_NULL_HANDLE;
10241037
result = pDispatch->CreateXcbSurfaceKHR(instance, &xcbCreateInfo, pAllocator, &fallbackSurface);
10251038
if (result != VK_SUCCESS) {
1026-
fprintf(stderr, "[Gamescope WSI] Failed to create Vulkan xcb (fallback) surface - vr: %s xid: 0x%x\n", vkroots::helpers::enumString(result), window);
1039+
fprintf(stderr, WSI_LAYER_INFO "Failed to create Vulkan xcb (fallback) surface - vr: %s xid: 0x%x\n", vkroots::helpers::enumString(result), window);
10271040
return result;
10281041
}
10291042

1030-
fprintf(stderr, "[Gamescope WSI] Made gamescope surface for xid: 0x%x\n", window);
1043+
fprintf(stderr, WSI_LAYER_INFO "Made gamescope surface for xid: 0x%x\n", window);
10311044
auto gamescopeSurface = GamescopeSurface::create(*pSurface, GamescopeSurfaceData {
10321045
.instance = instance,
10331046
.display = gamescopeInstance->display,
@@ -1046,7 +1059,7 @@ namespace GamescopeWSILayer {
10461059
}
10471060

10481061
static void DumpGamescopeSurfaceState(GamescopeInstance& instance, GamescopeSurface& surface) {
1049-
fprintf(stderr, "[Gamescope WSI] Surface state:\n");
1062+
fprintf(stderr, WSI_LAYER_INFO "Surface state:\n");
10501063
fprintf(stderr, " steam app id: %u\n", instance->appId);
10511064
fprintf(stderr, " window xid: 0x%x\n", surface->window);
10521065
fprintf(stderr, " wayland surface res id: %u\n", wl_proxy_get_id(reinterpret_cast<struct wl_proxy *>(surface->surface)));
@@ -1076,9 +1089,9 @@ namespace GamescopeWSILayer {
10761089
gamescope_swapchain_destroy(state->object);
10771090
}
10781091
GamescopeSwapchain::remove(swapchain);
1079-
fprintf(stderr, "[Gamescope WSI] Destroying swapchain: %p\n", reinterpret_cast<void*>(swapchain));
1092+
fprintf(stderr, WSI_LAYER_INFO "Destroying swapchain: %p\n", reinterpret_cast<void*>(swapchain));
10801093
pDispatch->DestroySwapchainKHR(device, swapchain, pAllocator);
1081-
fprintf(stderr, "[Gamescope WSI] Destroyed swapchain: %p\n", reinterpret_cast<void*>(swapchain));
1094+
fprintf(stderr, WSI_LAYER_INFO "Destroyed swapchain: %p\n", reinterpret_cast<void*>(swapchain));
10821095
}
10831096

10841097
static VkResult CreateSwapchainKHR(
@@ -1158,7 +1171,7 @@ namespace GamescopeWSILayer {
11581171
minImageCount = std::max(getMinImageCount(), minImageCount);
11591172
swapchainInfo.minImageCount = minImageCount;
11601173

1161-
fprintf(stderr, "[Gamescope WSI] Creating swapchain for xid: 0x%0x - oldSwapchain: %p - provided minImageCount: %u - minImageCount: %u - format: %s - colorspace: %s - flip: %s\n",
1174+
fprintf(stderr, WSI_LAYER_INFO "Creating swapchain for xid: 0x%0x - oldSwapchain: %p - provided minImageCount: %u - minImageCount: %u - format: %s - colorspace: %s - flip: %s\n",
11621175
gamescopeSurface->window,
11631176
reinterpret_cast<void*>(pCreateInfo->oldSwapchain),
11641177
pCreateInfo->minImageCount,
@@ -1183,7 +1196,7 @@ namespace GamescopeWSILayer {
11831196
&VkSurfaceFormatKHR::format) ;
11841197

11851198
if (!supportedSwapchainFormat) {
1186-
fprintf(stderr, "[Gamescope WSI] Refusing to make swapchain (unsupported VkFormat) for xid: 0x%0x - format: %s - colorspace: %s - flip: %s\n",
1199+
fprintf(stderr, WSI_LAYER_INFO "Refusing to make swapchain (unsupported VkFormat) for xid: 0x%0x - format: %s - colorspace: %s - flip: %s\n",
11871200
gamescopeSurface->window,
11881201
vkroots::helpers::enumString(pCreateInfo->imageFormat),
11891202
vkroots::helpers::enumString(pCreateInfo->imageColorSpace),
@@ -1197,21 +1210,21 @@ namespace GamescopeWSILayer {
11971210
if (!gamescopeSurface->isWayland()) {
11981211
auto oServerId = xcb::getPropertyValue<uint32_t>(gamescopeSurface->connection, "GAMESCOPE_XWAYLAND_SERVER_ID"sv);
11991212
if (!oServerId) {
1200-
fprintf(stderr, "[Gamescope WSI] Failed to get Xwayland server id. Failing swapchain creation.\n");
1213+
fprintf(stderr, WSI_LAYER_INFO "Failed to get Xwayland server id. Failing swapchain creation.\n");
12011214
return VK_ERROR_SURFACE_LOST_KHR;
12021215
}
12031216
serverId = *oServerId;
12041217
}
12051218

12061219
auto gamescopeInstance = GamescopeInstance::get(gamescopeSurface->instance);
12071220
if (!gamescopeInstance) {
1208-
fprintf(stderr, "[Gamescope WSI] CreateSwapchainKHR: Instance for swapchain was already destroyed. (App use after free).\n");
1221+
fprintf(stderr, WSI_LAYER_INFO "CreateSwapchainKHR: Instance for swapchain was already destroyed. (App use after free).\n");
12091222
return VK_ERROR_SURFACE_LOST_KHR;
12101223
}
12111224

12121225
VkResult result = pDispatch->CreateSwapchainKHR(device, &swapchainInfo, pAllocator, pSwapchain);
12131226
if (result != VK_SUCCESS) {
1214-
fprintf(stderr, "[Gamescope WSI] Failed to create swapchain - vr: %s xid: 0x%x\n", vkroots::helpers::enumString(result), gamescopeSurface->window);
1227+
fprintf(stderr, WSI_LAYER_INFO "Failed to create swapchain - vr: %s xid: 0x%x\n", vkroots::helpers::enumString(result), gamescopeSurface->window);
12151228
return result;
12161229
}
12171230

@@ -1239,7 +1252,7 @@ namespace GamescopeWSILayer {
12391252
uint32_t imageCount = 0;
12401253
pDispatch->GetSwapchainImagesKHR(device, *pSwapchain, &imageCount, nullptr);
12411254

1242-
fprintf(stderr, "[Gamescope WSI] Created swapchain for xid: 0x%0x swapchain: %p - imageCount: %u\n",
1255+
fprintf(stderr, WSI_LAYER_INFO "Created swapchain for xid: 0x%0x swapchain: %p - imageCount: %u\n",
12431256
gamescopeSurface->window,
12441257
reinterpret_cast<void*>(*pSwapchain),
12451258
imageCount);
@@ -1310,7 +1323,7 @@ namespace GamescopeWSILayer {
13101323
assert(pPresentTimes->swapchainCount == presentInfo.swapchainCount);
13111324

13121325
#if GAMESCOPE_WSI_DISPLAY_TIMING_DEBUG
1313-
fprintf(stderr, "[Gamescope WSI] QueuePresentKHR: presentID: %u - desiredPresentTime: %lu - now: %lu\n", pPresentTimes->pTimes[i].presentID, pPresentTimes->pTimes[i].desiredPresentTime, getTimeMonotonic());
1326+
fprintf(stderr, WSI_LAYER_INFO "QueuePresentKHR: presentID: %u - desiredPresentTime: %lu - now: %lu\n", pPresentTimes->pTimes[i].presentID, pPresentTimes->pTimes[i].desiredPresentTime, getTimeMonotonic());
13141327
#endif
13151328
gamescope_swapchain_set_present_time(
13161329
gamescopeSwapchain->object,
@@ -1408,13 +1421,13 @@ namespace GamescopeWSILayer {
14081421
// exposed as supported in order for them to handle presentation latency like they
14091422
// would as in FIFO mode.
14101423
if (frameLimiterAware && gamescopeSwapchain->forceFifo != forceFifo) {
1411-
fprintf(stderr, "[Gamescope WSI] Forcing swapchain recreation as frame limiter changed, and we want the app to know the exposed modes changed.\n");
1424+
fprintf(stderr, WSI_LAYER_INFO "Forcing swapchain recreation as frame limiter changed, and we want the app to know the exposed modes changed.\n");
14121425
UpdateSwapchainResult(VK_ERROR_OUT_OF_DATE_KHR);
14131426
}
14141427

14151428
auto gamescopeSurface = GamescopeSurface::get(gamescopeSwapchain->surface);
14161429
if (!gamescopeSurface) {
1417-
fprintf(stderr, "[Gamescope WSI] QueuePresentKHR: Surface for swapchain %u was already destroyed. (App use after free).\n", i);
1430+
fprintf(stderr, WSI_LAYER_INFO "QueuePresentKHR: Surface for swapchain %u was already destroyed. (App use after free).\n", i);
14181431
abort();
14191432
continue;
14201433
}
@@ -1438,7 +1451,7 @@ namespace GamescopeWSILayer {
14381451
if (windowSizeChanged)
14391452
UpdateSwapchainResult(VK_ERROR_OUT_OF_DATE_KHR);
14401453
} else {
1441-
fprintf(stderr, "[Gamescope WSI] QueuePresentKHR: Failed to get cached window size for swapchain %u\n", i);
1454+
fprintf(stderr, WSI_LAYER_INFO "QueuePresentKHR: Failed to get cached window size for swapchain %u\n", i);
14421455
}
14431456
}
14441457
}
@@ -1456,7 +1469,7 @@ namespace GamescopeWSILayer {
14561469
for (uint32_t i = 0; i < swapchainCount; i++) {
14571470
auto gamescopeSwapchain = GamescopeSwapchain::get(pSwapchains[i]);
14581471
if (!gamescopeSwapchain) {
1459-
fprintf(stderr, "[Gamescope WSI] SetHdrMetadataEXT: Swapchain %u does not support HDR.\n", i);
1472+
fprintf(stderr, WSI_LAYER_INFO "SetHdrMetadataEXT: Swapchain %u does not support HDR.\n", i);
14601473
continue;
14611474
}
14621475

@@ -1476,7 +1489,7 @@ namespace GamescopeWSILayer {
14761489
nits_to_u16(metadata.maxContentLightLevel),
14771490
nits_to_u16(metadata.maxFrameAverageLightLevel));
14781491

1479-
fprintf(stderr, "[Gamescope WSI] VkHdrMetadataEXT: display primaries:\n");
1492+
fprintf(stderr, WSI_LAYER_INFO "VkHdrMetadataEXT: display primaries:\n");
14801493
fprintf(stderr, " r: %.4g %.4g\n", metadata.displayPrimaryRed.x, metadata.displayPrimaryRed.y);
14811494
fprintf(stderr, " g: %.4g %.4g\n", metadata.displayPrimaryGreen.x, metadata.displayPrimaryGreen.y);
14821495
fprintf(stderr, " b: %.4g %.4g\n", metadata.displayPrimaryBlue.x, metadata.displayPrimaryBlue.y);
@@ -1495,7 +1508,7 @@ namespace GamescopeWSILayer {
14951508
VkPastPresentationTimingGOOGLE* pPresentationTimings) {
14961509
auto gamescopeSwapchain = GamescopeSwapchain::get(swapchain);
14971510
if (!gamescopeSwapchain) {
1498-
fprintf(stderr, "[Gamescope WSI] GetPastPresentationTimingGOOGLE: Not a gamescope swapchain.\n");
1511+
fprintf(stderr, WSI_LAYER_INFO "GetPastPresentationTimingGOOGLE: Not a gamescope swapchain.\n");
14991512
return VK_ERROR_SURFACE_LOST_KHR;
15001513
}
15011514

@@ -1522,7 +1535,7 @@ namespace GamescopeWSILayer {
15221535
VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
15231536
auto gamescopeSwapchain = GamescopeSwapchain::get(swapchain);
15241537
if (!gamescopeSwapchain) {
1525-
fprintf(stderr, "[Gamescope WSI] GetRefreshCycleDurationGOOGLE: Not a gamescope swapchain.\n");
1538+
fprintf(stderr, WSI_LAYER_INFO "GetRefreshCycleDurationGOOGLE: Not a gamescope swapchain.\n");
15261539
return VK_ERROR_SURFACE_LOST_KHR;
15271540
}
15281541

0 commit comments

Comments
 (0)