refilter_on_resize

This will avoid corner cases where we need to resize while no frame has
been received yet.

BUILD.md

@@ -254,10 +254,10 @@ You can then [run](README.md#run) _scrcpy_.
 
 ## Prebuilt server
 
- - [`scrcpy-server-v1.16`][direct-scrcpy-server]  
-   _(SHA-256: 94a79e05b4498d0460ab7bd9d12cbf05156e3a47bf0c5d1420cee1d4493b3832)_
+ - [`scrcpy-server-v1.17`][direct-scrcpy-server]  
+   _(SHA-256: 11b5ad2d1bc9b9730fb7254a78efd71a8ff46b1938ff468e47a21b653a1b6725_
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.16/scrcpy-server-v1.16
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-server-v1.17
 
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:

FAQ.md

@@ -201,3 +201,39 @@ scrcpy -m 800
 ```
 
 You could also try another [encoder](README.md#encoder).
+
+
+## Command line on Windows
+
+Some Windows users are not familiar with the command line. Here is how to open a
+terminal and run `scrcpy` with arguments:
+
+ 1. Press <kbd>Windows</kbd>+<kbd>r</kbd>, this opens a dialog box.
+ 2. Type `cmd` and press <kbd>Enter</kbd>, this opens a terminal.
+ 3. Go to your _scrcpy_ directory, by typing (adapt the path):
+
+    ```bat
+    cd C:\Users\user\Downloads\scrcpy-win64-xxx
+    ```
+
+    and press <kbd>Enter</kbd>
+ 4. Type your command. For example:
+
+    ```bat
+    scrcpy --record file.mkv
+    ```
+
+If you plan to always use the same arguments, create a file `myscrcpy.bat`
+(enable [show file extensions] to avoid confusion) in the `scrcpy` directory,
+containing your command. For example:
+
+```bat
+scrcpy --prefer-text --turn-screen-off --stay-awake
+```
+
+Then just double-click on that file.
+
+You could also edit (a copy of) `scrcpy-console.bat` or `scrcpy-noconsole.vbs`
+to add some arguments.
+
+[show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/

LICENSE

@@ -188,7 +188,7 @@
       identification within third-party archives.
 
    Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2020 Romain Vimont
+   Copyright (C) 2018-2021 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.id.md

@@ -675,7 +675,7 @@ Baca [halaman pengembang].
 ## Lisensi
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2021 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

@@ -477,7 +477,7 @@ _²화면이 꺼진 상태에서 우클릭 시 다시 켜지며, 그 외의 상
 ## 라이선스
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2021 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

@@ -1,4 +1,4 @@
-# scrcpy (v1.16)
+# scrcpy (v1.17)
 
 [Read in another language](#translations)
 
@@ -77,10 +77,10 @@ hard).
 For Windows, for simplicity, a prebuilt archive with all the dependencies
 (including `adb`) is available:
 
- - [`scrcpy-win64-v1.16.zip`][direct-win64]  
-   _(SHA-256: 3f30dc5db1a2f95c2b40a0f5de91ec1642d9f53799250a8c529bc882bc0918f0)_
+ - [`scrcpy-win64-v1.17.zip`][direct-win64]  
+   _(SHA-256: 8b9e57993c707367ed10ebfe0e1ef563c7a29d9af4a355cd8b6a52a317c73eea)_
 
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.16/scrcpy-win64-v1.16.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-win64-v1.17.zip
 
 It is also available in [Chocolatey]:
 
@@ -116,6 +116,10 @@ brew install scrcpy
 You need `adb`, accessible from your `PATH`. If you don't have it yet:
 
 ```bash
+# Homebrew >= 2.6.0
+brew install --cask android-platform-tools
+
+# Homebrew < 2.6.0
 brew cask install android-platform-tools
 ```
 
@@ -202,6 +206,8 @@ scrcpy --lock-video-orientation 3   # 90° clockwise
 
 This affects recording orientation.
 
+The [window may also be rotated](#rotation) independently.
+
 
 #### Encoder
 
@@ -407,9 +413,9 @@ Note that _scrcpy_ manages 3 different rotations:
  - <kbd>MOD</kbd>+<kbd>r</kbd> requests the device to switch between portrait
    and landscape (the current running app may refuse, if it does support the
    requested orientation).
- - `--lock-video-orientation` changes the mirroring orientation (the orientation
-   of the video sent from the device to the computer). This affects the
-   recording.
+ - [`--lock-video-orientation`](#lock-video-orientation) changes the mirroring
+   orientation (the orientation of the video sent from the device to the
+   computer). This affects the recording.
  - `--rotation` (or <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
    rotates only the window content. This affects only the display, not the
    recording.
@@ -766,7 +772,7 @@ Read the [developers page].
 ## Licence
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2021 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.pt-br.md

@@ -508,7 +508,7 @@ Leia a  [developers page].
 ## Licença
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2021 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.zh-Hans.md

@@ -703,7 +703,7 @@ _³需要安卓版本 Android >= 7。_
 ## 许可协议
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2021 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.zh-Hant.md

@@ -682,7 +682,7 @@ _³只支援 Android 7+。_
 ## Licence
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2021 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

@@ -1,7 +1,8 @@
 src = [
     'src/main.c',
+    'src/adb.c',
     'src/cli.c',
-    'src/command.c',
+    'src/compat.c',
     'src/control_msg.c',
     'src/controller.c',
     'src/decoder.c',
@@ -10,6 +11,7 @@ src = [
     'src/event_converter.c',
     'src/file_handler.c',
     'src/fps_counter.c',
+    'src/frame_texture.c',
     'src/input_manager.c',
     'src/opengl.c',
     'src/receiver.c',
@@ -21,9 +23,23 @@ src = [
     'src/tiny_xpm.c',
     'src/video_buffer.c',
     'src/util/net.c',
-    'src/util/str_util.c'
+    'src/util/process.c',
+    'src/util/str_util.c',
+    'src/util/thread.c',
 ]
 
+if host_machine.system() == 'windows'
+    src += [ 'src/sys/win/process.c' ]
+else
+    src += [ 'src/sys/unix/process.c' ]
+endif
+
+check_functions = [
+    'strdup'
+]
+
+cc = meson.get_compiler('c')
+
 if not get_option('crossbuild_windows')
 
     # native build
@@ -31,14 +47,13 @@ if not get_option('crossbuild_windows')
         dependency('libavformat'),
         dependency('libavcodec'),
         dependency('libavutil'),
+        dependency('libswscale'),
         dependency('sdl2'),
     ]
 
 else
 
     # cross-compile mingw32 build (from Linux to Windows)
-    cc = meson.get_compiler('c')
-
     prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
     sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
     sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/lib'
@@ -73,17 +88,19 @@ else
 
 endif
 
-cc = meson.get_compiler('c')
-
 if host_machine.system() == 'windows'
-    src += [ 'src/sys/win/command.c' ]
     dependencies += cc.find_library('ws2_32')
-else
-    src += [ 'src/sys/unix/command.c' ]
 endif
 
 conf = configuration_data()
 
+foreach f : check_functions
+  if cc.has_function(f)
+    define = 'HAVE_' + f.underscorify().to_upper()
+    conf.set(define, true)
+  endif
+endforeach
+
 # expose the build type
 conf.set('NDEBUG', get_option('buildtype') != 'debug')
 
@@ -119,9 +136,6 @@ conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
 # enable High DPI support
 conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
 
-# disable console on Windows
-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'))
 
@@ -132,18 +146,11 @@ configure_file(configuration: conf, output: 'config.h')
 
 src_dir = include_directories('src')
 
-if get_option('windows_noconsole')
-    link_args = [ '-Wl,--subsystem,windows' ]
-else
-    link_args = []
-endif
-
 executable('scrcpy', src,
            dependencies: dependencies,
            include_directories: src_dir,
            install: true,
-           c_args: [],
-           link_args: link_args)
+           c_args: [])
 
 install_man('scrcpy.1')
 

app/scrcpy.1

@@ -167,6 +167,13 @@ Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each incre
 .BI "\-s, \-\-serial " number
 The device serial number. Mandatory only if several devices are connected to adb.
 
+.TP
+.BI "\-\-scale\-filter filter
+Supported filters are "none" and "trilinear".
+
+Trilinear filtering is only available if the renderer is OpenGL 3.0+ or OpenGL
+ES 2.0+.
+
 .TP
 .BI "\-\-shortcut\-mod " key[+...]][,...]
 Specify the modifiers to use for scrcpy shortcuts. Possible keys are "lctrl", "rctrl", "lalt", "ralt", "lsuper" and "rsuper".

app/src/adb.c

@@ -1,12 +1,10 @@
-#include "command.h"
+#include "adb.h"
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "config.h"
-#include "common.h"
 #include "util/log.h"
 #include "util/str_util.h"
 
@@ -70,7 +68,7 @@ show_adb_installation_msg() {
         {"pacman", "pacman -S android-tools"},
     };
     for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
-        if (cmd_search(pkg_managers[i].binary)) {
+        if (search_executable(pkg_managers[i].binary)) {
             LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
             return;
         }
@@ -118,7 +116,7 @@ adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
 
     memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
     cmd[len + i] = NULL;
-    enum process_result r = cmd_execute(cmd, &process);
+    enum process_result r = process_execute(cmd, &process);
     if (r != PROCESS_SUCCESS) {
         show_adb_err_msg(r, cmd);
         return PROCESS_NONE;
@@ -175,7 +173,7 @@ adb_push(const char *serial, const char *local, const char *remote) {
     }
     remote = strquote(remote);
     if (!remote) {
-        SDL_free((void *) local);
+        free((void *) local);
         return PROCESS_NONE;
     }
 #endif
@@ -184,8 +182,8 @@ adb_push(const char *serial, const char *local, const char *remote) {
     process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 
 #ifdef __WINDOWS__
-    SDL_free((void *) remote);
-    SDL_free((void *) local);
+    free((void *) remote);
+    free((void *) local);
 #endif
 
     return proc;
@@ -206,26 +204,8 @@ adb_install(const char *serial, const char *local) {
     process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 
 #ifdef __WINDOWS__
-    SDL_free((void *) local);
+    free((void *) local);
 #endif
 
     return proc;
 }
-
-bool
-process_check_success(process_t proc, const char *name) {
-    if (proc == PROCESS_NONE) {
-        LOGE("Could not execute \"%s\"", name);
-        return false;
-    }
-    exit_code_t exit_code;
-    if (!cmd_simple_wait(proc, &exit_code)) {
-        if (exit_code != NO_EXIT_CODE) {
-            LOGE("\"%s\" returned with value %" PRIexitcode, name, exit_code);
-        } else {
-            LOGE("\"%s\" exited unexpectedly", name);
-        }
-        return false;
-    }
-    return true;
-}

app/src/adb.h

@@ -0,0 +1,34 @@
+#ifndef SC_ADB_H
+#define SC_ADB_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <inttypes.h>
+
+#include "util/process.h"
+
+process_t
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
+
+process_t
+adb_forward(const char *serial, uint16_t local_port,
+            const char *device_socket_name);
+
+process_t
+adb_forward_remove(const char *serial, uint16_t local_port);
+
+process_t
+adb_reverse(const char *serial, const char *device_socket_name,
+            uint16_t local_port);
+
+process_t
+adb_reverse_remove(const char *serial, const char *device_socket_name);
+
+process_t
+adb_push(const char *serial, const char *local, const char *remote);
+
+process_t
+adb_install(const char *serial, const char *local);
+
+#endif

app/src/cli.c

@@ -6,7 +6,6 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#include "config.h"
 #include "scrcpy.h"
 #include "util/log.h"
 #include "util/str_util.h"
@@ -104,11 +103,6 @@ scrcpy_print_usage(const char *arg0) {
         "    --no-key-repeat\n"
         "        Do not forward repeated key events when a key is held down.\n"
         "\n"
-        "    --no-mipmaps\n"
-        "        If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then\n"
-        "        mipmaps are automatically generated to improve downscaling\n"
-        "        quality. This option disables the generation of mipmaps.\n"
-        "\n"
         "    -p, --port port[:port]\n"
         "        Set the TCP port (range) used by the client to listen.\n"
         "        Default is %d:%d.\n"
@@ -155,6 +149,11 @@ scrcpy_print_usage(const char *arg0) {
         "        The device serial number. Mandatory only if several devices\n"
         "        are connected to adb.\n"
         "\n"
+        "    --scale-filter filter\n"
+        "        Supported filters are \"none\" and \"trilinear\".\n"
+        "        Trilinear filtering is only available if the renderer is\n"
+        "        OpenGL 3.0+ or OpenGL ES 2.0+.\n"
+        "\n"
         "    --shortcut-mod key[+...]][,...]\n"
         "        Specify the modifiers to use for scrcpy shortcuts.\n"
         "        Possible keys are \"lctrl\", \"rctrl\", \"lalt\", \"ralt\",\n"
@@ -478,14 +477,14 @@ parse_port_range(const char *s, struct sc_port_range *port_range) {
 }
 
 static bool
-parse_display_id(const char *s, uint16_t *display_id) {
+parse_display_id(const char *s, uint32_t *display_id) {
     long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF, "display id");
+    bool ok = parse_integer_arg(s, &value, false, 0, 0x7FFFFFFF, "display id");
     if (!ok) {
         return false;
     }
 
-    *display_id = (uint16_t) value;
+    *display_id = (uint32_t) value;
     return true;
 }
 
@@ -642,6 +641,62 @@ guess_record_format(const char *filename) {
     return 0;
 }
 
+static bool
+parse_scale_filter(const char *optarg, enum sc_scale_filter *filter) {
+    // TODO store in a map and loop over the entries instead
+    if (!strcmp(optarg, "none")) {
+        *filter = SC_SCALE_FILTER_NONE;
+        return true;
+    }
+    if (!strcmp(optarg, "trilinear")) {
+        *filter = SC_SCALE_FILTER_TRILINEAR;
+        return true;
+    }
+    if (!strcmp(optarg, "bilinear")) {
+        *filter = SC_SCALE_FILTER_BILINEAR;
+        return true;
+    }
+    if (!strcmp(optarg, "bicubic")) {
+        *filter = SC_SCALE_FILTER_BICUBIC;
+        return true;
+    }
+    if (!strcmp(optarg, "x")) {
+        *filter = SC_SCALE_FILTER_X;
+        return true;
+    }
+    if (!strcmp(optarg, "point")) {
+        *filter = SC_SCALE_FILTER_POINT;
+        return true;
+    }
+    if (!strcmp(optarg, "area")) {
+        *filter = SC_SCALE_FILTER_AREA;
+        return true;
+    }
+    if (!strcmp(optarg, "bicublin")) {
+        *filter = SC_SCALE_FILTER_BICUBLIN;
+        return true;
+    }
+    if (!strcmp(optarg, "gauss")) {
+        *filter = SC_SCALE_FILTER_GAUSS;
+        return true;
+    }
+    if (!strcmp(optarg, "sinc")) {
+        *filter = SC_SCALE_FILTER_SINC;
+        return true;
+    }
+    if (!strcmp(optarg, "lanczos")) {
+        *filter = SC_SCALE_FILTER_LANCZOS;
+        return true;
+    }
+    if (!strcmp(optarg, "spline")) {
+        *filter = SC_SCALE_FILTER_SPLINE;
+        return true;
+    }
+    LOGE("Unsupported scale filter: %s "
+         "(expected one of [TODO])", optarg);
+    return false;
+}
+
 #define OPT_RENDER_EXPIRED_FRAMES  1000
 #define OPT_WINDOW_TITLE           1001
 #define OPT_PUSH_TARGET            1002
@@ -668,6 +723,7 @@ guess_record_format(const char *filename) {
 #define OPT_FORWARD_ALL_CLICKS     1023
 #define OPT_LEGACY_PASTE           1024
 #define OPT_ENCODER_NAME           1025
+#define OPT_SCALE_FILTER           1026
 
 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@@ -704,6 +760,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         {"render-expired-frames",  no_argument,       NULL,
                                                   OPT_RENDER_EXPIRED_FRAMES},
         {"rotation",               required_argument, NULL, OPT_ROTATION},
+        {"scale-filter",           required_argument, NULL, OPT_SCALE_FILTER},
         {"serial",                 required_argument, NULL, 's'},
         {"shortcut-mod",           required_argument, NULL, OPT_SHORTCUT_MOD},
         {"show-touches",           no_argument,       NULL, 't'},
@@ -858,7 +915,9 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
                 opts->render_driver = optarg;
                 break;
             case OPT_NO_MIPMAPS:
-                opts->mipmaps = false;
+                LOGW("Deprecated option --no-mipmaps. "
+                     "Use --scale-filter=none instead.");
+                opts->scale_filter = SC_SCALE_FILTER_NONE;
                 break;
             case OPT_NO_KEY_REPEAT:
                 opts->forward_key_repeat = false;
@@ -886,6 +945,11 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
             case OPT_LEGACY_PASTE:
                 opts->legacy_paste = true;
                 break;
+            case OPT_SCALE_FILTER:
+                if (!parse_scale_filter(optarg, &opts->scale_filter)) {
+                    return false;
+                }
+                break;
             default:
                 // getopt prints the error message on stderr
                 return false;

app/src/cli.h

@@ -1,9 +1,10 @@
 #ifndef SCRCPY_CLI_H
 #define SCRCPY_CLI_H
 
+#include "common.h"
+
 #include <stdbool.h>
 
-#include "config.h"
 #include "scrcpy.h"
 
 struct scrcpy_cli_args {

app/src/common.h

@@ -1,35 +1,11 @@
 #ifndef COMMON_H
 #define COMMON_H
 
-#include <stdint.h>
-
 #include "config.h"
+#include "compat.h"
 
 #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)
 
-struct size {
-    uint16_t width;
-    uint16_t height;
-};
-
-struct point {
-    int32_t x;
-    int32_t y;
-};
-
-struct position {
-    // The video screen size may be different from the real device screen size,
-    // so store to which size the absolute position apply, to scale it
-    // accordingly.
-    struct size screen_size;
-    struct point point;
-};
-
-struct port_range {
-    uint16_t first;
-    uint16_t last;
-};
-
 #endif

app/src/compat.c

@@ -0,0 +1,14 @@
+#include "compat.h"
+
+#include "config.h"
+
+#ifndef HAVE_STRDUP
+char *strdup(const char *s) {
+    size_t size = strlen(s) + 1;
+    char *dup = malloc(size);
+    if (dup) {
+        memcpy(dup, s, size);
+    }
+    return dup;
+}
+#endif

app/src/compat.h

@@ -1,6 +1,14 @@
 #ifndef COMPAT_H
 #define COMPAT_H
 
+#define _POSIX_C_SOURCE 200809L
+#define _XOPEN_SOURCE 700
+#define _GNU_SOURCE
+#ifdef __APPLE__
+# define _DARWIN_C_SOURCE
+#endif
+
+#include <libavcodec/version.h>
 #include <libavformat/version.h>
 #include <SDL2/SDL_version.h>
 
@@ -48,4 +56,8 @@
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
 #endif
 
+#ifdef HAVE_STRDUP
+char *strdup(const char *s);
+#endif
+
 #endif

app/src/control_msg.c

@@ -1,9 +1,9 @@
 #include "control_msg.h"
 
 #include <assert.h>
+#include <stdlib.h>
 #include <string.h>
 
-#include "config.h"
 #include "util/buffer_util.h"
 #include "util/log.h"
 #include "util/str_util.h"
@@ -94,10 +94,10 @@ void
 control_msg_destroy(struct control_msg *msg) {
     switch (msg->type) {
         case CONTROL_MSG_TYPE_INJECT_TEXT:
-            SDL_free(msg->inject_text.text);
+            free(msg->inject_text.text);
             break;
         case CONTROL_MSG_TYPE_SET_CLIPBOARD:
-            SDL_free(msg->set_clipboard.text);
+            free(msg->set_clipboard.text);
             break;
         default:
             // do nothing

app/src/control_msg.h

@@ -1,14 +1,15 @@
 #ifndef CONTROLMSG_H
 #define CONTROLMSG_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
-#include "config.h"
 #include "android/input.h"
 #include "android/keycodes.h"
-#include "common.h"
+#include "coords.h"
 
 #define CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
 
@@ -49,7 +50,7 @@ struct control_msg {
             enum android_metastate metastate;
         } inject_keycode;
         struct {
-            char *text; // owned, to be freed by SDL_free()
+            char *text; // owned, to be freed by free()
         } inject_text;
         struct {
             enum android_motionevent_action action;
@@ -64,7 +65,7 @@ struct control_msg {
             int32_t vscroll;
         } inject_scroll_event;
         struct {
-            char *text; // owned, to be freed by SDL_free()
+            char *text; // owned, to be freed by free()
             bool paste;
         } set_clipboard;
         struct {

app/src/controller.c

@@ -2,26 +2,27 @@
 
 #include <assert.h>
 
-#include "config.h"
-#include "util/lock.h"
 #include "util/log.h"
 
 bool
 controller_init(struct controller *controller, socket_t control_socket) {
     cbuf_init(&controller->queue);
 
-    if (!receiver_init(&controller->receiver, control_socket)) {
+    bool ok = receiver_init(&controller->receiver, control_socket);
+    if (!ok) {
         return false;
     }
 
-    if (!(controller->mutex = SDL_CreateMutex())) {
+    ok = sc_mutex_init(&controller->mutex);
+    if (!ok) {
         receiver_destroy(&controller->receiver);
         return false;
     }
 
-    if (!(controller->msg_cond = SDL_CreateCond())) {
+    ok = sc_cond_init(&controller->msg_cond);
+    if (!ok) {
         receiver_destroy(&controller->receiver);
-        SDL_DestroyMutex(controller->mutex);
+        sc_mutex_destroy(&controller->mutex);
         return false;
     }
 
@@ -33,8 +34,8 @@ controller_init(struct controller *controller, socket_t control_socket) {
 
 void
 controller_destroy(struct controller *controller) {
-    SDL_DestroyCond(controller->msg_cond);
-    SDL_DestroyMutex(controller->mutex);
+    sc_cond_destroy(&controller->msg_cond);
+    sc_mutex_destroy(&controller->mutex);
 
     struct control_msg msg;
     while (cbuf_take(&controller->queue, &msg)) {
@@ -47,13 +48,13 @@ controller_destroy(struct controller *controller) {
 bool
 controller_push_msg(struct controller *controller,
                       const struct control_msg *msg) {
-    mutex_lock(controller->mutex);
+    sc_mutex_lock(&controller->mutex);
     bool was_empty = cbuf_is_empty(&controller->queue);
     bool res = cbuf_push(&controller->queue, *msg);
     if (was_empty) {
-        cond_signal(controller->msg_cond);
+        sc_cond_signal(&controller->msg_cond);
     }
-    mutex_unlock(controller->mutex);
+    sc_mutex_unlock(&controller->mutex);
     return res;
 }
 
@@ -61,12 +62,12 @@ static bool
 process_msg(struct controller *controller,
               const struct control_msg *msg) {
     static unsigned char serialized_msg[CONTROL_MSG_MAX_SIZE];
-    int length = control_msg_serialize(msg, serialized_msg);
+    size_t length = control_msg_serialize(msg, serialized_msg);
     if (!length) {
         return false;
     }
     int w = net_send_all(controller->control_socket, serialized_msg, length);
-    return w == length;
+    return (size_t) w == length;
 }
 
 static int
@@ -74,20 +75,20 @@ run_controller(void *data) {
     struct controller *controller = data;
 
     for (;;) {
-        mutex_lock(controller->mutex);
+        sc_mutex_lock(&controller->mutex);
         while (!controller->stopped && cbuf_is_empty(&controller->queue)) {
-            cond_wait(controller->msg_cond, controller->mutex);
+            sc_cond_wait(&controller->msg_cond, &controller->mutex);
         }
         if (controller->stopped) {
             // stop immediately, do not process further msgs
-            mutex_unlock(controller->mutex);
+            sc_mutex_unlock(&controller->mutex);
             break;
         }
         struct control_msg msg;
         bool non_empty = cbuf_take(&controller->queue, &msg);
         assert(non_empty);
         (void) non_empty;
-        mutex_unlock(controller->mutex);
+        sc_mutex_unlock(&controller->mutex);
 
         bool ok = process_msg(controller, &msg);
         control_msg_destroy(&msg);
@@ -103,16 +104,16 @@ bool
 controller_start(struct controller *controller) {
     LOGD("Starting controller thread");
 
-    controller->thread = SDL_CreateThread(run_controller, "controller",
-                                          controller);
-    if (!controller->thread) {
+    bool ok = sc_thread_create(&controller->thread, run_controller,
+                               "controller", controller);
+    if (!ok) {
         LOGC("Could not start controller thread");
         return false;
     }
 
     if (!receiver_start(&controller->receiver)) {
         controller_stop(controller);
-        SDL_WaitThread(controller->thread, NULL);
+        sc_thread_join(&controller->thread, NULL);
         return false;
     }
 
@@ -121,14 +122,14 @@ controller_start(struct controller *controller) {
 
 void
 controller_stop(struct controller *controller) {
-    mutex_lock(controller->mutex);
+    sc_mutex_lock(&controller->mutex);
     controller->stopped = true;
-    cond_signal(controller->msg_cond);
-    mutex_unlock(controller->mutex);
+    sc_cond_signal(&controller->msg_cond);
+    sc_mutex_unlock(&controller->mutex);
 }
 
 void
 controller_join(struct controller *controller) {
-    SDL_WaitThread(controller->thread, NULL);
+    sc_thread_join(&controller->thread, NULL);
     receiver_join(&controller->receiver);
 }

app/src/controller.h

@@ -1,23 +1,23 @@
 #ifndef CONTROLLER_H
 #define CONTROLLER_H
 
-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
+#include "common.h"
+
+#include <stdbool.h>
 
-#include "config.h"
 #include "control_msg.h"
 #include "receiver.h"
 #include "util/cbuf.h"
 #include "util/net.h"
+#include "util/thread.h"
 
 struct control_msg_queue CBUF(struct control_msg, 64);
 
 struct controller {
     socket_t control_socket;
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *msg_cond;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond msg_cond;
     bool stopped;
     struct control_msg_queue queue;
     struct receiver receiver;

app/src/coords.h

@@ -0,0 +1,24 @@
+#ifndef SC_COORDS
+#define SC_COORDS
+
+#include <stdint.h>
+
+struct size {
+    uint16_t width;
+    uint16_t height;
+};
+
+struct point {
+    int32_t x;
+    int32_t y;
+};
+
+struct position {
+    // The video screen size may be different from the real device screen size,
+    // so store to which size the absolute position apply, to scale it
+    // accordingly.
+    struct size screen_size;
+    struct point point;
+};
+
+#endif

app/src/decoder.c

@@ -3,12 +3,8 @@
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
 #include <SDL2/SDL_events.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
 #include <unistd.h>
 
-#include "config.h"
-#include "compat.h"
 #include "events.h"
 #include "recorder.h"
 #include "video_buffer.h"

app/src/decoder.h

@@ -1,11 +1,11 @@
 #ifndef DECODER_H
 #define DECODER_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <libavformat/avformat.h>
 
-#include "config.h"
-
 struct video_buffer;
 
 struct decoder {

app/src/device.c

@@ -1,6 +1,5 @@
 #include "device.h"
 
-#include "config.h"
 #include "util/log.h"
 
 bool

app/src/device.h

@@ -1,10 +1,11 @@
 #ifndef DEVICE_H
 #define DEVICE_H
 
+#include "common.h"
+
 #include <stdbool.h>
 
-#include "config.h"
-#include "common.h"
+#include "coords.h"
 #include "util/net.h"
 
 #define DEVICE_NAME_FIELD_LENGTH 64

app/src/device_msg.c

@@ -1,8 +1,8 @@
 #include "device_msg.h"
 
+#include <stdlib.h>
 #include <string.h>
 
-#include "config.h"
 #include "util/buffer_util.h"
 #include "util/log.h"
 
@@ -21,7 +21,7 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
             if (clipboard_len > len - 5) {
                 return 0; // not available
             }
-            char *text = SDL_malloc(clipboard_len + 1);
+            char *text = malloc(clipboard_len + 1);
             if (!text) {
                 LOGW("Could not allocate text for clipboard");
                 return -1;
@@ -43,6 +43,6 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
 void
 device_msg_destroy(struct device_msg *msg) {
     if (msg->type == DEVICE_MSG_TYPE_CLIPBOARD) {
-        SDL_free(msg->clipboard.text);
+        free(msg->clipboard.text);
     }
 }

app/src/device_msg.h

@@ -1,12 +1,12 @@
 #ifndef DEVICEMSG_H
 #define DEVICEMSG_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <unistd.h>
 
-#include "config.h"
-
 #define DEVICE_MSG_MAX_SIZE (1 << 18) // 256k
 // type: 1 byte; length: 4 bytes
 #define DEVICE_MSG_TEXT_MAX_LENGTH (DEVICE_MSG_MAX_SIZE - 5)
@@ -19,7 +19,7 @@ struct device_msg {
     enum device_msg_type type;
     union {
         struct {
-            char *text; // owned, to be freed by SDL_free()
+            char *text; // owned, to be freed by free()
         } clipboard;
     };
 };

app/src/event_converter.c

@@ -1,7 +1,5 @@
 #include "event_converter.h"
 
-#include "config.h"
-
 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false
 

app/src/event_converter.h

@@ -1,10 +1,11 @@
 #ifndef CONVERT_H
 #define CONVERT_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <SDL2/SDL_events.h>
 
-#include "config.h"
 #include "control_msg.h"
 
 bool

app/src/file_handler.c

@@ -3,16 +3,14 @@
 #include <assert.h>
 #include <string.h>
 
-#include "config.h"
-#include "command.h"
-#include "util/lock.h"
+#include "adb.h"
 #include "util/log.h"
 
 #define DEFAULT_PUSH_TARGET "/sdcard/"
 
 static void
 file_handler_request_destroy(struct file_handler_request *req) {
-    SDL_free(req->file);
+    free(req->file);
 }
 
 bool
@@ -21,21 +19,23 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
 
     cbuf_init(&file_handler->queue);
 
-    if (!(file_handler->mutex = SDL_CreateMutex())) {
+    bool ok = sc_mutex_init(&file_handler->mutex);
+    if (!ok) {
         return false;
     }
 
-    if (!(file_handler->event_cond = SDL_CreateCond())) {
-        SDL_DestroyMutex(file_handler->mutex);
+    ok = sc_cond_init(&file_handler->event_cond);
+    if (!ok) {
+        sc_mutex_destroy(&file_handler->mutex);
         return false;
     }
 
     if (serial) {
-        file_handler->serial = SDL_strdup(serial);
+        file_handler->serial = strdup(serial);
         if (!file_handler->serial) {
             LOGW("Could not strdup serial");
-            SDL_DestroyCond(file_handler->event_cond);
-            SDL_DestroyMutex(file_handler->mutex);
+            sc_cond_destroy(&file_handler->event_cond);
+            sc_mutex_destroy(&file_handler->mutex);
             return false;
         }
     } else {
@@ -55,9 +55,9 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
 
 void
 file_handler_destroy(struct file_handler *file_handler) {
-    SDL_DestroyCond(file_handler->event_cond);
-    SDL_DestroyMutex(file_handler->mutex);
-    SDL_free(file_handler->serial);
+    sc_cond_destroy(&file_handler->event_cond);
+    sc_mutex_destroy(&file_handler->mutex);
+    free(file_handler->serial);
 
     struct file_handler_request req;
     while (cbuf_take(&file_handler->queue, &req)) {
@@ -93,13 +93,13 @@ file_handler_request(struct file_handler *file_handler,
         .file = file,
     };
 
-    mutex_lock(file_handler->mutex);
+    sc_mutex_lock(&file_handler->mutex);
     bool was_empty = cbuf_is_empty(&file_handler->queue);
     bool res = cbuf_push(&file_handler->queue, req);
     if (was_empty) {
-        cond_signal(file_handler->event_cond);
+        sc_cond_signal(&file_handler->event_cond);
     }
-    mutex_unlock(file_handler->mutex);
+    sc_mutex_unlock(&file_handler->mutex);
     return res;
 }
 
@@ -108,14 +108,14 @@ run_file_handler(void *data) {
     struct file_handler *file_handler = data;
 
     for (;;) {
-        mutex_lock(file_handler->mutex);
+        sc_mutex_lock(&file_handler->mutex);
         file_handler->current_process = PROCESS_NONE;
         while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
-            cond_wait(file_handler->event_cond, file_handler->mutex);
+            sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
         }
         if (file_handler->stopped) {
             // stop immediately, do not process further events
-            mutex_unlock(file_handler->mutex);
+            sc_mutex_unlock(&file_handler->mutex);
             break;
         }
         struct file_handler_request req;
@@ -133,16 +133,16 @@ run_file_handler(void *data) {
                                 file_handler->push_target);
         }
         file_handler->current_process = process;
-        mutex_unlock(file_handler->mutex);
+        sc_mutex_unlock(&file_handler->mutex);
 
         if (req.action == ACTION_INSTALL_APK) {
-            if (process_check_success(process, "adb install")) {
+            if (process_check_success(process, "adb install", false)) {
                 LOGI("%s successfully installed", req.file);
             } else {
                 LOGE("Failed to install %s", req.file);
             }
         } else {
-            if (process_check_success(process, "adb push")) {
+            if (process_check_success(process, "adb push", false)) {
                 LOGI("%s successfully pushed to %s", req.file,
                                                      file_handler->push_target);
             } else {
@@ -151,6 +151,14 @@ run_file_handler(void *data) {
             }
         }
 
+        sc_mutex_lock(&file_handler->mutex);
+        // Close the process (it is necessary already terminated)
+        // Execute this call with mutex locked to avoid race conditions with
+        // file_handler_stop()
+        process_close(file_handler->current_process);
+        file_handler->current_process = PROCESS_NONE;
+        sc_mutex_unlock(&file_handler->mutex);
+
         file_handler_request_destroy(&req);
     }
     return 0;
@@ -160,9 +168,9 @@ bool
 file_handler_start(struct file_handler *file_handler) {
     LOGD("Starting file_handler thread");
 
-    file_handler->thread = SDL_CreateThread(run_file_handler, "file_handler",
-                                            file_handler);
-    if (!file_handler->thread) {
+    bool ok = sc_thread_create(&file_handler->thread, run_file_handler,
+                               "file_handler", file_handler);
+    if (!ok) {
         LOGC("Could not start file_handler thread");
         return false;
     }
@@ -172,20 +180,18 @@ file_handler_start(struct file_handler *file_handler) {
 
 void
 file_handler_stop(struct file_handler *file_handler) {
-    mutex_lock(file_handler->mutex);
+    sc_mutex_lock(&file_handler->mutex);
     file_handler->stopped = true;
-    cond_signal(file_handler->event_cond);
+    sc_cond_signal(&file_handler->event_cond);
     if (file_handler->current_process != PROCESS_NONE) {
-        if (!cmd_terminate(file_handler->current_process)) {
-            LOGW("Could not terminate install process");
+        if (!process_terminate(file_handler->current_process)) {
+            LOGW("Could not terminate push/install process");
         }
-        cmd_simple_wait(file_handler->current_process, NULL);
-        file_handler->current_process = PROCESS_NONE;
     }
-    mutex_unlock(file_handler->mutex);
+    sc_mutex_unlock(&file_handler->mutex);
 }
 
 void
 file_handler_join(struct file_handler *file_handler) {
-    SDL_WaitThread(file_handler->thread, NULL);
+    sc_thread_join(&file_handler->thread, NULL);
 }

app/src/file_handler.h

@@ -1,13 +1,13 @@
 #ifndef FILE_HANDLER_H
 #define FILE_HANDLER_H
 
-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
+#include "common.h"
 
-#include "config.h"
-#include "command.h"
+#include <stdbool.h>
+
+#include "adb.h"
 #include "util/cbuf.h"
+#include "util/thread.h"
 
 typedef enum {
     ACTION_INSTALL_APK,
@@ -24,9 +24,9 @@ struct file_handler_request_queue CBUF(struct file_handler_request, 16);
 struct file_handler {
     char *serial;
     const char *push_target;
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *event_cond;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond event_cond;
     bool stopped;
     bool initialized;
     process_t current_process;
@@ -49,7 +49,7 @@ file_handler_stop(struct file_handler *file_handler);
 void
 file_handler_join(struct file_handler *file_handler);
 
-// take ownership of file, and will SDL_free() it
+// take ownership of file, and will free() it
 bool
 file_handler_request(struct file_handler *file_handler,
                      file_handler_action_t action,

app/src/fps_counter.c

@@ -3,26 +3,24 @@
 #include <assert.h>
 #include <SDL2/SDL_timer.h>
 
-#include "config.h"
-#include "util/lock.h"
 #include "util/log.h"
 
 #define FPS_COUNTER_INTERVAL_MS 1000
 
 bool
 fps_counter_init(struct fps_counter *counter) {
-    counter->mutex = SDL_CreateMutex();
-    if (!counter->mutex) {
+    bool ok = sc_mutex_init(&counter->mutex);
+    if (!ok) {
         return false;
     }
 
-    counter->state_cond = SDL_CreateCond();
-    if (!counter->state_cond) {
-        SDL_DestroyMutex(counter->mutex);
+    ok = sc_cond_init(&counter->state_cond);
+    if (!ok) {
+        sc_mutex_destroy(&counter->mutex);
         return false;
     }
 
-    counter->thread = NULL;
+    counter->thread_started = false;
     atomic_init(&counter->started, 0);
     // no need to initialize the other fields, they are unused until started
 
@@ -31,8 +29,8 @@ fps_counter_init(struct fps_counter *counter) {
 
 void
 fps_counter_destroy(struct fps_counter *counter) {
-    SDL_DestroyCond(counter->state_cond);
-    SDL_DestroyMutex(counter->mutex);
+    sc_cond_destroy(&counter->state_cond);
+    sc_mutex_destroy(&counter->mutex);
 }
 
 static inline bool
@@ -78,10 +76,10 @@ static int
 run_fps_counter(void *data) {
     struct fps_counter *counter = data;
 
-    mutex_lock(counter->mutex);
+    sc_mutex_lock(&counter->mutex);
     while (!counter->interrupted) {
         while (!counter->interrupted && !is_started(counter)) {
-            cond_wait(counter->state_cond, counter->mutex);
+            sc_cond_wait(&counter->state_cond, &counter->mutex);
         }
         while (!counter->interrupted && is_started(counter)) {
             uint32_t now = SDL_GetTicks();
@@ -91,32 +89,35 @@ run_fps_counter(void *data) {
             uint32_t remaining = counter->next_timestamp - now;
 
             // ignore the reason (timeout or signaled), we just loop anyway
-            cond_wait_timeout(counter->state_cond, counter->mutex, remaining);
+            sc_cond_timedwait(&counter->state_cond, &counter->mutex, remaining);
         }
     }
-    mutex_unlock(counter->mutex);
+    sc_mutex_unlock(&counter->mutex);
     return 0;
 }
 
 bool
 fps_counter_start(struct fps_counter *counter) {
-    mutex_lock(counter->mutex);
+    sc_mutex_lock(&counter->mutex);
     counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
     counter->nr_rendered = 0;
     counter->nr_skipped = 0;
-    mutex_unlock(counter->mutex);
+    sc_mutex_unlock(&counter->mutex);
 
     set_started(counter, true);
-    cond_signal(counter->state_cond);
+    sc_cond_signal(&counter->state_cond);
 
-    // counter->thread is always accessed from the same thread, no need to lock
-    if (!counter->thread) {
-        counter->thread =
-            SDL_CreateThread(run_fps_counter, "fps counter", counter);
-        if (!counter->thread) {
+    // counter->thread_started and counter->thread are always accessed from the
+    // same thread, no need to lock
+    if (!counter->thread_started) {
+        bool ok = sc_thread_create(&counter->thread, run_fps_counter,
+                                   "fps counter", counter);
+        if (!ok) {
             LOGE("Could not start FPS counter thread");
             return false;
         }
+
+        counter->thread_started = true;
     }
 
     return true;
@@ -125,7 +126,7 @@ fps_counter_start(struct fps_counter *counter) {
 void
 fps_counter_stop(struct fps_counter *counter) {
     set_started(counter, false);
-    cond_signal(counter->state_cond);
+    sc_cond_signal(&counter->state_cond);
 }
 
 bool
@@ -135,21 +136,21 @@ fps_counter_is_started(struct fps_counter *counter) {
 
 void
 fps_counter_interrupt(struct fps_counter *counter) {
-    if (!counter->thread) {
+    if (!counter->thread_started) {
         return;
     }
 
-    mutex_lock(counter->mutex);
+    sc_mutex_lock(&counter->mutex);
     counter->interrupted = true;
-    mutex_unlock(counter->mutex);
+    sc_mutex_unlock(&counter->mutex);
     // wake up blocking wait
-    cond_signal(counter->state_cond);
+    sc_cond_signal(&counter->state_cond);
 }
 
 void
 fps_counter_join(struct fps_counter *counter) {
-    if (counter->thread) {
-        SDL_WaitThread(counter->thread, NULL);
+    if (counter->thread_started) {
+        sc_thread_join(&counter->thread, NULL);
     }
 }
 
@@ -159,11 +160,11 @@ fps_counter_add_rendered_frame(struct fps_counter *counter) {
         return;
     }
 
-    mutex_lock(counter->mutex);
+    sc_mutex_lock(&counter->mutex);
     uint32_t now = SDL_GetTicks();
     check_interval_expired(counter, now);
     ++counter->nr_rendered;
-    mutex_unlock(counter->mutex);
+    sc_mutex_unlock(&counter->mutex);
 }
 
 void
@@ -172,9 +173,9 @@ fps_counter_add_skipped_frame(struct fps_counter *counter) {
         return;
     }
 
-    mutex_lock(counter->mutex);
+    sc_mutex_lock(&counter->mutex);
     uint32_t now = SDL_GetTicks();
     check_interval_expired(counter, now);
     ++counter->nr_skipped;
-    mutex_unlock(counter->mutex);
+    sc_mutex_unlock(&counter->mutex);
 }

app/src/fps_counter.h

@@ -1,18 +1,20 @@
 #ifndef FPSCOUNTER_H
 #define FPSCOUNTER_H
 
+#include "common.h"
+
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
 
-#include "config.h"
+#include "util/thread.h"
 
 struct fps_counter {
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *state_cond;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond state_cond;
+
+    bool thread_started;
 
     // atomic so that we can check without locking the mutex
     // if the FPS counter is disabled, we don't want to lock unnecessarily

app/src/frame_texture.c

@@ -0,0 +1,247 @@
+#include "frame_texture.h"
+
+#include <assert.h>
+#include <libavutil/imgutils.h>
+#include <libswscale/swscale.h>
+
+#include "util/log.h"
+
+static inline bool
+is_swscale_enabled(enum sc_scale_filter scale_filter) {
+    return scale_filter != SC_SCALE_FILTER_NONE
+        && scale_filter != SC_SCALE_FILTER_TRILINEAR;
+}
+
+static SDL_Texture *
+create_texture(struct sc_frame_texture *ftex, struct size size) {
+    SDL_Renderer *renderer = ftex->renderer;
+    SDL_PixelFormatEnum fmt = is_swscale_enabled(ftex->scale_filter)
+                            ? SDL_PIXELFORMAT_RGB24
+                            : SDL_PIXELFORMAT_YV12;
+    SDL_Texture *texture = SDL_CreateTexture(renderer, fmt,
+                                             SDL_TEXTUREACCESS_STREAMING,
+                                             size.width, size.height);
+    if (!texture) {
+        return NULL;
+    }
+
+    if (ftex->scale_filter == SC_SCALE_FILTER_TRILINEAR) {
+        struct sc_opengl *gl = &ftex->gl;
+
+        SDL_GL_BindTexture(texture, NULL, NULL);
+
+        // Enable trilinear filtering for downscaling
+        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                          GL_LINEAR_MIPMAP_LINEAR);
+        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
+
+        SDL_GL_UnbindTexture(texture);
+    }
+
+    return texture;
+}
+
+bool
+sc_frame_texture_init(struct sc_frame_texture *ftex, SDL_Renderer *renderer,
+                      enum sc_scale_filter scale_filter,
+                      struct size initial_size) {
+    SDL_RendererInfo renderer_info;
+    int r = SDL_GetRendererInfo(renderer, &renderer_info);
+    const char *renderer_name = r ? NULL : renderer_info.name;
+    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
+
+    ftex->scale_filter = scale_filter;
+
+    // starts with "opengl"
+    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
+    if (use_opengl) {
+        struct sc_opengl *gl = &ftex->gl;
+        sc_opengl_init(gl);
+
+        LOGI("OpenGL version: %s", gl->version);
+
+        if (scale_filter == SC_SCALE_FILTER_TRILINEAR) {
+            bool supports_mipmaps =
+                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
+                                               2, 0  /* OpenGL ES 2.0+ */);
+            if (!supports_mipmaps) {
+                LOGW("Trilinear filtering disabled "
+                     "(OpenGL 3.0+ or ES 2.0+ required)");
+                ftex->scale_filter = SC_SCALE_FILTER_NONE;
+            }
+        }
+    } else if (scale_filter == SC_SCALE_FILTER_TRILINEAR) {
+        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
+    }
+
+    LOGD("Scale filter: %s\n", sc_scale_filter_name(ftex->scale_filter));
+
+    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, initial_size.width,
+                                                  initial_size.height);
+    ftex->renderer = renderer;
+    ftex->texture = create_texture(ftex, initial_size);
+    if (!ftex->texture) {
+        LOGC("Could not create texture: %s", SDL_GetError());
+        SDL_DestroyRenderer(ftex->renderer);
+        return false;
+    }
+
+    ftex->texture_size = initial_size;
+    ftex->decoded_frame = NULL;
+    memset(ftex->data, 0, sizeof(ftex->data));
+    memset(ftex->linesize, 0, sizeof(ftex->linesize));
+
+    return true;
+}
+
+void
+sc_frame_texture_destroy(struct sc_frame_texture *ftex) {
+    if (ftex->texture) {
+        SDL_DestroyTexture(ftex->texture);
+    }
+}
+
+static int
+to_sws_filter(enum sc_scale_filter scale_filter) {
+    switch (scale_filter) {
+        case SC_SCALE_FILTER_BILINEAR:  return SWS_BILINEAR;
+        case SC_SCALE_FILTER_BICUBIC:   return SWS_BICUBIC;
+        case SC_SCALE_FILTER_X:         return SWS_X;
+        case SC_SCALE_FILTER_POINT:     return SWS_POINT;
+        case SC_SCALE_FILTER_AREA:      return SWS_AREA;
+        case SC_SCALE_FILTER_BICUBLIN:  return SWS_BICUBLIN;
+        case SC_SCALE_FILTER_GAUSS:     return SWS_GAUSS;
+        case SC_SCALE_FILTER_SINC:      return SWS_SINC;
+        case SC_SCALE_FILTER_LANCZOS:   return SWS_LANCZOS;
+        case SC_SCALE_FILTER_SPLINE:    return SWS_SPLINE;
+        default: assert(!"unsupported filter");
+    }
+}
+
+static bool
+screen_generate_resized_frame(struct sc_frame_texture *ftex,
+                              struct size target_size) {
+    assert(is_swscale_enabled(ftex->scale_filter));
+    // TODO
+
+    if (ftex->data[0]) {
+        av_freep(&ftex->data[0]);
+    }
+
+    int ret = av_image_alloc(ftex->data, ftex->linesize, target_size.width,
+                             target_size.height, AV_PIX_FMT_RGB24, 16);
+    if (ret < 0) {
+        return false;
+    }
+
+    const AVFrame *input = ftex->decoded_frame;
+    assert(input);
+
+    int flags = to_sws_filter(ftex->scale_filter);
+    struct SwsContext *ctx =
+        sws_getContext(input->width, input->height, AV_PIX_FMT_YUV420P,
+                       target_size.width, target_size.height, AV_PIX_FMT_RGB24,
+                       flags, NULL, NULL, NULL);
+    if (!ctx) {
+        return false;
+    }
+
+    sws_scale(ctx, (const uint8_t *const *) input->data, input->linesize, 0,
+              input->height, ftex->data, ftex->linesize);
+    sws_freeContext(ctx);
+
+    return true;
+}
+
+static bool
+sc_frame_texture_update_direct(struct sc_frame_texture *ftex,
+                               const AVFrame *frame) {
+    struct size frame_size = {frame->width, frame->height};
+    if (ftex->texture_size.width != frame_size.width
+            || ftex->texture_size.height != frame_size.height) {
+        // Frame dimensions changed, destroy texture
+        SDL_DestroyTexture(ftex->texture);
+
+        LOGI("New texture: %" PRIu16 "x%" PRIu16, frame_size.width,
+                                                  frame_size.height);
+        ftex->texture = create_texture(ftex, frame_size);
+        if (!ftex->texture) {
+            LOGC("Could not create texture: %s", SDL_GetError());
+            return false;
+        }
+
+        ftex->texture_size = frame_size;
+    }
+
+    SDL_UpdateYUVTexture(ftex->texture, NULL,
+            frame->data[0], frame->linesize[0],
+            frame->data[1], frame->linesize[1],
+            frame->data[2], frame->linesize[2]);
+
+    if (ftex->scale_filter == SC_SCALE_FILTER_TRILINEAR) {
+        SDL_GL_BindTexture(ftex->texture, NULL, NULL);
+        ftex->gl.GenerateMipmap(GL_TEXTURE_2D);
+        SDL_GL_UnbindTexture(ftex->texture);
+    }
+
+    return true;
+}
+
+static bool
+sc_frame_texture_update_swscale(struct sc_frame_texture *ftex,
+                                const AVFrame *frame, struct size target_size) {
+    if (ftex->texture_size.width != target_size.width
+            || ftex->texture_size.height != target_size.height) {
+        // Frame dimensions changed, destroy texture
+        SDL_DestroyTexture(ftex->texture);
+
+        ftex->texture = create_texture(ftex, target_size);
+        if (!ftex->texture) {
+            LOGC("Could not create texture: %s", SDL_GetError());
+            return false;
+        }
+
+        ftex->texture_size = target_size;
+    }
+
+    // The frame is valid until the next call to
+    // video_buffer_take_rendering_frame()
+    ftex->decoded_frame = frame;
+
+    bool ok = screen_generate_resized_frame(ftex, target_size);
+    if (!ok) {
+        LOGE("Failed to resize frame\n");
+        return false;
+    }
+
+    SDL_UpdateTexture(ftex->texture, NULL, ftex->data[0], ftex->linesize[0]);
+
+    if (ftex->scale_filter == SC_SCALE_FILTER_TRILINEAR) {
+        SDL_GL_BindTexture(ftex->texture, NULL, NULL);
+        ftex->gl.GenerateMipmap(GL_TEXTURE_2D);
+        SDL_GL_UnbindTexture(ftex->texture);
+    }
+
+    return true;
+}
+
+bool
+sc_frame_texture_update(struct sc_frame_texture *ftex, const AVFrame *frame,
+                        struct size target_size) {
+    if (is_swscale_enabled(ftex->scale_filter)) {
+        return sc_frame_texture_update_swscale(ftex, frame, target_size);
+    }
+    return sc_frame_texture_update_direct(ftex, frame);
+}
+
+bool
+sc_frame_texture_resize(struct sc_frame_texture *ftex,
+                        struct size target_size) {
+    if (is_swscale_enabled(ftex->scale_filter)) {
+        return sc_frame_texture_update_swscale(ftex, ftex->decoded_frame,
+                                               target_size);
+    }
+
+    // Nothing to do
+    return true;
+}

app/src/frame_texture.h

@@ -0,0 +1,44 @@
+#ifndef SC_FRAME_TEXTURE_H
+#define SC_FRAME_TEXTURE_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <SDL2/SDL.h>
+#include <libavformat/avformat.h>
+
+#include "coords.h"
+#include "opengl.h"
+#include "scrcpy.h"
+
+struct sc_frame_texture {
+    SDL_Renderer *renderer; // owned by struct screen
+
+    enum sc_scale_filter scale_filter;
+    struct sc_opengl gl;
+
+    SDL_Texture *texture;
+    struct size texture_size;
+
+    // For swscaling
+    const AVFrame *decoded_frame; // owned by the video_buffer
+    uint8_t *data[4];
+    int linesize[4];
+};
+
+bool
+sc_frame_texture_init(struct sc_frame_texture *ftex, SDL_Renderer *renderer,
+                      enum sc_scale_filter scale_filter,
+                      struct size initial_size);
+
+void
+sc_frame_texture_destroy(struct sc_frame_texture *ftex);
+
+bool
+sc_frame_texture_update(struct sc_frame_texture *ftex, const AVFrame *frame,
+                        struct size target_size);
+
+bool
+sc_frame_texture_resize(struct sc_frame_texture *ftex, struct size target_size);
+
+#endif

app/src/input_manager.c

@@ -3,9 +3,7 @@
 #include <assert.h>
 #include <SDL2/SDL_keycode.h>
 
-#include "config.h"
 #include "event_converter.h"
-#include "util/lock.h"
 #include "util/log.h"
 
 static const int ACTION_DOWN = 1;
@@ -191,13 +189,20 @@ set_device_clipboard(struct controller *controller, bool paste) {
         return;
     }
 
+    char *text_dup = strdup(text);
+    SDL_free(text);
+    if (!text_dup) {
+        LOGW("Could not strdup input text");
+        return;
+    }
+
     struct control_msg msg;
     msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
-    msg.set_clipboard.text = text;
+    msg.set_clipboard.text = text_dup;
     msg.set_clipboard.paste = paste;
 
     if (!controller_push_msg(controller, &msg)) {
-        SDL_free(text);
+        free(text_dup);
         LOGW("Could not request 'set device clipboard'");
     }
 }
@@ -243,11 +248,18 @@ clipboard_paste(struct controller *controller) {
         return;
     }
 
+    char *text_dup = strdup(text);
+    SDL_free(text);
+    if (!text_dup) {
+        LOGW("Could not strdup input text");
+        return;
+    }
+
     struct control_msg msg;
     msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = text;
+    msg.inject_text.text = text_dup;
     if (!controller_push_msg(controller, &msg)) {
-        SDL_free(text);
+        free(text_dup);
         LOGW("Could not request 'paste clipboard'");
     }
 }
@@ -292,13 +304,13 @@ input_manager_process_text_input(struct input_manager *im,
 
     struct control_msg msg;
     msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = SDL_strdup(event->text);
+    msg.inject_text.text = strdup(event->text);
     if (!msg.inject_text.text) {
         LOGW("Could not strdup input text");
         return;
     }
     if (!controller_push_msg(im->controller, &msg)) {
-        SDL_free(msg.inject_text.text);
+        free(msg.inject_text.text);
         LOGW("Could not request 'inject text'");
     }
 }

app/src/input_manager.h

@@ -1,12 +1,12 @@
 #ifndef INPUTMANAGER_H
 #define INPUTMANAGER_H
 
+#include "common.h"
+
 #include <stdbool.h>
 
 #include <SDL2/SDL.h>
 
-#include "config.h"
-#include "common.h"
 #include "controller.h"
 #include "fps_counter.h"
 #include "scrcpy.h"

app/src/main.c

@@ -1,5 +1,7 @@
 #include "scrcpy.h"
 
+#include "common.h"
+
 #include <assert.h>
 #include <stdbool.h>
 #include <unistd.h>
@@ -7,9 +9,7 @@
 #define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
 #include <SDL2/SDL.h>
 
-#include "config.h"
 #include "cli.h"
-#include "compat.h"
 #include "util/log.h"
 
 static void

app/src/opengl.h

@@ -1,11 +1,11 @@
 #ifndef SC_OPENGL_H
 #define SC_OPENGL_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <SDL2/SDL_opengl.h>
 
-#include "config.h"
-
 struct sc_opengl {
     const char *version;
     bool is_opengles;

app/src/receiver.c

@@ -3,14 +3,13 @@
 #include <assert.h>
 #include <SDL2/SDL_clipboard.h>
 
-#include "config.h"
 #include "device_msg.h"
-#include "util/lock.h"
 #include "util/log.h"
 
 bool
 receiver_init(struct receiver *receiver, socket_t control_socket) {
-    if (!(receiver->mutex = SDL_CreateMutex())) {
+    bool ok = sc_mutex_init(&receiver->mutex);
+    if (!ok) {
         return false;
     }
     receiver->control_socket = control_socket;
@@ -19,7 +18,7 @@ receiver_init(struct receiver *receiver, socket_t control_socket) {
 
 void
 receiver_destroy(struct receiver *receiver) {
-    SDL_DestroyMutex(receiver->mutex);
+    sc_mutex_destroy(&receiver->mutex);
 }
 
 static void
@@ -102,8 +101,9 @@ bool
 receiver_start(struct receiver *receiver) {
     LOGD("Starting receiver thread");
 
-    receiver->thread = SDL_CreateThread(run_receiver, "receiver", receiver);
-    if (!receiver->thread) {
+    bool ok = sc_thread_create(&receiver->thread, run_receiver, "receiver",
+                               receiver);
+    if (!ok) {
         LOGC("Could not start receiver thread");
         return false;
     }
@@ -113,5 +113,5 @@ receiver_start(struct receiver *receiver) {
 
 void
 receiver_join(struct receiver *receiver) {
-    SDL_WaitThread(receiver->thread, NULL);
+    sc_thread_join(&receiver->thread, NULL);
 }

app/src/receiver.h

@@ -1,19 +1,19 @@
 #ifndef RECEIVER_H
 #define RECEIVER_H
 
-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
+#include "common.h"
+
+#include <stdbool.h>
 
-#include "config.h"
 #include "util/net.h"
+#include "util/thread.h"
 
 // receive events from the device
 // managed by the controller
 struct receiver {
     socket_t control_socket;
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
+    sc_thread thread;
+    sc_mutex mutex;
 };
 
 bool

app/src/recorder.c

@@ -3,9 +3,6 @@
 #include <assert.h>
 #include <libavutil/time.h>
 
-#include "config.h"
-#include "compat.h"
-#include "util/lock.h"
 #include "util/log.h"
 
 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
@@ -29,7 +26,7 @@ find_muxer(const char *name) {
 
 static struct record_packet *
 record_packet_new(const AVPacket *packet) {
-    struct record_packet *rec = SDL_malloc(sizeof(*rec));
+    struct record_packet *rec = malloc(sizeof(*rec));
     if (!rec) {
         return NULL;
     }
@@ -39,7 +36,7 @@ record_packet_new(const AVPacket *packet) {
     av_init_packet(&rec->packet);
 
     if (av_packet_ref(&rec->packet, packet)) {
-        SDL_free(rec);
+        free(rec);
         return NULL;
     }
     return rec;
@@ -48,7 +45,7 @@ record_packet_new(const AVPacket *packet) {
 static void
 record_packet_delete(struct record_packet *rec) {
     av_packet_unref(&rec->packet);
-    SDL_free(rec);
+    free(rec);
 }
 
 static void
@@ -65,24 +62,24 @@ recorder_init(struct recorder *recorder,
               const char *filename,
               enum sc_record_format format,
               struct size declared_frame_size) {
-    recorder->filename = SDL_strdup(filename);
+    recorder->filename = strdup(filename);
     if (!recorder->filename) {
         LOGE("Could not strdup filename");
         return false;
     }
 
-    recorder->mutex = SDL_CreateMutex();
-    if (!recorder->mutex) {
+    bool ok = sc_mutex_init(&recorder->mutex);
+    if (!ok) {
         LOGC("Could not create mutex");
-        SDL_free(recorder->filename);
+        free(recorder->filename);
         return false;
     }
 
-    recorder->queue_cond = SDL_CreateCond();
-    if (!recorder->queue_cond) {
+    ok = sc_cond_init(&recorder->queue_cond);
+    if (!ok) {
         LOGC("Could not create cond");
-        SDL_DestroyMutex(recorder->mutex);
-        SDL_free(recorder->filename);
+        sc_mutex_destroy(&recorder->mutex);
+        free(recorder->filename);
         return false;
     }
 
@@ -99,9 +96,9 @@ recorder_init(struct recorder *recorder,
 
 void
 recorder_destroy(struct recorder *recorder) {
-    SDL_DestroyCond(recorder->queue_cond);
-    SDL_DestroyMutex(recorder->mutex);
-    SDL_free(recorder->filename);
+    sc_cond_destroy(&recorder->queue_cond);
+    sc_mutex_destroy(&recorder->mutex);
+    free(recorder->filename);
 }
 
 static const char *
@@ -260,17 +257,17 @@ run_recorder(void *data) {
     struct recorder *recorder = data;
 
     for (;;) {
-        mutex_lock(recorder->mutex);
+        sc_mutex_lock(&recorder->mutex);
 
         while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
-            cond_wait(recorder->queue_cond, recorder->mutex);
+            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
         }
 
         // if stopped is set, continue to process the remaining events (to
         // finish the recording) before actually stopping
 
         if (recorder->stopped && queue_is_empty(&recorder->queue)) {
-            mutex_unlock(recorder->mutex);
+            sc_mutex_unlock(&recorder->mutex);
             struct record_packet *last = recorder->previous;
             if (last) {
                 // assign an arbitrary duration to the last packet
@@ -290,7 +287,7 @@ run_recorder(void *data) {
         struct record_packet *rec;
         queue_take(&recorder->queue, next, &rec);
 
-        mutex_unlock(recorder->mutex);
+        sc_mutex_unlock(&recorder->mutex);
 
         // recorder->previous is only written from this thread, no need to lock
         struct record_packet *previous = recorder->previous;
@@ -313,11 +310,11 @@ run_recorder(void *data) {
         if (!ok) {
             LOGE("Could not record packet");
 
-            mutex_lock(recorder->mutex);
+            sc_mutex_lock(&recorder->mutex);
             recorder->failed = true;
             // discard pending packets
             recorder_queue_clear(&recorder->queue);
-            mutex_unlock(recorder->mutex);
+            sc_mutex_unlock(&recorder->mutex);
             break;
         }
 
@@ -332,8 +329,9 @@ bool
 recorder_start(struct recorder *recorder) {
     LOGD("Starting recorder thread");
 
-    recorder->thread = SDL_CreateThread(run_recorder, "recorder", recorder);
-    if (!recorder->thread) {
+    bool ok = sc_thread_create(&recorder->thread, run_recorder, "recorder",
+                               recorder);
+    if (!ok) {
         LOGC("Could not start recorder thread");
         return false;
     }
@@ -343,38 +341,38 @@ recorder_start(struct recorder *recorder) {
 
 void
 recorder_stop(struct recorder *recorder) {
-    mutex_lock(recorder->mutex);
+    sc_mutex_lock(&recorder->mutex);
     recorder->stopped = true;
-    cond_signal(recorder->queue_cond);
-    mutex_unlock(recorder->mutex);
+    sc_cond_signal(&recorder->queue_cond);
+    sc_mutex_unlock(&recorder->mutex);
 }
 
 void
 recorder_join(struct recorder *recorder) {
-    SDL_WaitThread(recorder->thread, NULL);
+    sc_thread_join(&recorder->thread, NULL);
 }
 
 bool
 recorder_push(struct recorder *recorder, const AVPacket *packet) {
-    mutex_lock(recorder->mutex);
+    sc_mutex_lock(&recorder->mutex);
     assert(!recorder->stopped);
 
     if (recorder->failed) {
         // reject any new packet (this will stop the stream)
-        mutex_unlock(recorder->mutex);
+        sc_mutex_unlock(&recorder->mutex);
         return false;
     }
 
     struct record_packet *rec = record_packet_new(packet);
     if (!rec) {
         LOGC("Could not allocate record packet");
-        mutex_unlock(recorder->mutex);
+        sc_mutex_unlock(&recorder->mutex);
         return false;
     }
 
     queue_push(&recorder->queue, next, rec);
-    cond_signal(recorder->queue_cond);
+    sc_cond_signal(&recorder->queue_cond);
 
-    mutex_unlock(recorder->mutex);
+    sc_mutex_unlock(&recorder->mutex);
     return true;
 }

app/src/recorder.h

@@ -1,15 +1,15 @@
 #ifndef RECORDER_H
 #define RECORDER_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <libavformat/avformat.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
 
-#include "config.h"
-#include "common.h"
+#include "coords.h"
 #include "scrcpy.h"
 #include "util/queue.h"
+#include "util/thread.h"
 
 struct record_packet {
     AVPacket packet;
@@ -25,9 +25,9 @@ struct recorder {
     struct size declared_frame_size;
     bool header_written;
 
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *queue_cond;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond queue_cond;
     bool stopped; // set on recorder_stop() by the stream reader
     bool failed; // set on packet write failure
     struct recorder_queue queue;

app/src/scrcpy.c

@@ -13,10 +13,6 @@
 # include <windows.h>
 #endif
 
-#include "config.h"
-#include "command.h"
-#include "common.h"
-#include "compat.h"
 #include "controller.h"
 #include "decoder.h"
 #include "device.h"
@@ -30,11 +26,30 @@
 #include "stream.h"
 #include "tiny_xpm.h"
 #include "video_buffer.h"
-#include "util/lock.h"
 #include "util/log.h"
 #include "util/net.h"
 
-static struct server server = SERVER_INITIALIZER;
+static const char *sc_scale_filter_names[SC_SCALE_FILTER__COUNT] = {
+    [SC_SCALE_FILTER_NONE] = "none",
+    [SC_SCALE_FILTER_TRILINEAR] = "trilinear",
+    [SC_SCALE_FILTER_BILINEAR] = "bilinear",
+    [SC_SCALE_FILTER_BICUBIC] = "bicubic",
+    [SC_SCALE_FILTER_X] = "x",
+    [SC_SCALE_FILTER_POINT] = "point",
+    [SC_SCALE_FILTER_AREA] = "area",
+    [SC_SCALE_FILTER_BICUBLIN] = "bicublin",
+    [SC_SCALE_FILTER_GAUSS] = "gauss",
+    [SC_SCALE_FILTER_SINC] = "sinc",
+    [SC_SCALE_FILTER_LANCZOS] = "lanczos",
+    [SC_SCALE_FILTER_SPLINE] = "spline",
+};
+
+const char *
+sc_scale_filter_name(enum sc_scale_filter scale_filter) {
+    return sc_scale_filter_names[scale_filter];
+}
+
+static struct server server;
 static struct screen screen = SCREEN_INITIALIZER;
 static struct fps_counter fps_counter;
 static struct video_buffer video_buffer;
@@ -189,7 +204,9 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
             }
             break;
         case SDL_WINDOWEVENT:
-            screen_handle_window_event(&screen, &event->window);
+            if (screen.has_frame) {
+                screen_handle_window_event(&screen, &event->window);
+            }
             break;
         case SDL_TEXTINPUT:
             if (!options->control) {
@@ -230,13 +247,20 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
             if (!options->control) {
                 break;
             }
+            char *file = strdup(event->drop.file);
+            SDL_free(event->drop.file);
+            if (!file) {
+                LOGW("Could not strdup drop filename\n");
+                break;
+            }
+
             file_handler_action_t action;
-            if (is_apk(event->drop.file)) {
+            if (is_apk(file)) {
                 action = ACTION_INSTALL_APK;
             } else {
                 action = ACTION_PUSH_FILE;
             }
-            file_handler_request(&file_handler, action, event->drop.file);
+            file_handler_request(&file_handler, action, file);
             break;
         }
     }
@@ -290,7 +314,7 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
     if (priority == 0) {
         return;
     }
-    char *local_fmt = SDL_malloc(strlen(fmt) + 10);
+    char *local_fmt = malloc(strlen(fmt) + 10);
     if (!local_fmt) {
         LOGC("Could not allocate string");
         return;
@@ -299,11 +323,26 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
     strcpy(local_fmt, "[FFmpeg] ");
     strcpy(local_fmt + 9, fmt);
     SDL_LogMessageV(SDL_LOG_CATEGORY_VIDEO, priority, local_fmt, vl);
-    SDL_free(local_fmt);
+    free(local_fmt);
 }
 
 bool
 scrcpy(const struct scrcpy_options *options) {
+    if (!server_init(&server)) {
+        return false;
+    }
+
+    bool ret = false;
+
+    bool server_started = false;
+    bool fps_counter_initialized = false;
+    bool video_buffer_initialized = false;
+    bool file_handler_initialized = false;
+    bool recorder_initialized = false;
+    bool stream_started = false;
+    bool controller_initialized = false;
+    bool controller_started = false;
+
     bool record = !!options->record_filename;
     struct server_params params = {
         .log_level = options->log_level,
@@ -322,18 +361,10 @@ scrcpy(const struct scrcpy_options *options) {
         .force_adb_forward = options->force_adb_forward,
     };
     if (!server_start(&server, options->serial, &params)) {
-        return false;
+        goto end;
     }
 
-    bool ret = false;
-
-    bool fps_counter_initialized = false;
-    bool video_buffer_initialized = false;
-    bool file_handler_initialized = false;
-    bool recorder_initialized = false;
-    bool stream_started = false;
-    bool controller_initialized = false;
-    bool controller_started = false;
+    server_started = true;
 
     if (!sdl_init_and_configure(options->display, options->render_driver,
                                 options->disable_screensaver)) {
@@ -423,7 +454,7 @@ scrcpy(const struct scrcpy_options *options) {
                                    options->window_y, options->window_width,
                                    options->window_height,
                                    options->window_borderless,
-                                   options->rotation, options->mipmaps)) {
+                                   options->rotation, options->scale_filter)) {
             goto end;
         }
 
@@ -465,8 +496,10 @@ end:
         fps_counter_interrupt(&fps_counter);
     }
 
-    // shutdown the sockets and kill the server
-    server_stop(&server);
+    if (server_started) {
+        // shutdown the sockets and kill the server
+        server_stop(&server);
+    }
 
     // now that the sockets are shutdown, the stream and controller are
     // interrupted, we can join them

app/src/scrcpy.h

@@ -1,12 +1,12 @@
 #ifndef SCRCPY_H
 #define SCRCPY_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
-#include "config.h"
-
 enum sc_log_level {
     SC_LOG_LEVEL_DEBUG,
     SC_LOG_LEVEL_INFO,
@@ -41,6 +41,25 @@ struct sc_port_range {
     uint16_t last;
 };
 
+enum sc_scale_filter {
+    SC_SCALE_FILTER_NONE,
+    SC_SCALE_FILTER_TRILINEAR, // mipmaps
+    SC_SCALE_FILTER_BILINEAR,
+    SC_SCALE_FILTER_BICUBIC,
+    SC_SCALE_FILTER_X,
+    SC_SCALE_FILTER_POINT,
+    SC_SCALE_FILTER_AREA,
+    SC_SCALE_FILTER_BICUBLIN,
+    SC_SCALE_FILTER_GAUSS,
+    SC_SCALE_FILTER_SINC,
+    SC_SCALE_FILTER_LANCZOS,
+    SC_SCALE_FILTER_SPLINE,
+    SC_SCALE_FILTER__COUNT,
+};
+
+const char *
+sc_scale_filter_name(enum sc_scale_filter scale_filter);
+
 #define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
 
 struct scrcpy_options {
@@ -56,6 +75,7 @@ struct scrcpy_options {
     enum sc_record_format record_format;
     struct sc_port_range port_range;
     struct sc_shortcut_mods shortcut_mods;
+    enum sc_scale_filter scale_filter;
     uint16_t max_size;
     uint32_t bit_rate;
     uint16_t max_fps;
@@ -65,7 +85,7 @@ struct scrcpy_options {
     int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
     uint16_t window_width;
     uint16_t window_height;
-    uint16_t display_id;
+    uint32_t display_id;
     bool show_touches;
     bool fullscreen;
     bool always_on_top;
@@ -75,7 +95,6 @@ struct scrcpy_options {
     bool render_expired_frames;
     bool prefer_text;
     bool window_borderless;
-    bool mipmaps;
     bool stay_awake;
     bool force_adb_forward;
     bool disable_screensaver;
@@ -103,6 +122,7 @@ struct scrcpy_options {
         .data = {SC_MOD_LALT, SC_MOD_LSUPER}, \
         .count = 2, \
     }, \
+    .scale_filter = SC_SCALE_FILTER_TRILINEAR, \
     .max_size = DEFAULT_MAX_SIZE, \
     .bit_rate = DEFAULT_BIT_RATE, \
     .max_fps = 0, \
@@ -122,7 +142,6 @@ struct scrcpy_options {
     .render_expired_frames = false, \
     .prefer_text = false, \
     .window_borderless = false, \
-    .mipmaps = true, \
     .stay_awake = false, \
     .force_adb_forward = false, \
     .disable_screensaver = false, \

app/src/screen.c

@@ -4,14 +4,9 @@
 #include <string.h>
 #include <SDL2/SDL.h>
 
-#include "config.h"
-#include "common.h"
-#include "compat.h"
 #include "icon.xpm"
-#include "scrcpy.h"
 #include "tiny_xpm.h"
 #include "video_buffer.h"
-#include "util/lock.h"
 #include "util/log.h"
 
 #define DISPLAY_MARGINS 96
@@ -199,39 +194,12 @@ screen_init(struct screen *screen) {
     *screen = (struct screen) SCREEN_INITIALIZER;
 }
 
-static inline SDL_Texture *
-create_texture(struct screen *screen) {
-    SDL_Renderer *renderer = screen->renderer;
-    struct size size = screen->frame_size;
-    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
-                                             SDL_TEXTUREACCESS_STREAMING,
-                                             size.width, size.height);
-    if (!texture) {
-        return NULL;
-    }
-
-    if (screen->mipmaps) {
-        struct sc_opengl *gl = &screen->gl;
-
-        SDL_GL_BindTexture(texture, NULL, NULL);
-
-        // Enable trilinear filtering for downscaling
-        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
-
-        SDL_GL_UnbindTexture(texture);
-    }
-
-    return texture;
-}
-
 bool
 screen_init_rendering(struct screen *screen, const char *window_title,
                       struct size frame_size, bool always_on_top,
                       int16_t window_x, int16_t window_y, uint16_t window_width,
                       uint16_t window_height, bool window_borderless,
-                      uint8_t rotation, bool mipmaps) {
+                      uint8_t rotation, enum sc_scale_filter scale_filter) {
     screen->frame_size = frame_size;
     screen->rotation = rotation;
     if (rotation) {
@@ -274,39 +242,17 @@ screen_init_rendering(struct screen *screen, const char *window_title,
                                           SDL_RENDERER_ACCELERATED);
     if (!screen->renderer) {
         LOGC("Could not create renderer: %s", SDL_GetError());
-        screen_destroy(screen);
+        SDL_DestroyWindow(screen->window);
         return false;
     }
 
-    SDL_RendererInfo renderer_info;
-    int r = SDL_GetRendererInfo(screen->renderer, &renderer_info);
-    const char *renderer_name = r ? NULL : renderer_info.name;
-    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
-
-    // starts with "opengl"
-    screen->use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (screen->use_opengl) {
-        struct sc_opengl *gl = &screen->gl;
-        sc_opengl_init(gl);
-
-        LOGI("OpenGL version: %s", gl->version);
-
-        if (mipmaps) {
-            bool supports_mipmaps =
-                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
-                                               2, 0  /* OpenGL ES 2.0+ */);
-            if (supports_mipmaps) {
-                LOGI("Trilinear filtering enabled");
-                screen->mipmaps = true;
-            } else {
-                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required)");
-            }
-        } else {
-            LOGI("Trilinear filtering disabled");
-        }
-    } else {
-        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
+    bool ok = sc_frame_texture_init(&screen->ftex, screen->renderer,
+                                    scale_filter, frame_size);
+    if (!ok) {
+        LOGC("Could not init frame texture");
+        SDL_DestroyRenderer(screen->renderer);
+        SDL_DestroyWindow(screen->window);
+        return false;
     }
 
     SDL_Surface *icon = read_xpm(icon_xpm);
@@ -317,15 +263,6 @@ screen_init_rendering(struct screen *screen, const char *window_title,
         LOGW("Could not load icon");
     }
 
-    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width,
-                                                  frame_size.height);
-    screen->texture = create_texture(screen);
-    if (!screen->texture) {
-        LOGC("Could not create texture: %s", SDL_GetError());
-        screen_destroy(screen);
-        return false;
-    }
-
     // Reset the window size to trigger a SIZE_CHANGED event, to workaround
     // HiDPI issues with some SDL renderers when several displays having
     // different HiDPI scaling are connected
@@ -343,15 +280,9 @@ screen_show_window(struct screen *screen) {
 
 void
 screen_destroy(struct screen *screen) {
-    if (screen->texture) {
-        SDL_DestroyTexture(screen->texture);
-    }
-    if (screen->renderer) {
-        SDL_DestroyRenderer(screen->renderer);
-    }
-    if (screen->window) {
-        SDL_DestroyWindow(screen->window);
-    }
+    sc_frame_texture_destroy(&screen->ftex);
+    SDL_DestroyRenderer(screen->renderer);
+    SDL_DestroyWindow(screen->window);
 }
 
 static void
@@ -412,13 +343,10 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
 }
 
 // recreate the texture and resize the window if the frame size has changed
-static bool
+static void
 prepare_for_frame(struct screen *screen, struct size new_frame_size) {
     if (screen->frame_size.width != new_frame_size.width
             || screen->frame_size.height != new_frame_size.height) {
-        // frame dimension changed, destroy texture
-        SDL_DestroyTexture(screen->texture);
-
         screen->frame_size = new_frame_size;
 
         struct size new_content_size =
@@ -426,46 +354,20 @@ prepare_for_frame(struct screen *screen, struct size new_frame_size) {
         set_content_size(screen, new_content_size);
 
         screen_update_content_rect(screen);
-
-        LOGI("New texture: %" PRIu16 "x%" PRIu16,
-                     screen->frame_size.width, screen->frame_size.height);
-        screen->texture = create_texture(screen);
-        if (!screen->texture) {
-            LOGC("Could not create texture: %s", SDL_GetError());
-            return false;
-        }
-    }
-
-    return true;
-}
-
-// write the frame into the texture
-static void
-update_texture(struct screen *screen, const AVFrame *frame) {
-    SDL_UpdateYUVTexture(screen->texture, NULL,
-            frame->data[0], frame->linesize[0],
-            frame->data[1], frame->linesize[1],
-            frame->data[2], frame->linesize[2]);
-
-    if (screen->mipmaps) {
-        assert(screen->use_opengl);
-        SDL_GL_BindTexture(screen->texture, NULL, NULL);
-        screen->gl.GenerateMipmap(GL_TEXTURE_2D);
-        SDL_GL_UnbindTexture(screen->texture);
     }
 }
 
 bool
 screen_update_frame(struct screen *screen, struct video_buffer *vb) {
-    mutex_lock(vb->mutex);
-    const AVFrame *frame = video_buffer_consume_rendered_frame(vb);
+    const AVFrame *frame = video_buffer_take_rendering_frame(vb);
     struct size new_frame_size = {frame->width, frame->height};
-    if (!prepare_for_frame(screen, new_frame_size)) {
-        mutex_unlock(vb->mutex);
+    prepare_for_frame(screen, new_frame_size);
+
+    struct size rect_size = {screen->rect.w, screen->rect.h};
+    bool ok = sc_frame_texture_update(&screen->ftex, frame, rect_size);
+    if (!ok) {
         return false;
     }
-    update_texture(screen, frame);
-    mutex_unlock(vb->mutex);
 
     screen_render(screen, false);
     return true;
@@ -475,11 +377,18 @@ void
 screen_render(struct screen *screen, bool update_content_rect) {
     if (update_content_rect) {
         screen_update_content_rect(screen);
+        struct size rect_size = {screen->rect.w, screen->rect.h};
+        if (!sc_frame_texture_resize(&screen->ftex, rect_size)) {
+            // FIXME return error
+            LOGC("oops");
+        }
     }
 
-    SDL_RenderClear(screen->renderer);
+    struct sc_frame_texture *ftex = &screen->ftex;
+    SDL_RenderClear(ftex->renderer);
     if (screen->rotation == 0) {
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
+        SDL_RenderCopy(screen->renderer, ftex->texture, NULL,
+                       &screen->rect);
     } else {
         // rotation in RenderCopyEx() is clockwise, while screen->rotation is
         // counterclockwise (to be consistent with --lock-video-orientation)
@@ -499,10 +408,10 @@ screen_render(struct screen *screen, bool update_content_rect) {
             dstrect = &screen->rect;
         }
 
-        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
+        SDL_RenderCopyEx(screen->renderer, ftex->texture, NULL, dstrect,
                          angle, NULL, 0);
     }
-    SDL_RenderPresent(screen->renderer);
+    SDL_RenderPresent(ftex->renderer);
 }
 
 void

app/src/screen.h

@@ -1,22 +1,24 @@
 #ifndef SCREEN_H
 #define SCREEN_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <SDL2/SDL.h>
 #include <libavformat/avformat.h>
 
-#include "config.h"
-#include "common.h"
+#include "coords.h"
+#include "frame_texture.h"
 #include "opengl.h"
+#include "scrcpy.h"
 
 struct video_buffer;
 
 struct screen {
     SDL_Window *window;
     SDL_Renderer *renderer;
-    SDL_Texture *texture;
-    bool use_opengl;
-    struct sc_opengl gl;
+    struct sc_frame_texture ftex;
+
     struct size frame_size;
     struct size content_size; // rotated frame_size
 
@@ -33,15 +35,12 @@ struct screen {
     bool fullscreen;
     bool maximized;
     bool no_window;
-    bool mipmaps;
 };
 
 #define SCREEN_INITIALIZER { \
     .window = NULL, \
     .renderer = NULL, \
-    .texture = NULL, \
-    .use_opengl = false, \
-    .gl = {0}, \
+    .ftex = {0}, \
     .frame_size = { \
         .width = 0, \
         .height = 0, \
@@ -66,7 +65,6 @@ struct screen {
     .fullscreen = false, \
     .maximized = false, \
     .no_window = false, \
-    .mipmaps = false, \
 }
 
 // initialize default values
@@ -80,7 +78,7 @@ screen_init_rendering(struct screen *screen, const char *window_title,
                       struct size frame_size, bool always_on_top,
                       int16_t window_x, int16_t window_y, uint16_t window_width,
                       uint16_t window_height, bool window_borderless,
-                      uint8_t rotation, bool mipmaps);
+                      uint8_t rotation, enum sc_scale_filter scale_filter);
 
 // show the window
 void

app/src/server.c

@@ -5,12 +5,10 @@
 #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 "adb.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/str_util.h"
@@ -33,7 +31,7 @@ get_server_path(void) {
 #ifdef __WINDOWS__
         char *server_path = utf8_from_wide_char(server_path_env);
 #else
-        char *server_path = SDL_strdup(server_path_env);
+        char *server_path = strdup(server_path_env);
 #endif
         if (!server_path) {
             LOGE("Could not allocate memory");
@@ -45,7 +43,7 @@ get_server_path(void) {
 
 #ifndef PORTABLE
     LOGD("Using server: " DEFAULT_SERVER_PATH);
-    char *server_path = SDL_strdup(DEFAULT_SERVER_PATH);
+    char *server_path = strdup(DEFAULT_SERVER_PATH);
     if (!server_path) {
         LOGE("Could not allocate memory");
         return NULL;
@@ -67,11 +65,11 @@ get_server_path(void) {
 
     // sizeof(SERVER_FILENAME) gives statically the size including the null byte
     size_t len = dirlen + 1 + sizeof(SERVER_FILENAME);
-    char *server_path = SDL_malloc(len);
+    char *server_path = malloc(len);
     if (!server_path) {
         LOGE("Could not alloc server path string, "
              "using " SERVER_FILENAME " from current directory");
-        SDL_free(executable_path);
+        free(executable_path);
         return SERVER_FILENAME;
     }
 
@@ -80,7 +78,7 @@ get_server_path(void) {
     memcpy(&server_path[dirlen + 1], SERVER_FILENAME, sizeof(SERVER_FILENAME));
     // the final null byte has been copied with SERVER_FILENAME
 
-    SDL_free(executable_path);
+    free(executable_path);
 
     LOGD("Using server (portable): %s", server_path);
     return server_path;
@@ -95,36 +93,36 @@ push_server(const char *serial) {
     }
     if (!is_regular_file(server_path)) {
         LOGE("'%s' does not exist or is not a regular file\n", server_path);
-        SDL_free(server_path);
+        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");
+    free(server_path);
+    return process_check_success(process, "adb push", true);
 }
 
 static bool
 enable_tunnel_reverse(const char *serial, uint16_t local_port) {
     process_t process = adb_reverse(serial, SOCKET_NAME, local_port);
-    return process_check_success(process, "adb reverse");
+    return process_check_success(process, "adb reverse", true);
 }
 
 static bool
 disable_tunnel_reverse(const char *serial) {
     process_t process = adb_reverse_remove(serial, SOCKET_NAME);
-    return process_check_success(process, "adb reverse --remove");
+    return process_check_success(process, "adb reverse --remove", true);
 }
 
 static bool
 enable_tunnel_forward(const char *serial, uint16_t local_port) {
     process_t process = adb_forward(serial, local_port, SOCKET_NAME);
-    return process_check_success(process, "adb forward");
+    return process_check_success(process, "adb forward", true);
 }
 
 static bool
 disable_tunnel_forward(const char *serial, uint16_t local_port) {
     process_t process = adb_forward_remove(serial, local_port);
-    return process_check_success(process, "adb forward --remove");
+    return process_check_success(process, "adb forward --remove", true);
 }
 
 static bool
@@ -257,12 +255,12 @@ execute_server(struct server *server, const struct server_params *params) {
     char bit_rate_string[11];
     char max_fps_string[6];
     char lock_video_orientation_string[5];
-    char display_id_string[6];
+    char display_id_string[11];
     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);
+    sprintf(display_id_string, "%"PRIu32, params->display_id);
     const char *const cmd[] = {
         "shell",
         "CLASSPATH=" DEVICE_SERVER_PATH,
@@ -353,15 +351,50 @@ close_socket(socket_t socket) {
     }
 }
 
-void
+bool
 server_init(struct server *server) {
-    *server = (struct server) SERVER_INITIALIZER;
+    server->serial = NULL;
+    server->process = PROCESS_NONE;
+    atomic_flag_clear_explicit(&server->server_socket_closed,
+                               memory_order_relaxed);
+
+    bool ok = sc_mutex_init(&server->mutex);
+    if (!ok) {
+        return false;
+    }
+
+    ok = sc_cond_init(&server->process_terminated_cond);
+    if (!ok) {
+        sc_mutex_destroy(&server->mutex);
+        return false;
+    }
+
+    server->process_terminated = false;
+
+    server->server_socket = INVALID_SOCKET;
+    server->video_socket = INVALID_SOCKET;
+    server->control_socket = INVALID_SOCKET;
+
+    server->port_range.first = 0;
+    server->port_range.last = 0;
+    server->local_port = 0;
+
+    server->tunnel_enabled = false;
+    server->tunnel_forward = false;
+
+    return true;
 }
 
 static int
 run_wait_server(void *data) {
     struct server *server = data;
-    cmd_simple_wait(server->process, NULL); // ignore exit code
+    process_wait(server->process, false); // ignore exit code
+
+    sc_mutex_lock(&server->mutex);
+    server->process_terminated = true;
+    sc_cond_signal(&server->process_terminated_cond);
+    sc_mutex_unlock(&server->mutex);
+
     // no need for synchronization, server_socket is initialized before this
     // thread was created
     if (server->server_socket != INVALID_SOCKET
@@ -380,7 +413,7 @@ server_start(struct server *server, const char *serial,
     server->port_range = params->port_range;
 
     if (serial) {
-        server->serial = SDL_strdup(serial);
+        server->serial = strdup(serial);
         if (!server->serial) {
             return false;
         }
@@ -407,11 +440,11 @@ server_start(struct server *server, const char *serial,
     // 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
+    bool ok = sc_thread_create(&server->wait_server_thread, run_wait_server,
+                               "wait-server", server);
+    if (!ok) {
+        process_terminate(server->process);
+        process_wait(server->process, true); // ignore exit code
         goto error2;
     }
 
@@ -430,7 +463,7 @@ error2:
     }
     disable_tunnel(server);
 error1:
-    SDL_free(server->serial);
+    free(server->serial);
     return false;
 }
 
@@ -493,17 +526,39 @@ server_stop(struct server *server) {
 
     assert(server->process != PROCESS_NONE);
 
-    cmd_terminate(server->process);
-
     if (server->tunnel_enabled) {
         // ignore failure
         disable_tunnel(server);
     }
 
-    SDL_WaitThread(server->wait_server_thread, NULL);
+    // Give some delay for the server to terminate properly
+    sc_mutex_lock(&server->mutex);
+    bool signaled = false;
+    if (!server->process_terminated) {
+#define WATCHDOG_DELAY_MS 1000
+        signaled = sc_cond_timedwait(&server->process_terminated_cond,
+                                     &server->mutex,
+                                     WATCHDOG_DELAY_MS);
+    }
+    sc_mutex_unlock(&server->mutex);
+
+    // After this delay, kill the server if it's not dead already.
+    // On some devices, closing the sockets is not sufficient to wake up the
+    // blocking calls while the device is asleep.
+    if (!signaled) {
+        // The process is terminated, but not reaped (closed) yet, so its PID
+        // is still valid.
+        LOGW("Killing the server...");
+        process_terminate(server->process);
+    }
+
+    sc_thread_join(&server->wait_server_thread, NULL);
+    process_close(server->process);
 }
 
 void
 server_destroy(struct server *server) {
-    SDL_free(server->serial);
+    free(server->serial);
+    sc_cond_destroy(&server->process_terminated_cond);
+    sc_mutex_destroy(&server->mutex);
 }

app/src/server.h

@@ -1,23 +1,28 @@
 #ifndef SERVER_H
 #define SERVER_H
 
+#include "common.h"
+
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL2/SDL_thread.h>
 
-#include "config.h"
-#include "command.h"
-#include "common.h"
+#include "adb.h"
 #include "scrcpy.h"
 #include "util/log.h"
 #include "util/net.h"
+#include "util/thread.h"
 
 struct server {
     char *serial;
     process_t process;
-    SDL_Thread *wait_server_thread;
+    sc_thread wait_server_thread;
     atomic_flag server_socket_closed;
+
+    sc_mutex mutex;
+    sc_cond process_terminated_cond;
+    bool process_terminated;
+
     socket_t server_socket; // only used if !tunnel_forward
     socket_t video_socket;
     socket_t control_socket;
@@ -27,23 +32,6 @@ struct server {
     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 = ATOMIC_FLAG_INIT, \
-    .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, \
-}
-
 struct server_params {
     enum sc_log_level log_level;
     const char *crop;
@@ -55,14 +43,14 @@ struct server_params {
     uint16_t max_fps;
     int8_t lock_video_orientation;
     bool control;
-    uint16_t display_id;
+    uint32_t display_id;
     bool show_touches;
     bool stay_awake;
     bool force_adb_forward;
 };
 
 // init default values
-void
+bool
 server_init(struct server *server);
 
 // push, enable tunnel et start the server

app/src/stream.c

@@ -4,12 +4,8 @@
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
 #include <SDL2/SDL_events.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
 #include <unistd.h>
 
-#include "config.h"
-#include "compat.h"
 #include "decoder.h"
 #include "events.h"
 #include "recorder.h"
@@ -281,8 +277,8 @@ bool
 stream_start(struct stream *stream) {
     LOGD("Starting stream thread");
 
-    stream->thread = SDL_CreateThread(run_stream, "stream", stream);
-    if (!stream->thread) {
+    bool ok = sc_thread_create(&stream->thread, run_stream, "stream", stream);
+    if (!ok) {
         LOGC("Could not start stream thread");
         return false;
     }
@@ -298,5 +294,5 @@ stream_stop(struct stream *stream) {
 
 void
 stream_join(struct stream *stream) {
-    SDL_WaitThread(stream->thread, NULL);
+    sc_thread_join(&stream->thread, NULL);
 }

app/src/stream.h

@@ -1,20 +1,21 @@
 #ifndef STREAM_H
 #define STREAM_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <libavformat/avformat.h>
 #include <SDL2/SDL_atomic.h>
-#include <SDL2/SDL_thread.h>
 
-#include "config.h"
 #include "util/net.h"
+#include "util/thread.h"
 
 struct video_buffer;
 
 struct stream {
     socket_t socket;
-    SDL_Thread *thread;
+    sc_thread thread;
     struct decoder *decoder;
     struct recorder *recorder;
     AVCodecContext *codec_ctx;

app/src/sys/unix/process.c

@@ -1,17 +1,4 @@
-// for portability (kill, readlink, strdup, strtok_r)
-#define _POSIX_C_SOURCE 200809L
-#define _BSD_SOURCE
-
-// modern glibc will complain without this
-#define _DEFAULT_SOURCE
-
-#ifdef __APPLE__
-# define _DARWIN_C_SOURCE // for strdup(), strtok_r(), memset_pattern4()
-#endif
-
-#include "command.h"
-
-#include "config.h"
+#include "util/process.h"
 
 #include <errno.h>
 #include <fcntl.h>
@@ -21,14 +8,13 @@
 #include <string.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) {
+search_executable(const char *file) {
     char *path = getenv("PATH");
     if (!path)
         return false;
@@ -64,7 +50,7 @@ cmd_search(const char *file) {
 }
 
 enum process_result
-cmd_execute(const char *const argv[], pid_t *pid) {
+process_execute(const char *const argv[], pid_t *pid) {
     int fd[2];
 
     if (pipe(fd) == -1) {
@@ -126,29 +112,37 @@ end:
 }
 
 bool
-cmd_terminate(pid_t pid) {
+process_terminate(pid_t pid) {
     if (pid <= 0) {
         LOGC("Requested to kill %d, this is an error. Please report the bug.\n",
              (int) pid);
         abort();
     }
-    return kill(pid, SIGTERM) != -1;
+    return kill(pid, SIGKILL) != -1;
 }
 
-bool
-cmd_simple_wait(pid_t pid, int *exit_code) {
-    int status;
+exit_code_t
+process_wait(pid_t pid, bool close) {
     int code;
-    if (waitpid(pid, &status, 0) == -1 || !WIFEXITED(status)) {
+    int options = WEXITED;
+    if (!close) {
+        options |= WNOWAIT;
+    }
+
+    siginfo_t info;
+    int r = waitid(P_PID, pid, &info, options);
+    if (r == -1 || info.si_code != CLD_EXITED) {
         // could not wait, or exited unexpectedly, probably by a signal
-        code = -1;
+        code = NO_EXIT_CODE;
     } else {
-        code = WEXITSTATUS(status);
+        code = info.si_status;
     }
-    if (exit_code) {
-        *exit_code = code;
-    }
-    return !code;
+    return code;
+}
+
+void
+process_close(pid_t pid) {
+    process_wait(pid, true); // ignore exit code
 }
 
 char *
@@ -162,7 +156,7 @@ get_executable_path(void) {
         return NULL;
     }
     buf[len] = '\0';
-    return SDL_strdup(buf);
+    return strdup(buf);
 #else
     // in practice, we only need this feature for portable builds, only used on
     // Windows, so we don't care implementing it for every platform

app/src/sys/win/process.c

@@ -1,8 +1,8 @@
-#include "command.h"
+#include "util/process.h"
 
+#include <assert.h>
 #include <sys/stat.h>
 
-#include "config.h"
 #include "util/log.h"
 #include "util/str_util.h"
 
@@ -21,7 +21,7 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
 }
 
 enum process_result
-cmd_execute(const char *const argv[], HANDLE *handle) {
+process_execute(const char *const argv[], HANDLE *handle) {
     STARTUPINFOW si;
     PROCESS_INFORMATION pi;
     memset(&si, 0, sizeof(si));
@@ -39,14 +39,9 @@ cmd_execute(const char *const argv[], HANDLE *handle) {
         return PROCESS_ERROR_GENERIC;
     }
 
-#ifdef WINDOWS_NOCONSOLE
-    int flags = CREATE_NO_WINDOW;
-#else
-    int flags = 0;
-#endif
-    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, flags, NULL, NULL, &si,
+    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, 0, NULL, NULL, &si,
                         &pi)) {
-        SDL_free(wide);
+        free(wide);
         *handle = NULL;
         if (GetLastError() == ERROR_FILE_NOT_FOUND) {
             return PROCESS_ERROR_MISSING_BINARY;
@@ -54,28 +49,35 @@ cmd_execute(const char *const argv[], HANDLE *handle) {
         return PROCESS_ERROR_GENERIC;
     }
 
-    SDL_free(wide);
+    free(wide);
     *handle = pi.hProcess;
     return PROCESS_SUCCESS;
 }
 
 bool
-cmd_terminate(HANDLE handle) {
-    return TerminateProcess(handle, 1) && CloseHandle(handle);
+process_terminate(HANDLE handle) {
+    return TerminateProcess(handle, 1);
 }
 
-bool
-cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
+exit_code_t
+process_wait(HANDLE handle, bool close) {
     DWORD code;
     if (WaitForSingleObject(handle, INFINITE) != WAIT_OBJECT_0
             || !GetExitCodeProcess(handle, &code)) {
         // could not wait or retrieve the exit code
-        code = -1; // max value, it's unsigned
+        code = NO_EXIT_CODE; // max value, it's unsigned
     }
-    if (exit_code) {
-        *exit_code = code;
+    if (close) {
+        CloseHandle(handle);
     }
-    return !code;
+    return code;
+}
+
+void
+process_close(HANDLE handle) {
+    bool closed = CloseHandle(handle);
+    assert(closed);
+    (void) closed;
 }
 
 char *
@@ -103,7 +105,7 @@ is_regular_file(const char *path) {
 
     struct _stat path_stat;
     int r = _wstat(wide_path, &path_stat);
-    SDL_free(wide_path);
+    free(wide_path);
 
     if (r) {
         perror("stat");

app/src/tiny_xpm.c

@@ -6,7 +6,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "config.h"
 #include "util/log.h"
 
 struct index {

app/src/tiny_xpm.h

@@ -1,9 +1,9 @@
 #ifndef TINYXPM_H
 #define TINYXPM_H
 
-#include <SDL2/SDL.h>
+#include "common.h"
 
-#include "config.h"
+#include <SDL2/SDL.h>
 
 SDL_Surface *
 read_xpm(char *xpm[]);

app/src/util/buffer_util.h

@@ -1,11 +1,11 @@
 #ifndef BUFFER_UTIL_H
 #define BUFFER_UTIL_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <stdint.h>
 
-#include "config.h"
-
 static inline void
 buffer_write16be(uint8_t *buf, uint16_t value) {
     buf[0] = value >> 8;
@@ -33,7 +33,7 @@ buffer_read16be(const uint8_t *buf) {
 
 static inline uint32_t
 buffer_read32be(const uint8_t *buf) {
-    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+    return ((uint32_t) buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 }
 
 static inline uint64_t

app/src/util/cbuf.h

@@ -2,11 +2,11 @@
 #ifndef CBUF_H
 #define CBUF_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <unistd.h>
 
-#include "config.h"
-
 // To define a circular buffer type of 20 ints:
 //     struct cbuf_int CBUF(int, 20);
 //

app/src/util/lock.h

@@ -1,74 +0,0 @@
-#ifndef LOCK_H
-#define LOCK_H
-
-#include <stdint.h>
-#include <SDL2/SDL_mutex.h>
-
-#include "config.h"
-#include "log.h"
-
-static inline void
-mutex_lock(SDL_mutex *mutex) {
-    int r = SDL_LockMutex(mutex);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not lock mutex: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-static inline void
-mutex_unlock(SDL_mutex *mutex) {
-    int r = SDL_UnlockMutex(mutex);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not unlock mutex: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-static inline void
-cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
-    int r = SDL_CondWait(cond, mutex);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not wait on condition: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-static inline int
-cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
-    int r = SDL_CondWaitTimeout(cond, mutex, ms);
-#ifndef NDEBUG
-    if (r < 0) {
-        LOGC("Could not wait on condition with timeout: %s", SDL_GetError());
-        abort();
-    }
-#endif
-    return r;
-}
-
-static inline void
-cond_signal(SDL_cond *cond) {
-    int r = SDL_CondSignal(cond);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not signal a condition: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-#endif

app/src/util/net.c

@@ -3,7 +3,6 @@
 #include <stdio.h>
 #include <SDL2/SDL_platform.h>
 
-#include "config.h"
 #include "log.h"
 
 #ifdef __WINDOWS__

app/src/util/net.h

@@ -1,6 +1,8 @@
 #ifndef NET_H
 #define NET_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <SDL2/SDL_platform.h>
@@ -17,8 +19,6 @@
   typedef int socket_t;
 #endif
 
-#include "config.h"
-
 bool
 net_init(void);
 

app/src/util/process.c

@@ -0,0 +1,21 @@
+#include "process.h"
+
+#include "log.h"
+
+bool
+process_check_success(process_t proc, const char *name, bool close) {
+    if (proc == PROCESS_NONE) {
+        LOGE("Could not execute \"%s\"", name);
+        return false;
+    }
+    exit_code_t exit_code = process_wait(proc, close);
+    if (exit_code) {
+        if (exit_code != NO_EXIT_CODE) {
+            LOGE("\"%s\" returned with value %" PRIexitcode, name, exit_code);
+        } else {
+            LOGE("\"%s\" exited unexpectedly", name);
+        }
+        return false;
+    }
+    return true;
+}

app/src/util/process.h

@@ -1,8 +1,9 @@
-#ifndef COMMAND_H
-#define COMMAND_H
+#ifndef SC_PROCESS_H
+#define SC_PROCESS_H
+
+#include "common.h"
 
 #include <stdbool.h>
-#include <inttypes.h>
 
 #ifdef _WIN32
 
@@ -31,58 +32,45 @@
 
 #endif
 
-#include "config.h"
-
 enum process_result {
     PROCESS_SUCCESS,
     PROCESS_ERROR_GENERIC,
     PROCESS_ERROR_MISSING_BINARY,
 };
 
-#ifndef __WINDOWS__
-bool
-cmd_search(const char *file);
-#endif
-
+// execute the command and write the result to the output parameter "process"
 enum process_result
-cmd_execute(const char *const argv[], process_t *process);
+process_execute(const char *const argv[], process_t *process);
 
+// kill the process
 bool
-cmd_terminate(process_t pid);
+process_terminate(process_t pid);
 
-bool
-cmd_simple_wait(process_t pid, exit_code_t *exit_code);
+// wait and close the process (like waitpid())
+// the "close" flag indicates if the process must be "closed" (reaped)
+// (passing false is equivalent to enable WNOWAIT in waitid())
+exit_code_t
+process_wait(process_t pid, bool close);
 
-process_t
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
-
-process_t
-adb_forward(const char *serial, uint16_t local_port,
-            const char *device_socket_name);
-
-process_t
-adb_forward_remove(const char *serial, uint16_t local_port);
-
-process_t
-adb_reverse(const char *serial, const char *device_socket_name,
-            uint16_t local_port);
-
-process_t
-adb_reverse_remove(const char *serial, const char *device_socket_name);
-
-process_t
-adb_push(const char *serial, const char *local, const char *remote);
-
-process_t
-adb_install(const char *serial, const char *local);
+// close the process
+//
+// Semantically, process_wait(close) = process_wait(noclose) + process_close
+void
+process_close(process_t pid);
 
 // convenience function to wait for a successful process execution
 // automatically log process errors with the provided process name
 bool
-process_check_success(process_t proc, const char *name);
+process_check_success(process_t proc, const char *name, bool close);
+
+#ifndef _WIN32
+// only used to find package manager, not implemented for Windows
+bool
+search_executable(const char *file);
+#endif
 
 // return the absolute path of the executable (the scrcpy binary)
-// may be NULL on error; to be freed by SDL_free
+// may be NULL on error; to be freed by free()
 char *
 get_executable_path(void);
 

app/src/util/queue.h

@@ -2,12 +2,12 @@
 #ifndef QUEUE_H
 #define QUEUE_H
 
+#include "common.h"
+
 #include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
 
-#include "config.h"
-
 // To define a queue type of "struct foo":
 //    struct queue_foo QUEUE(struct foo);
 #define QUEUE(TYPE) { \

app/src/util/str_util.c

@@ -10,10 +10,6 @@
 # include <tchar.h>
 #endif
 
-#include <SDL2/SDL_stdinc.h>
-
-#include "config.h"
-
 size_t
 xstrncpy(char *dest, const char *src, size_t n) {
     size_t i;
@@ -51,7 +47,7 @@ truncated:
 char *
 strquote(const char *src) {
     size_t len = strlen(src);
-    char *quoted = SDL_malloc(len + 3);
+    char *quoted = malloc(len + 3);
     if (!quoted) {
         return NULL;
     }
@@ -169,7 +165,7 @@ utf8_to_wide_char(const char *utf8) {
         return NULL;
     }
 
-    wchar_t *wide = SDL_malloc(len * sizeof(wchar_t));
+    wchar_t *wide = malloc(len * sizeof(wchar_t));
     if (!wide) {
         return NULL;
     }
@@ -185,7 +181,7 @@ utf8_from_wide_char(const wchar_t *ws) {
         return NULL;
     }
 
-    char *utf8 = SDL_malloc(len);
+    char *utf8 = malloc(len);
     if (!utf8) {
         return NULL;
     }

app/src/util/str_util.h

@@ -1,11 +1,11 @@
 #ifndef STRUTIL_H
 #define STRUTIL_H
 
+#include "common.h"
+
 #include <stdbool.h>
 #include <stddef.h>
 
-#include "config.h"
-
 // like strncpy, except:
 //  - it copies at most n-1 chars
 //  - the dest string is nul-terminated

app/src/util/thread.c

@@ -0,0 +1,160 @@
+#include "thread.h"
+
+#include <assert.h>
+#include <SDL2/SDL_thread.h>
+
+#include "log.h"
+
+bool
+sc_thread_create(sc_thread *thread, sc_thread_fn fn, const char *name,
+                 void *userdata) {
+    SDL_Thread *sdl_thread = SDL_CreateThread(fn, name, userdata);
+    if (!sdl_thread) {
+        return false;
+    }
+
+    thread->thread = sdl_thread;
+    return true;
+}
+
+void
+sc_thread_join(sc_thread *thread, int *status) {
+    SDL_WaitThread(thread->thread, status);
+}
+
+bool
+sc_mutex_init(sc_mutex *mutex) {
+    SDL_mutex *sdl_mutex = SDL_CreateMutex();
+    if (!sdl_mutex) {
+        return false;
+    }
+
+    mutex->mutex = sdl_mutex;
+#ifndef NDEBUG
+    mutex->locker = 0;
+#endif
+    return true;
+}
+
+void
+sc_mutex_destroy(sc_mutex *mutex) {
+    SDL_DestroyMutex(mutex->mutex);
+}
+
+void
+sc_mutex_lock(sc_mutex *mutex) {
+    // SDL mutexes are recursive, but we don't want to use recursive mutexes
+    assert(!sc_mutex_held(mutex));
+    int r = SDL_LockMutex(mutex->mutex);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not lock mutex: %s", SDL_GetError());
+        abort();
+    }
+
+    mutex->locker = sc_thread_get_id();
+#else
+    (void) r;
+#endif
+}
+
+void
+sc_mutex_unlock(sc_mutex *mutex) {
+#ifndef NDEBUG
+    assert(sc_mutex_held(mutex));
+    mutex->locker = 0;
+#endif
+    int r = SDL_UnlockMutex(mutex->mutex);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not lock mutex: %s", SDL_GetError());
+        abort();
+    }
+#else
+    (void) r;
+#endif
+}
+
+sc_thread_id
+sc_thread_get_id(void) {
+    return SDL_ThreadID();
+}
+
+#ifndef NDEBUG
+bool
+sc_mutex_held(struct sc_mutex *mutex) {
+    return mutex->locker == sc_thread_get_id();
+}
+#endif
+
+bool
+sc_cond_init(sc_cond *cond) {
+    SDL_cond *sdl_cond = SDL_CreateCond();
+    if (!sdl_cond) {
+        return false;
+    }
+
+    cond->cond = sdl_cond;
+    return true;
+}
+
+void
+sc_cond_destroy(sc_cond *cond) {
+    SDL_DestroyCond(cond->cond);
+}
+
+void
+sc_cond_wait(sc_cond *cond, sc_mutex *mutex) {
+    int r = SDL_CondWait(cond->cond, mutex->mutex);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not wait on condition: %s", SDL_GetError());
+        abort();
+    }
+
+    mutex->locker = sc_thread_get_id();
+#else
+    (void) r;
+#endif
+}
+
+bool
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms) {
+    int r = SDL_CondWaitTimeout(cond->cond, mutex->mutex, ms);
+#ifndef NDEBUG
+    if (r < 0) {
+        LOGC("Could not wait on condition with timeout: %s", SDL_GetError());
+        abort();
+    }
+
+    mutex->locker = sc_thread_get_id();
+#endif
+    assert(r == 0 || r == SDL_MUTEX_TIMEDOUT);
+    return r == 0;
+}
+
+void
+sc_cond_signal(sc_cond *cond) {
+    int r = SDL_CondSignal(cond->cond);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not signal a condition: %s", SDL_GetError());
+        abort();
+    }
+#else
+    (void) r;
+#endif
+}
+
+void
+sc_cond_broadcast(sc_cond *cond) {
+    int r = SDL_CondBroadcast(cond->cond);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not broadcast a condition: %s", SDL_GetError());
+        abort();
+    }
+#else
+    (void) r;
+#endif
+}

app/src/util/thread.h

@@ -0,0 +1,81 @@
+#ifndef SC_THREAD_H
+#define SC_THREAD_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+/* Forward declarations */
+typedef struct SDL_Thread SDL_Thread;
+typedef struct SDL_mutex SDL_mutex;
+typedef struct SDL_cond SDL_cond;
+
+typedef int sc_thread_fn(void *);
+typedef unsigned int sc_thread_id;
+
+typedef struct sc_thread {
+    SDL_Thread *thread;
+} sc_thread;
+
+typedef struct sc_mutex {
+    SDL_mutex *mutex;
+#ifndef NDEBUG
+    sc_thread_id locker;
+#endif
+} sc_mutex;
+
+typedef struct sc_cond {
+    SDL_cond *cond;
+} sc_cond;
+
+bool
+sc_thread_create(sc_thread *thread, sc_thread_fn fn, const char *name,
+                 void *userdata);
+
+void
+sc_thread_join(sc_thread *thread, int *status);
+
+bool
+sc_mutex_init(sc_mutex *mutex);
+
+void
+sc_mutex_destroy(sc_mutex *mutex);
+
+void
+sc_mutex_lock(sc_mutex *mutex);
+
+void
+sc_mutex_unlock(sc_mutex *mutex);
+
+sc_thread_id
+sc_thread_get_id(void);
+
+#ifndef NDEBUG
+bool
+sc_mutex_held(struct sc_mutex *mutex);
+# define sc_mutex_assert(mutex) assert(sc_mutex_held(mutex))
+#else
+# define sc_mutex_assert(mutex)
+#endif
+
+bool
+sc_cond_init(sc_cond *cond);
+
+void
+sc_cond_destroy(sc_cond *cond);
+
+void
+sc_cond_wait(sc_cond *cond, sc_mutex *mutex);
+
+// return true on signaled, false on timeout
+bool
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms);
+
+void
+sc_cond_signal(sc_cond *cond);
+
+void
+sc_cond_broadcast(sc_cond *cond);
+
+#endif

app/src/video_buffer.c

@@ -1,12 +1,9 @@
 #include "video_buffer.h"
 
 #include <assert.h>
-#include <SDL2/SDL_mutex.h>
 #include <libavutil/avutil.h>
 #include <libavformat/avformat.h>
 
-#include "config.h"
-#include "util/lock.h"
 #include "util/log.h"
 
 bool
@@ -14,22 +11,31 @@ video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
                   bool render_expired_frames) {
     vb->fps_counter = fps_counter;
 
-    if (!(vb->decoding_frame = av_frame_alloc())) {
+    vb->decoding_frame = av_frame_alloc();
+    if (!vb->decoding_frame) {
         goto error_0;
     }
 
-    if (!(vb->rendering_frame = av_frame_alloc())) {
+    vb->pending_frame = av_frame_alloc();
+    if (!vb->pending_frame) {
         goto error_1;
     }
 
-    if (!(vb->mutex = SDL_CreateMutex())) {
+    vb->rendering_frame = av_frame_alloc();
+    if (!vb->rendering_frame) {
         goto error_2;
     }
 
+    bool ok = sc_mutex_init(&vb->mutex);
+    if (!ok) {
+        goto error_3;
+    }
+
     vb->render_expired_frames = render_expired_frames;
     if (render_expired_frames) {
-        if (!(vb->rendering_frame_consumed_cond = SDL_CreateCond())) {
-            SDL_DestroyMutex(vb->mutex);
+        ok = sc_cond_init(&vb->pending_frame_consumed_cond);
+        if (!ok) {
+            sc_mutex_destroy(&vb->mutex);
             goto error_2;
         }
         // interrupted is not used if expired frames are not rendered
@@ -39,12 +45,14 @@ video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
 
     // there is initially no rendering frame, so consider it has already been
     // consumed
-    vb->rendering_frame_consumed = true;
+    vb->pending_frame_consumed = true;
 
     return true;
 
-error_2:
+error_3:
     av_frame_free(&vb->rendering_frame);
+error_2:
+    av_frame_free(&vb->pending_frame);
 error_1:
     av_frame_free(&vb->decoding_frame);
 error_0:
@@ -54,60 +62,78 @@ error_0:
 void
 video_buffer_destroy(struct video_buffer *vb) {
     if (vb->render_expired_frames) {
-        SDL_DestroyCond(vb->rendering_frame_consumed_cond);
+        sc_cond_destroy(&vb->pending_frame_consumed_cond);
     }
-    SDL_DestroyMutex(vb->mutex);
+    sc_mutex_destroy(&vb->mutex);
     av_frame_free(&vb->rendering_frame);
+    av_frame_free(&vb->pending_frame);
     av_frame_free(&vb->decoding_frame);
 }
 
 static void
-video_buffer_swap_frames(struct video_buffer *vb) {
+video_buffer_swap_decoding_frame(struct video_buffer *vb) {
+    sc_mutex_assert(&vb->mutex);
     AVFrame *tmp = vb->decoding_frame;
-    vb->decoding_frame = vb->rendering_frame;
-    vb->rendering_frame = tmp;
+    vb->decoding_frame = vb->pending_frame;
+    vb->pending_frame = tmp;
+}
+
+static void
+video_buffer_swap_rendering_frame(struct video_buffer *vb) {
+    sc_mutex_assert(&vb->mutex);
+    AVFrame *tmp = vb->rendering_frame;
+    vb->rendering_frame = vb->pending_frame;
+    vb->pending_frame = tmp;
 }
 
 void
 video_buffer_offer_decoded_frame(struct video_buffer *vb,
                                  bool *previous_frame_skipped) {
-    mutex_lock(vb->mutex);
+    sc_mutex_lock(&vb->mutex);
     if (vb->render_expired_frames) {
         // wait for the current (expired) frame to be consumed
-        while (!vb->rendering_frame_consumed && !vb->interrupted) {
-            cond_wait(vb->rendering_frame_consumed_cond, vb->mutex);
+        while (!vb->pending_frame_consumed && !vb->interrupted) {
+            sc_cond_wait(&vb->pending_frame_consumed_cond, &vb->mutex);
         }
-    } else if (!vb->rendering_frame_consumed) {
+    } else if (!vb->pending_frame_consumed) {
         fps_counter_add_skipped_frame(vb->fps_counter);
     }
 
-    video_buffer_swap_frames(vb);
+    video_buffer_swap_decoding_frame(vb);
 
-    *previous_frame_skipped = !vb->rendering_frame_consumed;
-    vb->rendering_frame_consumed = false;
+    *previous_frame_skipped = !vb->pending_frame_consumed;
+    vb->pending_frame_consumed = false;
 
-    mutex_unlock(vb->mutex);
+    sc_mutex_unlock(&vb->mutex);
 }
 
 const AVFrame *
-video_buffer_consume_rendered_frame(struct video_buffer *vb) {
-    assert(!vb->rendering_frame_consumed);
-    vb->rendering_frame_consumed = true;
+video_buffer_take_rendering_frame(struct video_buffer *vb) {
+    sc_mutex_lock(&vb->mutex);
+    assert(!vb->pending_frame_consumed);
+    vb->pending_frame_consumed = true;
+
     fps_counter_add_rendered_frame(vb->fps_counter);
+
+    video_buffer_swap_rendering_frame(vb);
+
     if (vb->render_expired_frames) {
         // unblock video_buffer_offer_decoded_frame()
-        cond_signal(vb->rendering_frame_consumed_cond);
+        sc_cond_signal(&vb->pending_frame_consumed_cond);
     }
+    sc_mutex_unlock(&vb->mutex);
+
+    // rendering_frame is only written from this thread, no need to lock
     return vb->rendering_frame;
 }
 
 void
 video_buffer_interrupt(struct video_buffer *vb) {
     if (vb->render_expired_frames) {
-        mutex_lock(vb->mutex);
+        sc_mutex_lock(&vb->mutex);
         vb->interrupted = true;
-        mutex_unlock(vb->mutex);
+        sc_mutex_unlock(&vb->mutex);
         // wake up blocking wait
-        cond_signal(vb->rendering_frame_consumed_cond);
+        sc_cond_signal(&vb->pending_frame_consumed_cond);
     }
 }

app/src/video_buffer.h

@@ -1,23 +1,45 @@
 #ifndef VIDEO_BUFFER_H
 #define VIDEO_BUFFER_H
 
-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
+#include "common.h"
+
+#include <stdbool.h>
 
-#include "config.h"
 #include "fps_counter.h"
+#include "util/thread.h"
 
 // forward declarations
 typedef struct AVFrame AVFrame;
 
+/**
+ * There are 3 frames in memory:
+ *  - one frame is held by the decoder (decoding_frame)
+ *  - one frame is held by the renderer (rendering_frame)
+ *  - one frame is shared between the decoder and the renderer (pending_frame)
+ *
+ * The decoder decodes a packet into the decoding_frame (it may takes time).
+ *
+ * Once the frame is decoded, it calls video_buffer_offer_decoded_frame(),
+ * which swaps the decoding and pending frames.
+ *
+ * When the renderer is notified that a new frame is available, it calls
+ * video_buffer_take_rendering_frame() to retrieve it, which swaps the pending
+ * and rendering frames. The frame is valid until the next call, without
+ * blocking the decoder.
+ */
+
 struct video_buffer {
     AVFrame *decoding_frame;
+    AVFrame *pending_frame;
     AVFrame *rendering_frame;
-    SDL_mutex *mutex;
+
+    sc_mutex mutex;
     bool render_expired_frames;
     bool interrupted;
-    SDL_cond *rendering_frame_consumed_cond;
-    bool rendering_frame_consumed;
+
+    sc_cond pending_frame_consumed_cond;
+    bool pending_frame_consumed;
+
     struct fps_counter *fps_counter;
 };
 
@@ -29,18 +51,15 @@ void
 video_buffer_destroy(struct video_buffer *vb);
 
 // set the decoded frame as ready for rendering
-// this function locks frames->mutex during its execution
 // the output flag is set to report whether the previous frame has been skipped
 void
 video_buffer_offer_decoded_frame(struct video_buffer *vb,
                                  bool *previous_frame_skipped);
 
 // mark the rendering frame as consumed and return it
-// MUST be called with frames->mutex locked!!!
-// the caller is expected to render the returned frame to some texture before
-// unlocking frames->mutex
+// the frame is valid until the next call to this function
 const AVFrame *
-video_buffer_consume_rendered_frame(struct video_buffer *vb);
+video_buffer_take_rendering_frame(struct video_buffer *vb);
 
 // wake up and avoid any blocking call
 void

app/tests/test_buffer_util.c

@@ -1,3 +1,5 @@
+#include "common.h"
+
 #include <assert.h>
 
 #include "util/buffer_util.h"

app/tests/test_cbuf.c

@@ -1,3 +1,5 @@
+#include "common.h"
+
 #include <assert.h>
 #include <string.h>
 

app/tests/test_cli.c

@@ -1,8 +1,9 @@
+#include "common.h"
+
 #include <assert.h>
 #include <string.h>
 
 #include "cli.h"
-#include "common.h"
 #include "scrcpy.h"
 
 static void test_flag_version(void) {

app/tests/test_control_msg_serialize.c

@@ -1,3 +1,5 @@
+#include "common.h"
+
 #include <assert.h>
 #include <string.h>
 
@@ -15,7 +17,7 @@ static void test_serialize_inject_keycode(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 14);
 
     const unsigned char expected[] = {
@@ -37,7 +39,7 @@ static void test_serialize_inject_text(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 18);
 
     const unsigned char expected[] = {
@@ -57,7 +59,7 @@ static void test_serialize_inject_text_long(void) {
     msg.inject_text.text = text;
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
 
     unsigned char expected[5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
@@ -93,7 +95,7 @@ static void test_serialize_inject_touch_event(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 28);
 
     const unsigned char expected[] = {
@@ -128,7 +130,7 @@ static void test_serialize_inject_scroll_event(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 21);
 
     const unsigned char expected[] = {
@@ -147,7 +149,7 @@ static void test_serialize_back_or_screen_on(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
@@ -162,7 +164,7 @@ static void test_serialize_expand_notification_panel(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
@@ -177,7 +179,7 @@ static void test_serialize_collapse_notification_panel(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
@@ -192,7 +194,7 @@ static void test_serialize_get_clipboard(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
@@ -211,7 +213,7 @@ static void test_serialize_set_clipboard(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 19);
 
     const unsigned char expected[] = {
@@ -232,7 +234,7 @@ static void test_serialize_set_screen_power_mode(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 2);
 
     const unsigned char expected[] = {
@@ -248,7 +250,7 @@ static void test_serialize_rotate_device(void) {
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {

app/tests/test_device_msg_deserialize.c

@@ -1,3 +1,5 @@
+#include "common.h"
+
 #include <assert.h>
 #include <string.h>
 

app/tests/test_queue.c

@@ -1,3 +1,5 @@
+#include "common.h"
+
 #include <assert.h>
 
 #include "util/queue.h"

app/tests/test_strutil.c

@@ -1,8 +1,9 @@
+#include "common.h"
+
 #include <assert.h>
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
-#include <SDL2/SDL.h>
 
 #include "util/str_util.h"
 
@@ -136,7 +137,7 @@ static void test_strquote(void) {
     // add '"' at the beginning and the end
     assert(!strcmp("\"abcde\"", out));
 
-    SDL_free(out);
+    free(out);
 }
 
 static void test_utf8_truncate(void) {

cross_win32.txt

@@ -17,4 +17,4 @@ endian = 'little'
 [properties]
 prebuilt_ffmpeg_shared = 'ffmpeg-4.3.1-win32-shared'
 prebuilt_ffmpeg_dev = 'ffmpeg-4.3.1-win32-dev'
-prebuilt_sdl2 = 'SDL2-2.0.12/i686-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.14/i686-w64-mingw32'

cross_win64.txt

@@ -17,4 +17,4 @@ endian = 'little'
 [properties]
 prebuilt_ffmpeg_shared = 'ffmpeg-4.3.1-win64-shared'
 prebuilt_ffmpeg_dev = 'ffmpeg-4.3.1-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.12/x86_64-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.14/x86_64-w64-mingw32'

data/scrcpy-noconsole.vbs

@@ -0,0 +1 @@
+CreateObject("Wscript.Shell").Run "cmd /c scrcpy.exe", 0, false

meson.build

@@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '1.16',
+        version: '1.17',
         meson_version: '>= 0.48',
         default_options: [
             'c_std=c11',

meson_options.txt

@@ -1,7 +1,6 @@
 option('compile_app', type: 'boolean', value: true, description: 'Build the client')
 option('compile_server', type: 'boolean', value: true, description: 'Build the server')
 option('crossbuild_windows', type: 'boolean', value: false, description: 'Build for Windows from Linux')
-option('windows_noconsole', type: 'boolean', value: false, description: 'Disable console on Windows (pass -mwindows flag)')
 option('prebuilt_server', type: 'string', description: 'Path of the prebuilt server')
 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')

prebuilt-deps/Makefile

@@ -30,9 +30,9 @@ prepare-ffmpeg-dev-win64:
 		ffmpeg-4.3.1-win64-dev
 
 prepare-sdl2:
-	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.12-mingw.tar.gz \
-		e614a60f797e35ef9f3f96aef3dc6a1d786de3cc7ca6216f97e435c0b6aafc46 \
-		SDL2-2.0.12
+	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.14-mingw.tar.gz \
+		405eaff3eb18f2e08fe669ef9e63bc9a8710b7d343756f238619761e9b60407d \
+		SDL2-2.0.14
 
 prepare-adb:
 	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r30.0.5-windows.zip \

release.mk

@@ -9,21 +9,20 @@
 # the server to the device.
 
 .PHONY: default clean \
+	test \
 	build-server \
 	prepare-deps-win32 prepare-deps-win64 \
-	build-win32 build-win32-noconsole \
-	build-win64 build-win64-noconsole \
+	build-win32 build-win64 \
 	dist-win32 dist-win64 \
 	zip-win32 zip-win64 \
-	sums release
+	release
 
 GRADLE ?= ./gradlew
 
+TEST_BUILD_DIR := build-test
 SERVER_BUILD_DIR := build-server
 WIN32_BUILD_DIR := build-win32
-WIN32_NOCONSOLE_BUILD_DIR := build-win32-noconsole
 WIN64_BUILD_DIR := build-win64
-WIN64_NOCONSOLE_BUILD_DIR := build-win64-noconsole
 
 DIST := dist
 WIN32_TARGET_DIR := scrcpy-win32
@@ -33,19 +32,35 @@ VERSION := $(shell git describe --tags --always)
 WIN32_TARGET := $(WIN32_TARGET_DIR)-$(VERSION).zip
 WIN64_TARGET := $(WIN64_TARGET_DIR)-$(VERSION).zip
 
-release: clean zip-win32 zip-win64 sums
-	@echo "Windows archives generated in $(DIST)/"
+RELEASE_DIR := release-$(VERSION)
+
+release: clean test build-server zip-win32 zip-win64
+	mkdir -p "$(RELEASE_DIR)"
+	cp "$(SERVER_BUILD_DIR)/server/scrcpy-server" \
+		"$(RELEASE_DIR)/scrcpy-server-$(VERSION)"
+	cp "$(DIST)/$(WIN32_TARGET)" "$(RELEASE_DIR)"
+	cp "$(DIST)/$(WIN64_TARGET)" "$(RELEASE_DIR)"
+	cd "$(RELEASE_DIR)" && \
+		sha256sum "scrcpy-server-$(VERSION)" \
+			"scrcpy-win32-$(VERSION).zip" \
+			"scrcpy-win64-$(VERSION).zip" > SHA256SUMS.txt
+	@echo "Release generated in $(RELEASE_DIR)/"
 
 clean:
 	$(GRADLE) clean
-	rm -rf "$(SERVER_BUILD_DIR)" "$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)" \
-		   "$(WIN32_NOCONSOLE_BUILD_DIR)" "$(WIN64_NOCONSOLE_BUILD_DIR)" "$(DIST)"
+	rm -rf "$(DIST)" "$(TEST_BUILD_DIR)" "$(SERVER_BUILD_DIR)" \
+		"$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)"
+
+test:
+	[ -d "$(TEST_BUILD_DIR)" ] || ( mkdir "$(TEST_BUILD_DIR)" && \
+		meson "$(TEST_BUILD_DIR)" -Db_sanitize=address )
+	ninja -C "$(TEST_BUILD_DIR)"
+	$(GRADLE) -p server check
 
 build-server:
 	[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
-		meson "$(SERVER_BUILD_DIR)" \
-			--buildtype release -Dcompile_app=false )
-		ninja -C "$(SERVER_BUILD_DIR)"
+		meson "$(SERVER_BUILD_DIR)" --buildtype release -Dcompile_app=false )
+	ninja -C "$(SERVER_BUILD_DIR)"
 
 prepare-deps-win32:
 	-$(MAKE) -C prebuilt-deps prepare-win32
@@ -60,17 +75,6 @@ build-win32: prepare-deps-win32
 			-Dportable=true )
 	ninja -C "$(WIN32_BUILD_DIR)"
 
-build-win32-noconsole: prepare-deps-win32
-	[ -d "$(WIN32_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN32_NOCONSOLE_BUILD_DIR)" && \
-		meson "$(WIN32_NOCONSOLE_BUILD_DIR)" \
-			--cross-file cross_win32.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
-			-Dwindows_noconsole=true \
-			-Dportable=true )
-	ninja -C "$(WIN32_NOCONSOLE_BUILD_DIR)"
-
 prepare-deps-win64:
 	-$(MAKE) -C prebuilt-deps prepare-win64
 
@@ -84,23 +88,12 @@ build-win64: prepare-deps-win64
 			-Dportable=true )
 	ninja -C "$(WIN64_BUILD_DIR)"
 
-build-win64-noconsole: prepare-deps-win64
-	[ -d "$(WIN64_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN64_NOCONSOLE_BUILD_DIR)" && \
-		meson "$(WIN64_NOCONSOLE_BUILD_DIR)" \
-			--cross-file cross_win64.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
-			-Dwindows_noconsole=true \
-			-Dportable=true )
-	ninja -C "$(WIN64_NOCONSOLE_BUILD_DIR)"
-
-dist-win32: build-server build-win32 build-win32-noconsole
+dist-win32: build-server build-win32
 	mkdir -p "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp "$(WIN32_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/scrcpy-noconsole.exe"
 	cp data/scrcpy-console.bat "$(DIST)/$(WIN32_TARGET_DIR)"
+	cp data/scrcpy-noconsole.vbs "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
@@ -109,14 +102,14 @@ dist-win32: build-server build-win32 build-win32-noconsole
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.12/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.14/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 
-dist-win64: build-server build-win64 build-win64-noconsole
+dist-win64: build-server build-win64
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp "$(WIN64_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/scrcpy-noconsole.exe"
 	cp data/scrcpy-console.bat "$(DIST)/$(WIN64_TARGET_DIR)"
+	cp data/scrcpy-noconsole.vbs "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
@@ -125,7 +118,7 @@ dist-win64: build-server build-win64 build-win64-noconsole
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.12/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.14/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 
 zip-win32: dist-win32
 	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
@@ -134,7 +127,3 @@ zip-win32: dist-win32
 zip-win64: dist-win64
 	cd "$(DIST)/$(WIN64_TARGET_DIR)"; \
 		zip -r "../$(WIN64_TARGET)" .
-
-sums:
-	cd "$(DIST)"; \
-		sha256sum *.zip > SHA256SUMS.txt

release.sh

@@ -1,44 +1,2 @@
 #!/bin/bash
-set -e
-
-# test locally
-TESTDIR=build_test
-rm -rf "$TESTDIR"
-# run client tests with ASAN enabled
-meson "$TESTDIR" -Db_sanitize=address
-ninja -C"$TESTDIR" test
-
-# test server
-GRADLE=${GRADLE:-./gradlew}
-$GRADLE -p server check
-
-BUILDDIR=build_release
-rm -rf "$BUILDDIR"
-meson "$BUILDDIR" --buildtype release --strip -Db_lto=true
-cd "$BUILDDIR"
-ninja
-cd -
-
-# build Windows releases
-make -f Makefile.CrossWindows
-
-# the generated server must be the same everywhere
-cmp "$BUILDDIR/server/scrcpy-server" dist/scrcpy-win32/scrcpy-server
-cmp "$BUILDDIR/server/scrcpy-server" dist/scrcpy-win64/scrcpy-server
-
-# get version name
-TAG=$(git describe --tags --always)
-
-# create release directory
-mkdir -p "release-$TAG"
-cp "$BUILDDIR/server/scrcpy-server" "release-$TAG/scrcpy-server-$TAG"
-cp "dist/scrcpy-win32-$TAG.zip" "release-$TAG/"
-cp "dist/scrcpy-win64-$TAG.zip" "release-$TAG/"
-
-# generate checksums
-cd "release-$TAG"
-sha256sum "scrcpy-server-$TAG" \
-          "scrcpy-win32-$TAG.zip" \
-          "scrcpy-win64-$TAG.zip" > SHA256SUMS.txt
-
-echo "Release generated in release-$TAG/"
+make -f release.mk

server/build.gradle

@@ -6,8 +6,8 @@ android {
         applicationId "com.genymobile.scrcpy"
         minSdkVersion 21
         targetSdkVersion 30
-        versionCode 19
-        versionName "1.16"
+        versionCode 20
+        versionName "1.17"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
     }
     buildTypes {

server/build_without_gradle.sh

@@ -12,7 +12,7 @@
 set -e
 
 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.16
+SCRCPY_VERSION_NAME=1.17
 
 PLATFORM=${ANDROID_PLATFORM:-30}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-30.0.0}

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

@@ -58,12 +58,14 @@ public final class Server {
             ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(), codecOptions,
                     options.getEncoderName());
 
+            Thread controllerThread = null;
+            Thread deviceMessageSenderThread = null;
             if (options.getControl()) {
                 final Controller controller = new Controller(device, connection);
 
                 // asynchronous
-                startController(controller);
-                startDeviceMessageSender(controller.getSender());
+                controllerThread = startController(controller);
+                deviceMessageSenderThread = startDeviceMessageSender(controller.getSender());
 
                 device.setClipboardListener(new Device.ClipboardListener() {
                     @Override
@@ -79,12 +81,19 @@ public final class Server {
             } catch (IOException e) {
                 // this is expected on close
                 Ln.d("Screen streaming stopped");
+            } finally {
+                if (controllerThread != null) {
+                    controllerThread.interrupt();
+                }
+                if (deviceMessageSenderThread != null) {
+                    deviceMessageSenderThread.interrupt();
+                }
             }
         }
     }
 
-    private static void startController(final Controller controller) {
-        new Thread(new Runnable() {
+    private static Thread startController(final Controller controller) {
+        Thread thread = new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
@@ -94,11 +103,13 @@ public final class Server {
                     Ln.d("Controller stopped");
                 }
             }
-        }).start();
+        });
+        thread.start();
+        return thread;
     }
 
-    private static void startDeviceMessageSender(final DeviceMessageSender sender) {
-        new Thread(new Runnable() {
+    private static Thread startDeviceMessageSender(final DeviceMessageSender sender) {
+        Thread thread = new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
@@ -108,7 +119,9 @@ public final class Server {
                     Ln.d("Device message sender stopped");
                 }
             }
-        }).start();
+        });
+        thread.start();
+        return thread;
     }
 
     private static Options createOptions(String... args) {