Enable mouse focus clickthrough in OTG mode

A single click on the window must both give focus and capture the mouse.

PR #2974 <https://github.com/Genymobile/scrcpy/pull/2974>

FAQ.md

@@ -219,6 +219,9 @@ scrcpy -m 1024
 scrcpy -m 800
 ```
 
+Since scrcpy v1.22, scrcpy automatically tries again with a lower definition
+before failing. This behavior can be disabled with `--no-downsize-on-error`.
+
 You could also try another [encoder](README.md#encoder).
 
 
@@ -245,8 +248,15 @@ Caused by: java.lang.IllegalArgumentException: displayToken must not be null
 
 ## Command line on Windows
 
-Some Windows users are not familiar with the command line. Here is how to open a
-terminal and run `scrcpy` with arguments:
+Since v1.22, a "shortcut" has been added to directly open a terminal in the
+scrcpy directory. Double-click on `open_a_terminal_here.bat`, then type your
+command. For example:
+
+```
+scrcpy --record file.mkv
+```
+
+You could also open a terminal and go to the scrcpy folder manually:
 
  1. Press <kbd>Windows</kbd>+<kbd>r</kbd>, this opens a dialog box.
  2. Type `cmd` and press <kbd>Enter</kbd>, this opens a terminal.

README.md

@@ -2,6 +2,8 @@
 
 <img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
 
+_pronounced "**scr**een **c**o**py**"_
+
 [Read in another language](#translations)
 
 This application provides display and control of Android devices connected via
@@ -33,6 +35,7 @@ Its features include:
    (Linux-only)
  - [physical mouse simulation (HID)](#physical-mouse-simulation-hid)
    (Linux-only)
+ - [OTG mode](#otg) (Linux-only)
  - and more…
 
 ## Requirements
@@ -847,6 +850,36 @@ Special capture keys, either <kbd>Alt</kbd> or <kbd>Super</kbd>, toggle
 the mouse back to the computer.
 
 
+#### OTG
+
+It is possible to run _scrcpy_ with only physical keyboard and mouse simulation
+(HID), as if the computer keyboard and mouse were plugged directly to the device
+via an OTG cable.
+
+In this mode, _adb_ (USB debugging) is not necessary, and mirroring is disabled.
+
+To enable OTG mode:
+
+```bash
+scrcpy --otg
+# Pass the serial if several USB devices are available
+scrcpy --otg -s 0123456789abcdef
+```
+
+It is possible to enable only HID keyboard or HID mouse:
+
+```bash
+scrcpy --otg --hid-keyboard              # keyboard only
+scrcpy --otg --hid-mouse                 # mouse only
+scrcpy --otg --hid-keyboard --hid-mouse  # keyboard and mouse
+# for convenience, enable both by default
+scrcpy --otg                             # keyboard and mouse
+```
+
+Like `--hid-keyboard` and `--hid-mouse`, it only works if the device is
+connected by USB, and is currently only supported on Linux.
+
+
 #### Text injection preference
 
 There are two kinds of [events][textevents] generated when typing text:

app/meson.build

@@ -11,7 +11,7 @@ src = [
     'src/decoder.c',
     'src/device_msg.c',
     'src/icon.c',
-    'src/file_handler.c',
+    'src/file_pusher.c',
     'src/fps_counter.c',
     'src/frame_buffer.c',
     'src/input_manager.c',
@@ -72,12 +72,15 @@ if v4l2_support
     src += [ 'src/v4l2_sink.c' ]
 endif
 
-aoa_hid_support = host_machine.system() == 'linux'
-if aoa_hid_support
+usb_support = host_machine.system() == 'linux'
+if usb_support
     src += [
-        'src/aoa_hid.c',
-        'src/hid_keyboard.c',
-        'src/hid_mouse.c',
+        'src/usb/aoa_hid.c',
+        'src/usb/hid_keyboard.c',
+        'src/usb/hid_mouse.c',
+        'src/usb/scrcpy_otg.c',
+        'src/usb/screen_otg.c',
+        'src/usb/usb.c',
     ]
 endif
 
@@ -99,7 +102,7 @@ if not crossbuild_windows
         dependencies += dependency('libavdevice')
     endif
 
-    if aoa_hid_support
+    if usb_support
         dependencies += dependency('libusb-1.0')
     endif
 
@@ -118,15 +121,20 @@ else
         include_directories: include_directories(sdl2_include_dir)
     )
 
-    prebuilt_ffmpeg_shared = meson.get_cross_property('prebuilt_ffmpeg_shared')
-    prebuilt_ffmpeg_dev = meson.get_cross_property('prebuilt_ffmpeg_dev')
-    ffmpeg_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_ffmpeg_shared + '/bin'
-    ffmpeg_include_dir = '../prebuilt-deps/' + prebuilt_ffmpeg_dev + '/include'
+    prebuilt_ffmpeg = meson.get_cross_property('prebuilt_ffmpeg')
+    ffmpeg_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_ffmpeg + '/bin'
+    ffmpeg_include_dir = '../prebuilt-deps/' + prebuilt_ffmpeg + '/include'
+
+    # ffmpeg versions are different for win32 and win64 builds
+    ffmpeg_avcodec = meson.get_cross_property('ffmpeg_avcodec')
+    ffmpeg_avformat = meson.get_cross_property('ffmpeg_avformat')
+    ffmpeg_avutil = meson.get_cross_property('ffmpeg_avutil')
+
     ffmpeg = declare_dependency(
         dependencies: [
-            cc.find_library('avcodec-58', dirs: ffmpeg_bin_dir),
-            cc.find_library('avformat-58', dirs: ffmpeg_bin_dir),
-            cc.find_library('avutil-56', dirs: ffmpeg_bin_dir),
+            cc.find_library(ffmpeg_avcodec, dirs: ffmpeg_bin_dir),
+            cc.find_library(ffmpeg_avformat, dirs: ffmpeg_bin_dir),
+            cc.find_library(ffmpeg_avutil, dirs: ffmpeg_bin_dir),
         ],
         include_directories: include_directories(ffmpeg_include_dir)
     )
@@ -188,7 +196,7 @@ conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == '
 conf.set('HAVE_V4L2', v4l2_support)
 
 # enable HID over AOA support (linux only)
-conf.set('HAVE_AOA_HID', aoa_hid_support)
+conf.set('HAVE_USB', usb_support)
 
 configure_file(configuration: conf, output: 'config.h')
 

app/scrcpy.1

@@ -140,6 +140,12 @@ By default, scrcpy automatically synchronizes the computer clipboard to the devi
 
 This option disables this automatic synchronization.
 
+.TP
+.B \-\-no\-downsize\-on\-error
+By default, on MediaCodec error, scrcpy automatically tries again with a lower definition.
+
+This option disables this behavior.
+
 .TP
 .B \-n, \-\-no\-control
 Disable device control (mirror the device in read\-only).
@@ -156,6 +162,20 @@ Do not forward repeated key events when a key is held down.
 .B \-\-no\-mipmaps
 If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then mipmaps are automatically generated to improve downscaling quality. This option disables the generation of mipmaps.
 
+.TP
+.B \-\-otg
+Run in OTG mode: simulate physical keyboard and mouse, as if the computer keyboard and mouse were plugged directly to the device via an OTG cable.
+
+In this mode, adb (USB debugging) is not necessary, and mirroring is disabled.
+
+LAlt, LSuper or RSuper toggle the mouse capture mode, to give control of the mouse back to the computer.
+
+If any of \fB\-\-hid\-keyboard\fR or \fB\-\-hid\-mouse\fR is set, only enable keyboard or mouse respectively, otherwise enable both.
+
+It may only work over USB, and is currently only supported on Linux.
+
+See \fB\-\-hid\-keyboard\fR and \fB\-\-hid\-mouse\fR.
+
 .TP
 .BI "\-p, \-\-port " port[:port]
 Set the TCP port (range) used by the client to listen.

app/src/adb.c

@@ -425,7 +425,7 @@ adb_get_serialno(struct sc_intr *intr, unsigned flags) {
     }
 
     if (r == -1) {
-        return false;
+        return NULL;
     }
 
     sc_str_truncate(buf, r, " \r\n");
@@ -455,7 +455,7 @@ adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
     }
 
     if (r == -1) {
-        return false;
+        return NULL;
     }
 
     assert((size_t) r <= sizeof(buf));

app/src/cli.c

@@ -52,6 +52,8 @@
 #define OPT_NO_CLIPBOARD_AUTOSYNC  1032
 #define OPT_TCPIP                  1033
 #define OPT_RAW_KEY_EVENTS         1034
+#define OPT_NO_DOWNSIZE_ON_ERROR   1035
+#define OPT_OTG                    1036
 
 struct sc_option {
     char shortopt;
@@ -236,6 +238,13 @@ static const struct sc_option options[] = {
                 "is preserved.\n"
                 "Default is 0 (unlimited).",
     },
+    {
+        .longopt_id = OPT_NO_DOWNSIZE_ON_ERROR,
+        .longopt = "no-downsize-on-error",
+        .text = "By default, on MediaCodec error, scrcpy automatically tries "
+                "again with a lower definition.\n"
+                "This option disables this behavior.",
+    },
     {
         .longopt_id = OPT_NO_CLIPBOARD_AUTOSYNC,
         .longopt = "no-clipboard-autosync",
@@ -268,6 +277,22 @@ static const struct sc_option options[] = {
                 "mipmaps are automatically generated to improve downscaling "
                 "quality. This option disables the generation of mipmaps.",
     },
+    {
+        .longopt_id = OPT_OTG,
+        .longopt = "otg",
+        .text = "Run in OTG mode: simulate physical keyboard and mouse, "
+                "as if the computer keyboard and mouse were plugged directly "
+                "to the device via an OTG cable.\n"
+                "In this mode, adb (USB debugging) is not necessary, and "
+                "mirroring is disabled.\n"
+                "LAlt, LSuper or RSuper toggle the mouse capture mode, to give "
+                "control of the mouse back to the computer.\n"
+                "If any of --hid-keyboard or --hid-mouse is set, only enable "
+                "keyboard or mouse respectively, otherwise enable both."
+                "It may only work over USB, and is currently only supported "
+                "on Linux.\n"
+                "See --hid-keyboard and --hid-mouse.",
+    },
     {
         .shortopt = 'p',
         .longopt = "port",
@@ -1310,14 +1335,14 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                 args->help = true;
                 break;
             case 'K':
-#ifdef HAVE_AOA_HID
+#ifdef HAVE_USB
                 opts->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_HID;
+                break;
 #else
                 LOGE("HID over AOA (-K/--hid-keyboard) is not supported on "
                      "this platform. It is only available on Linux.");
                 return false;
 #endif
-                break;
             case OPT_MAX_FPS:
                 if (!parse_max_fps(optarg, &opts->max_fps)) {
                     return false;
@@ -1329,14 +1354,14 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                 }
                 break;
             case 'M':
-#ifdef HAVE_AOA_HID
+#ifdef HAVE_USB
                 opts->mouse_input_mode = SC_MOUSE_INPUT_MODE_HID;
+                break;
 #else
                 LOGE("HID over AOA (-M/--hid-mouse) is not supported on this"
                      "platform. It is only available on Linux.");
                 return false;
 #endif
-                break;
             case OPT_LOCK_VIDEO_ORIENTATION:
                 if (!parse_lock_video_orientation(optarg,
                         &opts->lock_video_orientation)) {
@@ -1489,24 +1514,36 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                 opts->tcpip = true;
                 opts->tcpip_dst = optarg;
                 break;
+            case OPT_NO_DOWNSIZE_ON_ERROR:
+                opts->downsize_on_error = false;
+                break;
+            case OPT_OTG:
+#ifdef HAVE_USB
+                opts->otg = true;
+                break;
+#else
+                LOGE("OTG mode (--otg) is not supported on this platform. It "
+                     "is only available on Linux.");
+                return false;
+#endif
             case OPT_V4L2_SINK:
 #ifdef HAVE_V4L2
                 opts->v4l2_device = optarg;
+                break;
 #else
                 LOGE("V4L2 (--v4l2-sink) is only available on Linux.");
                 return false;
 #endif
-                break;
             case OPT_V4L2_BUFFER:
 #ifdef HAVE_V4L2
                 if (!parse_buffering_time(optarg, &opts->v4l2_buffer)) {
                     return false;
                 }
+                break;
 #else
                 LOGE("V4L2 (--v4l2-buffer) is only available on Linux.");
                 return false;
 #endif
-                break;
             default:
                 // getopt prints the error message on stderr
                 return false;
@@ -1534,11 +1571,18 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         return false;
     }
 
-    if (opts->v4l2_device && opts->lock_video_orientation
-                             == SC_LOCK_VIDEO_ORIENTATION_UNLOCKED) {
-        LOGI("Video orientation is locked for v4l2 sink. "
-             "See --lock-video-orientation.");
-        opts->lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_INITIAL;
+    if (opts->v4l2_device) {
+        if (opts->lock_video_orientation ==
+                SC_LOCK_VIDEO_ORIENTATION_UNLOCKED) {
+            LOGI("Video orientation is locked for v4l2 sink. "
+                 "See --lock-video-orientation.");
+            opts->lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_INITIAL;
+        }
+
+        // V4L2 could not handle size change.
+        // Do not log because downsizing on error is the default behavior,
+        // not an explicit request from the user.
+        opts->downsize_on_error = false;
     }
 
     if (opts->v4l2_buffer && !opts->v4l2_device) {
@@ -1573,15 +1617,61 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         }
     }
 
-    if (!opts->control && opts->turn_screen_off) {
-        LOGE("Could not request to turn screen off if control is disabled");
-        return false;
+    if (!opts->control) {
+        if (opts->turn_screen_off) {
+            LOGE("Could not request to turn screen off if control is disabled");
+            return false;
+        }
+        if (opts->stay_awake) {
+            LOGE("Could not request to stay awake if control is disabled");
+            return false;
+        }
+        if (opts->show_touches) {
+            LOGE("Could not request to show touches if control is disabled");
+            return false;
+        }
+        if (opts->power_off_on_close) {
+            LOGE("Could not request power off on close if control is disabled");
+            return false;
+        }
     }
 
-    if (!opts->control && opts->stay_awake) {
-        LOGE("Could not request to stay awake if control is disabled");
-        return false;
+#ifdef HAVE_USB
+    if (opts->otg) {
+        // OTG mode is compatible with only very few options.
+        // Only report obvious errors.
+        if (opts->record_filename) {
+            LOGE("OTG mode: could not record");
+            return false;
+        }
+        if (opts->turn_screen_off) {
+            LOGE("OTG mode: could not turn screen off");
+            return false;
+        }
+        if (opts->stay_awake) {
+            LOGE("OTG mode: could not stay awake");
+            return false;
+        }
+        if (opts->show_touches) {
+            LOGE("OTG mode: could not request to show touches");
+            return false;
+        }
+        if (opts->power_off_on_close) {
+            LOGE("OTG mode: could not request power off on close");
+            return false;
+        }
+        if (opts->display_id) {
+            LOGE("OTG mode: could not select display");
+            return false;
+        }
+#ifdef HAVE_V4L2
+        if (opts->v4l2_device) {
+            LOGE("OTG mode: could not sink to V4L2 device");
+            return false;
+        }
+#endif
     }
+#endif
 
     return true;
 }

app/src/control_msg.c

@@ -92,19 +92,19 @@ size_t
 sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
     buf[0] = msg->type;
     switch (msg->type) {
-        case CONTROL_MSG_TYPE_INJECT_KEYCODE:
+        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
             buf[1] = msg->inject_keycode.action;
             buffer_write32be(&buf[2], msg->inject_keycode.keycode);
             buffer_write32be(&buf[6], msg->inject_keycode.repeat);
             buffer_write32be(&buf[10], msg->inject_keycode.metastate);
             return 14;
-        case CONTROL_MSG_TYPE_INJECT_TEXT: {
+        case SC_CONTROL_MSG_TYPE_INJECT_TEXT: {
             size_t len =
                 write_string(msg->inject_text.text,
-                             CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
+                             SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
             return 1 + len;
         }
-        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
+        case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
             buf[1] = msg->inject_touch_event.action;
             buffer_write64be(&buf[2], msg->inject_touch_event.pointer_id);
             write_position(&buf[10], &msg->inject_touch_event.position);
@@ -113,7 +113,7 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
             buffer_write16be(&buf[22], pressure);
             buffer_write32be(&buf[24], msg->inject_touch_event.buttons);
             return 28;
-        case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
+        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
             write_position(&buf[1], &msg->inject_scroll_event.position);
             buffer_write32be(&buf[13],
                              (uint32_t) msg->inject_scroll_event.hscroll);
@@ -121,27 +121,26 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
                              (uint32_t) msg->inject_scroll_event.vscroll);
             buffer_write32be(&buf[21], msg->inject_scroll_event.buttons);
             return 25;
-        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
+        case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
             buf[1] = msg->inject_keycode.action;
             return 2;
-        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
+        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
             buf[1] = msg->get_clipboard.copy_key;
             return 2;
-        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
+        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
             buffer_write64be(&buf[1], msg->set_clipboard.sequence);
             buf[9] = !!msg->set_clipboard.paste;
             size_t len = write_string(msg->set_clipboard.text,
-                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
+                                      SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
                                       &buf[10]);
             return 10 + len;
-        }
-        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
+        case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
             buf[1] = msg->set_screen_power_mode.mode;
             return 2;
-        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
-        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
-        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
+        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
+        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
+        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
+        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
             // no additional data
             return 1;
         default:
@@ -154,17 +153,17 @@ void
 sc_control_msg_log(const struct sc_control_msg *msg) {
 #define LOG_CMSG(fmt, ...) LOGV("input: " fmt, ## __VA_ARGS__)
     switch (msg->type) {
-        case CONTROL_MSG_TYPE_INJECT_KEYCODE:
+        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
             LOG_CMSG("key %-4s code=%d repeat=%" PRIu32 " meta=%06lx",
                      KEYEVENT_ACTION_LABEL(msg->inject_keycode.action),
                      (int) msg->inject_keycode.keycode,
                      msg->inject_keycode.repeat,
                      (long) msg->inject_keycode.metastate);
             break;
-        case CONTROL_MSG_TYPE_INJECT_TEXT:
+        case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
             LOG_CMSG("text \"%s\"", msg->inject_text.text);
             break;
-        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: {
+        case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: {
             int action = msg->inject_touch_event.action
                        & AMOTION_EVENT_ACTION_MASK;
             uint64_t id = msg->inject_touch_event.pointer_id;
@@ -191,7 +190,7 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
             }
             break;
         }
-        case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
+        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
             LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%" PRIi32
                          " vscroll=%" PRIi32 " buttons=%06lx",
                      msg->inject_scroll_event.position.point.x,
@@ -200,34 +199,34 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
                      msg->inject_scroll_event.vscroll,
                      (long) msg->inject_scroll_event.buttons);
             break;
-        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
+        case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
             LOG_CMSG("back-or-screen-on %s",
                      KEYEVENT_ACTION_LABEL(msg->inject_keycode.action));
             break;
-        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
+        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
             LOG_CMSG("get clipboard copy_key=%s",
                      copy_key_labels[msg->get_clipboard.copy_key]);
             break;
-        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
+        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
             LOG_CMSG("clipboard %" PRIu64_ " %s \"%s\"",
                      msg->set_clipboard.sequence,
                      msg->set_clipboard.paste ? "paste" : "nopaste",
                      msg->set_clipboard.text);
             break;
-        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
+        case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
             LOG_CMSG("power mode %s",
                      SCREEN_POWER_MODE_LABEL(msg->set_screen_power_mode.mode));
             break;
-        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
+        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
             LOG_CMSG("expand notification panel");
             break;
-        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
+        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
             LOG_CMSG("expand settings panel");
             break;
-        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
+        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
             LOG_CMSG("collapse panels");
             break;
-        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
+        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
             LOG_CMSG("rotate device");
             break;
         default:
@@ -239,10 +238,10 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
 void
 sc_control_msg_destroy(struct sc_control_msg *msg) {
     switch (msg->type) {
-        case CONTROL_MSG_TYPE_INJECT_TEXT:
+        case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
             free(msg->inject_text.text);
             break;
-        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
+        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
             free(msg->set_clipboard.text);
             break;
         default:

app/src/control_msg.h

@@ -11,40 +11,40 @@
 #include "android/keycodes.h"
 #include "coords.h"
 
-#define CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
+#define SC_CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
 
-#define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
+#define SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
 // type: 1 byte; sequence: 8 bytes; paste flag: 1 byte; length: 4 bytes
-#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (CONTROL_MSG_MAX_SIZE - 14)
+#define SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (SC_CONTROL_MSG_MAX_SIZE - 14)
 
 #define POINTER_ID_MOUSE UINT64_C(-1)
 #define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2)
 
 enum sc_control_msg_type {
-    CONTROL_MSG_TYPE_INJECT_KEYCODE,
-    CONTROL_MSG_TYPE_INJECT_TEXT,
-    CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-    CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
-    CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
-    CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
-    CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
-    CONTROL_MSG_TYPE_COLLAPSE_PANELS,
-    CONTROL_MSG_TYPE_GET_CLIPBOARD,
-    CONTROL_MSG_TYPE_SET_CLIPBOARD,
-    CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
-    CONTROL_MSG_TYPE_ROTATE_DEVICE,
+    SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
+    SC_CONTROL_MSG_TYPE_INJECT_TEXT,
+    SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+    SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
+    SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
+    SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
+    SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+    SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
+    SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
+    SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
+    SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
+    SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
 };
 
-enum screen_power_mode {
+enum sc_screen_power_mode {
     // see <https://android.googlesource.com/platform/frameworks/base.git/+/pie-release-2/core/java/android/view/SurfaceControl.java#305>
-    SCREEN_POWER_MODE_OFF = 0,
-    SCREEN_POWER_MODE_NORMAL = 2,
+    SC_SCREEN_POWER_MODE_OFF = 0,
+    SC_SCREEN_POWER_MODE_NORMAL = 2,
 };
 
-enum get_clipboard_copy_key {
-    GET_CLIPBOARD_COPY_KEY_NONE,
-    GET_CLIPBOARD_COPY_KEY_COPY,
-    GET_CLIPBOARD_COPY_KEY_CUT,
+enum sc_copy_key {
+    SC_COPY_KEY_NONE,
+    SC_COPY_KEY_COPY,
+    SC_COPY_KEY_CUT,
 };
 
 struct sc_control_msg {
@@ -77,7 +77,7 @@ struct sc_control_msg {
             // screen may only be turned on on ACTION_DOWN
         } back_or_screen_on;
         struct {
-            enum get_clipboard_copy_key copy_key;
+            enum sc_copy_key copy_key;
         } get_clipboard;
         struct {
             uint64_t sequence;
@@ -85,7 +85,7 @@ struct sc_control_msg {
             bool paste;
         } set_clipboard;
         struct {
-            enum screen_power_mode mode;
+            enum sc_screen_power_mode mode;
         } set_screen_power_mode;
     };
 };

app/src/controller.c

@@ -66,7 +66,7 @@ sc_controller_push_msg(struct sc_controller *controller,
 static bool
 process_msg(struct sc_controller *controller,
             const struct sc_control_msg *msg) {
-    static unsigned char serialized_msg[CONTROL_MSG_MAX_SIZE];
+    static unsigned char serialized_msg[SC_CONTROL_MSG_MAX_SIZE];
     size_t length = sc_control_msg_serialize(msg, serialized_msg);
     if (!length) {
         return false;

app/src/events.h

@@ -2,3 +2,4 @@
 #define EVENT_STREAM_STOPPED           (SDL_USEREVENT + 1)
 #define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
 #define EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
+#define EVENT_USB_DEVICE_DISCONNECTED  (SDL_USEREVENT + 4)

app/src/file_handler.c

@@ -1,178 +0,0 @@
-#include "file_handler.h"
-
-#include <assert.h>
-#include <string.h>
-
-#include "adb.h"
-#include "util/log.h"
-#include "util/process_intr.h"
-
-#define DEFAULT_PUSH_TARGET "/sdcard/Download/"
-
-static void
-file_handler_request_destroy(struct file_handler_request *req) {
-    free(req->file);
-}
-
-bool
-file_handler_init(struct file_handler *file_handler, const char *serial,
-                  const char *push_target) {
-    assert(serial);
-
-    cbuf_init(&file_handler->queue);
-
-    bool ok = sc_mutex_init(&file_handler->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&file_handler->event_cond);
-    if (!ok) {
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
-    }
-
-    ok = sc_intr_init(&file_handler->intr);
-    if (!ok) {
-        sc_cond_destroy(&file_handler->event_cond);
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
-    }
-
-    file_handler->serial = strdup(serial);
-    if (!file_handler->serial) {
-        LOG_OOM();
-        sc_intr_destroy(&file_handler->intr);
-        sc_cond_destroy(&file_handler->event_cond);
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
-    }
-
-    // lazy initialization
-    file_handler->initialized = false;
-
-    file_handler->stopped = false;
-
-    file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
-
-    return true;
-}
-
-void
-file_handler_destroy(struct file_handler *file_handler) {
-    sc_cond_destroy(&file_handler->event_cond);
-    sc_mutex_destroy(&file_handler->mutex);
-    sc_intr_destroy(&file_handler->intr);
-    free(file_handler->serial);
-
-    struct file_handler_request req;
-    while (cbuf_take(&file_handler->queue, &req)) {
-        file_handler_request_destroy(&req);
-    }
-}
-
-bool
-file_handler_request(struct file_handler *file_handler,
-                     file_handler_action_t action, char *file) {
-    // start file_handler if it's used for the first time
-    if (!file_handler->initialized) {
-        if (!file_handler_start(file_handler)) {
-            return false;
-        }
-        file_handler->initialized = true;
-    }
-
-    LOGI("Request to %s %s", action == ACTION_INSTALL_APK ? "install" : "push",
-                             file);
-    struct file_handler_request req = {
-        .action = action,
-        .file = file,
-    };
-
-    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) {
-        sc_cond_signal(&file_handler->event_cond);
-    }
-    sc_mutex_unlock(&file_handler->mutex);
-    return res;
-}
-
-static int
-run_file_handler(void *data) {
-    struct file_handler *file_handler = data;
-    struct sc_intr *intr = &file_handler->intr;
-
-    const char *serial = file_handler->serial;
-    assert(serial);
-
-    const char *push_target = file_handler->push_target;
-    assert(push_target);
-
-    for (;;) {
-        sc_mutex_lock(&file_handler->mutex);
-        while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
-            sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
-        }
-        if (file_handler->stopped) {
-            // stop immediately, do not process further events
-            sc_mutex_unlock(&file_handler->mutex);
-            break;
-        }
-        struct file_handler_request req;
-        bool non_empty = cbuf_take(&file_handler->queue, &req);
-        assert(non_empty);
-        (void) non_empty;
-        sc_mutex_unlock(&file_handler->mutex);
-
-        if (req.action == ACTION_INSTALL_APK) {
-            LOGI("Installing %s...", req.file);
-            bool ok = adb_install(intr, serial, req.file, 0);
-            if (ok) {
-                LOGI("%s successfully installed", req.file);
-            } else {
-                LOGE("Failed to install %s", req.file);
-            }
-        } else {
-            LOGI("Pushing %s...", req.file);
-            bool ok = adb_push(intr, serial, req.file, push_target, 0);
-            if (ok) {
-                LOGI("%s successfully pushed to %s", req.file, push_target);
-            } else {
-                LOGE("Failed to push %s to %s", req.file, push_target);
-            }
-        }
-
-        file_handler_request_destroy(&req);
-    }
-    return 0;
-}
-
-bool
-file_handler_start(struct file_handler *file_handler) {
-    LOGD("Starting file_handler thread");
-
-    bool ok = sc_thread_create(&file_handler->thread, run_file_handler,
-                               "scrcpy-file", file_handler);
-    if (!ok) {
-        LOGC("Could not start file_handler thread");
-        return false;
-    }
-
-    return true;
-}
-
-void
-file_handler_stop(struct file_handler *file_handler) {
-    sc_mutex_lock(&file_handler->mutex);
-    file_handler->stopped = true;
-    sc_cond_signal(&file_handler->event_cond);
-    sc_intr_interrupt(&file_handler->intr);
-    sc_mutex_unlock(&file_handler->mutex);
-}
-
-void
-file_handler_join(struct file_handler *file_handler) {
-    sc_thread_join(&file_handler->thread, NULL);
-}

app/src/file_handler.h

@@ -1,60 +0,0 @@
-#ifndef FILE_HANDLER_H
-#define FILE_HANDLER_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "adb.h"
-#include "util/cbuf.h"
-#include "util/thread.h"
-#include "util/intr.h"
-
-typedef enum {
-    ACTION_INSTALL_APK,
-    ACTION_PUSH_FILE,
-} file_handler_action_t;
-
-struct file_handler_request {
-    file_handler_action_t action;
-    char *file;
-};
-
-struct file_handler_request_queue CBUF(struct file_handler_request, 16);
-
-struct file_handler {
-    char *serial;
-    const char *push_target;
-    sc_thread thread;
-    sc_mutex mutex;
-    sc_cond event_cond;
-    bool stopped;
-    bool initialized;
-    struct file_handler_request_queue queue;
-
-    struct sc_intr intr;
-};
-
-bool
-file_handler_init(struct file_handler *file_handler, const char *serial,
-                  const char *push_target);
-
-void
-file_handler_destroy(struct file_handler *file_handler);
-
-bool
-file_handler_start(struct file_handler *file_handler);
-
-void
-file_handler_stop(struct file_handler *file_handler);
-
-void
-file_handler_join(struct file_handler *file_handler);
-
-// take ownership of file, and will free() it
-bool
-file_handler_request(struct file_handler *file_handler,
-                     file_handler_action_t action,
-                     char *file);
-
-#endif

app/src/file_pusher.c

@@ -0,0 +1,178 @@
+#include "file_pusher.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "adb.h"
+#include "util/log.h"
+#include "util/process_intr.h"
+
+#define DEFAULT_PUSH_TARGET "/sdcard/Download/"
+
+static void
+sc_file_pusher_request_destroy(struct sc_file_pusher_request *req) {
+    free(req->file);
+}
+
+bool
+sc_file_pusher_init(struct sc_file_pusher *fp, const char *serial,
+                    const char *push_target) {
+    assert(serial);
+
+    cbuf_init(&fp->queue);
+
+    bool ok = sc_mutex_init(&fp->mutex);
+    if (!ok) {
+        return false;
+    }
+
+    ok = sc_cond_init(&fp->event_cond);
+    if (!ok) {
+        sc_mutex_destroy(&fp->mutex);
+        return false;
+    }
+
+    ok = sc_intr_init(&fp->intr);
+    if (!ok) {
+        sc_cond_destroy(&fp->event_cond);
+        sc_mutex_destroy(&fp->mutex);
+        return false;
+    }
+
+    fp->serial = strdup(serial);
+    if (!fp->serial) {
+        LOG_OOM();
+        sc_intr_destroy(&fp->intr);
+        sc_cond_destroy(&fp->event_cond);
+        sc_mutex_destroy(&fp->mutex);
+        return false;
+    }
+
+    // lazy initialization
+    fp->initialized = false;
+
+    fp->stopped = false;
+
+    fp->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
+
+    return true;
+}
+
+void
+sc_file_pusher_destroy(struct sc_file_pusher *fp) {
+    sc_cond_destroy(&fp->event_cond);
+    sc_mutex_destroy(&fp->mutex);
+    sc_intr_destroy(&fp->intr);
+    free(fp->serial);
+
+    struct sc_file_pusher_request req;
+    while (cbuf_take(&fp->queue, &req)) {
+        sc_file_pusher_request_destroy(&req);
+    }
+}
+
+bool
+sc_file_pusher_request(struct sc_file_pusher *fp,
+                       enum sc_file_pusher_action action, char *file) {
+    // start file_pusher if it's used for the first time
+    if (!fp->initialized) {
+        if (!sc_file_pusher_start(fp)) {
+            return false;
+        }
+        fp->initialized = true;
+    }
+
+    LOGI("Request to %s %s", action == SC_FILE_PUSHER_ACTION_INSTALL_APK
+                                 ? "install" : "push",
+                             file);
+    struct sc_file_pusher_request req = {
+        .action = action,
+        .file = file,
+    };
+
+    sc_mutex_lock(&fp->mutex);
+    bool was_empty = cbuf_is_empty(&fp->queue);
+    bool res = cbuf_push(&fp->queue, req);
+    if (was_empty) {
+        sc_cond_signal(&fp->event_cond);
+    }
+    sc_mutex_unlock(&fp->mutex);
+    return res;
+}
+
+static int
+run_file_pusher(void *data) {
+    struct sc_file_pusher *fp = data;
+    struct sc_intr *intr = &fp->intr;
+
+    const char *serial = fp->serial;
+    assert(serial);
+
+    const char *push_target = fp->push_target;
+    assert(push_target);
+
+    for (;;) {
+        sc_mutex_lock(&fp->mutex);
+        while (!fp->stopped && cbuf_is_empty(&fp->queue)) {
+            sc_cond_wait(&fp->event_cond, &fp->mutex);
+        }
+        if (fp->stopped) {
+            // stop immediately, do not process further events
+            sc_mutex_unlock(&fp->mutex);
+            break;
+        }
+        struct sc_file_pusher_request req;
+        bool non_empty = cbuf_take(&fp->queue, &req);
+        assert(non_empty);
+        (void) non_empty;
+        sc_mutex_unlock(&fp->mutex);
+
+        if (req.action == SC_FILE_PUSHER_ACTION_INSTALL_APK) {
+            LOGI("Installing %s...", req.file);
+            bool ok = adb_install(intr, serial, req.file, 0);
+            if (ok) {
+                LOGI("%s successfully installed", req.file);
+            } else {
+                LOGE("Failed to install %s", req.file);
+            }
+        } else {
+            LOGI("Pushing %s...", req.file);
+            bool ok = adb_push(intr, serial, req.file, push_target, 0);
+            if (ok) {
+                LOGI("%s successfully pushed to %s", req.file, push_target);
+            } else {
+                LOGE("Failed to push %s to %s", req.file, push_target);
+            }
+        }
+
+        sc_file_pusher_request_destroy(&req);
+    }
+    return 0;
+}
+
+bool
+sc_file_pusher_start(struct sc_file_pusher *fp) {
+    LOGD("Starting file_pusher thread");
+
+    bool ok = sc_thread_create(&fp->thread, run_file_pusher, "scrcpy-file", fp);
+    if (!ok) {
+        LOGC("Could not start file_pusher thread");
+        return false;
+    }
+
+    return true;
+}
+
+void
+sc_file_pusher_stop(struct sc_file_pusher *fp) {
+    sc_mutex_lock(&fp->mutex);
+    fp->stopped = true;
+    sc_cond_signal(&fp->event_cond);
+    sc_intr_interrupt(&fp->intr);
+    sc_mutex_unlock(&fp->mutex);
+}
+
+void
+sc_file_pusher_join(struct sc_file_pusher *fp) {
+    sc_thread_join(&fp->thread, NULL);
+}

app/src/file_pusher.h

@@ -0,0 +1,59 @@
+#ifndef SC_FILE_PUSHER_H
+#define SC_FILE_PUSHER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "adb.h"
+#include "util/cbuf.h"
+#include "util/thread.h"
+#include "util/intr.h"
+
+enum sc_file_pusher_action {
+    SC_FILE_PUSHER_ACTION_INSTALL_APK,
+    SC_FILE_PUSHER_ACTION_PUSH_FILE,
+};
+
+struct sc_file_pusher_request {
+    enum sc_file_pusher_action action;
+    char *file;
+};
+
+struct sc_file_pusher_request_queue CBUF(struct sc_file_pusher_request, 16);
+
+struct sc_file_pusher {
+    char *serial;
+    const char *push_target;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond event_cond;
+    bool stopped;
+    bool initialized;
+    struct sc_file_pusher_request_queue queue;
+
+    struct sc_intr intr;
+};
+
+bool
+sc_file_pusher_init(struct sc_file_pusher *fp, const char *serial,
+                    const char *push_target);
+
+void
+sc_file_pusher_destroy(struct sc_file_pusher *fp);
+
+bool
+sc_file_pusher_start(struct sc_file_pusher *fp);
+
+void
+sc_file_pusher_stop(struct sc_file_pusher *fp);
+
+void
+sc_file_pusher_join(struct sc_file_pusher *fp);
+
+// take ownership of file, and will free() it
+bool
+sc_file_pusher_request(struct sc_file_pusher *fp,
+                       enum sc_file_pusher_action action, char *file);
+
+#endif

app/src/frame_buffer.c

@@ -50,9 +50,7 @@ swap_frames(AVFrame **lhs, AVFrame **rhs) {
 
 bool
 sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
-                  bool *previous_frame_skipped) {
-    sc_mutex_lock(&fb->mutex);
-
+                     bool *previous_frame_skipped) {
     // Use a temporary frame to preserve pending_frame in case of error.
     // tmp_frame is an empty frame, no need to call av_frame_unref() beforehand.
     int r = av_frame_ref(fb->tmp_frame, frame);
@@ -61,6 +59,8 @@ sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
         return false;
     }
 
+    sc_mutex_lock(&fb->mutex);
+
     // Now that av_frame_ref() succeeded, we can replace the previous
     // pending_frame
     swap_frames(&fb->pending_frame, &fb->tmp_frame);

app/src/input_events.h

@@ -377,4 +377,76 @@ struct sc_touch_event {
     float pressure;
 };
 
+static inline uint16_t
+sc_mods_state_from_sdl(uint16_t mods_state) {
+    return mods_state;
+}
+
+static inline enum sc_keycode
+sc_keycode_from_sdl(SDL_Keycode keycode) {
+    return (enum sc_keycode) keycode;
+}
+
+static inline enum sc_scancode
+sc_scancode_from_sdl(SDL_Scancode scancode) {
+    return (enum sc_scancode) scancode;
+}
+
+static inline enum sc_action
+sc_action_from_sdl_keyboard_type(uint32_t type) {
+    assert(type == SDL_KEYDOWN || type == SDL_KEYUP);
+    if (type == SDL_KEYDOWN) {
+        return SC_ACTION_DOWN;
+    }
+    return SC_ACTION_UP;
+}
+
+static inline enum sc_action
+sc_action_from_sdl_mousebutton_type(uint32_t type) {
+    assert(type == SDL_MOUSEBUTTONDOWN || type == SDL_MOUSEBUTTONUP);
+    if (type == SDL_MOUSEBUTTONDOWN) {
+        return SC_ACTION_DOWN;
+    }
+    return SC_ACTION_UP;
+}
+
+static inline enum sc_touch_action
+sc_touch_action_from_sdl(uint32_t type) {
+    assert(type == SDL_FINGERMOTION || type == SDL_FINGERDOWN ||
+           type == SDL_FINGERUP);
+    if (type == SDL_FINGERMOTION) {
+        return SC_TOUCH_ACTION_MOVE;
+    }
+    if (type == SDL_FINGERDOWN) {
+        return SC_TOUCH_ACTION_DOWN;
+    }
+    return SC_TOUCH_ACTION_UP;
+}
+
+static inline enum sc_mouse_button
+sc_mouse_button_from_sdl(uint8_t button) {
+    if (button >= SDL_BUTTON_LEFT && button <= SDL_BUTTON_X2) {
+        // SC_MOUSE_BUTTON_* constants are initialized from SDL_BUTTON(index)
+        return SDL_BUTTON(button);
+    }
+
+    return SC_MOUSE_BUTTON_UNKNOWN;
+}
+
+static inline uint8_t
+sc_mouse_buttons_state_from_sdl(uint32_t buttons_state,
+                                bool forward_all_clicks) {
+    assert(buttons_state < 0x100); // fits in uint8_t
+
+    uint8_t mask = SC_MOUSE_BUTTON_LEFT;
+    if (forward_all_clicks) {
+        mask |= SC_MOUSE_BUTTON_RIGHT
+              | SC_MOUSE_BUTTON_MIDDLE
+              | SC_MOUSE_BUTTON_X1
+              | SC_MOUSE_BUTTON_X2;
+    }
+
+    return buttons_state & mask;
+}
+
 #endif

app/src/input_manager.c

@@ -7,78 +7,6 @@
 #include "screen.h"
 #include "util/log.h"
 
-static inline uint16_t
-sc_mods_state_from_sdl(uint16_t mods_state) {
-    return mods_state;
-}
-
-static inline enum sc_keycode
-sc_keycode_from_sdl(SDL_Keycode keycode) {
-    return (enum sc_keycode) keycode;
-}
-
-static inline enum sc_scancode
-sc_scancode_from_sdl(SDL_Scancode scancode) {
-    return (enum sc_scancode) scancode;
-}
-
-static inline enum sc_action
-sc_action_from_sdl_keyboard_type(uint32_t type) {
-    assert(type == SDL_KEYDOWN || type == SDL_KEYUP);
-    if (type == SDL_KEYDOWN) {
-        return SC_ACTION_DOWN;
-    }
-    return SC_ACTION_UP;
-}
-
-static inline enum sc_action
-sc_action_from_sdl_mousebutton_type(uint32_t type) {
-    assert(type == SDL_MOUSEBUTTONDOWN || type == SDL_MOUSEBUTTONUP);
-    if (type == SDL_MOUSEBUTTONDOWN) {
-        return SC_ACTION_DOWN;
-    }
-    return SC_ACTION_UP;
-}
-
-static inline enum sc_touch_action
-sc_touch_action_from_sdl(uint32_t type) {
-    assert(type == SDL_FINGERMOTION || type == SDL_FINGERDOWN ||
-           type == SDL_FINGERUP);
-    if (type == SDL_FINGERMOTION) {
-        return SC_TOUCH_ACTION_MOVE;
-    }
-    if (type == SDL_FINGERDOWN) {
-        return SC_TOUCH_ACTION_DOWN;
-    }
-    return SC_TOUCH_ACTION_UP;
-}
-
-static inline enum sc_mouse_button
-sc_mouse_button_from_sdl(uint8_t button) {
-    if (button >= SDL_BUTTON_LEFT && button <= SDL_BUTTON_X2) {
-        // SC_MOUSE_BUTTON_* constants are initialized from SDL_BUTTON(index)
-        return SDL_BUTTON(button);
-    }
-
-    return SC_MOUSE_BUTTON_UNKNOWN;
-}
-
-static inline uint8_t
-sc_mouse_buttons_state_from_sdl(uint32_t buttons_state,
-                                bool forward_all_clicks) {
-    assert(buttons_state < 0x100); // fits in uint8_t
-
-    uint8_t mask = SC_MOUSE_BUTTON_LEFT;
-    if (forward_all_clicks) {
-        mask |= SC_MOUSE_BUTTON_RIGHT
-              | SC_MOUSE_BUTTON_MIDDLE
-              | SC_MOUSE_BUTTON_X1
-              | SC_MOUSE_BUTTON_X2;
-    }
-
-    return buttons_state & mask;
-}
-
 #define SC_SDL_SHORTCUT_MODS_MASK (KMOD_CTRL | KMOD_ALT | KMOD_GUI)
 
 static inline uint16_t
@@ -124,15 +52,15 @@ is_shortcut_mod(struct sc_input_manager *im, uint16_t sdl_mod) {
 void
 sc_input_manager_init(struct sc_input_manager *im,
                       const struct sc_input_manager_params *params) {
-    assert(!params->control || (params->kp && params->kp->ops));
-    assert(!params->control || (params->mp && params->mp->ops));
+    assert(!params->controller || (params->kp && params->kp->ops));
+    assert(!params->controller || (params->mp && params->mp->ops));
 
     im->controller = params->controller;
+    im->fp = params->fp;
     im->screen = params->screen;
     im->kp = params->kp;
     im->mp = params->mp;
 
-    im->control = params->control;
     im->forward_all_clicks = params->forward_all_clicks;
     im->legacy_paste = params->legacy_paste;
     im->clipboard_autosync = params->clipboard_autosync;
@@ -161,7 +89,7 @@ send_keycode(struct sc_controller *controller, enum android_keycode keycode,
              enum sc_action action, const char *name) {
     // send DOWN event
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
+    msg.type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
     msg.inject_keycode.action = action == SC_ACTION_DOWN
                               ? AKEY_EVENT_ACTION_DOWN
                               : AKEY_EVENT_ACTION_UP;
@@ -215,7 +143,7 @@ static void
 press_back_or_turn_screen_on(struct sc_controller *controller,
                              enum sc_action action) {
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
+    msg.type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
     msg.back_or_screen_on.action = action == SC_ACTION_DOWN
                                  ? AKEY_EVENT_ACTION_DOWN
                                  : AKEY_EVENT_ACTION_UP;
@@ -228,7 +156,7 @@ press_back_or_turn_screen_on(struct sc_controller *controller,
 static void
 expand_notification_panel(struct sc_controller *controller) {
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
+    msg.type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
 
     if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'expand notification panel'");
@@ -238,7 +166,7 @@ expand_notification_panel(struct sc_controller *controller) {
 static void
 expand_settings_panel(struct sc_controller *controller) {
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
+    msg.type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
 
     if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'expand settings panel'");
@@ -248,7 +176,7 @@ expand_settings_panel(struct sc_controller *controller) {
 static void
 collapse_panels(struct sc_controller *controller) {
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_COLLAPSE_PANELS;
+    msg.type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS;
 
     if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'collapse notification panel'");
@@ -257,9 +185,9 @@ collapse_panels(struct sc_controller *controller) {
 
 static bool
 get_device_clipboard(struct sc_controller *controller,
-                     enum get_clipboard_copy_key copy_key) {
+                     enum sc_copy_key copy_key) {
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_GET_CLIPBOARD;
+    msg.type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD;
     msg.get_clipboard.copy_key = copy_key;
 
     if (!sc_controller_push_msg(controller, &msg)) {
@@ -287,7 +215,7 @@ set_device_clipboard(struct sc_controller *controller, bool paste,
     }
 
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
+    msg.type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD;
     msg.set_clipboard.sequence = sequence;
     msg.set_clipboard.text = text_dup;
     msg.set_clipboard.paste = paste;
@@ -303,9 +231,9 @@ set_device_clipboard(struct sc_controller *controller, bool paste,
 
 static void
 set_screen_power_mode(struct sc_controller *controller,
-                      enum screen_power_mode mode) {
+                      enum sc_screen_power_mode mode) {
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
+    msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
     msg.set_screen_power_mode.mode = mode;
 
     if (!sc_controller_push_msg(controller, &msg)) {
@@ -350,7 +278,7 @@ clipboard_paste(struct sc_controller *controller) {
     }
 
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
+    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
     msg.inject_text.text = text_dup;
     if (!sc_controller_push_msg(controller, &msg)) {
         free(text_dup);
@@ -361,7 +289,7 @@ clipboard_paste(struct sc_controller *controller) {
 static void
 rotate_device(struct sc_controller *controller) {
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_ROTATE_DEVICE;
+    msg.type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE;
 
     if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request device rotation");
@@ -407,7 +335,7 @@ simulate_virtual_finger(struct sc_input_manager *im,
     bool up = action == AMOTION_EVENT_ACTION_UP;
 
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
+    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
     msg.inject_touch_event.action = action;
     msg.inject_touch_event.position.screen_size = im->screen->frame_size;
     msg.inject_touch_event.position.point = point;
@@ -433,9 +361,7 @@ inverse_point(struct sc_point point, struct sc_size size) {
 static void
 sc_input_manager_process_key(struct sc_input_manager *im,
                              const SDL_KeyboardEvent *event) {
-    // control: indicates the state of the command-line option --no-control
-    bool control = im->control;
-
+    // controller is NULL if --no-control is requested
     struct sc_controller *controller = im->controller;
 
     SDL_Keycode keycode = event->keysym.sym;
@@ -462,47 +388,47 @@ sc_input_manager_process_key(struct sc_input_manager *im,
         enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
         switch (keycode) {
             case SDLK_h:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_home(controller, action);
                 }
                 return;
             case SDLK_b: // fall-through
             case SDLK_BACKSPACE:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_back(controller, action);
                 }
                 return;
             case SDLK_s:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_app_switch(controller, action);
                 }
                 return;
             case SDLK_m:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_menu(controller, action);
                 }
                 return;
             case SDLK_p:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_power(controller, action);
                 }
                 return;
             case SDLK_o:
-                if (control && !repeat && down) {
-                    enum screen_power_mode mode = shift
-                                                ? SCREEN_POWER_MODE_NORMAL
-                                                : SCREEN_POWER_MODE_OFF;
+                if (controller && !repeat && down) {
+                    enum sc_screen_power_mode mode = shift
+                                                   ? SC_SCREEN_POWER_MODE_NORMAL
+                                                   : SC_SCREEN_POWER_MODE_OFF;
                     set_screen_power_mode(controller, mode);
                 }
                 return;
             case SDLK_DOWN:
-                if (control && !shift) {
+                if (controller && !shift) {
                     // forward repeated events
                     action_volume_down(controller, action);
                 }
                 return;
             case SDLK_UP:
-                if (control && !shift) {
+                if (controller && !shift) {
                     // forward repeated events
                     action_volume_up(controller, action);
                 }
@@ -518,19 +444,17 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 }
                 return;
             case SDLK_c:
-                if (control && !shift && !repeat && down) {
-                    get_device_clipboard(controller,
-                                         GET_CLIPBOARD_COPY_KEY_COPY);
+                if (controller && !shift && !repeat && down) {
+                    get_device_clipboard(controller, SC_COPY_KEY_COPY);
                 }
                 return;
             case SDLK_x:
-                if (control && !shift && !repeat && down) {
-                    get_device_clipboard(controller,
-                                         GET_CLIPBOARD_COPY_KEY_CUT);
+                if (controller && !shift && !repeat && down) {
+                    get_device_clipboard(controller, SC_COPY_KEY_CUT);
                 }
                 return;
             case SDLK_v:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                     if (shift || im->legacy_paste) {
                         // inject the text as input events
                         clipboard_paste(controller);
@@ -563,7 +487,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 }
                 return;
             case SDLK_n:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                     if (shift) {
                         collapse_panels(controller);
                     } else if (im->key_repeat == 0) {
@@ -574,7 +498,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 }
                 return;
             case SDLK_r:
-                if (control && !shift && !repeat && down) {
+                if (controller && !shift && !repeat && down) {
                     rotate_device(controller);
                 }
                 return;
@@ -583,7 +507,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
         return;
     }
 
-    if (!control) {
+    if (!controller) {
         return;
     }
 
@@ -700,7 +624,7 @@ sc_input_manager_process_touch(struct sc_input_manager *im,
 static void
 sc_input_manager_process_mouse_button(struct sc_input_manager *im,
                                       const SDL_MouseButtonEvent *event) {
-    bool control = im->control;
+    struct sc_controller *controller = im->controller;
 
     if (event->which == SDL_TOUCH_MOUSEID) {
         // simulated from touch events, so it's a duplicate
@@ -709,27 +633,29 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
 
     bool down = event->type == SDL_MOUSEBUTTONDOWN;
     if (!im->forward_all_clicks) {
-        enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
+        if (controller) {
+            enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
 
-        if (control && event->button == SDL_BUTTON_X1) {
-            action_app_switch(im->controller, action);
-            return;
-        }
-        if (control && event->button == SDL_BUTTON_X2 && down) {
-            if (event->clicks < 2) {
-                expand_notification_panel(im->controller);
-            } else {
-                expand_settings_panel(im->controller);
+            if (event->button == SDL_BUTTON_X1) {
+                action_app_switch(controller, action);
+                return;
+            }
+            if (event->button == SDL_BUTTON_X2 && down) {
+                if (event->clicks < 2) {
+                    expand_notification_panel(controller);
+                } else {
+                    expand_settings_panel(controller);
+                }
+                return;
+            }
+            if (event->button == SDL_BUTTON_RIGHT) {
+                press_back_or_turn_screen_on(controller, action);
+                return;
+            }
+            if (event->button == SDL_BUTTON_MIDDLE) {
+                action_home(controller, action);
+                return;
             }
-            return;
-        }
-        if (control && event->button == SDL_BUTTON_RIGHT) {
-            press_back_or_turn_screen_on(im->controller, action);
-            return;
-        }
-        if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, action);
-            return;
         }
 
         // double-click on black borders resize to fit the device screen
@@ -750,7 +676,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
         // otherwise, send the click event to the device
     }
 
-    if (!control) {
+    if (!controller) {
         return;
     }
 
@@ -834,45 +760,81 @@ sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,
     im->mp->ops->process_mouse_scroll(im->mp, &evt);
 }
 
-bool
+static bool
+is_apk(const char *file) {
+    const char *ext = strrchr(file, '.');
+    return ext && !strcmp(ext, ".apk");
+}
+
+static void
+sc_input_manager_process_file(struct sc_input_manager *im,
+                              const SDL_DropEvent *event) {
+    char *file = strdup(event->file);
+    SDL_free(event->file);
+    if (!file) {
+        LOG_OOM();
+        return;
+    }
+
+    enum sc_file_pusher_action action;
+    if (is_apk(file)) {
+        action = SC_FILE_PUSHER_ACTION_INSTALL_APK;
+    } else {
+        action = SC_FILE_PUSHER_ACTION_PUSH_FILE;
+    }
+    bool ok = sc_file_pusher_request(im->fp, action, file);
+    if (!ok) {
+        free(file);
+    }
+}
+
+void
 sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event) {
+    bool control = im->controller;
     switch (event->type) {
         case SDL_TEXTINPUT:
-            if (!im->control) {
-                return true;
+            if (!control) {
+                break;
             }
             sc_input_manager_process_text_input(im, &event->text);
-            return true;
+            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
             sc_input_manager_process_key(im, &event->key);
-            return true;
+            break;
         case SDL_MOUSEMOTION:
-            if (!im->control) {
+            if (!control) {
                 break;
             }
             sc_input_manager_process_mouse_motion(im, &event->motion);
-            return true;
+            break;
         case SDL_MOUSEWHEEL:
-            if (!im->control) {
+            if (!control) {
                 break;
             }
             sc_input_manager_process_mouse_wheel(im, &event->wheel);
-            return true;
+            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
             sc_input_manager_process_mouse_button(im, &event->button);
-            return true;
+            break;
         case SDL_FINGERMOTION:
         case SDL_FINGERDOWN:
         case SDL_FINGERUP:
+            if (!control) {
+                break;
+            }
             sc_input_manager_process_touch(im, &event->tfinger);
-            return true;
+            break;
+        case SDL_DROPFILE: {
+            if (!control) {
+                break;
+            }
+            sc_input_manager_process_file(im, &event->drop);
+        }
     }
-
-    return false;
 }

app/src/input_manager.h

@@ -8,6 +8,7 @@
 #include <SDL2/SDL.h>
 
 #include "controller.h"
+#include "file_pusher.h"
 #include "fps_counter.h"
 #include "options.h"
 #include "trait/key_processor.h"
@@ -15,12 +16,12 @@
 
 struct sc_input_manager {
     struct sc_controller *controller;
+    struct sc_file_pusher *fp;
     struct sc_screen *screen;
 
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
 
-    bool control;
     bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
@@ -44,11 +45,11 @@ struct sc_input_manager {
 
 struct sc_input_manager_params {
     struct sc_controller *controller;
+    struct sc_file_pusher *fp;
     struct sc_screen *screen;
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
 
-    bool control;
     bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
@@ -59,7 +60,7 @@ void
 sc_input_manager_init(struct sc_input_manager *im,
                       const struct sc_input_manager_params *params);
 
-bool
+void
 sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event);
 
 #endif

app/src/keyboard_inject.c

@@ -248,7 +248,7 @@ convert_meta_state(uint16_t mod) {
 static bool
 convert_input_key(const struct sc_key_event *event, struct sc_control_msg *msg,
                   enum sc_key_inject_mode key_inject_mode, uint32_t repeat) {
-    msg->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
+    msg->type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
 
     if (!convert_keycode(event->keycode, &msg->inject_keycode.keycode,
                          event->mods_state, key_inject_mode)) {
@@ -310,7 +310,7 @@ sc_key_processor_process_text(struct sc_key_processor *kp,
     }
 
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
+    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
     msg.inject_text.text = strdup(event->text);
     if (!msg.inject_text.text) {
         LOGW("Could not strdup input text");

app/src/main.c

@@ -13,28 +13,27 @@
 #include "cli.h"
 #include "options.h"
 #include "scrcpy.h"
+#include "usb/scrcpy_otg.h"
 #include "util/log.h"
 
 static void
 print_version(void) {
-    fprintf(stderr, "scrcpy %s\n\n", SCRCPY_VERSION);
-
-    fprintf(stderr, "dependencies:\n");
-    fprintf(stderr, " - SDL %d.%d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION,
-                                         SDL_PATCHLEVEL);
-    fprintf(stderr, " - libavcodec %d.%d.%d\n", LIBAVCODEC_VERSION_MAJOR,
-                                                LIBAVCODEC_VERSION_MINOR,
-                                                LIBAVCODEC_VERSION_MICRO);
-    fprintf(stderr, " - libavformat %d.%d.%d\n", LIBAVFORMAT_VERSION_MAJOR,
-                                                 LIBAVFORMAT_VERSION_MINOR,
-                                                 LIBAVFORMAT_VERSION_MICRO);
-    fprintf(stderr, " - libavutil %d.%d.%d\n", LIBAVUTIL_VERSION_MAJOR,
-                                               LIBAVUTIL_VERSION_MINOR,
-                                               LIBAVUTIL_VERSION_MICRO);
+    printf("\ndependencies:\n");
+    printf(" - SDL %d.%d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION,
+                                SDL_PATCHLEVEL);
+    printf(" - libavcodec %d.%d.%d\n", LIBAVCODEC_VERSION_MAJOR,
+                                       LIBAVCODEC_VERSION_MINOR,
+                                       LIBAVCODEC_VERSION_MICRO);
+    printf(" - libavformat %d.%d.%d\n", LIBAVFORMAT_VERSION_MAJOR,
+                                        LIBAVFORMAT_VERSION_MINOR,
+                                        LIBAVFORMAT_VERSION_MICRO);
+    printf(" - libavutil %d.%d.%d\n", LIBAVUTIL_VERSION_MAJOR,
+                                      LIBAVUTIL_VERSION_MINOR,
+                                      LIBAVUTIL_VERSION_MICRO);
 #ifdef HAVE_V4L2
-    fprintf(stderr, " - libavdevice %d.%d.%d\n", LIBAVDEVICE_VERSION_MAJOR,
-                                                 LIBAVDEVICE_VERSION_MINOR,
-                                                 LIBAVDEVICE_VERSION_MICRO);
+    printf(" - libavdevice %d.%d.%d\n", LIBAVDEVICE_VERSION_MAJOR,
+                                        LIBAVDEVICE_VERSION_MINOR,
+                                        LIBAVDEVICE_VERSION_MICRO);
 #endif
 }
 
@@ -90,9 +89,14 @@ main(int argc, char *argv[]) {
         return 1;
     }
 
-    int res = scrcpy(&args.opts) ? 0 : 1;
+#ifdef HAVE_USB
+    bool ok = args.opts.otg ? scrcpy_otg(&args.opts)
+                            : scrcpy(&args.opts);
+#else
+    bool ok = scrcpy(&args.opts);
+#endif
 
     avformat_network_deinit(); // ignore failure
 
-    return res;
+    return ok ? 0 : 1;
 }

app/src/mouse_inject.c

@@ -66,7 +66,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
     struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
             .action = AMOTION_EVENT_ACTION_MOVE,
             .pointer_id = POINTER_ID_MOUSE,
@@ -87,7 +87,7 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
     struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
             .action = convert_mouse_action(event->action),
             .pointer_id = POINTER_ID_MOUSE,
@@ -108,7 +108,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
     struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
+        .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
         .inject_scroll_event = {
             .position = event->position,
             .hscroll = event->hscroll,
@@ -128,7 +128,7 @@ sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
     struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
             .action = convert_touch_action(event->action),
             .pointer_id = event->pointer_id,

app/src/options.c

@@ -37,6 +37,9 @@ const struct scrcpy_options scrcpy_options_default = {
     .display_id = 0,
     .display_buffer = 0,
     .v4l2_buffer = 0,
+#ifdef HAVE_USB
+    .otg = false,
+#endif
     .show_touches = false,
     .fullscreen = false,
     .always_on_top = false,
@@ -54,6 +57,7 @@ const struct scrcpy_options scrcpy_options_default = {
     .legacy_paste = false,
     .power_off_on_close = false,
     .clipboard_autosync = true,
+    .downsize_on_error = true,
     .tcpip = false,
     .tcpip_dst = NULL,
 };

app/src/options.h

@@ -112,6 +112,9 @@ struct scrcpy_options {
     uint32_t display_id;
     sc_tick display_buffer;
     sc_tick v4l2_buffer;
+#ifdef HAVE_USB
+    bool otg;
+#endif
     bool show_touches;
     bool fullscreen;
     bool always_on_top;
@@ -129,6 +132,7 @@ struct scrcpy_options {
     bool legacy_paste;
     bool power_off_on_close;
     bool clipboard_autosync;
+    bool downsize_on_error;
     bool tcpip;
     const char *tcpip_dst;
 };

app/src/scrcpy.c

@@ -16,17 +16,19 @@
 #include "controller.h"
 #include "decoder.h"
 #include "events.h"
-#include "file_handler.h"
-#ifdef HAVE_AOA_HID
-# include "hid_keyboard.h"
-# include "hid_mouse.h"
-#endif
+#include "file_pusher.h"
 #include "keyboard_inject.h"
 #include "mouse_inject.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
 #include "stream.h"
+#ifdef HAVE_USB
+# include "usb/aoa_hid.h"
+# include "usb/hid_keyboard.h"
+# include "usb/hid_mouse.h"
+# include "usb/usb.h"
+#endif
 #include "util/acksync.h"
 #include "util/log.h"
 #include "util/net.h"
@@ -44,21 +46,22 @@ struct scrcpy {
     struct sc_v4l2_sink v4l2_sink;
 #endif
     struct sc_controller controller;
-    struct file_handler file_handler;
-#ifdef HAVE_AOA_HID
+    struct sc_file_pusher file_pusher;
+#ifdef HAVE_USB
+    struct sc_usb usb;
     struct sc_aoa aoa;
     // sequence/ack helper to synchronize clipboard and Ctrl+v via HID
     struct sc_acksync acksync;
 #endif
     union {
         struct sc_keyboard_inject keyboard_inject;
-#ifdef HAVE_AOA_HID
+#ifdef HAVE_USB
         struct sc_hid_keyboard keyboard_hid;
 #endif
     };
     union {
         struct sc_mouse_inject mouse_inject;
-#ifdef HAVE_AOA_HID
+#ifdef HAVE_USB
         struct sc_hid_mouse mouse_hid;
 #endif
     };
@@ -149,68 +152,18 @@ sdl_configure(bool display, bool disable_screensaver) {
 }
 
 static bool
-is_apk(const char *file) {
-    const char *ext = strrchr(file, '.');
-    return ext && !strcmp(ext, ".apk");
-}
-
-enum event_result {
-    EVENT_RESULT_CONTINUE,
-    EVENT_RESULT_STOPPED_BY_USER,
-    EVENT_RESULT_STOPPED_BY_EOS,
-};
-
-static enum event_result
-handle_event(struct scrcpy *s, const struct scrcpy_options *options,
-             SDL_Event *event) {
-    switch (event->type) {
-        case EVENT_STREAM_STOPPED:
-            LOGD("Video stream stopped");
-            return EVENT_RESULT_STOPPED_BY_EOS;
-        case SDL_QUIT:
-            LOGD("User requested to quit");
-            return EVENT_RESULT_STOPPED_BY_USER;
-        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(file)) {
-                action = ACTION_INSTALL_APK;
-            } else {
-                action = ACTION_PUSH_FILE;
-            }
-            file_handler_request(&s->file_handler, action, file);
-            goto end;
-        }
-    }
-
-    bool consumed = sc_screen_handle_event(&s->screen, event);
-    (void) consumed;
-
-end:
-    return EVENT_RESULT_CONTINUE;
-}
-
-static bool
-event_loop(struct scrcpy *s, const struct scrcpy_options *options) {
+event_loop(struct scrcpy *s) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
-        enum event_result result = handle_event(s, options, &event);
-        switch (result) {
-            case EVENT_RESULT_STOPPED_BY_USER:
-                return true;
-            case EVENT_RESULT_STOPPED_BY_EOS:
+        switch (event.type) {
+            case EVENT_STREAM_STOPPED:
                 LOGW("Device disconnected");
                 return false;
-            case EVENT_RESULT_CONTINUE:
+            case SDL_QUIT:
+                LOGD("User requested to quit");
+                return true;
+            default:
+                sc_screen_handle_event(&s->screen, &event);
                 break;
         }
     }
@@ -327,13 +280,13 @@ scrcpy(struct scrcpy_options *options) {
     bool ret = false;
 
     bool server_started = false;
-    bool file_handler_initialized = false;
+    bool file_pusher_initialized = false;
     bool recorder_initialized = false;
 #ifdef HAVE_V4L2
     bool v4l2_sink_initialized = false;
 #endif
     bool stream_started = false;
-#ifdef HAVE_AOA_HID
+#ifdef HAVE_USB
     bool aoa_hid_initialized = false;
     bool hid_keyboard_initialized = false;
     bool hid_mouse_initialized = false;
@@ -364,6 +317,7 @@ scrcpy(struct scrcpy_options *options) {
         .force_adb_forward = options->force_adb_forward,
         .power_off_on_close = options->power_off_on_close,
         .clipboard_autosync = options->clipboard_autosync,
+        .downsize_on_error = options->downsize_on_error,
         .tcpip = options->tcpip,
         .tcpip_dst = options->tcpip_dst,
     };
@@ -406,12 +360,15 @@ scrcpy(struct scrcpy_options *options) {
     const char *serial = s->server.params.serial;
     assert(serial);
 
+    struct sc_file_pusher *fp = NULL;
+
     if (options->display && options->control) {
-        if (!file_handler_init(&s->file_handler, serial,
-                               options->push_target)) {
+        if (!sc_file_pusher_init(&s->file_pusher, serial,
+                                 options->push_target)) {
             goto end;
         }
-        file_handler_initialized = true;
+        fp = &s->file_pusher;
+        file_pusher_initialized = true;
     }
 
     struct decoder *dec = NULL;
@@ -451,11 +408,12 @@ scrcpy(struct scrcpy_options *options) {
         stream_add_sink(&s->stream, &rec->packet_sink);
     }
 
+    struct sc_controller *controller = NULL;
     struct sc_key_processor *kp = NULL;
     struct sc_mouse_processor *mp = NULL;
 
     if (options->control) {
-#ifdef HAVE_AOA_HID
+#ifdef HAVE_USB
         bool use_hid_keyboard =
             options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID;
         bool use_hid_mouse =
@@ -466,9 +424,52 @@ scrcpy(struct scrcpy_options *options) {
                 goto end;
             }
 
-            ok = sc_aoa_init(&s->aoa, serial, &s->acksync);
+            ok = sc_usb_init(&s->usb);
+            if (!ok) {
+                LOGE("Failed to initialize USB");
+                sc_acksync_destroy(&s->acksync);
+                goto aoa_hid_end;
+            }
+
+            assert(serial);
+            struct sc_usb_device usb_devices[16];
+            ssize_t count = sc_usb_find_devices(&s->usb, serial, usb_devices,
+                                                ARRAY_LEN(usb_devices));
+            if (count <= 0) {
+                LOGE("Could not find USB device %s", serial);
+                sc_usb_destroy(&s->usb);
+                sc_acksync_destroy(&s->acksync);
+                goto aoa_hid_end;
+            }
+
+            if (count > 1) {
+                LOGE("Multiple (%d) devices with serial %s", (int) count, serial);
+                sc_usb_device_destroy_all(usb_devices, count);
+                sc_usb_destroy(&s->usb);
+                sc_acksync_destroy(&s->acksync);
+                goto aoa_hid_end;
+            }
+
+            struct sc_usb_device *usb_device = &usb_devices[0];
+
+            LOGI("USB device: %s (%04" PRIx16 ":%04" PRIx16 ") %s %s",
+                 usb_device->serial, usb_device->vid, usb_device->pid,
+                 usb_device->manufacturer, usb_device->product);
+
+            ok = sc_usb_connect(&s->usb, usb_device->device, NULL, NULL);
+            sc_usb_device_destroy(usb_device);
+            if (!ok) {
+                LOGE("Failed to connect to USB device %s", serial);
+                sc_usb_destroy(&s->usb);
+                sc_acksync_destroy(&s->acksync);
+                goto aoa_hid_end;
+            }
+
+            ok = sc_aoa_init(&s->aoa, &s->usb, &s->acksync);
             if (!ok) {
                 LOGE("Failed to enable HID over AOA");
+                sc_usb_disconnect(&s->usb);
+                sc_usb_destroy(&s->usb);
                 sc_acksync_destroy(&s->acksync);
                 goto aoa_hid_end;
             }
@@ -495,6 +496,8 @@ scrcpy(struct scrcpy_options *options) {
 
             if (!need_aoa || !sc_aoa_start(&s->aoa)) {
                 sc_acksync_destroy(&s->acksync);
+                sc_usb_disconnect(&s->usb);
+                sc_usb_destroy(&s->usb);
                 sc_aoa_destroy(&s->aoa);
                 goto aoa_hid_end;
             }
@@ -556,11 +559,12 @@ aoa_hid_end:
             goto end;
         }
         controller_started = true;
+        controller = &s->controller;
 
         if (options->turn_screen_off) {
             struct sc_control_msg msg;
-            msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
-            msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF;
+            msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
+            msg.set_screen_power_mode.mode = SC_SCREEN_POWER_MODE_OFF;
 
             if (!sc_controller_push_msg(&s->controller, &msg)) {
                 LOGW("Could not request 'set screen power mode'");
@@ -569,15 +573,18 @@ aoa_hid_end:
 
     }
 
+    // There is a controller if and only if control is enabled
+    assert(options->control == !!controller);
+
     if (options->display) {
         const char *window_title =
             options->window_title ? options->window_title : info->device_name;
 
         struct sc_screen_params screen_params = {
-            .controller = &s->controller,
+            .controller = controller,
+            .fp = fp,
             .kp = kp,
             .mp = mp,
-            .control = options->control,
             .forward_all_clicks = options->forward_all_clicks,
             .legacy_paste = options->legacy_paste,
             .clipboard_autosync = options->clipboard_autosync,
@@ -624,7 +631,7 @@ aoa_hid_end:
     }
     stream_started = true;
 
-    ret = event_loop(s, options);
+    ret = event_loop(s);
     LOGD("quit...");
 
     // Close the window immediately on closing, because screen_destroy() may
@@ -634,12 +641,16 @@ aoa_hid_end:
 end:
     // The stream is not stopped explicitly, because it will stop by itself on
     // end-of-stream
-#ifdef HAVE_AOA_HID
+#ifdef HAVE_USB
     if (aoa_hid_initialized) {
         if (hid_keyboard_initialized) {
             sc_hid_keyboard_destroy(&s->keyboard_hid);
         }
+        if (hid_mouse_initialized) {
+            sc_hid_mouse_destroy(&s->mouse_hid);
+        }
         sc_aoa_stop(&s->aoa);
+        sc_usb_stop(&s->usb);
     }
     if (acksync) {
         sc_acksync_destroy(acksync);
@@ -648,8 +659,8 @@ end:
     if (controller_started) {
         sc_controller_stop(&s->controller);
     }
-    if (file_handler_initialized) {
-        file_handler_stop(&s->file_handler);
+    if (file_pusher_initialized) {
+        sc_file_pusher_stop(&s->file_pusher);
     }
     if (screen_initialized) {
         sc_screen_interrupt(&s->screen);
@@ -672,10 +683,13 @@ end:
     }
 #endif
 
-#ifdef HAVE_AOA_HID
+#ifdef HAVE_USB
     if (aoa_hid_initialized) {
         sc_aoa_join(&s->aoa);
         sc_aoa_destroy(&s->aoa);
+        sc_usb_join(&s->usb);
+        sc_usb_disconnect(&s->usb);
+        sc_usb_destroy(&s->usb);
     }
 #endif
 
@@ -697,9 +711,9 @@ end:
         recorder_destroy(&s->recorder);
     }
 
-    if (file_handler_initialized) {
-        file_handler_join(&s->file_handler);
-        file_handler_destroy(&s->file_handler);
+    if (file_pusher_initialized) {
+        sc_file_pusher_join(&s->file_pusher);
+        sc_file_pusher_destroy(&s->file_pusher);
     }
 
     sc_server_destroy(&s->server);

app/src/screen.c

@@ -156,7 +156,13 @@ get_initial_optimal_size(struct sc_size content_size, uint16_t req_width,
     return window_size;
 }
 
-static inline void
+static inline bool
+sc_screen_is_relative_mode(struct sc_screen *screen) {
+    // screen->im.mp may be NULL if --no-control
+    return screen->im.mp && screen->im.mp->relative_mode;
+}
+
+static void
 sc_screen_capture_mouse(struct sc_screen *screen, bool capture) {
     if (SDL_SetRelativeMouseMode(capture)) {
         LOGE("Could not set relative mouse mode to %s: %s",
@@ -369,6 +375,12 @@ sc_screen_init(struct sc_screen *screen,
     screen->mouse_captured = false;
     screen->mouse_capture_key_pressed = 0;
 
+    screen->req.x = params->window_x;
+    screen->req.y = params->window_y;
+    screen->req.width = params->window_width;
+    screen->req.height = params->window_height;
+    screen->req.fullscreen = params->fullscreen;
+
     static const struct sc_video_buffer_callbacks cbs = {
         .on_new_frame = sc_video_buffer_on_new_frame,
     };
@@ -397,9 +409,6 @@ sc_screen_init(struct sc_screen *screen,
         get_rotated_size(screen->frame_size, screen->rotation);
     screen->content_size = content_size;
 
-    struct sc_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;
@@ -410,13 +419,9 @@ sc_screen_init(struct sc_screen *screen,
         window_flags |= SDL_WINDOW_BORDERLESS;
     }
 
-    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);
+    // The window will be positioned and sized on first video frame
+    screen->window =
+        SDL_CreateWindow(params->window_title, 0, 0, 0, 0, window_flags);
     if (!screen->window) {
         LOGC("Could not create window: %s", SDL_GetError());
         goto error_destroy_fps_counter;
@@ -486,10 +491,10 @@ sc_screen_init(struct sc_screen *screen,
 
     struct sc_input_manager_params im_params = {
         .controller = params->controller,
+        .fp = params->fp,
         .screen = screen,
         .kp = params->kp,
         .mp = params->mp,
-        .control = params->control,
         .forward_all_clicks = params->forward_all_clicks,
         .legacy_paste = params->legacy_paste,
         .clipboard_autosync = params->clipboard_autosync,
@@ -498,17 +503,6 @@ sc_screen_init(struct sc_screen *screen,
 
     sc_input_manager_init(&screen->im, &im_params);
 
-    // 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
-    SDL_SetWindowSize(screen->window, window_size.width, window_size.height);
-
-    sc_screen_update_content_rect(screen);
-
-    if (params->fullscreen) {
-        sc_screen_switch_fullscreen(screen);
-    }
-
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
     SDL_AddEventWatch(event_watcher, screen);
 #endif
@@ -545,7 +539,23 @@ error_destroy_video_buffer:
 }
 
 static void
-sc_screen_show_window(struct sc_screen *screen) {
+sc_screen_show_initial_window(struct sc_screen *screen) {
+    int x = screen->req.x != SC_WINDOW_POSITION_UNDEFINED
+          ? screen->req.x : (int) SDL_WINDOWPOS_CENTERED;
+    int y = screen->req.y != SC_WINDOW_POSITION_UNDEFINED
+          ? screen->req.y : (int) SDL_WINDOWPOS_CENTERED;
+
+    struct sc_size window_size =
+        get_initial_optimal_size(screen->content_size, screen->req.width,
+                                                       screen->req.height);
+
+    set_window_size(screen, window_size);
+    SDL_SetWindowPosition(screen->window, x, y);
+
+    if (screen->req.fullscreen) {
+        sc_screen_switch_fullscreen(screen);
+    }
+
     SDL_ShowWindow(screen->window);
 }
 
@@ -693,6 +703,17 @@ sc_screen_update_frame(struct sc_screen *screen) {
     }
     update_texture(screen, frame);
 
+    if (!screen->has_frame) {
+        screen->has_frame = true;
+        // this is the very first frame, show the window
+        sc_screen_show_initial_window(screen);
+
+        if (sc_screen_is_relative_mode(screen)) {
+            // Capture mouse on start
+            sc_screen_capture_mouse(screen, true);
+        }
+    }
+
     sc_screen_render(screen, false);
     return true;
 }
@@ -760,24 +781,22 @@ sc_screen_is_mouse_capture_key(SDL_Keycode key) {
     return key == SDLK_LALT || key == SDLK_LGUI || key == SDLK_RGUI;
 }
 
-bool
+void
 sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event) {
+    bool relative_mode = sc_screen_is_relative_mode(screen);
+
     switch (event->type) {
-        case EVENT_NEW_FRAME:
-            if (!screen->has_frame) {
-                screen->has_frame = true;
-                // this is the very first frame, show the window
-                sc_screen_show_window(screen);
-            }
+        case EVENT_NEW_FRAME: {
             bool ok = sc_screen_update_frame(screen);
             if (!ok) {
                 LOGW("Frame update failed\n");
             }
-            return true;
+            return;
+        }
         case SDL_WINDOWEVENT:
             if (!screen->has_frame) {
                 // Do nothing
-                return true;
+                return;
             }
             switch (event->window.event) {
                 case SDL_WINDOWEVENT_EXPOSED:
@@ -803,70 +822,72 @@ sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event) {
                     sc_screen_render(screen, true);
                     break;
                 case SDL_WINDOWEVENT_FOCUS_LOST:
-                    if (screen->im.mp->relative_mode) {
+                    if (relative_mode) {
                         sc_screen_capture_mouse(screen, false);
                     }
                     break;
             }
-            return true;
+            return;
         case SDL_KEYDOWN:
-            if (screen->im.mp->relative_mode) {
+            if (relative_mode) {
                 SDL_Keycode key = event->key.keysym.sym;
                 if (sc_screen_is_mouse_capture_key(key)) {
                     if (!screen->mouse_capture_key_pressed) {
                         screen->mouse_capture_key_pressed = key;
-                        return true;
                     } else {
                         // Another mouse capture key has been pressed, cancel
                         // mouse (un)capture
                         screen->mouse_capture_key_pressed = 0;
-                        // Do not return, the event must be forwarded to the
-                        // input manager
                     }
+                    // Mouse capture keys are never forwarded to the device
+                    return;
                 }
             }
             break;
         case SDL_KEYUP:
-            if (screen->im.mp->relative_mode) {
+            if (relative_mode) {
                 SDL_Keycode key = event->key.keysym.sym;
                 SDL_Keycode cap = screen->mouse_capture_key_pressed;
                 screen->mouse_capture_key_pressed = 0;
-                if (key == cap) {
-                    // A mouse capture key has been pressed then released:
-                    // toggle the capture mouse mode
-                    sc_screen_capture_mouse(screen, !screen->mouse_captured);
-                    return true;
+                if (sc_screen_is_mouse_capture_key(key)) {
+                    if (key == cap) {
+                        // A mouse capture key has been pressed then released:
+                        // toggle the capture mouse mode
+                        sc_screen_capture_mouse(screen,
+                                                !screen->mouse_captured);
+                    }
+                    // Mouse capture keys are never forwarded to the device
+                    return;
                 }
-                // Do not return, the event must be forwarded to the input
-                // manager
             }
             break;
         case SDL_MOUSEWHEEL:
         case SDL_MOUSEMOTION:
         case SDL_MOUSEBUTTONDOWN:
-            if (screen->im.mp->relative_mode && !screen->mouse_captured) {
+            if (relative_mode && !screen->mouse_captured) {
                 // Do not forward to input manager, the mouse will be captured
                 // on SDL_MOUSEBUTTONUP
-                return true;
+                return;
             }
             break;
         case SDL_FINGERMOTION:
         case SDL_FINGERDOWN:
         case SDL_FINGERUP:
-            if (screen->im.mp->relative_mode) {
+            if (relative_mode) {
                 // Touch events are not compatible with relative mode
                 // (coordinates are not relative)
-                return true;
+                return;
             }
             break;
         case SDL_MOUSEBUTTONUP:
-            if (screen->im.mp->relative_mode && !screen->mouse_captured) {
+            if (relative_mode && !screen->mouse_captured) {
                 sc_screen_capture_mouse(screen, true);
-                return true;
+                return;
             }
+            break;
     }
 
-    return sc_input_manager_handle_event(&screen->im, event);
+    sc_input_manager_handle_event(&screen->im, event);
 }
 
 struct sc_point

app/src/screen.h

@@ -28,6 +28,15 @@ struct sc_screen {
     struct sc_video_buffer vb;
     struct fps_counter fps_counter;
 
+    // The initial requested window properties
+    struct {
+        int16_t x;
+        int16_t y;
+        uint16_t width;
+        uint16_t height;
+        bool fullscreen;
+    } req;
+
     SDL_Window *window;
     SDL_Renderer *renderer;
     SDL_Texture *texture;
@@ -61,10 +70,10 @@ struct sc_screen {
 
 struct sc_screen_params {
     struct sc_controller *controller;
+    struct sc_file_pusher *fp;
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
 
-    bool control;
     bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
@@ -74,10 +83,10 @@ struct sc_screen_params {
     struct sc_size frame_size;
     bool always_on_top;
 
-    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
+    int16_t window_x; // accepts SC_WINDOW_POSITION_UNDEFINED
+    int16_t window_y; // accepts SC_WINDOW_POSITION_UNDEFINED
+    uint16_t window_width;
+    uint16_t window_height;
 
     bool window_borderless;
 
@@ -130,7 +139,7 @@ void
 sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation);
 
 // react to SDL events
-bool
+void
 sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event);
 
 // convert point from window coordinates to frame coordinates

app/src/server.c

@@ -234,6 +234,10 @@ execute_server(struct sc_server *server,
         // By default, clipboard_autosync is true
         ADD_PARAM("clipboard_autosync=false");
     }
+    if (!params->downsize_on_error) {
+        // By default, downsize_on_error is true
+        ADD_PARAM("downsize_on_error=false");
+    }
 
 #undef ADD_PARAM
 #undef STRBOOL
@@ -765,12 +769,10 @@ run_server(void *data) {
     // Interrupt sockets to wake up socket blocking calls on the server
     assert(server->video_socket != SC_SOCKET_NONE);
     net_interrupt(server->video_socket);
-    net_close(server->video_socket);
 
     if (server->control_socket != SC_SOCKET_NONE) {
         // There is no control_socket if --no-control is set
         net_interrupt(server->control_socket);
-        net_close(server->control_socket);
     }
 
     // Give some delay for the server to terminate properly
@@ -826,6 +828,13 @@ sc_server_stop(struct sc_server *server) {
 
 void
 sc_server_destroy(struct sc_server *server) {
+    if (server->video_socket != SC_SOCKET_NONE) {
+        net_close(server->video_socket);
+    }
+    if (server->control_socket != SC_SOCKET_NONE) {
+        net_close(server->control_socket);
+    }
+
     sc_server_params_destroy(&server->params);
     sc_intr_destroy(&server->intr);
     sc_cond_destroy(&server->cond_stopped);

app/src/server.h

@@ -42,6 +42,7 @@ struct sc_server_params {
     bool force_adb_forward;
     bool power_off_on_close;
     bool clipboard_autosync;
+    bool downsize_on_error;
     bool tcpip;
     const char *tcpip_dst;
 };

app/src/usb/aoa_hid.c

@@ -50,80 +50,9 @@ log_libusb_error(enum libusb_error errcode) {
     LOGW("libusb error: %s", libusb_strerror(errcode));
 }
 
-static bool
-accept_device(libusb_device *device, const char *serial) {
-    // do not log any USB error in this function, it is expected that many USB
-    // devices available on the computer have permission restrictions
-
-    struct libusb_device_descriptor desc;
-    libusb_get_device_descriptor(device, &desc);
-
-    if (!desc.iSerialNumber) {
-        return false;
-    }
-
-    libusb_device_handle *handle;
-    int result = libusb_open(device, &handle);
-    if (result < 0) {
-        return false;
-    }
-
-    char buffer[128];
-    result = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber,
-                                                (unsigned char *) buffer,
-                                                sizeof(buffer));
-    libusb_close(handle);
-    if (result < 0) {
-        return false;
-    }
-
-    buffer[sizeof(buffer) - 1] = '\0'; // just in case
-
-    // accept the device if its serial matches
-    return !strcmp(buffer, serial);
-}
-
-static libusb_device *
-sc_aoa_find_usb_device(const char *serial) {
-    if (!serial) {
-        return NULL;
-    }
-
-    libusb_device **list;
-    libusb_device *result = NULL;
-    ssize_t count = libusb_get_device_list(NULL, &list);
-    if (count < 0) {
-        log_libusb_error((enum libusb_error) count);
-        return NULL;
-    }
-
-    for (size_t i = 0; i < (size_t) count; ++i) {
-        libusb_device *device = list[i];
-
-        if (accept_device(device, serial)) {
-            result = libusb_ref_device(device);
-            break;
-        }
-    }
-    libusb_free_device_list(list, 1);
-    return result;
-}
-
-static int
-sc_aoa_open_usb_handle(libusb_device *device, libusb_device_handle **handle) {
-    int result = libusb_open(device, handle);
-    if (result < 0) {
-        log_libusb_error((enum libusb_error) result);
-        return result;
-    }
-    return 0;
-}
-
 bool
-sc_aoa_init(struct sc_aoa *aoa, const char *serial,
+sc_aoa_init(struct sc_aoa *aoa, struct sc_usb *usb,
             struct sc_acksync *acksync) {
-    assert(acksync);
-
     cbuf_init(&aoa->queue);
 
     if (!sc_mutex_init(&aoa->mutex)) {
@@ -135,32 +64,9 @@ sc_aoa_init(struct sc_aoa *aoa, const char *serial,
         return false;
     }
 
-    if (libusb_init(&aoa->usb_context) != LIBUSB_SUCCESS) {
-        sc_cond_destroy(&aoa->event_cond);
-        sc_mutex_destroy(&aoa->mutex);
-        return false;
-    }
-
-    aoa->usb_device = sc_aoa_find_usb_device(serial);
-    if (!aoa->usb_device) {
-        LOGW("USB device of serial %s not found", serial);
-        libusb_exit(aoa->usb_context);
-        sc_mutex_destroy(&aoa->mutex);
-        sc_cond_destroy(&aoa->event_cond);
-        return false;
-    }
-
-    if (sc_aoa_open_usb_handle(aoa->usb_device, &aoa->usb_handle) < 0) {
-        LOGW("Open USB handle failed");
-        libusb_unref_device(aoa->usb_device);
-        libusb_exit(aoa->usb_context);
-        sc_cond_destroy(&aoa->event_cond);
-        sc_mutex_destroy(&aoa->mutex);
-        return false;
-    }
-
     aoa->stopped = false;
     aoa->acksync = acksync;
+    aoa->usb = usb;
 
     return true;
 }
@@ -173,9 +79,6 @@ sc_aoa_destroy(struct sc_aoa *aoa) {
         sc_hid_event_destroy(&event);
     }
 
-    libusb_close(aoa->usb_handle);
-    libusb_unref_device(aoa->usb_device);
-    libusb_exit(aoa->usb_context);
     sc_cond_destroy(&aoa->event_cond);
     sc_mutex_destroy(&aoa->mutex);
 }
@@ -192,8 +95,8 @@ sc_aoa_register_hid(struct sc_aoa *aoa, uint16_t accessory_id,
     uint16_t index = report_desc_size;
     unsigned char *buffer = NULL;
     uint16_t length = 0;
-    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
-                                         value, index, buffer, length,
+    int result = libusb_control_transfer(aoa->usb->handle, request_type,
+                                         request, value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         log_libusb_error((enum libusb_error) result);
@@ -228,8 +131,8 @@ sc_aoa_set_hid_report_desc(struct sc_aoa *aoa, uint16_t accessory_id,
     // libusb_control_transfer expects a pointer to non-const
     unsigned char *buffer = (unsigned char *) report_desc;
     uint16_t length = report_desc_size;
-    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
-                                         value, index, buffer, length,
+    int result = libusb_control_transfer(aoa->usb->handle, request_type,
+                                         request, value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         log_libusb_error((enum libusb_error) result);
@@ -270,8 +173,8 @@ sc_aoa_send_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
     uint16_t index = 0;
     unsigned char *buffer = event->buffer;
     uint16_t length = event->size;
-    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
-                                         value, index, buffer, length,
+    int result = libusb_control_transfer(aoa->usb->handle, request_type,
+                                         request, value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         log_libusb_error((enum libusb_error) result);
@@ -292,8 +195,8 @@ sc_aoa_unregister_hid(struct sc_aoa *aoa, const uint16_t accessory_id) {
     uint16_t index = 0;
     unsigned char *buffer = NULL;
     uint16_t length = 0;
-    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
-                                         value, index, buffer, length,
+    int result = libusb_control_transfer(aoa->usb->handle, request_type,
+                                         request, value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         log_libusb_error((enum libusb_error) result);
@@ -343,6 +246,11 @@ run_aoa_thread(void *data) {
 
         if (ack_to_wait != SC_SEQUENCE_INVALID) {
             LOGD("Waiting ack from server sequence=%" PRIu64_, ack_to_wait);
+
+            // If some events have ack_to_wait set, then sc_aoa must have been
+            // initialized with a non NULL acksync
+            assert(aoa->acksync);
+
             // Do not block the loop indefinitely if the ack never comes (it
             // should never happen)
             sc_tick deadline = sc_tick_now() + SC_TICK_FROM_MS(500);
@@ -389,7 +297,9 @@ sc_aoa_stop(struct sc_aoa *aoa) {
     sc_cond_signal(&aoa->event_cond);
     sc_mutex_unlock(&aoa->mutex);
 
-    sc_acksync_interrupt(aoa->acksync);
+    if (aoa->acksync) {
+        sc_acksync_interrupt(aoa->acksync);
+    }
 }
 
 void

app/src/usb/aoa_hid.h

@@ -6,6 +6,7 @@
 
 #include <libusb-1.0/libusb.h>
 
+#include "usb.h"
 #include "util/acksync.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
@@ -29,9 +30,7 @@ sc_hid_event_destroy(struct sc_hid_event *hid_event);
 struct sc_hid_event_queue CBUF(struct sc_hid_event, 64);
 
 struct sc_aoa {
-    libusb_context *usb_context;
-    libusb_device *usb_device;
-    libusb_device_handle *usb_handle;
+    struct sc_usb *usb;
     sc_thread thread;
     sc_mutex mutex;
     sc_cond event_cond;
@@ -42,7 +41,7 @@ struct sc_aoa {
 };
 
 bool
-sc_aoa_init(struct sc_aoa *aoa, const char *serial, struct sc_acksync *acksync);
+sc_aoa_init(struct sc_aoa *aoa, struct sc_usb *usb, struct sc_acksync *acksync);
 
 void
 sc_aoa_destroy(struct sc_aoa *aoa);

app/src/usb/hid_mouse.c

@@ -262,6 +262,6 @@ void
 sc_hid_mouse_destroy(struct sc_hid_mouse *mouse) {
     bool ok = sc_aoa_unregister_hid(mouse->aoa, HID_MOUSE_ACCESSORY_ID);
     if (!ok) {
-        LOGW("Could not unregister HID");
+        LOGW("Could not unregister HID mouse");
     }
 }

app/src/usb/hid_mouse.h

@@ -1,5 +1,5 @@
-#ifndef HID_MOUSE_H
-#define HID_MOUSE_H
+#ifndef SC_HID_MOUSE_H
+#define SC_HID_MOUSE_H
 
 #include "common.h"
 

app/src/usb/scrcpy_otg.c

@@ -0,0 +1,232 @@
+#include "scrcpy_otg.h"
+
+#include <SDL2/SDL.h>
+
+#include "events.h"
+#include "screen_otg.h"
+#include "util/log.h"
+
+struct scrcpy_otg {
+    struct sc_usb usb;
+    struct sc_aoa aoa;
+    struct sc_hid_keyboard keyboard;
+    struct sc_hid_mouse mouse;
+
+    struct sc_screen_otg screen_otg;
+};
+
+static void
+sc_usb_on_disconnected(struct sc_usb *usb, void *userdata) {
+    (void) usb;
+    (void) userdata;
+
+    SDL_Event event;
+    event.type = EVENT_USB_DEVICE_DISCONNECTED;
+    int ret = SDL_PushEvent(&event);
+    if (ret < 0) {
+        LOGE("Could not post USB disconnection event: %s", SDL_GetError());
+    }
+}
+
+static bool
+event_loop(struct scrcpy_otg *s) {
+    SDL_Event event;
+    while (SDL_WaitEvent(&event)) {
+        switch (event.type) {
+            case EVENT_USB_DEVICE_DISCONNECTED:
+                LOGW("Device disconnected");
+                return false;
+            case SDL_QUIT:
+                LOGD("User requested to quit");
+                return true;
+            default:
+                sc_screen_otg_handle_event(&s->screen_otg, &event);
+                break;
+        }
+    }
+    return false;
+}
+
+bool
+scrcpy_otg(struct scrcpy_options *options) {
+    static struct scrcpy_otg scrcpy_otg;
+    struct scrcpy_otg *s = &scrcpy_otg;
+
+    const char *serial = options->serial;
+
+    // Minimal SDL initialization
+    if (SDL_Init(SDL_INIT_EVENTS)) {
+        LOGC("Could not initialize SDL: %s", SDL_GetError());
+        return false;
+    }
+
+    atexit(SDL_Quit);
+
+    if (!SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1")) {
+        LOGW("Could not enable mouse focus clickthrough");
+    }
+
+    bool ret = false;
+
+    struct sc_hid_keyboard *keyboard = NULL;
+    struct sc_hid_mouse *mouse = NULL;
+    bool usb_device_initialized = false;
+    bool usb_connected = false;
+    bool aoa_started = false;
+    bool aoa_initialized = false;
+
+    static const struct sc_usb_callbacks cbs = {
+        .on_disconnected = sc_usb_on_disconnected,
+    };
+    bool ok = sc_usb_init(&s->usb);
+    if (!ok) {
+        return false;
+    }
+
+    struct sc_usb_device usb_devices[16];
+    ssize_t count = sc_usb_find_devices(&s->usb, serial, usb_devices,
+                                        ARRAY_LEN(usb_devices));
+    if (count < 0) {
+        LOGE("Could not list USB devices");
+        goto end;
+    }
+
+    if (count == 0) {
+        if (serial) {
+            LOGE("Could not find USB device %s", serial);
+        } else {
+            LOGE("Could not find any USB device");
+        }
+        goto end;
+    }
+
+    if (count > 1) {
+        if (serial) {
+            LOGE("Multiple (%d) USB devices with serial %s:", (int) count,
+                 serial);
+        } else {
+            LOGE("Multiple (%d) USB devices:", (int) count);
+        }
+        for (size_t i = 0; i < (size_t) count; ++i) {
+            struct sc_usb_device *d = &usb_devices[i];
+            LOGE("    %-18s (%04" PRIx16 ":%04" PRIx16 ")  %s %s",
+                 d->serial, d->vid, d->pid, d->manufacturer, d->product);
+        }
+        if (!serial) {
+            LOGE("Specify the device via -s or --serial");
+        }
+        sc_usb_device_destroy_all(usb_devices, count);
+        goto end;
+    }
+    usb_device_initialized = true;
+
+    struct sc_usb_device *usb_device = &usb_devices[0];
+
+    LOGI("USB device: %s (%04" PRIx16 ":%04" PRIx16 ") %s %s",
+         usb_device->serial, usb_device->vid, usb_device->pid,
+         usb_device->manufacturer, usb_device->product);
+
+    ok = sc_usb_connect(&s->usb, usb_device->device, &cbs, NULL);
+    if (!ok) {
+        goto end;
+    }
+    usb_connected = true;
+
+    ok = sc_aoa_init(&s->aoa, &s->usb, NULL);
+    if (!ok) {
+        goto end;
+    }
+    aoa_initialized = true;
+
+    bool enable_keyboard =
+        options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID;
+    bool enable_mouse =
+        options->mouse_input_mode == SC_MOUSE_INPUT_MODE_HID;
+
+    // If neither --hid-keyboard or --hid-mouse is passed, enable both
+    if (!enable_keyboard && !enable_mouse) {
+        enable_keyboard = true;
+        enable_mouse = true;
+    }
+
+    if (enable_keyboard) {
+        ok = sc_hid_keyboard_init(&s->keyboard, &s->aoa);
+        if (!ok) {
+            goto end;
+        }
+        keyboard = &s->keyboard;
+    }
+
+    if (enable_mouse) {
+        ok = sc_hid_mouse_init(&s->mouse, &s->aoa);
+        if (!ok) {
+            goto end;
+        }
+        mouse = &s->mouse;
+    }
+
+    ok = sc_aoa_start(&s->aoa);
+    if (!ok) {
+        goto end;
+    }
+    aoa_started = true;
+
+    const char *window_title = options->window_title;
+    if (!window_title) {
+        window_title = usb_device->product ? usb_device->product : "scrcpy";
+    }
+
+    struct sc_screen_otg_params params = {
+        .keyboard = keyboard,
+        .mouse = mouse,
+        .window_title = window_title,
+        .always_on_top = options->always_on_top,
+        .window_x = options->window_x,
+        .window_y = options->window_y,
+        .window_borderless = options->window_borderless,
+    };
+
+    ok = sc_screen_otg_init(&s->screen_otg, &params);
+    if (!ok) {
+        goto end;
+    }
+
+    // usb_device not needed anymore
+    sc_usb_device_destroy(usb_device);
+    usb_device_initialized = false;
+
+    ret = event_loop(s);
+    LOGD("quit...");
+
+end:
+    if (aoa_started) {
+        sc_aoa_stop(&s->aoa);
+    }
+    sc_usb_stop(&s->usb);
+
+    if (mouse) {
+        sc_hid_mouse_destroy(&s->mouse);
+    }
+    if (keyboard) {
+        sc_hid_keyboard_destroy(&s->keyboard);
+    }
+
+    if (aoa_initialized) {
+        sc_aoa_join(&s->aoa);
+        sc_aoa_destroy(&s->aoa);
+    }
+
+    sc_usb_join(&s->usb);
+
+    if (usb_connected) {
+        sc_usb_disconnect(&s->usb);
+    }
+
+    if (usb_device_initialized) {
+        sc_usb_device_destroy(usb_device);
+    }
+
+    sc_usb_destroy(&s->usb);
+
+    return ret;
+}

app/src/usb/scrcpy_otg.h

@@ -0,0 +1,12 @@
+#ifndef SCRCPY_OTG_H
+#define SCRCPY_OTG_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include "options.h"
+
+bool
+scrcpy_otg(struct scrcpy_options *options);
+
+#endif

app/src/usb/screen_otg.c

@@ -0,0 +1,267 @@
+#include "screen_otg.h"
+
+#include "icon.h"
+#include "options.h"
+#include "util/log.h"
+
+static void
+sc_screen_otg_capture_mouse(struct sc_screen_otg *screen, bool capture) {
+    assert(screen->mouse);
+    if (SDL_SetRelativeMouseMode(capture)) {
+        LOGE("Could not set relative mouse mode to %s: %s",
+             capture ? "true" : "false", SDL_GetError());
+        return;
+    }
+
+    screen->mouse_captured = capture;
+}
+
+static void
+sc_screen_otg_render(struct sc_screen_otg *screen) {
+    SDL_RenderClear(screen->renderer);
+    if (screen->texture) {
+        SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
+    }
+    SDL_RenderPresent(screen->renderer);
+}
+
+bool
+sc_screen_otg_init(struct sc_screen_otg *screen,
+                   const struct sc_screen_otg_params *params) {
+    screen->keyboard = params->keyboard;
+    screen->mouse = params->mouse;
+
+    screen->mouse_captured = false;
+    screen->mouse_capture_key_pressed = 0;
+
+    const char *title = params->window_title;
+    assert(title);
+
+    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;
+    int width = 256;
+    int height = 256;
+
+    uint32_t window_flags = 0;
+    if (params->always_on_top) {
+        window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
+    }
+    if (params->window_borderless) {
+        window_flags |= SDL_WINDOW_BORDERLESS;
+    }
+
+    screen->window = SDL_CreateWindow(title, x, y, width, height, window_flags);
+    if (!screen->window) {
+        LOGE("Could not create window: %s", SDL_GetError());
+        return false;
+    }
+
+    screen->renderer = SDL_CreateRenderer(screen->window, -1, 0);
+    if (!screen->renderer) {
+        LOGE("Could not create renderer: %s", SDL_GetError());
+        goto error_destroy_window;
+    }
+
+    SDL_Surface *icon = scrcpy_icon_load();
+
+    if (icon) {
+        SDL_SetWindowIcon(screen->window, icon);
+
+        screen->texture = SDL_CreateTextureFromSurface(screen->renderer, icon);
+        scrcpy_icon_destroy(icon);
+        if (!screen->texture) {
+            goto error_destroy_renderer;
+        }
+    } else {
+        screen->texture = NULL;
+        LOGW("Could not load icon");
+    }
+
+    if (screen->mouse) {
+        // Capture mouse on start
+        sc_screen_otg_capture_mouse(screen, true);
+    }
+
+    return true;
+
+error_destroy_window:
+    SDL_DestroyWindow(screen->window);
+error_destroy_renderer:
+    SDL_DestroyRenderer(screen->renderer);
+
+    return false;
+}
+
+void
+sc_screen_otg_destroy(struct sc_screen_otg *screen) {
+    if (screen->texture) {
+        SDL_DestroyTexture(screen->texture);
+    }
+    SDL_DestroyRenderer(screen->renderer);
+    SDL_DestroyWindow(screen->window);
+}
+
+static inline bool
+sc_screen_otg_is_mouse_capture_key(SDL_Keycode key) {
+    return key == SDLK_LALT || key == SDLK_LGUI || key == SDLK_RGUI;
+}
+
+static void
+sc_screen_otg_process_key(struct sc_screen_otg *screen,
+                             const SDL_KeyboardEvent *event) {
+    assert(screen->keyboard);
+    struct sc_key_processor *kp = &screen->keyboard->key_processor;
+
+    struct sc_key_event evt = {
+        .action = sc_action_from_sdl_keyboard_type(event->type),
+        .keycode = sc_keycode_from_sdl(event->keysym.sym),
+        .scancode = sc_scancode_from_sdl(event->keysym.scancode),
+        .repeat = event->repeat,
+        .mods_state = sc_mods_state_from_sdl(event->keysym.mod),
+    };
+
+    assert(kp->ops->process_key);
+    kp->ops->process_key(kp, &evt, SC_SEQUENCE_INVALID);
+}
+
+static void
+sc_screen_otg_process_mouse_motion(struct sc_screen_otg *screen,
+                                   const SDL_MouseMotionEvent *event) {
+    assert(screen->mouse);
+    struct sc_mouse_processor *mp = &screen->mouse->mouse_processor;
+
+    struct sc_mouse_motion_event evt = {
+        // .position not used for HID events
+        .xrel = event->xrel,
+        .yrel = event->yrel,
+        .buttons_state = sc_mouse_buttons_state_from_sdl(event->state, true),
+    };
+
+    assert(mp->ops->process_mouse_motion);
+    mp->ops->process_mouse_motion(mp, &evt);
+}
+
+static void
+sc_screen_otg_process_mouse_button(struct sc_screen_otg *screen,
+                                   const SDL_MouseButtonEvent *event) {
+    assert(screen->mouse);
+    struct sc_mouse_processor *mp = &screen->mouse->mouse_processor;
+
+    uint32_t sdl_buttons_state = SDL_GetMouseState(NULL, NULL);
+
+    struct sc_mouse_click_event evt = {
+        // .position not used for HID events
+        .action = sc_action_from_sdl_mousebutton_type(event->type),
+        .button = sc_mouse_button_from_sdl(event->button),
+        .buttons_state =
+            sc_mouse_buttons_state_from_sdl(sdl_buttons_state, true),
+    };
+
+    assert(mp->ops->process_mouse_click);
+    mp->ops->process_mouse_click(mp, &evt);
+}
+
+static void
+sc_screen_otg_process_mouse_wheel(struct sc_screen_otg *screen,
+                                  const SDL_MouseWheelEvent *event) {
+    assert(screen->mouse);
+    struct sc_mouse_processor *mp = &screen->mouse->mouse_processor;
+
+    uint32_t sdl_buttons_state = SDL_GetMouseState(NULL, NULL);
+
+    struct sc_mouse_scroll_event evt = {
+        // .position not used for HID events
+        .hscroll = event->x,
+        .vscroll = event->y,
+        .buttons_state =
+            sc_mouse_buttons_state_from_sdl(sdl_buttons_state, true),
+    };
+
+    assert(mp->ops->process_mouse_scroll);
+    mp->ops->process_mouse_scroll(mp, &evt);
+}
+
+void
+sc_screen_otg_handle_event(struct sc_screen_otg *screen, SDL_Event *event) {
+    switch (event->type) {
+        case SDL_WINDOWEVENT:
+            switch (event->window.event) {
+                case SDL_WINDOWEVENT_EXPOSED:
+                    sc_screen_otg_render(screen);
+                    break;
+                case SDL_WINDOWEVENT_FOCUS_LOST:
+                    if (screen->mouse) {
+                        sc_screen_otg_capture_mouse(screen, false);
+                    }
+                    break;
+            }
+            return;
+        case SDL_KEYDOWN:
+            if (screen->mouse) {
+                SDL_Keycode key = event->key.keysym.sym;
+                if (sc_screen_otg_is_mouse_capture_key(key)) {
+                    if (!screen->mouse_capture_key_pressed) {
+                        screen->mouse_capture_key_pressed = key;
+                    } else {
+                        // Another mouse capture key has been pressed, cancel
+                        // mouse (un)capture
+                        screen->mouse_capture_key_pressed = 0;
+                    }
+                    // Mouse capture keys are never forwarded to the device
+                    return;
+                }
+            }
+
+            if (screen->keyboard) {
+                sc_screen_otg_process_key(screen, &event->key);
+            }
+            break;
+        case SDL_KEYUP:
+            if (screen->mouse) {
+                SDL_Keycode key = event->key.keysym.sym;
+                SDL_Keycode cap = screen->mouse_capture_key_pressed;
+                screen->mouse_capture_key_pressed = 0;
+                if (sc_screen_otg_is_mouse_capture_key(key)) {
+                    if (key == cap) {
+                        // A mouse capture key has been pressed then released:
+                        // toggle the capture mouse mode
+                        sc_screen_otg_capture_mouse(screen,
+                                                    !screen->mouse_captured);
+                    }
+                    // Mouse capture keys are never forwarded to the device
+                    return;
+                }
+            }
+
+            if (screen->keyboard) {
+                sc_screen_otg_process_key(screen, &event->key);
+            }
+            break;
+        case SDL_MOUSEMOTION:
+            if (screen->mouse && screen->mouse_captured) {
+                sc_screen_otg_process_mouse_motion(screen, &event->motion);
+            }
+            break;
+        case SDL_MOUSEBUTTONDOWN:
+            if (screen->mouse && screen->mouse_captured) {
+                sc_screen_otg_process_mouse_button(screen, &event->button);
+            }
+            break;
+        case SDL_MOUSEBUTTONUP:
+            if (screen->mouse) {
+                if (screen->mouse_captured) {
+                    sc_screen_otg_process_mouse_button(screen, &event->button);
+                } else {
+                    sc_screen_otg_capture_mouse(screen, true);
+                }
+            }
+            break;
+        case SDL_MOUSEWHEEL:
+            if (screen->mouse && screen->mouse_captured) {
+                sc_screen_otg_process_mouse_wheel(screen, &event->wheel);
+            }
+            break;
+    }
+}

app/src/usb/screen_otg.h

@@ -0,0 +1,46 @@
+#ifndef SC_SCREEN_OTG_H
+#define SC_SCREEN_OTG_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <SDL2/SDL.h>
+
+#include "hid_keyboard.h"
+#include "hid_mouse.h"
+
+struct sc_screen_otg {
+    struct sc_hid_keyboard *keyboard;
+    struct sc_hid_mouse *mouse;
+
+    SDL_Window *window;
+    SDL_Renderer *renderer;
+    SDL_Texture *texture;
+
+    // See equivalent mechanism in screen.h
+    bool mouse_captured;
+    SDL_Keycode mouse_capture_key_pressed;
+};
+
+struct sc_screen_otg_params {
+    struct sc_hid_keyboard *keyboard;
+    struct sc_hid_mouse *mouse;
+
+    const char *window_title;
+    bool always_on_top;
+    int16_t window_x; // accepts SC_WINDOW_POSITION_UNDEFINED
+    int16_t window_y; // accepts SC_WINDOW_POSITION_UNDEFINED
+    bool window_borderless;
+};
+
+bool
+sc_screen_otg_init(struct sc_screen_otg *screen,
+                   const struct sc_screen_otg_params *params);
+
+void
+sc_screen_otg_destroy(struct sc_screen_otg *screen);
+
+void
+sc_screen_otg_handle_event(struct sc_screen_otg *screen, SDL_Event *event);
+
+#endif

app/src/usb/usb.c

@@ -0,0 +1,264 @@
+#include "usb.h"
+
+#include <assert.h>
+
+#include "util/log.h"
+
+static inline void
+log_libusb_error(enum libusb_error errcode) {
+    LOGW("libusb error: %s", libusb_strerror(errcode));
+}
+
+static char *
+read_string(libusb_device_handle *handle, uint8_t desc_index) {
+    char buffer[128];
+    int result =
+        libusb_get_string_descriptor_ascii(handle, desc_index,
+                                           (unsigned char *) buffer,
+                                           sizeof(buffer));
+    if (result < 0) {
+        return NULL;
+    }
+
+    assert((size_t) result <= sizeof(buffer));
+
+    // When non-negative, 'result' contains the number of bytes written
+    char *s = malloc(result + 1);
+    memcpy(s, buffer, result);
+    s[result] = '\0';
+    return s;
+}
+
+static bool
+accept_device(libusb_device *device, const char *serial,
+              struct sc_usb_device *out) {
+    // Do not log any USB error in this function, it is expected that many USB
+    // devices available on the computer have permission restrictions
+
+    struct libusb_device_descriptor desc;
+    int result = libusb_get_device_descriptor(device, &desc);
+    if (result < 0 || !desc.iSerialNumber) {
+        return false;
+    }
+
+    libusb_device_handle *handle;
+    result = libusb_open(device, &handle);
+    if (result < 0) {
+        return false;
+    }
+
+    char *device_serial = read_string(handle, desc.iSerialNumber);
+    if (!device_serial) {
+        libusb_close(handle);
+        return false;
+    }
+
+    if (serial) {
+        // Filter by serial
+        bool matches = !strcmp(serial, device_serial);
+        if (!matches) {
+            free(device_serial);
+            libusb_close(handle);
+            return false;
+        }
+    }
+
+    out->device = libusb_ref_device(device);
+    out->serial = device_serial;
+    out->vid = desc.idVendor;
+    out->pid = desc.idProduct;
+    out->manufacturer = read_string(handle, desc.iManufacturer);
+    out->product = read_string(handle, desc.iProduct);
+
+    libusb_close(handle);
+
+    return true;
+}
+
+void
+sc_usb_device_destroy(struct sc_usb_device *usb_device) {
+    libusb_unref_device(usb_device->device);
+    free(usb_device->serial);
+    free(usb_device->manufacturer);
+    free(usb_device->product);
+}
+
+void
+sc_usb_device_destroy_all(struct sc_usb_device *usb_devices, size_t count) {
+    for (size_t i = 0; i < count; ++i) {
+        sc_usb_device_destroy(&usb_devices[i]);
+    }
+}
+
+ssize_t
+sc_usb_find_devices(struct sc_usb *usb, const char *serial,
+                    struct sc_usb_device *devices, size_t len) {
+    libusb_device **list;
+    ssize_t count = libusb_get_device_list(usb->context, &list);
+    if (count < 0) {
+        log_libusb_error((enum libusb_error) count);
+        return -1;
+    }
+
+    size_t idx = 0;
+    for (size_t i = 0; i < (size_t) count && idx < len; ++i) {
+        libusb_device *device = list[i];
+
+        if (accept_device(device, serial, &devices[idx])) {
+            ++idx;
+        }
+    }
+
+    libusb_free_device_list(list, 1);
+    return idx;
+}
+
+static libusb_device_handle *
+sc_usb_open_handle(libusb_device *device) {
+    libusb_device_handle *handle;
+    int result = libusb_open(device, &handle);
+    if (result < 0) {
+        log_libusb_error((enum libusb_error) result);
+        return NULL;
+    }
+    return handle;
+ }
+
+bool
+sc_usb_init(struct sc_usb *usb) {
+    usb->handle = NULL;
+    return libusb_init(&usb->context) == LIBUSB_SUCCESS;
+}
+
+void
+sc_usb_destroy(struct sc_usb *usb) {
+    libusb_exit(usb->context);
+}
+
+static int
+sc_usb_libusb_callback(libusb_context *ctx, libusb_device *device,
+                       libusb_hotplug_event event, void *userdata) {
+    (void) ctx;
+    (void) device;
+    (void) event;
+
+    struct sc_usb *usb = userdata;
+
+    libusb_device *dev = libusb_get_device(usb->handle);
+    assert(dev);
+    if (dev != device) {
+        // Not the connected device
+        return 0;
+    }
+
+    assert(usb->cbs && usb->cbs->on_disconnected);
+    usb->cbs->on_disconnected(usb, usb->cbs_userdata);
+
+    // Do not automatically deregister the callback by returning 1. Instead,
+    // manually deregister to interrupt libusb_handle_events() from the libusb
+    // event thread: <https://stackoverflow.com/a/60119225/1987178>
+    return 0;
+}
+
+static int
+run_libusb_event_handler(void *data) {
+    struct sc_usb *usb = data;
+    while (!atomic_load(&usb->stopped)) {
+        // Interrupted by events or by libusb_hotplug_deregister_callback()
+        libusb_handle_events(usb->context);
+    }
+    return 0;
+}
+
+static bool
+sc_usb_register_callback(struct sc_usb *usb) {
+    if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
+        LOGW("libusb does not have hotplug capability");
+        return false;
+    }
+
+    libusb_device *device = libusb_get_device(usb->handle);
+    assert(device);
+
+    struct libusb_device_descriptor desc;
+    int result = libusb_get_device_descriptor(device, &desc);
+    if (result < 0) {
+        log_libusb_error((enum libusb_error) result);
+        LOGW("Could not read USB device descriptor");
+        return false;
+    }
+
+    int events = LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT;
+    int flags = LIBUSB_HOTPLUG_NO_FLAGS;
+    int vendor_id = desc.idVendor;
+    int product_id = desc.idProduct;
+    int dev_class = LIBUSB_HOTPLUG_MATCH_ANY;
+    result = libusb_hotplug_register_callback(usb->context, events, flags,
+                                              vendor_id, product_id, dev_class,
+                                              sc_usb_libusb_callback, usb,
+                                              &usb->callback_handle);
+    if (result < 0) {
+        log_libusb_error((enum libusb_error) result);
+        LOGW("Could not register USB callback");
+        return false;
+    }
+
+    usb->has_callback_handle = true;
+    return true;
+}
+
+bool
+sc_usb_connect(struct sc_usb *usb, libusb_device *device,
+              const struct sc_usb_callbacks *cbs, void *cbs_userdata) {
+    usb->handle = sc_usb_open_handle(device);
+    if (!usb->handle) {
+        return false;
+    }
+
+    usb->has_callback_handle = false;
+    usb->has_libusb_event_thread = false;
+
+    // If cbs is set, then cbs->on_disconnected must be set
+    assert(!cbs || cbs->on_disconnected);
+    usb->cbs = cbs;
+    usb->cbs_userdata = cbs_userdata;
+
+    if (cbs) {
+        atomic_init(&usb->stopped, false);
+        if (sc_usb_register_callback(usb)) {
+            // Create a thread to process libusb events, so that device
+            // disconnection could be detected immediately
+            usb->has_libusb_event_thread =
+                sc_thread_create(&usb->libusb_event_thread,
+                                 run_libusb_event_handler, "scrcpy-usbev", usb);
+            if (!usb->has_libusb_event_thread) {
+                LOGW("Libusb event thread handler could not be created, USB "
+                     "device disconnection might not be detected immediately");
+            }
+        } else {
+            LOGW("Could not register USB device disconnection callback");
+        }
+    }
+
+    return true;
+}
+
+void
+sc_usb_disconnect(struct sc_usb *usb) {
+    libusb_close(usb->handle);
+}
+
+void
+sc_usb_stop(struct sc_usb *usb) {
+    if (usb->has_callback_handle) {
+        atomic_store(&usb->stopped, true);
+        libusb_hotplug_deregister_callback(usb->context, usb->callback_handle);
+    }
+}
+
+void
+sc_usb_join(struct sc_usb *usb) {
+    if (usb->has_libusb_event_thread) {
+        sc_thread_join(&usb->libusb_event_thread, NULL);
+    }
+}

app/src/usb/usb.h

@@ -0,0 +1,69 @@
+#ifndef SC_USB_H
+#define SC_USB_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <libusb-1.0/libusb.h>
+
+#include "util/thread.h"
+
+struct sc_usb {
+    libusb_context *context;
+    libusb_device_handle *handle;
+
+    const struct sc_usb_callbacks *cbs;
+    void *cbs_userdata;
+
+    bool has_callback_handle;
+    libusb_hotplug_callback_handle callback_handle;
+
+    bool has_libusb_event_thread;
+    sc_thread libusb_event_thread;
+
+    atomic_bool stopped; // only used if cbs != NULL
+};
+
+struct sc_usb_callbacks {
+    void (*on_disconnected)(struct sc_usb *usb, void *userdata);
+};
+
+struct sc_usb_device {
+    libusb_device *device;
+    char *serial;
+    char *manufacturer;
+    char *product;
+    uint16_t vid;
+    uint16_t pid;
+};
+
+void
+sc_usb_device_destroy(struct sc_usb_device *usb_device);
+
+void
+sc_usb_device_destroy_all(struct sc_usb_device *usb_devices, size_t count);
+
+bool
+sc_usb_init(struct sc_usb *usb);
+
+void
+sc_usb_destroy(struct sc_usb *usb);
+
+ssize_t
+sc_usb_find_devices(struct sc_usb *usb, const char *serial,
+                    struct sc_usb_device *devices, size_t len);
+
+bool
+sc_usb_connect(struct sc_usb *usb, libusb_device *device,
+               const struct sc_usb_callbacks *cbs, void *cbs_userdata);
+
+void
+sc_usb_disconnect(struct sc_usb *usb);
+
+void
+sc_usb_stop(struct sc_usb *usb);
+
+void
+sc_usb_join(struct sc_usb *usb);
+
+#endif

app/tests/test_control_msg_serialize.c

@@ -7,7 +7,7 @@
 
 static void test_serialize_inject_keycode(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_KEYCODE,
+        .type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
         .inject_keycode = {
             .action = AKEY_EVENT_ACTION_UP,
             .keycode = AKEYCODE_ENTER,
@@ -16,12 +16,12 @@ static void test_serialize_inject_keycode(void) {
         },
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 14);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_INJECT_KEYCODE,
+        SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
         0x01, // AKEY_EVENT_ACTION_UP
         0x00, 0x00, 0x00, 0x42, // AKEYCODE_ENTER
         0x00, 0x00, 0x00, 0X05, // repeat
@@ -32,18 +32,18 @@ static void test_serialize_inject_keycode(void) {
 
 static void test_serialize_inject_text(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_TEXT,
+        .type = SC_CONTROL_MSG_TYPE_INJECT_TEXT,
         .inject_text = {
             .text = "hello, world!",
         },
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 18);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_INJECT_TEXT,
+        SC_CONTROL_MSG_TYPE_INJECT_TEXT,
         0x00, 0x00, 0x00, 0x0d, // text length
         'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
     };
@@ -52,30 +52,30 @@ static void test_serialize_inject_text(void) {
 
 static void test_serialize_inject_text_long(void) {
     struct sc_control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    char text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1];
-    memset(text, 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
-    text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
+    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
+    char text[SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1];
+    memset(text, 'a', SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    text[SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
     msg.inject_text.text = text;
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    assert(size == 5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
 
-    unsigned char expected[5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
-    expected[0] = CONTROL_MSG_TYPE_INJECT_TEXT;
+    unsigned char expected[5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
+    expected[0] = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
     expected[1] = 0x00;
     expected[2] = 0x00;
     expected[3] = 0x01;
     expected[4] = 0x2c; // text length (32 bits)
-    memset(&expected[5], 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    memset(&expected[5], 'a', SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
 
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_inject_touch_event(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
             .action = AMOTION_EVENT_ACTION_DOWN,
             .pointer_id = UINT64_C(0x1234567887654321),
@@ -94,12 +94,12 @@ static void test_serialize_inject_touch_event(void) {
         },
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 28);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         0x00, // AKEY_EVENT_ACTION_DOWN
         0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21, // pointer id
         0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0xc8, // 100 200
@@ -112,7 +112,7 @@ static void test_serialize_inject_touch_event(void) {
 
 static void test_serialize_inject_scroll_event(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
+        .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
         .inject_scroll_event = {
             .position = {
                 .point = {
@@ -130,12 +130,12 @@ static void test_serialize_inject_scroll_event(void) {
         },
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 25);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
+        SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
         0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x02, // 260 1026
         0x04, 0x38, 0x07, 0x80, // 1080 1920
         0x00, 0x00, 0x00, 0x01, // 1
@@ -147,18 +147,18 @@ static void test_serialize_inject_scroll_event(void) {
 
 static void test_serialize_back_or_screen_on(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
+        .type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
         .back_or_screen_on = {
             .action = AKEY_EVENT_ACTION_UP,
         },
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 2);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
+        SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
         0x01, // AKEY_EVENT_ACTION_UP
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
@@ -166,71 +166,71 @@ static void test_serialize_back_or_screen_on(void) {
 
 static void test_serialize_expand_notification_panel(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
+        .type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
+        SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_expand_settings_panel(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+        .type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+        SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_collapse_panels(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_COLLAPSE_PANELS,
+        .type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_COLLAPSE_PANELS,
+        SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_get_clipboard(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_GET_CLIPBOARD,
+        .type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
         .get_clipboard = {
-            .copy_key = GET_CLIPBOARD_COPY_KEY_COPY,
+            .copy_key = SC_COPY_KEY_COPY,
         },
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 2);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_GET_CLIPBOARD,
-        GET_CLIPBOARD_COPY_KEY_COPY,
+        SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
+        SC_COPY_KEY_COPY,
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_set_clipboard(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_SET_CLIPBOARD,
+        .type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
         .set_clipboard = {
             .sequence = UINT64_C(0x0102030405060708),
             .paste = true,
@@ -238,12 +238,12 @@ static void test_serialize_set_clipboard(void) {
         },
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 27);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_SET_CLIPBOARD,
+        SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
         1, // paste
         0x00, 0x00, 0x00, 0x0d, // text length
@@ -254,7 +254,7 @@ static void test_serialize_set_clipboard(void) {
 
 static void test_serialize_set_clipboard_long(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_SET_CLIPBOARD,
+        .type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
         .set_clipboard = {
             .sequence = UINT64_C(0x0102030405060708),
             .paste = true,
@@ -262,60 +262,60 @@ static void test_serialize_set_clipboard_long(void) {
         },
     };
 
-    char text[CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH + 1];
-    memset(text, 'a', CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH);
-    text[CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH] = '\0';
+    char text[SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH + 1];
+    memset(text, 'a', SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH);
+    text[SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH] = '\0';
     msg.set_clipboard.text = text;
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == CONTROL_MSG_MAX_SIZE);
+    assert(size == SC_CONTROL_MSG_MAX_SIZE);
 
-    unsigned char expected[CONTROL_MSG_MAX_SIZE] = {
-        CONTROL_MSG_TYPE_SET_CLIPBOARD,
+    unsigned char expected[SC_CONTROL_MSG_MAX_SIZE] = {
+        SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
         1, // paste
         // text length
-        CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 24,
-        (CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 16) & 0xff,
-        (CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 8) & 0xff,
-        CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH & 0xff,
+        SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 24,
+        (SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 16) & 0xff,
+        (SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 8) & 0xff,
+        SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH & 0xff,
     };
-    memset(expected + 14, 'a', CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH);
+    memset(expected + 14, 'a', SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH);
 
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_set_screen_power_mode(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
+        .type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
         .set_screen_power_mode = {
-            .mode = SCREEN_POWER_MODE_NORMAL,
+            .mode = SC_SCREEN_POWER_MODE_NORMAL,
         },
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 2);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
-        0x02, // SCREEN_POWER_MODE_NORMAL
+        SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
+        0x02, // SC_SCREEN_POWER_MODE_NORMAL
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_rotate_device(void) {
     struct sc_control_msg msg = {
-        .type = CONTROL_MSG_TYPE_ROTATE_DEVICE,
+        .type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
     };
 
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_ROTATE_DEVICE,
+        SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }

cross_win32.txt

@@ -16,6 +16,8 @@ cpu = 'i686'
 endian = 'little'
 
 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.3.1-win32-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.3.1-win32-dev'
-prebuilt_sdl2 = 'SDL2-2.0.18/i686-w64-mingw32'
+ffmpeg_avcodec = 'avcodec-58'
+ffmpeg_avformat = 'avformat-58'
+ffmpeg_avutil = 'avutil-56'
+prebuilt_ffmpeg = 'ffmpeg-4.3.1-win32-shared'
+prebuilt_sdl2 = 'SDL2-2.0.20/i686-w64-mingw32'

cross_win64.txt

@@ -16,6 +16,8 @@ cpu = 'x86_64'
 endian = 'little'
 
 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.3.1-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.3.1-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.18/x86_64-w64-mingw32'
+ffmpeg_avcodec = 'avcodec-59'
+ffmpeg_avformat = 'avformat-59'
+ffmpeg_avutil = 'avutil-57'
+prebuilt_ffmpeg = 'ffmpeg-5.0-full_build-shared'
+prebuilt_sdl2 = 'SDL2-2.0.20/x86_64-w64-mingw32'

data/open_a_terminal_here.bat

@@ -0,0 +1 @@
+@cmd

prebuilt-deps/Makefile

@@ -1,40 +1,33 @@
 .PHONY: prepare-win32 prepare-win64 \
-	prepare-ffmpeg-shared-win32 \
-	prepare-ffmpeg-dev-win32 \
-	prepare-ffmpeg-shared-win64 \
-	prepare-ffmpeg-dev-win64 \
+	prepare-ffmpeg-win32 \
+	prepare-ffmpeg-win64 \
 	prepare-sdl2 \
 	prepare-adb
 
-prepare-win32: prepare-sdl2 prepare-ffmpeg-shared-win32 prepare-ffmpeg-dev-win32 prepare-adb
-prepare-win64: prepare-sdl2 prepare-ffmpeg-shared-win64 prepare-ffmpeg-dev-win64 prepare-adb
+prepare-win32: prepare-sdl2 prepare-ffmpeg-win32 prepare-adb
+prepare-win64: prepare-sdl2 prepare-ffmpeg-win64 prepare-adb
 
-prepare-ffmpeg-shared-win32:
+# Use old FFmpeg version for win32, there are no new prebuilts
+prepare-ffmpeg-win32:
 	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win32-shared.zip \
 		357af9901a456f4dcbacd107e83a934d344c9cb07ddad8aaf80612eeab7d26d2 \
 		ffmpeg-4.3.1-win32-shared
-
-prepare-ffmpeg-dev-win32:
 	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win32-dev.zip \
 		230efb08e9bcf225bd474da29676c70e591fc94d8790a740ca801408fddcb78b \
 		ffmpeg-4.3.1-win32-dev
+	ln -sf ../ffmpeg-4.3.1-win32-dev/include ffmpeg-4.3.1-win32-shared/
 
-prepare-ffmpeg-shared-win64:
-	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win64-shared.zip \
-		dd29b7f92f48dead4dd940492c7509138c0f99db445076d0a597007298a79940 \
-		ffmpeg-4.3.1-win64-shared
-
-prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win64-dev.zip \
-		2e8038242cf8e1bd095c2978f196ff0462b122cc6ef7e74626a6af15459d8b81 \
-		ffmpeg-4.3.1-win64-dev
+prepare-ffmpeg-win64:
+	@./prepare-dep https://github.com/GyanD/codexffmpeg/releases/download/5.0/ffmpeg-5.0-full_build-shared.7z \
+		e5900f6cecd4c438d398bd2fc308736c10b857cd8dd61c11bcfb05bff5d1211a \
+		ffmpeg-5.0-full_build-shared
 
 prepare-sdl2:
-	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.18-mingw.tar.gz \
-		bbad7c6947f6ca3e05292f065852ed8b62f319fc5533047e7708769c4dbae394 \
-		SDL2-2.0.18
+	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.20-mingw.tar.gz \
+		38094d82a857d6c62352e5c5cdec74948c5b4d25c59cbd298d6d233568976bd1 \
+		SDL2-2.0.20
 
 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r31.0.3-windows.zip \
-		0f4b8fdd26af2c3733539d6eebb3c2ed499ea1d4bb1f4e0ecc2d6016961a6e24 \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r32.0.0-windows.zip \
+		41f4c7512b32cbb3f8c624c20b56326abb692a6f169b03b4b63b6c5a6fdbb08c \
 		platform-tools

prebuilt-deps/prepare-dep

@@ -34,6 +34,9 @@ extract() {
     elif [[ "$file" == *.tar.gz ]]
     then
         tar xf "$file"
+    elif [[ "$file" == *.7z ]]
+    then
+        7z x "$file"
     else
         echo "Unsupported file: $file"
         return 1

release.mk

@@ -93,6 +93,7 @@ dist-win32: build-server build-win32
 	cp data/scrcpy-console.bat "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp data/scrcpy-noconsole.vbs "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp data/icon.png "$(DIST)/$(WIN32_TARGET_DIR)"
+	cp data/open_a_terminal_here.bat "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
@@ -101,7 +102,7 @@ dist-win32: build-server build-win32
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.18/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.20/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 
 dist-win64: build-server build-win64
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
@@ -110,15 +111,16 @@ dist-win64: build-server build-win64
 	cp data/scrcpy-console.bat "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp data/scrcpy-noconsole.vbs "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp data/icon.png "$(DIST)/$(WIN64_TARGET_DIR)"
-	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp data/open_a_terminal_here.bat "$(DIST)/$(WIN64_TARGET_DIR)"
+	cp prebuilt-deps/ffmpeg-5.0-full_build-shared/bin/avutil-57.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-5.0-full_build-shared/bin/avcodec-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-5.0-full_build-shared/bin/avformat-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-5.0-full_build-shared/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-5.0-full_build-shared/bin/swscale-6.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.18/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.20/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 
 zip-win32: dist-win32
 	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \

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

@@ -46,15 +46,17 @@ public final class DesktopConnection implements Closeable {
         return localSocket;
     }
 
-    public static DesktopConnection open(Device device, boolean tunnelForward, boolean control) throws IOException {
+    public static DesktopConnection open(boolean tunnelForward, boolean control, boolean sendDummyByte) throws IOException {
         LocalSocket videoSocket;
         LocalSocket controlSocket = null;
         if (tunnelForward) {
             LocalServerSocket localServerSocket = new LocalServerSocket(SOCKET_NAME);
             try {
                 videoSocket = localServerSocket.accept();
-                // send one byte so the client may read() to detect a connection error
-                videoSocket.getOutputStream().write(0);
+                if (sendDummyByte) {
+                    // send one byte so the client may read() to detect a connection error
+                    videoSocket.getOutputStream().write(0);
+                }
                 if (control) {
                     try {
                         controlSocket = localServerSocket.accept();
@@ -78,10 +80,7 @@ public final class DesktopConnection implements Closeable {
             }
         }
 
-        DesktopConnection connection = new DesktopConnection(videoSocket, controlSocket);
-        Size videoSize = device.getScreenInfo().getVideoSize();
-        connection.send(Device.getDeviceName(), videoSize.getWidth(), videoSize.getHeight());
-        return connection;
+        return new DesktopConnection(videoSocket, controlSocket);
     }
 
     public void close() throws IOException {
@@ -95,7 +94,7 @@ public final class DesktopConnection implements Closeable {
         }
     }
 
-    private void send(String deviceName, int width, int height) throws IOException {
+    public void sendDeviceMeta(String deviceName, int width, int height) throws IOException {
         byte[] buffer = new byte[DEVICE_NAME_FIELD_LENGTH + 4];
 
         byte[] deviceNameBytes = deviceName.getBytes(StandardCharsets.UTF_8);

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

@@ -42,6 +42,11 @@ public final class Device {
         void onClipboardTextChanged(String text);
     }
 
+    private final Size deviceSize;
+    private final Rect crop;
+    private int maxSize;
+    private final int lockVideoOrientation;
+
     private ScreenInfo screenInfo;
     private RotationListener rotationListener;
     private ClipboardListener clipboardListener;
@@ -69,7 +74,12 @@ public final class Device {
 
         int displayInfoFlags = displayInfo.getFlags();
 
-        screenInfo = ScreenInfo.computeScreenInfo(displayInfo, options.getCrop(), options.getMaxSize(), options.getLockVideoOrientation());
+        deviceSize = displayInfo.getSize();
+        crop = options.getCrop();
+        maxSize = options.getMaxSize();
+        lockVideoOrientation = options.getLockVideoOrientation();
+
+        screenInfo = ScreenInfo.computeScreenInfo(displayInfo.getRotation(), deviceSize, crop, maxSize, lockVideoOrientation);
         layerStack = displayInfo.getLayerStack();
 
         SERVICE_MANAGER.getWindowManager().registerRotationWatcher(new IRotationWatcher.Stub() {
@@ -123,6 +133,11 @@ public final class Device {
         }
     }
 
+    public synchronized void setMaxSize(int newMaxSize) {
+        maxSize = newMaxSize;
+        screenInfo = ScreenInfo.computeScreenInfo(screenInfo.getReverseVideoRotation(), deviceSize, crop, newMaxSize, lockVideoOrientation);
+    }
+
     public synchronized ScreenInfo getScreenInfo() {
         return screenInfo;
     }

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

@@ -12,7 +12,6 @@ public class Options {
     private int lockVideoOrientation = -1;
     private boolean tunnelForward;
     private Rect crop;
-    private boolean sendFrameMeta = true; // send PTS so that the client may record properly
     private boolean control = true;
     private int displayId;
     private boolean showTouches;
@@ -21,6 +20,12 @@ public class Options {
     private String encoderName;
     private boolean powerOffScreenOnClose;
     private boolean clipboardAutosync = true;
+    private boolean downsizeOnError = true;
+
+    // Options not used by the scrcpy client, but useful to use scrcpy-server directly
+    private boolean sendDeviceMeta = true; // send device name and size
+    private boolean sendFrameMeta = true; // send PTS so that the client may record properly
+    private boolean sendDummyByte = true; // write a byte on start to detect connection issues
 
     public Ln.Level getLogLevel() {
         return logLevel;
@@ -78,14 +83,6 @@ public class Options {
         this.crop = crop;
     }
 
-    public boolean getSendFrameMeta() {
-        return sendFrameMeta;
-    }
-
-    public void setSendFrameMeta(boolean sendFrameMeta) {
-        this.sendFrameMeta = sendFrameMeta;
-    }
-
     public boolean getControl() {
         return control;
     }
@@ -149,4 +146,36 @@ public class Options {
     public void setClipboardAutosync(boolean clipboardAutosync) {
         this.clipboardAutosync = clipboardAutosync;
     }
+
+    public boolean getDownsizeOnError() {
+        return downsizeOnError;
+    }
+
+    public void setDownsizeOnError(boolean downsizeOnError) {
+        this.downsizeOnError = downsizeOnError;
+    }
+
+    public boolean getSendDeviceMeta() {
+        return sendDeviceMeta;
+    }
+
+    public void setSendDeviceMeta(boolean sendDeviceMeta) {
+        this.sendDeviceMeta = sendDeviceMeta;
+    }
+
+    public boolean getSendFrameMeta() {
+        return sendFrameMeta;
+    }
+
+    public void setSendFrameMeta(boolean sendFrameMeta) {
+        this.sendFrameMeta = sendFrameMeta;
+    }
+
+    public boolean getSendDummyByte() {
+        return sendDummyByte;
+    }
+
+    public void setSendDummyByte(boolean sendDummyByte) {
+        this.sendDummyByte = sendDummyByte;
+    }
 }

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

@@ -25,6 +25,9 @@ public class ScreenEncoder implements Device.RotationListener {
     private static final int REPEAT_FRAME_DELAY_US = 100_000; // repeat after 100ms
     private static final String KEY_MAX_FPS_TO_ENCODER = "max-fps-to-encoder";
 
+    // Keep the values in descending order
+    private static final int[] MAX_SIZE_FALLBACK = {2560, 1920, 1600, 1280, 1024, 800};
+
     private static final int NO_PTS = -1;
 
     private final AtomicBoolean rotationChanged = new AtomicBoolean();
@@ -35,14 +38,19 @@ public class ScreenEncoder implements Device.RotationListener {
     private final int bitRate;
     private final int maxFps;
     private final boolean sendFrameMeta;
+    private final boolean downsizeOnError;
     private long ptsOrigin;
 
-    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName) {
+    private boolean firstFrameSent;
+
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
+            boolean downsizeOnError) {
         this.sendFrameMeta = sendFrameMeta;
         this.bitRate = bitRate;
         this.maxFps = maxFps;
         this.codecOptions = codecOptions;
         this.encoderName = encoderName;
+        this.downsizeOnError = downsizeOnError;
     }
 
     @Override
@@ -91,6 +99,23 @@ public class ScreenEncoder implements Device.RotationListener {
                     alive = encode(codec, fd);
                     // do not call stop() on exception, it would trigger an IllegalStateException
                     codec.stop();
+                } catch (IllegalStateException e) {
+                    Ln.e("Encoding error: " + e.getClass().getName() + ": " + e.getMessage());
+                    if (!downsizeOnError || firstFrameSent) {
+                        // Fail immediately
+                        throw e;
+                    }
+
+                    int newMaxSize = chooseMaxSizeFallback(screenInfo.getVideoSize());
+                    if (newMaxSize == 0) {
+                        // Definitively fail
+                        throw e;
+                    }
+
+                    // Retry with a smaller device size
+                    Ln.i("Retrying with -m" + newMaxSize + "...");
+                    device.setMaxSize(newMaxSize);
+                    alive = true;
                 } finally {
                     destroyDisplay(display);
                     codec.release();
@@ -102,6 +127,18 @@ public class ScreenEncoder implements Device.RotationListener {
         }
     }
 
+    private static int chooseMaxSizeFallback(Size failedSize) {
+        int currentMaxSize = Math.max(failedSize.getWidth(), failedSize.getHeight());
+        for (int value : MAX_SIZE_FALLBACK) {
+            if (value < currentMaxSize) {
+                // We found a smaller value to reduce the video size
+                return value;
+            }
+        }
+        // No fallback, fail definitively
+        return 0;
+    }
+
     private boolean encode(MediaCodec codec, FileDescriptor fd) throws IOException {
         boolean eof = false;
         MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
@@ -122,6 +159,10 @@ public class ScreenEncoder implements Device.RotationListener {
                     }
 
                     IO.writeFully(fd, codecBuffer);
+                    if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
+                        // If this is not a config packet, then it contains a frame
+                        firstFrameSent = true;
+                    }
                 }
             } finally {
                 if (outputBufferId >= 0) {

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

@@ -80,15 +80,12 @@ public final class ScreenInfo {
         return new ScreenInfo(newContentRect, newUnlockedVideoSize, newDeviceRotation, lockedVideoOrientation);
     }
 
-    public static ScreenInfo computeScreenInfo(DisplayInfo displayInfo, Rect crop, int maxSize, int lockedVideoOrientation) {
-        int rotation = displayInfo.getRotation();
-
+    public static ScreenInfo computeScreenInfo(int rotation, Size deviceSize, Rect crop, int maxSize, int lockedVideoOrientation) {
         if (lockedVideoOrientation == Device.LOCK_VIDEO_ORIENTATION_INITIAL) {
             // The user requested to lock the video orientation to the current orientation
             lockedVideoOrientation = rotation;
         }
 
-        Size deviceSize = displayInfo.getSize();
         Rect contentRect = new Rect(0, 0, deviceSize.getWidth(), deviceSize.getHeight());
         if (crop != null) {
             if (rotation % 2 != 0) { // 180s preserve dimensions

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

@@ -1,7 +1,6 @@
 package com.genymobile.scrcpy;
 
 import android.graphics.Rect;
-import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.os.BatteryManager;
 import android.os.Build;
@@ -20,6 +19,7 @@ public final class Server {
     private static void initAndCleanUp(Options options) {
         boolean mustDisableShowTouchesOnCleanUp = false;
         int restoreStayOn = -1;
+        boolean restoreNormalPowerMode = options.getControl(); // only restore power mode if control is enabled
         if (options.getShowTouches() || options.getStayAwake()) {
             Settings settings = Device.getSettings();
             if (options.getShowTouches()) {
@@ -52,7 +52,8 @@ public final class Server {
         }
 
         try {
-            CleanUp.configure(options.getDisplayId(), restoreStayOn, mustDisableShowTouchesOnCleanUp, true, options.getPowerOffScreenOnClose());
+            CleanUp.configure(options.getDisplayId(), restoreStayOn, mustDisableShowTouchesOnCleanUp, restoreNormalPowerMode,
+                    options.getPowerOffScreenOnClose());
         } catch (IOException e) {
             Ln.e("Could not configure cleanup", e);
         }
@@ -67,10 +68,15 @@ public final class Server {
 
         boolean tunnelForward = options.isTunnelForward();
         boolean control = options.getControl();
+        boolean sendDummyByte = options.getSendDummyByte();
 
-        try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward, control)) {
+        try (DesktopConnection connection = DesktopConnection.open(tunnelForward, control, sendDummyByte)) {
+            if (options.getSendDeviceMeta()) {
+                Size videoSize = device.getScreenInfo().getVideoSize();
+                connection.sendDeviceMeta(Device.getDeviceName(), videoSize.getWidth(), videoSize.getHeight());
+            }
             ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(), codecOptions,
-                    options.getEncoderName());
+                    options.getEncoderName(), options.getDownsizeOnError());
 
             Thread controllerThread = null;
             Thread deviceMessageSenderThread = null;
@@ -200,10 +206,6 @@ public final class Server {
                     Rect crop = parseCrop(value);
                     options.setCrop(crop);
                     break;
-                case "send_frame_meta":
-                    boolean sendFrameMeta = Boolean.parseBoolean(value);
-                    options.setSendFrameMeta(sendFrameMeta);
-                    break;
                 case "control":
                     boolean control = Boolean.parseBoolean(value);
                     options.setControl(control);
@@ -237,6 +239,30 @@ public final class Server {
                     boolean clipboardAutosync = Boolean.parseBoolean(value);
                     options.setClipboardAutosync(clipboardAutosync);
                     break;
+                case "downsize_on_error":
+                    boolean downsizeOnError = Boolean.parseBoolean(value);
+                    options.setDownsizeOnError(downsizeOnError);
+                    break;
+                case "send_device_meta":
+                    boolean sendDeviceMeta = Boolean.parseBoolean(value);
+                    options.setSendDeviceMeta(sendDeviceMeta);
+                    break;
+                case "send_frame_meta":
+                    boolean sendFrameMeta = Boolean.parseBoolean(value);
+                    options.setSendFrameMeta(sendFrameMeta);
+                    break;
+                case "send_dummy_byte":
+                    boolean sendDummyByte = Boolean.parseBoolean(value);
+                    options.setSendDummyByte(sendDummyByte);
+                    break;
+                case "raw_video_stream":
+                    boolean rawVideoStream = Boolean.parseBoolean(value);
+                    if (rawVideoStream) {
+                        options.setSendDeviceMeta(false);
+                        options.setSendFrameMeta(false);
+                        options.setSendDummyByte(false);
+                    }
+                    break;
                 default:
                     Ln.w("Unknown server option: " + key);
                     break;
@@ -263,16 +289,6 @@ public final class Server {
     }
 
     private static void suggestFix(Throwable e) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            if (e instanceof MediaCodec.CodecException) {
-                MediaCodec.CodecException mce = (MediaCodec.CodecException) e;
-                if (mce.getErrorCode() == 0xfffffc0e) {
-                    Ln.e("The hardware encoder is not able to encode at the given definition.");
-                    Ln.e("Try with a lower definition:");
-                    Ln.e("    scrcpy -m 1024");
-                }
-            }
-        }
         if (e instanceof InvalidDisplayIdException) {
             InvalidDisplayIdException idie = (InvalidDisplayIdException) e;
             int[] displayIds = idie.getAvailableDisplayIds();

server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java

@@ -16,6 +16,7 @@ public final class InputManager {
 
     private final IInterface manager;
     private Method injectInputEventMethod;
+    private boolean alternativeInjectInputEventMethod;
 
     private static Method setDisplayIdMethod;
 
@@ -25,7 +26,12 @@ public final class InputManager {
 
     private Method getInjectInputEventMethod() throws NoSuchMethodException {
         if (injectInputEventMethod == null) {
-            injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
+            try {
+                injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
+            } catch (NoSuchMethodException e) {
+                injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class, int.class);
+                alternativeInjectInputEventMethod = true;
+            }
         }
         return injectInputEventMethod;
     }
@@ -33,6 +39,10 @@ public final class InputManager {
     public boolean injectInputEvent(InputEvent inputEvent, int mode) {
         try {
             Method method = getInjectInputEventMethod();
+            if (alternativeInjectInputEventMethod) {
+                // See <https://github.com/Genymobile/scrcpy/issues/2250>
+                return (boolean) method.invoke(manager, inputEvent, mode, 0);
+            }
             return (boolean) method.invoke(manager, inputEvent, mode);
         } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             Ln.e("Could not invoke method", e);