Reset window size on initialization

On macOS with renderer "metal", HiDPI scaling may be incorrect on
initialization when several displays are connected.

Resetting the window size fixes the problem.

Refs #15 <https://github.com/Genymobile/scrcpy/issues/15>

README.md

@@ -210,7 +210,6 @@ To disable mirroring while recording:
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrupt recording with Ctrl+C
-# Ctrl+C does not terminate properly on Windows, so disconnect the device
 ```
 
 "Skipped frames" are recorded, even if they are not displayed in real time (for

app/src/scrcpy.c

@@ -7,6 +7,10 @@
 #include <sys/time.h>
 #include <SDL2/SDL.h>
 
+#ifdef _WIN32
+# include <windows.h>
+#endif
+
 #include "config.h"
 #include "command.h"
 #include "common.h"
@@ -45,6 +49,18 @@ static struct input_manager input_manager = {
     .prefer_text = false, // initialized later
 };
 
+#ifdef _WIN32
+BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
+    if (ctrl_type == CTRL_C_EVENT) {
+        SDL_Event event;
+        event.type = SDL_QUIT;
+        SDL_PushEvent(&event);
+        return TRUE;
+    }
+    return FALSE;
+}
+#endif // _WIN32
+
 // init SDL and set appropriate hints
 static bool
 sdl_init_and_configure(bool display, const char *render_driver) {
@@ -56,6 +72,14 @@ sdl_init_and_configure(bool display, const char *render_driver) {
 
     atexit(SDL_Quit);
 
+#ifdef _WIN32
+    // Clean up properly on Ctrl+C on Windows
+    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
+    if (!ok) {
+        LOGW("Could not set Ctrl+C handler");
+    }
+#endif // _WIN32
+
     if (!display) {
         return true;
     }
@@ -112,7 +136,7 @@ event_watcher(void *data, SDL_Event *event) {
             && event->window.event == SDL_WINDOWEVENT_RESIZED) {
         // In practice, it seems to always be called from the same thread in
         // that specific case. Anyway, it's just a workaround.
-        screen_render(&screen);
+        screen_render(&screen, true);
     }
     return 0;
 }

app/src/screen.c

@@ -30,10 +30,10 @@ get_rotated_size(struct size size, int rotation) {
 
 // get the window size in a struct size
 static struct size
-get_window_size(SDL_Window *window) {
+get_window_size(const struct screen *screen) {
     int width;
     int height;
-    SDL_GetWindowSize(window, &width, &height);
+    SDL_GetWindowSize(screen->window, &width, &height);
 
     struct size size;
     size.width = width;
@@ -41,31 +41,12 @@ get_window_size(SDL_Window *window) {
     return size;
 }
 
-// get the windowed window size
-static struct size
-get_windowed_window_size(const struct screen *screen) {
-    if (screen->fullscreen || screen->maximized) {
-        return screen->windowed_window_size;
-    }
-    return get_window_size(screen->window);
-}
-
-// apply the windowed window size if fullscreen and maximized are disabled
-static void
-apply_windowed_size(struct screen *screen) {
-    if (!screen->fullscreen && !screen->maximized) {
-        SDL_SetWindowSize(screen->window, screen->windowed_window_size.width,
-                                          screen->windowed_window_size.height);
-    }
-}
-
 // set the window size to be applied when fullscreen is disabled
 static void
 set_window_size(struct screen *screen, struct size new_size) {
-    // setting the window size during fullscreen is implementation defined,
-    // so apply the resize only after fullscreen is disabled
-    screen->windowed_window_size = new_size;
-    apply_windowed_size(screen);
+    assert(!screen->fullscreen);
+    assert(!screen->maximized);
+    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
 }
 
 // get the preferred display bounds (i.e. the screen bounds with some margins)
@@ -144,8 +125,8 @@ get_optimal_size(struct size current_size, struct size content_size) {
 // same as get_optimal_size(), but read the current size from the window
 static inline struct size
 get_optimal_window_size(const struct screen *screen, struct size content_size) {
-    struct size windowed_size = get_windowed_window_size(screen);
-    return get_optimal_size(windowed_size, content_size);
+    struct size window_size = get_window_size(screen);
+    return get_optimal_size(window_size, content_size);
 }
 
 // initially, there is no current size, so use the frame size as current size
@@ -176,7 +157,7 @@ get_initial_optimal_size(struct size content_size, uint16_t req_width,
 }
 
 static void
-update_content_rect(struct screen *screen) {
+screen_update_content_rect(struct screen *screen) {
     int dw;
     int dh;
     SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
@@ -210,8 +191,6 @@ update_content_rect(struct screen *screen) {
                                        / content_size.height;
         rect->x = (drawable_size.width - rect->w) / 2;
     }
-
-    LOGI("== update_content_rect: %d,%d %dx%d", rect->x, rect->y, rect->w, rect->h);
 }
 
 void
@@ -346,10 +325,12 @@ screen_init_rendering(struct screen *screen, const char *window_title,
         return false;
     }
 
-    LOGI("# init");
-    update_content_rect(screen);
+    // Reset the window size to trigger a SIZE_CHANGED event, to workaround
+    // HiDPI issues with some SDL renderers when several displays having
+    // different HiDPI scaling are connected
+    SDL_SetWindowSize(screen->window, window_size.width, window_size.height);
 
-    screen->windowed_window_size = window_size;
+    screen_update_content_rect(screen);
 
     return true;
 }
@@ -372,6 +353,45 @@ screen_destroy(struct screen *screen) {
     }
 }
 
+static void
+resize_for_content(struct screen *screen, struct size old_content_size,
+                                                 struct size new_content_size) {
+    struct size window_size = get_window_size(screen);
+    struct size target_size = {
+        .width = (uint32_t) window_size.width * new_content_size.width
+                / old_content_size.width,
+        .height = (uint32_t) window_size.height * new_content_size.height
+                / old_content_size.height,
+    };
+    target_size = get_optimal_size(target_size, new_content_size);
+    set_window_size(screen, target_size);
+}
+
+static void
+set_content_size(struct screen *screen, struct size new_content_size) {
+    if (!screen->fullscreen && !screen->maximized) {
+        resize_for_content(screen, screen->content_size, new_content_size);
+    } else if (!screen->resize_pending) {
+        // Store the windowed size to be able to compute the optimal size once
+        // fullscreen and maximized are disabled
+        screen->windowed_content_size = screen->content_size;
+        screen->resize_pending = true;
+    }
+
+    screen->content_size = new_content_size;
+}
+
+static void
+apply_pending_resize(struct screen *screen) {
+    assert(!screen->fullscreen);
+    assert(!screen->maximized);
+    if (screen->resize_pending) {
+        resize_for_content(screen, screen->windowed_content_size,
+                                   screen->content_size);
+        screen->resize_pending = false;
+    }
+}
+
 void
 screen_set_rotation(struct screen *screen, unsigned rotation) {
     assert(rotation < 4);
@@ -379,26 +399,15 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
         return;
     }
 
-    struct size old_content_size = screen->content_size;
     struct size new_content_size =
         get_rotated_size(screen->frame_size, rotation);
 
-    struct size windowed_size = get_windowed_window_size(screen);
-    struct size target_size = {
-        .width = (uint32_t) windowed_size.width * new_content_size.width
-                / old_content_size.width,
-        .height = (uint32_t) windowed_size.height * new_content_size.height
-                / old_content_size.height,
-    };
-    target_size = get_optimal_size(target_size, new_content_size);
-    set_window_size(screen, target_size);
+    set_content_size(screen, new_content_size);
 
-    screen->content_size = new_content_size;
     screen->rotation = rotation;
     LOGI("Display rotation set to %u", rotation);
 
-    update_content_rect(screen);
-    screen_render(screen);
+    screen_render(screen, true);
 }
 
 // recreate the texture and resize the window if the frame size has changed
@@ -409,23 +418,13 @@ prepare_for_frame(struct screen *screen, struct size new_frame_size) {
         // frame dimension changed, destroy texture
         SDL_DestroyTexture(screen->texture);
 
+        screen->frame_size = new_frame_size;
+
         struct size new_content_size =
             get_rotated_size(new_frame_size, screen->rotation);
-        struct size content_size = screen->content_size;
-        struct size windowed_size = get_windowed_window_size(screen);
-        struct size target_size = {
-            (uint32_t) windowed_size.width * new_content_size.width
-                    / content_size.width,
-            (uint32_t) windowed_size.height * new_content_size.height
-                    / content_size.height,
-        };
-        target_size = get_optimal_size(target_size, new_content_size);
-        set_window_size(screen, target_size);
+        set_content_size(screen, new_content_size);
 
-        screen->frame_size = new_frame_size;
-        screen->content_size = new_content_size;
-        LOGI("# prepare_for_frame");
-        update_content_rect(screen);
+        screen_update_content_rect(screen);
 
         LOGI("New texture: %" PRIu16 "x%" PRIu16,
                      screen->frame_size.width, screen->frame_size.height);
@@ -467,12 +466,16 @@ screen_update_frame(struct screen *screen, struct video_buffer *vb) {
     update_texture(screen, frame);
     mutex_unlock(vb->mutex);
 
-    screen_render(screen);
+    screen_render(screen, false);
     return true;
 }
 
 void
-screen_render(struct screen *screen) {
+screen_render(struct screen *screen, bool update_content_rect) {
+    if (update_content_rect) {
+        screen_update_content_rect(screen);
+    }
+
     SDL_RenderClear(screen->renderer);
     if (screen->rotation == 0) {
         SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
@@ -510,26 +513,20 @@ screen_switch_fullscreen(struct screen *screen) {
     }
 
     screen->fullscreen = !screen->fullscreen;
-    apply_windowed_size(screen);
+    if (!screen->fullscreen && !screen->maximized) {
+        apply_pending_resize(screen);
+    }
 
     LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
-    LOGI("# screen_switch_fullscreen");
-    update_content_rect(screen);
-    screen_render(screen);
+    screen_render(screen, true);
 }
 
 void
 screen_resize_to_fit(struct screen *screen) {
-    LOGI("resize_to_fit (fullscreen=%d)", screen->fullscreen);
-    if (screen->fullscreen) {
+    if (screen->fullscreen || screen->maximized) {
         return;
     }
 
-    if (screen->maximized) {
-        SDL_RestoreWindow(screen->window);
-        screen->maximized = false;
-    }
-
     struct size optimal_size =
         get_optimal_window_size(screen, screen->content_size);
     SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
@@ -559,43 +556,24 @@ screen_handle_window_event(struct screen *screen,
                            const SDL_WindowEvent *event) {
     switch (event->event) {
         case SDL_WINDOWEVENT_EXPOSED:
-            LOGI("SDL_WINDOW_EVENT_EXPOSED");
-            update_content_rect(screen);
-            screen_render(screen);
+            screen_render(screen, true);
             break;
         case SDL_WINDOWEVENT_SIZE_CHANGED:
-            if (!screen->fullscreen && !screen->maximized) {
-                // Backup the previous size: if we receive the MAXIMIZED event,
-                // then the new size must be ignored (it's the maximized size).
-                // We could not rely on the window flags due to race conditions
-                // (they could be updated asynchronously, at least on X11).
-                screen->windowed_window_size_backup =
-                    screen->windowed_window_size;
-
-                // Save the windowed size, so that it is available once the
-                // window is maximized or fullscreen is enabled.
-                screen->windowed_window_size = get_window_size(screen->window);
-            }
-            LOGI("SDL_WINDOW_EVENT_SIZE_CHANGED");
-            update_content_rect(screen);
-            screen_render(screen);
+            screen_render(screen, true);
             break;
         case SDL_WINDOWEVENT_MAXIMIZED:
-            // The backup size must be non-nul.
-            assert(screen->windowed_window_size_backup.width);
-            assert(screen->windowed_window_size_backup.height);
-            // Revert the last size, it was updated while screen was maximized.
-            screen->windowed_window_size = screen->windowed_window_size_backup;
-#ifdef DEBUG
-            // Reset the backup to invalid values to detect unexpected usage
-            screen->windowed_window_size_backup.width = 0;
-            screen->windowed_window_size_backup.height = 0;
-#endif
             screen->maximized = true;
             break;
         case SDL_WINDOWEVENT_RESTORED:
+            if (screen->fullscreen) {
+                // On Windows, in maximized+fullscreen, disabling fullscreen
+                // mode unexpectedly triggers the "restored" then "maximized"
+                // events, leaving the window in a weird state (maximized
+                // according to the events, but not maximized visually).
+                break;
+            }
             screen->maximized = false;
-            apply_windowed_size(screen);
+            apply_pending_resize(screen);
             break;
     }
 }
@@ -605,9 +583,6 @@ screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y) {
     unsigned rotation = screen->rotation;
     assert(rotation < 4);
 
-    int old_x = x;
-    int old_y = y;
-
     int32_t w = screen->content_size.width;
     int32_t h = screen->content_size.height;
 
@@ -616,11 +591,6 @@ screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y) {
     x = (int64_t) (x - screen->rect.x) * w / screen->rect.w;
     y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;
 
-    LOGI("content=%dx%d, rect={%d, %d, %dx%d}: (%d, %d) -> (%d, %d)",
-         (int) w, (int) h,
-         screen->rect.x, screen->rect.y, screen->rect.w, screen->rect.h,
-         old_x, old_y, (int) x, (int) y);
-
     // rotate
     struct point result;
     switch (rotation) {

app/src/screen.h

@@ -21,11 +21,12 @@ struct screen {
     struct sc_opengl gl;
     struct size frame_size;
     struct size content_size; // rotated frame_size
-    // The window size the last time it was not maximized or fullscreen.
-    struct size windowed_window_size;
-    // Since we receive the event SIZE_CHANGED before MAXIMIZED, we must be
-    // able to revert the size to its non-maximized value.
-    struct size windowed_window_size_backup;
+
+    bool resize_pending; // resize requested while fullscreen or maximized
+    // The content size the last time the window was not maximized or
+    // fullscreen (meaningful only when resize_pending is true)
+    struct size windowed_content_size;
+
     // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
     unsigned rotation;
     // rectangle of the content (excluding black borders)
@@ -51,11 +52,8 @@ struct screen {
         .width = 0, \
         .height = 0, \
     }, \
-    .windowed_window_size = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
-    .windowed_window_size_backup = { \
+    .resize_pending = false, \
+    .windowed_content_size = { \
         .width = 0, \
         .height = 0, \
     }, \
@@ -99,8 +97,11 @@ bool
 screen_update_frame(struct screen *screen, struct video_buffer *vb);
 
 // render the texture to the renderer
+//
+// Set the update_content_rect flag if the window or content size may have
+// changed, so that the content rectangle is recomputed
 void
-screen_render(struct screen *screen);
+screen_render(struct screen *screen, bool update_content_rect);
 
 // switch the fullscreen mode
 void

server/src/main/java/com/genymobile/scrcpy/Controller.java

@@ -215,7 +215,7 @@ public class Controller {
 
         MotionEvent event = MotionEvent
                 .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
-                        InputDevice.SOURCE_MOUSE, 0);
+                        InputDevice.SOURCE_TOUCHSCREEN, 0);
         return injectEvent(event);
     }