rename recapture

This will allow the mouse processor to handle relative motion easily.

BUILD.md

@@ -270,10 +270,10 @@ install` must be run as root)._
 
 #### Option 2: Use prebuilt server
 
- - [`scrcpy-server-v1.22`][direct-scrcpy-server]  
+ - [`scrcpy-server-v1.21`][direct-scrcpy-server]  
-   _(SHA-256: c05d273eec7533c0e106282e0254cf04e7f5e8f0c2920ca39448865fab2a419b)_
+   _(SHA-256: dbcccab523ee26796e55ea33652649e4b7af498edae9aa75e4d4d7869c0ab848)_
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.22/scrcpy-server-v1.22
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.21/scrcpy-server-v1.21
 
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:

FAQ.md

@@ -12,7 +12,7 @@ Here are the common reported problems and their status.
 
 In that case, it will print this error:
 
->     ERROR: "adb get-serialno" returned with value 1
+>     ERROR: "adb push" returned with value 1
 
 This is typically not a bug in _scrcpy_, but a problem in your environment.
 
@@ -32,38 +32,28 @@ in the release, so it should work out-of-the-box.
 
 ### Device unauthorized
 
-
+Check [stackoverflow][device-unauthorized].
->     error: device unauthorized.
->     This adb server's $ADB_VENDOR_KEYS is not set
->     Try 'adb kill-server' if that seems wrong.
->     Otherwise check for a confirmation dialog on your device.
-
-When connecting, a popup should open on the device. You must authorize USB
-debugging.
-
-If it does not open, check [stackoverflow][device-unauthorized].
 
 [device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
 
 
 ### Device not detected
 
->     error: no devices/emulators found
+>     adb: error: failed to get feature set: no devices/emulators found
 
 Check that you correctly enabled [adb debugging][enable-adb].
 
-If your device is not detected, you may need some [drivers] (on Windows). There is a separate [USB driver for Google devices][google-usb-driver].
+If your device is not detected, you may need some [drivers] (on Windows).
 
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
-[google-usb-driver]: https://developer.android.com/studio/run/win-usb
 
 
 ### Several devices connected
 
 If several devices are connected, you will encounter this error:
 
->     error: more than one device/emulator
+>     adb: error: failed to get feature set: more than one device/emulator
 
 the identifier of the device you want to mirror must be provided:
 
@@ -71,7 +61,7 @@ the identifier of the device you want to mirror must be provided:
 scrcpy -s 01234567890abcdef
 ```
 
-Note that if your device is connected over TCP/IP, you might get this message:
+Note that if your device is connected over TCP/IP, you'll get this message:
 
 >     adb: error: more than one device/emulator
 >     ERROR: "adb reverse" returned with value 1
@@ -229,9 +219,6 @@ 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).
 
 
@@ -258,15 +245,8 @@ Caused by: java.lang.IllegalArgumentException: displayToken must not be null
 
 ## Command line on Windows
 
-Since v1.22, a "shortcut" has been added to directly open a terminal in the
+Some Windows users are not familiar with the command line. Here is how to open a
-scrcpy directory. Double-click on `open_a_terminal_here.bat`, then type your
+terminal and run `scrcpy` with arguments:
-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.
@@ -305,4 +285,4 @@ This FAQ is available in other languages:
 
  - [Italiano (Italiano, `it`) - v1.19](FAQ.it.md)
  - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md)
- - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.22](FAQ.zh-Hans.md)
+ - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.18](FAQ.zh-Hans.md)

FAQ.zh-Hans.md

@@ -1,12 +1,7 @@
-_Only the original [FAQ.md](FAQ.md) is guaranteed to be up-to-date._
+只有原版的[FAQ](FAQ.md)会保持更新。
+本文根据[d6aaa5]翻译。
 
-_只有原版的 [FAQ.md](FAQ.md)是保证最新的。_
+[d6aaa5]:https://github.com/Genymobile/scrcpy/blob/d6aaa5bf9aa3710660c683b6e3e0ed971ee44af5/FAQ.md
-
-Current version is based on [28054cd]
-
-本文根据[28054cd]进行翻译。
-
-[28054cd]: https://github.com/Genymobile/scrcpy/blob/28054cd471f848733e11372c9d745cd5d71e6ce7/FAQ.md
 
 # 常见问题
 
@@ -14,11 +9,11 @@ Current version is based on [28054cd]
 
 ## `adb` 相关问题
 
-`scrcpy` 执行 `adb` 命令来初始化和设备之间的连接。如果 `adb` 执行失败了， scrcpy 就无法工作。
+`scrcpy` 执行 `adb` 命令来初始化和设备之间的连接。如果`adb` 执行失败了， scrcpy 就无法工作。
 
 在这种情况中，将会输出这个错误:
 
->     ERROR: "adb get-serialno" returned with value 1
+>     ERROR: "adb push" returned with value 1
 
 这通常不是 _scrcpy_ 的bug，而是你的环境的问题。
 
@@ -38,37 +33,28 @@ adb devices
 
 ### 设备未授权
 
-
+参见这里 [stackoverflow][device-unauthorized].
->     error: device unauthorized.
->     This adb server's $ADB_VENDOR_KEYS is not set
->     Try 'adb kill-server' if that seems wrong.
->     Otherwise check for a confirmation dialog on your device.
-
-连接时，在设备上应该会打开一个弹出窗口。 您必须授权 USB 调试。
-
-如果没有打开，参见[stackoverflow][device-unauthorized].
 
 [device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
 
 
 ### 未检测到设备
 
->     error: no devices/emulators found
+>     adb: error: failed to get feature set: no devices/emulators found
 
 确认已经正确启用 [adb debugging][enable-adb].
 
-如果你的设备没有被检测到，你可能需要一些[驱动][drivers] (在 Windows上)。这里有一个单独的 [适用于Google设备的USB驱动][google-usb-driver].
+如果你的设备没有被检测到，你可能需要一些[驱动][drivers] (在 Windows上).
 
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
-[google-usb-driver]: https://developer.android.com/studio/run/win-usb
 
 
 ### 已连接多个设备
 
 如果连接了多个设备，您将遇到以下错误：
 
->     error: more than one device/emulator
+>     adb: error: failed to get feature set: more than one device/emulator
 
 必须提供要镜像的设备的标识符：
 
@@ -104,19 +90,19 @@ scrcpy
 ### 设备断开连接
 
 如果 _scrcpy_ 在警告“设备连接断开”的情况下自动中止，那就意味着`adb`连接已经断开了。
-
+请尝试使用另一条USB线或者电脑上的另一个USB接口。
-请尝试使用另一条USB线或者电脑上的另一个USB接口。请参看 [#281] 和 [#283]。
+请参看 [#281] 和 [#283]。
 
 [#281]: https://github.com/Genymobile/scrcpy/issues/281
 [#283]: https://github.com/Genymobile/scrcpy/issues/283
 
-
 ## 控制相关问题
 
 ### 鼠标和键盘不起作用
 
 
 在某些设备上，您可能需要启用一个选项以允许 [模拟输入][simulating input]。
+
 在开发者选项中，打开：
 
 > **USB调试 (安全设置)**  
@@ -129,12 +115,10 @@ scrcpy
 
 可输入的文本[被限制为ASCII字符][text-input]。也可以用一些小技巧输入一些[带重音符号的字符][accented-characters]，但是仅此而已。参见[#37]。
 
-自 Linux 上的 scrcpy v1.20 之后，可以模拟[物理键盘][hid] (HID)。
 
 [text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
 [accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
 [#37]: https://github.com/Genymobile/scrcpy/issues/37
-[hid]: README.md#physical-keyboard-simulation-hid
 
 
 ## 客户端相关问题
@@ -145,6 +129,7 @@ scrcpy
 
 [#40]: https://github.com/Genymobile/scrcpy/issues/40
 
+
 为了提升降尺度的质量，如果渲染器是OpenGL并且支持mip映射，就会自动开启三线性过滤。
 
 在Windows上，你可能希望强制使用OpenGL：
@@ -192,7 +177,6 @@ scrcpy
 ## 崩溃
 
 ### 异常
-
 可能有很多原因。一个常见的原因是您的设备无法按给定清晰度进行编码：
 
 > ```
@@ -220,40 +204,12 @@ scrcpy -m 1024
 scrcpy -m 800
 ```
 
-自 scrcpy v1.22以来，scrcpy 会自动在失败前以更低的分辨率重试。这种行为可以用`--no-downsize-on-error`关闭。
-
 你也可以尝试另一种 [编码器](README.md#encoder)。
 
 
-如果您在 Android 12 上遇到此异常，则只需升级到 scrcpy >= 1.18 (见 [#2129])：
-
-```
-> ERROR: Exception on thread Thread[main,5,main]
-java.lang.AssertionError: java.lang.reflect.InvocationTargetException
-    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:75)
-    ...
-Caused by: java.lang.reflect.InvocationTargetException
-    at java.lang.reflect.Method.invoke(Native Method)
-    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:73)
-    ... 7 more
-Caused by: java.lang.IllegalArgumentException: displayToken must not be null
-    at android.view.SurfaceControl$Transaction.setDisplaySurface(SurfaceControl.java:3067)
-    at android.view.SurfaceControl.setDisplaySurface(SurfaceControl.java:2147)
-    ... 9 more
-```
-
-[#2129]: https://github.com/Genymobile/scrcpy/issues/2129
-
-
 ## Windows命令行
 
-从 v1.22 开始，增加了一个“快捷方式”，可以直接在 scrcpy 目录打开一个终端。双击`open_a_terminal_here.bat`，然后输入你的命令。 例如：
+一些Windows用户不熟悉命令行。以下是如何打开终端并带参数执行`scrcpy`：
-
-```
-scrcpy --record file.mkv
-```
-
-您也可以打开终端并手动转到 scrcpy 文件夹：
 
  1. 按下 <kbd>Windows</kbd>+<kbd>r</kbd>，打开一个对话框。
  2. 输入 `cmd` 并按 <kbd>Enter</kbd>，这样就打开了一个终端。
@@ -277,7 +233,7 @@ scrcpy --record file.mkv
 scrcpy --prefer-text --turn-screen-off --stay-awake
 ```
 
-然后只需双击刚刚创建的文件。
+然后双击刚刚创建的文件。
 
 你也可以编辑 `scrcpy-console.bat` 或者 `scrcpy-noconsole.vbs`（的副本）来添加参数。
 

LICENSE

@@ -188,7 +188,7 @@
       identification within third-party archives.
 
    Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2022 Romain Vimont
+   Copyright (C) 2018-2021 Romain Vimont
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.id.md

@@ -672,7 +672,7 @@ Baca [halaman pengembang].
 ## Lisensi
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

README.it.md

@@ -790,7 +790,7 @@ Leggi la [pagina per sviluppatori].
 ## Licenza (in inglese)
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

README.jp.md

@@ -776,7 +776,7 @@ _⁴Android 7以上のみ._
 ## ライセンス
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

README.ko.md

@@ -475,7 +475,7 @@ _²화면이 꺼진 상태에서 우클릭 시 다시 켜지며, 그 외의 상
 ## 라이선스
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

README.md

@@ -1,9 +1,7 @@
-# scrcpy (v1.22)
+# scrcpy (v1.21)
 
 <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,9 +31,6 @@ Its features include:
  - device screen [as a webcam (V4L2)](#v4l2loopback) (Linux-only)
  - [physical keyboard simulation (HID)](#physical-keyboard-simulation-hid)
    (Linux-only)
- - [physical mouse simulation (HID)](#physical-mouse-simulation-hid)
-   (Linux-only)
- - [OTG mode](#otg) (Linux-only)
  - and more…
 
 ## Requirements
@@ -76,12 +71,6 @@ On Debian and Ubuntu:
 apt install scrcpy
 ```
 
-On Arch Linux:
-
-```
-pacman -S scrcpy
-```
-
 A [Snap] package is available: [`scrcpy`][snap-link].
 
 [snap-link]: https://snapstats.org/snaps/scrcpy
@@ -93,6 +82,10 @@ For Fedora, a [COPR] package is available: [`scrcpy`][copr-link].
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 
+For Arch Linux, an [AUR] package is available: [`scrcpy`][aur-link].
+
+[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
+[aur-link]: https://aur.archlinux.org/packages/scrcpy/
 
 For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
 
@@ -108,10 +101,10 @@ process][BUILD_simple]).
 For Windows, for simplicity, a prebuilt archive with all the dependencies
 (including `adb`) is available:
 
- - [`scrcpy-win64-v1.22.zip`][direct-win64]  
+ - [`scrcpy-win64-v1.21.zip`][direct-win64]  
-   _(SHA-256: ce4d9b8cc761e29862c4a72d8ad6f538bdd1f1831d15fd1f36633cd3b403db82)_
+   _(SHA-256: fdab0c1421353b592a9bbcebd6e252675eadccca65cca8105686feaa9c1ded53)_
 
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.22/scrcpy-win64-v1.22.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.21/scrcpy-win64-v1.21.zip
 
 It is also available in [Chocolatey]:
 
@@ -822,65 +815,6 @@ a physical keyboard is connected).
 
 [Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
 
-#### Physical mouse simulation (HID)
-
-Similarly to the physical keyboard simulation, it is possible to simulate a
-physical mouse. Likewise, it only works if the device is connected by USB, and
-is currently only supported on Linux.
-
-By default, scrcpy uses Android mouse events injection, using absolute
-coordinates. By simulating a physical mouse, a mouse pointer appears on the
-Android device, and relative mouse motion, clicks and scrolls are injected.
-
-To enable this mode:
-
-```bash
-scrcpy --hid-mouse
-scrcpy -M  # short version
-```
-
-You could also add `--forward-all-clicks` to [forward all mouse
-buttons][forward_all_clicks].
-
-[forward_all_clicks]: #right-click-and-middle-click
-
-When this mode is enabled, the computer mouse is "captured" (the mouse pointer
-disappears from the computer and appears on the Android device instead).
-
-Special capture keys, either <kbd>Alt</kbd> or <kbd>Super</kbd>, toggle
-(disable or enable) the mouse capture. Use one of them to give the control of
-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
 
@@ -1002,7 +936,7 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
  | Click on `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Middle-click_
  | Click on `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Right-click²_
  | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4th-click³_
- | Click on `MENU` (unlock screen)⁴            | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | Click on `MENU` (unlock screen)             | <kbd>MOD</kbd>+<kbd>m</kbd>
  | Click on `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(up)_
  | Click on `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(down)_
  | Click on `POWER`                            | <kbd>MOD</kbd>+<kbd>p</kbd>
@@ -1013,9 +947,9 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
  | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5th-click³_
  | Expand settings panel                       | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Double-5th-click³_
  | Collapse panels                             | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copy to clipboard⁵                          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Copy to clipboard⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Cut to clipboard⁵                           | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Cut to clipboard⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Synchronize clipboards and paste⁵           | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | Synchronize clipboards and paste⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>
  | Inject computer clipboard text              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
  | Enable/disable FPS counter (on stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
  | Pinch-to-zoom                               | <kbd>Ctrl</kbd>+_click-and-move_
@@ -1025,8 +959,7 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._  
 _³4th and 5th mouse buttons, if your mouse has them._  
-_⁴For react-native apps in development, `MENU` triggers development menu._  
+_⁴Only on Android >= 7._
-_⁵Only on Android >= 7._
 
 Shortcuts with repeated keys are executted by releasing and pressing the key a
 second time. For example, to execute "Expand settings panel":
@@ -1084,7 +1017,7 @@ Read the [developers page].
 ## Licence
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -1110,14 +1043,13 @@ Read the [developers page].
 
 This README is available in other languages:
 
-- [Deutsch (German, `de`) - v1.22](README.de.md)
 - [Indonesian (Indonesia, `id`) - v1.16](README.id.md)
 - [Italiano (Italiano, `it`) - v1.19](README.it.md)
 - [日本語 (Japanese, `jp`) - v1.19](README.jp.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
 - [Português Brasileiro (Brazilian Portuguese, `pt-BR`) - v1.19](README.pt-br.md)
-- [Español (Spanish, `sp`) - v1.21](README.sp.md)
+- [Español (Spanish, `sp`) - v1.17](README.sp.md)
-- [简体中文 (Simplified Chinese, `zh-Hans`) - v1.22](README.zh-Hans.md)
+- [简体中文 (Simplified Chinese, `zh-Hans`) - v1.20](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
 - [Turkish (Turkish, `tr`) - v1.18](README.tr.md)
 

README.pt-br.md

@@ -857,7 +857,7 @@ Leia a [página dos desenvolvedores][developers page].
 ## Licença
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

README.sp.md

@@ -1,36 +1,24 @@
 Solo se garantiza que el archivo [README](README.md) original esté actualizado.
 
-# scrcpy (v1.21)
+# scrcpy (v1.17)
 
-<img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
+Esta aplicación proporciona imagen y control de un dispositivo Android conectado
-
+por USB (o [por TCP/IP][article-tcpip]). No requiere acceso _root_.
-Esta aplicación proporciona control e imagen de un dispositivo Android conectado
-por USB (o [por TCP/IP](#conexión)). No requiere acceso _root_.
 Compatible con _GNU/Linux_, _Windows_ y _macOS_.
 
 ![screenshot](assets/screenshot-debian-600.jpg)
 
-Se enfoca en:
+Sus características principales son:
- - **ser ligera**: aplicación nativa, solo muestra la imagen del dispositivo
+
- - **rendimiento**: 30~120fps, dependiendo del dispositivo
+ - **ligero** (nativo, solo muestra la imagen del dispositivo)
- - **calidad**: 1920×1080 o superior
+ - **desempeño** (30~60fps)
- - **baja latencia**: [35~70ms][lowlatency]
+ - **calidad** (1920×1080 o superior)
- - **inicio rápido**: ~1 segundo para mostrar la primera imagen
+ - **baja latencia** ([35~70ms][lowlatency])
- - **no intrusivo**: no deja nada instalado en el dispositivo
+ - **corto tiempo de inicio** (~1 segundo para mostrar la primera imagen)
- - **beneficios**: sin cuentas, sin anuncios, no requiere acceso a internet
+ - **no intrusivo** (no se deja nada instalado en el dispositivo)
- - **libertad**: software gratis y de código abierto
 
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 
-Con la aplicación puede:
- - [grabar la pantalla](#capturas-y-grabaciones)
- - duplicar la imagen con [la pantalla apagada](#apagar-la-pantalla)
- - [copiar y pegar](#copiar-y-pegar) en ambos sentidos
- - [configurar la calidad](#configuración-de-captura)
- - usar la pantalla del dispositivo [como webcam (V4L2)](#v4l2loopback) (solo en Linux)
- - [emular un teclado físico (HID)](#emular-teclado-físico-hid)
-   (solo en Linux)
- - y mucho más…
 
 ## Requisitos
 
@@ -63,7 +51,7 @@ Construir desde la fuente: [BUILD] ([proceso simplificado][BUILD_simple])
 
 ### Linux
 
-En Debian y Ubuntu:
+En Debian (_test_ y _sid_ por ahora) y Ubuntu (20.04):
 
 ```
 apt install scrcpy
@@ -137,7 +125,7 @@ Necesitarás `adb`, accesible desde `PATH`. Si aún no lo tienes:
 brew install android-platform-tools
 ```
 
-También está disponible en [MacPorts], que configura el adb automáticamente:
+También está disponible en [MacPorts], que configurará el adb automáticamente:
 
 ```bash
 sudo port install scrcpy
@@ -165,7 +153,7 @@ scrcpy --help
 
 ## Características
 
-### Configuración de captura
+### Capturar configuración
 
 #### Reducir la definición
 
@@ -220,11 +208,10 @@ Si `--max-size` también está especificado, el cambio de tamaño es aplicado de
 Para fijar la rotación de la transmisión:
 
 ```bash
-scrcpy --lock-video-orientation     # orientación inicial
+scrcpy --lock-video-orientation 0   # orientación normal
-scrcpy --lock-video-orientation=0   # orientación normal
+scrcpy --lock-video-orientation 1   # 90° contrarreloj
-scrcpy --lock-video-orientation=1   # 90° contrarreloj
+scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation 3   # 90° sentido de las agujas del reloj
-scrcpy --lock-video-orientation=3   # 90° sentido de las agujas del reloj
 ```
 
 Esto afecta la rotación de la grabación.
@@ -246,10 +233,7 @@ Para listar los codificadores disponibles, puedes pasar un nombre de codificador
 scrcpy --encoder _
 ```
 
-### Capturas y grabaciones
+### Grabación
-
-
-#### Grabación
 
 Es posible grabar la pantalla mientras se transmite:
 
@@ -266,117 +250,17 @@ scrcpy -Nr file.mkv
 # interrumpe la grabación con Ctrl+C
 ```
 
-Los "skipped frames" son grabados, incluso si no se mostrados en tiempo real (por razones de desempeño). Los frames tienen _marcas de tiempo_ en el dispositivo, por lo que el "[packet delay
+"Skipped frames" son grabados, incluso si no son mostrados en tiempo real (por razones de desempeño). Los frames tienen _marcas de tiempo_ en el dispositivo, por lo que el "[packet delay
 variation]" no impacta el archivo grabado.
 
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 
 
-#### v4l2loopback
-
-En Linux se puede mandar el stream del video a un dispositivo loopback v4l2, por
-lo que se puede abrir el dispositivo Android como una webcam con cualquier
-programa compatible con v4l2.
-
-Se debe instalar el modulo `v4l2loopback`:
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-Para crear un dispositivo v4l2:
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-Esto va a crear un nuevo dispositivo de video en `/dev/videoN`, donde `N` es un número
-(hay más [opciones](https://github.com/umlaeute/v4l2loopback#options) disponibles
-para crear múltiples dispositivos o usar un ID en específico).
-
-Para ver los dispositivos disponibles:
-
-```bash
-# requiere el paquete v4l-utils
-v4l2-ctl --list-devices
-# simple pero generalmente suficiente
-ls /dev/video*
-```
-
-Para iniciar scrcpy usando una fuente v4l2:
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # deshabilita la transmisión de imagen
-scrcpy --v4l2-sink=/dev/videoN -N            # más corto
-```
-
-(reemplace `N` con el ID del dispositivo, compruebe con `ls /dev/video*`)
-
-Una vez habilitado, podés abrir el stream del video con una herramienta compatible con v4l2:
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLC puede agregar un delay por buffering
-```
-
-Por ejemplo, podrías capturar el video usando [OBS].
-
-[OBS]: https://obsproject.com/
-
-
-#### Buffering
-
-Es posible agregar buffering al video. Esto reduce el ruido en la imagen ("jitter")
-pero aumenta la latencia (vea [#2464]).
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-La opción de buffering está disponible para la transmisión de imagen:
-
-```bash
-scrcpy --display-buffer=50  # agrega 50 ms de buffering a la imagen
-```
-
-y las fuentes V4L2:
-
-```bash
-scrcpy --v4l2-buffer=500    # agrega 500 ms de buffering a la fuente v4l2
-```
-
-
 ### Conexión
 
-#### TCP/IP (Inalámbrica)
+#### Inalámbrica
 
-_Scrcpy_ usa `adb` para comunicarse con el dispositivo, y `adb` puede [conectarse] vía TCP/IP.
+_Scrcpy_ usa `adb` para comunicarse con el dispositivo, y `adb` puede [conectarse] vía TCP/IP:
-El dispositivo debe estar conectado a la misma red que la computadora:
-
-##### Automático
-
-La opción `--tcpip` permite configurar la conexión automáticamente. Hay 2 variables.
-
-Si el dispositivo (accesible en 192.168.1.1 para este ejemplo) ya está escuchando
-en un puerto (generalmente 5555) esperando una conexión adb entrante, entonces corré:
-
-```bash
-scrcpy --tcpip=192.168.1.1       # el puerto default es 5555
-scrcpy --tcpip=192.168.1.1:5555
-```
-
-Si el dispositivo no tiene habilitado el modo adb TCP/IP (o si no sabés la dirección IP),
-entonces conectá el dispositivo por USB y corré:
-
-```bash
-scrcpy --tcpip    # sin argumentos
-```
-
-El programa buscará automáticamente la IP del dispositivo, habilitará el modo TCP/IP, y
-se conectará al dispositivo antes de comenzar a transmitir la imagen.
-
-##### Manual
-
-Como alternativa, se puede habilitar la conexión TCP/IP manualmente usando `adb`:
 
 1. Conecta el dispositivo al mismo Wi-Fi que tu computadora.
 2. Obtén la dirección IP del dispositivo, en Ajustes → Acerca del dispositivo → Estado, o ejecutando este comando:
@@ -418,7 +302,7 @@ scrcpy -s 192.168.0.1:5555  # versión breve
 
 Puedes iniciar múltiples instancias de _scrcpy_ para múltiples dispositivos.
 
-#### Iniciar automáticamente al detectar dispositivo
+#### Autoiniciar al detectar dispositivo
 
 Puedes utilizar [AutoAdb]:
 
@@ -428,82 +312,37 @@ autoadb scrcpy -s '{}'
 
 [AutoAdb]: https://github.com/rom1v/autoadb
 
-#### Túneles
+#### Túnel SSH
 
-Para conectarse a un dispositivo remoto, es posible conectar un cliente local `adb` a un servidor remoto `adb` (siempre y cuando utilicen la misma versión de protocolos _adb_).
+Para conectarse a un dispositivo remoto, es posible conectar un cliente local de `adb` a un servidor remoto `adb` (siempre y cuando utilicen la misma versión de protocolos _adb_):
-
-##### Servidor ADB remoto
-
-Para conectarse a un servidor ADB remoto, haz que el servidor escuche en todas las interfaces:
 
 ```bash
-adb kill-server
+adb kill-server    # cierra el servidor local adb en 5037
-adb -a nodaemon server start
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # conserva este servidor abierto
 ```
 
-**Advertencia: todas las comunicaciones entre los clientes y el servidor ADB están desencriptadas.**
+Desde otra terminal:
-
-Supondremos que este servidor se puede acceder desde 192.168.1.2. Entonces, desde otra
-terminal, corré scrcpy:
 
 ```bash
-export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
-scrcpy --tunnel-host=192.168.1.2
-```
-
-Por default, scrcpy usa el puerto local que se usó para establecer el tunel
-`adb forward` (típicamente `27183`, vea `--port`). También es posible forzar un
-puerto diferente (puede resultar útil en situaciones más complejas, donde haya
-múltiples redirecciones):
-
-```
-scrcpy --tunnel-port=1234
-```
-
-
-##### Túnel SSH
-
-Para comunicarse con un servidor ADB remoto de forma segura, es preferible usar un túnel SSH.
-
-Primero, asegurate que el servidor ADB está corriendo en la computadora remota:
-
-```bash
-adb start-server
-```
-
-Después, establecé el túnel SSH:
-
-```bash
-# local  5038 --> remoto  5037
-# local 27183 <-- remoto 27183
-ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# conserva este servidor abierto
-```
-
-Desde otra terminal, corré scrcpy:
-
-```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
 
 Para evitar habilitar "remote port forwarding", puedes forzar una "forward connection" (nótese el argumento `-L` en vez de `-R`):
 
 ```bash
-# local  5038 --> remoto  5037
+adb kill-server    # cierra el servidor local adb en 5037
-# local 27183 --> remoto 27183
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
-ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # conserva este servidor abierto
 ```
 
-Desde otra terminal, corré scrcpy:
+Desde otra terminal:
 
 ```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
 
+
 Al igual que las conexiones inalámbricas, puede resultar útil reducir la calidad:
 
 ```
@@ -563,7 +402,7 @@ Se puede rotar la ventana:
 scrcpy --rotation 1
 ```
 
-Los posibles valores son:
+Los valores posibles son:
  - `0`: sin rotación
  - `1`: 90 grados contrarreloj
  - `2`: 180 grados
@@ -577,7 +416,7 @@ Nótese que _scrcpy_ maneja 3 diferentes rotaciones:
  - `--rotation` (o <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) rota solo el contenido de la imagen. Esto solo afecta a la imagen mostrada, no a la grabación.
 
 
-### Otras opciones
+### Otras opciones menores
 
 #### Solo lectura ("Read-only")
 
@@ -640,12 +479,14 @@ scrcpy -Sw  # versión breve
 ```
 
 
-#### Apagar al cerrar la aplicación
+#### Renderizar frames vencidos
 
-Para apagar la pantalla del dispositivo al cerrar scrcpy:
+Por defecto, para minimizar la latencia, _scrcpy_ siempre renderiza el último frame disponible decodificado, e ignora cualquier frame anterior.
+
+Para forzar el renderizado de todos los frames (a costo de posible aumento de latencia), use:
 
 ```bash
-scrcpy --power-off-on-close
+scrcpy --render-expired-frames
 ```
 
 #### Mostrar clicks
@@ -707,8 +548,6 @@ Además, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permite inyectar el texto
 
 Algunos dispositivos no se comportan como es esperado al establecer el portapapeles programáticamente. La opción `--legacy-paste` está disponible para cambiar el comportamiento de <kbd>Ctrl</kbd>+<kbd>v</kbd> y <kbd>MOD</kbd>+<kbd>v</kbd> para que también inyecten el texto del portapapeles de la computadora como una secuencia de teclas (de la misma forma que <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
 
-Para deshabilitar la auto-sincronización del portapapeles, use `--no-clipboard-autosync`.
-
 #### Pellizcar para zoom
 
 Para simular "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-y-mover_.
@@ -717,48 +556,6 @@ Más precisamente, mantén <kbd>Ctrl</kbd> mientras presionas botón izquierdo.
 
 Concretamente, scrcpy genera clicks adicionales con un "dedo virtual" en la posición invertida respecto al centro de la pantalla.
 
-#### Emular teclado físico (HID)
-
-Por default, scrcpy usa el sistema de Android para la injección de teclas o texto:
-funciona en todas partes, pero está limitado a ASCII.
-
-En Linux, scrcpy puede emular un teclado USB físico en Android para proveer
-una mejor experiencia al enviar _inputs_ (usando [USB HID vía AOAv2][hid-aoav2]):
-deshabilita el teclado virtual y funciona para todos los caracteres y IME.
-
-[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
-
-Sin embargo, solo funciona si el dispositivo está conectado por USB, y por ahora
-solo funciona en Linux.
-
-Para habilitar este modo:
-
-```bash
-scrcpy --hid-keyboard
-scrcpy -K  # más corto
-```
-
-Si por alguna razón falla (por ejemplo si el dispositivo no está conectado vía
-USB), automáticamente vuelve al modo default (un mensaje se escribirá en la consola).
-Se puede usar los mismos argumentos en la línea de comandos tanto si se conecta con
-USB o vía TCP/IP.
-
-En este modo, los _raw key events_ (_scancodes_) se envían al dispositivo, independientemente
-del mapeo del teclado en el host. Por eso, si el diseño de tu teclado no concuerda, debe ser
-configurado en el dispositivo Android, en Ajustes → Sistema → Idioma y Entrada de Texto
-→ [Teclado Físico].
-
-Se puede iniciar automáticamente en esta página de ajustes:
-
-```bash
-adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
-```
-
-Sin embargo, la opción solo está disponible cuando el teclado HID está activo
-(o cuando se conecta un teclado físico).
-
-[Teclado Físico]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
-
 
 #### Preferencias de inyección de texto
 
@@ -776,23 +573,13 @@ scrcpy --prefer-text
 
 (Pero esto romperá el comportamiento del teclado en los juegos)
 
-Por el contrario, se puede forzar scrcpy para siempre injectar _raw key events_:
-
-```bash
-scrcpy --raw-key-events
-```
-
-Estas opciones no tienen efecto en los teclados HID (todos los _key events_ son enviados como
-_scancodes_ en este modo).
-
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 
 
 #### Repetir tecla
 
-Por defecto, mantener una tecla presionada genera múltiples _key events_. Esto puede
+Por defecto, mantener una tecla presionada genera múltiples _key events_. Esto puede causar problemas de desempeño en algunos juegos, donde estos eventos no tienen sentido de todos modos.
-causar problemas de desempeño en algunos juegos, donde estos eventos no tienen sentido de todos modos.
 
 Para evitar enviar _key events_ repetidos:
 
@@ -800,9 +587,6 @@ Para evitar enviar _key events_ repetidos:
 scrcpy --no-key-repeat
 ```
 
-Estas opciones no tienen efecto en los teclados HID (Android maneja directamente
-las repeticiones de teclas en este modo)
-
 
 #### Botón derecho y botón del medio
 
@@ -824,15 +608,14 @@ No hay respuesta visual, un mensaje se escribirá en la consola.
 
 #### Enviar archivos al dispositivo
 
-Para enviar un archivo a `/sdcard/Download/` en el dispositivo, arrastre y suelte
+Para enviar un archivo a `/sdcard/` en el dispositivo, arrastre y suelte un archivo (no APK) a la ventana de _scrcpy_.
-un archivo (no APK) a la ventana de _scrcpy_.
 
-No hay ninguna respuesta visual, un mensaje se escribirá en la consola.
+No hay respuesta visual, un mensaje se escribirá en la consola.
 
 El directorio de destino puede ser modificado al iniciar:
 
 ```bash
-scrcpy --push-target=/sdcard/Movies/
+scrcpy --push-target=/sdcard/Download/
 ```
 
 
@@ -864,48 +647,36 @@ _<kbd>[Super]</kbd> es generalmente la tecla <kbd>Windows</kbd> o <kbd>Cmd</kbd>
 
 [Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
 
- | Acción                                       |   Atajo
+ | Acción                                      |   Atajo
- | -------------------------------------------  |:-----------------------------
+ | ------------------------------------------- |:-----------------------------
- | Alterne entre pantalla compelta              | <kbd>MOD</kbd>+<kbd>f</kbd>
+ | Alterne entre pantalla compelta             | <kbd>MOD</kbd>+<kbd>f</kbd>
- | Rotar pantalla hacia la izquierda            | <kbd>MOD</kbd>+<kbd>←</kbd> _(izquierda)_
+ | Rotar pantalla hacia la izquierda           | <kbd>MOD</kbd>+<kbd>←</kbd> _(izquierda)_
- | Rotar pantalla hacia la derecha              | <kbd>MOD</kbd>+<kbd>→</kbd> _(derecha)_
+ | Rotar pantalla hacia la derecha             | <kbd>MOD</kbd>+<kbd>→</kbd> _(derecha)_
- | Ajustar ventana a 1:1 ("pixel-perfect")      | <kbd>MOD</kbd>+<kbd>g</kbd>
+ | Ajustar ventana a 1:1 ("pixel-perfect")     | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Ajustar ventana para quitar los bordes negros| <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doble click izquierdo¹_
+ | Ajustar ventana para quitar los bordes negros| <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doble click¹_
- | Click en `INICIO`                            | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Click medio_
+ | Click en `INICIO`                           | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Botón del medio_
- | Click en `RETROCEDER`                        | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Click derecho²_
+ | Click en `RETROCEDER`                       | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Botón derecho²_
- | Click en `CAMBIAR APLICACIÓN`                | <kbd>MOD</kbd>+<kbd>s</kbd> \| _Cuarto botón³_
+ | Click en `CAMBIAR APLICACIÓN`               | <kbd>MOD</kbd>+<kbd>s</kbd>
- | Click en `MENÚ` (desbloquear pantalla)⁴      | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | Click en `MENÚ` (desbloquear pantalla)      | <kbd>MOD</kbd>+<kbd>m</kbd>
- | Click en `SUBIR VOLUMEN`                     | <kbd>MOD</kbd>+<kbd>↑</kbd> _(arriba)_
+ | Click en `SUBIR VOLUMEN`                    | <kbd>MOD</kbd>+<kbd>↑</kbd> _(arriba)_
- | Click en `BAJAR VOLUME`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(abajo)_
+ | Click en `BAJAR VOLUME`                     | <kbd>MOD</kbd>+<kbd>↓</kbd> _(abajo)_
- | Click en `ENCENDIDO`                         | <kbd>MOD</kbd>+<kbd>p</kbd>
+ | Click en `ENCENDIDO`                        | <kbd>MOD</kbd>+<kbd>p</kbd>
- | Encendido                                    | _Botón derecho²_
+ | Encendido                                   | _Botón derecho²_
- | Apagar pantalla (manteniendo la transmisión) | <kbd>MOD</kbd>+<kbd>o</kbd>
+ | Apagar pantalla (manteniendo la transmisión)| <kbd>MOD</kbd>+<kbd>o</kbd>
- | Encender pantalla                            | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
+ | Encender pantalla                           | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
- | Rotar pantalla del dispositivo               | <kbd>MOD</kbd>+<kbd>r</kbd>
+ | Rotar pantalla del dispositivo              | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Abrir panel de notificaciones                | <kbd>MOD</kbd>+<kbd>n</kbd> \| _Quinto botón³_
+ | Abrir panel de notificaciones               | <kbd>MOD</kbd>+<kbd>n</kbd>
- | Abrir panel de configuración                 | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Doble quinto botón³_
+ | Cerrar panel de notificaciones              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Cerrar paneles                               | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copiar al portapapeles³                     | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Copiar al portapapeles⁵                      | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Cortar al portapapeles³                     | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Cortar al portapapeles⁵                      | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Synchronizar portapapeles y pegar³          | <kbd>MOD</kbd>+<kbd>v</kbd>
- | Synchronizar portapapeles y pegar⁵           | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | inyectar texto del portapapeles de la PC    | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
- | Inyectar texto del portapapeles de la PC     | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
  | Habilitar/Deshabilitar contador de FPS (en stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Pellizcar para zoom                          | <kbd>Ctrl</kbd>+_click-y-mover_
+ | Pellizcar para zoom                         | <kbd>Ctrl</kbd>+_click-y-mover_
- | Arrastrar y soltar un archivo (APK)          | Instalar APK desde la computadora
- | Arrastrar y soltar un archivo (no APK)       | [Mover archivo al dispositivo](#enviar-archivos-al-dispositivo)
 
 _¹Doble click en los bordes negros para eliminarlos._  
 _²Botón derecho enciende la pantalla si estaba apagada, sino ejecuta RETROCEDER._  
-_³Cuarto y quinto botón del mouse, si tu mouse los tiene._  
+_³Solo en Android >= 7._
-_⁴Para las apps react-native en desarrollo, `MENU` activa el menú de desarrollo._  
-_⁵Solo en Android >= 7._
-
-Los shortcuts con teclas repetidas se ejecutan soltando y volviendo a apretar la tecla
-por segunda vez. Por ejemplo, para ejecutar "Abrir panel de configuración":
-
- 1. Apretá y mantené apretado <kbd>MOD</kbd>.
- 2. Después apretá dos veces la tecla <kbd>n</kbd>.
- 3. Por último, soltá la tecla <kbd>MOD</kbd>.
 
 Todos los atajos <kbd>Ctrl</kbd>+_tecla_ son enviados al dispositivo para que sean manejados por la aplicación activa.
 
@@ -920,8 +691,6 @@ ADB=/path/to/adb scrcpy
 
 Para sobreescribir el path del archivo `scrcpy-server`, configure el path en `SCRCPY_SERVER_PATH`.
 
-Para sobreescribir el ícono, configure el path en `SCRCPY_ICON_PATH`.
-
 
 ## ¿Por qué _scrcpy_?
 
@@ -951,7 +720,7 @@ Lea la [hoja de desarrolladores (en inglés)](DEVELOP.md).
 ## Licencia
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

README.tr.md

@@ -801,7 +801,7 @@ Bakınız [FAQ](FAQ.md).
 ## Lisans
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

README.zh-Hans.md

@@ -1,19 +1,17 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._
 
-_只有原版的 [README](README.md)是保证最新的。_
+只有原版的[README](README.md)会保持最新。
 
-Current version is based on [f4c7044]
+Current version is based on [65b023a]
 
-本文根据[f4c7044]进行翻译。
+本文根据[65b023a]进行翻译。
 
-[f4c7044]: https://github.com/Genymobile/scrcpy/blob/f4c7044b46ae28eb64cb5e1a15c9649a44023c70/README.md
+[65b023a]: https://github.com/Genymobile/scrcpy/blob/65b023ac6d586593193fd5290f65e25603b68e02/README.md
 
-# scrcpy (v1.22)
+# scrcpy (v1.20)
 
 <img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
 
-_发音为 "**scr**een **c**o**py**"_
-
 本应用程序可以显示并控制通过 USB (或 [TCP/IP][article-tcpip]) 连接的安卓设备，且不需要任何 _root_ 权限。本程序支持 _GNU/Linux_, _Windows_ 和 _macOS_。
 
 ![screenshot](assets/screenshot-debian-600.jpg)
@@ -38,8 +36,6 @@ _发音为 "**scr**een **c**o**py**"_
  - [可配置显示质量](#采集设置)
  - 以设备屏幕[作为摄像头(V4L2)](#v4l2loopback) (仅限 Linux)
  - [模拟物理键盘 (HID)](#物理键盘模拟-hid) (仅限 Linux)
- - [物理鼠标模拟 (HID)](#物理鼠标模拟-hid) (仅限 Linux)
- - [OTG模式](#otg) (仅限 Linux)
  - 更多 ……
 
 ## 系统要求
@@ -72,18 +68,12 @@ _发音为 "**scr**een **c**o**py**"_
 
 ### Linux
 
-在 Debian 和 Ubuntu 上：
+在 Debian (目前仅支持 _testing_ 和 _sid_ 分支) 和Ubuntu (20.04) 上：
 
 ```
 apt install scrcpy
 ```
 
-在 Arch Linux 上:
-
-```
-pacman -S scrcpy
-```
-
 我们也提供 [Snap] 包： [`scrcpy`][snap-link]。
 
 [snap-link]: https://snapstats.org/snaps/scrcpy
@@ -95,6 +85,11 @@ pacman -S scrcpy
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 
+对 Arch Linux 我们提供 [AUR] 包： [`scrcpy`][aur-link]。
+
+[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
+[aur-link]: https://aur.archlinux.org/packages/scrcpy/
+
 对 Gentoo 我们提供 [Ebuild] 包：[`scrcpy/`][ebuild-link]。
 
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
@@ -348,32 +343,9 @@ scrcpy --v4l2-buffer=500    # 为 v4l2 漏增加 500 毫秒的缓冲
 
 ### 连接
 
-#### TCP/IP （无线）
+#### 无线
 
-_Scrcpy_ 使用 `adb` 与设备通信，并且 `adb` 支持通过 TCP/IP [连接]到设备（设备必须连接与电脑相同的网络）。
+_Scrcpy_ 使用 `adb` 与设备通信，并且 `adb` 支持通过 TCP/IP [连接]到设备:
-
-##### 自动配置
-
-参数 `--tcpip` 允许自动配置连接。这里有两种方式。
-
-对于传入的 adb 连接，如果设备（在这个例子中以192.168.1.1为可用地址）已经监听了一个端口（通常是5555），运行：
-
-```bash
-scrcpy --tcpip=192.168.1.1       # 默认端口是5555
-scrcpy --tcpip=192.168.1.1:5555
-```
-
-如果adb TCP/IP（无线） 模式在某些设备上不被启用（或者你不知道IP地址），用USB连接设备，然后运行：
-
-```bash
-scrcpy --tcpip    # 无需其他参数
-```
-
-这将会自动寻找设备IP地址，启用TCP/IP模式，然后在启动之前连接到设备。
-
-##### 手动配置
-
-或者，可以通过 `adb` 使用手动启用 TCP/IP 连接：
 
 1. 将设备和电脑连接至同一 Wi-Fi。
 2. 打开 设置 → 关于手机 → 状态信息，获取设备的 IP 地址，也可以执行以下的命令：
@@ -382,12 +354,12 @@ scrcpy --tcpip    # 无需其他参数
     adb shell ip route | awk '{print $9}'
     ```
 
-3. 启用设备的网络 adb 功能：`adb tcpip 5555`。
+3. 启用设备的网络 adb 功能： `adb tcpip 5555`。
 4. 断开设备的 USB 连接。
 5. 连接到您的设备：`adb connect DEVICE_IP:5555` _(将 `DEVICE_IP` 替换为设备 IP)_。
 6. 正常运行 `scrcpy`。
 
-降低比特率和分辨率可能很有用：
+可能降低码率和分辨率会更好一些：
 
 ```bash
 scrcpy --bit-rate 2M --max-size 800
@@ -425,75 +397,33 @@ autoadb scrcpy -s '{}'
 
 [AutoAdb]: https://github.com/rom1v/autoadb
 
-#### 隧道
+#### SSH 隧道
 
-要远程连接到设备，可以将本地的 adb 客户端连接到远程的 adb 服务端 (需要两端的 _adb_ 协议版本相同)。
+要远程连接到设备，可以将本地的 adb 客户端连接到远程的 adb 服务端 (需要两端的 _adb_ 协议版本相同)：
-
-##### 远程ADB服务器
-
-要连接到一个远程ADB服务器，让服务器在所有接口上监听：
 
 ```bash
-adb kill-server
+adb kill-server    # 关闭本地 5037 端口上的 adb 服务端
-adb -a nodaemon server start
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # 保持该窗口开启
 ```
 
-**警告：所有客户端与ADB服务器的交流都是未加密的。**
+在另一个终端：
-
-假设此服务器可在 192.168.1.2 访问。 然后，从另一个终端，运行 scrcpy：
 
 ```bash
-export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
-scrcpy --tunnel-host=192.168.1.2
-```
-
-默认情况下，scrcpy使用用于 `adb forward` 隧道建立的本地端口（通常是 `27183`，见 `--port` ）。它也可以强制使用一个不同的隧道端口（当涉及更多的重定向时，这在更复杂的情况下可能很有用）:
-
-```
-scrcpy --tunnel-port=1234
-```
-
-
-##### SSH 隧道
-
-为了安全地与远程ADB服务器通信，最好使用SSH隧道。
-
-首先，确保ADB服务器正在远程计算机上运行：
-
-```bash
-adb start-server
-```
-
-然后，建立一个SSH隧道：
-
-```bash
-# 本地  5038 --> 远程  5037
-# 本地 27183 <-- 远程 27183
-ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# 保持该窗口开启
-```
-
-在另一个终端上，运行scrcpy：
-
-```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
 
-若要不使用远程端口转发，可以强制使用正向连接（注意是 `-L` 而不是 `-R` ）：
+若要不使用远程端口转发，可以强制使用正向连接 (注意 `-L` 和 `-R` 的区别)：
 
 ```bash
-# 本地  5038 --> 远程  5037
+adb kill-server    # 关闭本地 5037 端口上的 adb 服务端
-# 本地 27183 <-- 远程 27183
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
-ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # 保持该窗口开启
 ```
 
-在另一个终端上，运行scrcpy：
+在另一个终端:
 
 ```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
 
@@ -511,7 +441,7 @@ scrcpy -b2M -m800 --max-fps 15
 窗口的标题默认为设备型号。可以通过如下命令修改：
 
 ```bash
-scrcpy --window-title "我的设备"
+scrcpy --window-title 'My device'
 ```
 
 #### 位置和大小
@@ -700,8 +630,6 @@ scrcpy --disable-screensaver
 
 一些设备不支持通过程序设置剪贴板。通过 `--legacy-paste` 选项可以修改 <kbd>Ctrl</kbd>+<kbd>v</kbd> 和 <kbd>MOD</kbd>+<kbd>v</kbd> 的工作方式，使它们通过按键事件 (同 <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>) 来注入电脑剪贴板内容。
 
-要禁用自动剪贴板同步功能，使用`--no-clipboard-autosync`。
-
 #### 双指缩放
 
 模拟“双指缩放”：<kbd>Ctrl</kbd>+_按住并移动鼠标_。
@@ -731,60 +659,11 @@ scrcpy -K  # 简写
 
 在这种模式下，原始按键事件 (扫描码) 被发送给设备，而与宿主机按键映射无关。因此，若键盘布局不匹配，需要在 Android 设备上进行配置，具体为 设置 → 系统 → 语言和输入法 → [实体键盘]。
 
-[实体键盘]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
+[Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
-
-#### 物理鼠标模拟 (HID)
-
-与物理键盘模拟类似，可以模拟一个物理鼠标。 同样，它仅在设备通过 USB 连接时才有效，并且目前仅在 Linux 上受支持。
-
-默认情况下，scrcpy 使用 Android 鼠标事件注入，使用绝对坐标。 通过模拟物理鼠标，在Android设备上出现鼠标指针，并注入鼠标相对运动、点击和滚动。
-
-启用此模式:
-
-```bash
-scrcpy --hid-mouse
-scrcpy -M  # 简写
-```
-
-您还可以将 `--forward-all-clicks` 添加到 [转发所有点击][forward_all_clicks].
-
-[forward_all_clicks]: #右键和中键
-
-启用此模式后，计算机鼠标将被“捕获”（鼠标指针从计算机上消失并出现在 Android 设备上）。
-
-特殊的捕获键，<kbd>Alt</kbd> 或 <kbd>Super</kbd>，切换（禁用或启用）鼠标捕获。 使用其中之一将鼠标的控制权交还给计算机。
-
-
-#### OTG
-
-可以仅使用物理键盘和鼠标模拟 (HID) 运行 _scrcpy_，就好像计算机键盘和鼠标通过 OTG 线直接插入设备一样。
-
-在这个模式下，_adb_ (USB 调试)是不必要的，且镜像被禁用。
-
-启用 OTG 模式:
-
-```bash
-scrcpy --otg
-# 如果有多个 USB 设备可用，则通过序列号选择
-scrcpy --otg -s 0123456789abcdef
-```
-
-只开启 HID 键盘 或 HID 鼠标 是可行的：
-
-```bash
-scrcpy --otg --hid-keyboard              # 只开启 HID 键盘
-scrcpy --otg --hid-mouse                 # 只开启 HID 鼠标
-scrcpy --otg --hid-keyboard --hid-mouse  # 开启 HID 键盘 和 HID 鼠标
-# 为了方便，默认两者都开启
-scrcpy --otg                             # 开启 HID 键盘 和 HID 鼠标
-```
-
-像 `--hid-keyboard` 和 `--hid-mouse` 一样，它只在设备通过 USB 连接时才有效，且目前仅在 Linux 上支持。
-
 
 #### 文本注入偏好
 
-输入文字的时候，系统会产生两种[事件][textevents]：
+打字的时候，系统会产生两种[事件][textevents]：
  - _按键事件_ ，代表一个按键被按下或松开。
  - _文本事件_ ，代表一个字符被输入。
 
@@ -796,13 +675,7 @@ scrcpy --otg                             # 开启 HID 键盘 和 HID 鼠标
 scrcpy --prefer-text
 ```
 
-(但这会导致键盘在游戏中工作不正常)
+(这会导致键盘在游戏中工作不正常)
-
-相反，您可以强制始终注入原始按键事件：
-
-```bash
-scrcpy --raw-key-events
-```
 
 该选项不影响 HID 键盘 (该模式下，所有按键都发送为扫描码)。
 
@@ -892,7 +765,7 @@ _<kbd>[Super]</kbd> 键通常是指 <kbd>Windows</kbd> 或 <kbd>Cmd</kbd> 键。
  | 点按 `主屏幕`                     | <kbd>MOD</kbd>+<kbd>h</kbd> \| _中键_
  | 点按 `返回`                       | <kbd>MOD</kbd>+<kbd>b</kbd> \| _右键²_
  | 点按 `切换应用`                   | <kbd>MOD</kbd>+<kbd>s</kbd> \| _第4键³_
- | 点按 `菜单` (解锁屏幕)⁴           | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | 点按 `菜单` (解锁屏幕)            | <kbd>MOD</kbd>+<kbd>m</kbd>
  | 点按 `音量+`                      | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上箭头)_
  | 点按 `音量-`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下箭头)_
  | 点按 `电源`                       | <kbd>MOD</kbd>+<kbd>p</kbd>
@@ -903,9 +776,9 @@ _<kbd>[Super]</kbd> 键通常是指 <kbd>Windows</kbd> 或 <kbd>Cmd</kbd> 键。
  | 展开通知面板                      | <kbd>MOD</kbd>+<kbd>n</kbd> \| _第5键³_
  | 展开设置面板                      | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _双击第5键³_
  | 收起通知面板                      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | 复制到剪贴板⁵                     | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | 复制到剪贴板⁴                     | <kbd>MOD</kbd>+<kbd>c</kbd>
- | 剪切到剪贴板⁵                     | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | 剪切到剪贴板⁴                     | <kbd>MOD</kbd>+<kbd>x</kbd>
- | 同步剪贴板并粘贴⁵                 | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | 同步剪贴板并粘贴⁴                 | <kbd>MOD</kbd>+<kbd>v</kbd>
  | 注入电脑剪贴板文本                | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
  | 打开/关闭FPS显示 (至标准输出)     | <kbd>MOD</kbd>+<kbd>i</kbd>
  | 捏拉缩放                          | <kbd>Ctrl</kbd>+_按住并移动鼠标_
@@ -915,8 +788,7 @@ _<kbd>[Super]</kbd> 键通常是指 <kbd>Windows</kbd> 或 <kbd>Cmd</kbd> 键。
 _¹双击黑边可以去除黑边。_  
 _²点击鼠标右键将在屏幕熄灭时点亮屏幕，其余情况则视为按下返回键 。_  
 _³鼠标的第4键和第5键。_  
-_⁴对于开发中的 react-native 应用程序，`MENU` 触发开发菜单。_  
+_⁴需要安卓版本 Android >= 7。_
-_⁵需要安卓版本 Android >= 7。_
 
 有重复按键的快捷键通过松开再按下一个按键来进行，如“展开设置面板”：
 
@@ -944,7 +816,7 @@ ADB=/path/to/adb scrcpy
 
 一个同事让我找出一个和 [gnirehtet] 一样难以发音的名字。
 
-[`strcpy`] 源于 **str**ing （字符串）； `scrcpy` 源于 **scr**een （屏幕）。
+[`strcpy`] 复制一个 **str**ing （字符串）； `scrcpy` 复制一个 **scr**een （屏幕）。
 
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
@@ -970,7 +842,7 @@ ADB=/path/to/adb scrcpy
 ## 许可协议
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

README.zh-Hant.md

@@ -679,7 +679,7 @@ _³只支援 Android 7+。_
 ## Licence
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

app/meson.build

@@ -11,7 +11,7 @@ src = [
     'src/decoder.c',
     'src/device_msg.c',
     'src/icon.c',
-    'src/file_pusher.c',
+    'src/file_handler.c',
     'src/fps_counter.c',
     'src/frame_buffer.c',
     'src/input_manager.c',
@@ -72,15 +72,12 @@ if v4l2_support
     src += [ 'src/v4l2_sink.c' ]
 endif
 
-usb_support = host_machine.system() == 'linux'
+aoa_hid_support = host_machine.system() == 'linux'
-if usb_support
+if aoa_hid_support
     src += [
-        'src/usb/aoa_hid.c',
+        'src/aoa_hid.c',
-        'src/usb/hid_keyboard.c',
+        'src/hid_keyboard.c',
-        'src/usb/hid_mouse.c',
+        'src/hid_mouse.c',
-        'src/usb/scrcpy_otg.c',
-        'src/usb/screen_otg.c',
-        'src/usb/usb.c',
     ]
 endif
 
@@ -102,16 +99,16 @@ if not crossbuild_windows
         dependencies += dependency('libavdevice')
     endif
 
-    if usb_support
+    if aoa_hid_support
         dependencies += dependency('libusb-1.0')
     endif
 
 else
     # cross-compile mingw32 build (from Linux to Windows)
     prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
-    sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/data/' + prebuilt_sdl2 + '/bin'
+    sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
-    sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/data/' + prebuilt_sdl2 + '/lib'
+    sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/lib'
-    sdl2_include_dir = '../prebuilt-deps/data/' + prebuilt_sdl2 + '/include'
+    sdl2_include_dir = '../prebuilt-deps/' + prebuilt_sdl2 + '/include'
 
     sdl2 = declare_dependency(
         dependencies: [
@@ -121,20 +118,15 @@ else
         include_directories: include_directories(sdl2_include_dir)
     )
 
-    prebuilt_ffmpeg = meson.get_cross_property('prebuilt_ffmpeg')
+    prebuilt_ffmpeg_shared = meson.get_cross_property('prebuilt_ffmpeg_shared')
-    ffmpeg_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/data/' + prebuilt_ffmpeg + '/bin'
+    prebuilt_ffmpeg_dev = meson.get_cross_property('prebuilt_ffmpeg_dev')
-    ffmpeg_include_dir = '../prebuilt-deps/data/' + prebuilt_ffmpeg + '/include'
+    ffmpeg_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_ffmpeg_shared + '/bin'
-
+    ffmpeg_include_dir = '../prebuilt-deps/' + prebuilt_ffmpeg_dev + '/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(ffmpeg_avcodec, dirs: ffmpeg_bin_dir),
+            cc.find_library('avcodec-58', dirs: ffmpeg_bin_dir),
-            cc.find_library(ffmpeg_avformat, dirs: ffmpeg_bin_dir),
+            cc.find_library('avformat-58', dirs: ffmpeg_bin_dir),
-            cc.find_library(ffmpeg_avutil, dirs: ffmpeg_bin_dir),
+            cc.find_library('avutil-56', dirs: ffmpeg_bin_dir),
         ],
         include_directories: include_directories(ffmpeg_include_dir)
     )
@@ -196,7 +188,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_USB', usb_support)
+conf.set('HAVE_AOA_HID', aoa_hid_support)
 
 configure_file(configuration: conf, output: 'config.h')
 

app/scrcpy-windows.rc

@@ -13,7 +13,7 @@ BEGIN
       VALUE "LegalCopyright", "Romain Vimont, Genymobile"
       VALUE "OriginalFilename", "scrcpy.exe"
       VALUE "ProductName", "scrcpy"
-      VALUE "ProductVersion", "1.22"
+      VALUE "ProductVersion", "1.21"
     END
   END
   BLOCK "VarFileInfo"

app/scrcpy.1

@@ -96,8 +96,6 @@ The keyboard layout must be configured (once and for all) on the device, via Set
 
 However, the option is only available when the HID keyboard is enabled (or a physical keyboard is connected).
 
-Also see \fB\-\-hid\-mouse\fR.
-
 .TP
 .B \-\-legacy\-paste
 Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+Shift+v).
@@ -122,30 +120,12 @@ Limit both the width and height of the video to \fIvalue\fR. The other dimension
 
 Default is 0 (unlimited).
 
-.TP
-.B \-M, \-\-hid\-mouse
-Simulate a physical mouse by using HID over AOAv2.
-
-In this mode, the computer mouse is captured to control the device directly (relative mouse mode).
-
-LAlt, LSuper or RSuper toggle the capture mode, to give control of the mouse back to the computer.
-
-It may only work over USB, and is currently only supported on Linux.
-
-Also see \fB\-\-hid\-keyboard\fR.
-
 .TP
 .B \-\-no\-clipboard\-autosync
 By default, scrcpy automatically synchronizes the computer clipboard to the device clipboard before injecting Ctrl+v, and the device clipboard to the computer clipboard whenever it changes.
 
 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).
@@ -162,20 +142,6 @@ 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.
@@ -480,7 +446,7 @@ Copyright \(co 2018 Genymobile
 Genymobile
 .UE
 
-Copyright \(co 2018\-2022
+Copyright \(co 2018\-2021
 .MT rom@rom1v.com
 Romain Vimont
 .ME

app/src/adb.c

@@ -425,7 +425,7 @@ adb_get_serialno(struct sc_intr *intr, unsigned flags) {
     }
 
     if (r == -1) {
-        return NULL;
+        return false;
     }
 
     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 NULL;
+        return false;
     }
 
     assert((size_t) r <= sizeof(buf));

app/src/aoa_hid.c

@@ -50,9 +50,80 @@ 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, struct sc_usb *usb,
+sc_aoa_init(struct sc_aoa *aoa, const char *serial,
             struct sc_acksync *acksync) {
+    assert(acksync);
+
     cbuf_init(&aoa->queue);
 
     if (!sc_mutex_init(&aoa->mutex)) {
@@ -64,9 +135,32 @@ sc_aoa_init(struct sc_aoa *aoa, struct sc_usb *usb,
         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;
 }
@@ -79,6 +173,9 @@ 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);
 }
@@ -95,8 +192,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,
+    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
-                                         request, value, index, buffer, length,
+                                         value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         log_libusb_error((enum libusb_error) result);
@@ -131,8 +228,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,
+    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
-                                         request, value, index, buffer, length,
+                                         value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         log_libusb_error((enum libusb_error) result);
@@ -173,8 +270,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,
+    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
-                                         request, value, index, buffer, length,
+                                         value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         log_libusb_error((enum libusb_error) result);
@@ -195,8 +292,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,
+    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
-                                         request, value, index, buffer, length,
+                                         value, index, buffer, length,
                                          DEFAULT_TIMEOUT);
     if (result < 0) {
         log_libusb_error((enum libusb_error) result);
@@ -246,13 +343,8 @@ run_aoa_thread(void *data) {
 
         if (ack_to_wait != SC_SEQUENCE_INVALID) {
             LOGD("Waiting ack from server sequence=%" PRIu64_, ack_to_wait);
-
+            // Do not block the loop indefinitely if the ack never comes (it should
-            // If some events have ack_to_wait set, then sc_aoa must have been
+            // never happen)
-            // 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);
             enum sc_acksync_wait_result result =
                 sc_acksync_wait(aoa->acksync, ack_to_wait, deadline);
@@ -297,9 +389,7 @@ sc_aoa_stop(struct sc_aoa *aoa) {
     sc_cond_signal(&aoa->event_cond);
     sc_mutex_unlock(&aoa->mutex);
 
-    if (aoa->acksync) {
+    sc_acksync_interrupt(aoa->acksync);
-        sc_acksync_interrupt(aoa->acksync);
-    }
 }
 
 void

app/src/aoa_hid.h

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

app/src/cli.c

@@ -52,8 +52,6 @@
 #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;
@@ -180,8 +178,7 @@ static const struct sc_option options[] = {
                 "directly: `adb shell am start -a "
                 "android.settings.HARD_KEYBOARD_SETTINGS`.\n"
                 "However, the option is only available when the HID keyboard "
-                "is enabled (or a physical keyboard is connected).\n"
+                "is enabled (or a physical keyboard is connected).",
-                "Also see --hid-mouse.",
     },
     {
         .shortopt = 'h',
@@ -217,18 +214,6 @@ static const struct sc_option options[] = {
         .text = "Limit the frame rate of screen capture (officially supported "
                 "since Android 10, but may work on earlier versions).",
     },
-    {
-        .shortopt = 'M',
-        .longopt = "hid-mouse",
-        .text = "Simulate a physical mouse by using HID over AOAv2.\n"
-                "In this mode, the computer mouse is captured to control the "
-                "device directly (relative mouse mode).\n"
-                "LAlt, LSuper or RSuper toggle the capture mode, to give "
-                "control of the mouse back to the computer.\n"
-                "It may only work over USB, and is currently only supported "
-                "on Linux.\n"
-                "Also see --hid-keyboard.",
-    },
     {
         .shortopt = 'm',
         .longopt = "max-size",
@@ -238,13 +223,6 @@ 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",
@@ -262,8 +240,11 @@ static const struct sc_option options[] = {
     {
         .shortopt = 'N',
         .longopt = "no-display",
-        .text = "Do not display device (only when screen recording or V4L2 "
+        .text = "Do not display device (only when screen recording "
-                "sink is enabled).",
+#ifdef HAVE_V4L2
+                "or V4L2 sink "
+#endif
+                "is enabled).",
     },
     {
         .longopt_id = OPT_NO_KEY_REPEAT,
@@ -277,22 +258,6 @@ 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",
@@ -416,14 +381,14 @@ static const struct sc_option options[] = {
                 "Default is 0 (not forced): the local port used for "
                 "establishing the tunnel will be used.",
     },
+#ifdef HAVE_V4L2
     {
         .longopt_id = OPT_V4L2_SINK,
         .longopt = "v4l2-sink",
         .argdesc = "/dev/videoN",
         .text = "Output to v4l2loopback device.\n"
                 "It requires to lock the video orientation (see "
-                "--lock-video-orientation).\n"
+                "--lock-video-orientation).",
-                "This feature is only available on Linux.",
     },
     {
         .longopt_id = OPT_V4L2_BUFFER,
@@ -433,9 +398,9 @@ static const struct sc_option options[] = {
                 "frames. This increases latency to compensate for jitter.\n"
                 "This option is similar to --display-buffer, but specific to "
                 "V4L2 sink.\n"
-                "Default is 0 (no buffering).\n"
+                "Default is 0 (no buffering).",
-                "This option is only available on Linux.",
     },
+#endif
     {
         .shortopt = 'V',
         .longopt = "verbosity",
@@ -1335,14 +1300,8 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                 args->help = true;
                 break;
             case 'K':
-#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
             case OPT_MAX_FPS:
                 if (!parse_max_fps(optarg, &opts->max_fps)) {
                     return false;
@@ -1353,15 +1312,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                     return false;
                 }
                 break;
-            case 'M':
-#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
             case OPT_LOCK_VIDEO_ORIENTATION:
                 if (!parse_lock_video_orientation(optarg,
                         &opts->lock_video_orientation)) {
@@ -1514,35 +1464,15 @@ 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
+            case OPT_V4L2_SINK:
                 opts->v4l2_device = optarg;
                 break;
-#else
-                LOGE("V4L2 (--v4l2-sink) is only available on Linux.");
-                return false;
-#endif
             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
             default:
                 // getopt prints the error message on stderr
@@ -1571,18 +1501,11 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         return false;
     }
 
-    if (opts->v4l2_device) {
+    if (opts->v4l2_device && opts->lock_video_orientation
-        if (opts->lock_video_orientation ==
+                             == SC_LOCK_VIDEO_ORIENTATION_UNLOCKED) {
-                SC_LOCK_VIDEO_ORIENTATION_UNLOCKED) {
+        LOGI("Video orientation is locked for v4l2 sink. "
-            LOGI("Video orientation is locked for v4l2 sink. "
+             "See --lock-video-orientation.");
-                 "See --lock-video-orientation.");
+        opts->lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_INITIAL;
-            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) {
@@ -1617,61 +1540,15 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         }
     }
 
-    if (!opts->control) {
+    if (!opts->control && opts->turn_screen_off) {
-        if (opts->turn_screen_off) {
+        LOGE("Could not request to turn screen off if control is disabled");
-            LOGE("Could not request to turn screen off if control is disabled");
+        return false;
-            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;
-        }
     }
 
-#ifdef HAVE_USB
+    if (!opts->control && opts->stay_awake) {
-    if (opts->otg) {
+        LOGE("Could not request to stay awake if control is disabled");
-        // OTG mode is compatible with only very few options.
+        return false;
-        // 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

@@ -89,22 +89,22 @@ to_fixed_point_16(float f) {
 }
 
 size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
+control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
     buf[0] = msg->type;
     switch (msg->type) {
-        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
+        case 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 SC_CONTROL_MSG_TYPE_INJECT_TEXT: {
+        case CONTROL_MSG_TYPE_INJECT_TEXT: {
             size_t len =
                 write_string(msg->inject_text.text,
-                             SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
+                             CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
             return 1 + len;
         }
-        case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
+        case 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 SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
+        case 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,26 +121,27 @@ 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 SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
+        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
             buf[1] = msg->inject_keycode.action;
             return 2;
-        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
+        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
             buf[1] = msg->get_clipboard.copy_key;
             return 2;
-        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
+        case 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,
-                                      SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
+                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
                                       &buf[10]);
             return 10 + len;
-        case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
+        }
+        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
             buf[1] = msg->set_screen_power_mode.mode;
             return 2;
-        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
+        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
+        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
-        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
+        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
-        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
+        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
             // no additional data
             return 1;
         default:
@@ -150,20 +151,20 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
 }
 
 void
-sc_control_msg_log(const struct sc_control_msg *msg) {
+control_msg_log(const struct control_msg *msg) {
 #define LOG_CMSG(fmt, ...) LOGV("input: " fmt, ## __VA_ARGS__)
     switch (msg->type) {
-        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
+        case 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 SC_CONTROL_MSG_TYPE_INJECT_TEXT:
+        case CONTROL_MSG_TYPE_INJECT_TEXT:
             LOG_CMSG("text \"%s\"", msg->inject_text.text);
             break;
-        case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: {
+        case 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;
@@ -190,7 +191,7 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
             }
             break;
         }
-        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
+        case 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,
@@ -199,34 +200,34 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
                      msg->inject_scroll_event.vscroll,
                      (long) msg->inject_scroll_event.buttons);
             break;
-        case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
+        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
             LOG_CMSG("back-or-screen-on %s",
                      KEYEVENT_ACTION_LABEL(msg->inject_keycode.action));
             break;
-        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
+        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
             LOG_CMSG("get clipboard copy_key=%s",
                      copy_key_labels[msg->get_clipboard.copy_key]);
             break;
-        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
+        case 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 SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
+        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
             LOG_CMSG("power mode %s",
                      SCREEN_POWER_MODE_LABEL(msg->set_screen_power_mode.mode));
             break;
-        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
+        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
             LOG_CMSG("expand notification panel");
             break;
-        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
+        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
             LOG_CMSG("expand settings panel");
             break;
-        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
+        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
             LOG_CMSG("collapse panels");
             break;
-        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
+        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
             LOG_CMSG("rotate device");
             break;
         default:
@@ -236,12 +237,12 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
 }
 
 void
-sc_control_msg_destroy(struct sc_control_msg *msg) {
+control_msg_destroy(struct control_msg *msg) {
     switch (msg->type) {
-        case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
+        case CONTROL_MSG_TYPE_INJECT_TEXT:
             free(msg->inject_text.text);
             break;
-        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
+        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
             free(msg->set_clipboard.text);
             break;
         default:

app/src/control_msg.h

@@ -11,44 +11,44 @@
 #include "android/keycodes.h"
 #include "coords.h"
 
-#define SC_CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
+#define CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
 
-#define SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
+#define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
 // type: 1 byte; sequence: 8 bytes; paste flag: 1 byte; length: 4 bytes
-#define SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (SC_CONTROL_MSG_MAX_SIZE - 14)
+#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (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 {
+enum control_msg_type {
-    SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
+    CONTROL_MSG_TYPE_INJECT_KEYCODE,
-    SC_CONTROL_MSG_TYPE_INJECT_TEXT,
+    CONTROL_MSG_TYPE_INJECT_TEXT,
-    SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+    CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-    SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
+    CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
-    SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
+    CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
-    SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
+    CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
-    SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+    CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
-    SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
+    CONTROL_MSG_TYPE_COLLAPSE_PANELS,
-    SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
+    CONTROL_MSG_TYPE_GET_CLIPBOARD,
-    SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
+    CONTROL_MSG_TYPE_SET_CLIPBOARD,
-    SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
+    CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
-    SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
+    CONTROL_MSG_TYPE_ROTATE_DEVICE,
 };
 
-enum sc_screen_power_mode {
+enum screen_power_mode {
     // see <https://android.googlesource.com/platform/frameworks/base.git/+/pie-release-2/core/java/android/view/SurfaceControl.java#305>
-    SC_SCREEN_POWER_MODE_OFF = 0,
+    SCREEN_POWER_MODE_OFF = 0,
-    SC_SCREEN_POWER_MODE_NORMAL = 2,
+    SCREEN_POWER_MODE_NORMAL = 2,
 };
 
-enum sc_copy_key {
+enum get_clipboard_copy_key {
-    SC_COPY_KEY_NONE,
+    GET_CLIPBOARD_COPY_KEY_NONE,
-    SC_COPY_KEY_COPY,
+    GET_CLIPBOARD_COPY_KEY_COPY,
-    SC_COPY_KEY_CUT,
+    GET_CLIPBOARD_COPY_KEY_CUT,
 };
 
-struct sc_control_msg {
+struct control_msg {
-    enum sc_control_msg_type type;
+    enum control_msg_type type;
     union {
         struct {
             enum android_keyevent_action action;
@@ -77,7 +77,7 @@ struct sc_control_msg {
             // screen may only be turned on on ACTION_DOWN
         } back_or_screen_on;
         struct {
-            enum sc_copy_key copy_key;
+            enum get_clipboard_copy_key copy_key;
         } get_clipboard;
         struct {
             uint64_t sequence;
@@ -85,7 +85,7 @@ struct sc_control_msg {
             bool paste;
         } set_clipboard;
         struct {
-            enum sc_screen_power_mode mode;
+            enum screen_power_mode mode;
         } set_screen_power_mode;
     };
 };
@@ -93,12 +93,12 @@ struct sc_control_msg {
 // buf size must be at least CONTROL_MSG_MAX_SIZE
 // return the number of bytes written
 size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf);
+control_msg_serialize(const struct control_msg *msg, unsigned char *buf);
 
 void
-sc_control_msg_log(const struct sc_control_msg *msg);
+control_msg_log(const struct control_msg *msg);
 
 void
-sc_control_msg_destroy(struct sc_control_msg *msg);
+control_msg_destroy(struct control_msg *msg);
 
 #endif

app/src/controller.c

@@ -5,8 +5,8 @@
 #include "util/log.h"
 
 bool
-sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
+controller_init(struct controller *controller, sc_socket control_socket,
-                   struct sc_acksync *acksync) {
+                struct sc_acksync *acksync) {
     cbuf_init(&controller->queue);
 
     bool ok = receiver_init(&controller->receiver, control_socket, acksync);
@@ -34,23 +34,23 @@ sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
 }
 
 void
-sc_controller_destroy(struct sc_controller *controller) {
+controller_destroy(struct controller *controller) {
     sc_cond_destroy(&controller->msg_cond);
     sc_mutex_destroy(&controller->mutex);
 
-    struct sc_control_msg msg;
+    struct control_msg msg;
     while (cbuf_take(&controller->queue, &msg)) {
-        sc_control_msg_destroy(&msg);
+        control_msg_destroy(&msg);
     }
 
     receiver_destroy(&controller->receiver);
 }
 
 bool
-sc_controller_push_msg(struct sc_controller *controller,
+controller_push_msg(struct controller *controller,
-                       const struct sc_control_msg *msg) {
+                    const struct control_msg *msg) {
     if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
-        sc_control_msg_log(msg);
+        control_msg_log(msg);
     }
 
     sc_mutex_lock(&controller->mutex);
@@ -64,10 +64,9 @@ sc_controller_push_msg(struct sc_controller *controller,
 }
 
 static bool
-process_msg(struct sc_controller *controller,
+process_msg(struct controller *controller, const struct control_msg *msg) {
-            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 = control_msg_serialize(msg, serialized_msg);
-    size_t length = sc_control_msg_serialize(msg, serialized_msg);
     if (!length) {
         return false;
     }
@@ -78,7 +77,7 @@ process_msg(struct sc_controller *controller,
 
 static int
 run_controller(void *data) {
-    struct sc_controller *controller = data;
+    struct controller *controller = data;
 
     for (;;) {
         sc_mutex_lock(&controller->mutex);
@@ -90,14 +89,14 @@ run_controller(void *data) {
             sc_mutex_unlock(&controller->mutex);
             break;
         }
-        struct sc_control_msg msg;
+        struct control_msg msg;
         bool non_empty = cbuf_take(&controller->queue, &msg);
         assert(non_empty);
         (void) non_empty;
         sc_mutex_unlock(&controller->mutex);
 
         bool ok = process_msg(controller, &msg);
-        sc_control_msg_destroy(&msg);
+        control_msg_destroy(&msg);
         if (!ok) {
             LOGD("Could not write msg to socket");
             break;
@@ -107,7 +106,7 @@ run_controller(void *data) {
 }
 
 bool
-sc_controller_start(struct sc_controller *controller) {
+controller_start(struct controller *controller) {
     LOGD("Starting controller thread");
 
     bool ok = sc_thread_create(&controller->thread, run_controller,
@@ -118,7 +117,7 @@ sc_controller_start(struct sc_controller *controller) {
     }
 
     if (!receiver_start(&controller->receiver)) {
-        sc_controller_stop(controller);
+        controller_stop(controller);
         sc_thread_join(&controller->thread, NULL);
         return false;
     }
@@ -127,7 +126,7 @@ sc_controller_start(struct sc_controller *controller) {
 }
 
 void
-sc_controller_stop(struct sc_controller *controller) {
+controller_stop(struct controller *controller) {
     sc_mutex_lock(&controller->mutex);
     controller->stopped = true;
     sc_cond_signal(&controller->msg_cond);
@@ -135,7 +134,7 @@ sc_controller_stop(struct sc_controller *controller) {
 }
 
 void
-sc_controller_join(struct sc_controller *controller) {
+controller_join(struct controller *controller) {
     sc_thread_join(&controller->thread, NULL);
     receiver_join(&controller->receiver);
 }

app/src/controller.h

@@ -12,36 +12,36 @@
 #include "util/net.h"
 #include "util/thread.h"
 
-struct sc_control_msg_queue CBUF(struct sc_control_msg, 64);
+struct control_msg_queue CBUF(struct control_msg, 64);
 
-struct sc_controller {
+struct controller {
     sc_socket control_socket;
     sc_thread thread;
     sc_mutex mutex;
     sc_cond msg_cond;
     bool stopped;
-    struct sc_control_msg_queue queue;
+    struct control_msg_queue queue;
     struct receiver receiver;
 };
 
 bool
-sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
+controller_init(struct controller *controller, sc_socket control_socket,
-                   struct sc_acksync *acksync);
+                struct sc_acksync *acksync);
 
 void
-sc_controller_destroy(struct sc_controller *controller);
+controller_destroy(struct controller *controller);
 
 bool
-sc_controller_start(struct sc_controller *controller);
+controller_start(struct controller *controller);
 
 void
-sc_controller_stop(struct sc_controller *controller);
+controller_stop(struct controller *controller);
 
 void
-sc_controller_join(struct sc_controller *controller);
+controller_join(struct controller *controller);
 
 bool
-sc_controller_push_msg(struct sc_controller *controller,
+controller_push_msg(struct controller *controller,
-                       const struct sc_control_msg *msg);
+                    const struct control_msg *msg);
 
 #endif

app/src/decoder.h

@@ -6,7 +6,6 @@
 #include "trait/packet_sink.h"
 
 #include <stdbool.h>
-#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 
 #define DECODER_MAX_SINKS 2

app/src/events.h

@@ -2,4 +2,3 @@
 #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

@@ -0,0 +1,178 @@
+#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

@@ -0,0 +1,60 @@
+#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

@@ -1,178 +0,0 @@
-#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

@@ -1,59 +0,0 @@
-#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,7 +50,9 @@ swap_frames(AVFrame **lhs, AVFrame **rhs) {
 
 bool
 sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
-                     bool *previous_frame_skipped) {
+                  bool *previous_frame_skipped) {
+    sc_mutex_lock(&fb->mutex);
+
     // 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);
@@ -59,8 +61,6 @@ 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/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 mouse");
+        LOGW("Could not unregister HID");
     }
 }

app/src/hid_mouse.h

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

app/src/icon.c

@@ -2,7 +2,6 @@
 
 #include <assert.h>
 #include <stdbool.h>
-#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include <libavutil/pixdesc.h>
 #include <libavutil/pixfmt.h>
@@ -86,7 +85,7 @@ decode_image(const char *path) {
 
     AVCodecParameters *params = ctx->streams[stream]->codecpar;
 
-    const AVCodec *codec = avcodec_find_decoder(params->codec_id);
+    AVCodec *codec = avcodec_find_decoder(params->codec_id);
     if (!codec) {
         LOGE("Could not find image decoder");
         goto close_input;

app/src/input_events.h

@@ -54,6 +54,7 @@ enum sc_mod {
 
     SC_MOD_NUM = KMOD_NUM,
     SC_MOD_CAPS = KMOD_CAPS,
+    SC_MOD_SCROLL = KMOD_SCROLL,
 };
 
 enum sc_action {
@@ -377,76 +378,4 @@ 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,6 +7,78 @@
 #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
@@ -34,7 +106,7 @@ to_sdl_mod(unsigned shortcut_mod) {
 }
 
 static bool
-is_shortcut_mod(struct sc_input_manager *im, uint16_t sdl_mod) {
+is_shortcut_mod(struct input_manager *im, uint16_t sdl_mod) {
     // keep only the relevant modifier keys
     sdl_mod &= SC_SDL_SHORTCUT_MODS_MASK;
 
@@ -50,17 +122,17 @@ is_shortcut_mod(struct sc_input_manager *im, uint16_t sdl_mod) {
 }
 
 void
-sc_input_manager_init(struct sc_input_manager *im,
+input_manager_init(struct input_manager *im,
-                      const struct sc_input_manager_params *params) {
+                   const struct input_manager_params *params) {
-    assert(!params->controller || (params->kp && params->kp->ops));
+    assert(!params->control || (params->kp && params->kp->ops));
-    assert(!params->controller || (params->mp && params->mp->ops));
+    assert(!params->control || (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;
@@ -85,11 +157,11 @@ sc_input_manager_init(struct sc_input_manager *im,
 }
 
 static void
-send_keycode(struct sc_controller *controller, enum android_keycode keycode,
+send_keycode(struct controller *controller, enum android_keycode keycode,
              enum sc_action action, const char *name) {
     // send DOWN event
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
+    msg.type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
     msg.inject_keycode.action = action == SC_ACTION_DOWN
                               ? AKEY_EVENT_ACTION_DOWN
                               : AKEY_EVENT_ACTION_UP;
@@ -97,100 +169,102 @@ send_keycode(struct sc_controller *controller, enum android_keycode keycode,
     msg.inject_keycode.metastate = 0;
     msg.inject_keycode.repeat = 0;
 
-    if (!sc_controller_push_msg(controller, &msg)) {
+    if (!controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'inject %s'", name);
+        return;
     }
 }
 
 static inline void
-action_home(struct sc_controller *controller, enum sc_action action) {
+action_home(struct controller *controller, enum sc_action action) {
     send_keycode(controller, AKEYCODE_HOME, action, "HOME");
 }
 
 static inline void
-action_back(struct sc_controller *controller, enum sc_action action) {
+action_back(struct controller *controller, enum sc_action action) {
     send_keycode(controller, AKEYCODE_BACK, action, "BACK");
 }
 
 static inline void
-action_app_switch(struct sc_controller *controller, enum sc_action action) {
+action_app_switch(struct controller *controller, enum sc_action action) {
     send_keycode(controller, AKEYCODE_APP_SWITCH, action, "APP_SWITCH");
 }
 
 static inline void
-action_power(struct sc_controller *controller, enum sc_action action) {
+action_power(struct controller *controller, enum sc_action action) {
     send_keycode(controller, AKEYCODE_POWER, action, "POWER");
 }
 
 static inline void
-action_volume_up(struct sc_controller *controller, enum sc_action action) {
+action_volume_up(struct controller *controller, enum sc_action action) {
     send_keycode(controller, AKEYCODE_VOLUME_UP, action, "VOLUME_UP");
 }
 
 static inline void
-action_volume_down(struct sc_controller *controller, enum sc_action action) {
+action_volume_down(struct controller *controller, enum sc_action action) {
     send_keycode(controller, AKEYCODE_VOLUME_DOWN, action, "VOLUME_DOWN");
 }
 
 static inline void
-action_menu(struct sc_controller *controller, enum sc_action action) {
+action_menu(struct controller *controller, enum sc_action action) {
     send_keycode(controller, AKEYCODE_MENU, action, "MENU");
 }
 
 // turn the screen on if it was off, press BACK otherwise
 // If the screen is off, it is turned on only on ACTION_DOWN
 static void
-press_back_or_turn_screen_on(struct sc_controller *controller,
+press_back_or_turn_screen_on(struct controller *controller,
                              enum sc_action action) {
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
+    msg.type = 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;
 
-    if (!sc_controller_push_msg(controller, &msg)) {
+    if (!controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'press back or turn screen on'");
+        return;
     }
 }
 
 static void
-expand_notification_panel(struct sc_controller *controller) {
+expand_notification_panel(struct controller *controller) {
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
+    msg.type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
 
-    if (!sc_controller_push_msg(controller, &msg)) {
+    if (!controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'expand notification panel'");
     }
 }
 
 static void
-expand_settings_panel(struct sc_controller *controller) {
+expand_settings_panel(struct controller *controller) {
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
+    msg.type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
 
-    if (!sc_controller_push_msg(controller, &msg)) {
+    if (!controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'expand settings panel'");
     }
 }
 
 static void
-collapse_panels(struct sc_controller *controller) {
+collapse_panels(struct controller *controller) {
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS;
+    msg.type = CONTROL_MSG_TYPE_COLLAPSE_PANELS;
 
-    if (!sc_controller_push_msg(controller, &msg)) {
+    if (!controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'collapse notification panel'");
     }
 }
 
 static bool
-get_device_clipboard(struct sc_controller *controller,
+get_device_clipboard(struct controller *controller,
-                     enum sc_copy_key copy_key) {
+                     enum get_clipboard_copy_key copy_key) {
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD;
+    msg.type = CONTROL_MSG_TYPE_GET_CLIPBOARD;
     msg.get_clipboard.copy_key = copy_key;
 
-    if (!sc_controller_push_msg(controller, &msg)) {
+    if (!controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'get device clipboard'");
         return false;
     }
@@ -199,7 +273,7 @@ get_device_clipboard(struct sc_controller *controller,
 }
 
 static bool
-set_device_clipboard(struct sc_controller *controller, bool paste,
+set_device_clipboard(struct controller *controller, bool paste,
                      uint64_t sequence) {
     char *text = SDL_GetClipboardText();
     if (!text) {
@@ -214,13 +288,13 @@ set_device_clipboard(struct sc_controller *controller, bool paste,
         return false;
     }
 
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD;
+    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
     msg.set_clipboard.sequence = sequence;
     msg.set_clipboard.text = text_dup;
     msg.set_clipboard.paste = paste;
 
-    if (!sc_controller_push_msg(controller, &msg)) {
+    if (!controller_push_msg(controller, &msg)) {
         free(text_dup);
         LOGW("Could not request 'set device clipboard'");
         return false;
@@ -230,13 +304,13 @@ set_device_clipboard(struct sc_controller *controller, bool paste,
 }
 
 static void
-set_screen_power_mode(struct sc_controller *controller,
+set_screen_power_mode(struct controller *controller,
-                      enum sc_screen_power_mode mode) {
+                      enum screen_power_mode mode) {
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
+    msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
     msg.set_screen_power_mode.mode = mode;
 
-    if (!sc_controller_push_msg(controller, &msg)) {
+    if (!controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'set screen power mode'");
     }
 }
@@ -258,7 +332,7 @@ switch_fps_counter_state(struct fps_counter *fps_counter) {
 }
 
 static void
-clipboard_paste(struct sc_controller *controller) {
+clipboard_paste(struct controller *controller) {
     char *text = SDL_GetClipboardText();
     if (!text) {
         LOGW("Could not get clipboard text: %s", SDL_GetError());
@@ -277,40 +351,40 @@ clipboard_paste(struct sc_controller *controller) {
         return;
     }
 
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
+    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
     msg.inject_text.text = text_dup;
-    if (!sc_controller_push_msg(controller, &msg)) {
+    if (!controller_push_msg(controller, &msg)) {
         free(text_dup);
         LOGW("Could not request 'paste clipboard'");
     }
 }
 
 static void
-rotate_device(struct sc_controller *controller) {
+rotate_device(struct controller *controller) {
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE;
+    msg.type = CONTROL_MSG_TYPE_ROTATE_DEVICE;
 
-    if (!sc_controller_push_msg(controller, &msg)) {
+    if (!controller_push_msg(controller, &msg)) {
         LOGW("Could not request device rotation");
     }
 }
 
 static void
-rotate_client_left(struct sc_screen *screen) {
+rotate_client_left(struct screen *screen) {
     unsigned new_rotation = (screen->rotation + 1) % 4;
-    sc_screen_set_rotation(screen, new_rotation);
+    screen_set_rotation(screen, new_rotation);
 }
 
 static void
-rotate_client_right(struct sc_screen *screen) {
+rotate_client_right(struct screen *screen) {
     unsigned new_rotation = (screen->rotation + 3) % 4;
-    sc_screen_set_rotation(screen, new_rotation);
+    screen_set_rotation(screen, new_rotation);
 }
 
 static void
-sc_input_manager_process_text_input(struct sc_input_manager *im,
+input_manager_process_text_input(struct input_manager *im,
-                                    const SDL_TextInputEvent *event) {
+                                 const SDL_TextInputEvent *event) {
     if (!im->kp->ops->process_text) {
         // The key processor does not support text input
         return;
@@ -329,13 +403,13 @@ sc_input_manager_process_text_input(struct sc_input_manager *im,
 }
 
 static bool
-simulate_virtual_finger(struct sc_input_manager *im,
+simulate_virtual_finger(struct input_manager *im,
                         enum android_motionevent_action action,
                         struct sc_point point) {
     bool up = action == AMOTION_EVENT_ACTION_UP;
 
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
+    msg.type = 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;
@@ -343,7 +417,7 @@ simulate_virtual_finger(struct sc_input_manager *im,
     msg.inject_touch_event.pressure = up ? 0.0f : 1.0f;
     msg.inject_touch_event.buttons = 0;
 
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!controller_push_msg(im->controller, &msg)) {
         LOGW("Could not request 'inject virtual finger event'");
         return false;
     }
@@ -359,10 +433,12 @@ inverse_point(struct sc_point point, struct sc_size size) {
 }
 
 static void
-sc_input_manager_process_key(struct sc_input_manager *im,
+input_manager_process_key(struct input_manager *im,
-                             const SDL_KeyboardEvent *event) {
+                          const SDL_KeyboardEvent *event) {
-    // controller is NULL if --no-control is requested
+    // control: indicates the state of the command-line option --no-control
-    struct sc_controller *controller = im->controller;
+    bool control = im->control;
+
+    struct controller *controller = im->controller;
 
     SDL_Keycode keycode = event->keysym.sym;
     uint16_t mod = event->keysym.mod;
@@ -388,47 +464,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 (controller && !shift && !repeat) {
+                if (control && !shift && !repeat) {
                     action_home(controller, action);
                 }
                 return;
             case SDLK_b: // fall-through
             case SDLK_BACKSPACE:
-                if (controller && !shift && !repeat) {
+                if (control && !shift && !repeat) {
                     action_back(controller, action);
                 }
                 return;
             case SDLK_s:
-                if (controller && !shift && !repeat) {
+                if (control && !shift && !repeat) {
                     action_app_switch(controller, action);
                 }
                 return;
             case SDLK_m:
-                if (controller && !shift && !repeat) {
+                if (control && !shift && !repeat) {
                     action_menu(controller, action);
                 }
                 return;
             case SDLK_p:
-                if (controller && !shift && !repeat) {
+                if (control && !shift && !repeat) {
                     action_power(controller, action);
                 }
                 return;
             case SDLK_o:
-                if (controller && !repeat && down) {
+                if (control && !repeat && down) {
-                    enum sc_screen_power_mode mode = shift
+                    enum screen_power_mode mode = shift
-                                                   ? SC_SCREEN_POWER_MODE_NORMAL
+                                                ? SCREEN_POWER_MODE_NORMAL
-                                                   : SC_SCREEN_POWER_MODE_OFF;
+                                                : SCREEN_POWER_MODE_OFF;
                     set_screen_power_mode(controller, mode);
                 }
                 return;
             case SDLK_DOWN:
-                if (controller && !shift) {
+                if (control && !shift) {
                     // forward repeated events
                     action_volume_down(controller, action);
                 }
                 return;
             case SDLK_UP:
-                if (controller && !shift) {
+                if (control && !shift) {
                     // forward repeated events
                     action_volume_up(controller, action);
                 }
@@ -444,17 +520,19 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 }
                 return;
             case SDLK_c:
-                if (controller && !shift && !repeat && down) {
+                if (control && !shift && !repeat && down) {
-                    get_device_clipboard(controller, SC_COPY_KEY_COPY);
+                    get_device_clipboard(controller,
+                                         GET_CLIPBOARD_COPY_KEY_COPY);
                 }
                 return;
             case SDLK_x:
-                if (controller && !shift && !repeat && down) {
+                if (control && !shift && !repeat && down) {
-                    get_device_clipboard(controller, SC_COPY_KEY_CUT);
+                    get_device_clipboard(controller,
+                                         GET_CLIPBOARD_COPY_KEY_CUT);
                 }
                 return;
             case SDLK_v:
-                if (controller && !repeat && down) {
+                if (control && !repeat && down) {
                     if (shift || im->legacy_paste) {
                         // inject the text as input events
                         clipboard_paste(controller);
@@ -468,17 +546,17 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 return;
             case SDLK_f:
                 if (!shift && !repeat && down) {
-                    sc_screen_switch_fullscreen(im->screen);
+                    screen_switch_fullscreen(im->screen);
                 }
                 return;
             case SDLK_w:
                 if (!shift && !repeat && down) {
-                    sc_screen_resize_to_fit(im->screen);
+                    screen_resize_to_fit(im->screen);
                 }
                 return;
             case SDLK_g:
                 if (!shift && !repeat && down) {
-                    sc_screen_resize_to_pixel_perfect(im->screen);
+                    screen_resize_to_pixel_perfect(im->screen);
                 }
                 return;
             case SDLK_i:
@@ -487,7 +565,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 }
                 return;
             case SDLK_n:
-                if (controller && !repeat && down) {
+                if (control && !repeat && down) {
                     if (shift) {
                         collapse_panels(controller);
                     } else if (im->key_repeat == 0) {
@@ -498,7 +576,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 }
                 return;
             case SDLK_r:
-                if (controller && !shift && !repeat && down) {
+                if (control && !shift && !repeat && down) {
                     rotate_device(controller);
                 }
                 return;
@@ -507,7 +585,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
         return;
     }
 
-    if (!controller) {
+    if (!control) {
         return;
     }
 
@@ -553,9 +631,17 @@ sc_input_manager_process_key(struct sc_input_manager *im,
 }
 
 static void
-sc_input_manager_process_mouse_motion(struct sc_input_manager *im,
+input_manager_process_mouse_motion(struct input_manager *im,
-                                      const SDL_MouseMotionEvent *event) {
+                                   const SDL_MouseMotionEvent *event) {
 
+    uint32_t mask = SDL_BUTTON_LMASK;
+    if (im->forward_all_clicks) {
+        mask |= SDL_BUTTON_MMASK | SDL_BUTTON_RMASK;
+    }
+    //if (!(event->state & mask)) {
+    //    // do not send motion events when no click is pressed
+    //    return;
+    //}
     if (event->which == SDL_TOUCH_MOUSEID) {
         // simulated from touch events, so it's a duplicate
         return;
@@ -564,9 +650,8 @@ sc_input_manager_process_mouse_motion(struct sc_input_manager *im,
     struct sc_mouse_motion_event evt = {
         .position = {
             .screen_size = im->screen->frame_size,
-            .point = sc_screen_convert_window_to_frame_coords(im->screen,
+            .point = screen_convert_window_to_frame_coords(im->screen,
-                                                              event->x,
+                                                           event->x, event->y),
-                                                              event->y),
         },
         .xrel = event->xrel,
         .yrel = event->yrel,
@@ -578,22 +663,18 @@ sc_input_manager_process_mouse_motion(struct sc_input_manager *im,
     assert(im->mp->ops->process_mouse_motion);
     im->mp->ops->process_mouse_motion(im->mp, &evt);
 
-    // vfinger must never be used in relative mode
-    assert(!im->mp->relative_mode || !im->vfinger_down);
-
     if (im->vfinger_down) {
-        assert(!im->mp->relative_mode); // assert one more time
         struct sc_point mouse =
-           sc_screen_convert_window_to_frame_coords(im->screen, event->x,
+            screen_convert_window_to_frame_coords(im->screen, event->x,
-                                                    event->y);
+                                                  event->y);
         struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
         simulate_virtual_finger(im, AMOTION_EVENT_ACTION_MOVE, vfinger);
     }
 }
 
 static void
-sc_input_manager_process_touch(struct sc_input_manager *im,
+input_manager_process_touch(struct input_manager *im,
-                               const SDL_TouchFingerEvent *event) {
+                            const SDL_TouchFingerEvent *event) {
     if (!im->mp->ops->process_touch) {
         // The mouse processor does not support touch events
         return;
@@ -610,8 +691,7 @@ sc_input_manager_process_touch(struct sc_input_manager *im,
     struct sc_touch_event evt = {
         .position = {
             .screen_size = im->screen->frame_size,
-            .point =
+            .point = screen_convert_drawable_to_frame_coords(im->screen, x, y),
-                sc_screen_convert_drawable_to_frame_coords(im->screen, x, y),
         },
         .action = sc_touch_action_from_sdl(event->type),
         .pointer_id = event->fingerId,
@@ -622,9 +702,9 @@ sc_input_manager_process_touch(struct sc_input_manager *im,
 }
 
 static void
-sc_input_manager_process_mouse_button(struct sc_input_manager *im,
+input_manager_process_mouse_button(struct input_manager *im,
-                                      const SDL_MouseButtonEvent *event) {
+                                   const SDL_MouseButtonEvent *event) {
-    struct sc_controller *controller = im->controller;
+    bool control = im->control;
 
     if (event->which == SDL_TOUCH_MOUSEID) {
         // simulated from touch events, so it's a duplicate
@@ -633,42 +713,40 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
 
     bool down = event->type == SDL_MOUSEBUTTONDOWN;
     if (!im->forward_all_clicks) {
-        if (controller) {
+        enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
-            enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
 
-            if (event->button == SDL_BUTTON_X1) {
+        if (control && event->button == SDL_BUTTON_X1) {
-                action_app_switch(controller, action);
+            action_app_switch(im->controller, action);
-                return;
+            return;
-            }
+        }
-            if (event->button == SDL_BUTTON_X2 && down) {
+        if (control && event->button == SDL_BUTTON_X2 && down) {
-                if (event->clicks < 2) {
+            if (event->clicks < 2) {
-                    expand_notification_panel(controller);
+                expand_notification_panel(im->controller);
-                } else {
+            } else {
-                    expand_settings_panel(controller);
+                expand_settings_panel(im->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
         if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
             int32_t x = event->x;
             int32_t y = event->y;
-            sc_screen_hidpi_scale_coords(im->screen, &x, &y);
+            screen_hidpi_scale_coords(im->screen, &x, &y);
             SDL_Rect *r = &im->screen->rect;
             bool outside = x < r->x || x >= r->x + r->w
                         || y < r->y || y >= r->y + r->h;
             if (outside) {
                 if (down) {
-                    sc_screen_resize_to_fit(im->screen);
+                    screen_resize_to_fit(im->screen);
                 }
                 return;
             }
@@ -676,7 +754,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
         // otherwise, send the click event to the device
     }
 
-    if (!controller) {
+    if (!control) {
         return;
     }
 
@@ -685,9 +763,8 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
     struct sc_mouse_click_event evt = {
         .position = {
             .screen_size = im->screen->frame_size,
-            .point = sc_screen_convert_window_to_frame_coords(im->screen,
+            .point = screen_convert_window_to_frame_coords(im->screen, event->x,
-                                                              event->x,
+                                                           event->y),
-                                                              event->y),
         },
         .action = sc_action_from_sdl_mousebutton_type(event->type),
         .button = sc_mouse_button_from_sdl(event->button),
@@ -715,12 +792,11 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
     // In other words, the center of the rotation/scaling is the center of the
     // screen.
 #define CTRL_PRESSED (SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL))
-    if (event->button == SDL_BUTTON_LEFT &&
+    if ((down && !im->vfinger_down && CTRL_PRESSED)
-            ((down && !im->vfinger_down && CTRL_PRESSED) ||
+            || (!down && im->vfinger_down)) {
-             (!down && im->vfinger_down))) {
         struct sc_point mouse =
-            sc_screen_convert_window_to_frame_coords(im->screen, event->x,
+            screen_convert_window_to_frame_coords(im->screen, event->x,
-                                                                 event->y);
+                                                              event->y);
         struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
         enum android_motionevent_action action = down
                                                ? AMOTION_EVENT_ACTION_DOWN
@@ -733,8 +809,8 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
 }
 
 static void
-sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,
+input_manager_process_mouse_wheel(struct input_manager *im,
-                                     const SDL_MouseWheelEvent *event) {
+                                  const SDL_MouseWheelEvent *event) {
     if (!im->mp->ops->process_mouse_scroll) {
         // The mouse processor does not support scroll events
         return;
@@ -748,8 +824,8 @@ sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,
     struct sc_mouse_scroll_event evt = {
         .position = {
             .screen_size = im->screen->frame_size,
-            .point = sc_screen_convert_window_to_frame_coords(im->screen,
+            .point = screen_convert_window_to_frame_coords(im->screen,
-                                                              mouse_x, mouse_y),
+                                                           mouse_x, mouse_y),
         },
         .hscroll = event->x,
         .vscroll = event->y,
@@ -760,81 +836,45 @@ sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,
     im->mp->ops->process_mouse_scroll(im->mp, &evt);
 }
 
-static bool
+bool
-is_apk(const char *file) {
+input_manager_handle_event(struct input_manager *im, SDL_Event *event) {
-    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 (!control) {
+            if (!im->control) {
-                break;
+                return true;
             }
-            sc_input_manager_process_text_input(im, &event->text);
+            input_manager_process_text_input(im, &event->text);
-            break;
+            return true;
         case SDL_KEYDOWN:
         case SDL_KEYUP:
             // some key events do not interact with the device, so process the
             // event even if control is disabled
-            sc_input_manager_process_key(im, &event->key);
+            input_manager_process_key(im, &event->key);
-            break;
+            return true;
         case SDL_MOUSEMOTION:
-            if (!control) {
+            if (!im->control) {
                 break;
             }
-            sc_input_manager_process_mouse_motion(im, &event->motion);
+            input_manager_process_mouse_motion(im, &event->motion);
-            break;
+            return true;
         case SDL_MOUSEWHEEL:
-            if (!control) {
+            if (!im->control) {
                 break;
             }
-            sc_input_manager_process_mouse_wheel(im, &event->wheel);
+            input_manager_process_mouse_wheel(im, &event->wheel);
-            break;
+            return true;
         case SDL_MOUSEBUTTONDOWN:
         case SDL_MOUSEBUTTONUP:
             // some mouse events do not interact with the device, so process
             // the event even if control is disabled
-            sc_input_manager_process_mouse_button(im, &event->button);
+            input_manager_process_mouse_button(im, &event->button);
-            break;
+            return true;
         case SDL_FINGERMOTION:
         case SDL_FINGERDOWN:
         case SDL_FINGERUP:
-            if (!control) {
+            input_manager_process_touch(im, &event->tfinger);
-                break;
+            return true;
-            }
-            sc_input_manager_process_touch(im, &event->tfinger);
-            break;
-        case SDL_DROPFILE: {
-            if (!control) {
-                break;
-            }
-            sc_input_manager_process_file(im, &event->drop);
-        }
     }
+
+    return false;
 }

app/src/input_manager.h

@@ -8,20 +8,21 @@
 #include <SDL2/SDL.h>
 
 #include "controller.h"
-#include "file_pusher.h"
 #include "fps_counter.h"
 #include "options.h"
 #include "trait/key_processor.h"
 #include "trait/mouse_processor.h"
 
-struct sc_input_manager {
+struct screen; // forward declaration to avoid cycle
-    struct sc_controller *controller;
+
-    struct sc_file_pusher *fp;
+struct input_manager {
-    struct sc_screen *screen;
+    struct controller *controller;
+    struct screen *screen;
 
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
 
+    bool control;
     bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
@@ -43,13 +44,13 @@ struct sc_input_manager {
     uint64_t next_sequence; // used for request acknowledgements
 };
 
-struct sc_input_manager_params {
+struct input_manager_params {
-    struct sc_controller *controller;
+    struct controller *controller;
-    struct sc_file_pusher *fp;
+    struct screen *screen;
-    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;
@@ -57,10 +58,10 @@ struct sc_input_manager_params {
 };
 
 void
-sc_input_manager_init(struct sc_input_manager *im,
+input_manager_init(struct input_manager *im,
-                      const struct sc_input_manager_params *params);
+                   const struct input_manager_params *params);
 
-void
+bool
-sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event);
+input_manager_handle_event(struct input_manager *im, SDL_Event *event);
 
 #endif

app/src/keyboard_inject.c

@@ -246,9 +246,9 @@ convert_meta_state(uint16_t mod) {
 }
 
 static bool
-convert_input_key(const struct sc_key_event *event, struct sc_control_msg *msg,
+convert_input_key(const struct sc_key_event *event, struct control_msg *msg,
                   enum sc_key_inject_mode key_inject_mode, uint32_t repeat) {
-    msg->type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
+    msg->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
 
     if (!convert_keycode(event->keycode, &msg->inject_keycode.keycode,
                          event->mods_state, key_inject_mode)) {
@@ -282,9 +282,9 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
         ki->repeat = 0;
     }
 
-    struct sc_control_msg msg;
+    struct control_msg msg;
     if (convert_input_key(event, &msg, ki->key_inject_mode, ki->repeat)) {
-        if (!sc_controller_push_msg(ki->controller, &msg)) {
+        if (!controller_push_msg(ki->controller, &msg)) {
             LOGW("Could not request 'inject keycode'");
         }
     }
@@ -309,14 +309,14 @@ sc_key_processor_process_text(struct sc_key_processor *kp,
         }
     }
 
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
+    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
     msg.inject_text.text = strdup(event->text);
     if (!msg.inject_text.text) {
         LOGW("Could not strdup input text");
         return;
     }
-    if (!sc_controller_push_msg(ki->controller, &msg)) {
+    if (!controller_push_msg(ki->controller, &msg)) {
         free(msg.inject_text.text);
         LOGW("Could not request 'inject text'");
     }
@@ -324,12 +324,11 @@ sc_key_processor_process_text(struct sc_key_processor *kp,
 
 void
 sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
-                        struct sc_controller *controller,
+                        struct controller *controller,
-                        enum sc_key_inject_mode key_inject_mode,
+                        const struct scrcpy_options *options) {
-                        bool forward_key_repeat) {
     ki->controller = controller;
-    ki->key_inject_mode = key_inject_mode;
+    ki->key_inject_mode = options->key_inject_mode;
-    ki->forward_key_repeat = forward_key_repeat;
+    ki->forward_key_repeat = options->forward_key_repeat;
 
     ki->repeat = 0;
 

app/src/keyboard_inject.h

@@ -12,7 +12,7 @@
 struct sc_keyboard_inject {
     struct sc_key_processor key_processor; // key processor trait
 
-    struct sc_controller *controller;
+    struct controller *controller;
 
     // SDL reports repeated events as a boolean, but Android expects the actual
     // number of repetitions. This variable keeps track of the count.
@@ -24,8 +24,7 @@ struct sc_keyboard_inject {
 
 void
 sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
-                        struct sc_controller *controller,
+                        struct controller *controller,
-                        enum sc_key_inject_mode key_inject_mode,
+                        const struct scrcpy_options *options);
-                        bool forward_key_repeat);
 
 #endif

app/src/main.c

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

app/src/mouse_inject.c

@@ -58,15 +58,10 @@ convert_touch_action(enum sc_touch_action action) {
 static void
 sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
                                     const struct sc_mouse_motion_event *event) {
-    if (!event->buttons_state) {
-        // Do not send motion events when no click is pressed
-        return;
-    }
-
     struct sc_mouse_inject *mi = DOWNCAST(mp);
 
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
             .action = AMOTION_EVENT_ACTION_MOVE,
             .pointer_id = POINTER_ID_MOUSE,
@@ -76,7 +71,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
+    if (!controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject mouse motion event'");
     }
 }
@@ -86,8 +81,8 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
                                     const struct sc_mouse_click_event *event) {
     struct sc_mouse_inject *mi = DOWNCAST(mp);
 
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
             .action = convert_mouse_action(event->action),
             .pointer_id = POINTER_ID_MOUSE,
@@ -97,7 +92,7 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
+    if (!controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject mouse click event'");
     }
 }
@@ -107,8 +102,8 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
                                    const struct sc_mouse_scroll_event *event) {
     struct sc_mouse_inject *mi = DOWNCAST(mp);
 
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
+        .type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
         .inject_scroll_event = {
             .position = event->position,
             .hscroll = event->hscroll,
@@ -117,7 +112,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
+    if (!controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject mouse scroll event'");
     }
 }
@@ -127,8 +122,8 @@ sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
                                  const struct sc_touch_event *event) {
     struct sc_mouse_inject *mi = DOWNCAST(mp);
 
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
             .action = convert_touch_action(event->action),
             .pointer_id = event->pointer_id,
@@ -138,14 +133,14 @@ sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
+    if (!controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject touch event'");
     }
 }
 
 void
 sc_mouse_inject_init(struct sc_mouse_inject *mi,
-                     struct sc_controller *controller) {
+                     struct controller *controller) {
     mi->controller = controller;
 
     static const struct sc_mouse_processor_ops ops = {

app/src/mouse_inject.h

@@ -12,11 +12,10 @@
 struct sc_mouse_inject {
     struct sc_mouse_processor mouse_processor; // mouse processor trait
 
-    struct sc_controller *controller;
+    struct controller *controller;
 };
 
 void
-sc_mouse_inject_init(struct sc_mouse_inject *mi,
+sc_mouse_inject_init(struct sc_mouse_inject *mi, struct controller *controller);
-                     struct sc_controller *controller);
 
 #endif

app/src/options.c

@@ -37,9 +37,6 @@ 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,
@@ -57,7 +54,6 @@ 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

@@ -38,11 +38,6 @@ enum sc_keyboard_input_mode {
     SC_KEYBOARD_INPUT_MODE_HID,
 };
 
-enum sc_mouse_input_mode {
-    SC_MOUSE_INPUT_MODE_INJECT,
-    SC_MOUSE_INPUT_MODE_HID,
-};
-
 enum sc_key_inject_mode {
     // Inject special keys, letters and space as key events.
     // Inject numbers and punctuation as text events.
@@ -95,7 +90,6 @@ struct scrcpy_options {
     enum sc_log_level log_level;
     enum sc_record_format record_format;
     enum sc_keyboard_input_mode keyboard_input_mode;
-    enum sc_mouse_input_mode mouse_input_mode;
     struct sc_port_range port_range;
     uint32_t tunnel_host;
     uint16_t tunnel_port;
@@ -112,9 +106,6 @@ 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;
@@ -132,7 +123,6 @@ 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,19 +16,17 @@
 #include "controller.h"
 #include "decoder.h"
 #include "events.h"
-#include "file_pusher.h"
+#include "file_handler.h"
+#ifdef HAVE_AOA_HID
+# include "hid_keyboard.h"
+# include "hid_mouse.h"
+#endif
 #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"
@@ -38,30 +36,29 @@
 
 struct scrcpy {
     struct sc_server server;
-    struct sc_screen screen;
+    struct screen screen;
     struct stream stream;
     struct decoder decoder;
     struct recorder recorder;
 #ifdef HAVE_V4L2
     struct sc_v4l2_sink v4l2_sink;
 #endif
-    struct sc_controller controller;
+    struct controller controller;
-    struct sc_file_pusher file_pusher;
+    struct file_handler file_handler;
-#ifdef HAVE_USB
+#ifdef HAVE_AOA_HID
-    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_USB
+#ifdef HAVE_AOA_HID
         struct sc_hid_keyboard keyboard_hid;
 #endif
     };
     union {
         struct sc_mouse_inject mouse_inject;
-#ifdef HAVE_USB
+#ifdef HAVE_AOA_HID
         struct sc_hid_mouse mouse_hid;
 #endif
     };
@@ -152,18 +149,68 @@ sdl_configure(bool display, bool disable_screensaver) {
 }
 
 static bool
-event_loop(struct scrcpy *s) {
+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 = 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) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
-        switch (event.type) {
+        enum event_result result = handle_event(s, options, &event);
-            case EVENT_STREAM_STOPPED:
+        switch (result) {
+            case EVENT_RESULT_STOPPED_BY_USER:
+                return true;
+            case EVENT_RESULT_STOPPED_BY_EOS:
                 LOGW("Device disconnected");
                 return false;
-            case SDL_QUIT:
+            case EVENT_RESULT_CONTINUE:
-                LOGD("User requested to quit");
-                return true;
-            default:
-                sc_screen_handle_event(&s->screen, &event);
                 break;
         }
     }
@@ -280,16 +327,14 @@ scrcpy(struct scrcpy_options *options) {
     bool ret = false;
 
     bool server_started = false;
-    bool file_pusher_initialized = false;
+    bool file_handler_initialized = false;
     bool recorder_initialized = false;
 #ifdef HAVE_V4L2
     bool v4l2_sink_initialized = false;
 #endif
     bool stream_started = false;
-#ifdef HAVE_USB
+#ifdef HAVE_AOA_HID
     bool aoa_hid_initialized = false;
-    bool hid_keyboard_initialized = false;
-    bool hid_mouse_initialized = false;
 #endif
     bool controller_initialized = false;
     bool controller_started = false;
@@ -317,7 +362,6 @@ 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,
     };
@@ -360,15 +404,12 @@ 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 (!sc_file_pusher_init(&s->file_pusher, serial,
+        if (!file_handler_init(&s->file_handler, serial,
-                                 options->push_target)) {
+                               options->push_target)) {
             goto end;
         }
-        fp = &s->file_pusher;
+        file_handler_initialized = true;
-        file_pusher_initialized = true;
     }
 
     struct decoder *dec = NULL;
@@ -408,183 +449,102 @@ 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_USB
+#ifdef HAVE_AOA_HID
-        bool use_hid_keyboard =
+        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID) {
-            options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID;
-        bool use_hid_mouse =
-            options->mouse_input_mode == SC_MOUSE_INPUT_MODE_HID;
-        if (use_hid_keyboard || use_hid_mouse) {
             bool ok = sc_acksync_init(&s->acksync);
             if (!ok) {
                 goto end;
             }
 
-            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;
-            }
-
-            if (use_hid_keyboard) {
-                if (sc_hid_keyboard_init(&s->keyboard_hid, &s->aoa)) {
-                    hid_keyboard_initialized = true;
-                    kp = &s->keyboard_hid.key_processor;
-                } else {
-                    LOGE("Could not initialize HID keyboard");
-                }
-            }
-
-            if (use_hid_mouse) {
-                if (sc_hid_mouse_init(&s->mouse_hid, &s->aoa)) {
-                    hid_mouse_initialized = true;
-                    mp = &s->mouse_hid.mouse_processor;
-                } else {
-                    LOGE("Could not initialized HID mouse");
-                }
-            }
-
-            bool need_aoa = hid_keyboard_initialized || hid_mouse_initialized;
-
-            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;
-            }
-
             acksync = &s->acksync;
-
-            aoa_hid_initialized = true;
-
-aoa_hid_end:
-            if (!aoa_hid_initialized) {
-                if (hid_keyboard_initialized) {
-                    sc_hid_keyboard_destroy(&s->keyboard_hid);
-                    hid_keyboard_initialized = false;
-                }
-                if (hid_mouse_initialized) {
-                    sc_hid_mouse_destroy(&s->mouse_hid);
-                    hid_mouse_initialized = false;
-                }
-            }
-
-            if (use_hid_keyboard && !hid_keyboard_initialized) {
-                LOGE("Fallback to default keyboard injection method "
-                     "(-K/--hid-keyboard ignored)");
-                options->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT;
-            }
-
-            if (use_hid_mouse && !hid_mouse_initialized) {
-                LOGE("Fallback to default mouse injection method "
-                     "(-M/--hid-mouse ignored)");
-                options->mouse_input_mode = SC_MOUSE_INPUT_MODE_INJECT;
-            }
         }
-#else
-        assert(options->keyboard_input_mode != SC_KEYBOARD_INPUT_MODE_HID);
-        assert(options->mouse_input_mode != SC_MOUSE_INPUT_MODE_HID);
 #endif
-
+        if (!controller_init(&s->controller, s->server.control_socket,
-        // keyboard_input_mode may have been reset if HID mode failed
+                             acksync)) {
-        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_INJECT) {
-            sc_keyboard_inject_init(&s->keyboard_inject, &s->controller,
-                                    options->key_inject_mode,
-                                    options->forward_key_repeat);
-            kp = &s->keyboard_inject.key_processor;
-        }
-
-        // mouse_input_mode may have been reset if HID mode failed
-        if (options->mouse_input_mode == SC_MOUSE_INPUT_MODE_INJECT) {
-            sc_mouse_inject_init(&s->mouse_inject, &s->controller);
-            mp = &s->mouse_inject.mouse_processor;
-        }
-
-        if (!sc_controller_init(&s->controller, s->server.control_socket,
-                                acksync)) {
             goto end;
         }
         controller_initialized = true;
 
-        if (!sc_controller_start(&s->controller)) {
+        if (!controller_start(&s->controller)) {
             goto end;
         }
         controller_started = true;
-        controller = &s->controller;
 
         if (options->turn_screen_off) {
-            struct sc_control_msg msg;
+            struct control_msg msg;
-            msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
+            msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
-            msg.set_screen_power_mode.mode = SC_SCREEN_POWER_MODE_OFF;
+            msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF;
 
-            if (!sc_controller_push_msg(&s->controller, &msg)) {
+            if (!controller_push_msg(&s->controller, &msg)) {
                 LOGW("Could not request 'set screen power mode'");
             }
         }
 
-    }
+        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID) {
+#ifdef HAVE_AOA_HID
+            bool aoa_hid_ok = false;
 
-    // There is a controller if and only if control is enabled
+            bool ok = sc_aoa_init(&s->aoa, serial, acksync);
-    assert(options->control == !!controller);
+            if (!ok) {
+                goto aoa_hid_end;
+            }
+
+            if (!sc_hid_keyboard_init(&s->keyboard_hid, &s->aoa)) {
+                sc_aoa_destroy(&s->aoa);
+                goto aoa_hid_end;
+            }
+
+            if (!sc_aoa_start(&s->aoa)) {
+                sc_hid_keyboard_destroy(&s->keyboard_hid);
+                sc_aoa_destroy(&s->aoa);
+                goto aoa_hid_end;
+            }
+
+            aoa_hid_ok = true;
+            kp = &s->keyboard_hid.key_processor;
+
+            aoa_hid_initialized = true;
+
+aoa_hid_end:
+            if (!aoa_hid_ok) {
+                LOGE("Failed to enable HID over AOA, "
+                     "fallback to default keyboard injection method "
+                     "(-K/--hid-keyboard ignored)");
+                options->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT;
+            }
+#else
+            LOGE("HID over AOA is not supported on this platform, "
+                 "fallback to default keyboard injection method "
+                 "(-K/--hid-keyboard ignored)");
+            options->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT;
+#endif
+        }
+
+        // keyboard_input_mode may have been reset if HID mode failed
+        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_INJECT) {
+            sc_keyboard_inject_init(&s->keyboard_inject, &s->controller,
+                                    options);
+            kp = &s->keyboard_inject.key_processor;
+        }
+
+        //sc_mouse_inject_init(&s->mouse_inject, &s->controller);
+        sc_hid_mouse_init(&s->mouse_hid, &s->aoa);
+        mp = &s->mouse_hid.mouse_processor;
+    }
 
     if (options->display) {
         const char *window_title =
             options->window_title ? options->window_title : info->device_name;
 
-        struct sc_screen_params screen_params = {
+        struct screen_params screen_params = {
-            .controller = controller,
+            .controller = &s->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,
@@ -603,7 +563,7 @@ aoa_hid_end:
             .buffering_time = options->display_buffer,
         };
 
-        if (!sc_screen_init(&s->screen, &screen_params)) {
+        if (!screen_init(&s->screen, &screen_params)) {
             goto end;
         }
         screen_initialized = true;
@@ -631,39 +591,33 @@ aoa_hid_end:
     }
     stream_started = true;
 
-    ret = event_loop(s);
+    ret = event_loop(s, options);
     LOGD("quit...");
 
     // Close the window immediately on closing, because screen_destroy() may
     // only be called once the stream thread is joined (it may take time)
-    sc_screen_hide_window(&s->screen);
+    screen_hide_window(&s->screen);
 
 end:
     // The stream is not stopped explicitly, because it will stop by itself on
     // end-of-stream
-#ifdef HAVE_USB
+#ifdef HAVE_AOA_HID
     if (aoa_hid_initialized) {
-        if (hid_keyboard_initialized) {
+        sc_hid_keyboard_destroy(&s->keyboard_hid);
-            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);
     }
 #endif
     if (controller_started) {
-        sc_controller_stop(&s->controller);
+        controller_stop(&s->controller);
     }
-    if (file_pusher_initialized) {
+    if (file_handler_initialized) {
-        sc_file_pusher_stop(&s->file_pusher);
+        file_handler_stop(&s->file_handler);
     }
     if (screen_initialized) {
-        sc_screen_interrupt(&s->screen);
+        screen_interrupt(&s->screen);
     }
 
     if (server_started) {
@@ -683,37 +637,34 @@ end:
     }
 #endif
 
-#ifdef HAVE_USB
+#ifdef HAVE_AOA_HID
     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
 
     // Destroy the screen only after the stream is guaranteed to be finished,
     // because otherwise the screen could receive new frames after destruction
     if (screen_initialized) {
-        sc_screen_join(&s->screen);
+        screen_join(&s->screen);
-        sc_screen_destroy(&s->screen);
+        screen_destroy(&s->screen);
     }
 
     if (controller_started) {
-        sc_controller_join(&s->controller);
+        controller_join(&s->controller);
     }
     if (controller_initialized) {
-        sc_controller_destroy(&s->controller);
+        controller_destroy(&s->controller);
     }
 
     if (recorder_initialized) {
         recorder_destroy(&s->recorder);
     }
 
-    if (file_pusher_initialized) {
+    if (file_handler_initialized) {
-        sc_file_pusher_join(&s->file_pusher);
+        file_handler_join(&s->file_handler);
-        sc_file_pusher_destroy(&s->file_pusher);
+        file_handler_destroy(&s->file_handler);
     }
 
     sc_server_destroy(&s->server);

app/src/screen.c

@@ -12,7 +12,7 @@
 
 #define DISPLAY_MARGINS 96
 
-#define DOWNCAST(SINK) container_of(SINK, struct sc_screen, frame_sink)
+#define DOWNCAST(SINK) container_of(SINK, struct screen, frame_sink)
 
 static inline struct sc_size
 get_rotated_size(struct sc_size size, int rotation) {
@@ -29,7 +29,7 @@ get_rotated_size(struct sc_size size, int rotation) {
 
 // get the window size in a struct sc_size
 static struct sc_size
-get_window_size(const struct sc_screen *screen) {
+get_window_size(const struct screen *screen) {
     int width;
     int height;
     SDL_GetWindowSize(screen->window, &width, &height);
@@ -41,7 +41,7 @@ get_window_size(const struct sc_screen *screen) {
 }
 
 static struct sc_point
-get_window_position(const struct sc_screen *screen) {
+get_window_position(const struct screen *screen) {
     int x;
     int y;
     SDL_GetWindowPosition(screen->window, &x, &y);
@@ -54,7 +54,7 @@ get_window_position(const struct sc_screen *screen) {
 
 // set the window size to be applied when fullscreen is disabled
 static void
-set_window_size(struct sc_screen *screen, struct sc_size new_size) {
+set_window_size(struct screen *screen, struct sc_size new_size) {
     assert(!screen->fullscreen);
     assert(!screen->maximized);
     SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
@@ -156,14 +156,8 @@ get_initial_optimal_size(struct sc_size content_size, uint16_t req_width,
     return window_size;
 }
 
-static inline bool
+static inline void
-sc_screen_is_relative_mode(struct sc_screen *screen) {
+screen_capture_mouse(struct screen *screen, bool capture) {
-    // 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",
              capture ? "true" : "false", SDL_GetError());
@@ -174,7 +168,7 @@ sc_screen_capture_mouse(struct sc_screen *screen, bool capture) {
 }
 
 static void
-sc_screen_update_content_rect(struct sc_screen *screen) {
+screen_update_content_rect(struct screen *screen) {
     int dw;
     int dh;
     SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
@@ -211,7 +205,7 @@ sc_screen_update_content_rect(struct sc_screen *screen) {
 }
 
 static inline SDL_Texture *
-create_texture(struct sc_screen *screen) {
+create_texture(struct screen *screen) {
     SDL_Renderer *renderer = screen->renderer;
     struct sc_size size = screen->frame_size;
     SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
@@ -242,9 +236,9 @@ create_texture(struct sc_screen *screen) {
 // Set the update_content_rect flag if the window or content size may have
 // changed, so that the content rectangle is recomputed
 static void
-sc_screen_render(struct sc_screen *screen, bool update_content_rect) {
+screen_render(struct screen *screen, bool update_content_rect) {
     if (update_content_rect) {
-        sc_screen_update_content_rect(screen);
+        screen_update_content_rect(screen);
     }
 
     SDL_RenderClear(screen->renderer);
@@ -288,20 +282,20 @@ sc_screen_render(struct sc_screen *screen, bool update_content_rect) {
 // <https://stackoverflow.com/a/40693139/1987178>
 static int
 event_watcher(void *data, SDL_Event *event) {
-    struct sc_screen *screen = data;
+    struct screen *screen = data;
     if (event->type == SDL_WINDOWEVENT
             && event->window.event == SDL_WINDOWEVENT_RESIZED) {
         // In practice, it seems to always be called from the same thread in
         // that specific case. Anyway, it's just a workaround.
-        sc_screen_render(screen, true);
+        screen_render(screen, true);
     }
     return 0;
 }
 #endif
 
 static bool
-sc_screen_frame_sink_open(struct sc_frame_sink *sink) {
+screen_frame_sink_open(struct sc_frame_sink *sink) {
-    struct sc_screen *screen = DOWNCAST(sink);
+    struct screen *screen = DOWNCAST(sink);
     (void) screen;
 #ifndef NDEBUG
     screen->open = true;
@@ -312,8 +306,8 @@ sc_screen_frame_sink_open(struct sc_frame_sink *sink) {
 }
 
 static void
-sc_screen_frame_sink_close(struct sc_frame_sink *sink) {
+screen_frame_sink_close(struct sc_frame_sink *sink) {
-    struct sc_screen *screen = DOWNCAST(sink);
+    struct screen *screen = DOWNCAST(sink);
     (void) screen;
 #ifndef NDEBUG
     screen->open = false;
@@ -323,8 +317,8 @@ sc_screen_frame_sink_close(struct sc_frame_sink *sink) {
 }
 
 static bool
-sc_screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
+screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
-    struct sc_screen *screen = DOWNCAST(sink);
+    struct screen *screen = DOWNCAST(sink);
     return sc_video_buffer_push(&screen->vb, frame);
 }
 
@@ -332,7 +326,7 @@ static void
 sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
                              void *userdata) {
     (void) vb;
-    struct sc_screen *screen = userdata;
+    struct screen *screen = userdata;
 
     // event_failed implies previous_skipped (the previous frame may not have
     // been consumed if the event was not sent)
@@ -365,8 +359,7 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
 }
 
 bool
-sc_screen_init(struct sc_screen *screen,
+screen_init(struct screen *screen, const struct screen_params *params) {
-               const struct sc_screen_params *params) {
     screen->resize_pending = false;
     screen->has_frame = false;
     screen->fullscreen = false;
@@ -375,12 +368,6 @@ 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,
     };
@@ -409,6 +396,9 @@ 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;
@@ -419,9 +409,13 @@ sc_screen_init(struct sc_screen *screen,
         window_flags |= SDL_WINDOW_BORDERLESS;
     }
 
-    // The window will be positioned and sized on first video frame
+    int x = params->window_x != SC_WINDOW_POSITION_UNDEFINED
-    screen->window =
+          ? params->window_x : (int) SDL_WINDOWPOS_UNDEFINED;
-        SDL_CreateWindow(params->window_title, 0, 0, 0, 0, window_flags);
+    int y = params->window_y != SC_WINDOW_POSITION_UNDEFINED
+          ? params->window_y : (int) SDL_WINDOWPOS_UNDEFINED;
+    screen->window = SDL_CreateWindow(params->window_title, x, y,
+                                      window_size.width, window_size.height,
+                                      window_flags);
     if (!screen->window) {
         LOGC("Could not create window: %s", SDL_GetError());
         goto error_destroy_fps_counter;
@@ -489,28 +483,39 @@ sc_screen_init(struct sc_screen *screen,
         goto error_destroy_texture;
     }
 
-    struct sc_input_manager_params im_params = {
+    struct 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,
         .shortcut_mods = params->shortcut_mods,
     };
 
-    sc_input_manager_init(&screen->im, &im_params);
+    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);
+
+    screen_update_content_rect(screen);
+
+    if (params->fullscreen) {
+        screen_switch_fullscreen(screen);
+    }
 
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
     SDL_AddEventWatch(event_watcher, screen);
 #endif
 
     static const struct sc_frame_sink_ops ops = {
-        .open = sc_screen_frame_sink_open,
+        .open = screen_frame_sink_open,
-        .close = sc_screen_frame_sink_close,
+        .close = screen_frame_sink_close,
-        .push = sc_screen_frame_sink_push,
+        .push = screen_frame_sink_push,
     };
 
     screen->frame_sink.ops = &ops;
@@ -539,45 +544,29 @@ error_destroy_video_buffer:
 }
 
 static void
-sc_screen_show_initial_window(struct sc_screen *screen) {
+screen_show_window(struct 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);
 }
 
 void
-sc_screen_hide_window(struct sc_screen *screen) {
+screen_hide_window(struct screen *screen) {
     SDL_HideWindow(screen->window);
 }
 
 void
-sc_screen_interrupt(struct sc_screen *screen) {
+screen_interrupt(struct screen *screen) {
     sc_video_buffer_stop(&screen->vb);
     fps_counter_interrupt(&screen->fps_counter);
 }
 
 void
-sc_screen_join(struct sc_screen *screen) {
+screen_join(struct screen *screen) {
     sc_video_buffer_join(&screen->vb);
     fps_counter_join(&screen->fps_counter);
 }
 
 void
-sc_screen_destroy(struct sc_screen *screen) {
+screen_destroy(struct screen *screen) {
 #ifndef NDEBUG
     assert(!screen->open);
 #endif
@@ -590,7 +579,7 @@ sc_screen_destroy(struct sc_screen *screen) {
 }
 
 static void
-resize_for_content(struct sc_screen *screen, struct sc_size old_content_size,
+resize_for_content(struct screen *screen, struct sc_size old_content_size,
                    struct sc_size new_content_size) {
     struct sc_size window_size = get_window_size(screen);
     struct sc_size target_size = {
@@ -604,7 +593,7 @@ resize_for_content(struct sc_screen *screen, struct sc_size old_content_size,
 }
 
 static void
-set_content_size(struct sc_screen *screen, struct sc_size new_content_size) {
+set_content_size(struct screen *screen, struct sc_size new_content_size) {
     if (!screen->fullscreen && !screen->maximized) {
         resize_for_content(screen, screen->content_size, new_content_size);
     } else if (!screen->resize_pending) {
@@ -618,7 +607,7 @@ set_content_size(struct sc_screen *screen, struct sc_size new_content_size) {
 }
 
 static void
-apply_pending_resize(struct sc_screen *screen) {
+apply_pending_resize(struct screen *screen) {
     assert(!screen->fullscreen);
     assert(!screen->maximized);
     if (screen->resize_pending) {
@@ -629,7 +618,7 @@ apply_pending_resize(struct sc_screen *screen) {
 }
 
 void
-sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation) {
+screen_set_rotation(struct screen *screen, unsigned rotation) {
     assert(rotation < 4);
     if (rotation == screen->rotation) {
         return;
@@ -643,12 +632,12 @@ sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation) {
     screen->rotation = rotation;
     LOGI("Display rotation set to %u", rotation);
 
-    sc_screen_render(screen, true);
+    screen_render(screen, true);
 }
 
 // recreate the texture and resize the window if the frame size has changed
 static bool
-prepare_for_frame(struct sc_screen *screen, struct sc_size new_frame_size) {
+prepare_for_frame(struct screen *screen, struct sc_size new_frame_size) {
     if (screen->frame_size.width != new_frame_size.width
             || screen->frame_size.height != new_frame_size.height) {
         // frame dimension changed, destroy texture
@@ -660,7 +649,7 @@ prepare_for_frame(struct sc_screen *screen, struct sc_size new_frame_size) {
             get_rotated_size(new_frame_size, screen->rotation);
         set_content_size(screen, new_content_size);
 
-        sc_screen_update_content_rect(screen);
+        screen_update_content_rect(screen);
 
         LOGI("New texture: %" PRIu16 "x%" PRIu16,
                      screen->frame_size.width, screen->frame_size.height);
@@ -676,7 +665,7 @@ prepare_for_frame(struct sc_screen *screen, struct sc_size new_frame_size) {
 
 // write the frame into the texture
 static void
-update_texture(struct sc_screen *screen, const AVFrame *frame) {
+update_texture(struct screen *screen, const AVFrame *frame) {
     SDL_UpdateYUVTexture(screen->texture, NULL,
             frame->data[0], frame->linesize[0],
             frame->data[1], frame->linesize[1],
@@ -690,7 +679,7 @@ update_texture(struct sc_screen *screen, const AVFrame *frame) {
 }
 
 static bool
-sc_screen_update_frame(struct sc_screen *screen) {
+screen_update_frame(struct screen *screen) {
     av_frame_unref(screen->frame);
     sc_video_buffer_consume(&screen->vb, screen->frame);
     AVFrame *frame = screen->frame;
@@ -703,23 +692,12 @@ sc_screen_update_frame(struct sc_screen *screen) {
     }
     update_texture(screen, frame);
 
-    if (!screen->has_frame) {
+    screen_render(screen, false);
-        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;
 }
 
 void
-sc_screen_switch_fullscreen(struct sc_screen *screen) {
+screen_switch_fullscreen(struct screen *screen) {
     uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
     if (SDL_SetWindowFullscreen(screen->window, new_mode)) {
         LOGW("Could not switch fullscreen mode: %s", SDL_GetError());
@@ -732,11 +710,11 @@ sc_screen_switch_fullscreen(struct sc_screen *screen) {
     }
 
     LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
-    sc_screen_render(screen, true);
+    screen_render(screen, true);
 }
 
 void
-sc_screen_resize_to_fit(struct sc_screen *screen) {
+screen_resize_to_fit(struct screen *screen) {
     if (screen->fullscreen || screen->maximized) {
         return;
     }
@@ -760,7 +738,7 @@ sc_screen_resize_to_fit(struct sc_screen *screen) {
 }
 
 void
-sc_screen_resize_to_pixel_perfect(struct sc_screen *screen) {
+screen_resize_to_pixel_perfect(struct screen *screen) {
     if (screen->fullscreen) {
         return;
     }
@@ -777,33 +755,35 @@ sc_screen_resize_to_pixel_perfect(struct sc_screen *screen) {
 }
 
 static inline bool
-sc_screen_is_mouse_capture_key(SDL_Keycode key) {
+screen_is_mouse_capture_key(SDL_Keycode key) {
     return key == SDLK_LALT || key == SDLK_LGUI || key == SDLK_RGUI;
 }
 
-void
+bool
-sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event) {
+screen_handle_event(struct screen *screen, SDL_Event *event) {
-    bool relative_mode = sc_screen_is_relative_mode(screen);
-
     switch (event->type) {
-        case EVENT_NEW_FRAME: {
+        case EVENT_NEW_FRAME:
-            bool ok = sc_screen_update_frame(screen);
+            if (!screen->has_frame) {
+                screen->has_frame = true;
+                // this is the very first frame, show the window
+                screen_show_window(screen);
+            }
+            bool ok = screen_update_frame(screen);
             if (!ok) {
                 LOGW("Frame update failed\n");
             }
-            return;
+            return true;
-        }
         case SDL_WINDOWEVENT:
             if (!screen->has_frame) {
                 // Do nothing
-                return;
+                return true;
             }
             switch (event->window.event) {
                 case SDL_WINDOWEVENT_EXPOSED:
-                    sc_screen_render(screen, true);
+                    screen_render(screen, true);
                     break;
                 case SDL_WINDOWEVENT_SIZE_CHANGED:
-                    sc_screen_render(screen, true);
+                    screen_render(screen, true);
                     break;
                 case SDL_WINDOWEVENT_MAXIMIZED:
                     screen->maximized = true;
@@ -819,80 +799,78 @@ sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event) {
                     }
                     screen->maximized = false;
                     apply_pending_resize(screen);
-                    sc_screen_render(screen, true);
+                    screen_render(screen, true);
                     break;
                 case SDL_WINDOWEVENT_FOCUS_LOST:
-                    if (relative_mode) {
+                    if (screen->im.mp->relative_mode) {
-                        sc_screen_capture_mouse(screen, false);
+                        screen_capture_mouse(screen, false);
                     }
                     break;
             }
-            return;
+            return true;
         case SDL_KEYDOWN:
-            if (relative_mode) {
+            if (screen->im.mp->relative_mode) {
                 SDL_Keycode key = event->key.keysym.sym;
-                if (sc_screen_is_mouse_capture_key(key)) {
+                if (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 (relative_mode) {
+            if (screen->im.mp->relative_mode) {
                 SDL_Keycode key = event->key.keysym.sym;
                 SDL_Keycode cap = screen->mouse_capture_key_pressed;
                 screen->mouse_capture_key_pressed = 0;
-                if (sc_screen_is_mouse_capture_key(key)) {
+                if (key == cap) {
-                    if (key == cap) {
+                    // A mouse capture key has been pressed then released:
-                        // A mouse capture key has been pressed then released:
+                    // toggle the capture mouse mode
-                        // toggle the capture mouse mode
+                    screen_capture_mouse(screen, !screen->mouse_captured);
-                        sc_screen_capture_mouse(screen,
+                    return true;
-                                                !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 (relative_mode && !screen->mouse_captured) {
+            if (screen->im.mp->relative_mode && !screen->mouse_captured) {
                 // Do not forward to input manager, the mouse will be captured
                 // on SDL_MOUSEBUTTONUP
-                return;
+                return true;
             }
             break;
         case SDL_FINGERMOTION:
         case SDL_FINGERDOWN:
         case SDL_FINGERUP:
-            if (relative_mode) {
+            if (screen->im.mp->relative_mode) {
                 // Touch events are not compatible with relative mode
                 // (coordinates are not relative)
-                return;
+                return true;
             }
             break;
         case SDL_MOUSEBUTTONUP:
-            if (relative_mode && !screen->mouse_captured) {
+            if (screen->im.mp->relative_mode && !screen->mouse_captured) {
-                sc_screen_capture_mouse(screen, true);
+                screen_capture_mouse(screen, true);
-                return;
             }
-            break;
+            return true;
     }
 
-    sc_input_manager_handle_event(&screen->im, event);
+    return input_manager_handle_event(&screen->im, event);
 }
 
 struct sc_point
-sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen,
+screen_convert_drawable_to_frame_coords(struct screen *screen,
-                                           int32_t x, int32_t y) {
+                                        int32_t x, int32_t y) {
     unsigned rotation = screen->rotation;
     assert(rotation < 4);
 
@@ -928,14 +906,14 @@ sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen,
 }
 
 struct sc_point
-sc_screen_convert_window_to_frame_coords(struct sc_screen *screen,
+screen_convert_window_to_frame_coords(struct screen *screen,
-                                         int32_t x, int32_t y) {
+                                      int32_t x, int32_t y) {
-    sc_screen_hidpi_scale_coords(screen, &x, &y);
+    screen_hidpi_scale_coords(screen, &x, &y);
-    return sc_screen_convert_drawable_to_frame_coords(screen, x, y);
+    return screen_convert_drawable_to_frame_coords(screen, x, y);
 }
 
 void
-sc_screen_hidpi_scale_coords(struct sc_screen *screen, int32_t *x, int32_t *y) {
+screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y) {
     // take the HiDPI scaling (dw/ww and dh/wh) into account
     int ww, wh, dw, dh;
     SDL_GetWindowSize(screen->window, &ww, &wh);

app/src/screen.h

@@ -17,26 +17,17 @@
 #include "trait/mouse_processor.h"
 #include "video_buffer.h"
 
-struct sc_screen {
+struct screen {
     struct sc_frame_sink frame_sink; // frame sink trait
 
 #ifndef NDEBUG
     bool open; // track the open/close state to assert correct behavior
 #endif
 
-    struct sc_input_manager im;
+    struct input_manager im;
     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;
@@ -68,12 +59,12 @@ struct sc_screen {
     AVFrame *frame;
 };
 
-struct sc_screen_params {
+struct screen_params {
-    struct sc_controller *controller;
+    struct 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;
@@ -83,10 +74,10 @@ struct sc_screen_params {
     struct sc_size frame_size;
     bool always_on_top;
 
-    int16_t window_x; // accepts SC_WINDOW_POSITION_UNDEFINED
+    int16_t window_x;
-    int16_t window_y; // accepts SC_WINDOW_POSITION_UNDEFINED
+    int16_t window_y;
-    uint16_t window_width;
+    uint16_t window_width;  // accepts SC_WINDOW_POSITION_UNDEFINED
-    uint16_t window_height;
+    uint16_t window_height; // accepts SC_WINDOW_POSITION_UNDEFINED
 
     bool window_borderless;
 
@@ -100,65 +91,65 @@ struct sc_screen_params {
 
 // initialize screen, create window, renderer and texture (window is hidden)
 bool
-sc_screen_init(struct sc_screen *screen, const struct sc_screen_params *params);
+screen_init(struct screen *screen, const struct screen_params *params);
 
 // request to interrupt any inner thread
 // must be called before screen_join()
 void
-sc_screen_interrupt(struct sc_screen *screen);
+screen_interrupt(struct screen *screen);
 
 // join any inner thread
 void
-sc_screen_join(struct sc_screen *screen);
+screen_join(struct screen *screen);
 
 // destroy window, renderer and texture (if any)
 void
-sc_screen_destroy(struct sc_screen *screen);
+screen_destroy(struct screen *screen);
 
 // hide the window
 //
 // It is used to hide the window immediately on closing without waiting for
 // screen_destroy()
 void
-sc_screen_hide_window(struct sc_screen *screen);
+screen_hide_window(struct screen *screen);
 
 // switch the fullscreen mode
 void
-sc_screen_switch_fullscreen(struct sc_screen *screen);
+screen_switch_fullscreen(struct screen *screen);
 
 // resize window to optimal size (remove black borders)
 void
-sc_screen_resize_to_fit(struct sc_screen *screen);
+screen_resize_to_fit(struct screen *screen);
 
 // resize window to 1:1 (pixel-perfect)
 void
-sc_screen_resize_to_pixel_perfect(struct sc_screen *screen);
+screen_resize_to_pixel_perfect(struct screen *screen);
 
 // set the display rotation (0, 1, 2 or 3, x90 degrees counterclockwise)
 void
-sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation);
+screen_set_rotation(struct screen *screen, unsigned rotation);
 
 // react to SDL events
-void
+bool
-sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event);
+screen_handle_event(struct screen *screen, SDL_Event *event);
 
 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels
 struct sc_point
-sc_screen_convert_window_to_frame_coords(struct sc_screen *screen,
+screen_convert_window_to_frame_coords(struct screen *screen,
-                                        int32_t x, int32_t y);
+                                      int32_t x, int32_t y);
 
 // convert point from drawable coordinates to frame coordinates
 // x and y are expressed in pixels
 struct sc_point
-sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen,
+screen_convert_drawable_to_frame_coords(struct screen *screen,
-                                          int32_t x, int32_t y);
+                                        int32_t x, int32_t y);
 
 // Convert coordinates from window to drawable.
 // Events are expressed in window coordinates, but content is expressed in
 // drawable coordinates. They are the same if HiDPI scaling is 1, but differ
 // otherwise.
 void
-sc_screen_hidpi_scale_coords(struct sc_screen *screen, int32_t *x, int32_t *y);
+screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y);
 
 #endif

app/src/server.c

@@ -188,6 +188,7 @@ execute_server(struct sc_server *server,
         } \
         cmd[count++] = p; \
     }
+#define STRBOOL(v) (v ? "true" : "false")
 
     ADD_PARAM("log_level=%s", log_level_to_server_string(params->log_level));
     ADD_PARAM("bit_rate=%" PRIu32, params->bit_rate);
@@ -203,23 +204,23 @@ execute_server(struct sc_server *server,
                   params->lock_video_orientation);
     }
     if (server->tunnel.forward) {
-        ADD_PARAM("tunnel_forward=true");
+        ADD_PARAM("tunnel_forward=%s", STRBOOL(server->tunnel.forward));
     }
     if (params->crop) {
         ADD_PARAM("crop=%s", params->crop);
     }
     if (!params->control) {
         // By default, control is true
-        ADD_PARAM("control=false");
+        ADD_PARAM("control=%s", STRBOOL(params->control));
     }
     if (params->display_id) {
         ADD_PARAM("display_id=%" PRIu32, params->display_id);
     }
     if (params->show_touches) {
-        ADD_PARAM("show_touches=true");
+        ADD_PARAM("show_touches=%s", STRBOOL(params->show_touches));
     }
     if (params->stay_awake) {
-        ADD_PARAM("stay_awake=true");
+        ADD_PARAM("stay_awake=%s", STRBOOL(params->stay_awake));
     }
     if (params->codec_options) {
         ADD_PARAM("codec_options=%s", params->codec_options);
@@ -228,15 +229,11 @@ execute_server(struct sc_server *server,
         ADD_PARAM("encoder_name=%s", params->encoder_name);
     }
     if (params->power_off_on_close) {
-        ADD_PARAM("power_off_on_close=true");
+        ADD_PARAM("power_off_on_close=%s", STRBOOL(params->power_off_on_close));
     }
     if (!params->clipboard_autosync) {
         // By default, clipboard_autosync is true
-        ADD_PARAM("clipboard_autosync=false");
+        ADD_PARAM("clipboard_autosync=%s", STRBOOL(params->clipboard_autosync));
-    }
-    if (!params->downsize_on_error) {
-        // By default, downsize_on_error is true
-        ADD_PARAM("downsize_on_error=false");
     }
 
 #undef ADD_PARAM
@@ -769,10 +766,12 @@ 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
@@ -828,13 +827,6 @@ 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,7 +42,6 @@ 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/stream.c

@@ -1,6 +1,7 @@
 #include "stream.h"
 
 #include <assert.h>
+#include <libavformat/avformat.h>
 #include <libavutil/time.h>
 #include <unistd.h>
 
@@ -191,7 +192,7 @@ static int
 run_stream(void *data) {
     struct stream *stream = data;
 
-    const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
+    AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
     if (!codec) {
         LOGE("H.264 decoder not found");
         goto end;

app/src/stream.h

@@ -5,7 +5,6 @@
 
 #include <stdbool.h>
 #include <stdint.h>
-#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 
 #include "trait/packet_sink.h"

app/src/usb/scrcpy_otg.c

@@ -1,232 +0,0 @@
-#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

@@ -1,12 +0,0 @@
-#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

@@ -1,267 +0,0 @@
-#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

@@ -1,46 +0,0 @@
-#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

@@ -1,264 +0,0 @@
-#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

@@ -1,69 +0,0 @@
-#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/src/util/log.c

@@ -1,8 +1,5 @@
 #include "log.h"
 
-#if _WIN32
-# include <windows.h>
-#endif
 #include <assert.h>
 
 static SDL_LogPriority
@@ -54,24 +51,3 @@ sc_get_log_level(void) {
     SDL_LogPriority sdl_log = SDL_LogGetPriority(SDL_LOG_CATEGORY_APPLICATION);
     return log_level_sdl_to_sc(sdl_log);
 }
-
-#ifdef _WIN32
-bool
-sc_log_windows_error(const char *prefix, int error) {
-    assert(prefix);
-
-    char *message;
-    DWORD flags = FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM;
-    DWORD lang_id = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
-    int ret =
-        FormatMessage(flags, NULL, error, lang_id, (char *) &message, 0, NULL);
-    if (ret <= 0) {
-        return false;
-    }
-
-    // Note: message already contains a trailing '\n'
-    LOGE("%s: [%d] %s", prefix, error, message);
-    LocalFree(message);
-    return true;
-}
-#endif

app/src/util/log.h

@@ -26,10 +26,4 @@ sc_set_log_level(enum sc_log_level level);
 enum sc_log_level
 sc_get_log_level(void);
 
-#ifdef _WIN32
-// Log system error (typically returned by GetLastError() or similar)
-bool
-sc_log_windows_error(const char *prefix, int error);
-#endif
-
 #endif

app/src/util/net.c

@@ -83,7 +83,6 @@ unwrap(sc_socket socket) {
 #endif
 }
 
-#ifndef HAVE_SOCK_CLOEXEC // avoid unused-function warning
 static inline bool
 sc_raw_socket_close(sc_raw_socket raw_sock) {
 #ifndef _WIN32
@@ -92,7 +91,6 @@ sc_raw_socket_close(sc_raw_socket raw_sock) {
     return !closesocket(raw_sock);
 #endif
 }
-#endif
 
 #ifndef HAVE_SOCK_CLOEXEC
 // If SOCK_CLOEXEC does not exist, the flag must be set manually once the
@@ -117,7 +115,14 @@ set_cloexec_flag(sc_raw_socket raw_sock) {
 static void
 net_perror(const char *s) {
 #ifdef _WIN32
-    sc_log_windows_error(s, WSAGetLastError());
+    int error = WSAGetLastError();
+    char *wsa_message;
+    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+            NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+            (char *) &wsa_message, 0, NULL);
+    // no explicit '\n', wsa_message already contains a trailing '\n'
+    fprintf(stderr, "%s: [%d] %s", s, error, wsa_message);
+    LocalFree(wsa_message);
 #else
     perror(s);
 #endif

app/src/util/process.h

@@ -15,7 +15,7 @@
 // <https://stackoverflow.com/a/44383330/1987178>
 # define SC_PRIsizet "Iu"
 # define SC_PROCESS_NONE NULL
-# define SC_EXIT_CODE_NONE -1UL // max value as unsigned long
+# define SC_EXIT_CODE_NONE -1u // max value as unsigned
   typedef HANDLE sc_pid;
   typedef DWORD sc_exit_code;
   typedef HANDLE sc_pipe;

app/src/v4l2_sink.h

@@ -3,14 +3,13 @@
 
 #include "common.h"
 
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-
 #include "coords.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
 #include "util/tick.h"
 
+#include <libavformat/avformat.h>
+
 struct sc_v4l2_sink {
     struct sc_frame_sink frame_sink; // frame sink trait
 

app/tests/test_control_msg_serialize.c

@@ -6,8 +6,8 @@
 #include "control_msg.h"
 
 static void test_serialize_inject_keycode(void) {
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
+        .type = 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[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 14);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
+        CONTROL_MSG_TYPE_INJECT_KEYCODE,
         0x01, // AKEY_EVENT_ACTION_UP
         0x00, 0x00, 0x00, 0x42, // AKEYCODE_ENTER
         0x00, 0x00, 0x00, 0X05, // repeat
@@ -31,19 +31,19 @@ static void test_serialize_inject_keycode(void) {
 }
 
 static void test_serialize_inject_text(void) {
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TEXT,
+        .type = CONTROL_MSG_TYPE_INJECT_TEXT,
         .inject_text = {
             .text = "hello, world!",
         },
     };
 
-    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 18);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_INJECT_TEXT,
+        CONTROL_MSG_TYPE_INJECT_TEXT,
         0x00, 0x00, 0x00, 0x0d, // text length
         'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
     };
@@ -51,31 +51,31 @@ static void test_serialize_inject_text(void) {
 }
 
 static void test_serialize_inject_text_long(void) {
-    struct sc_control_msg msg;
+    struct control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
+    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    char text[SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1];
+    char text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1];
-    memset(text, 'a', SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    memset(text, 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
-    text[SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
+    text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
     msg.inject_text.text = text;
 
-    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
-    assert(size == 5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    assert(size == 5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
 
-    unsigned char expected[5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
+    unsigned char expected[5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
-    expected[0] = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
+    expected[0] = 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', SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    memset(&expected[5], 'a', 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 = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        .type = 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[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 28);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        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
@@ -111,8 +111,8 @@ static void test_serialize_inject_touch_event(void) {
 }
 
 static void test_serialize_inject_scroll_event(void) {
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
+        .type = 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[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 25);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
+        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
@@ -146,91 +146,91 @@ static void test_serialize_inject_scroll_event(void) {
 }
 
 static void test_serialize_back_or_screen_on(void) {
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
+        .type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
         .back_or_screen_on = {
             .action = AKEY_EVENT_ACTION_UP,
         },
     };
 
-    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 2);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
+        CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
         0x01, // AKEY_EVENT_ACTION_UP
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_expand_notification_panel(void) {
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
+        .type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
     };
 
-    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
+        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 = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+        .type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
     };
 
-    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+        CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_collapse_panels(void) {
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
+        .type = CONTROL_MSG_TYPE_COLLAPSE_PANELS,
     };
 
-    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
+        CONTROL_MSG_TYPE_COLLAPSE_PANELS,
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_get_clipboard(void) {
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
+        .type = CONTROL_MSG_TYPE_GET_CLIPBOARD,
         .get_clipboard = {
-            .copy_key = SC_COPY_KEY_COPY,
+            .copy_key = GET_CLIPBOARD_COPY_KEY_COPY,
         },
     };
 
-    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 2);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
+        CONTROL_MSG_TYPE_GET_CLIPBOARD,
-        SC_COPY_KEY_COPY,
+        GET_CLIPBOARD_COPY_KEY_COPY,
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_set_clipboard(void) {
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
+        .type = 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[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 27);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
+        CONTROL_MSG_TYPE_SET_CLIPBOARD,
         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
         1, // paste
         0x00, 0x00, 0x00, 0x0d, // text length
@@ -253,8 +253,8 @@ static void test_serialize_set_clipboard(void) {
 }
 
 static void test_serialize_set_clipboard_long(void) {
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
+        .type = 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[SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH + 1];
+    char text[CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH + 1];
-    memset(text, 'a', SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH);
+    memset(text, 'a', CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH);
-    text[SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH] = '\0';
+    text[CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH] = '\0';
     msg.set_clipboard.text = text;
 
-    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
-    assert(size == SC_CONTROL_MSG_MAX_SIZE);
+    assert(size == CONTROL_MSG_MAX_SIZE);
 
-    unsigned char expected[SC_CONTROL_MSG_MAX_SIZE] = {
+    unsigned char expected[CONTROL_MSG_MAX_SIZE] = {
-        SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
+        CONTROL_MSG_TYPE_SET_CLIPBOARD,
         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
         1, // paste
         // text length
-        SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 24,
+        CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 24,
-        (SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 16) & 0xff,
+        (CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 16) & 0xff,
-        (SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 8) & 0xff,
+        (CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 8) & 0xff,
-        SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH & 0xff,
+        CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH & 0xff,
     };
-    memset(expected + 14, 'a', SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH);
+    memset(expected + 14, 'a', 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 = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
+        .type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
         .set_screen_power_mode = {
-            .mode = SC_SCREEN_POWER_MODE_NORMAL,
+            .mode = SCREEN_POWER_MODE_NORMAL,
         },
     };
 
-    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 2);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
+        CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
-        0x02, // SC_SCREEN_POWER_MODE_NORMAL
+        0x02, // SCREEN_POWER_MODE_NORMAL
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
 static void test_serialize_rotate_device(void) {
-    struct sc_control_msg msg = {
+    struct control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
+        .type = CONTROL_MSG_TYPE_ROTATE_DEVICE,
     };
 
-    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
     assert(size == 1);
 
     const unsigned char expected[] = {
-        SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
+        CONTROL_MSG_TYPE_ROTATE_DEVICE,
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }

cross_win32.txt

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

cross_win64.txt

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

data/open_a_terminal_here.bat

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

install_release.sh

@@ -2,8 +2,8 @@
 set -e
 
 BUILDDIR=build-auto
-PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.22/scrcpy-server-v1.22
+PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.21/scrcpy-server-v1.21
-PREBUILT_SERVER_SHA256=c05d273eec7533c0e106282e0254cf04e7f5e8f0c2920ca39448865fab2a419b
+PREBUILT_SERVER_SHA256=dbcccab523ee26796e55ea33652649e4b7af498edae9aa75e4d4d7869c0ab848
 
 echo "[scrcpy] Downloading prebuilt server..."
 wget "$PREBUILT_SERVER_URL" -O scrcpy-server

meson.build

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

prebuilt-deps/.gitignore

@@ -1 +1,4 @@
-/data
+*
+!/.gitignore
+!/Makefile
+!/prepare-dep

prebuilt-deps/Makefile

@@ -0,0 +1,40 @@
+.PHONY: prepare-win32 prepare-win64 \
+	prepare-ffmpeg-shared-win32 \
+	prepare-ffmpeg-dev-win32 \
+	prepare-ffmpeg-shared-win64 \
+	prepare-ffmpeg-dev-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-ffmpeg-shared-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
+
+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-sdl2:
+	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.18-mingw.tar.gz \
+		bbad7c6947f6ca3e05292f065852ed8b62f319fc5533047e7708769c4dbae394 \
+		SDL2-2.0.18
+
+prepare-adb:
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r31.0.3-windows.zip \
+		0f4b8fdd26af2c3733539d6eebb3c2ed499ea1d4bb1f4e0ecc2d6016961a6e24 \
+		platform-tools

prebuilt-deps/common

@@ -1,22 +0,0 @@
-PREBUILT_DATA_DIR=data
-
-checksum() {
-    local file="$1"
-    local sum="$2"
-    echo "$file: verifying checksum..."
-    echo "$sum  $file" | sha256sum -c
-}
-
-get_file() {
-    local url="$1"
-    local file="$2"
-    local sum="$3"
-    if [[ -f "$file" ]]
-    then
-        echo "$file: found"
-    else
-        echo "$file: not found, downloading..."
-        wget "$url" -O "$file"
-    fi
-    checksum "$file" "$sum"
-}

prebuilt-deps/prepare-adb.sh

@@ -1,32 +0,0 @@
-#!/usr/bin/env bash
-set -e
-DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DIR"
-. common
-mkdir -p "$PREBUILT_DATA_DIR"
-cd "$PREBUILT_DATA_DIR"
-
-DEP_DIR=platform-tools-31.0.3
-
-FILENAME=platform-tools_r31.0.3-windows.zip
-SHA256SUM=0f4b8fdd26af2c3733539d6eebb3c2ed499ea1d4bb1f4e0ecc2d6016961a6e24
-
-if [[ -d "$DEP_DIR" ]]
-then
-    echo "$DEP_DIR" found
-    exit 0
-fi
-
-get_file "https://dl.google.com/android/repository/$FILENAME" \
-    "$FILENAME" "$SHA256SUM"
-
-mkdir "$DEP_DIR"
-cd "$DEP_DIR"
-
-ZIP_PREFIX=platform-tools
-unzip "../$FILENAME" \
-    "$ZIP_PREFIX"/AdbWinApi.dll \
-    "$ZIP_PREFIX"/AdbWinUsbApi.dll \
-    "$ZIP_PREFIX"/adb.exe
-mv "$ZIP_PREFIX"/* .
-rmdir "$ZIP_PREFIX"

prebuilt-deps/prepare-dep

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+set -e
+url="$1"
+sum="$2"
+dir="$3"
+
+checksum() {
+    local file="$1"
+    local sum="$2"
+    echo "$file: verifying checksum..."
+    echo "$sum  $file" | sha256sum -c
+}
+
+get_file() {
+    local url="$1"
+    local file="$2"
+    local sum="$3"
+    if [[ -f "$file" ]]
+    then
+        echo "$file: found"
+    else
+        echo "$file: not found, downloading..."
+        wget "$url" -O "$file"
+    fi
+    checksum "$file" "$sum"
+}
+
+extract() {
+    local file="$1"
+    echo "Extracting $file..."
+    if [[ "$file" == *.zip ]]
+    then
+        unzip -q "$file"
+    elif [[ "$file" == *.tar.gz ]]
+    then
+        tar xf "$file"
+    else
+        echo "Unsupported file: $file"
+        return 1
+    fi
+}
+
+get_dep() {
+    local url="$1"
+    local sum="$2"
+    local dir="$3"
+    local file="${url##*/}"
+    if [[ -d "$dir" ]]
+    then
+        echo "$dir: found"
+    else
+        echo "$dir: not found"
+        get_file "$url" "$file" "$sum"
+        extract "$file"
+    fi
+}
+
+get_dep "$url" "$sum" "$dir"

prebuilt-deps/prepare-ffmpeg-win32.sh

@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-set -e
-DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DIR"
-. common
-mkdir -p "$PREBUILT_DATA_DIR"
-cd "$PREBUILT_DATA_DIR"
-
-DEP_DIR=ffmpeg-win32-4.3.1
-
-FILENAME_SHARED=ffmpeg-4.3.1-win32-shared.zip
-SHA256SUM_SHARED=357af9901a456f4dcbacd107e83a934d344c9cb07ddad8aaf80612eeab7d26d2
-
-FILENAME_DEV=ffmpeg-4.3.1-win32-dev.zip
-SHA256SUM_DEV=230efb08e9bcf225bd474da29676c70e591fc94d8790a740ca801408fddcb78b
-
-if [[ -d "$DEP_DIR" ]]
-then
-    echo "$DEP_DIR" found
-    exit 0
-fi
-
-get_file "https://github.com/Genymobile/scrcpy/releases/download/v1.16/$FILENAME_SHARED" \
-    "$FILENAME_SHARED" "$SHA256SUM_SHARED"
-get_file "https://github.com/Genymobile/scrcpy/releases/download/v1.16/$FILENAME_DEV" \
-    "$FILENAME_DEV" "$SHA256SUM_DEV"
-
-mkdir "$DEP_DIR"
-cd "$DEP_DIR"
-
-ZIP_PREFIX_SHARED=ffmpeg-4.3.1-win32-shared
-unzip "../$FILENAME_SHARED" \
-    "$ZIP_PREFIX_SHARED"/bin/avutil-56.dll \
-    "$ZIP_PREFIX_SHARED"/bin/avcodec-58.dll \
-    "$ZIP_PREFIX_SHARED"/bin/avformat-58.dll \
-    "$ZIP_PREFIX_SHARED"/bin/swresample-3.dll \
-    "$ZIP_PREFIX_SHARED"/bin/swscale-5.dll
-
-ZIP_PREFIX_DEV=ffmpeg-4.3.1-win32-dev
-unzip "../$FILENAME_DEV" \
-    "$ZIP_PREFIX_DEV/include/*"
-
-mv "$ZIP_PREFIX_SHARED"/* .
-mv "$ZIP_PREFIX_DEV"/* .
-rmdir "$ZIP_PREFIX_SHARED" "$ZIP_PREFIX_DEV"

prebuilt-deps/prepare-ffmpeg-win64.sh

@@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-set -e
-DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DIR"
-. common
-mkdir -p "$PREBUILT_DATA_DIR"
-cd "$PREBUILT_DATA_DIR"
-
-DEP_DIR=ffmpeg-win64-5.0
-
-FILENAME=ffmpeg-5.0-full_build-shared.7z
-SHA256SUM=e5900f6cecd4c438d398bd2fc308736c10b857cd8dd61c11bcfb05bff5d1211a
-
-if [[ -d "$DEP_DIR" ]]
-then
-    echo "$DEP_DIR" found
-    exit 0
-fi
-
-get_file "https://github.com/GyanD/codexffmpeg/releases/download/5.0/$FILENAME" \
-    "$FILENAME" "$SHA256SUM"
-
-mkdir "$DEP_DIR"
-cd "$DEP_DIR"
-
-ZIP_PREFIX=ffmpeg-5.0-full_build-shared
-7z x "../$FILENAME" \
-    "$ZIP_PREFIX"/bin/avutil-57.dll \
-    "$ZIP_PREFIX"/bin/avcodec-59.dll \
-    "$ZIP_PREFIX"/bin/avformat-59.dll \
-    "$ZIP_PREFIX"/bin/swresample-4.dll \
-    "$ZIP_PREFIX"/bin/swscale-6.dll \
-    "$ZIP_PREFIX"/include
-mv "$ZIP_PREFIX"/* .
-rmdir "$ZIP_PREFIX"

prebuilt-deps/prepare-sdl.sh

@@ -1,32 +0,0 @@
-#!/usr/bin/env bash
-set -e
-DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DIR"
-. common
-mkdir -p "$PREBUILT_DATA_DIR"
-cd "$PREBUILT_DATA_DIR"
-
-DEP_DIR=SDL2-2.0.20
-
-FILENAME=SDL2-devel-2.0.20-mingw.tar.gz
-SHA256SUM=38094d82a857d6c62352e5c5cdec74948c5b4d25c59cbd298d6d233568976bd1
-
-if [[ -d "$DEP_DIR" ]]
-then
-    echo "$DEP_DIR" found
-    exit 0
-fi
-
-get_file "https://libsdl.org/release/$FILENAME" "$FILENAME" "$SHA256SUM"
-
-mkdir "$DEP_DIR"
-cd "$DEP_DIR"
-
-TAR_PREFIX="$DEP_DIR" # root directory inside the tar has the same name
-tar xf "../$FILENAME" --strip-components=1 \
-    "$TAR_PREFIX"/i686-w64-mingw32/bin/SDL2.dll \
-    "$TAR_PREFIX"/i686-w64-mingw32/include/ \
-    "$TAR_PREFIX"/i686-w64-mingw32/lib/ \
-    "$TAR_PREFIX"/x86_64-w64-mingw32/bin/SDL2.dll \
-    "$TAR_PREFIX"/x86_64-w64-mingw32/include/ \
-    "$TAR_PREFIX"/x86_64-w64-mingw32/lib/ \

release.mk

@@ -63,9 +63,7 @@ build-server:
 	ninja -C "$(SERVER_BUILD_DIR)"
 
 prepare-deps-win32:
-	@prebuilt-deps/prepare-adb.sh
+	-$(MAKE) -C prebuilt-deps prepare-win32
-	@prebuilt-deps/prepare-sdl.sh
-	@prebuilt-deps/prepare-ffmpeg-win32.sh
 
 build-win32: prepare-deps-win32
 	[ -d "$(WIN32_BUILD_DIR)" ] || ( mkdir "$(WIN32_BUILD_DIR)" && \
@@ -77,9 +75,7 @@ build-win32: prepare-deps-win32
 	ninja -C "$(WIN32_BUILD_DIR)"
 
 prepare-deps-win64:
-	@prebuilt-deps/prepare-adb.sh
+	-$(MAKE) -C prebuilt-deps prepare-win64
-	@prebuilt-deps/prepare-sdl.sh
-	@prebuilt-deps/prepare-ffmpeg-win64.sh
 
 build-win64: prepare-deps-win64
 	[ -d "$(WIN64_BUILD_DIR)" ] || ( mkdir "$(WIN64_BUILD_DIR)" && \
@@ -97,16 +93,15 @@ 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/data/ffmpeg-win32-4.3.1/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/data/ffmpeg-win32-4.3.1/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)/"
-	cp prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/data/platform-tools-31.0.3/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/data/platform-tools-31.0.3/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/data/platform-tools-31.0.3/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/data/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)"
@@ -115,16 +110,15 @@ 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 data/open_a_terminal_here.bat "$(DIST)/$(WIN64_TARGET_DIR)"
+	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/data/ffmpeg-win64-5.0/bin/avutil-57.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/data/ffmpeg-win64-5.0/bin/avcodec-59.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/data/ffmpeg-win64-5.0/bin/avformat-59.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/data/ffmpeg-win64-5.0/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/data/ffmpeg-win64-5.0/bin/swscale-6.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/data/platform-tools-31.0.3/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/data/platform-tools-31.0.3/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/data/platform-tools-31.0.3/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/data/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/build.gradle

@@ -6,8 +6,8 @@ android {
         applicationId "com.genymobile.scrcpy"
         minSdkVersion 21
         targetSdkVersion 31
-        versionCode 12200
+        versionCode 12100
-        versionName "1.22"
+        versionName "1.21"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
     }
     buildTypes {

server/build_without_gradle.sh

@@ -12,7 +12,7 @@
 set -e
 
 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.22
+SCRCPY_VERSION_NAME=1.21
 
 PLATFORM=${ANDROID_PLATFORM:-31}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-31.0.0}

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

@@ -46,17 +46,15 @@ public final class DesktopConnection implements Closeable {
         return localSocket;
     }
 
-    public static DesktopConnection open(boolean tunnelForward, boolean control, boolean sendDummyByte) throws IOException {
+    public static DesktopConnection open(Device device, boolean tunnelForward, boolean control) throws IOException {
         LocalSocket videoSocket;
         LocalSocket controlSocket = null;
         if (tunnelForward) {
             LocalServerSocket localServerSocket = new LocalServerSocket(SOCKET_NAME);
             try {
                 videoSocket = localServerSocket.accept();
-                if (sendDummyByte) {
+                // send one byte so the client may read() to detect a connection error
-                    // send one byte so the client may read() to detect a connection error
+                videoSocket.getOutputStream().write(0);
-                    videoSocket.getOutputStream().write(0);
-                }
                 if (control) {
                     try {
                         controlSocket = localServerSocket.accept();
@@ -80,7 +78,10 @@ public final class DesktopConnection implements Closeable {
             }
         }
 
-        return new DesktopConnection(videoSocket, controlSocket);
+        DesktopConnection connection = new DesktopConnection(videoSocket, controlSocket);
+        Size videoSize = device.getScreenInfo().getVideoSize();
+        connection.send(Device.getDeviceName(), videoSize.getWidth(), videoSize.getHeight());
+        return connection;
     }
 
     public void close() throws IOException {
@@ -94,7 +95,7 @@ public final class DesktopConnection implements Closeable {
         }
     }
 
-    public void sendDeviceMeta(String deviceName, int width, int height) throws IOException {
+    private void send(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,11 +42,6 @@ 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;
@@ -74,12 +69,7 @@ public final class Device {
 
         int displayInfoFlags = displayInfo.getFlags();
 
-        deviceSize = displayInfo.getSize();
+        screenInfo = ScreenInfo.computeScreenInfo(displayInfo, options.getCrop(), options.getMaxSize(), options.getLockVideoOrientation());
-        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() {
@@ -133,11 +123,6 @@ 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,6 +12,7 @@ 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;
@@ -20,12 +21,6 @@ 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;
@@ -83,6 +78,14 @@ public class Options {
         this.crop = crop;
     }
 
+    public boolean getSendFrameMeta() {
+        return sendFrameMeta;
+    }
+
+    public void setSendFrameMeta(boolean sendFrameMeta) {
+        this.sendFrameMeta = sendFrameMeta;
+    }
+
     public boolean getControl() {
         return control;
     }
@@ -146,36 +149,4 @@ 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,32 +25,24 @@ 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();
     private final ByteBuffer headerBuffer = ByteBuffer.allocate(12);
 
-    private final String encoderName;
+    private String encoderName;
-    private final List<CodecOption> codecOptions;
+    private List<CodecOption> codecOptions;
-    private final int bitRate;
+    private int bitRate;
-    private final int maxFps;
+    private int maxFps;
-    private final boolean sendFrameMeta;
+    private boolean sendFrameMeta;
-    private final boolean downsizeOnError;
     private long ptsOrigin;
 
-    private boolean firstFrameSent;
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName) {
-
-    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
@@ -99,23 +91,6 @@ 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();
@@ -127,18 +102,6 @@ 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();
@@ -159,10 +122,6 @@ 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,12 +80,15 @@ public final class ScreenInfo {
         return new ScreenInfo(newContentRect, newUnlockedVideoSize, newDeviceRotation, lockedVideoOrientation);
     }
 
-    public static ScreenInfo computeScreenInfo(int rotation, Size deviceSize, Rect crop, int maxSize, int lockedVideoOrientation) {
+    public static ScreenInfo computeScreenInfo(DisplayInfo displayInfo, Rect crop, int maxSize, int lockedVideoOrientation) {
+        int rotation = displayInfo.getRotation();
+
         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,6 +1,7 @@
 package com.genymobile.scrcpy;
 
 import android.graphics.Rect;
+import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.os.BatteryManager;
 import android.os.Build;
@@ -19,7 +20,6 @@ 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,8 +52,7 @@ public final class Server {
         }
 
         try {
-            CleanUp.configure(options.getDisplayId(), restoreStayOn, mustDisableShowTouchesOnCleanUp, restoreNormalPowerMode,
+            CleanUp.configure(options.getDisplayId(), restoreStayOn, mustDisableShowTouchesOnCleanUp, true, options.getPowerOffScreenOnClose());
-                    options.getPowerOffScreenOnClose());
         } catch (IOException e) {
             Ln.e("Could not configure cleanup", e);
         }
@@ -68,15 +67,10 @@ public final class Server {
 
         boolean tunnelForward = options.isTunnelForward();
         boolean control = options.getControl();
-        boolean sendDummyByte = options.getSendDummyByte();
 
-        try (DesktopConnection connection = DesktopConnection.open(tunnelForward, control, sendDummyByte)) {
+        try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward, control)) {
-            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.getDownsizeOnError());
+                    options.getEncoderName());
 
             Thread controllerThread = null;
             Thread deviceMessageSenderThread = null;
@@ -206,6 +200,10 @@ 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);
@@ -239,30 +237,6 @@ 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;
@@ -289,6 +263,16 @@ 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,7 +16,6 @@ public final class InputManager {
 
     private final IInterface manager;
     private Method injectInputEventMethod;
-    private boolean alternativeInjectInputEventMethod;
 
     private static Method setDisplayIdMethod;
 
@@ -26,12 +25,7 @@ public final class InputManager {
 
     private Method getInjectInputEventMethod() throws NoSuchMethodException {
         if (injectInputEventMethod == null) {
-            try {
+            injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
-                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;
     }
@@ -39,10 +33,6 @@ 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);