Forward DOWN and UP separately for right-click

The shortcut "back on screen on" is a bit special: the control is
requested by the client, but the actual event injection (POWER or BACK)
is determined on the device.

To properly inject DOWN and UP events for BACK, transmit the action as
a control parameter.

If the screen is off:
 - on DOWN, inject POWER (DOWN and UP) (wake up the device immediately)
 - on UP, do nothing
If the screen is on:
 - on DOWN, inject BACK DOWN
 - on UP, inject BACK UP

A corner case is when the screen turns off between the DOWN and UP
event. In that case, a BACK UP event will be injected, so it's harmless.

With this change, the actual BACK is handled by Android on UP on the
device (instead of DOWN). This is consistent with the keyboard shortcut
(Mod+b) behavior.

app/meson.build

@@ -23,7 +23,8 @@ src = [
     'src/video_buffer.c',
     'src/util/net.c',
     'src/util/process.c',
-    'src/util/str_util.c'
+    'src/util/str_util.c',
+    'src/util/thread.c',
 ]
 
 if host_machine.system() == 'windows'
@@ -98,9 +99,6 @@ foreach f : check_functions
   endif
 endforeach
 
-# expose the build type
-conf.set('NDEBUG', get_option('buildtype') != 'debug')
-
 # the version, updated on release
 conf.set_quoted('SCRCPY_VERSION', meson.project_version())
 
@@ -116,23 +114,10 @@ conf.set('PORTABLE', get_option('portable'))
 conf.set('DEFAULT_LOCAL_PORT_RANGE_FIRST', '27183')
 conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')
 
-# the default max video size for both dimensions, in pixels
-# overridden by option --max-size
-conf.set('DEFAULT_MAX_SIZE', '0')  # 0: unlimited
-
-# the default video orientation
-# natural device orientation is 0 and each increment adds 90 degrees
-# counterclockwise
-# overridden by option --lock-video-orientation
-conf.set('DEFAULT_LOCK_VIDEO_ORIENTATION', '-1')  # -1: unlocked
-
 # the default video bitrate, in bits/second
 # overridden by option --bit-rate
 conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
 
-# enable High DPI support
-conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
-
 # run a server debugger and wait for a client to be attached
 conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
 

app/scrcpy.1

@@ -187,16 +187,16 @@ Enable "show touches" on start, restore the initial value on exit.
 
 It only shows physical touches (not clicks from scrcpy).
 
-.TP
-.B \-v, \-\-version
-Print the version of scrcpy.
-
 .TP
 .BI "\-V, \-\-verbosity " value
 Set the log level ("debug", "info", "warn" or "error").
 
 Default is "info" for release builds, "debug" for debug builds.
 
+.TP
+.B \-v, \-\-version
+Print the version of scrcpy.
+
 .TP
 .B \-w, \-\-stay-awake
 Keep the device on while scrcpy is running, when the device is plugged in.

app/src/cli.c

@@ -10,6 +10,9 @@
 #include "util/log.h"
 #include "util/str_util.h"
 
+#define STR_IMPL_(x) #x
+#define STR(x) STR_IMPL_(x)
+
 void
 scrcpy_print_usage(const char *arg0) {
     fprintf(stderr,
@@ -23,7 +26,7 @@ scrcpy_print_usage(const char *arg0) {
         "    -b, --bit-rate value\n"
         "        Encode the video at the given bit-rate, expressed in bits/s.\n"
         "        Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
-        "        Default is %d.\n"
+        "        Default is " STR(DEFAULT_BIT_RATE) ".\n"
         "\n"
         "    --codec-options key[:type]=value[,...]\n"
         "        Set a list of comma-separated key:type=value options for the\n"
@@ -81,7 +84,7 @@ scrcpy_print_usage(const char *arg0) {
         "        Possible values are -1 (unlocked), 0, 1, 2 and 3.\n"
         "        Natural device orientation is 0, and each increment adds a\n"
         "        90 degrees rotation counterclockwise.\n"
-        "        Default is %d%s.\n"
+        "        Default is -1 (unlocked).\n"
         "\n"
         "    --max-fps value\n"
         "        Limit the frame rate of screen capture (officially supported\n"
@@ -91,7 +94,7 @@ scrcpy_print_usage(const char *arg0) {
         "        Limit both the width and height of the video to value. The\n"
         "        other dimension is computed so that the device aspect-ratio\n"
         "        is preserved.\n"
-        "        Default is %d%s.\n"
+        "        Default is 0 (unlimited).\n"
         "\n"
         "    -n, --no-control\n"
         "        Disable device control (mirror the device in read-only).\n"
@@ -110,7 +113,8 @@ scrcpy_print_usage(const char *arg0) {
         "\n"
         "    -p, --port port[:port]\n"
         "        Set the TCP port (range) used by the client to listen.\n"
-        "        Default is %d:%d.\n"
+        "        Default is " STR(DEFAULT_LOCAL_PORT_RANGE_FIRST) ":"
+                              STR(DEFAULT_LOCAL_PORT_RANGE_LAST) ".\n"
         "\n"
         "    --prefer-text\n"
         "        Inject alpha characters and space as text events instead of\n"
@@ -175,9 +179,6 @@ scrcpy_print_usage(const char *arg0) {
         "        on exit.\n"
         "        It only shows physical touches (not clicks from scrcpy).\n"
         "\n"
-        "    -v, --version\n"
-        "        Print the version of scrcpy.\n"
-        "\n"
         "    -V, --verbosity value\n"
         "        Set the log level (debug, info, warn or error).\n"
 #ifndef NDEBUG
@@ -185,6 +186,9 @@ scrcpy_print_usage(const char *arg0) {
 #else
         "        Default is info.\n"
 #endif
+        "\n"
+        "    -v, --version\n"
+        "        Print the version of scrcpy.\n"
         "\n"
         "    -w, --stay-awake\n"
         "        Keep the device on while scrcpy is running, when the device\n"
@@ -297,12 +301,7 @@ scrcpy_print_usage(const char *arg0) {
         "\n"
         "    Drag & drop APK file\n"
         "        Install APK from computer\n"
-        "\n",
-        arg0,
-        DEFAULT_BIT_RATE,
-        DEFAULT_LOCK_VIDEO_ORIENTATION, DEFAULT_LOCK_VIDEO_ORIENTATION >= 0 ? "" : " (unlocked)",
-        DEFAULT_MAX_SIZE, DEFAULT_MAX_SIZE ? "" : " (unlimited)",
-        DEFAULT_LOCAL_PORT_RANGE_FIRST, DEFAULT_LOCAL_PORT_RANGE_LAST);
+        "\n", arg0);
 }
 
 static bool
@@ -667,6 +666,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_POWER_OFF_ON_CLOSE     1026
 
 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@@ -717,6 +717,8 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         {"window-height",          required_argument, NULL, OPT_WINDOW_HEIGHT},
         {"window-borderless",      no_argument,       NULL,
                                                   OPT_WINDOW_BORDERLESS},
+        {"power-off-on-close",     no_argument,       NULL,
+                                                  OPT_POWER_OFF_ON_CLOSE},
         {NULL,                     0,                 NULL, 0  },
     };
 
@@ -885,6 +887,9 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
             case OPT_LEGACY_PASTE:
                 opts->legacy_paste = true;
                 break;
+            case OPT_POWER_OFF_ON_CLOSE:
+                opts->power_off_on_close = true;
+                break;
             default:
                 // getopt prints the error message on stderr
                 return false;

app/src/compat.h

@@ -56,7 +56,7 @@
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
 #endif
 
-#ifdef HAVE_STRDUP
+#ifndef HAVE_STRDUP
 char *strdup(const char *s);
 #endif
 

app/src/control_msg.c

@@ -67,6 +67,9 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
             buffer_write32be(&buf[17],
                              (uint32_t) msg->inject_scroll_event.vscroll);
             return 21;
+        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
+            buf[1] = msg->inject_keycode.action;
+            return 2;
         case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
             buf[1] = !!msg->set_clipboard.paste;
             size_t len = write_string(msg->set_clipboard.text,
@@ -77,7 +80,6 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
         case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
             buf[1] = msg->set_screen_power_mode.mode;
             return 2;
-        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
         case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
         case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
         case CONTROL_MSG_TYPE_GET_CLIPBOARD:

app/src/control_msg.h

@@ -64,6 +64,10 @@ struct control_msg {
             int32_t hscroll;
             int32_t vscroll;
         } inject_scroll_event;
+        struct {
+            enum android_keyevent_action action; // action for the BACK key
+            // screen may only be turned on on ACTION_DOWN
+        } back_or_screen_on;
         struct {
             char *text; // owned, to be freed by free()
             bool paste;

app/src/controller.c

@@ -2,25 +2,27 @@
 
 #include <assert.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;
     }
 
@@ -32,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)) {
@@ -46,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;
 }
 
@@ -73,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);
@@ -102,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;
     }
 
@@ -120,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

@@ -4,21 +4,20 @@
 #include "common.h"
 
 #include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.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/decoder.c

@@ -1,34 +1,11 @@
 #include "decoder.h"
 
 #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 "events.h"
-#include "recorder.h"
 #include "video_buffer.h"
-#include "util/buffer_util.h"
 #include "util/log.h"
 
-// set the decoded frame as ready for rendering, and notify
-static void
-push_frame(struct decoder *decoder) {
-    bool previous_frame_skipped;
-    video_buffer_offer_decoded_frame(decoder->video_buffer,
-                                     &previous_frame_skipped);
-    if (previous_frame_skipped) {
-        // the previous EVENT_NEW_FRAME will consume this frame
-        return;
-    }
-    static SDL_Event new_frame_event = {
-        .type = EVENT_NEW_FRAME,
-    };
-    SDL_PushEvent(&new_frame_event);
-}
-
 void
 decoder_init(struct decoder *decoder, struct video_buffer *vb) {
     decoder->video_buffer = vb;
@@ -68,10 +45,10 @@ decoder_push(struct decoder *decoder, const AVPacket *packet) {
         return false;
     }
     ret = avcodec_receive_frame(decoder->codec_ctx,
-                                decoder->video_buffer->decoding_frame);
+                                decoder->video_buffer->producer_frame);
     if (!ret) {
         // a frame was received
-        push_frame(decoder);
+        video_buffer_producer_offer_frame(decoder->video_buffer);
     } else if (ret != AVERROR(EAGAIN)) {
         LOGE("Could not receive video frame: %d", ret);
         return false;
@@ -79,7 +56,7 @@ decoder_push(struct decoder *decoder, const AVPacket *packet) {
 #else
     int got_picture;
     int len = avcodec_decode_video2(decoder->codec_ctx,
-                                    decoder->video_buffer->decoding_frame,
+                                    decoder->video_buffer->producer_frame,
                                     &got_picture,
                                     packet);
     if (len < 0) {
@@ -87,7 +64,7 @@ decoder_push(struct decoder *decoder, const AVPacket *packet) {
         return false;
     }
     if (got_picture) {
-        push_frame(decoder);
+        video_buffer_producer_offer_frame(decoder->video_buffer);
     }
 #endif
     return true;

app/src/decoder.h

@@ -10,6 +10,7 @@ struct video_buffer;
 
 struct decoder {
     struct video_buffer *video_buffer;
+
     AVCodecContext *codec_ctx;
 };
 

app/src/events.h

@@ -1,3 +1,2 @@
-#define EVENT_NEW_SESSION SDL_USEREVENT
-#define EVENT_NEW_FRAME (SDL_USEREVENT + 1)
-#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 2)
+#define EVENT_NEW_FRAME       SDL_USEREVENT
+#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 1)

app/src/file_handler.c

@@ -4,7 +4,6 @@
 #include <string.h>
 
 #include "adb.h"
-#include "util/lock.h"
 #include "util/log.h"
 
 #define DEFAULT_PUSH_TARGET "/sdcard/"
@@ -20,12 +19,14 @@ 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;
     }
 
@@ -33,8 +34,8 @@ file_handler_init(struct file_handler *file_handler, const char *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 {
@@ -54,8 +55,8 @@ 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);
+    sc_cond_destroy(&file_handler->event_cond);
+    sc_mutex_destroy(&file_handler->mutex);
     free(file_handler->serial);
 
     struct file_handler_request req;
@@ -92,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;
 }
 
@@ -107,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;
@@ -132,7 +133,7 @@ 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", false)) {
@@ -150,13 +151,13 @@ run_file_handler(void *data) {
             }
         }
 
-        mutex_lock(file_handler->mutex);
+        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;
-        mutex_unlock(file_handler->mutex);
+        sc_mutex_unlock(&file_handler->mutex);
 
         file_handler_request_destroy(&req);
     }
@@ -167,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;
     }
@@ -179,18 +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 (!process_terminate(file_handler->current_process)) {
             LOGW("Could not terminate push/install process");
         }
     }
-    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

@@ -4,11 +4,10 @@
 #include "common.h"
 
 #include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
 
 #include "adb.h"
 #include "util/cbuf.h"
+#include "util/thread.h"
 
 typedef enum {
     ACTION_INSTALL_APK,
@@ -25,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;

app/src/fps_counter.c

@@ -3,25 +3,24 @@
 #include <assert.h>
 #include <SDL2/SDL_timer.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
 
@@ -30,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
@@ -77,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();
@@ -90,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;
@@ -124,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
@@ -134,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);
     }
 }
 
@@ -158,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
@@ -171,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

@@ -6,13 +6,15 @@
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.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/input_manager.c

@@ -4,7 +4,6 @@
 #include <SDL2/SDL_keycode.h>
 
 #include "event_converter.h"
-#include "util/lock.h"
 #include "util/log.h"
 
 static const int ACTION_DOWN = 1;
@@ -147,13 +146,25 @@ action_cut(struct controller *controller, int actions) {
 }
 
 // turn the screen on if it was off, press BACK otherwise
+// If the screen is off, it is turned on only on ACTION_DOWN
 static void
-press_back_or_turn_screen_on(struct controller *controller) {
+press_back_or_turn_screen_on(struct controller *controller, int actions) {
     struct control_msg msg;
     msg.type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
 
-    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request 'press back or turn screen on'");
+    if (actions & ACTION_DOWN) {
+        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_DOWN;
+        if (!controller_push_msg(controller, &msg)) {
+            LOGW("Could not request 'press back or turn screen on'");
+            return;
+        }
+    }
+
+    if (actions & ACTION_UP) {
+        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_UP;
+        if (!controller_push_msg(controller, &msg)) {
+            LOGW("Could not request 'press back or turn screen on'");
+        }
     }
 }
 
@@ -287,7 +298,7 @@ rotate_client_right(struct screen *screen) {
     screen_set_rotation(screen, new_rotation);
 }
 
-void
+static void
 input_manager_process_text_input(struct input_manager *im,
                                  const SDL_TextInputEvent *event) {
     if (is_shortcut_mod(im, SDL_GetModState())) {
@@ -367,7 +378,7 @@ convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
     return true;
 }
 
-void
+static void
 input_manager_process_key(struct input_manager *im,
                           const SDL_KeyboardEvent *event) {
     // control: indicates the state of the command-line option --no-control
@@ -481,9 +492,7 @@ input_manager_process_key(struct input_manager *im,
                 return;
             case SDLK_i:
                 if (!shift && !repeat && down) {
-                    struct fps_counter *fps_counter =
-                        im->video_buffer->fps_counter;
-                    switch_fps_counter_state(fps_counter);
+                    switch_fps_counter_state(im->fps_counter);
                 }
                 return;
             case SDLK_n:
@@ -552,7 +561,7 @@ convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
     return true;
 }
 
-void
+static void
 input_manager_process_mouse_motion(struct input_manager *im,
                                    const SDL_MouseMotionEvent *event) {
     if (!event->state) {
@@ -606,7 +615,7 @@ convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
     return true;
 }
 
-void
+static void
 input_manager_process_touch(struct input_manager *im,
                             const SDL_TouchFingerEvent *event) {
     struct control_msg msg;
@@ -638,7 +647,7 @@ convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
     return true;
 }
 
-void
+static void
 input_manager_process_mouse_button(struct input_manager *im,
                                    const SDL_MouseButtonEvent *event) {
     bool control = im->control;
@@ -649,13 +658,15 @@ input_manager_process_mouse_button(struct input_manager *im,
     }
 
     bool down = event->type == SDL_MOUSEBUTTONDOWN;
-    if (!im->forward_all_clicks && down) {
+    if (!im->forward_all_clicks) {
+        int action = down ? ACTION_DOWN : ACTION_UP;
+
         if (control && event->button == SDL_BUTTON_RIGHT) {
-            press_back_or_turn_screen_on(im->controller);
+            press_back_or_turn_screen_on(im->controller, action);
             return;
         }
         if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, ACTION_DOWN | ACTION_UP);
+            action_home(im->controller, action);
             return;
         }
 
@@ -668,7 +679,9 @@ input_manager_process_mouse_button(struct input_manager *im,
             bool outside = x < r->x || x >= r->x + r->w
                         || y < r->y || y >= r->y + r->h;
             if (outside) {
-                screen_resize_to_fit(im->screen);
+                if (down) {
+                    screen_resize_to_fit(im->screen);
+                }
                 return;
             }
         }
@@ -737,7 +750,7 @@ convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
     return true;
 }
 
-void
+static void
 input_manager_process_mouse_wheel(struct input_manager *im,
                                   const SDL_MouseWheelEvent *event) {
     struct control_msg msg;
@@ -747,3 +760,46 @@ input_manager_process_mouse_wheel(struct input_manager *im,
         }
     }
 }
+
+bool
+input_manager_handle_event(struct input_manager *im, SDL_Event *event) {
+    switch (event->type) {
+        case SDL_TEXTINPUT:
+            if (!im->control) {
+                return true;
+            }
+            input_manager_process_text_input(im, &event->text);
+            return true;
+        case SDL_KEYDOWN:
+        case SDL_KEYUP:
+            // some key events do not interact with the device, so process the
+            // event even if control is disabled
+            input_manager_process_key(im, &event->key);
+            return true;
+        case SDL_MOUSEMOTION:
+            if (!im->control) {
+                break;
+            }
+            input_manager_process_mouse_motion(im, &event->motion);
+            return true;
+        case SDL_MOUSEWHEEL:
+            if (!im->control) {
+                break;
+            }
+            input_manager_process_mouse_wheel(im, &event->wheel);
+            return true;
+        case SDL_MOUSEBUTTONDOWN:
+        case SDL_MOUSEBUTTONUP:
+            // some mouse events do not interact with the device, so process
+            // the event even if control is disabled
+            input_manager_process_mouse_button(im, &event->button);
+            return true;
+        case SDL_FINGERMOTION:
+        case SDL_FINGERDOWN:
+        case SDL_FINGERUP:
+            input_manager_process_touch(im, &event->tfinger);
+            return true;
+    }
+
+    return false;
+}

app/src/input_manager.h

@@ -11,11 +11,10 @@
 #include "fps_counter.h"
 #include "scrcpy.h"
 #include "screen.h"
-#include "video_buffer.h"
 
 struct input_manager {
     struct controller *controller;
-    struct video_buffer *video_buffer;
+    struct fps_counter *fps_counter;
     struct screen *screen;
 
     // SDL reports repeated events as a boolean, but Android expects the actual
@@ -40,28 +39,7 @@ void
 input_manager_init(struct input_manager *im,
                    const struct scrcpy_options *options);
 
-void
-input_manager_process_text_input(struct input_manager *im,
-                                 const SDL_TextInputEvent *event);
-
-void
-input_manager_process_key(struct input_manager *im,
-                          const SDL_KeyboardEvent *event);
-
-void
-input_manager_process_mouse_motion(struct input_manager *im,
-                                   const SDL_MouseMotionEvent *event);
-
-void
-input_manager_process_touch(struct input_manager *im,
-                            const SDL_TouchFingerEvent *event);
-
-void
-input_manager_process_mouse_button(struct input_manager *im,
-                                   const SDL_MouseButtonEvent *event);
-
-void
-input_manager_process_mouse_wheel(struct input_manager *im,
-                                  const SDL_MouseWheelEvent *event);
+bool
+input_manager_handle_event(struct input_manager *im, SDL_Event *event);
 
 #endif

app/src/receiver.c

@@ -4,12 +4,12 @@
 #include <SDL2/SDL_clipboard.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;
@@ -18,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
@@ -101,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;
     }
@@ -112,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

@@ -4,17 +4,16 @@
 #include "common.h"
 
 #include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.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,7 +3,6 @@
 #include <assert.h>
 #include <libavutil/time.h>
 
-#include "util/lock.h"
 #include "util/log.h"
 
 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
@@ -69,17 +68,17 @@ recorder_init(struct recorder *recorder,
         return false;
     }
 
-    recorder->mutex = SDL_CreateMutex();
-    if (!recorder->mutex) {
+    bool ok = sc_mutex_init(&recorder->mutex);
+    if (!ok) {
         LOGC("Could not create mutex");
         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);
+        sc_mutex_destroy(&recorder->mutex);
         free(recorder->filename);
         return false;
     }
@@ -97,8 +96,8 @@ recorder_init(struct recorder *recorder,
 
 void
 recorder_destroy(struct recorder *recorder) {
-    SDL_DestroyCond(recorder->queue_cond);
-    SDL_DestroyMutex(recorder->mutex);
+    sc_cond_destroy(&recorder->queue_cond);
+    sc_mutex_destroy(&recorder->mutex);
     free(recorder->filename);
 }
 
@@ -229,7 +228,7 @@ recorder_rescale_packet(struct recorder *recorder, AVPacket *packet) {
     av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
 }
 
-bool
+static bool
 recorder_write(struct recorder *recorder, AVPacket *packet) {
     if (!recorder->header_written) {
         if (packet->pts != AV_NOPTS_VALUE) {
@@ -258,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
@@ -288,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;
@@ -311,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;
         }
 
@@ -330,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;
     }
@@ -341,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

@@ -5,12 +5,11 @@
 
 #include <stdbool.h>
 #include <libavformat/avformat.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
 
 #include "coords.h"
 #include "scrcpy.h"
 #include "util/queue.h"
+#include "util/thread.h"
 
 struct record_packet {
     AVPacket packet;
@@ -26,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

@@ -26,12 +26,11 @@
 #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;
-static struct screen screen = SCREEN_INITIALIZER;
+static struct screen screen;
 static struct fps_counter fps_counter;
 static struct video_buffer video_buffer;
 static struct stream stream;
@@ -42,7 +41,7 @@ static struct file_handler file_handler;
 
 static struct input_manager input_manager = {
     .controller = &controller,
-    .video_buffer = &video_buffer,
+    .fps_counter = &fps_counter,
     .screen = &screen,
     .repeat = 0,
 
@@ -129,30 +128,6 @@ sdl_init_and_configure(bool display, const char *render_driver,
     return true;
 }
 
-
-#if defined(__APPLE__) || defined(__WINDOWS__)
-# define CONTINUOUS_RESIZING_WORKAROUND
-#endif
-
-#ifdef CONTINUOUS_RESIZING_WORKAROUND
-// On Windows and MacOS, resizing blocks the event loop, so resizing events are
-// not triggered. As a workaround, handle them in an event handler.
-//
-// <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
-// <https://stackoverflow.com/a/40693139/1987178>
-static int
-event_watcher(void *data, SDL_Event *event) {
-    (void) data;
-    if (event->type == SDL_WINDOWEVENT
-            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
-        // In practice, it seems to always be called from the same thread in
-        // that specific case. Anyway, it's just a workaround.
-        screen_render(&screen, true);
-    }
-    return 0;
-}
-#endif
-
 static bool
 is_apk(const char *file) {
     const char *ext = strrchr(file, '.');
@@ -174,78 +149,42 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
         case SDL_QUIT:
             LOGD("User requested to quit");
             return EVENT_RESULT_STOPPED_BY_USER;
-        case EVENT_NEW_FRAME:
-            if (!screen.has_frame) {
-                screen.has_frame = true;
-                // this is the very first frame, show the window
-                screen_show_window(&screen);
-            }
-            if (!screen_update_frame(&screen, &video_buffer)) {
-                return EVENT_RESULT_CONTINUE;
-            }
-            break;
-        case SDL_WINDOWEVENT:
-            screen_handle_window_event(&screen, &event->window);
-            break;
-        case SDL_TEXTINPUT:
-            if (!options->control) {
-                break;
-            }
-            input_manager_process_text_input(&input_manager, &event->text);
-            break;
-        case SDL_KEYDOWN:
-        case SDL_KEYUP:
-            // some key events do not interact with the device, so process the
-            // event even if control is disabled
-            input_manager_process_key(&input_manager, &event->key);
-            break;
-        case SDL_MOUSEMOTION:
-            if (!options->control) {
-                break;
-            }
-            input_manager_process_mouse_motion(&input_manager, &event->motion);
-            break;
-        case SDL_MOUSEWHEEL:
-            if (!options->control) {
-                break;
-            }
-            input_manager_process_mouse_wheel(&input_manager, &event->wheel);
-            break;
-        case SDL_MOUSEBUTTONDOWN:
-        case SDL_MOUSEBUTTONUP:
-            // some mouse events do not interact with the device, so process
-            // the event even if control is disabled
-            input_manager_process_mouse_button(&input_manager, &event->button);
-            break;
-        case SDL_FINGERMOTION:
-        case SDL_FINGERDOWN:
-        case SDL_FINGERUP:
-            input_manager_process_touch(&input_manager, &event->tfinger);
-            break;
         case SDL_DROPFILE: {
             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);
-            break;
+            file_handler_request(&file_handler, action, file);
+            goto end;
         }
     }
+
+    bool consumed = screen_handle_event(&screen, event);
+    if (consumed) {
+        goto end;
+    }
+
+    consumed = input_manager_handle_event(&input_manager, event);
+    (void) consumed;
+
+end:
     return EVENT_RESULT_CONTINUE;
 }
 
 static bool
 event_loop(const struct scrcpy_options *options) {
-#ifdef CONTINUOUS_RESIZING_WORKAROUND
-    if (options->display) {
-        SDL_AddEventWatch(event_watcher, NULL);
-    }
-#endif
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         enum event_result result = handle_event(&event, options);
@@ -314,6 +253,7 @@ scrcpy(const struct scrcpy_options *options) {
     bool stream_started = false;
     bool controller_initialized = false;
     bool controller_started = false;
+    bool screen_initialized = false;
 
     bool record = !!options->record_filename;
     struct server_params params = {
@@ -331,6 +271,7 @@ scrcpy(const struct scrcpy_options *options) {
         .codec_options = options->codec_options,
         .encoder_name = options->encoder_name,
         .force_adb_forward = options->force_adb_forward,
+        .power_off_on_close = options->power_off_on_close,
     };
     if (!server_start(&server, options->serial, &params)) {
         goto end;
@@ -364,8 +305,7 @@ scrcpy(const struct scrcpy_options *options) {
         }
         fps_counter_initialized = true;
 
-        if (!video_buffer_init(&video_buffer, &fps_counter,
-                               options->render_expired_frames)) {
+        if (!video_buffer_init(&video_buffer, options->render_expired_frames)) {
             goto end;
         }
         video_buffer_initialized = true;
@@ -398,13 +338,6 @@ scrcpy(const struct scrcpy_options *options) {
 
     stream_init(&stream, server.video_socket, dec, rec);
 
-    // now we consumed the header values, the socket receives the video stream
-    // start the stream
-    if (!stream_start(&stream)) {
-        goto end;
-    }
-    stream_started = true;
-
     if (options->display) {
         if (options->control) {
             if (!controller_init(&controller, server.control_socket)) {
@@ -421,14 +354,25 @@ scrcpy(const struct scrcpy_options *options) {
         const char *window_title =
             options->window_title ? options->window_title : device_name;
 
-        if (!screen_init_rendering(&screen, window_title, frame_size,
-                                   options->always_on_top, options->window_x,
-                                   options->window_y, options->window_width,
-                                   options->window_height,
-                                   options->window_borderless,
-                                   options->rotation, options->mipmaps)) {
+        struct screen_params screen_params = {
+            .window_title = window_title,
+            .frame_size = frame_size,
+            .always_on_top = options->always_on_top,
+            .window_x = options->window_x,
+            .window_y = options->window_y,
+            .window_width = options->window_width,
+            .window_height = options->window_height,
+            .window_borderless = options->window_borderless,
+            .rotation = options->rotation,
+            .mipmaps = options->mipmaps,
+            .fullscreen = options->fullscreen,
+        };
+
+        if (!screen_init(&screen, &video_buffer, &fps_counter,
+                         &screen_params)) {
             goto end;
         }
+        screen_initialized = true;
 
         if (options->turn_screen_off) {
             struct control_msg msg;
@@ -439,19 +383,20 @@ scrcpy(const struct scrcpy_options *options) {
                 LOGW("Could not request 'set screen power mode'");
             }
         }
-
-        if (options->fullscreen) {
-            screen_switch_fullscreen(&screen);
-        }
     }
 
+    // now we consumed the header values, the socket receives the video stream
+    // start the stream
+    if (!stream_start(&stream)) {
+        goto end;
+    }
+    stream_started = true;
+
     input_manager_init(&input_manager, options);
 
     ret = event_loop(options);
     LOGD("quit...");
 
-    screen_destroy(&screen);
-
 end:
     // stop stream and controller so that they don't continue once their socket
     // is shutdown
@@ -478,6 +423,13 @@ end:
     if (stream_started) {
         stream_join(&stream);
     }
+
+    // Destroy the screen only after the stream is guaranteed to be finished,
+    // because otherwise the screen could receive new frames after destruction
+    if (screen_initialized) {
+        screen_destroy(&screen);
+    }
+
     if (controller_started) {
         controller_join(&controller);
     }

app/src/scrcpy.h

@@ -82,6 +82,7 @@ struct scrcpy_options {
     bool forward_key_repeat;
     bool forward_all_clicks;
     bool legacy_paste;
+    bool power_off_on_close;
 };
 
 #define SCRCPY_OPTIONS_DEFAULT { \
@@ -103,10 +104,10 @@ struct scrcpy_options {
         .data = {SC_MOD_LALT, SC_MOD_LSUPER}, \
         .count = 2, \
     }, \
-    .max_size = DEFAULT_MAX_SIZE, \
+    .max_size = 0, \
     .bit_rate = DEFAULT_BIT_RATE, \
     .max_fps = 0, \
-    .lock_video_orientation = DEFAULT_LOCK_VIDEO_ORIENTATION, \
+    .lock_video_orientation = -1, \
     .rotation = 0, \
     .window_x = SC_WINDOW_POSITION_UNDEFINED, \
     .window_y = SC_WINDOW_POSITION_UNDEFINED, \
@@ -129,6 +130,7 @@ struct scrcpy_options {
     .forward_key_repeat = true, \
     .forward_all_clicks = false, \
     .legacy_paste = false, \
+    .power_off_on_close = false, \
 }
 
 bool

app/src/screen.c

@@ -4,11 +4,11 @@
 #include <string.h>
 #include <SDL2/SDL.h>
 
+#include "events.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
@@ -191,9 +191,25 @@ screen_update_content_rect(struct screen *screen) {
     }
 }
 
-void
-screen_init(struct screen *screen) {
-    *screen = (struct screen) SCREEN_INITIALIZER;
+static void
+on_frame_available(struct video_buffer *vb, void *userdata) {
+    (void) vb;
+    (void) userdata;
+
+    static SDL_Event new_frame_event = {
+        .type = EVENT_NEW_FRAME,
+    };
+
+    // Post the event on the UI thread
+    SDL_PushEvent(&new_frame_event);
+}
+
+static void
+on_frame_skipped(struct video_buffer *vb, void *userdata) {
+    (void) vb;
+
+    struct screen *screen = userdata;
+    fps_counter_add_skipped_frame(screen->fps_counter);
 }
 
 static inline SDL_Texture *
@@ -223,27 +239,63 @@ create_texture(struct screen *screen) {
     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) {
-    screen->frame_size = frame_size;
-    screen->rotation = rotation;
-    if (rotation) {
-        LOGI("Initial display rotation set to %u", rotation);
+#if defined(__APPLE__) || defined(__WINDOWS__)
+# define CONTINUOUS_RESIZING_WORKAROUND
+#endif
+
+#ifdef CONTINUOUS_RESIZING_WORKAROUND
+// On Windows and MacOS, resizing blocks the event loop, so resizing events are
+// not triggered. As a workaround, handle them in an event handler.
+//
+// <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
+// <https://stackoverflow.com/a/40693139/1987178>
+static int
+event_watcher(void *data, SDL_Event *event) {
+    struct screen *screen = data;
+    if (event->type == SDL_WINDOWEVENT
+            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
+        // In practice, it seems to always be called from the same thread in
+        // that specific case. Anyway, it's just a workaround.
+        screen_render(screen, true);
     }
-    struct size content_size = get_rotated_size(frame_size, screen->rotation);
+    return 0;
+}
+#endif
+
+bool
+screen_init(struct screen *screen, struct video_buffer *vb,
+            struct fps_counter *fps_counter,
+            const struct screen_params *params) {
+    screen->vb = vb;
+    screen->fps_counter = fps_counter;
+
+    screen->resize_pending = false;
+    screen->has_frame = false;
+    screen->fullscreen = false;
+    screen->maximized = false;
+
+    static const struct video_buffer_callbacks cbs = {
+        .on_frame_available = on_frame_available,
+        .on_frame_skipped = on_frame_skipped,
+    };
+    video_buffer_set_consumer_callbacks(vb, &cbs, screen);
+
+    screen->frame_size = params->frame_size;
+    screen->rotation = params->rotation;
+    if (screen->rotation) {
+        LOGI("Initial display rotation set to %u", screen->rotation);
+    }
+    struct size content_size =
+        get_rotated_size(screen->frame_size, screen->rotation);
     screen->content_size = content_size;
 
-    struct size window_size =
-        get_initial_optimal_size(content_size, window_width, window_height);
-    uint32_t window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
-#ifdef HIDPI_SUPPORT
-    window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
-#endif
-    if (always_on_top) {
+    struct size window_size = get_initial_optimal_size(content_size,
+                                                       params->window_width,
+                                                       params->window_height);
+    uint32_t window_flags = SDL_WINDOW_HIDDEN
+                          | SDL_WINDOW_RESIZABLE
+                          | SDL_WINDOW_ALLOW_HIGHDPI;
+    if (params->always_on_top) {
 #ifdef SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
         window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
 #else
@@ -251,15 +303,15 @@ screen_init_rendering(struct screen *screen, const char *window_title,
              "(compile with SDL >= 2.0.5 to enable it)");
 #endif
     }
-    if (window_borderless) {
+    if (params->window_borderless) {
         window_flags |= SDL_WINDOW_BORDERLESS;
     }
 
-    int x = window_x != SC_WINDOW_POSITION_UNDEFINED
-          ? window_x : (int) SDL_WINDOWPOS_UNDEFINED;
-    int y = window_y != SC_WINDOW_POSITION_UNDEFINED
-          ? window_y : (int) SDL_WINDOWPOS_UNDEFINED;
-    screen->window = SDL_CreateWindow(window_title, x, y,
+    int x = params->window_x != SC_WINDOW_POSITION_UNDEFINED
+          ? params->window_x : (int) SDL_WINDOWPOS_UNDEFINED;
+    int y = params->window_y != SC_WINDOW_POSITION_UNDEFINED
+          ? params->window_y : (int) SDL_WINDOWPOS_UNDEFINED;
+    screen->window = SDL_CreateWindow(params->window_title, x, y,
                                       window_size.width, window_size.height,
                                       window_flags);
     if (!screen->window) {
@@ -271,7 +323,7 @@ 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;
     }
 
@@ -280,15 +332,17 @@ screen_init_rendering(struct screen *screen, const char *window_title,
     const char *renderer_name = r ? NULL : renderer_info.name;
     LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
 
+    screen->mipmaps = false;
+
     // starts with "opengl"
-    screen->use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (screen->use_opengl) {
+    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
+    if (use_opengl) {
         struct sc_opengl *gl = &screen->gl;
         sc_opengl_init(gl);
 
         LOGI("OpenGL version: %s", gl->version);
 
-        if (mipmaps) {
+        if (params->mipmaps) {
             bool supports_mipmaps =
                 sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
                                                2, 0  /* OpenGL ES 2.0+ */);
@@ -302,7 +356,7 @@ screen_init_rendering(struct screen *screen, const char *window_title,
         } else {
             LOGI("Trilinear filtering disabled");
         }
-    } else {
+    } else if (params->mipmaps) {
         LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
     }
 
@@ -314,12 +368,13 @@ 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);
+    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, params->frame_size.width,
+                                                  params->frame_size.height);
     screen->texture = create_texture(screen);
     if (!screen->texture) {
         LOGC("Could not create texture: %s", SDL_GetError());
-        screen_destroy(screen);
+        SDL_DestroyRenderer(screen->renderer);
+        SDL_DestroyWindow(screen->window);
         return false;
     }
 
@@ -330,25 +385,27 @@ screen_init_rendering(struct screen *screen, const char *window_title,
 
     screen_update_content_rect(screen);
 
+    if (params->fullscreen) {
+        screen_switch_fullscreen(screen);
+    }
+
+#ifdef CONTINUOUS_RESIZING_WORKAROUND
+    SDL_AddEventWatch(event_watcher, screen);
+#endif
+
     return true;
 }
 
-void
+static void
 screen_show_window(struct screen *screen) {
     SDL_ShowWindow(screen->window);
 }
 
 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);
-    }
+    SDL_DestroyTexture(screen->texture);
+    SDL_DestroyRenderer(screen->renderer);
+    SDL_DestroyWindow(screen->window);
 }
 
 static void
@@ -445,24 +502,23 @@ update_texture(struct screen *screen, const AVFrame *frame) {
             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);
+static bool
+screen_update_frame(struct screen *screen) {
+    const AVFrame *frame = video_buffer_consumer_take_frame(screen->vb);
+
+    fps_counter_add_rendered_frame(screen->fps_counter);
+
     struct size new_frame_size = {frame->width, frame->height};
     if (!prepare_for_frame(screen, new_frame_size)) {
-        mutex_unlock(vb->mutex);
         return false;
     }
     update_texture(screen, frame);
-    mutex_unlock(vb->mutex);
 
     screen_render(screen, false);
     return true;
@@ -549,31 +605,52 @@ screen_resize_to_pixel_perfect(struct screen *screen) {
                                             content_size.height);
 }
 
-void
-screen_handle_window_event(struct screen *screen,
-                           const SDL_WindowEvent *event) {
-    switch (event->event) {
-        case SDL_WINDOWEVENT_EXPOSED:
-            screen_render(screen, true);
-            break;
-        case SDL_WINDOWEVENT_SIZE_CHANGED:
-            screen_render(screen, true);
-            break;
-        case SDL_WINDOWEVENT_MAXIMIZED:
-            screen->maximized = true;
-            break;
-        case SDL_WINDOWEVENT_RESTORED:
-            if (screen->fullscreen) {
-                // On Windows, in maximized+fullscreen, disabling fullscreen
-                // mode unexpectedly triggers the "restored" then "maximized"
-                // events, leaving the window in a weird state (maximized
-                // according to the events, but not maximized visually).
-                break;
+bool
+screen_handle_event(struct screen *screen, SDL_Event *event) {
+    switch (event->type) {
+        case EVENT_NEW_FRAME:
+            if (!screen->has_frame) {
+                screen->has_frame = true;
+                // this is the very first frame, show the window
+                screen_show_window(screen);
             }
-            screen->maximized = false;
-            apply_pending_resize(screen);
-            break;
+            bool ok = screen_update_frame(screen);
+            if (!ok) {
+                LOGW("Frame update failed\n");
+            }
+            return true;
+        case SDL_WINDOWEVENT:
+            if (!screen->has_frame) {
+                // Do nothing
+                return true;
+            }
+            switch (event->window.event) {
+                case SDL_WINDOWEVENT_EXPOSED:
+                    screen_render(screen, true);
+                    break;
+                case SDL_WINDOWEVENT_SIZE_CHANGED:
+                    screen_render(screen, true);
+                    break;
+                case SDL_WINDOWEVENT_MAXIMIZED:
+                    screen->maximized = true;
+                    break;
+                case SDL_WINDOWEVENT_RESTORED:
+                    if (screen->fullscreen) {
+                        // On Windows, in maximized+fullscreen, disabling
+                        // fullscreen mode unexpectedly triggers the "restored"
+                        // then "maximized" events, leaving the window in a
+                        // weird state (maximized according to the events, but
+                        // not maximized visually).
+                        break;
+                    }
+                    screen->maximized = false;
+                    apply_pending_resize(screen);
+                    break;
+            }
+            return true;
     }
+
+    return false;
 }
 
 struct point

app/src/screen.h

@@ -13,10 +13,12 @@
 struct video_buffer;
 
 struct screen {
+    struct video_buffer *vb;
+    struct fps_counter *fps_counter;
+
     SDL_Window *window;
     SDL_Renderer *renderer;
     SDL_Texture *texture;
-    bool use_opengl;
     struct sc_opengl gl;
     struct size frame_size;
     struct size content_size; // rotated frame_size
@@ -33,68 +35,37 @@ struct screen {
     bool has_frame;
     bool fullscreen;
     bool maximized;
-    bool no_window;
     bool mipmaps;
 };
 
-#define SCREEN_INITIALIZER { \
-    .window = NULL, \
-    .renderer = NULL, \
-    .texture = NULL, \
-    .use_opengl = false, \
-    .gl = {0}, \
-    .frame_size = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
-    .content_size = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
-    .resize_pending = false, \
-    .windowed_content_size = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
-    .rotation = 0, \
-    .rect = { \
-        .x = 0, \
-        .y = 0, \
-        .w = 0, \
-        .h = 0, \
-    }, \
-    .has_frame = false, \
-    .fullscreen = false, \
-    .maximized = false, \
-    .no_window = false, \
-    .mipmaps = false, \
-}
+struct screen_params {
+    const char *window_title;
+    struct size frame_size;
+    bool always_on_top;
 
-// initialize default values
-void
-screen_init(struct screen *screen);
+    int16_t window_x;
+    int16_t window_y;
+    uint16_t window_width;  // accepts SC_WINDOW_POSITION_UNDEFINED
+    uint16_t window_height; // accepts SC_WINDOW_POSITION_UNDEFINED
+
+    bool window_borderless;
+
+    uint8_t rotation;
+    bool mipmaps;
+
+    bool fullscreen;
+};
 
 // initialize screen, create window, renderer and texture (window is hidden)
-// window_x and window_y accept SC_WINDOW_POSITION_UNDEFINED
 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);
-
-// show the window
-void
-screen_show_window(struct screen *screen);
+screen_init(struct screen *screen, struct video_buffer *vb,
+            struct fps_counter *fps_counter,
+            const struct screen_params *params);
 
 // destroy window, renderer and texture (if any)
 void
 screen_destroy(struct screen *screen);
 
-// resize if necessary and write the rendered frame into the texture
-bool
-screen_update_frame(struct screen *screen, struct video_buffer *vb);
-
 // render the texture to the renderer
 //
 // Set the update_content_rect flag if the window or content size may have
@@ -118,9 +89,9 @@ screen_resize_to_pixel_perfect(struct screen *screen);
 void
 screen_set_rotation(struct screen *screen, unsigned rotation);
 
-// react to window events
-void
-screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);
+// react to SDL events
+bool
+screen_handle_event(struct screen *screen, SDL_Event *event);
 
 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels

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 "adb.h"
-#include "util/lock.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/str_util.h"
@@ -295,6 +293,7 @@ execute_server(struct server *server, const struct server_params *params) {
         params->stay_awake ? "true" : "false",
         params->codec_options ? params->codec_options : "-",
         params->encoder_name ? params->encoder_name : "-",
+        params->power_off_on_close ? "true" : "false",
     };
 #ifdef SERVER_DEBUGGER
     LOGI("Server debugger waiting for a client on device port "
@@ -357,18 +356,17 @@ bool
 server_init(struct server *server) {
     server->serial = NULL;
     server->process = PROCESS_NONE;
-    server->wait_server_thread = NULL;
     atomic_flag_clear_explicit(&server->server_socket_closed,
                                memory_order_relaxed);
 
-    server->mutex = SDL_CreateMutex();
-    if (!server->mutex) {
+    bool ok = sc_mutex_init(&server->mutex);
+    if (!ok) {
         return false;
     }
 
-    server->process_terminated_cond = SDL_CreateCond();
-    if (!server->process_terminated_cond) {
-        SDL_DestroyMutex(server->mutex);
+    ok = sc_cond_init(&server->process_terminated_cond);
+    if (!ok) {
+        sc_mutex_destroy(&server->mutex);
         return false;
     }
 
@@ -378,8 +376,6 @@ server_init(struct server *server) {
     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;
@@ -393,10 +389,10 @@ run_wait_server(void *data) {
     struct server *server = data;
     process_wait(server->process, false); // ignore exit code
 
-    mutex_lock(server->mutex);
+    sc_mutex_lock(&server->mutex);
     server->process_terminated = true;
-    cond_signal(server->process_terminated_cond);
-    mutex_unlock(server->mutex);
+    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
@@ -413,8 +409,6 @@ run_wait_server(void *data) {
 bool
 server_start(struct server *server, const char *serial,
              const struct server_params *params) {
-    server->port_range = params->port_range;
-
     if (serial) {
         server->serial = strdup(serial);
         if (!server->serial) {
@@ -443,9 +437,9 @@ 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) {
+    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;
@@ -535,33 +529,33 @@ server_stop(struct server *server) {
     }
 
     // Give some delay for the server to terminate properly
-    mutex_lock(server->mutex);
-    int r = 0;
+    sc_mutex_lock(&server->mutex);
+    bool signaled = false;
     if (!server->process_terminated) {
 #define WATCHDOG_DELAY_MS 1000
-        r = cond_wait_timeout(server->process_terminated_cond,
-                              server->mutex,
-                              WATCHDOG_DELAY_MS);
+        signaled = sc_cond_timedwait(&server->process_terminated_cond,
+                                     &server->mutex,
+                                     WATCHDOG_DELAY_MS);
     }
-    mutex_unlock(server->mutex);
+    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 (r == SDL_MUTEX_TIMEDOUT) {
+    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);
     }
 
-    SDL_WaitThread(server->wait_server_thread, NULL);
+    sc_thread_join(&server->wait_server_thread, NULL);
     process_close(server->process);
 }
 
 void
 server_destroy(struct server *server) {
     free(server->serial);
-    SDL_DestroyCond(server->process_terminated_cond);
-    SDL_DestroyMutex(server->mutex);
+    sc_cond_destroy(&server->process_terminated_cond);
+    sc_mutex_destroy(&server->mutex);
 }

app/src/server.h

@@ -6,27 +6,26 @@
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL2/SDL_thread.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;
 
-    SDL_mutex *mutex;
-    SDL_cond *process_terminated_cond;
+    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;
-    struct sc_port_range port_range;
     uint16_t local_port; // selected from port_range
     bool tunnel_enabled;
     bool tunnel_forward; // use "adb forward" instead of "adb reverse"
@@ -47,6 +46,7 @@ struct server_params {
     bool show_touches;
     bool stay_awake;
     bool force_adb_forward;
+    bool power_off_on_close;
 };
 
 // init default values

app/src/stream.c

@@ -4,8 +4,6 @@
 #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 "decoder.h"
@@ -279,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;
     }
@@ -296,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

@@ -7,15 +7,13 @@
 #include <stdint.h>
 #include <libavformat/avformat.h>
 #include <SDL2/SDL_atomic.h>
-#include <SDL2/SDL_thread.h>
 
 #include "util/net.h"
-
-struct video_buffer;
+#include "util/thread.h"
 
 struct stream {
     socket_t socket;
-    SDL_Thread *thread;
+    sc_thread thread;
     struct decoder *decoder;
     struct recorder *recorder;
     AVCodecContext *codec_ctx;

app/src/util/lock.h

@@ -1,75 +0,0 @@
-#ifndef LOCK_H
-#define LOCK_H
-
-#include "common.h"
-
-#include <stdint.h>
-#include <SDL2/SDL_mutex.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/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,112 +1,147 @@
 #include "video_buffer.h"
 
 #include <assert.h>
-#include <SDL2/SDL_mutex.h>
 #include <libavutil/avutil.h>
 #include <libavformat/avformat.h>
 
-#include "util/lock.h"
 #include "util/log.h"
 
 bool
-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())) {
+video_buffer_init(struct video_buffer *vb, bool wait_consumer) {
+    vb->producer_frame = av_frame_alloc();
+    if (!vb->producer_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->consumer_frame = av_frame_alloc();
+    if (!vb->consumer_frame) {
         goto error_2;
     }
 
-    vb->render_expired_frames = render_expired_frames;
-    if (render_expired_frames) {
-        if (!(vb->rendering_frame_consumed_cond = SDL_CreateCond())) {
-            SDL_DestroyMutex(vb->mutex);
+    bool ok = sc_mutex_init(&vb->mutex);
+    if (!ok) {
+        goto error_3;
+    }
+
+    vb->wait_consumer = wait_consumer;
+    if (wait_consumer) {
+        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
-        // since offering a frame will never block
+        // interrupted is not used if wait_consumer is disabled since offering
+        // a frame will never block
         vb->interrupted = false;
     }
 
-    // there is initially no rendering frame, so consider it has already been
-    // consumed
-    vb->rendering_frame_consumed = true;
+    // there is initially no frame, so consider it has already been consumed
+    vb->pending_frame_consumed = true;
+
+    // The callbacks must be set by the consumer via
+    // video_buffer_set_consumer_callbacks()
+    vb->cbs = NULL;
 
     return true;
 
+error_3:
+    av_frame_free(&vb->consumer_frame);
 error_2:
-    av_frame_free(&vb->rendering_frame);
+    av_frame_free(&vb->pending_frame);
 error_1:
-    av_frame_free(&vb->decoding_frame);
+    av_frame_free(&vb->producer_frame);
 error_0:
     return false;
 }
 
 void
 video_buffer_destroy(struct video_buffer *vb) {
-    if (vb->render_expired_frames) {
-        SDL_DestroyCond(vb->rendering_frame_consumed_cond);
+    if (vb->wait_consumer) {
+        sc_cond_destroy(&vb->pending_frame_consumed_cond);
     }
-    SDL_DestroyMutex(vb->mutex);
-    av_frame_free(&vb->rendering_frame);
-    av_frame_free(&vb->decoding_frame);
+    sc_mutex_destroy(&vb->mutex);
+    av_frame_free(&vb->consumer_frame);
+    av_frame_free(&vb->pending_frame);
+    av_frame_free(&vb->producer_frame);
 }
 
-static void
-video_buffer_swap_frames(struct video_buffer *vb) {
-    AVFrame *tmp = vb->decoding_frame;
-    vb->decoding_frame = vb->rendering_frame;
-    vb->rendering_frame = tmp;
+static inline void
+swap_frames(AVFrame **lhs, AVFrame **rhs) {
+    AVFrame *tmp = *lhs;
+    *lhs = *rhs;
+    *rhs = tmp;
 }
 
 void
-video_buffer_offer_decoded_frame(struct video_buffer *vb,
-                                 bool *previous_frame_skipped) {
-    mutex_lock(vb->mutex);
-    if (vb->render_expired_frames) {
+video_buffer_set_consumer_callbacks(struct video_buffer *vb,
+                                    const struct video_buffer_callbacks *cbs,
+                                    void *cbs_userdata) {
+    assert(!vb->cbs); // must be set only once
+    assert(cbs);
+    assert(cbs->on_frame_available);
+    vb->cbs = cbs;
+    vb->cbs_userdata = cbs_userdata;
+}
+
+void
+video_buffer_producer_offer_frame(struct video_buffer *vb) {
+    assert(vb->cbs);
+
+    sc_mutex_lock(&vb->mutex);
+    if (vb->wait_consumer) {
         // 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) {
-        fps_counter_add_skipped_frame(vb->fps_counter);
     }
 
-    video_buffer_swap_frames(vb);
+    av_frame_unref(vb->pending_frame);
+    swap_frames(&vb->producer_frame, &vb->pending_frame);
 
-    *previous_frame_skipped = !vb->rendering_frame_consumed;
-    vb->rendering_frame_consumed = false;
+    bool skipped = !vb->pending_frame_consumed;
+    vb->pending_frame_consumed = false;
 
-    mutex_unlock(vb->mutex);
+    sc_mutex_unlock(&vb->mutex);
+
+    if (skipped) {
+        if (vb->cbs->on_frame_skipped)
+            vb->cbs->on_frame_skipped(vb, vb->cbs_userdata);
+    } else {
+        vb->cbs->on_frame_available(vb, vb->cbs_userdata);
+    }
 }
 
 const AVFrame *
-video_buffer_consume_rendered_frame(struct video_buffer *vb) {
-    assert(!vb->rendering_frame_consumed);
-    vb->rendering_frame_consumed = true;
-    fps_counter_add_rendered_frame(vb->fps_counter);
-    if (vb->render_expired_frames) {
+video_buffer_consumer_take_frame(struct video_buffer *vb) {
+    sc_mutex_lock(&vb->mutex);
+    assert(!vb->pending_frame_consumed);
+    vb->pending_frame_consumed = true;
+
+    swap_frames(&vb->consumer_frame, &vb->pending_frame);
+    av_frame_unref(vb->pending_frame);
+
+    if (vb->wait_consumer) {
         // unblock video_buffer_offer_decoded_frame()
-        cond_signal(vb->rendering_frame_consumed_cond);
+        sc_cond_signal(&vb->pending_frame_consumed_cond);
     }
-    return vb->rendering_frame;
+    sc_mutex_unlock(&vb->mutex);
+
+    // consumer_frame is only written from this thread, no need to lock
+    return vb->consumer_frame;
 }
 
 void
 video_buffer_interrupt(struct video_buffer *vb) {
-    if (vb->render_expired_frames) {
-        mutex_lock(vb->mutex);
+    if (vb->wait_consumer) {
+        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

@@ -4,44 +4,76 @@
 #include "common.h"
 
 #include <stdbool.h>
-#include <SDL2/SDL_mutex.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 producer (producer_frame)
+ *  - one frame is held by the consumer (consumer_frame)
+ *  - one frame is shared between the producer and the consumer (pending_frame)
+ *
+ * The producer generates a frame into the producer_frame (it may takes time).
+ *
+ * Once the frame is produced, it calls video_buffer_producer_offer_frame(),
+ * which swaps the producer and pending frames.
+ *
+ * When the consumer is notified that a new frame is available, it calls
+ * video_buffer_consumer_take_frame() to retrieve it, which swaps the pending
+ * and consumer frames. The frame is valid until the next call, without
+ * blocking the producer.
+ */
+
 struct video_buffer {
-    AVFrame *decoding_frame;
-    AVFrame *rendering_frame;
-    SDL_mutex *mutex;
-    bool render_expired_frames;
+    AVFrame *producer_frame;
+    AVFrame *pending_frame;
+    AVFrame *consumer_frame;
+
+    sc_mutex mutex;
+    bool wait_consumer; // never overwrite a pending frame if it is not consumed
     bool interrupted;
-    SDL_cond *rendering_frame_consumed_cond;
-    bool rendering_frame_consumed;
-    struct fps_counter *fps_counter;
+
+    sc_cond pending_frame_consumed_cond;
+    bool pending_frame_consumed;
+
+    const struct video_buffer_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+struct video_buffer_callbacks {
+    // Called when a new frame can be consumed by
+    // video_buffer_consumer_take_frame(vb)
+    // This callback is mandatory (it must not be NULL).
+    void (*on_frame_available)(struct video_buffer *vb, void *userdata);
+
+    // Called when a pending frame has been overwritten by the producer
+    // This callback is optional (it may be NULL).
+    void (*on_frame_skipped)(struct video_buffer *vb, void *userdata);
 };
 
 bool
-video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
-                  bool render_expired_frames);
+video_buffer_init(struct video_buffer *vb, bool wait_consumer);
 
 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);
+video_buffer_set_consumer_callbacks(struct video_buffer *vb,
+                                    const struct video_buffer_callbacks *cbs,
+                                    void *cbs_userdata);
 
-// 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
+// set the producer frame as ready for consuming
+void
+video_buffer_producer_offer_frame(struct video_buffer *vb);
+
+// mark the consumer frame as consumed and return it
+// the frame is valid until the next call to this function
 const AVFrame *
-video_buffer_consume_rendered_frame(struct video_buffer *vb);
+video_buffer_consumer_take_frame(struct video_buffer *vb);
 
 // wake up and avoid any blocking call
 void

app/tests/test_control_msg_serialize.c

@@ -146,14 +146,18 @@ static void test_serialize_inject_scroll_event(void) {
 static void test_serialize_back_or_screen_on(void) {
     struct control_msg msg = {
         .type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
+        .back_or_screen_on = {
+            .action = AKEY_EVENT_ACTION_UP,
+        },
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
     size_t size = control_msg_serialize(&msg, buf);
-    assert(size == 1);
+    assert(size == 2);
 
     const unsigned char expected[] = {
         CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
+        0x01, // AKEY_EVENT_ACTION_UP
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }

cross_win32.txt

@@ -2,11 +2,11 @@
 
 [binaries]
 name = 'mingw'
-c = '/usr/bin/i686-w64-mingw32-gcc'
-cpp = '/usr/bin/i686-w64-mingw32-g++'
-ar = '/usr/bin/i686-w64-mingw32-ar'
-strip = '/usr/bin/i686-w64-mingw32-strip'
-pkgconfig = '/usr/bin/i686-w64-mingw32-pkg-config'
+c = 'i686-w64-mingw32-gcc'
+cpp = 'i686-w64-mingw32-g++'
+ar = 'i686-w64-mingw32-ar'
+strip = 'i686-w64-mingw32-strip'
+pkgconfig = 'i686-w64-mingw32-pkg-config'
 
 [host_machine]
 system = 'windows'

cross_win64.txt

@@ -2,11 +2,11 @@
 
 [binaries]
 name = 'mingw'
-c = '/usr/bin/x86_64-w64-mingw32-gcc'
-cpp = '/usr/bin/x86_64-w64-mingw32-g++'
-ar = '/usr/bin/x86_64-w64-mingw32-ar'
-strip = '/usr/bin/x86_64-w64-mingw32-strip'
-pkgconfig = '/usr/bin/x86_64-w64-mingw32-pkg-config'
+c = 'x86_64-w64-mingw32-gcc'
+cpp = 'x86_64-w64-mingw32-g++'
+ar = 'x86_64-w64-mingw32-ar'
+strip = 'x86_64-w64-mingw32-strip'
+pkgconfig = 'x86_64-w64-mingw32-pkg-config'
 
 [host_machine]
 system = 'windows'

data/scrcpy-noconsole.vbs

@@ -1 +1,7 @@
-CreateObject("Wscript.Shell").Run "cmd /c scrcpy.exe", 0, false
+strCommand = "cmd /c scrcpy.exe"
+
+For Each Arg In WScript.Arguments
+    strCommand = strCommand & " """ & replace(Arg, """", """""""""") & """"
+Next
+
+CreateObject("Wscript.Shell").Run strCommand, 0, false

meson.build

@@ -4,6 +4,7 @@ project('scrcpy', 'c',
         default_options: [
             'c_std=c11',
             'warning_level=2',
+            'b_ndebug=if-release',
         ])
 
 if get_option('compile_app')

meson_options.txt

@@ -3,6 +3,5 @@ option('compile_server', type: 'boolean', value: true, description: 'Build the s
 option('crossbuild_windows', type: 'boolean', value: false, description: 'Build for Windows from Linux')
 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')
 option('server_debugger', type: 'boolean', value: false, description: 'Run a server debugger and wait for a client to be attached')
 option('server_debugger_method', type: 'combo', choices: ['old', 'new'], value: 'new', description: 'Select the debugger method (Android < 9: "old", Android >= 9: "new")')

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

@@ -19,19 +19,21 @@ public final class CleanUp {
         // not instantiable
     }
 
-    public static void configure(boolean disableShowTouches, int restoreStayOn, boolean restoreNormalPowerMode) throws IOException {
-        boolean needProcess = disableShowTouches || restoreStayOn != -1 || restoreNormalPowerMode;
+    public static void configure(boolean disableShowTouches, int restoreStayOn, boolean restoreNormalPowerMode, boolean powerOffScreen, int displayId)
+            throws IOException {
+        boolean needProcess = disableShowTouches || restoreStayOn != -1 || restoreNormalPowerMode || powerOffScreen;
         if (needProcess) {
-            startProcess(disableShowTouches, restoreStayOn, restoreNormalPowerMode);
+            startProcess(disableShowTouches, restoreStayOn, restoreNormalPowerMode, powerOffScreen, displayId);
         } else {
             // There is no additional clean up to do when scrcpy dies
             unlinkSelf();
         }
     }
 
-    private static void startProcess(boolean disableShowTouches, int restoreStayOn, boolean restoreNormalPowerMode) throws IOException {
+    private static void startProcess(boolean disableShowTouches, int restoreStayOn, boolean restoreNormalPowerMode, boolean powerOffScreen,
+            int displayId) throws IOException {
         String[] cmd = {"app_process", "/", CleanUp.class.getName(), String.valueOf(disableShowTouches), String.valueOf(
-                restoreStayOn), String.valueOf(restoreNormalPowerMode)};
+                restoreStayOn), String.valueOf(restoreNormalPowerMode), String.valueOf(powerOffScreen), String.valueOf(displayId)};
 
         ProcessBuilder builder = new ProcessBuilder(cmd);
         builder.environment().put("CLASSPATH", SERVER_PATH);
@@ -61,6 +63,8 @@ public final class CleanUp {
         boolean disableShowTouches = Boolean.parseBoolean(args[0]);
         int restoreStayOn = Integer.parseInt(args[1]);
         boolean restoreNormalPowerMode = Boolean.parseBoolean(args[2]);
+        boolean powerOffScreen = Boolean.parseBoolean(args[3]);
+        int displayId = Integer.parseInt(args[4]);
 
         if (disableShowTouches || restoreStayOn != -1) {
             ServiceManager serviceManager = new ServiceManager();
@@ -76,9 +80,12 @@ public final class CleanUp {
             }
         }
 
-        if (restoreNormalPowerMode) {
-            Ln.i("Restoring normal power mode");
-            if (Device.isScreenOn()) {
+        if (Device.isScreenOn()) {
+            if (powerOffScreen) {
+                Ln.i("Power off screen");
+                Device.powerOffScreen(displayId);
+            } else if (restoreNormalPowerMode) {
+                Ln.i("Restoring normal power mode");
                 Device.setScreenPowerMode(Device.POWER_MODE_NORMAL);
             }
         }

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

@@ -71,6 +71,13 @@ public final class ControlMessage {
         return msg;
     }
 
+    public static ControlMessage createBackOrScreenOn(int action) {
+        ControlMessage msg = new ControlMessage();
+        msg.type = TYPE_BACK_OR_SCREEN_ON;
+        msg.action = action;
+        return msg;
+    }
+
     public static ControlMessage createSetClipboard(String text, boolean paste) {
         ControlMessage msg = new ControlMessage();
         msg.type = TYPE_SET_CLIPBOARD;

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

@@ -11,6 +11,7 @@ public class ControlMessageReader {
     static final int INJECT_KEYCODE_PAYLOAD_LENGTH = 13;
     static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 27;
     static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
+    static final int BACK_OR_SCREEN_ON_LENGTH = 1;
     static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
     static final int SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH = 1;
 
@@ -66,13 +67,15 @@ public class ControlMessageReader {
             case ControlMessage.TYPE_INJECT_SCROLL_EVENT:
                 msg = parseInjectScrollEvent();
                 break;
+            case ControlMessage.TYPE_BACK_OR_SCREEN_ON:
+                msg = parseBackOrScreenOnEvent();
+                break;
             case ControlMessage.TYPE_SET_CLIPBOARD:
                 msg = parseSetClipboard();
                 break;
             case ControlMessage.TYPE_SET_SCREEN_POWER_MODE:
                 msg = parseSetScreenPowerMode();
                 break;
-            case ControlMessage.TYPE_BACK_OR_SCREEN_ON:
             case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
             case ControlMessage.TYPE_COLLAPSE_NOTIFICATION_PANEL:
             case ControlMessage.TYPE_GET_CLIPBOARD:
@@ -150,6 +153,14 @@ public class ControlMessageReader {
         return ControlMessage.createInjectScrollEvent(position, hScroll, vScroll);
     }
 
+    private ControlMessage parseBackOrScreenOnEvent() {
+        if (buffer.remaining() < BACK_OR_SCREEN_ON_LENGTH) {
+            return null;
+        }
+        int action = toUnsigned(buffer.get());
+        return ControlMessage.createBackOrScreenOn(action);
+    }
+
     private ControlMessage parseSetClipboard() {
         if (buffer.remaining() < SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH) {
             return null;

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

@@ -14,7 +14,7 @@ import java.util.concurrent.TimeUnit;
 
 public class Controller {
 
-    private static final int DEVICE_ID_VIRTUAL = -1;
+    private static final int DEFAULT_DEVICE_ID = 0;
 
     private static final ScheduledExecutorService EXECUTOR = Executors.newSingleThreadScheduledExecutor();
 
@@ -45,7 +45,7 @@ public class Controller {
 
             MotionEvent.PointerCoords coords = new MotionEvent.PointerCoords();
             coords.orientation = 0;
-            coords.size = 1;
+            coords.size = 0;
 
             pointerProperties[i] = props;
             pointerCoords[i] = coords;
@@ -101,7 +101,7 @@ public class Controller {
                 break;
             case ControlMessage.TYPE_BACK_OR_SCREEN_ON:
                 if (device.supportsInputEvents()) {
-                    pressBackOrTurnScreenOn();
+                    pressBackOrTurnScreenOn(msg.getAction());
                 }
                 break;
             case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
@@ -208,9 +208,13 @@ public class Controller {
         // Right-click and middle-click only work if the source is a mouse
         boolean nonPrimaryButtonPressed = (buttons & ~MotionEvent.BUTTON_PRIMARY) != 0;
         int source = nonPrimaryButtonPressed ? InputDevice.SOURCE_MOUSE : InputDevice.SOURCE_TOUCHSCREEN;
+        if (source != InputDevice.SOURCE_MOUSE) {
+            // Buttons must not be set for touch events
+            buttons = 0;
+        }
 
         MotionEvent event = MotionEvent
-                .obtain(lastTouchDown, now, action, pointerCount, pointerProperties, pointerCoords, 0, buttons, 1f, 1f, DEVICE_ID_VIRTUAL, 0, source,
+                .obtain(lastTouchDown, now, action, pointerCount, pointerProperties, pointerCoords, 0, buttons, 1f, 1f, DEFAULT_DEVICE_ID, 0, source,
                         0);
         return device.injectEvent(event);
     }
@@ -233,7 +237,7 @@ public class Controller {
         coords.setAxisValue(MotionEvent.AXIS_VSCROLL, vScroll);
 
         MotionEvent event = MotionEvent
-                .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
+                .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEFAULT_DEVICE_ID, 0,
                         InputDevice.SOURCE_TOUCHSCREEN, 0);
         return device.injectEvent(event);
     }
@@ -251,12 +255,22 @@ public class Controller {
         }, 200, TimeUnit.MILLISECONDS);
     }
 
-    private boolean pressBackOrTurnScreenOn() {
-        int keycode = Device.isScreenOn() ? KeyEvent.KEYCODE_BACK : KeyEvent.KEYCODE_POWER;
-        if (keepPowerModeOff && keycode == KeyEvent.KEYCODE_POWER) {
+    private boolean pressBackOrTurnScreenOn(int action) {
+        if (Device.isScreenOn()) {
+            return device.injectKeyEvent(action, KeyEvent.KEYCODE_BACK, 0, 0);
+        }
+
+        // Screen is off
+        // Only press POWER on ACTION_DOWN
+        if (action != KeyEvent.ACTION_DOWN) {
+            // do nothing,
+            return true;
+        }
+
+        if (keepPowerModeOff) {
             schedulePowerModeOff();
         }
-        return device.injectKeycode(keycode);
+        return device.injectKeycode(KeyEvent.KEYCODE_POWER);
     }
 
     private boolean setClipboard(String text, boolean paste) {

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

@@ -153,13 +153,17 @@ public final class Device {
         return Build.MODEL;
     }
 
+    public static boolean supportsInputEvents(int displayId) {
+        return displayId == 0 || Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q;
+    }
+
     public boolean supportsInputEvents() {
         return supportsInputEvents;
     }
 
-    public boolean injectEvent(InputEvent inputEvent, int mode) {
-        if (!supportsInputEvents()) {
-            throw new AssertionError("Could not inject input event if !supportsInputEvents()");
+    public static boolean injectEvent(InputEvent inputEvent, int mode, int displayId) {
+        if (!supportsInputEvents(displayId)) {
+            return false;
         }
 
         if (displayId != 0 && !InputManager.setDisplayId(inputEvent, displayId)) {
@@ -169,10 +173,29 @@ public final class Device {
         return SERVICE_MANAGER.getInputManager().injectInputEvent(inputEvent, mode);
     }
 
+    public boolean injectEvent(InputEvent inputEvent, int mode) {
+        if (!supportsInputEvents()) {
+            throw new AssertionError("Could not inject input event if !supportsInputEvents()");
+        }
+
+        return injectEvent(inputEvent, mode, displayId);
+    }
+
+    public static boolean injectEventOnDisplay(InputEvent event, int displayId) {
+        return injectEvent(event, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC, displayId);
+    }
+
     public boolean injectEvent(InputEvent event) {
         return injectEvent(event, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
     }
 
+    public static boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState, int displayId) {
+        long now = SystemClock.uptimeMillis();
+        KeyEvent event = new KeyEvent(now, now, action, keyCode, repeat, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0,
+                InputDevice.SOURCE_KEYBOARD);
+        return injectEventOnDisplay(event, displayId);
+    }
+
     public boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState) {
         long now = SystemClock.uptimeMillis();
         KeyEvent event = new KeyEvent(now, now, action, keyCode, repeat, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0,
@@ -180,6 +203,10 @@ public final class Device {
         return injectEvent(event);
     }
 
+    public static boolean injectKeycode(int keyCode, int displayId) {
+        return injectKeyEvent(KeyEvent.ACTION_DOWN, keyCode, 0, 0, displayId) && injectKeyEvent(KeyEvent.ACTION_UP, keyCode, 0, 0, displayId);
+    }
+
     public boolean injectKeycode(int keyCode) {
         return injectKeyEvent(KeyEvent.ACTION_DOWN, keyCode, 0, 0) && injectKeyEvent(KeyEvent.ACTION_UP, keyCode, 0, 0);
     }
@@ -249,6 +276,13 @@ public final class Device {
         return SurfaceControl.setDisplayPowerMode(d, mode);
     }
 
+    public static boolean powerOffScreen(int displayId) {
+        if (!isScreenOn()) {
+            return true;
+        }
+        return injectKeycode(KeyEvent.KEYCODE_POWER, displayId);
+    }
+
     /**
      * Disable auto-rotation (if enabled), set the screen rotation and re-enable auto-rotation (if it was enabled).
      */

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

@@ -17,6 +17,7 @@ public class Options {
     private boolean stayAwake;
     private String codecOptions;
     private String encoderName;
+    private boolean powerOffScreenOnClose;
 
     public Ln.Level getLogLevel() {
         return logLevel;
@@ -129,4 +130,12 @@ public class Options {
     public void setEncoderName(String encoderName) {
         this.encoderName = encoderName;
     }
+
+    public void setPowerOffScreenOnClose(boolean powerOffScreenOnClose) {
+        this.powerOffScreenOnClose = powerOffScreenOnClose;
+    }
+
+    public boolean getPowerOffScreenOnClose() {
+        return this.powerOffScreenOnClose;
+    }
 }

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

@@ -50,7 +50,7 @@ public final class Server {
             }
         }
 
-        CleanUp.configure(mustDisableShowTouchesOnCleanUp, restoreStayOn, true);
+        CleanUp.configure(mustDisableShowTouchesOnCleanUp, restoreStayOn, true, options.getPowerOffScreenOnClose(), options.getDisplayId());
 
         boolean tunnelForward = options.isTunnelForward();
 
@@ -135,7 +135,7 @@ public final class Server {
                     "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
         }
 
-        final int expectedParameters = 15;
+        final int expectedParameters = 16;
         if (args.length != expectedParameters) {
             throw new IllegalArgumentException("Expecting " + expectedParameters + " parameters");
         }
@@ -185,6 +185,9 @@ public final class Server {
         String encoderName = "-".equals(args[14]) ? null : args[14];
         options.setEncoderName(encoderName);
 
+        boolean powerOffScreenOnClose = Boolean.parseBoolean(args[15]);
+        options.setPowerOffScreenOnClose(powerOffScreenOnClose);
+
         return options;
     }
 
@@ -230,7 +233,7 @@ public final class Server {
             if (encoders != null && encoders.length > 0) {
                 Ln.e("Try to use one of the available encoders:");
                 for (MediaCodecInfo encoder : encoders) {
-                    Ln.e("    scrcpy --encoder-name '" + encoder.getName() + "'");
+                    Ln.e("    scrcpy --encoder '" + encoder.getName() + "'");
                 }
             }
         }

server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java

@@ -154,6 +154,7 @@ public class ControlMessageReaderTest {
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         DataOutputStream dos = new DataOutputStream(bos);
         dos.writeByte(ControlMessage.TYPE_BACK_OR_SCREEN_ON);
+        dos.writeByte(KeyEvent.ACTION_UP);
 
         byte[] packet = bos.toByteArray();
 
@@ -161,6 +162,7 @@ public class ControlMessageReaderTest {
         ControlMessage event = reader.next();
 
         Assert.assertEquals(ControlMessage.TYPE_BACK_OR_SCREEN_ON, event.getType());
+        Assert.assertEquals(KeyEvent.ACTION_DOWN, event.getAction());
     }
 
     @Test