longlong

Move platorm-specific defines to common.h
They could be useful anywhere.
2019-12-10 09:22:30 +01:00 · 2019-12-10 09:11:09 +01:00
50 changed files with 437 additions and 1248 deletions
--- a/BUILD.md
+++ b/BUILD.md
@ -233,10 +233,10 @@ You can then [run](README.md#run) _scrcpy_.

 ## Prebuilt server

- - [`scrcpy-server-v1.12.1`][direct-scrcpy-server]  
-   _(SHA-256: 63e569c8a1d0c1df31d48c4214871c479a601782945fed50c1e61167d78266ea)_
+ - [`scrcpy-server-v1.12`][direct-scrcpy-server]  
+   _(SHA-256: b6595262c230e9773fdb817257abcc8c6e6e00f15b1c32b6a850ccfd8176dc10)_

-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-server-v1.12.1
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.12/scrcpy-server-v1.12

 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/DEVELOP.md
+++ b/DEVELOP.md
@ -189,7 +189,7 @@ The client uses 4 threads:
   recording,
 - the **controller** thread, sending _control messages_ to the server,
 - the **receiver** thread (managed by the controller), receiving _device
-   messages_ from the server.
+   messages_ from the client.

 In addition, another thread can be started if necessary to handle APK
 installation or file push requests (via drag&drop on the main window) or to
@ -214,7 +214,7 @@ When a new decoded frame is available, the decoder _swaps_ the decoding and
 rendering frame (with proper synchronization). Thus, it immediatly starts
 to decode a new frame while the main thread renders the last one.

-If a [recorder] is present (i.e. `--record` is enabled), then it muxes the raw
+If a [recorder] is present (i.e. `--record` is enabled), then its muxes the raw
 H.264 packet to the output video file.

 [stream]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/stream.h
@ -282,15 +282,6 @@ meson x -Dserver_debugger=true
 meson configure x -Dserver_debugger=true
 ```

-If your device runs Android 8 or below, set the `server_debugger_method` to
-`old` in addition:
-
-```bash
-meson x -Dserver_debugger=true -Dserver_debugger_method=old
-# or, if x is already configured
-meson configure x -Dserver_debugger=true -Dserver_debugger_method=old
-```
-
 Then recompile.

 When you start scrcpy, it will start a debugger on port 5005 on the device.
--- a/2
+++ b/2
@ -188,7 +188,7 @@
      identification within third-party archives.

   Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2020 Romain Vimont
+   Copyright (C) 2018-2019 Romain Vimont

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
--- a/README.ko.md
+++ b/README.ko.md
@ -475,7 +475,7 @@ _²화면이 꺼진 상태에서 우클릭 시 다시 켜지며, 그 외의 상
 ## 라이선스

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2019 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
--- a/README.md
+++ b/README.md
@ -1,4 +1,4 @@
-# scrcpy (v1.12.1)
+# scrcpy (v1.12)

 This application provides display and control of Android devices connected on
 USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
@ -37,11 +37,8 @@ control it using keyboard and mouse.

 ### Linux

-In Debian (_testing_ and _sid_ for now):
-
-```
-apt install scrcpy
-```
+On Linux, you typically need to [build the app manually][BUILD]. Don't worry,
+it's not that hard.

 A [Snap] package is available: [`scrcpy`][snap-link].

@ -59,37 +56,19 @@ For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy

-You could also [build the app manually][BUILD] (don't worry, it's not that
-hard).
-
-

 ### Windows

 For Windows, for simplicity, prebuilt archives with all the dependencies
 (including `adb`) are available:

- - [`scrcpy-win32-v1.12.1.zip`][direct-win32]  
-   _(SHA-256: 0f4b3b063536b50a2df05dc42c760f9cc0093a9a26dbdf02d8232c74dab43480)_
- - [`scrcpy-win64-v1.12.1.zip`][direct-win64]  
-   _(SHA-256: 57d34b6d16cfd9fe169bc37c4df58ebd256d05c1ea3febc63d9cb0a027ab47c9)_
+ - [`scrcpy-win32-v1.12.zip`][direct-win32]  
+   _(SHA-256: b2c8c4a3899c037cf448a2102906775114826ba646ce1b847826925103fa801d)_
+ - [`scrcpy-win64-v1.12.zip`][direct-win64]  
+   _(SHA-256: 7d47983b426f7287de0230b88975dc17c1d9c343fa61a93ff2af78b6e9ef5c8c)_

-[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win32-v1.12.1.zip
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win64-v1.12.1.zip
-
-It is also available in [Chocolatey]:
-
-[Chocolatey]: https://chocolatey.org/
-
-```bash
-choco install scrcpy
-```
-
-You need `adb`, accessible from your `PATH`. If you don't have it yet:
-
-```bash
-choco install adb
-```
+[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.12/scrcpy-win32-v1.12.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.12/scrcpy-win64-v1.12.zip

 You can also [build the app manually][BUILD].

@ -158,14 +137,12 @@ scrcpy -b 2M  # short version

 #### Limit frame rate

-The capture frame rate can be limited:
+On devices with Android >= 10, the capture frame rate can be limited:

 ```bash
 scrcpy --max-fps 15
 ```

-This is officially supported since Android 10, but may work on earlier versions.
-
 #### Crop

 The device screen may be cropped to mirror only part of the screen.
@ -179,21 +156,6 @@ scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
 If `--max-size` is also specified, resizing is applied after cropping.


-#### Lock video orientation
-
-
-To lock the orientation of the mirroring:
-
-```bash
-scrcpy --lock-video-orientation 0   # natural orientation
-scrcpy --lock-video-orientation 1   # 90° counterclockwise
-scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation 3   # 90° clockwise
-```
-
-This affects recording orientation.
-
-
 ### Recording

 It is possible to record the screen while mirroring:
@ -252,25 +214,8 @@ scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # short version
 ```

-If the device is connected over TCP/IP:
-
-```bash
-scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # short version
-```
-
 You can start several instances of _scrcpy_ for several devices.

-#### Autostart on device connection
-
-You could use [AutoAdb]:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/usbaudio
-
 #### SSH tunnel

 To connect to a remote device, it is possible to connect a local `adb` client to
@ -353,21 +298,6 @@ scrcpy --no-control
 scrcpy -n
 ```

-#### Display
-
-If several displays are available, it is possible to select the display to
-mirror:
-
-```bash
-scrcpy --display 1
-```
-
-The list of display ids can be retrieved by:
-
-```
-adb shell dumpsys display   # search "mDisplayId=" in the output
-```
-
 #### Turn screen off

 It is possible to turn the device screen off while mirroring on start with a
@ -559,7 +489,7 @@ Read the [developers page].
 ## Licence

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2019 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
--- a/app/meson.build
+++ b/app/meson.build
@ -76,9 +76,11 @@ cc = meson.get_compiler('c')

 if host_machine.system() == 'windows'
    src += [ 'src/sys/win/command.c' ]
+    src += [ 'src/sys/win/net.c' ]
    dependencies += cc.find_library('ws2_32')
 else
    src += [ 'src/sys/unix/command.c' ]
+    src += [ 'src/sys/unix/net.c' ]
 endif

 conf = configuration_data()
@ -96,21 +98,14 @@ conf.set_quoted('PREFIX', get_option('prefix'))
 # directory as the executable)
 conf.set('PORTABLE', get_option('portable'))

-# the default client TCP port range for the "adb reverse" tunnel
+# the default client TCP port for the "adb reverse" tunnel
 # overridden by option --port
-conf.set('DEFAULT_LOCAL_PORT_RANGE_FIRST', '27183')
-conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')
+conf.set('DEFAULT_LOCAL_PORT', '27183')

 # the default max video size for both dimensions, in pixels
 # overridden by option --max-size
 conf.set('DEFAULT_MAX_SIZE', '0')  # 0: unlimited

-# the default video orientation
-# natural device orientation is 0 and each increment adds 90 degrees
-# counterclockwise
-# overridden by option --lock-video-orientation
-conf.set('DEFAULT_LOCK_VIDEO_ORIENTATION', '-1')  # -1: unlocked
-
 # the default video bitrate, in bits/second
 # overridden by option --bit-rate
 conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
@ -124,9 +119,6 @@ conf.set('WINDOWS_NOCONSOLE', get_option('windows_noconsole'))
 # run a server debugger and wait for a client to be attached
 conf.set('SERVER_DEBUGGER', get_option('server_debugger'))

-# select the debugger method ('old' for Android < 9, 'new' for Android >= 9)
-conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == 'new')
-
 configure_file(configuration: conf, output: 'config.h')

 src_dir = include_directories('src')
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -33,15 +33,6 @@ The values are expressed in the device natural orientation (typically, portrait
 .B \-\-max\-size
 value is computed on the cropped size.

-.TP
-.BI "\-\-display " id
-Specify the display id to mirror.
-
-The list of possible display ids can be listed by "adb shell dumpsys display"
-(search "mDisplayId=" in the output).
-
-Default is 0.
-
 .TP
 .B \-f, \-\-fullscreen
 Start in fullscreen.
@ -50,15 +41,9 @@ Start in fullscreen.
 .B \-h, \-\-help
 Print this help.

-.TP
-.BI "\-\-lock\-video\-orientation " value
-Lock video orientation to \fIvalue\fR. Values are integers in the range [-1..3]. Natural device orientation is 0 and each increment adds 90 degrees counterclockwise.
-
-Default is -1 (unlocked).
-
 .TP
 .BI "\-\-max\-fps " value
-Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
+Limit the framerate of screen capture (only supported on devices with Android >= 10).

 .TP
 .BI "\-m, \-\-max\-size " value
@ -75,10 +60,10 @@ Disable device control (mirror the device in read\-only).
 Do not display device (only when screen recording is enabled).

 .TP
-.BI "\-p, \-\-port " port[:port]
-Set the TCP port (range) used by the client to listen.
+.BI "\-p, \-\-port " port
+Set the TCP port the client listens on.

-Default is 27183:27199.
+Default is 27183.

 .TP
 .B \-\-prefer\-text
@ -140,13 +125,13 @@ Set a custom window title.
 .BI "\-\-window\-x " value
 Set the initial window horizontal position.

-Default is "auto".\n
+Default is -1 (automatic).\n

 .TP
 .BI "\-\-window\-y " value
 Set the initial window vertical position.

-Default is "auto".\n
+Default is -1 (automatic).\n

 .TP
 .BI "\-\-window\-width " value
@ -276,7 +261,7 @@ Copyright \(co 2018 Genymobile
 Genymobile
 .UE

-Copyright \(co 2018\-2020
+Copyright \(co 2018\-2019
 .MT rom@rom1v.com
 Romain Vimont
 .ME
--- a/app/src/cli.c
+++ b/app/src/cli.c
@ -1,8 +1,8 @@
 #include "cli.h"

-#include <assert.h>
 #include <getopt.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <unistd.h>

 #include "config.h"
@ -36,30 +36,15 @@ scrcpy_print_usage(const char *arg0) {
        "        (typically, portrait for a phone, landscape for a tablet).\n"
        "        Any --max-size value is computed on the cropped size.\n"
        "\n"
-        "    --display id\n"
-        "        Specify the display id to mirror.\n"
-        "\n"
-        "        The list of possible display ids can be listed by:\n"
-        "            adb shell dumpsys display\n"
-        "        (search \"mDisplayId=\" in the output)\n"
-        "\n"
-        "        Default is 0.\n"
-        "\n"
        "    -f, --fullscreen\n"
        "        Start in fullscreen.\n"
        "\n"
        "    -h, --help\n"
        "        Print this help.\n"
        "\n"
-        "    --lock-video-orientation value\n"
-        "        Lock video orientation to value. Values are integers in the\n"
-        "        range [-1..3]. Natural device orientation is 0 and each\n"
-        "        increment adds 90 degrees counterclockwise.\n"
-        "        Default is %d%s.\n"
-        "\n"
        "    --max-fps value\n"
-        "        Limit the frame rate of screen capture (officially supported\n"
-        "        since Android 10, but may work on earlier versions).\n"
+        "        Limit the frame rate of screen capture (only supported on\n"
+        "        devices with Android >= 10).\n"
        "\n"
        "    -m, --max-size value\n"
        "        Limit both the width and height of the video to value. The\n"
@ -74,9 +59,9 @@ scrcpy_print_usage(const char *arg0) {
        "        Do not display device (only when screen recording is\n"
        "        enabled).\n"
        "\n"
-        "    -p, --port port[:port]\n"
-        "        Set the TCP port (range) used by the client to listen.\n"
-        "        Default is %d:%d.\n"
+        "    -p, --port port\n"
+        "        Set the TCP port the client listens on.\n"
+        "        Default is %d.\n"
        "\n"
        "    --prefer-text\n"
        "        Inject alpha characters and space as text events instead of\n"
@ -126,11 +111,11 @@ scrcpy_print_usage(const char *arg0) {
        "\n"
        "    --window-x value\n"
        "        Set the initial window horizontal position.\n"
-        "        Default is \"auto\".\n"
+        "        Default is -1 (automatic).\n"
        "\n"
        "    --window-y value\n"
        "        Set the initial window vertical position.\n"
-        "        Default is \"auto\".\n"
+        "        Default is -1 (automatic).\n"
        "\n"
        "    --window-width value\n"
        "        Set the initial window width.\n"
@ -208,15 +193,14 @@ scrcpy_print_usage(const char *arg0) {
        "\n",
        arg0,
        DEFAULT_BIT_RATE,
-        DEFAULT_LOCK_VIDEO_ORIENTATION, DEFAULT_LOCK_VIDEO_ORIENTATION >= 0 ? "" : " (unlocked)",
        DEFAULT_MAX_SIZE, DEFAULT_MAX_SIZE ? "" : " (unlimited)",
-        DEFAULT_LOCAL_PORT_RANGE_FIRST, DEFAULT_LOCAL_PORT_RANGE_LAST);
+        DEFAULT_LOCAL_PORT);
 }

 static bool
-parse_integer_arg(const char *s, long *out, bool accept_suffix, long min,
-                  long max, const char *name) {
-    long value;
+parse_integer_arg(const char *s, long long *out, bool accept_suffix,
+                  long long min, long long max, const char *name) {
+    long long value;
    bool ok;
    if (accept_suffix) {
        ok = parse_integer_with_suffix(s, &value);
@ -229,8 +213,8 @@ parse_integer_arg(const char *s, long *out, bool accept_suffix, long min,
    }

    if (value < min || value > max) {
-        LOGE("Could not parse %s: value (%ld) out-of-range (%ld; %ld)",
-             name, value, min, max);
+        LOGE("Could not parse %s: value (%" PRIlld ") out-of-range (%"
+             PRIlld "; %" PRIlld ")", name, value, min, max);
        return false;
    }

@ -238,33 +222,10 @@ parse_integer_arg(const char *s, long *out, bool accept_suffix, long min,
    return true;
 }

-static size_t
-parse_integers_arg(const char *s, size_t max_items, long *out, long min,
-                   long max, const char *name) {
-    size_t count = parse_integers(s, ':', max_items, out);
-    if (!count) {
-        LOGE("Could not parse %s: %s", name, s);
-        return 0;
-    }
-
-    for (size_t i = 0; i < count; ++i) {
-        long value = out[i];
-        if (value < min || value > max) {
-            LOGE("Could not parse %s: value (%ld) out-of-range (%ld; %ld)",
-                 name, value, min, max);
-            return 0;
-        }
-    }
-
-    return count;
-}
-
 static bool
 parse_bit_rate(const char *s, uint32_t *bit_rate) {
-    long value;
-    // long may be 32 bits (it is the case on mingw), so do not use more than
-    // 31 bits (long is signed)
-    bool ok = parse_integer_arg(s, &value, true, 0, 0x7FFFFFFF, "bit-rate");
+    long long value;
+    bool ok = parse_integer_arg(s, &value, true, 0, 0xFFFFFFFFLL, "bit-rate");
    if (!ok) {
        return false;
    }
@ -275,7 +236,7 @@ parse_bit_rate(const char *s, uint32_t *bit_rate) {

 static bool
 parse_max_size(const char *s, uint16_t *max_size) {
-    long value;
+    long long value;
    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF, "max size");
    if (!ok) {
        return false;
@ -287,7 +248,7 @@ parse_max_size(const char *s, uint16_t *max_size) {

 static bool
 parse_max_fps(const char *s, uint16_t *max_fps) {
-    long value;
+    long long value;
    bool ok = parse_integer_arg(s, &value, false, 0, 1000, "max fps");
    if (!ok) {
        return false;
@ -297,31 +258,10 @@ parse_max_fps(const char *s, uint16_t *max_fps) {
    return true;
 }

-static bool
-parse_lock_video_orientation(const char *s, int8_t *lock_video_orientation) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, -1, 3,
-                                "lock video orientation");
-    if (!ok) {
-        return false;
-    }
-
-    *lock_video_orientation = (int8_t) value;
-    return true;
-}
-
 static bool
 parse_window_position(const char *s, int16_t *position) {
-    // special value for "auto"
-    static_assert(WINDOW_POSITION_UNDEFINED == -0x8000, "unexpected value");
-
-    if (!strcmp(s, "auto")) {
-        *position = WINDOW_POSITION_UNDEFINED;
-        return true;
-    }
-
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, -0x7FFF, 0x7FFF,
+    long long value;
+    bool ok = parse_integer_arg(s, &value, false, -1, 0x7FFF,
                                "window position");
    if (!ok) {
        return false;
@ -333,7 +273,7 @@ parse_window_position(const char *s, int16_t *position) {

 static bool
 parse_window_dimension(const char *s, uint16_t *dimension) {
-    long value;
+    long long value;
    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF,
                                "window dimension");
    if (!ok) {
@ -345,42 +285,14 @@ parse_window_dimension(const char *s, uint16_t *dimension) {
 }

 static bool
-parse_port_range(const char *s, struct port_range *port_range) {
-    long values[2];
-    size_t count = parse_integers_arg(s, 2, values, 0, 0xFFFF, "port");
-    if (!count) {
-        return false;
-    }
-
-    uint16_t v0 = (uint16_t) values[0];
-    if (count == 1) {
-        port_range->first = v0;
-        port_range->last = v0;
-        return true;
-    }
-
-    assert(count == 2);
-    uint16_t v1 = (uint16_t) values[1];
-    if (v0 < v1) {
-        port_range->first = v0;
-        port_range->last = v1;
-    } else {
-        port_range->first = v1;
-        port_range->last = v0;
-    }
-
-    return true;
-}
-
-static bool
-parse_display_id(const char *s, uint16_t *display_id) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF, "display id");
+parse_port(const char *s, uint16_t *port) {
+    long long value;
+    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF, "port");
    if (!ok) {
        return false;
    }

-    *display_id = (uint16_t) value;
+    *port = (uint16_t) value;
    return true;
 }

@ -414,56 +326,51 @@ guess_record_format(const char *filename) {
    return 0;
 }

-#define OPT_RENDER_EXPIRED_FRAMES  1000
-#define OPT_WINDOW_TITLE           1001
-#define OPT_PUSH_TARGET            1002
-#define OPT_ALWAYS_ON_TOP          1003
-#define OPT_CROP                   1004
-#define OPT_RECORD_FORMAT          1005
-#define OPT_PREFER_TEXT            1006
-#define OPT_WINDOW_X               1007
-#define OPT_WINDOW_Y               1008
-#define OPT_WINDOW_WIDTH           1009
-#define OPT_WINDOW_HEIGHT          1010
-#define OPT_WINDOW_BORDERLESS      1011
-#define OPT_MAX_FPS                1012
-#define OPT_LOCK_VIDEO_ORIENTATION 1013
-#define OPT_DISPLAY_ID             1014
+#define OPT_RENDER_EXPIRED_FRAMES 1000
+#define OPT_WINDOW_TITLE          1001
+#define OPT_PUSH_TARGET           1002
+#define OPT_ALWAYS_ON_TOP         1003
+#define OPT_CROP                  1004
+#define OPT_RECORD_FORMAT         1005
+#define OPT_PREFER_TEXT           1006
+#define OPT_WINDOW_X              1007
+#define OPT_WINDOW_Y              1008
+#define OPT_WINDOW_WIDTH          1009
+#define OPT_WINDOW_HEIGHT         1010
+#define OPT_WINDOW_BORDERLESS     1011
+#define OPT_MAX_FPS               1012

 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
    static const struct option long_options[] = {
-        {"always-on-top",          no_argument,       NULL, OPT_ALWAYS_ON_TOP},
-        {"bit-rate",               required_argument, NULL, 'b'},
-        {"crop",                   required_argument, NULL, OPT_CROP},
-        {"display",                required_argument, NULL, OPT_DISPLAY_ID},
-        {"fullscreen",             no_argument,       NULL, 'f'},
-        {"help",                   no_argument,       NULL, 'h'},
-        {"lock-video-orientation", required_argument, NULL,
-                                                  OPT_LOCK_VIDEO_ORIENTATION},
-        {"max-fps",                required_argument, NULL, OPT_MAX_FPS},
-        {"max-size",               required_argument, NULL, 'm'},
-        {"no-control",             no_argument,       NULL, 'n'},
-        {"no-display",             no_argument,       NULL, 'N'},
-        {"port",                   required_argument, NULL, 'p'},
-        {"push-target",            required_argument, NULL, OPT_PUSH_TARGET},
-        {"record",                 required_argument, NULL, 'r'},
-        {"record-format",          required_argument, NULL, OPT_RECORD_FORMAT},
-        {"render-expired-frames",  no_argument,       NULL,
-                                                  OPT_RENDER_EXPIRED_FRAMES},
-        {"serial",                 required_argument, NULL, 's'},
-        {"show-touches",           no_argument,       NULL, 't'},
-        {"turn-screen-off",        no_argument,       NULL, 'S'},
-        {"prefer-text",            no_argument,       NULL, OPT_PREFER_TEXT},
-        {"version",                no_argument,       NULL, 'v'},
-        {"window-title",           required_argument, NULL, OPT_WINDOW_TITLE},
-        {"window-x",               required_argument, NULL, OPT_WINDOW_X},
-        {"window-y",               required_argument, NULL, OPT_WINDOW_Y},
-        {"window-width",           required_argument, NULL, OPT_WINDOW_WIDTH},
-        {"window-height",          required_argument, NULL, OPT_WINDOW_HEIGHT},
-        {"window-borderless",      no_argument,       NULL,
-                                                  OPT_WINDOW_BORDERLESS},
-        {NULL,                     0,                 NULL, 0  },
+        {"always-on-top",         no_argument,       NULL, OPT_ALWAYS_ON_TOP},
+        {"bit-rate",              required_argument, NULL, 'b'},
+        {"crop",                  required_argument, NULL, OPT_CROP},
+        {"fullscreen",            no_argument,       NULL, 'f'},
+        {"help",                  no_argument,       NULL, 'h'},
+        {"max-fps",               required_argument, NULL, OPT_MAX_FPS},
+        {"max-size",              required_argument, NULL, 'm'},
+        {"no-control",            no_argument,       NULL, 'n'},
+        {"no-display",            no_argument,       NULL, 'N'},
+        {"port",                  required_argument, NULL, 'p'},
+        {"push-target",           required_argument, NULL, OPT_PUSH_TARGET},
+        {"record",                required_argument, NULL, 'r'},
+        {"record-format",         required_argument, NULL, OPT_RECORD_FORMAT},
+        {"render-expired-frames", no_argument,       NULL,
+                                                     OPT_RENDER_EXPIRED_FRAMES},
+        {"serial",                required_argument, NULL, 's'},
+        {"show-touches",          no_argument,       NULL, 't'},
+        {"turn-screen-off",       no_argument,       NULL, 'S'},
+        {"prefer-text",           no_argument,       NULL, OPT_PREFER_TEXT},
+        {"version",               no_argument,       NULL, 'v'},
+        {"window-title",          required_argument, NULL, OPT_WINDOW_TITLE},
+        {"window-x",              required_argument, NULL, OPT_WINDOW_X},
+        {"window-y",              required_argument, NULL, OPT_WINDOW_Y},
+        {"window-width",          required_argument, NULL, OPT_WINDOW_WIDTH},
+        {"window-height",         required_argument, NULL, OPT_WINDOW_HEIGHT},
+        {"window-borderless",     no_argument,       NULL,
+                                                     OPT_WINDOW_BORDERLESS},
+        {NULL,                    0,                 NULL, 0  },
    };

    struct scrcpy_options *opts = &args->opts;
@ -485,11 +392,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case OPT_CROP:
                opts->crop = optarg;
                break;
-            case OPT_DISPLAY_ID:
-                if (!parse_display_id(optarg, &opts->display_id)) {
-                    return false;
-                }
-                break;
            case 'f':
                opts->fullscreen = true;
                break;
@ -514,11 +416,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
                    return false;
                }
                break;
-            case OPT_LOCK_VIDEO_ORIENTATION:
-                if (!parse_lock_video_orientation(optarg, &opts->lock_video_orientation)) {
-                    return false;
-                }
-                break;
            case 'n':
                opts->control = false;
                break;
@ -526,7 +423,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
                opts->display = false;
                break;
            case 'p':
-                if (!parse_port_range(optarg, &opts->port_range)) {
+                if (!parse_port(optarg, &opts->port)) {
                    return false;
                }
                break;
--- a/app/src/command.c
+++ b/app/src/command.c
@ -4,6 +4,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>

 #include "config.h"
 #include "common.h"
@ -55,32 +58,6 @@ argv_to_string(const char *const *argv, char *buf, size_t bufsize) {
    return idx;
 }

-static void
-show_adb_installation_msg() {
-#ifndef __WINDOWS__
-    static const struct {
-        const char *binary;
-        const char *command;
-    } pkg_managers[] = {
-        {"apt", "apt install adb"},
-        {"apt-get", "apt-get install adb"},
-        {"brew", "brew cask install android-platform-tools"},
-        {"dnf", "dnf install android-tools"},
-        {"emerge", "emerge dev-util/android-tools"},
-        {"pacman", "pacman -S android-tools"},
-    };
-    for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
-        if (cmd_search(pkg_managers[i].binary)) {
-            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
-            return;
-        }
-    }
-#endif
-
-    LOGI("You may download and install 'adb' from "
-         "https://developer.android.com/studio/releases/platform-tools");
-}
-
 static void
 show_adb_err_msg(enum process_result err, const char *const argv[]) {
    char buf[512];
@ -94,7 +71,6 @@ show_adb_err_msg(enum process_result err, const char *const argv[]) {
            LOGE("Command not found: %s", buf);
            LOGE("(make 'adb' accessible from your PATH or define its full"
                 "path in the ADB environment variable)");
-            show_adb_installation_msg();
            break;
        case PROCESS_SUCCESS:
            // do nothing
@ -229,3 +205,14 @@ process_check_success(process_t proc, const char *name) {
    }
    return true;
 }
+
+bool
+is_regular_file(const char *path) {
+    struct stat path_stat;
+    int r = stat(path, &path_stat);
+    if (r) {
+        perror("stat");
+        return false;
+    }
+    return S_ISREG(path_stat.st_mode);
+}
--- a/app/src/command.h
+++ b/app/src/command.h
@ -4,38 +4,8 @@
 #include <stdbool.h>
 #include <inttypes.h>

-#ifdef _WIN32
-
- // not needed here, but winsock2.h must never be included AFTER windows.h
-# include <winsock2.h>
-# include <windows.h>
-# define PATH_SEPARATOR '\\'
-# define PRIexitcode "lu"
-// <https://stackoverflow.com/a/44383330/1987178>
-# ifdef _WIN64
-#   define PRIsizet PRIu64
-# else
-#   define PRIsizet PRIu32
-# endif
-# define PROCESS_NONE NULL
-# define NO_EXIT_CODE -1u // max value as unsigned
-  typedef HANDLE process_t;
-  typedef DWORD exit_code_t;
-
-#else
-
-# include <sys/types.h>
-# define PATH_SEPARATOR '/'
-# define PRIsizet "zu"
-# define PRIexitcode "d"
-# define PROCESS_NONE -1
-# define NO_EXIT_CODE -1
-  typedef pid_t process_t;
-  typedef int exit_code_t;
-
-#endif
-
 #include "config.h"
+#include "common.h"

 enum process_result {
    PROCESS_SUCCESS,
@ -43,11 +13,6 @@ enum process_result {
    PROCESS_ERROR_MISSING_BINARY,
 };

-#ifndef __WINDOWS__
-bool
-cmd_search(const char *file);
-#endif
-
 enum process_result
 cmd_execute(const char *const argv[], process_t *process);

--- a/app/src/common.h
+++ b/app/src/common.h
@ -5,6 +5,44 @@

 #include "config.h"

+#ifdef _WIN32
+
+ // not needed here, but winsock2.h must never be included AFTER windows.h
+# include <winsock2.h>
+# include <windows.h>
+# define PATH_SEPARATOR '\\'
+# define PRIexitcode "lu"
+// <https://stackoverflow.com/a/44383330/1987178>
+# ifdef _WIN64
+#   define PRIsizet PRIu64
+# else
+#   define PRIsizet PRIu32
+# endif
+# define PROCESS_NONE NULL
+# define NO_EXIT_CODE -1u // max value as unsigned
+  typedef HANDLE process_t;
+  typedef DWORD exit_code_t;
+
+#else
+
+# include <sys/types.h>
+# define PATH_SEPARATOR '/'
+# define PRIsizet "zu"
+# define PRIexitcode "d"
+# define PROCESS_NONE -1
+# define NO_EXIT_CODE -1
+  typedef pid_t process_t;
+  typedef int exit_code_t;
+
+#endif
+
+// in MinGW, "%ll" is not supported as printf format for long long
+# ifdef __MINGW32__
+#   define PRIlld "I64d"
+# else
+#   define PRIlld "lld"
+# endif
+
 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
 #define MIN(X,Y) (X) < (Y) ? (X) : (Y)
 #define MAX(X,Y) (X) > (Y) ? (X) : (Y)
@ -27,9 +65,4 @@ struct position {
    struct point point;
 };

-struct port_range {
-    uint16_t first;
-    uint16_t last;
-};
-
 #endif
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@ -94,23 +94,6 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
    }

-    if (!(mod & (KMOD_NUM | KMOD_SHIFT))) {
-        // Handle Numpad events when Num Lock is disabled
-        // If SHIFT is pressed, a text event will be sent instead
-        switch(from) {
-            MAP(SDLK_KP_0,            AKEYCODE_INSERT);
-            MAP(SDLK_KP_1,            AKEYCODE_MOVE_END);
-            MAP(SDLK_KP_2,            AKEYCODE_DPAD_DOWN);
-            MAP(SDLK_KP_3,            AKEYCODE_PAGE_DOWN);
-            MAP(SDLK_KP_4,            AKEYCODE_DPAD_LEFT);
-            MAP(SDLK_KP_6,            AKEYCODE_DPAD_RIGHT);
-            MAP(SDLK_KP_7,            AKEYCODE_MOVE_HOME);
-            MAP(SDLK_KP_8,            AKEYCODE_DPAD_UP);
-            MAP(SDLK_KP_9,            AKEYCODE_PAGE_UP);
-            MAP(SDLK_KP_PERIOD,       AKEYCODE_FORWARD_DEL);
-        }
-    }
-
    if (prefer_text) {
        // do not forward alpha and space key events
        return false;
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -60,9 +60,9 @@ sdl_init_and_configure(bool display) {
        return true;
    }

-    // Linear filtering
-    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
-        LOGW("Could not enable linear filtering");
+    // Use the best available scale quality
+    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "2")) {
+        LOGW("Could not enable bilinear filtering");
    }

 #ifdef SCRCPY_SDL_HAS_HINT_MOUSE_FOCUS_CLICKTHROUGH
@ -280,13 +280,11 @@ scrcpy(const struct scrcpy_options *options) {
    bool record = !!options->record_filename;
    struct server_params params = {
        .crop = options->crop,
-        .port_range = options->port_range,
+        .local_port = options->port,
        .max_size = options->max_size,
        .bit_rate = options->bit_rate,
        .max_fps = options->max_fps,
-        .lock_video_orientation = options->lock_video_orientation,
        .control = options->control,
-        .display_id = options->display_id,
    };
    if (!server_start(&server, options->serial, &params)) {
        return false;
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@ -5,7 +5,6 @@
 #include <stdint.h>

 #include "config.h"
-#include "common.h"
 #include "input_manager.h"
 #include "recorder.h"

@ -16,16 +15,14 @@ struct scrcpy_options {
    const char *window_title;
    const char *push_target;
    enum recorder_format record_format;
-    struct port_range port_range;
+    uint16_t port;
    uint16_t max_size;
    uint32_t bit_rate;
    uint16_t max_fps;
-    int8_t lock_video_orientation;
-    int16_t window_x; // WINDOW_POSITION_UNDEFINED for "auto"
-    int16_t window_y; // WINDOW_POSITION_UNDEFINED for "auto"
+    int16_t window_x;
+    int16_t window_y;
    uint16_t window_width;
    uint16_t window_height;
-    uint16_t display_id;
    bool show_touches;
    bool fullscreen;
    bool always_on_top;
@ -44,19 +41,14 @@ struct scrcpy_options {
    .window_title = NULL, \
    .push_target = NULL, \
    .record_format = RECORDER_FORMAT_AUTO, \
-    .port_range = { \
-        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
-        .last = DEFAULT_LOCAL_PORT_RANGE_LAST, \
-    }, \
+    .port = DEFAULT_LOCAL_PORT, \
    .max_size = DEFAULT_MAX_SIZE, \
    .bit_rate = DEFAULT_BIT_RATE, \
    .max_fps = 0, \
-    .lock_video_orientation = DEFAULT_LOCK_VIDEO_ORIENTATION, \
-    .window_x = WINDOW_POSITION_UNDEFINED, \
-    .window_y = WINDOW_POSITION_UNDEFINED, \
+    .window_x = -1, \
+    .window_y = -1, \
    .window_width = 0, \
    .window_height = 0, \
-    .display_id = 0, \
    .show_touches = false, \
    .fullscreen = false, \
    .always_on_top = false, \
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -186,10 +186,8 @@ screen_init_rendering(struct screen *screen, const char *window_title,
        window_flags |= SDL_WINDOW_BORDERLESS;
    }

-    int x = window_x != WINDOW_POSITION_UNDEFINED
-          ? window_x : (int) SDL_WINDOWPOS_UNDEFINED;
-    int y = window_y != WINDOW_POSITION_UNDEFINED
-          ? window_y : (int) SDL_WINDOWPOS_UNDEFINED;
+    int x = window_x != -1 ? window_x : (int) SDL_WINDOWPOS_UNDEFINED;
+    int y = window_y != -1 ? window_y : (int) SDL_WINDOWPOS_UNDEFINED;
    screen->window = SDL_CreateWindow(window_title, x, y,
                                      window_size.width, window_size.height,
                                      window_flags);
--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -8,8 +8,6 @@
 #include "config.h"
 #include "common.h"

-#define WINDOW_POSITION_UNDEFINED (-0x8000)
-
 struct video_buffer;

 struct screen {
@ -55,7 +53,6 @@ void
 screen_init(struct screen *screen);

 // initialize screen, create window, renderer and texture (window is hidden)
-// window_x and window_y accept WINDOW_POSITION_UNDEFINED
 bool
 screen_init_rendering(struct screen *screen, const char *window_title,
                      struct size frame_size, bool always_on_top,
--- a/app/src/server.c
+++ b/app/src/server.c
@ -5,15 +5,12 @@
 #include <inttypes.h>
 #include <libgen.h>
 #include <stdio.h>
-#include <SDL2/SDL_thread.h>
 #include <SDL2/SDL_timer.h>
-#include <SDL2/SDL_platform.h>

 #include "config.h"
 #include "command.h"
 #include "util/log.h"
 #include "util/net.h"
-#include "util/str_util.h"

 #define SOCKET_NAME "scrcpy"
 #define SERVER_FILENAME "scrcpy-server"
@ -21,39 +18,20 @@
 #define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FILENAME
 #define DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"

-static char *
+static const char *
 get_server_path(void) {
-#ifdef __WINDOWS__
-    const wchar_t *server_path_env = _wgetenv(L"SCRCPY_SERVER_PATH");
-#else
    const char *server_path_env = getenv("SCRCPY_SERVER_PATH");
-#endif
    if (server_path_env) {
+        LOGD("Using SCRCPY_SERVER_PATH: %s", server_path_env);
        // if the envvar is set, use it
-#ifdef __WINDOWS__
-        char *server_path = utf8_from_wide_char(server_path_env);
-#else
-        char *server_path = SDL_strdup(server_path_env);
-#endif
-        if (!server_path) {
-            LOGE("Could not allocate memory");
-            return NULL;
-        }
-        LOGD("Using SCRCPY_SERVER_PATH: %s", server_path);
-        return server_path;
+        return server_path_env;
    }

 #ifndef PORTABLE
    LOGD("Using server: " DEFAULT_SERVER_PATH);
-    char *server_path = SDL_strdup(DEFAULT_SERVER_PATH);
-    if (!server_path) {
-        LOGE("Could not allocate memory");
-        return NULL;
-    }
    // the absolute path is hardcoded
-    return server_path;
+    return DEFAULT_SERVER_PATH;
 #else
-
    // use scrcpy-server in the same directory as the executable
    char *executable_path = get_executable_path();
    if (!executable_path) {
@ -89,17 +67,12 @@ get_server_path(void) {

 static bool
 push_server(const char *serial) {
-    char *server_path = get_server_path();
-    if (!server_path) {
-        return false;
-    }
+    const char *server_path = get_server_path();
    if (!is_regular_file(server_path)) {
        LOGE("'%s' does not exist or is not a regular file\n", server_path);
-        SDL_free(server_path);
        return false;
    }
    process_t process = adb_push(serial, server_path, DEVICE_SERVER_PATH);
-    SDL_free(server_path);
    return process_check_success(process, "adb push");
 }

@ -127,6 +100,17 @@ disable_tunnel_forward(const char *serial, uint16_t local_port) {
    return process_check_success(process, "adb forward --remove");
 }

+static bool
+enable_tunnel(struct server *server) {
+    if (enable_tunnel_reverse(server->serial, server->local_port)) {
+        return true;
+    }
+
+    LOGW("'adb reverse' failed, fallback to 'adb forward'");
+    server->tunnel_forward = true;
+    return enable_tunnel_forward(server->serial, server->local_port);
+}
+
 static bool
 disable_tunnel(struct server *server) {
    if (server->tunnel_forward) {
@ -135,125 +119,21 @@ disable_tunnel(struct server *server) {
    return disable_tunnel_reverse(server->serial);
 }

-static socket_t
-listen_on_port(uint16_t port) {
-#define IPV4_LOCALHOST 0x7F000001
-    return net_listen(IPV4_LOCALHOST, port, 1);
-}
-
-static bool
-enable_tunnel_reverse_any_port(struct server *server,
-                               struct port_range port_range) {
-    uint16_t port = port_range.first;
-    for (;;) {
-        if (!enable_tunnel_reverse(server->serial, port)) {
-            // the command itself failed, it will fail on any port
-            return false;
-        }
-
-        // At the application level, the device part is "the server" because it
-        // serves video stream and control. However, at the network level, the
-        // client listens and the server connects to the client. That way, the
-        // client can listen before starting the server app, so there is no
-        // need to try to connect until the server socket is listening on the
-        // device.
-        server->server_socket = listen_on_port(port);
-        if (server->server_socket != INVALID_SOCKET) {
-            // success
-            server->local_port = port;
-            return true;
-        }
-
-        // failure, disable tunnel and try another port
-        if (!disable_tunnel_reverse(server->serial)) {
-            LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
-        }
-
-        // check before incrementing to avoid overflow on port 65535
-        if (port < port_range.last) {
-            LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
-                 port, port + 1);
-            port++;
-            continue;
-        }
-
-        if (port_range.first == port_range.last) {
-            LOGE("Could not listen on port %" PRIu16, port_range.first);
-        } else {
-            LOGE("Could not listen on any port in range %" PRIu16 ":%" PRIu16,
-                 port_range.first, port_range.last);
-        }
-        return false;
-    }
-}
-
-static bool
-enable_tunnel_forward_any_port(struct server *server,
-                               struct port_range port_range) {
-    server->tunnel_forward = true;
-    uint16_t port = port_range.first;
-    for (;;) {
-        if (enable_tunnel_forward(server->serial, port)) {
-            // success
-            server->local_port = port;
-            return true;
-        }
-
-        if (port < port_range.last) {
-            LOGW("Could not forward port %" PRIu16", retrying on %" PRIu16,
-                 port, port + 1);
-            port++;
-            continue;
-        }
-
-        if (port_range.first == port_range.last) {
-            LOGE("Could not forward port %" PRIu16, port_range.first);
-        } else {
-            LOGE("Could not forward any port in range %" PRIu16 ":%" PRIu16,
-                 port_range.first, port_range.last);
-        }
-        return false;
-    }
-}
-
-static bool
-enable_tunnel_any_port(struct server *server, struct port_range port_range) {
-    if (enable_tunnel_reverse_any_port(server, port_range)) {
-        return true;
-    }
-
-    // if "adb reverse" does not work (e.g. over "adb connect"), it fallbacks to
-    // "adb forward", so the app socket is the client
-
-    LOGW("'adb reverse' failed, fallback to 'adb forward'");
-    return enable_tunnel_forward_any_port(server, port_range);
-}
-
 static process_t
 execute_server(struct server *server, const struct server_params *params) {
    char max_size_string[6];
    char bit_rate_string[11];
    char max_fps_string[6];
-    char lock_video_orientation_string[3];
-    char display_id_string[6];
    sprintf(max_size_string, "%"PRIu16, params->max_size);
    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
    sprintf(max_fps_string, "%"PRIu16, params->max_fps);
-    sprintf(lock_video_orientation_string, "%"PRIi8, params->lock_video_orientation);
-    sprintf(display_id_string, "%"PRIu16, params->display_id);
    const char *const cmd[] = {
        "shell",
        "CLASSPATH=" DEVICE_SERVER_PATH,
        "app_process",
 #ifdef SERVER_DEBUGGER
 # define SERVER_DEBUGGER_PORT "5005"
-# ifdef SERVER_DEBUGGER_METHOD_NEW
-        /* Android 9 and above */
-        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,server=y,address="
-# else
-        /* Android 8 and below */
        "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
-# endif
            SERVER_DEBUGGER_PORT,
 #endif
        "/", // unused
@ -262,12 +142,10 @@ execute_server(struct server *server, const struct server_params *params) {
        max_size_string,
        bit_rate_string,
        max_fps_string,
-        lock_video_orientation_string,
        server->tunnel_forward ? "true" : "false",
        params->crop ? params->crop : "-",
        "true", // always send frame meta (packet boundaries + timestamp)
        params->control ? "true" : "false",
-        display_id_string,
    };
 #ifdef SERVER_DEBUGGER
    LOGI("Server debugger waiting for a client on device port "
@ -283,6 +161,13 @@ execute_server(struct server *server, const struct server_params *params) {
    return adb_execute(server->serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
 }

+#define IPV4_LOCALHOST 0x7F000001
+
+static socket_t
+listen_on_port(uint16_t port) {
+    return net_listen(IPV4_LOCALHOST, port, 1);
+}
+
 static socket_t
 connect_and_read_byte(uint16_t port) {
    socket_t socket = net_connect(IPV4_LOCALHOST, port);
@ -318,12 +203,14 @@ connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
 }

 static void
-close_socket(socket_t socket) {
-    assert(socket != INVALID_SOCKET);
-    net_shutdown(socket, SHUT_RDWR);
-    if (!net_close(socket)) {
+close_socket(socket_t *socket) {
+    assert(*socket != INVALID_SOCKET);
+    net_shutdown(*socket, SHUT_RDWR);
+    if (!net_close(*socket)) {
        LOGW("Could not close socket");
+        return;
    }
+    *socket = INVALID_SOCKET;
 }

 void
@ -331,26 +218,10 @@ server_init(struct server *server) {
    *server = (struct server) SERVER_INITIALIZER;
 }

-static int
-run_wait_server(void *data) {
-    struct server *server = data;
-    cmd_simple_wait(server->process, NULL); // ignore exit code
-    // no need for synchronization, server_socket is initialized before this
-    // thread was created
-    if (server->server_socket != INVALID_SOCKET
-            && SDL_AtomicCAS(&server->server_socket_closed, 0, 1)) {
-        // On Linux, accept() is unblocked by shutdown(), but on Windows, it is
-        // unblocked by closesocket(). Therefore, call both (close_socket()).
-        close_socket(server->server_socket);
-    }
-    LOGD("Server terminated");
-    return 0;
-}
-
 bool
 server_start(struct server *server, const char *serial,
             const struct server_params *params) {
-    server->port_range = params->port_range;
+    server->local_port = params->local_port;

    if (serial) {
        server->serial = SDL_strdup(serial);
@ -360,47 +231,49 @@ server_start(struct server *server, const char *serial,
    }

    if (!push_server(serial)) {
-        goto error1;
+        SDL_free(server->serial);
+        return false;
    }

-    if (!enable_tunnel_any_port(server, params->port_range)) {
-        goto error1;
+    if (!enable_tunnel(server)) {
+        SDL_free(server->serial);
+        return false;
+    }
+
+    // if "adb reverse" does not work (e.g. over "adb connect"), it fallbacks to
+    // "adb forward", so the app socket is the client
+    if (!server->tunnel_forward) {
+        // At the application level, the device part is "the server" because it
+        // serves video stream and control. However, at the network level, the
+        // client listens and the server connects to the client. That way, the
+        // client can listen before starting the server app, so there is no
+        // need to try to connect until the server socket is listening on the
+        // device.
+
+        server->server_socket = listen_on_port(params->local_port);
+        if (server->server_socket == INVALID_SOCKET) {
+            LOGE("Could not listen on port %" PRIu16, params->local_port);
+            disable_tunnel(server);
+            SDL_free(server->serial);
+            return false;
+        }
    }

    // server will connect to our server socket
    server->process = execute_server(server, params);
-    if (server->process == PROCESS_NONE) {
-        goto error2;
-    }

-    // If the server process dies before connecting to the server socket, then
-    // the client will be stuck forever on accept(). To avoid the problem, we
-    // must be able to wake up the accept() call when the server dies. To keep
-    // things simple and multiplatform, just spawn a new thread waiting for the
-    // server process and calling shutdown()/close() on the server socket if
-    // necessary to wake up any accept() blocking call.
-    server->wait_server_thread =
-        SDL_CreateThread(run_wait_server, "wait-server", server);
-    if (!server->wait_server_thread) {
-        cmd_terminate(server->process);
-        cmd_simple_wait(server->process, NULL); // ignore exit code
-        goto error2;
+    if (server->process == PROCESS_NONE) {
+        if (!server->tunnel_forward) {
+            close_socket(&server->server_socket);
+        }
+        disable_tunnel(server);
+        SDL_free(server->serial);
+        return false;
    }

    server->tunnel_enabled = true;

    return true;
-
-error2:
-    if (!server->tunnel_forward) {
-        // the wait server thread is not started, SDL_AtomicSet() is sufficient
-        SDL_AtomicSet(&server->server_socket_closed, 1);
-        close_socket(server->server_socket);
-    }
-    disable_tunnel(server);
-error1:
-    SDL_free(server->serial);
-    return false;
 }

 bool
@ -418,11 +291,7 @@ server_connect_to(struct server *server) {
        }

        // we don't need the server socket anymore
-        if (SDL_AtomicCAS(&server->server_socket_closed, 0, 1)) {
-            // close it from here
-            close_socket(server->server_socket);
-            // otherwise, it is closed by run_wait_server()
-        }
+        close_socket(&server->server_socket);
    } else {
        uint32_t attempts = 100;
        uint32_t delay = 100; // ms
@ -449,27 +318,29 @@ server_connect_to(struct server *server) {

 void
 server_stop(struct server *server) {
-    if (server->server_socket != INVALID_SOCKET
-            && SDL_AtomicCAS(&server->server_socket_closed, 0, 1)) {
-        close_socket(server->server_socket);
+    if (server->server_socket != INVALID_SOCKET) {
+        close_socket(&server->server_socket);
    }
    if (server->video_socket != INVALID_SOCKET) {
-        close_socket(server->video_socket);
+        close_socket(&server->video_socket);
    }
    if (server->control_socket != INVALID_SOCKET) {
-        close_socket(server->control_socket);
+        close_socket(&server->control_socket);
    }

    assert(server->process != PROCESS_NONE);

-    cmd_terminate(server->process);
+    if (!cmd_terminate(server->process)) {
+        LOGW("Could not terminate server");
+    }
+
+    cmd_simple_wait(server->process, NULL); // ignore exit code
+    LOGD("Server terminated");

    if (server->tunnel_enabled) {
        // ignore failure
        disable_tunnel(server);
    }
-
-    SDL_WaitThread(server->wait_server_thread, NULL);
 }

 void
--- a/app/src/server.h
+++ b/app/src/server.h
@ -3,54 +3,40 @@

 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL2/SDL_atomic.h>
-#include <SDL2/SDL_thread.h>

 #include "config.h"
 #include "command.h"
-#include "common.h"
 #include "util/net.h"

 struct server {
    char *serial;
    process_t process;
-    SDL_Thread *wait_server_thread;
-    SDL_atomic_t server_socket_closed;
    socket_t server_socket; // only used if !tunnel_forward
    socket_t video_socket;
    socket_t control_socket;
-    struct port_range port_range;
-    uint16_t local_port; // selected from port_range
+    uint16_t local_port;
    bool tunnel_enabled;
    bool tunnel_forward; // use "adb forward" instead of "adb reverse"
 };

-#define SERVER_INITIALIZER { \
-    .serial = NULL, \
-    .process = PROCESS_NONE, \
-    .wait_server_thread = NULL, \
-    .server_socket_closed = {0}, \
-    .server_socket = INVALID_SOCKET, \
-    .video_socket = INVALID_SOCKET, \
+#define SERVER_INITIALIZER {          \
+    .serial = NULL,                   \
+    .process = PROCESS_NONE,          \
+    .server_socket = INVALID_SOCKET,  \
+    .video_socket = INVALID_SOCKET,   \
    .control_socket = INVALID_SOCKET, \
-    .port_range = { \
-        .first = 0, \
-        .last = 0, \
-    }, \
-    .local_port = 0, \
-    .tunnel_enabled = false, \
-    .tunnel_forward = false, \
+    .local_port = 0,                  \
+    .tunnel_enabled = false,          \
+    .tunnel_forward = false,          \
 }

 struct server_params {
    const char *crop;
-    struct port_range port_range;
+    uint16_t local_port;
    uint16_t max_size;
    uint32_t bit_rate;
    uint16_t max_fps;
-    int8_t lock_video_orientation;
    bool control;
-    uint16_t display_id;
 };

 // init default values
--- a/app/src/sys/unix/command.c
+++ b/app/src/sys/unix/command.c
@ -14,50 +14,12 @@
 #include <limits.h>
 #include <signal.h>
 #include <stdlib.h>
-#include <sys/stat.h>
 #include <sys/types.h>
-#include <sys/stat.h>
 #include <sys/wait.h>
 #include <unistd.h>

 #include "util/log.h"

-bool
-cmd_search(const char *file) {
-    char *path = getenv("PATH");
-    if (!path)
-        return false;
-    path = strdup(path);
-    if (!path)
-        return false;
-
-    bool ret = false;
-    size_t file_len = strlen(file);
-    char *saveptr;
-    for (char *dir = strtok_r(path, ":", &saveptr); dir;
-            dir = strtok_r(NULL, ":", &saveptr)) {
-        size_t dir_len = strlen(dir);
-        char *fullpath = malloc(dir_len + file_len + 2);
-        if (!fullpath)
-            continue;
-        memcpy(fullpath, dir, dir_len);
-        fullpath[dir_len] = '/';
-        memcpy(fullpath + dir_len + 1, file, file_len + 1);
-
-        struct stat sb;
-        bool fullpath_executable = stat(fullpath, &sb) == 0 &&
-            sb.st_mode & S_IXUSR;
-        free(fullpath);
-        if (fullpath_executable) {
-            ret = true;
-            break;
-        }
-    }
-
-    free(path);
-    return ret;
-}
-
 enum process_result
 cmd_execute(const char *const argv[], pid_t *pid) {
    int fd[2];
@ -165,14 +127,3 @@ get_executable_path(void) {
    return NULL;
 #endif
 }
-
-bool
-is_regular_file(const char *path) {
-    struct stat path_stat;
-
-    if (stat(path, &path_stat)) {
-        perror("stat");
-        return false;
-    }
-    return S_ISREG(path_stat.st_mode);
-}
--- a/app/src/sys/unix/net.c
+++ b/app/src/sys/unix/net.c
@ -0,0 +1,21 @@
+#include "util/net.h"
+
+#include <unistd.h>
+
+#include "config.h"
+
+bool
+net_init(void) {
+    // do nothing
+    return true;
+}
+
+void
+net_cleanup(void) {
+    // do nothing
+}
+
+bool
+net_close(socket_t socket) {
+    return !close(socket);
+}
--- a/app/src/sys/win/command.c
+++ b/app/src/sys/win/command.c
@ -1,7 +1,5 @@
 #include "command.h"

-#include <sys/stat.h>
-
 #include "config.h"
 #include "util/log.h"
 #include "util/str_util.h"
@ -92,22 +90,3 @@ get_executable_path(void) {
    buf[len] = '\0';
    return utf8_from_wide_char(buf);
 }
-
-bool
-is_regular_file(const char *path) {
-    wchar_t *wide_path = utf8_to_wide_char(path);
-    if (!wide_path) {
-        LOGC("Could not allocate wide char string");
-        return false;
-    }
-
-    struct _stat path_stat;
-    int r = _wstat(wide_path, &path_stat);
-    SDL_free(wide_path);
-
-    if (r) {
-        perror("stat");
-        return false;
-    }
-    return S_ISREG(path_stat.st_mode);
-}
--- a/app/src/sys/win/net.c
+++ b/app/src/sys/win/net.c
@ -0,0 +1,25 @@
+#include "util/net.h"
+
+#include "config.h"
+#include "util/log.h"
+
+bool
+net_init(void) {
+    WSADATA wsa;
+    int res = WSAStartup(MAKEWORD(2, 2), &wsa) < 0;
+    if (res < 0) {
+        LOGC("WSAStartup failed with error %d", res);
+        return false;
+    }
+    return true;
+}
+
+void
+net_cleanup(void) {
+    WSACleanup();
+}
+
+bool
+net_close(socket_t socket) {
+    return !closesocket(socket);
+}
--- a/app/src/util/net.c
+++ b/app/src/util/net.c
@ -1,7 +1,6 @@
 #include "net.h"

 #include <stdio.h>
-#include <SDL2/SDL_platform.h>

 #include "config.h"
 #include "log.h"
@ -116,32 +115,3 @@ bool
 net_shutdown(socket_t socket, int how) {
    return !shutdown(socket, how);
 }
-
-bool
-net_init(void) {
-#ifdef __WINDOWS__
-    WSADATA wsa;
-    int res = WSAStartup(MAKEWORD(2, 2), &wsa) < 0;
-    if (res < 0) {
-        LOGC("WSAStartup failed with error %d", res);
-        return false;
-    }
-#endif
-    return true;
-}
-
-void
-net_cleanup(void) {
-#ifdef __WINDOWS__
-    WSACleanup();
-#endif
-}
-
-bool
-net_close(socket_t socket) {
-#ifdef __WINDOWS__
-    return !closesocket(socket);
-#else
-    return !close(socket);
-#endif
-}
--- a/app/src/util/str_util.c
+++ b/app/src/util/str_util.c
@ -63,13 +63,13 @@ strquote(const char *src) {
 }

 bool
-parse_integer(const char *s, long *out) {
+parse_integer(const char *s, long long *out) {
    char *endptr;
    if (*s == '\0') {
        return false;
    }
    errno = 0;
-    long value = strtol(s, &endptr, 0);
+    long long value = strtol(s, &endptr, 0);
    if (errno == ERANGE) {
        return false;
    }
@ -81,43 +81,14 @@ parse_integer(const char *s, long *out) {
    return true;
 }

-size_t
-parse_integers(const char *s, const char sep, size_t max_items, long *out) {
-    size_t count = 0;
-    char *endptr;
-    do {
-        errno = 0;
-        long value = strtol(s, &endptr, 0);
-        if (errno == ERANGE) {
-            return 0;
-        }
-
-        if (endptr == s || (*endptr != sep && *endptr != '\0')) {
-            return 0;
-        }
-
-        out[count++] = value;
-        if (*endptr == sep) {
-            if (count >= max_items) {
-                // max items already reached, could not accept a new item
-                return 0;
-            }
-            // parse the next token during the next iteration
-            s = endptr + 1;
-        }
-    } while (*endptr != '\0');
-
-    return count;
-}
-
 bool
-parse_integer_with_suffix(const char *s, long *out) {
+parse_integer_with_suffix(const char *s, long long *out) {
    char *endptr;
    if (*s == '\0') {
        return false;
    }
    errno = 0;
-    long value = strtol(s, &endptr, 0);
+    long long value = strtoll(s, &endptr, 0);
    if (errno == ERANGE) {
        return false;
    }
@ -135,8 +106,8 @@ parse_integer_with_suffix(const char *s, long *out) {
        }
    }

-    if ((value < 0 && LONG_MIN / mul > value) ||
-        (value > 0 && LONG_MAX / mul < value)) {
+    if ((value < 0 && LLONG_MIN / mul > value) ||
+        (value > 0 && LLONG_MAX / mul < value)) {
        return false;
    }

--- a/app/src/util/str_util.h
+++ b/app/src/util/str_util.h
@ -29,19 +29,14 @@ strquote(const char *src);
 // parse s as an integer into value
 // returns true if the conversion succeeded, false otherwise
 bool
-parse_integer(const char *s, long *out);
-
-// parse s as integers separated by sep (for example '1234:2000')
-// returns the number of integers on success, 0 on failure
-size_t
-parse_integers(const char *s, const char sep, size_t max_items, long *out);
+parse_integer(const char *s, long long *out);

 // parse s as an integer into value
 // like parse_integer(), but accept 'k'/'K' (x1000) and 'm'/'M' (x1000000) as
 // suffix
 // returns true if the conversion succeeded, false otherwise
 bool
-parse_integer_with_suffix(const char *s, long *out);
+parse_integer_with_suffix(const char *s, long long *out);

 // return the index to truncate a UTF-8 string at a valid position
 size_t
--- a/app/tests/test_cli.c
+++ b/app/tests/test_cli.c
@ -48,10 +48,9 @@ static void test_options(void) {
        "--fullscreen",
        "--max-fps", "30",
        "--max-size", "1024",
-        "--lock-video-orientation", "2",
        // "--no-control" is not compatible with "--turn-screen-off"
        // "--no-display" is not compatible with "--fulscreen"
-        "--port", "1234:1236",
+        "--port", "1234",
        "--push-target", "/sdcard/Movies",
        "--record", "file",
        "--record-format", "mkv",
@ -79,9 +78,7 @@ static void test_options(void) {
    assert(opts->fullscreen);
    assert(opts->max_fps == 30);
    assert(opts->max_size == 1024);
-    assert(opts->lock_video_orientation == 2);
-    assert(opts->port_range.first == 1234);
-    assert(opts->port_range.last == 1236);
+    assert(opts->port == 1234);
    assert(!strcmp(opts->push_target, "/sdcard/Movies"));
    assert(!strcmp(opts->record_filename, "file"));
    assert(opts->record_format == RECORDER_FORMAT_MKV);
--- a/app/tests/test_strutil.c
+++ b/app/tests/test_strutil.c
@ -171,7 +171,7 @@ static void test_utf8_truncate(void) {
 }

 static void test_parse_integer(void) {
-    long value;
+    long long value;
    bool ok = parse_integer("1234", &value);
    assert(ok);
    assert(value == 1234);
@ -187,57 +187,8 @@ static void test_parse_integer(void) {
    assert(!ok); // out-of-range
 }

-static void test_parse_integers(void) {
-    long values[5];
-
-    size_t count = parse_integers("1234", ':', 5, values);
-    assert(count == 1);
-    assert(values[0] == 1234);
-
-    count = parse_integers("1234:5678", ':', 5, values);
-    assert(count == 2);
-    assert(values[0] == 1234);
-    assert(values[1] == 5678);
-
-    count = parse_integers("1234:5678", ':', 2, values);
-    assert(count == 2);
-    assert(values[0] == 1234);
-    assert(values[1] == 5678);
-
-    count = parse_integers("1234:-5678", ':', 2, values);
-    assert(count == 2);
-    assert(values[0] == 1234);
-    assert(values[1] == -5678);
-
-    count = parse_integers("1:2:3:4:5", ':', 5, values);
-    assert(count == 5);
-    assert(values[0] == 1);
-    assert(values[1] == 2);
-    assert(values[2] == 3);
-    assert(values[3] == 4);
-    assert(values[4] == 5);
-
-    count = parse_integers("1234:5678", ':', 1, values);
-    assert(count == 0); // max_items == 1
-
-    count = parse_integers("1:2:3:4:5", ':', 3, values);
-    assert(count == 0); // max_items == 3
-
-    count = parse_integers(":1234", ':', 5, values);
-    assert(count == 0); // invalid
-
-    count = parse_integers("1234:", ':', 5, values);
-    assert(count == 0); // invalid
-
-    count = parse_integers("1234:", ':', 1, values);
-    assert(count == 0); // invalid, even when max_items == 1
-
-    count = parse_integers("1234::5678", ':', 5, values);
-    assert(count == 0); // invalid
-}
-
 static void test_parse_integer_with_suffix(void) {
-    long value;
+    long long value;
    bool ok = parse_integer_with_suffix("1234", &value);
    assert(ok);
    assert(value == 1234);
@ -298,7 +249,6 @@ int main(void) {
    test_strquote();
    test_utf8_truncate();
    test_parse_integer();
-    test_parse_integers();
    test_parse_integer_with_suffix();
    return 0;
 }
--- a/config/checkstyle/checkstyle.xml
+++ b/config/checkstyle/checkstyle.xml
@ -129,6 +129,11 @@ page at http://checkstyle.sourceforge.net/config.html -->
    </module>
    <module name="IllegalInstantiation" />
    <module name="InnerAssignment" />
+    <module name="MagicNumber">
+      <property name="severity" value="info" />
+      <property name="ignoreHashCodeMethod" value="true" />
+      <property name="ignoreAnnotation" value="true" />
+    </module>
    <module name="MissingSwitchDefault" />
    <module name="SimplifyBooleanExpression" />
    <module name="SimplifyBooleanReturn" />
--- a/meson.build
+++ b/meson.build
@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '1.12.1',
+        version: '1.12',
        meson_version: '>= 0.37',
        default_options: [
            'c_std=c11',
--- a/meson_options.txt
+++ b/meson_options.txt
@ -6,4 +6,3 @@ option('prebuilt_server', type: 'string', description: 'Path of the prebuilt ser
 option('portable', type: 'boolean', value: false, description: 'Use scrcpy-server from the same directory as the scrcpy executable')
 option('hidpi_support', type: 'boolean', value: true, description: 'Enable High DPI support')
 option('server_debugger', type: 'boolean', value: false, description: 'Run a server debugger and wait for a client to be attached')
-option('server_debugger_method', type: 'combo', choices: ['old', 'new'], value: 'new', description: 'Select the debugger method (Android < 9: "old", Android >= 9: "new")')
--- a/server/build.gradle
+++ b/server/build.gradle
@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 29
-        versionCode 14
-        versionName "1.12.1"
+        versionCode 13
+        versionName "1.12"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
--- a/server/build_without_gradle.sh
+++ b/server/build_without_gradle.sh
@ -12,7 +12,7 @@
 set -e

 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.12.1
+SCRCPY_VERSION_NAME=1.12

 PLATFORM=${ANDROID_PLATFORM:-29}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-29.0.2}
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
@ -8,10 +8,11 @@ import java.nio.charset.StandardCharsets;

 public class ControlMessageReader {

-    static final int INJECT_KEYCODE_PAYLOAD_LENGTH = 9;
-    static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 27;
-    static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
-    static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
+    private static final int INJECT_KEYCODE_PAYLOAD_LENGTH = 9;
+    private static final int INJECT_MOUSE_EVENT_PAYLOAD_LENGTH = 17;
+    private static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 21;
+    private static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
+    private static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;

    public static final int TEXT_MAX_LENGTH = 300;
    public static final int CLIPBOARD_TEXT_MAX_LENGTH = 4093;
@ -121,6 +122,7 @@ public class ControlMessageReader {
        return ControlMessage.createInjectText(text);
    }

+    @SuppressWarnings("checkstyle:MagicNumber")
    private ControlMessage parseInjectTouchEvent() {
        if (buffer.remaining() < INJECT_TOUCH_EVENT_PAYLOAD_LENGTH) {
            return null;
@ -170,10 +172,12 @@ public class ControlMessageReader {
        return new Position(x, y, screenWidth, screenHeight);
    }

+    @SuppressWarnings("checkstyle:MagicNumber")
    private static int toUnsigned(short value) {
        return value & 0xffff;
    }

+    @SuppressWarnings("checkstyle:MagicNumber")
    private static int toUnsigned(byte value) {
        return value & 0xff;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@ -47,6 +47,7 @@ public class Controller {
        }
    }

+    @SuppressWarnings("checkstyle:MagicNumber")
    public void control() throws IOException {
        // on start, power on the device
        if (!device.isScreenOn()) {
@ -75,29 +76,19 @@ public class Controller {
        ControlMessage msg = connection.receiveControlMessage();
        switch (msg.getType()) {
            case ControlMessage.TYPE_INJECT_KEYCODE:
-                if (device.supportsInputEvents()) {
-                    injectKeycode(msg.getAction(), msg.getKeycode(), msg.getMetaState());
-                }
+                injectKeycode(msg.getAction(), msg.getKeycode(), msg.getMetaState());
                break;
            case ControlMessage.TYPE_INJECT_TEXT:
-                if (device.supportsInputEvents()) {
-                    injectText(msg.getText());
-                }
+                injectText(msg.getText());
                break;
            case ControlMessage.TYPE_INJECT_TOUCH_EVENT:
-                if (device.supportsInputEvents()) {
-                    injectTouch(msg.getAction(), msg.getPointerId(), msg.getPosition(), msg.getPressure(), msg.getButtons());
-                }
+                injectTouch(msg.getAction(), msg.getPointerId(), msg.getPosition(), msg.getPressure(), msg.getButtons());
                break;
            case ControlMessage.TYPE_INJECT_SCROLL_EVENT:
-                if (device.supportsInputEvents()) {
-                    injectScroll(msg.getPosition(), msg.getHScroll(), msg.getVScroll());
-                }
+                injectScroll(msg.getPosition(), msg.getHScroll(), msg.getVScroll());
                break;
            case ControlMessage.TYPE_BACK_OR_SCREEN_ON:
-                if (device.supportsInputEvents()) {
-                    pressBackOrTurnScreenOn();
-                }
+                pressBackOrTurnScreenOn();
                break;
            case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
                device.expandNotificationPanel();
@ -113,9 +104,7 @@ public class Controller {
                device.setClipboardText(msg.getText());
                break;
            case ControlMessage.TYPE_SET_SCREEN_POWER_MODE:
-                if (device.supportsInputEvents()) {
-                    device.setScreenPowerMode(msg.getAction());
-                }
+                device.setScreenPowerMode(msg.getAction());
                break;
            case ControlMessage.TYPE_ROTATE_DEVICE:
                device.rotateDevice();
--- a/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
@ -84,6 +84,7 @@ public final class DesktopConnection implements Closeable {
        controlSocket.close();
    }

+    @SuppressWarnings("checkstyle:MagicNumber")
    private void send(String deviceName, int width, int height) throws IOException {
        byte[] buffer = new byte[DEVICE_NAME_FIELD_LENGTH + 4];

--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@ -1,6 +1,5 @@
 package com.genymobile.scrcpy;

-import com.genymobile.scrcpy.wrappers.InputManager;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 import com.genymobile.scrcpy.wrappers.SurfaceControl;
 import com.genymobile.scrcpy.wrappers.WindowManager;
@ -26,40 +25,13 @@ public final class Device {
    private ScreenInfo screenInfo;
    private RotationListener rotationListener;

-    /**
-     * Logical display identifier
-     */
-    private final int displayId;
-
-    /**
-     * The surface flinger layer stack associated with this logical display
-     */
-    private final int layerStack;
-
-    /**
-     * The FLAG_PRESENTATION from the DisplayInfo
-     */
-    private final boolean isPresentationDisplay;
-
    public Device(Options options) {
-        displayId = options.getDisplayId();
-        DisplayInfo displayInfo = serviceManager.getDisplayManager().getDisplayInfo(displayId);
-        if (displayInfo == null) {
-            int[] displayIds = serviceManager.getDisplayManager().getDisplayIds();
-            throw new InvalidDisplayIdException(displayId, displayIds);
-        }
-
-        int displayInfoFlags = displayInfo.getFlags();
-
-        screenInfo = ScreenInfo.computeScreenInfo(displayInfo, options.getCrop(), options.getMaxSize(), options.getLockedVideoOrientation());
-        layerStack = displayInfo.getLayerStack();
-        isPresentationDisplay = (displayInfoFlags & DisplayInfo.FLAG_PRESENTATION) != 0;
-
+        screenInfo = computeScreenInfo(options.getCrop(), options.getMaxSize());
        registerRotationWatcher(new IRotationWatcher.Stub() {
            @Override
            public void onRotationChanged(int rotation) throws RemoteException {
                synchronized (Device.this) {
-                    screenInfo = screenInfo.withDeviceRotation(rotation);
+                    screenInfo = screenInfo.withRotation(rotation);

                    // notify
                    if (rotationListener != null) {
@ -68,69 +40,88 @@ public final class Device {
                }
            }
        });
-
-        if ((displayInfoFlags & DisplayInfo.FLAG_SUPPORTS_PROTECTED_BUFFERS) == 0) {
-            Ln.w("Display doesn't have FLAG_SUPPORTS_PROTECTED_BUFFERS flag, mirroring can be restricted");
-        }
-
-        if (!supportsInputEvents()) {
-            Ln.w("Input events are not supported for displays with FLAG_PRESENTATION enabled for devices with API lower than 29");
-        }
    }

    public synchronized ScreenInfo getScreenInfo() {
        return screenInfo;
    }

-    public int getLayerStack() {
-        return layerStack;
+    private ScreenInfo computeScreenInfo(Rect crop, int maxSize) {
+        DisplayInfo displayInfo = serviceManager.getDisplayManager().getDisplayInfo();
+        boolean rotated = (displayInfo.getRotation() & 1) != 0;
+        Size deviceSize = displayInfo.getSize();
+        Rect contentRect = new Rect(0, 0, deviceSize.getWidth(), deviceSize.getHeight());
+        if (crop != null) {
+            if (rotated) {
+                // the crop (provided by the user) is expressed in the natural orientation
+                crop = flipRect(crop);
+            }
+            if (!contentRect.intersect(crop)) {
+                // intersect() changes contentRect so that it is intersected with crop
+                Ln.w("Crop rectangle (" + formatCrop(crop) + ") does not intersect device screen (" + formatCrop(deviceSize.toRect()) + ")");
+                contentRect = new Rect(); // empty
+            }
+        }
+
+        Size videoSize = computeVideoSize(contentRect.width(), contentRect.height(), maxSize);
+        return new ScreenInfo(contentRect, videoSize, rotated);
+    }
+
+    private static String formatCrop(Rect rect) {
+        return rect.width() + ":" + rect.height() + ":" + rect.left + ":" + rect.top;
+    }
+
+    @SuppressWarnings("checkstyle:MagicNumber")
+    private static Size computeVideoSize(int w, int h, int maxSize) {
+        // Compute the video size and the padding of the content inside this video.
+        // Principle:
+        // - scale down the great side of the screen to maxSize (if necessary);
+        // - scale down the other side so that the aspect ratio is preserved;
+        // - round this value to the nearest multiple of 8 (H.264 only accepts multiples of 8)
+        w &= ~7; // in case it's not a multiple of 8
+        h &= ~7;
+        if (maxSize > 0) {
+            if (BuildConfig.DEBUG && maxSize % 8 != 0) {
+                throw new AssertionError("Max size must be a multiple of 8");
+            }
+            boolean portrait = h > w;
+            int major = portrait ? h : w;
+            int minor = portrait ? w : h;
+            if (major > maxSize) {
+                int minorExact = minor * maxSize / major;
+                // +4 to round the value to the nearest multiple of 8
+                minor = (minorExact + 4) & ~7;
+                major = maxSize;
+            }
+            w = portrait ? minor : major;
+            h = portrait ? major : minor;
+        }
+        return new Size(w, h);
    }

    public Point getPhysicalPoint(Position position) {
        // it hides the field on purpose, to read it with a lock
        @SuppressWarnings("checkstyle:HiddenField")
        ScreenInfo screenInfo = getScreenInfo(); // read with synchronization
-
-        // ignore the locked video orientation, the events will apply in coordinates considered in the physical device orientation
-        Size unlockedVideoSize = screenInfo.getUnlockedVideoSize();
-
-        int reverseVideoRotation = screenInfo.getReverseVideoRotation();
-        // reverse the video rotation to apply the events
-        Position devicePosition = position.rotate(reverseVideoRotation);
-
-        Size clientVideoSize = devicePosition.getScreenSize();
-        if (!unlockedVideoSize.equals(clientVideoSize)) {
+        Size videoSize = screenInfo.getVideoSize();
+        Size clientVideoSize = position.getScreenSize();
+        if (!videoSize.equals(clientVideoSize)) {
            // The client sends a click relative to a video with wrong dimensions,
            // the device may have been rotated since the event was generated, so ignore the event
            return null;
        }
        Rect contentRect = screenInfo.getContentRect();
-        Point point = devicePosition.getPoint();
-        int convertedX = contentRect.left + point.getX() * contentRect.width() / unlockedVideoSize.getWidth();
-        int convertedY = contentRect.top + point.getY() * contentRect.height() / unlockedVideoSize.getHeight();
-        return new Point(convertedX, convertedY);
+        Point point = position.getPoint();
+        int scaledX = contentRect.left + point.getX() * contentRect.width() / videoSize.getWidth();
+        int scaledY = contentRect.top + point.getY() * contentRect.height() / videoSize.getHeight();
+        return new Point(scaledX, scaledY);
    }

    public static String getDeviceName() {
        return Build.MODEL;
    }

-    public boolean supportsInputEvents() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            return true;
-        }
-        return !isPresentationDisplay;
-    }
-
    public boolean injectInputEvent(InputEvent inputEvent, int mode) {
-        if (!supportsInputEvents()) {
-            throw new AssertionError("Could not inject input event if !supportsInputEvents()");
-        }
-
-        if (displayId != 0 && !InputManager.setDisplayId(inputEvent, displayId)) {
-            return false;
-        }
-
        return serviceManager.getInputManager().injectInputEvent(inputEvent, mode);
    }

@ -200,4 +191,8 @@ public final class Device {
            wm.thawRotation();
        }
    }
+
+    static Rect flipRect(Rect crop) {
+        return new Rect(crop.top, crop.left, crop.bottom, crop.right);
+    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/DeviceMessageWriter.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DeviceMessageWriter.java
@ -13,6 +13,7 @@ public class DeviceMessageWriter {
    private final byte[] rawBuffer = new byte[MAX_EVENT_SIZE];
    private final ByteBuffer buffer = ByteBuffer.wrap(rawBuffer);

+    @SuppressWarnings("checkstyle:MagicNumber")
    public void writeTo(DeviceMessage msg, OutputStream output) throws IOException {
        buffer.clear();
        buffer.put((byte) DeviceMessage.TYPE_CLIPBOARD);
--- a/server/src/main/java/com/genymobile/scrcpy/DisplayInfo.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DisplayInfo.java
@ -1,25 +1,12 @@
 package com.genymobile.scrcpy;

 public final class DisplayInfo {
-    private final int displayId;
    private final Size size;
    private final int rotation;
-    private final int layerStack;
-    private final int flags;

-    public static final int FLAG_SUPPORTS_PROTECTED_BUFFERS = 0x00000001;
-    public static final int FLAG_PRESENTATION = 0x00000008;
-
-    public DisplayInfo(int displayId, Size size, int rotation, int layerStack, int flags) {
-        this.displayId = displayId;
+    public DisplayInfo(Size size, int rotation) {
        this.size = size;
        this.rotation = rotation;
-        this.layerStack = layerStack;
-        this.flags = flags;
-    }
-
-    public int getDisplayId() {
-        return displayId;
    }

    public Size getSize() {
@ -29,13 +16,5 @@ public final class DisplayInfo {
    public int getRotation() {
        return rotation;
    }
-
-    public int getLayerStack() {
-        return layerStack;
-    }
-
-    public int getFlags() {
-        return flags;
-    }
 }

--- a/server/src/main/java/com/genymobile/scrcpy/InvalidDisplayIdException.java
+++ b/server/src/main/java/com/genymobile/scrcpy/InvalidDisplayIdException.java
@ -1,21 +0,0 @@
-package com.genymobile.scrcpy;
-
-public class InvalidDisplayIdException extends RuntimeException {
-
-    private final int displayId;
-    private final int[] availableDisplayIds;
-
-    public InvalidDisplayIdException(int displayId, int[] availableDisplayIds) {
-        super("There is no display having id " + displayId);
-        this.displayId = displayId;
-        this.availableDisplayIds = availableDisplayIds;
-    }
-
-    public int getDisplayId() {
-        return displayId;
-    }
-
-    public int[] getAvailableDisplayIds() {
-        return availableDisplayIds;
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@ -6,12 +6,10 @@ public class Options {
    private int maxSize;
    private int bitRate;
    private int maxFps;
-    private int lockedVideoOrientation;
    private boolean tunnelForward;
    private Rect crop;
    private boolean sendFrameMeta; // send PTS so that the client may record properly
    private boolean control;
-    private int displayId;

    public int getMaxSize() {
        return maxSize;
@ -37,14 +35,6 @@ public class Options {
        this.maxFps = maxFps;
    }

-    public int getLockedVideoOrientation() {
-        return lockedVideoOrientation;
-    }
-
-    public void setLockedVideoOrientation(int lockedVideoOrientation) {
-        this.lockedVideoOrientation = lockedVideoOrientation;
-    }
-
    public boolean isTunnelForward() {
        return tunnelForward;
    }
@ -76,12 +66,4 @@ public class Options {
    public void setControl(boolean control) {
        this.control = control;
    }
-
-    public int getDisplayId() {
-        return displayId;
-    }
-
-    public void setDisplayId(int displayId) {
-        this.displayId = displayId;
-    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Position.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Position.java
@ -23,19 +23,6 @@ public class Position {
        return screenSize;
    }

-    public Position rotate(int rotation) {
-        switch (rotation) {
-            case 1:
-                return new Position(new Point(screenSize.getHeight() - point.getY(), point.getX()), screenSize.rotate());
-            case 2:
-                return new Position(new Point(screenSize.getWidth() - point.getX(), screenSize.getHeight() - point.getY()), screenSize);
-            case 3:
-                return new Position(new Point(point.getY(), screenSize.getWidth() - point.getX()), screenSize.rotate());
-            default:
-                return this;
-        }
-    }
-
    @Override
    public boolean equals(Object o) {
        if (this == o) {
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@ -6,6 +6,7 @@ import android.graphics.Rect;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaFormat;
+import android.os.Build;
 import android.os.IBinder;
 import android.view.Surface;

@ -18,7 +19,6 @@ public class ScreenEncoder implements Device.RotationListener {

    private static final int DEFAULT_I_FRAME_INTERVAL = 10; // seconds
    private static final int REPEAT_FRAME_DELAY_US = 100_000; // repeat after 100ms
-    private static final String KEY_MAX_FPS_TO_ENCODER = "max-fps-to-encoder";

    private static final int NO_PTS = -1;

@ -27,21 +27,19 @@ public class ScreenEncoder implements Device.RotationListener {

    private int bitRate;
    private int maxFps;
-    private int lockedVideoOrientation;
    private int iFrameInterval;
    private boolean sendFrameMeta;
    private long ptsOrigin;

-    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, int lockedVideoOrientation, int iFrameInterval) {
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, int iFrameInterval) {
        this.sendFrameMeta = sendFrameMeta;
        this.bitRate = bitRate;
        this.maxFps = maxFps;
-        this.lockedVideoOrientation = lockedVideoOrientation;
        this.iFrameInterval = iFrameInterval;
    }

-    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, int lockedVideoOrientation) {
-        this(sendFrameMeta, bitRate, maxFps, lockedVideoOrientation, DEFAULT_I_FRAME_INTERVAL);
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps) {
+        this(sendFrameMeta, bitRate, maxFps, DEFAULT_I_FRAME_INTERVAL);
    }

    @Override
@ -64,19 +62,12 @@ public class ScreenEncoder implements Device.RotationListener {
            do {
                MediaCodec codec = createCodec();
                IBinder display = createDisplay();
-                ScreenInfo screenInfo = device.getScreenInfo();
-                Rect contentRect = screenInfo.getContentRect();
-                // include the locked video orientation
-                Rect videoRect = screenInfo.getVideoSize().toRect();
-                // does not include the locked video orientation
-                Rect unlockedVideoRect = screenInfo.getUnlockedVideoSize().toRect();
-                int videoRotation = screenInfo.getVideoRotation();
-                int layerStack = device.getLayerStack();
-
+                Rect contentRect = device.getScreenInfo().getContentRect();
+                Rect videoRect = device.getScreenInfo().getVideoSize().toRect();
                setSize(format, videoRect.width(), videoRect.height());
                configure(codec, format);
                Surface surface = codec.createInputSurface();
-                setDisplaySurface(display, surface, videoRotation, contentRect, unlockedVideoRect, layerStack);
+                setDisplaySurface(display, surface, contentRect, videoRect);
                codec.start();
                try {
                    alive = encode(codec, fd);
@ -147,6 +138,7 @@ public class ScreenEncoder implements Device.RotationListener {
        return MediaCodec.createEncoderByType("video/avc");
    }

+    @SuppressWarnings("checkstyle:MagicNumber")
    private static MediaFormat createFormat(int bitRate, int maxFps, int iFrameInterval) {
        MediaFormat format = new MediaFormat();
        format.setString(MediaFormat.KEY_MIME, "video/avc");
@ -158,10 +150,11 @@ public class ScreenEncoder implements Device.RotationListener {
        // display the very first frame, and recover from bad quality when no new frames
        format.setLong(MediaFormat.KEY_REPEAT_PREVIOUS_FRAME_AFTER, REPEAT_FRAME_DELAY_US); // µs
        if (maxFps > 0) {
-            // The key existed privately before Android 10:
-            // <https://android.googlesource.com/platform/frameworks/base/+/625f0aad9f7a259b6881006ad8710adce57d1384%5E%21/>
-            // <https://github.com/Genymobile/scrcpy/issues/488#issuecomment-567321437>
-            format.setFloat(KEY_MAX_FPS_TO_ENCODER, maxFps);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                format.setFloat(MediaFormat.KEY_MAX_FPS_TO_ENCODER, maxFps);
+            } else {
+                Ln.w("Max FPS is only supported since Android 10, the option has been ignored");
+            }
        }
        return format;
    }
@ -179,12 +172,12 @@ public class ScreenEncoder implements Device.RotationListener {
        format.setInteger(MediaFormat.KEY_HEIGHT, height);
    }

-    private static void setDisplaySurface(IBinder display, Surface surface, int orientation, Rect deviceRect, Rect displayRect, int layerStack) {
+    private static void setDisplaySurface(IBinder display, Surface surface, Rect deviceRect, Rect displayRect) {
        SurfaceControl.openTransaction();
        try {
            SurfaceControl.setDisplaySurface(display, surface);
-            SurfaceControl.setDisplayProjection(display, orientation, deviceRect, displayRect);
-            SurfaceControl.setDisplayLayerStack(display, layerStack);
+            SurfaceControl.setDisplayProjection(display, 0, deviceRect, displayRect);
+            SurfaceControl.setDisplayLayerStack(display, 0);
        } finally {
            SurfaceControl.closeTransaction();
        }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenInfo.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenInfo.java
@ -3,161 +3,29 @@ package com.genymobile.scrcpy;
 import android.graphics.Rect;

 public final class ScreenInfo {
-    /**
-     * Device (physical) size, possibly cropped
-     */
    private final Rect contentRect; // device size, possibly cropped
+    private final Size videoSize;
+    private final boolean rotated;

-    /**
-     * Video size, possibly smaller than the device size, already taking the device rotation and crop into account.
-     * <p>
-     * However, it does not include the locked video orientation.
-     */
-    private final Size unlockedVideoSize;
-
-    /**
-     * Device rotation, related to the natural device orientation (0, 1, 2 or 3)
-     */
-    private final int deviceRotation;
-
-    /**
-     * The locked video orientation (-1: disabled, 0: normal, 1: 90° CCW, 2: 180°, 3: 90° CW)
-     */
-    private final int lockedVideoOrientation;
-
-    public ScreenInfo(Rect contentRect, Size unlockedVideoSize, int deviceRotation, int lockedVideoOrientation) {
+    public ScreenInfo(Rect contentRect, Size videoSize, boolean rotated) {
        this.contentRect = contentRect;
-        this.unlockedVideoSize = unlockedVideoSize;
-        this.deviceRotation = deviceRotation;
-        this.lockedVideoOrientation = lockedVideoOrientation;
+        this.videoSize = videoSize;
+        this.rotated = rotated;
    }

    public Rect getContentRect() {
        return contentRect;
    }

-    /**
-     * Return the video size as if locked video orientation was not set.
-     *
-     * @return the unlocked video size
-     */
-    public Size getUnlockedVideoSize() {
-        return unlockedVideoSize;
-    }
-
-    /**
-     * Return the actual video size if locked video orientation is set.
-     *
-     * @return the actual video size
-     */
    public Size getVideoSize() {
-        if (getVideoRotation() % 2 == 0) {
-            return unlockedVideoSize;
-        }
-
-        return unlockedVideoSize.rotate();
+        return videoSize;
    }

-    public int getDeviceRotation() {
-        return deviceRotation;
-    }
-
-    public ScreenInfo withDeviceRotation(int newDeviceRotation) {
-        if (newDeviceRotation == deviceRotation) {
+    public ScreenInfo withRotation(int rotation) {
+        boolean newRotated = (rotation & 1) != 0;
+        if (rotated == newRotated) {
            return this;
        }
-        // true if changed between portrait and landscape
-        boolean orientationChanged = (deviceRotation + newDeviceRotation) % 2 != 0;
-        Rect newContentRect;
-        Size newUnlockedVideoSize;
-        if (orientationChanged) {
-            newContentRect = flipRect(contentRect);
-            newUnlockedVideoSize = unlockedVideoSize.rotate();
-        } else {
-            newContentRect = contentRect;
-            newUnlockedVideoSize = unlockedVideoSize;
-        }
-        return new ScreenInfo(newContentRect, newUnlockedVideoSize, newDeviceRotation, lockedVideoOrientation);
-    }
-
-    public static ScreenInfo computeScreenInfo(DisplayInfo displayInfo, Rect crop, int maxSize, int lockedVideoOrientation) {
-        int rotation = displayInfo.getRotation();
-        Size deviceSize = displayInfo.getSize();
-        Rect contentRect = new Rect(0, 0, deviceSize.getWidth(), deviceSize.getHeight());
-        if (crop != null) {
-            if (rotation % 2 != 0) { // 180s preserve dimensions
-                // the crop (provided by the user) is expressed in the natural orientation
-                crop = flipRect(crop);
-            }
-            if (!contentRect.intersect(crop)) {
-                // intersect() changes contentRect so that it is intersected with crop
-                Ln.w("Crop rectangle (" + formatCrop(crop) + ") does not intersect device screen (" + formatCrop(deviceSize.toRect()) + ")");
-                contentRect = new Rect(); // empty
-            }
-        }
-
-        Size videoSize = computeVideoSize(contentRect.width(), contentRect.height(), maxSize);
-        return new ScreenInfo(contentRect, videoSize, rotation, lockedVideoOrientation);
-    }
-
-    private static String formatCrop(Rect rect) {
-        return rect.width() + ":" + rect.height() + ":" + rect.left + ":" + rect.top;
-    }
-
-    private static Size computeVideoSize(int w, int h, int maxSize) {
-        // Compute the video size and the padding of the content inside this video.
-        // Principle:
-        // - scale down the great side of the screen to maxSize (if necessary);
-        // - scale down the other side so that the aspect ratio is preserved;
-        // - round this value to the nearest multiple of 8 (H.264 only accepts multiples of 8)
-        w &= ~7; // in case it's not a multiple of 8
-        h &= ~7;
-        if (maxSize > 0) {
-            if (BuildConfig.DEBUG && maxSize % 8 != 0) {
-                throw new AssertionError("Max size must be a multiple of 8");
-            }
-            boolean portrait = h > w;
-            int major = portrait ? h : w;
-            int minor = portrait ? w : h;
-            if (major > maxSize) {
-                int minorExact = minor * maxSize / major;
-                // +4 to round the value to the nearest multiple of 8
-                minor = (minorExact + 4) & ~7;
-                major = maxSize;
-            }
-            w = portrait ? minor : major;
-            h = portrait ? major : minor;
-        }
-        return new Size(w, h);
-    }
-
-    private static Rect flipRect(Rect crop) {
-        return new Rect(crop.top, crop.left, crop.bottom, crop.right);
-    }
-
-    /**
-     * Return the rotation to apply to the device rotation to get the requested locked video orientation
-     *
-     * @return the rotation offset
-     */
-    public int getVideoRotation() {
-        if (lockedVideoOrientation == -1) {
-            // no offset
-            return 0;
-        }
-        return (deviceRotation + 4 - lockedVideoOrientation) % 4;
-    }
-
-    /**
-     * Return the rotation to apply to the requested locked video orientation to get the device rotation
-     *
-     * @return the (reverse) rotation offset
-     */
-    public int getReverseVideoRotation() {
-        if (lockedVideoOrientation == -1) {
-            // no offset
-            return 0;
-        }
-        return (lockedVideoOrientation + 4 - deviceRotation) % 4;
+        return new ScreenInfo(Device.flipRect(contentRect), videoSize.rotate(), newRotated);
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -16,12 +16,10 @@ public final class Server {
    }

    private static void scrcpy(Options options) throws IOException {
-        Ln.i("Device: " + Build.MANUFACTURER + " " + Build.MODEL + " (Android " + Build.VERSION.RELEASE + ")");
        final Device device = new Device(options);
        boolean tunnelForward = options.isTunnelForward();
        try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward)) {
-            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(),
-                    options.getLockedVideoOrientation());
+            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps());

            if (options.getControl()) {
                Controller controller = new Controller(device, connection);
@ -69,6 +67,7 @@ public final class Server {
        }).start();
    }

+    @SuppressWarnings("checkstyle:MagicNumber")
    private static Options createOptions(String... args) {
        if (args.length < 1) {
            throw new IllegalArgumentException("Missing client version");
@ -77,11 +76,11 @@ public final class Server {
        String clientVersion = args[0];
        if (!clientVersion.equals(BuildConfig.VERSION_NAME)) {
            throw new IllegalArgumentException(
-                    "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
+                    "The server version (" + clientVersion + ") does not match the client " + "(" + BuildConfig.VERSION_NAME + ")");
        }

-        if (args.length != 10) {
-            throw new IllegalArgumentException("Expecting 10 parameters");
+        if (args.length != 8) {
+            throw new IllegalArgumentException("Expecting 8 parameters");
        }

        Options options = new Options();
@ -95,28 +94,23 @@ public final class Server {
        int maxFps = Integer.parseInt(args[3]);
        options.setMaxFps(maxFps);

-        int lockedVideoOrientation = Integer.parseInt(args[4]);
-        options.setLockedVideoOrientation(lockedVideoOrientation);
-
        // use "adb forward" instead of "adb tunnel"? (so the server must listen)
-        boolean tunnelForward = Boolean.parseBoolean(args[5]);
+        boolean tunnelForward = Boolean.parseBoolean(args[4]);
        options.setTunnelForward(tunnelForward);

-        Rect crop = parseCrop(args[6]);
+        Rect crop = parseCrop(args[5]);
        options.setCrop(crop);

-        boolean sendFrameMeta = Boolean.parseBoolean(args[7]);
+        boolean sendFrameMeta = Boolean.parseBoolean(args[6]);
        options.setSendFrameMeta(sendFrameMeta);

-        boolean control = Boolean.parseBoolean(args[8]);
+        boolean control = Boolean.parseBoolean(args[7]);
        options.setControl(control);

-        int displayId = Integer.parseInt(args[9]);
-        options.setDisplayId(displayId);
-
        return options;
    }

+    @SuppressWarnings("checkstyle:MagicNumber")
    private static Rect parseCrop(String crop) {
        if ("-".equals(crop)) {
            return null;
@ -141,6 +135,7 @@ public final class Server {
        }
    }

+    @SuppressWarnings("checkstyle:MagicNumber")
    private static void suggestFix(Throwable e) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (e instanceof MediaCodec.CodecException) {
@ -152,16 +147,6 @@ public final class Server {
                }
            }
        }
-        if (e instanceof InvalidDisplayIdException) {
-            InvalidDisplayIdException idie = (InvalidDisplayIdException) e;
-            int[] displayIds = idie.getAvailableDisplayIds();
-            if (displayIds != null && displayIds.length > 0) {
-                Ln.e("Try to use one of the available display ids:");
-                for (int id : displayIds) {
-                    Ln.e("    scrcpy --display " + id);
-                }
-            }
-        }
    }

    public static void main(String... args) throws Exception {
--- a/server/src/main/java/com/genymobile/scrcpy/StringUtils.java
+++ b/server/src/main/java/com/genymobile/scrcpy/StringUtils.java
@ -5,6 +5,7 @@ public final class StringUtils {
        // not instantiable
    }

+    @SuppressWarnings("checkstyle:MagicNumber")
    public static int getUtf8TruncationIndex(byte[] utf8, int maxLength) {
        int len = utf8.length;
        if (len <= maxLength) {
--- a/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
@ -73,7 +73,7 @@ public final class Workarounds {
            mInitialApplicationField.set(activityThread, app);
        } catch (Throwable throwable) {
            // this is a workaround, so failing is not an error
-            Ln.d("Could not fill app info: " + throwable.getMessage());
+            Ln.w("Could not fill app info: " + throwable.getMessage());
        }
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayManager.java
@ -12,28 +12,15 @@ public final class DisplayManager {
        this.manager = manager;
    }

-    public DisplayInfo getDisplayInfo(int displayId) {
+    public DisplayInfo getDisplayInfo() {
        try {
-            Object displayInfo = manager.getClass().getMethod("getDisplayInfo", int.class).invoke(manager, displayId);
-            if (displayInfo == null) {
-                return null;
-            }
+            Object displayInfo = manager.getClass().getMethod("getDisplayInfo", int.class).invoke(manager, 0);
            Class<?> cls = displayInfo.getClass();
            // width and height already take the rotation into account
            int width = cls.getDeclaredField("logicalWidth").getInt(displayInfo);
            int height = cls.getDeclaredField("logicalHeight").getInt(displayInfo);
            int rotation = cls.getDeclaredField("rotation").getInt(displayInfo);
-            int layerStack = cls.getDeclaredField("layerStack").getInt(displayInfo);
-            int flags = cls.getDeclaredField("flags").getInt(displayInfo);
-            return new DisplayInfo(displayId, new Size(width, height), rotation, layerStack, flags);
-        } catch (Exception e) {
-            throw new AssertionError(e);
-        }
-    }
-
-    public int[] getDisplayIds() {
-        try {
-            return (int[]) manager.getClass().getMethod("getDisplayIds").invoke(manager);
+            return new DisplayInfo(new Size(width, height), rotation);
        } catch (Exception e) {
            throw new AssertionError(e);
        }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
@ -17,8 +17,6 @@ public final class InputManager {
    private final IInterface manager;
    private Method injectInputEventMethod;

-    private static Method setDisplayIdMethod;
-
    public InputManager(IInterface manager) {
        this.manager = manager;
    }
@ -39,23 +37,4 @@ public final class InputManager {
            return false;
        }
    }
-
-    private static Method getSetDisplayIdMethod() throws NoSuchMethodException {
-        if (setDisplayIdMethod == null) {
-            setDisplayIdMethod = InputEvent.class.getMethod("setDisplayId", int.class);
-        }
-        return setDisplayIdMethod;
-    }
-
-    public static boolean setDisplayId(InputEvent inputEvent, int displayId) {
-        try {
-            Method method = getSetDisplayIdMethod();
-            method.invoke(inputEvent, displayId);
-            return true;
-        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
-            // just a warning, it might happen on old devices
-            Ln.w("Cannot associate a display id to the input event");
-            return false;
-        }
-    }
 }
--- a/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
@ -28,9 +28,6 @@ public class ControlMessageReaderTest {
        dos.writeInt(KeyEvent.META_CTRL_ON);
        byte[] packet = bos.toByteArray();

-        // The message type (1 byte) does not count
-        Assert.assertEquals(ControlMessageReader.INJECT_KEYCODE_PAYLOAD_LENGTH, packet.length - 1);
-
        reader.readFrom(new ByteArrayInputStream(packet));
        ControlMessage event = reader.next();

@ -80,6 +77,7 @@ public class ControlMessageReaderTest {
    }

    @Test
+    @SuppressWarnings("checkstyle:MagicNumber")
    public void testParseTouchEvent() throws IOException {
        ControlMessageReader reader = new ControlMessageReader();

@ -97,9 +95,6 @@ public class ControlMessageReaderTest {

        byte[] packet = bos.toByteArray();

-        // The message type (1 byte) does not count
-        Assert.assertEquals(ControlMessageReader.INJECT_TOUCH_EVENT_PAYLOAD_LENGTH, packet.length - 1);
-
        reader.readFrom(new ByteArrayInputStream(packet));
        ControlMessage event = reader.next();

@ -115,6 +110,7 @@ public class ControlMessageReaderTest {
    }

    @Test
+    @SuppressWarnings("checkstyle:MagicNumber")
    public void testParseScrollEvent() throws IOException {
        ControlMessageReader reader = new ControlMessageReader();

@ -130,9 +126,6 @@ public class ControlMessageReaderTest {

        byte[] packet = bos.toByteArray();

-        // The message type (1 byte) does not count
-        Assert.assertEquals(ControlMessageReader.INJECT_SCROLL_EVENT_PAYLOAD_LENGTH, packet.length - 1);
-
        reader.readFrom(new ByteArrayInputStream(packet));
        ControlMessage event = reader.next();

@ -240,9 +233,6 @@ public class ControlMessageReaderTest {

        byte[] packet = bos.toByteArray();

-        // The message type (1 byte) does not count
-        Assert.assertEquals(ControlMessageReader.SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH, packet.length - 1);
-
        reader.readFrom(new ByteArrayInputStream(packet));
        ControlMessage event = reader.next();

--- a/server/src/test/java/com/genymobile/scrcpy/StringUtilsTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/StringUtilsTest.java
@ -8,6 +8,7 @@ import java.nio.charset.StandardCharsets;
 public class StringUtilsTest {

    @Test
+    @SuppressWarnings("checkstyle:MagicNumber")
    public void testUtf8Truncate() {
        String s = "aÉbÔc";
        byte[] utf8 = s.getBytes(StandardCharsets.UTF_8);
Author	SHA1	Message	Date
Romain Vimont	185802fbe2	longlong	2019-12-10 09:22:30 +01:00
Romain Vimont	78f566bd6d	Move platorm-specific defines to common.h They could be useful anywhere.	2019-12-10 09:11:09 +01:00