Show a friendly hint for adb installation

Signed-off-by: Romain Vimont <rom@rom1v.com>

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

FAQ.md

@@ -3,102 +3,19 @@
 Here are the common reported problems and their status.
 
 
-## `adb` issues
+### On Windows, my device is not detected
 
-`scrcpy` execute `adb` commands to initialize the connection with the device. If
+The most common is your device not being detected by `adb`, or is unauthorized.
-`adb` fails, then scrcpy will not work.
+Check everything is ok by calling:
 
-In that case, it will print this error:
-
->     ERROR: "adb push" returned with value 1
-
-This is typically not a bug in _scrcpy_, but a problem in your environment.
-
-To find out the cause, execute:
-
-```bash
     adb devices
-```
 
-### `adb` not found
+Windows may need some [drivers] to detect your device.
-
-You need `adb` accessible from your `PATH`.
-
-On Windows, the current directory is in your `PATH`, and `adb.exe` is included
-in the release, so it should work out-of-the-box.
-
-
-### Device unauthorized
-
-Check [stackoverflow][device-unauthorized].
-
-[device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
-
-
-### Device not detected
-
-If your device is not detected, you may need some [drivers] (on Windows).
 
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
 
 
-### Several devices connected
+### I can only mirror, I cannot interact with the device
-
-If several devices are connected, you will encounter this error:
-
->     adb: error: failed to get feature set: more than one device/emulator
-
-the identifier of the device you want to mirror must be provided:
-
-```bash
-scrcpy -s 01234567890abcdef
-```
-
-Note that if your device is connected over TCP/IP, you'll get this message:
-
->     adb: error: more than one device/emulator
->     ERROR: "adb reverse" returned with value 1
->     WARN: 'adb reverse' failed, fallback to 'adb forward'
-
-This is expected (due to a bug on old Android versions, see [#5]), but in that
-case, scrcpy fallbacks to a different method, which should work.
-
-[#5]: https://github.com/Genymobile/scrcpy/issues/5
-
-
-### Conflicts between adb versions
-
->     adb server version (41) doesn't match this client (39); killing...
-
-This error occurs when you use several `adb` versions simultaneously. You must
-find the program using a different `adb` version, and use the same `adb` version
-everywhere.
-
-You could overwrite the `adb` binary in the other program, or ask _scrcpy_ to
-use a specific `adb` binary, by setting the `ADB` environment variable:
-
-```bash
-set ADB=/path/to/your/adb
-scrcpy
-```
-
-
-### Device disconnected
-
-If _scrcpy_ stops itself with the warning "Device disconnected", then the
-`adb` connection has been closed.
-
-Try with another USB cable or plug it into another USB port. See [#281] and
-[#283].
-
-[#281]: https://github.com/Genymobile/scrcpy/issues/281
-[#283]: https://github.com/Genymobile/scrcpy/issues/283
-
-
-
-## Control issues
-
-### Mouse and keyboard do not work
 
 On some devices, you may need to enable an option to allow [simulating input].
 In developer options, enable:
@@ -112,25 +29,18 @@ In developer options, enable:
 ### Mouse clicks at wrong location
 
 On MacOS, with HiDPI support and multiple screens, input location are wrongly
-scaled. See [#15].
+scaled. See [issue 15].
 
-[#15]: https://github.com/Genymobile/scrcpy/issues/15
+[issue 15]: https://github.com/Genymobile/scrcpy/issues/15
 
-Open _scrcpy_ directly on the monitor you use it.
+A workaround is to build with HiDPI support disabled:
 
+```bash
+meson x --buildtype release -Dhidpi_support=false
+```
 
-### Special characters do not work
+However, the video will be displayed at lower resolution.
 
-Injecting text input is [limited to ASCII characters][text-input]. A trick
-allows to also inject some [accented characters][accented-characters], but
-that's all. See [#37].
-
-[text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
-[accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
-[#37]: https://github.com/Genymobile/scrcpy/issues/37
-
-
-## Client issues
 
 ### The quality is low on HiDPI display
 
@@ -141,11 +51,6 @@ On Windows, you may need to configure the [scaling behavior].
 
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 
-If your computer definition is far smaller than your screen, then you'll get
-poor quality. See [#40].
-
-[#40]: https://github.com/Genymobile/scrcpy/issues/40
-
 
 ### KWin compositor crashes
 
@@ -156,29 +61,19 @@ As a workaround, [disable "Block compositing"][kwin].
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
 
 
-## Crashes
+### I get an error "Could not open video stream"
-
-### Exception
 
 There may be many reasons. One common cause is that the hardware encoder of your
 device is not able to encode at the given definition:
 
-> ```
+```
-> ERROR: Exception on thread Thread[main,5,main]
+ERROR: Exception on thread Thread[main,5,main]
-> android.media.MediaCodec$CodecException: Error 0xfffffc0e
+android.media.MediaCodec$CodecException: Error 0xfffffc0e
-> ...
+...
-> Exit due to uncaughtException in main thread:
+Exit due to uncaughtException in main thread:
-> ERROR: Could not open video stream
+ERROR: Could not open video stream
-> INFO: Initial texture: 1080x2336
+INFO: Initial texture: 1080x2336
-> ```
+```
-
-or
-
-> ```
-> ERROR: Exception on thread Thread[main,5,main]
-> java.lang.IllegalStateException
->         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
-> ```
 
 Just try with a lower definition:
 

LICENSE

@@ -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.

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.

README.md

@@ -37,11 +37,8 @@ control it using keyboard and mouse.
 
 ### Linux
 
-In Debian (_testing_ and _sid_ for now):
+On Linux, you typically need to [build the app manually][BUILD]. Don't worry,
-
+it's not that hard.
-```
-apt install scrcpy
-```
 
 A [Snap] package is available: [`scrcpy`][snap-link].
 
@@ -59,39 +56,20 @@ 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, a prebuilt archive with all the dependencies
+For Windows, for simplicity, prebuilt archives with all the dependencies
-(including `adb`) is available:
+(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)_
 
+[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
-choco install adb    # if you don't have it yet
-```
-
-And in [Scoop]:
-
-```bash
-scoop install scrcpy
-scoop install adb    # if you don't have it yet
-```
-
-[Scoop]: https://scoop.sh
-
 You can also [build the app manually][BUILD].
 
 
@@ -159,12 +137,14 @@ scrcpy -b 2M  # short version
 
 #### Limit frame rate
 
-On devices with Android >= 10, the capture frame rate can be limited:
+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.
@@ -236,13 +216,6 @@ 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.
 
 #### SSH tunnel
@@ -518,7 +491,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.

app/meson.build

@@ -76,11 +76,9 @@ 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()
@@ -98,9 +96,10 @@ conf.set_quoted('PREFIX', get_option('prefix'))
 # directory as the executable)
 conf.set('PORTABLE', get_option('portable'))
 
-# the default client TCP port for the "adb reverse" tunnel
+# the default client TCP port range for the "adb reverse" tunnel
 # overridden by option --port
-conf.set('DEFAULT_LOCAL_PORT', '27183')
+conf.set('DEFAULT_LOCAL_PORT_RANGE_FIRST', '27183')
+conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')
 
 # the default max video size for both dimensions, in pixels
 # overridden by option --max-size

app/scrcpy.1

@@ -43,7 +43,7 @@ Print this help.
 
 .TP
 .BI "\-\-max\-fps " value
-Limit the framerate of screen capture (only supported on devices with Android >= 10).
+Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
 
 .TP
 .BI "\-m, \-\-max\-size " value
@@ -60,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
+.BI "\-p, \-\-port " port[:port]
-Set the TCP port the client listens on.
+Set the TCP port (range) used by the client to listen.
 
-Default is 27183.
+Default is 27183:27199.
 
 .TP
 .B \-\-prefer\-text
@@ -261,7 +261,7 @@ Copyright \(co 2018 Genymobile
 Genymobile
 .UE
 
-Copyright \(co 2018\-2020
+Copyright \(co 2018\-2019
 .MT rom@rom1v.com
 Romain Vimont
 .ME

app/src/cli.c

@@ -42,8 +42,8 @@ scrcpy_print_usage(const char *arg0) {
         "        Print this help.\n"
         "\n"
         "    --max-fps value\n"
-        "        Limit the frame rate of screen capture (only supported on\n"
+        "        Limit the frame rate of screen capture (officially supported\n"
-        "        devices with Android >= 10).\n"
+        "        since Android 10, but may work on earlier versions).\n"
         "\n"
         "    -m, --max-size value\n"
         "        Limit both the width and height of the video to value. The\n"
@@ -58,9 +58,9 @@ scrcpy_print_usage(const char *arg0) {
         "        Do not display device (only when screen recording is\n"
         "        enabled).\n"
         "\n"
-        "    -p, --port port\n"
+        "    -p, --port port[:port]\n"
-        "        Set the TCP port the client listens on.\n"
+        "        Set the TCP port (range) used by the client to listen.\n"
-        "        Default is %d.\n"
+        "        Default is %d:%d.\n"
         "\n"
         "    --prefer-text\n"
         "        Inject alpha characters and space as text events instead of\n"
@@ -193,7 +193,7 @@ scrcpy_print_usage(const char *arg0) {
         arg0,
         DEFAULT_BIT_RATE,
         DEFAULT_MAX_SIZE, DEFAULT_MAX_SIZE ? "" : " (unlimited)",
-        DEFAULT_LOCAL_PORT);
+        DEFAULT_LOCAL_PORT_RANGE_FIRST, DEFAULT_LOCAL_PORT_RANGE_LAST);
 }
 
 static bool
@@ -221,6 +221,27 @@ 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;
@@ -286,14 +307,30 @@ parse_window_dimension(const char *s, uint16_t *dimension) {
 }
 
 static bool
-parse_port(const char *s, uint16_t *port) {
+parse_port_range(const char *s, struct port_range *port_range) {
-    long value;
+    long values[2];
-    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF, "port");
+    size_t count = parse_integers_arg(s, 2, values, 0, 0xFFFF, "port");
-    if (!ok) {
+    if (!count) {
         return false;
     }
 
-    *port = (uint16_t) value;
+    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;
 }
 
@@ -424,7 +461,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
                 opts->display = false;
                 break;
             case 'p':
-                if (!parse_port(optarg, &opts->port)) {
+                if (!parse_port_range(optarg, &opts->port_range)) {
                     return false;
                 }
                 break;

app/src/command.c

@@ -4,9 +4,6 @@
 #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"
@@ -58,6 +55,28 @@ argv_to_string(const char *const *argv, char *buf, size_t bufsize) {
     return idx;
 }
 
+static void
+show_adb_installation_msg() {
+    static const struct {
+        const char *binary;
+        const char *command;
+    } pkg_managers[] = {
+        {"apt", "apt install adb"},
+        {"apt-get", "apt-get install adb"},
+        {"brew", "brew install android-platform-tools"},
+        {"dnf", "dnf install 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;
+        }
+    }
+
+    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];
@@ -71,6 +90,7 @@ 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
@@ -205,14 +225,3 @@ 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);
-}

app/src/command.h

@@ -43,6 +43,9 @@ enum process_result {
     PROCESS_ERROR_MISSING_BINARY,
 };
 
+bool
+cmd_search(const char *file);
+
 enum process_result
 cmd_execute(const char *const argv[], process_t *process);
 

app/src/common.h

@@ -27,4 +27,9 @@ struct position {
     struct point point;
 };
 
+struct port_range {
+    uint16_t first;
+    uint16_t last;
+};
+
 #endif

app/src/scrcpy.c

@@ -280,7 +280,7 @@ scrcpy(const struct scrcpy_options *options) {
     bool record = !!options->record_filename;
     struct server_params params = {
         .crop = options->crop,
-        .local_port = options->port,
+        .port_range = options->port_range,
         .max_size = options->max_size,
         .bit_rate = options->bit_rate,
         .max_fps = options->max_fps,

app/src/scrcpy.h

@@ -5,6 +5,7 @@
 #include <stdint.h>
 
 #include "config.h"
+#include "common.h"
 #include "input_manager.h"
 #include "recorder.h"
 
@@ -15,7 +16,7 @@ struct scrcpy_options {
     const char *window_title;
     const char *push_target;
     enum recorder_format record_format;
-    uint16_t port;
+    struct port_range port_range;
     uint16_t max_size;
     uint32_t bit_rate;
     uint16_t max_fps;
@@ -41,7 +42,10 @@ struct scrcpy_options {
     .window_title = NULL, \
     .push_target = NULL, \
     .record_format = RECORDER_FORMAT_AUTO, \
-    .port = DEFAULT_LOCAL_PORT, \
+    .port_range = { \
+        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
+        .last = DEFAULT_LOCAL_PORT_RANGE_LAST, \
+    }, \
     .max_size = DEFAULT_MAX_SIZE, \
     .bit_rate = DEFAULT_BIT_RATE, \
     .max_fps = 0, \

app/src/server.c

@@ -6,11 +6,13 @@
 #include <libgen.h>
 #include <stdio.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"
@@ -18,20 +20,39 @@
 #define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FILENAME
 #define DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"
 
-static const char *
+static 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
-        return server_path_env;
+#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;
     }
 
 #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 DEFAULT_SERVER_PATH;
+    return server_path;
 #else
+
     // use scrcpy-server in the same directory as the executable
     char *executable_path = get_executable_path();
     if (!executable_path) {
@@ -67,12 +88,17 @@ get_server_path(void) {
 
 static bool
 push_server(const char *serial) {
-    const char *server_path = get_server_path();
+    char *server_path = get_server_path();
+    if (!server_path) {
+        return false;
+    }
     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");
 }
 
@@ -100,17 +126,6 @@ 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) {
@@ -119,6 +134,100 @@ 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];
@@ -161,13 +270,6 @@ 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);
@@ -221,7 +323,7 @@ server_init(struct server *server) {
 bool
 server_start(struct server *server, const char *serial,
              const struct server_params *params) {
-    server->local_port = params->local_port;
+    server->port_range = params->port_range;
 
     if (serial) {
         server->serial = SDL_strdup(serial);
@@ -235,30 +337,11 @@ server_start(struct server *server, const char *serial,
         return false;
     }
 
-    if (!enable_tunnel(server)) {
+    if (!enable_tunnel_any_port(server, params->port_range)) {
         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);
 

app/src/server.h

@@ -6,6 +6,7 @@
 
 #include "config.h"
 #include "command.h"
+#include "common.h"
 #include "util/net.h"
 
 struct server {
@@ -14,7 +15,8 @@ struct server {
     socket_t server_socket; // only used if !tunnel_forward
     socket_t video_socket;
     socket_t control_socket;
-    uint16_t local_port;
+    struct port_range port_range;
+    uint16_t local_port; // selected from port_range
     bool tunnel_enabled;
     bool tunnel_forward; // use "adb forward" instead of "adb reverse"
 };
@@ -25,6 +27,10 @@ struct server {
     .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, \
@@ -32,7 +38,7 @@ struct server {
 
 struct server_params {
     const char *crop;
-    uint16_t local_port;
+    struct port_range port_range;
     uint16_t max_size;
     uint32_t bit_rate;
     uint16_t max_fps;

app/src/sys/unix/command.c

@@ -14,12 +14,50 @@
 #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];
@@ -127,3 +165,14 @@ 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);
+}

app/src/sys/unix/net.c

@@ -1,21 +0,0 @@
-#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);
-}

app/src/sys/win/command.c

@@ -1,9 +1,17 @@
 #include "command.h"
 
+#include <sys/stat.h>
+
 #include "config.h"
 #include "util/log.h"
 #include "util/str_util.h"
 
+bool
+cmd_search(const char *file) {
+    // :/
+    return false;
+}
+
 static int
 build_cmd(char *cmd, size_t len, const char *const argv[]) {
     // Windows command-line parsing is WTF:
@@ -90,3 +98,22 @@ 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);
+}

app/src/sys/win/net.c

@@ -1,25 +0,0 @@
-#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);
-}

app/src/util/net.c

@@ -1,6 +1,7 @@
 #include "net.h"
 
 #include <stdio.h>
+#include <SDL2/SDL_platform.h>
 
 #include "config.h"
 #include "log.h"
@@ -115,3 +116,32 @@ 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
+}

app/src/util/str_util.c

@@ -81,6 +81,35 @@ 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) {
     char *endptr;

app/src/util/str_util.h

@@ -31,6 +31,11 @@ strquote(const char *src);
 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 s as an integer into value
 // like parse_integer(), but accept 'k'/'K' (x1000) and 'm'/'M' (x1000000) as
 // suffix

app/tests/test_cli.c

@@ -50,7 +50,7 @@ static void test_options(void) {
         "--max-size", "1024",
         // "--no-control" is not compatible with "--turn-screen-off"
         // "--no-display" is not compatible with "--fulscreen"
-        "--port", "1234",
+        "--port", "1234:1236",
         "--push-target", "/sdcard/Movies",
         "--record", "file",
         "--record-format", "mkv",
@@ -78,7 +78,8 @@ static void test_options(void) {
     assert(opts->fullscreen);
     assert(opts->max_fps == 30);
     assert(opts->max_size == 1024);
-    assert(opts->port == 1234);
+    assert(opts->port_range.first == 1234);
+    assert(opts->port_range.last == 1236);
     assert(!strcmp(opts->push_target, "/sdcard/Movies"));
     assert(!strcmp(opts->record_filename, "file"));
     assert(opts->record_format == RECORDER_FORMAT_MKV);

app/tests/test_strutil.c

@@ -187,6 +187,55 @@ 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;
     bool ok = parse_integer_with_suffix("1234", &value);
@@ -249,6 +298,7 @@ int main(void) {
     test_strquote();
     test_utf8_truncate();
     test_parse_integer();
+    test_parse_integers();
     test_parse_integer_with_suffix();
     return 0;
 }

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

@@ -19,6 +19,7 @@ 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;
 
@@ -150,11 +151,10 @@ 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) {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            // The key existed privately before Android 10:
-                format.setFloat(MediaFormat.KEY_MAX_FPS_TO_ENCODER, maxFps);
+            // <https://android.googlesource.com/platform/frameworks/base/+/625f0aad9f7a259b6881006ad8710adce57d1384%5E%21/>
-            } else {
+            // <https://github.com/Genymobile/scrcpy/issues/488#issuecomment-567321437>
-                Ln.w("Max FPS is only supported since Android 10, the option has been ignored");
+            format.setFloat(KEY_MAX_FPS_TO_ENCODER, maxFps);
-            }
         }
         return format;
     }