vkreplay: Add support for fullscreen replay

Change-Id: Ie5a867938a87c5e7de607c34552aa0cf696373af

Author: davidlunarg

.travis.yml

@@ -41,7 +41,7 @@ before_install:
   - |
     if [[ "$VULKAN_BUILD_TARGET" == "LINUX" ]]; then
       sudo apt-get -qq update
-      sudo apt-get -y install libxkbcommon-dev libwayland-dev libmirclient-dev libxrandr-dev libx11-xcb-dev libxcb-keysyms1 libxcb-keysyms1-dev
+      sudo apt-get -y install libxkbcommon-dev libwayland-dev libmirclient-dev libxrandr-dev libx11-xcb-dev libxcb-keysyms1 libxcb-keysyms1-dev libxcb-ewmh-dev
       # Needed for devsim test
       sudo apt-get -y install jq
     fi

BUILD.md

@@ -20,7 +20,7 @@ These additional packages are needed for building the components in this repo.
 # Dependencies from included submodule components
 sudo apt-get install git cmake build-essential bison libx11-xcb-dev libxkbcommon-dev libmirclient-dev libwayland-dev libxrandr-dev
 # Additional dependencies for this repo:
-sudo apt-get install wget autotools-dev libxcb-keysyms1 libxcb-keysyms1-dev
+sudo apt-get install wget autotools-dev libxcb-keysyms1 libxcb-keysyms1-dev libxcb-ewmh-dev
 # If performing 32-bit builds, you will also need:
 sudo apt-get install libc6-dev-i386 g++-multilib
 ```

vktrace/vktrace_replay/CMakeLists.txt

@@ -20,7 +20,7 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
     add_library(${XCB_DISPLAY_LIB} SHARED ${XCB_SRC_LIST} ${XCB_HDR_LIST})
 
     target_link_libraries(${XCB_DISPLAY_LIB}
-        xcb
+        xcb-randr xcb-ewmh xcb
         vktrace_common
     )
 

vktrace/vktrace_replay/vkreplay_main.cpp

@@ -555,7 +555,7 @@ int vkreplay_main(int argc, char** argv, vktrace_replay::ReplayDisplayImp* pDisp
 
     // Create window. Initial size is 100x100. It will later get resized to the size
     // used by the traced app. The resize will happen  during playback of swapchain functions.
-    vktrace_replay::ReplayDisplay disp(100, 100, false);
+    vktrace_replay::ReplayDisplay disp(100, 100);
 
 // Create display
 #if defined(PLATFORM_LINUX) && !defined(ANDROID)

vktrace/vktrace_replay/vkreplay_vkdisplay.cpp

@@ -197,6 +197,16 @@ int vkDisplayWin32::create_window(const unsigned int width, const unsigned int h
         vktrace_LogError("Failed to create window");
         return -1;
     }
+
+    // Get and save screen size
+    RECT sr;
+    if (!GetWindowRect(GetDesktopWindow(), &sr)) {
+        vktrace_LogError("Failed to get size of screen");
+        return -1;
+    }
+    m_screenWidth = sr.right;
+    m_screenHeight = sr.bottom;
+
     // TODO : Not sure of best place to put this, but I have all the info I need here so just setting it all here for now
     m_surface.base.platform = VK_ICD_WSI_PLATFORM_WIN32;
     m_surface.hinstance = wcex.hInstance;
@@ -209,10 +219,19 @@ void vkDisplayWin32::resize_window(const unsigned int width, const unsigned int
     if (width != m_windowWidth || height != m_windowHeight) {
         m_windowWidth = width;
         m_windowHeight = height;
-
-        RECT wr = {0, 0, (LONG)width, (LONG)height};
-        AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
-        SetWindowPos(get_window_handle(), HWND_TOP, 0, 0, wr.right - wr.left, wr.bottom - wr.top, SWP_NOMOVE);
+        if (width >= m_screenWidth || height >= m_screenHeight) {
+            // Make window full screen w/o borders
+            BOOL rval;
+            rval = (NULL != SetWindowLongPtr(m_windowHandle, GWL_STYLE, WS_VISIBLE | WS_POPUP));
+            rval &= SetWindowPos(m_windowHandle, HWND_TOP, 0, 0, width, height, SWP_FRAMECHANGED);
+            if (!rval) {
+                vktrace_LogError("Failed to set window size to %d %d", width, height);
+            }
+        } else {
+            RECT wr = {0, 0, (LONG)width, (LONG)height};
+            AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
+            SetWindowPos(m_windowHandle, HWND_TOP, 0, 0, wr.right - wr.left, wr.bottom - wr.top, SWP_NOMOVE);
+        }
 
         // Make sure window is visible.
         ShowWindow(m_windowHandle, SW_SHOWDEFAULT);

vktrace/vktrace_replay/vkreplay_vkdisplay.h

@@ -64,10 +64,11 @@ class vkDisplayXcb : public vktrace_replay::ReplayDisplayImp {
     xcb_screen_t *m_pXcbScreen;
     xcb_window_t m_XcbWindow;
     xcb_intern_atom_reply_t *atom_wm_delete_window;
-// VkPlatformHandleXcbKHR m_XcbPlatformHandle;
 
     unsigned int m_windowWidth;
     unsigned int m_windowHeight;
+    unsigned int m_screenWidth;
+    unsigned int m_screenHeight;
     std::vector<VkExtent2D> imageExtents;
     std::vector<VkImage> imageHandles;
     std::vector<VkDeviceMemory> imageMemory;
@@ -115,6 +116,7 @@ class vkDisplayWayland : public vktrace_replay::ReplayDisplayImp {
     struct wl_seat *m_seat;
     struct wl_pointer *m_pointer;
     struct wl_keyboard *m_keyboard;
+    struct wl_output *m_output;
 
     static void handle_ping(void *data, wl_shell_surface *shell_surface, uint32_t serial);
     static void handle_configure(void *data, wl_shell_surface *shell_surface, uint32_t edges, int32_t width, int32_t height);
@@ -142,9 +144,16 @@ class vkDisplayWayland : public vktrace_replay::ReplayDisplayImp {
     static void registry_handle_global(void *data, wl_registry *registry, uint32_t id, const char *interface, uint32_t version);
     static void registry_handle_global_remove(void *data, wl_registry *registry, uint32_t name);
     static struct wl_registry_listener registry_listener;
+    static void output_handle_geometry(void *data, struct wl_output *wl_output, int x, int y, int physical_width,
+                                       int physical_height, int subpixel, const char *make, const char *model, int transform);
+    static void output_handle_mode(void *data, struct wl_output *wl_output, uint32_t flags, int width, int height, int refresh);
+    static struct wl_output_listener output_listener;
 
     unsigned int m_windowWidth;
     unsigned int m_windowHeight;
+    unsigned int m_screenWidth;
+    unsigned int m_screenHeight;
+    unsigned int m_refresh;
     std::vector<VkExtent2D> imageExtents;
     std::vector<VkImage> imageHandles;
     std::vector<VkDeviceMemory> imageMemory;
@@ -230,6 +239,9 @@ class vkDisplayWin32 : public vktrace_replay::ReplayDisplayImp {
 
     unsigned int m_windowWidth;
     unsigned int m_windowHeight;
+    unsigned int m_screenWidth;
+    unsigned int m_screenHeight;
+
     std::vector<VkExtent2D> imageExtents;
     std::vector<VkImage> imageHandles;
     std::vector<VkDeviceMemory> imageMemory;
@@ -245,4 +257,4 @@ class vkDisplayWin32 : public vktrace_replay::ReplayDisplayImp {
     bool m_pause = false;
     bool m_quit = false;
 };
-#endif
+#endif

vktrace/vktrace_replay/vkreplay_vkdisplay_wayland.cpp

@@ -49,6 +49,9 @@ vkDisplayWayland::vkDisplayWayland() : m_windowWidth(0), m_windowHeight(0) {
 
     registry_listener.global = registry_handle_global;
     registry_listener.global_remove = registry_handle_global_remove;
+
+    output_listener.geometry = output_handle_geometry;
+    output_listener.mode = output_handle_mode;
 }
 
 vkDisplayWayland::~vkDisplayWayland() {
@@ -116,6 +119,11 @@ void vkDisplayWayland::resize_window(const unsigned int width, const unsigned in
     if (width != m_windowWidth || height != m_windowHeight) {
         m_windowWidth = width;
         m_windowHeight = height;
+        if (width >= m_screenWidth || height >= m_screenHeight) {
+            // Make window full screen
+            wl_shell_surface_set_fullscreen(m_shell_surface, WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, m_refresh, m_output);
+        }
+
         // In Wayland, the shell_surface should resize based on the Vulkan surface automagically
     }
 }
@@ -220,9 +228,26 @@ void vkDisplayWayland::registry_handle_global(void *data, wl_registry *registry,
     } else if (strcmp(interface, "wl_seat") == 0) {
         display->m_seat = (wl_seat *)wl_registry_bind(registry, id, &wl_seat_interface, 1);
         wl_seat_add_listener(display->m_seat, &seat_listener, display);
+    } else if (strcmp(interface, "wl_output") == 0) {
+        display->m_output = (wl_output *)wl_registry_bind(registry, id, &wl_output_interface, 1);
+        wl_output_add_listener(display->m_output, &output_listener, display);
     }
 }
 
 void vkDisplayWayland::registry_handle_global_remove(void *data, wl_registry *registry, uint32_t name) {}
 
-struct wl_registry_listener vkDisplayWayland::registry_listener;
+struct wl_registry_listener vkDisplayWayland::registry_listener;
+
+void vkDisplayWayland::output_handle_geometry(void *data, struct wl_output *wl_output, int x, int y, int physical_width,
+                                              int physical_height, int subpixel, const char *make, const char *model,
+                                              int transform) {}
+
+void vkDisplayWayland::output_handle_mode(void *data, struct wl_output *wl_output, uint32_t flags, int width, int height,
+                                          int refresh) {
+    auto *display = (vkDisplayWayland *)data;
+    display->m_screenWidth = width;
+    display->m_screenHeight = height;
+    display->m_refresh = refresh;
+}
+
+struct wl_output_listener vkDisplayWayland::output_listener;

vktrace/vktrace_replay/vkreplay_vkdisplay_xcb.cpp

@@ -20,6 +20,8 @@
  */
 
 #include "vkreplay_vkdisplay.h"
+#include <xcb/randr.h>
+#include <xcb/xcb_ewmh.h>
 
 extern "C" {
 __attribute__((visibility("default"))) vkDisplayXcb *CreateVkDisplayXcb() { return new vkDisplayXcb(); }
@@ -69,9 +71,33 @@ int vkDisplayXcb::create_window(const unsigned int width, const unsigned int hei
     value_list[0] = m_pXcbScreen->black_pixel;
     value_list[1] = XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_EXPOSURE;
 
+    m_windowWidth = width;
+    m_windowHeight = height;
+
     xcb_create_window(m_pXcbConnection, XCB_COPY_FROM_PARENT, m_XcbWindow, m_pXcbScreen->root, 0, 0, width, height, 0,
                       XCB_WINDOW_CLASS_INPUT_OUTPUT, m_pXcbScreen->root_visual, value_mask, value_list);
 
+    // Magic code to get screen size
+    xcb_randr_get_screen_resources_cookie_t screenResCookie;
+    xcb_randr_crtc_t *pCRTC;
+    xcb_randr_get_crtc_info_cookie_t crtcResCookie;
+    xcb_flush(m_pXcbConnection);
+    screenResCookie = xcb_randr_get_screen_resources(m_pXcbConnection, m_XcbWindow);
+    xcb_randr_get_screen_resources_reply_t *screenResReply;
+    screenResReply = xcb_randr_get_screen_resources_reply(m_pXcbConnection, screenResCookie, 0);
+    if (screenResReply)
+        pCRTC = xcb_randr_get_screen_resources_crtcs(screenResReply);
+    else
+        return -1;
+    crtcResCookie = xcb_randr_get_crtc_info(m_pXcbConnection, *pCRTC, 0);
+    xcb_randr_get_crtc_info_reply_t *crtcResReply;
+    crtcResReply = xcb_randr_get_crtc_info_reply(m_pXcbConnection, crtcResCookie, 0);
+    if (crtcResReply) {
+        m_screenWidth = crtcResReply->width;
+        m_screenHeight = crtcResReply->height;
+    } else
+        return -1;
+
     // Magic code that will send notification when window is destroyed
     xcb_intern_atom_cookie_t cookie = xcb_intern_atom(m_pXcbConnection, 1, 12, "WM_PROTOCOLS");
     xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(m_pXcbConnection, cookie, 0);
@@ -97,6 +123,15 @@ void vkDisplayXcb::resize_window(const unsigned int width, const unsigned int he
     if (width != m_windowWidth || height != m_windowHeight) {
         m_windowWidth = width;
         m_windowHeight = height;
+        if (width >= m_screenWidth || height >= m_screenHeight) {
+            // Magic code that makes window full screen
+            xcb_ewmh_connection_t EWMH;
+            xcb_intern_atom_cookie_t *EWMHCookie = xcb_ewmh_init_atoms(m_pXcbConnection, &EWMH);
+            xcb_ewmh_init_atoms_replies(&EWMH, EWMHCookie, NULL);
+            xcb_change_property(m_pXcbConnection, XCB_PROP_MODE_REPLACE, m_XcbWindow, EWMH._NET_WM_STATE, XCB_ATOM_ATOM, 32, 1,
+                                &(EWMH._NET_WM_STATE_FULLSCREEN));
+        }
+
         uint32_t values[2];
         values[0] = width;
         values[1] = height;

vktrace/vktrace_replay/vkreplay_vkreplay.cpp

@@ -3442,6 +3442,12 @@ VkResult vkReplay::manually_replay_vkQueuePresentKHR(packet_vkQueuePresentKHR *p
         VKTRACE_DELETE(pRemappedSwapchains);
     }
 
+    if (pPacket->result != VK_SUCCESS) {
+        // The call failed during tracing, probably because the window was resized by the app.
+        // We'll return the result from the trace file, even though the call succeeded.
+        return pPacket->result;
+    }
+
     return replayResult;
 }
 

vktrace/vktrace_replay/vkreplay_window.h

@@ -42,7 +42,7 @@ extern "C" {
 #endif
 
 /* classes to abstract the display and initialization of rendering API for presenting
- * framebuffers for display into a window on the screen or else fullscreen.
+ * framebuffers for display into a window on the screen.
  * Uses Bridge design pattern.
  */
 namespace vktrace_replay {
@@ -67,13 +67,12 @@ class ReplayDisplayImp {
 
 class ReplayDisplay {
    public:
-    ReplayDisplay() : m_imp(NULL), m_width(0), m_height(0), m_gpu(0), m_fullscreen(false) {}
+    ReplayDisplay() : m_imp(NULL), m_width(0), m_height(0), m_gpu(0) {}
 
-    ReplayDisplay(const unsigned int width, const unsigned int height, const unsigned int gpu, const bool fullscreen)
-        : m_imp(NULL), m_width(width), m_height(height), m_gpu(gpu), m_fullscreen(fullscreen) {}
+    ReplayDisplay(const unsigned int width, const unsigned int height, const unsigned int gpu)
+        : m_imp(NULL), m_width(width), m_height(height), m_gpu(gpu) {}
 
-    ReplayDisplay(const unsigned int width, const unsigned int height, const bool fullscreen)
-        : m_imp(NULL), m_width(width), m_height(height), m_gpu(-1), m_fullscreen(fullscreen) {}
+    ReplayDisplay(const unsigned int width, const unsigned int height) : m_imp(NULL), m_width(width), m_height(height), m_gpu(-1) {}
 
     virtual ~ReplayDisplay() {}
 
@@ -99,7 +98,6 @@ class ReplayDisplay {
     unsigned int get_gpu() { return m_gpu; }
     unsigned int get_width() { return m_width; }
     unsigned int get_height() { return m_height; }
-    bool get_fullscreen() { return m_fullscreen; }
     bool get_pause_status() {
         if (m_imp) {
             return m_imp->get_pause_status();
@@ -124,7 +122,6 @@ class ReplayDisplay {
     unsigned int m_width;
     unsigned int m_height;
     unsigned int m_gpu;
-    bool m_fullscreen;
 };
 
 }  // namespace vktrace_replay