wip resizer

The video buffer held 3 frames:
 - the producer frame (for decoding)
 - the pending frame (to exchange between the producer and consumer)
 - the consumer frame (for rendering)

It worked well, but it prevented video buffers to be chained, because
the consumer frame of the first video buffer must be the same as the
producer frame of the second video buffer.

To solve this problem, make the decoder and the screen handle their own
frames, and keep only the pending frame in the video_buffer.

This paves the way to support asynchronous swscale.

app/meson.build

@@ -15,6 +15,7 @@ src = [
     'src/opengl.c',
     'src/receiver.c',
     'src/recorder.c',
+    'src/resizer.c',
     'src/scrcpy.c',
     'src/screen.c',
     'src/server.c',
@@ -118,6 +119,9 @@ conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')
 # 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

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

@@ -106,11 +106,6 @@ scrcpy_print_usage(const char *arg0) {
         "    --no-key-repeat\n"
         "        Do not forward repeated key events when a key is held down.\n"
         "\n"
-        "    --no-mipmaps\n"
-        "        If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then\n"
-        "        mipmaps are automatically generated to improve downscaling\n"
-        "        quality. This option disables the generation of mipmaps.\n"
-        "\n"
         "    -p, --port port[:port]\n"
         "        Set the TCP port (range) used by the client to listen.\n"
         "        Default is " STR(DEFAULT_LOCAL_PORT_RANGE_FIRST) ":"
@@ -158,6 +153,11 @@ scrcpy_print_usage(const char *arg0) {
         "        The device serial number. Mandatory only if several devices\n"
         "        are connected to adb.\n"
         "\n"
+        "    --scale-filter filter\n"
+        "        Supported filters are \"none\" and \"trilinear\".\n"
+        "        Trilinear filtering is only available if the renderer is\n"
+        "        OpenGL 3.0+ or OpenGL ES 2.0+.\n"
+        "\n"
         "    --shortcut-mod key[+...]][,...]\n"
         "        Specify the modifiers to use for scrcpy shortcuts.\n"
         "        Possible keys are \"lctrl\", \"rctrl\", \"lalt\", \"ralt\",\n"
@@ -179,6 +179,9 @@ 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
@@ -186,9 +189,6 @@ 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"
@@ -640,6 +640,21 @@ guess_record_format(const char *filename) {
     return 0;
 }
 
+static bool
+parse_scale_filter(const char *optarg, enum sc_scale_filter *filter) {
+    if (!strcmp(optarg, "none")) {
+        *filter = SC_SCALE_FILTER_NONE;
+        return true;
+    }
+    if (!strcmp(optarg, "trilinear")) {
+        *filter = SC_SCALE_FILTER_TRILINEAR;
+        return true;
+    }
+    LOGE("Unsupported scale filter: %s "
+         "(expected \"none\" or \"trilinear\")", optarg);
+    return false;
+}
+
 #define OPT_RENDER_EXPIRED_FRAMES  1000
 #define OPT_WINDOW_TITLE           1001
 #define OPT_PUSH_TARGET            1002
@@ -666,7 +681,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
+#define OPT_SCALE_FILTER           1026
 
 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@@ -703,6 +718,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         {"render-expired-frames",  no_argument,       NULL,
                                                   OPT_RENDER_EXPIRED_FRAMES},
         {"rotation",               required_argument, NULL, OPT_ROTATION},
+        {"scale-filter",           required_argument, NULL, OPT_SCALE_FILTER},
         {"serial",                 required_argument, NULL, 's'},
         {"shortcut-mod",           required_argument, NULL, OPT_SHORTCUT_MOD},
         {"show-touches",           no_argument,       NULL, 't'},
@@ -717,8 +733,6 @@ 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  },
     };
 
@@ -859,7 +873,9 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
                 opts->render_driver = optarg;
                 break;
             case OPT_NO_MIPMAPS:
-                opts->mipmaps = false;
+                LOGW("Deprecated option --no-mipmaps. "
+                     "Use --scale-filter=none instead.");
+                opts->scale_filter = SC_SCALE_FILTER_NONE;
                 break;
             case OPT_NO_KEY_REPEAT:
                 opts->forward_key_repeat = false;
@@ -887,8 +903,10 @@ 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;
+            case OPT_SCALE_FILTER:
+                if (!parse_scale_filter(optarg, &opts->scale_filter)) {
+                    return false;
+                }
                 break;
             default:
                 // getopt prints the error message on stderr

app/src/control_msg.c

@@ -67,9 +67,6 @@ 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,
@@ -80,6 +77,7 @@ 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,10 +64,6 @@ 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/decoder.c

@@ -1,9 +1,14 @@
 #include "decoder.h"
 
 #include <libavformat/avformat.h>
+#include <libavutil/time.h>
+#include <SDL2/SDL_events.h>
+#include <unistd.h>
 
 #include "events.h"
+#include "recorder.h"
 #include "video_buffer.h"
+#include "util/buffer_util.h"
 #include "util/log.h"
 
 void
@@ -25,11 +30,20 @@ decoder_open(struct decoder *decoder, const AVCodec *codec) {
         return false;
     }
 
+    decoder->frame = av_frame_alloc();
+    if (!decoder->frame) {
+        LOGE("Could not create decoder frame");
+        avcodec_close(decoder->codec_ctx);
+        avcodec_free_context(&decoder->codec_ctx);
+        return false;
+    }
+
     return true;
 }
 
 void
 decoder_close(struct decoder *decoder) {
+    av_frame_free(&decoder->frame);
     avcodec_close(decoder->codec_ctx);
     avcodec_free_context(&decoder->codec_ctx);
 }
@@ -44,11 +58,11 @@ decoder_push(struct decoder *decoder, const AVPacket *packet) {
         LOGE("Could not send video packet: %d", ret);
         return false;
     }
-    ret = avcodec_receive_frame(decoder->codec_ctx,
-                                decoder->video_buffer->producer_frame);
+    ret = avcodec_receive_frame(decoder->codec_ctx, decoder->frame);
     if (!ret) {
         // a frame was received
-        video_buffer_producer_offer_frame(decoder->video_buffer);
+        video_buffer_producer_offer_frame(decoder->video_buffer,
+                                          &decoder->frame);
     } else if (ret != AVERROR(EAGAIN)) {
         LOGE("Could not receive video frame: %d", ret);
         return false;
@@ -56,7 +70,7 @@ decoder_push(struct decoder *decoder, const AVPacket *packet) {
 #else
     int got_picture;
     int len = avcodec_decode_video2(decoder->codec_ctx,
-                                    decoder->video_buffer->producer_frame,
+                                    decoder->frame,
                                     &got_picture,
                                     packet);
     if (len < 0) {
@@ -64,7 +78,7 @@ decoder_push(struct decoder *decoder, const AVPacket *packet) {
         return false;
     }
     if (got_picture) {
-        video_buffer_producer_offer_frame(decoder->video_buffer);
+        push_frame(decoder);
     }
 #endif
     return true;

app/src/decoder.h

@@ -12,6 +12,7 @@ struct decoder {
     struct video_buffer *video_buffer;
 
     AVCodecContext *codec_ctx;
+    AVFrame *frame;
 };
 
 void

app/src/input_manager.c

@@ -146,25 +146,13 @@ 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, int actions) {
+press_back_or_turn_screen_on(struct controller *controller) {
     struct control_msg msg;
     msg.type = CONTROL_MSG_TYPE_BACK_OR_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'");
-        }
+    if (!controller_push_msg(controller, &msg)) {
+        LOGW("Could not request 'press back or turn screen on'");
     }
 }
 
@@ -658,15 +646,13 @@ input_manager_process_mouse_button(struct input_manager *im,
     }
 
     bool down = event->type == SDL_MOUSEBUTTONDOWN;
-    if (!im->forward_all_clicks) {
-        int action = down ? ACTION_DOWN : ACTION_UP;
-
+    if (!im->forward_all_clicks && down) {
         if (control && event->button == SDL_BUTTON_RIGHT) {
-            press_back_or_turn_screen_on(im->controller, action);
+            press_back_or_turn_screen_on(im->controller);
             return;
         }
         if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, action);
+            action_home(im->controller, ACTION_DOWN | ACTION_UP);
             return;
         }
 
@@ -679,9 +665,7 @@ 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) {
-                if (down) {
-                    screen_resize_to_fit(im->screen);
-                }
+                screen_resize_to_fit(im->screen);
                 return;
             }
         }

app/src/input_manager.h

@@ -11,9 +11,11 @@
 #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;
 

app/src/recorder.c

@@ -228,7 +228,7 @@ recorder_rescale_packet(struct recorder *recorder, AVPacket *packet) {
     av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
 }
 
-static bool
+bool
 recorder_write(struct recorder *recorder, AVPacket *packet) {
     if (!recorder->header_written) {
         if (packet->pts != AV_NOPTS_VALUE) {

app/src/resizer.c

@@ -0,0 +1,132 @@
+#include "resizer.h"
+
+#include <assert.h>
+
+#include "util/log.h"
+
+bool
+sc_resizer_init(struct sc_resizer *resizer, struct video_buffer *vb_in,
+                struct video_buffer *vb_out, struct size size) {
+    bool ok = sc_mutex_init(&resizer->mutex);
+    if (!ok) {
+        return false;
+    }
+
+    ok = sc_cond_init(&resizer->req_cond);
+    if (!ok) {
+        sc_mutex_destroy(&resizer->mutex);
+        return false;
+    }
+
+    resizer->resized_frame = av_frame_alloc();
+    if (!resizer->resized_frame) {
+        sc_cond_destroy(&resizer->req_cond);
+        sc_mutex_destroy(&resizer->mutex);
+        return false;
+    }
+
+    resizer->vb_in = vb_in;
+    resizer->vb_out = vb_out;
+    resizer->size = size;
+
+    resizer->input_frame = NULL;
+    resizer->has_request = false;
+    resizer->has_new_frame = false;
+    resizer->interrupted = false;
+
+    return true;
+}
+
+void
+sc_resizer_destroy(struct sc_resizer *resizer) {
+    av_frame_free(&resizer->resized_frame);
+    sc_cond_destroy(&resizer->req_cond);
+    sc_mutex_destroy(&resizer->mutex);
+}
+
+static bool
+sc_resizer_swscale(struct sc_resizer *resizer) {
+    assert(!resizer->resized_frame->buf[0]); // The frame must be "empty"
+
+    return false;
+}
+
+static int
+run_resizer(void *data) {
+    struct sc_resizer *resizer = data;
+
+    sc_mutex_lock(&resizer->mutex);
+    while (!resizer->interrupted) {
+        while (!resizer->interrupted && !resizer->has_request) {
+            sc_cond_wait(&resizer->req_cond, &resizer->mutex);
+        }
+
+        if (resizer->has_new_frame) {
+            resizer->input_frame =
+                video_buffer_consumer_take_frame(resizer->vb_in);
+
+            resizer->has_new_frame = false;
+        }
+
+        resizer->has_request = false;
+        sc_mutex_unlock(&resizer->mutex);
+
+        // Do the actual work without mutex
+        sc_resizer_swscale(resizer);
+
+        video_buffer_producer_offer_frame(resizer->vb_out,
+                                          &resizer->resized_frame);
+
+        sc_mutex_lock(&resizer->mutex);
+    }
+    sc_mutex_unlock(&resizer->mutex);
+
+    return 0;
+}
+
+bool
+sc_resizer_start(struct sc_resizer *resizer) {
+    LOGD("Starting resizer thread");
+
+    bool ok = sc_thread_create(&resizer->thread, run_resizer, "resizer",
+                               resizer);
+    if (!ok) {
+        LOGE("Could not start resizer thread");
+        return false;
+    }
+
+    return true;
+}
+
+void
+sc_resizer_stop(struct sc_resizer *resizer) {
+    sc_mutex_lock(&resizer->mutex);
+    resizer->interrupted = true;
+    sc_cond_signal(&resizer->req_cond);
+    sc_mutex_unlock(&resizer->mutex);
+
+    video_buffer_interrupt(resizer->vb_out);
+}
+
+void
+sc_resizer_join(struct sc_resizer *resizer) {
+    sc_thread_join(&resizer->thread, NULL);
+}
+
+void
+sc_resizer_process_new_frame(struct sc_resizer *resizer) {
+    sc_mutex_lock(&resizer->mutex);
+    resizer->has_request = true;
+    resizer->has_new_frame = true;
+    sc_cond_signal(&resizer->req_cond);
+    sc_mutex_unlock(&resizer->mutex);
+}
+
+void
+sc_resizer_process_new_size(struct sc_resizer *resizer, struct size size) {
+    sc_mutex_lock(&resizer->mutex);
+    resizer->size = size;
+    resizer->has_request = true;
+    sc_cond_signal(&resizer->req_cond);
+    sc_mutex_unlock(&resizer->mutex);
+}

app/src/resizer.h

@@ -0,0 +1,53 @@
+#ifndef SC_RESIZER
+#define SC_RESIZER
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <libavformat/avformat.h>
+
+#include "coords.h"
+#include "util/thread.h"
+#include "video_buffer.h"
+
+struct sc_resizer {
+    struct video_buffer *vb_in;
+    struct video_buffer *vb_out;
+    struct size size;
+
+    // valid until the next call to video_buffer_consumer_take_frame(vb_in)
+    const AVFrame *input_frame;
+    AVFrame *resized_frame;
+
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond req_cond;
+
+    bool has_request;
+    bool has_new_frame;
+    bool interrupted;
+};
+
+bool
+sc_resizer_init(struct sc_resizer *resizer, struct video_buffer *vb_in,
+                struct video_buffer *vb_out, struct size initial_size);
+
+void
+sc_resizer_destroy(struct sc_resizer *resizer);
+
+bool
+sc_resizer_start(struct sc_resizer *resizer);
+
+void
+sc_resizer_stop(struct sc_resizer *resizer);
+
+void
+sc_resizer_join(struct sc_resizer *resizer);
+
+void
+sc_resizer_process_new_frame(struct sc_resizer *resizer);
+
+void
+sc_resizer_process_new_size(struct sc_resizer *resizer, struct size size);
+
+#endif

app/src/scrcpy.c

@@ -41,6 +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,
@@ -128,6 +129,30 @@ 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, '.');
@@ -167,7 +192,7 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
                 action = ACTION_PUSH_FILE;
             }
             file_handler_request(&file_handler, action, file);
-            goto end;
+            break;
         }
     }
 
@@ -185,6 +210,11 @@ end:
 
 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);
@@ -253,7 +283,6 @@ 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 = {
@@ -271,7 +300,6 @@ 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,15 +392,13 @@ scrcpy(const struct scrcpy_options *options) {
             .window_height = options->window_height,
             .window_borderless = options->window_borderless,
             .rotation = options->rotation,
-            .mipmaps = options->mipmaps,
-            .fullscreen = options->fullscreen,
+            .scale_filter = options->scale_filter,
         };
 
         if (!screen_init(&screen, &video_buffer, &fps_counter,
                          &screen_params)) {
             goto end;
         }
-        screen_initialized = true;
 
         if (options->turn_screen_off) {
             struct control_msg msg;
@@ -383,6 +409,10 @@ 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
@@ -397,6 +427,8 @@ scrcpy(const struct scrcpy_options *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
@@ -423,13 +455,6 @@ 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

@@ -41,6 +41,11 @@ struct sc_port_range {
     uint16_t last;
 };
 
+enum sc_scale_filter {
+    SC_SCALE_FILTER_NONE,
+    SC_SCALE_FILTER_TRILINEAR, // mipmaps
+};
+
 #define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
 
 struct scrcpy_options {
@@ -56,6 +61,7 @@ struct scrcpy_options {
     enum sc_record_format record_format;
     struct sc_port_range port_range;
     struct sc_shortcut_mods shortcut_mods;
+    enum sc_scale_filter scale_filter;
     uint16_t max_size;
     uint32_t bit_rate;
     uint16_t max_fps;
@@ -75,14 +81,12 @@ struct scrcpy_options {
     bool render_expired_frames;
     bool prefer_text;
     bool window_borderless;
-    bool mipmaps;
     bool stay_awake;
     bool force_adb_forward;
     bool disable_screensaver;
     bool forward_key_repeat;
     bool forward_all_clicks;
     bool legacy_paste;
-    bool power_off_on_close;
 };
 
 #define SCRCPY_OPTIONS_DEFAULT { \
@@ -104,6 +108,7 @@ struct scrcpy_options {
         .data = {SC_MOD_LALT, SC_MOD_LSUPER}, \
         .count = 2, \
     }, \
+    .scale_filter = SC_SCALE_FILTER_TRILINEAR, \
     .max_size = 0, \
     .bit_rate = DEFAULT_BIT_RATE, \
     .max_fps = 0, \
@@ -123,14 +128,12 @@ struct scrcpy_options {
     .render_expired_frames = false, \
     .prefer_text = false, \
     .window_borderless = false, \
-    .mipmaps = true, \
     .stay_awake = false, \
     .force_adb_forward = false, \
     .disable_screensaver = false, \
     .forward_key_repeat = true, \
     .forward_all_clicks = false, \
     .legacy_paste = false, \
-    .power_off_on_close = false, \
 }
 
 bool

app/src/screen.c

@@ -6,7 +6,6 @@
 
 #include "events.h"
 #include "icon.xpm"
-#include "scrcpy.h"
 #include "tiny_xpm.h"
 #include "video_buffer.h"
 #include "util/log.h"
@@ -239,29 +238,6 @@ create_texture(struct screen *screen) {
     return texture;
 }
 
-#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);
-    }
-    return 0;
-}
-#endif
-
 bool
 screen_init(struct screen *screen, struct video_buffer *vb,
             struct fps_counter *fps_counter,
@@ -292,9 +268,10 @@ screen_init(struct screen *screen, struct video_buffer *vb,
     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;
+    uint32_t window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
+#ifdef HIDPI_SUPPORT
+    window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
+#endif
     if (params->always_on_top) {
 #ifdef SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
         window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
@@ -336,13 +313,14 @@ screen_init(struct screen *screen, struct video_buffer *vb,
 
     // starts with "opengl"
     bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
+    bool mipmaps = params->scale_filter == SC_SCALE_FILTER_TRILINEAR;
     if (use_opengl) {
         struct sc_opengl *gl = &screen->gl;
         sc_opengl_init(gl);
 
         LOGI("OpenGL version: %s", gl->version);
 
-        if (params->mipmaps) {
+        if (mipmaps) {
             bool supports_mipmaps =
                 sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
                                                2, 0  /* OpenGL ES 2.0+ */);
@@ -356,7 +334,7 @@ screen_init(struct screen *screen, struct video_buffer *vb,
         } else {
             LOGI("Trilinear filtering disabled");
         }
-    } else if (params->mipmaps) {
+    } else if (mipmaps) {
         LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
     }
 
@@ -378,6 +356,15 @@ screen_init(struct screen *screen, struct video_buffer *vb,
         return false;
     }
 
+    screen->frame = av_frame_alloc();
+    if (!screen->frame) {
+        LOGC("Could not create screen frame");
+        SDL_DestroyTexture(screen->texture);
+        SDL_DestroyRenderer(screen->renderer);
+        SDL_DestroyWindow(screen->window);
+        return false;
+    }
+
     // Reset the window size to trigger a SIZE_CHANGED event, to workaround
     // HiDPI issues with some SDL renderers when several displays having
     // different HiDPI scaling are connected
@@ -385,24 +372,17 @@ screen_init(struct screen *screen, struct video_buffer *vb,
 
     screen_update_content_rect(screen);
 
-    if (params->fullscreen) {
-        screen_switch_fullscreen(screen);
-    }
-
-#ifdef CONTINUOUS_RESIZING_WORKAROUND
-    SDL_AddEventWatch(event_watcher, screen);
-#endif
-
     return true;
 }
 
-static void
+void
 screen_show_window(struct screen *screen) {
     SDL_ShowWindow(screen->window);
 }
 
 void
 screen_destroy(struct screen *screen) {
+    av_frame_free(&screen->frame);
     SDL_DestroyTexture(screen->texture);
     SDL_DestroyRenderer(screen->renderer);
     SDL_DestroyWindow(screen->window);
@@ -510,7 +490,8 @@ update_texture(struct screen *screen, const AVFrame *frame) {
 
 static bool
 screen_update_frame(struct screen *screen) {
-    const AVFrame *frame = video_buffer_consumer_take_frame(screen->vb);
+    video_buffer_consumer_take_frame(screen->vb, &screen->frame);
+    AVFrame *frame = screen->frame;
 
     fps_counter_add_rendered_frame(screen->fps_counter);
 

app/src/screen.h

@@ -9,6 +9,7 @@
 
 #include "coords.h"
 #include "opengl.h"
+#include "scrcpy.h"
 
 struct video_buffer;
 
@@ -36,6 +37,8 @@ struct screen {
     bool fullscreen;
     bool maximized;
     bool mipmaps;
+
+    AVFrame *frame;
 };
 
 struct screen_params {
@@ -51,9 +54,7 @@ struct screen_params {
     bool window_borderless;
 
     uint8_t rotation;
-    bool mipmaps;
-
-    bool fullscreen;
+    enum sc_scale_filter scale_filter;
 };
 
 // initialize screen, create window, renderer and texture (window is hidden)
@@ -62,6 +63,10 @@ screen_init(struct screen *screen, struct video_buffer *vb,
             struct fps_counter *fps_counter,
             const struct screen_params *params);
 
+// show the window
+void
+screen_show_window(struct screen *screen);
+
 // destroy window, renderer and texture (if any)
 void
 screen_destroy(struct screen *screen);

app/src/server.c

@@ -293,7 +293,6 @@ 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 "

app/src/server.h

@@ -46,7 +46,6 @@ struct server_params {
     bool show_touches;
     bool stay_awake;
     bool force_adb_forward;
-    bool power_off_on_close;
 };
 
 // init default values

app/src/stream.h

@@ -11,6 +11,8 @@
 #include "util/net.h"
 #include "util/thread.h"
 
+struct video_buffer;
+
 struct stream {
     socket_t socket;
     sc_thread thread;

app/src/video_buffer.c

@@ -8,24 +8,14 @@
 
 bool
 video_buffer_init(struct video_buffer *vb, bool wait_consumer) {
-    vb->producer_frame = av_frame_alloc();
-    if (!vb->producer_frame) {
-        goto error_0;
-    }
-
     vb->pending_frame = av_frame_alloc();
     if (!vb->pending_frame) {
-        goto error_1;
-    }
-
-    vb->consumer_frame = av_frame_alloc();
-    if (!vb->consumer_frame) {
-        goto error_2;
+        goto error_0;
     }
 
     bool ok = sc_mutex_init(&vb->mutex);
     if (!ok) {
-        goto error_3;
+        goto error_1;
     }
 
     vb->wait_consumer = wait_consumer;
@@ -33,7 +23,7 @@ video_buffer_init(struct video_buffer *vb, bool wait_consumer) {
         ok = sc_cond_init(&vb->pending_frame_consumed_cond);
         if (!ok) {
             sc_mutex_destroy(&vb->mutex);
-            goto error_2;
+            goto error_1;
         }
         // interrupted is not used if wait_consumer is disabled since offering
         // a frame will never block
@@ -49,12 +39,8 @@ video_buffer_init(struct video_buffer *vb, bool wait_consumer) {
 
     return true;
 
-error_3:
-    av_frame_free(&vb->consumer_frame);
-error_2:
-    av_frame_free(&vb->pending_frame);
 error_1:
-    av_frame_free(&vb->producer_frame);
+    av_frame_free(&vb->pending_frame);
 error_0:
     return false;
 }
@@ -65,9 +51,7 @@ video_buffer_destroy(struct video_buffer *vb) {
         sc_cond_destroy(&vb->pending_frame_consumed_cond);
     }
     sc_mutex_destroy(&vb->mutex);
-    av_frame_free(&vb->consumer_frame);
     av_frame_free(&vb->pending_frame);
-    av_frame_free(&vb->producer_frame);
 }
 
 static inline void
@@ -89,7 +73,7 @@ video_buffer_set_consumer_callbacks(struct video_buffer *vb,
 }
 
 void
-video_buffer_producer_offer_frame(struct video_buffer *vb) {
+video_buffer_producer_offer_frame(struct video_buffer *vb, AVFrame **pframe) {
     assert(vb->cbs);
 
     sc_mutex_lock(&vb->mutex);
@@ -101,7 +85,7 @@ video_buffer_producer_offer_frame(struct video_buffer *vb) {
     }
 
     av_frame_unref(vb->pending_frame);
-    swap_frames(&vb->producer_frame, &vb->pending_frame);
+    swap_frames(pframe, &vb->pending_frame);
 
     bool skipped = !vb->pending_frame_consumed;
     vb->pending_frame_consumed = false;
@@ -116,13 +100,13 @@ video_buffer_producer_offer_frame(struct video_buffer *vb) {
     }
 }
 
-const AVFrame *
-video_buffer_consumer_take_frame(struct video_buffer *vb) {
+void
+video_buffer_consumer_take_frame(struct video_buffer *vb, AVFrame **pframe) {
     sc_mutex_lock(&vb->mutex);
     assert(!vb->pending_frame_consumed);
     vb->pending_frame_consumed = true;
 
-    swap_frames(&vb->consumer_frame, &vb->pending_frame);
+    swap_frames(pframe, &vb->pending_frame);
     av_frame_unref(vb->pending_frame);
 
     if (vb->wait_consumer) {
@@ -130,9 +114,6 @@ video_buffer_consumer_take_frame(struct video_buffer *vb) {
         sc_cond_signal(&vb->pending_frame_consumed_cond);
     }
     sc_mutex_unlock(&vb->mutex);
-
-    // consumer_frame is only written from this thread, no need to lock
-    return vb->consumer_frame;
 }
 
 void

app/src/video_buffer.h

@@ -29,9 +29,7 @@ typedef struct AVFrame AVFrame;
  */
 
 struct video_buffer {
-    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
@@ -67,13 +65,14 @@ video_buffer_set_consumer_callbacks(struct video_buffer *vb,
                                     void *cbs_userdata);
 
 // set the producer frame as ready for consuming
+// the produced frame is exchanged with an unused allocated frame
 void
-video_buffer_producer_offer_frame(struct video_buffer *vb);
+video_buffer_producer_offer_frame(struct video_buffer *vb, AVFrame **pframe);
 
-// mark the consumer frame as consumed and return it
-// the frame is valid until the next call to this function
-const AVFrame *
-video_buffer_consumer_take_frame(struct video_buffer *vb);
+// mark the consumer frame as consumed and exchange it with an unused allocated
+// frame
+void
+video_buffer_consumer_take_frame(struct video_buffer *vb, AVFrame **pframe);
 
 // wake up and avoid any blocking call
 void

app/tests/test_control_msg_serialize.c

@@ -146,18 +146,14 @@ 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 == 2);
+    assert(size == 1);
 
     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 = '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'
+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'
 
 [host_machine]
 system = 'windows'

cross_win64.txt

@@ -2,11 +2,11 @@
 
 [binaries]
 name = 'mingw'
-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'
+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'
 
 [host_machine]
 system = 'windows'

data/scrcpy-noconsole.vbs

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

meson_options.txt

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

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

@@ -71,13 +71,6 @@ 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,7 +11,6 @@ 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;
 
@@ -67,15 +66,13 @@ 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:
@@ -153,14 +150,6 @@ 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 DEFAULT_DEVICE_ID = 0;
+    private static final int DEVICE_ID_VIRTUAL = -1;
 
     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 = 0;
+            coords.size = 1;
 
             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(msg.getAction());
+                    pressBackOrTurnScreenOn();
                 }
                 break;
             case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
@@ -208,13 +208,9 @@ 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, DEFAULT_DEVICE_ID, 0, source,
+                .obtain(lastTouchDown, now, action, pointerCount, pointerProperties, pointerCoords, 0, buttons, 1f, 1f, DEVICE_ID_VIRTUAL, 0, source,
                         0);
         return device.injectEvent(event);
     }
@@ -237,7 +233,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, DEFAULT_DEVICE_ID, 0,
+                .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
                         InputDevice.SOURCE_TOUCHSCREEN, 0);
         return device.injectEvent(event);
     }
@@ -255,22 +251,12 @@ public class Controller {
         }, 200, TimeUnit.MILLISECONDS);
     }
 
-    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) {
+    private boolean pressBackOrTurnScreenOn() {
+        int keycode = Device.isScreenOn() ? KeyEvent.KEYCODE_BACK : KeyEvent.KEYCODE_POWER;
+        if (keepPowerModeOff && keycode == KeyEvent.KEYCODE_POWER) {
             schedulePowerModeOff();
         }
-        return device.injectKeycode(KeyEvent.KEYCODE_POWER);
+        return device.injectKeycode(keycode);
     }
 
     private boolean setClipboard(String text, boolean paste) {

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

@@ -153,17 +153,13 @@ 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 static boolean injectEvent(InputEvent inputEvent, int mode, int displayId) {
-        if (!supportsInputEvents(displayId)) {
-            return false;
+    public boolean injectEvent(InputEvent inputEvent, int mode) {
+        if (!supportsInputEvents()) {
+            throw new AssertionError("Could not inject input event if !supportsInputEvents()");
         }
 
         if (displayId != 0 && !InputManager.setDisplayId(inputEvent, displayId)) {
@@ -173,29 +169,10 @@ 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,
@@ -203,10 +180,6 @@ 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);
     }
@@ -276,13 +249,6 @@ 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,7 +17,6 @@ public class Options {
     private boolean stayAwake;
     private String codecOptions;
     private String encoderName;
-    private boolean powerOffScreenOnClose;
 
     public Ln.Level getLogLevel() {
         return logLevel;
@@ -130,12 +129,4 @@ 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, options.getPowerOffScreenOnClose(), options.getDisplayId());
+        CleanUp.configure(mustDisableShowTouchesOnCleanUp, restoreStayOn, true);
 
         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 = 16;
+        final int expectedParameters = 15;
         if (args.length != expectedParameters) {
             throw new IllegalArgumentException("Expecting " + expectedParameters + " parameters");
         }
@@ -185,9 +185,6 @@ 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;
     }
 
@@ -233,7 +230,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 '" + encoder.getName() + "'");
+                    Ln.e("    scrcpy --encoder-name '" + encoder.getName() + "'");
                 }
             }
         }

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

@@ -154,7 +154,6 @@ 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();
 
@@ -162,7 +161,6 @@ 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