Log server pushed

Now that "adb push" stdout is disabled, add a log to notify server
pushed.

BUILD.md

@@ -14,7 +14,8 @@ First, you need to install the required packages:
 # for Debian/Ubuntu
 sudo apt install ffmpeg libsdl2-2.0-0 adb wget \
                  gcc git pkg-config meson ninja-build libsdl2-dev \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev
+                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
+                 libusb-1.0-0 libusb-dev
 ```
 
 Then clone the repo and execute the installation script
@@ -88,11 +89,12 @@ Install the required packages from your package manager.
 
 ```bash
 # runtime dependencies
-sudo apt install ffmpeg libsdl2-2.0-0 adb
+sudo apt install ffmpeg libsdl2-2.0-0 adb libusb-1.0-0
 
 # client build dependencies
 sudo apt install gcc git pkg-config meson ninja-build libsdl2-dev \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev
+                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
+                 libusb-dev
 
 # server build dependencies
 sudo apt install openjdk-11-jdk
@@ -114,7 +116,7 @@ pip3 install meson
 sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
 
 # client build dependencies
-sudo dnf install SDL2-devel ffms2-devel meson gcc make
+sudo dnf install SDL2-devel ffms2-devel libusb-devel meson gcc make
 
 # server build dependencies
 sudo dnf install java-devel
@@ -268,10 +270,10 @@ install` must be run as root)._
 
 #### Option 2: Use prebuilt server
 
- - [`scrcpy-server-v1.18`][direct-scrcpy-server]  
-   _(SHA-256: 641c5c6beda9399dfae72d116f5ff43b5ed1059d871c9ebc3f47610fd33c51a3)_
+ - [`scrcpy-server-v1.20`][direct-scrcpy-server]  
+   _(SHA-256: b20aee4951f99b060c4a44000ba94de973f9604758ef62beb253b371aad3df34)_
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-server-v1.18
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.20/scrcpy-server-v1.20
 
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:

DEVELOP.md

@@ -76,7 +76,7 @@ The server uses 3 threads:
  - the **main** thread, encoding and streaming the video to the client;
  - the **controller** thread, listening for _control messages_ (typically,
    keyboard and mouse events) from the client;
- - the **receiver** thread (managed by the controller), sending _device messges_
+ - the **receiver** thread (managed by the controller), sending _device messages_
    to the clients (currently, it is only used to send the device clipboard
    content).
 

FAQ.it.md

@@ -140,6 +140,24 @@ Potresti anche dover configurare il [comportamento di ridimensionamento][scaling
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 
 
+### Problema con Wayland
+
+Per impostazione predefinita, SDL utilizza x11 su Linux. Il [video driver] può essere cambiato attraversio la variabile d'ambiente `SDL_VIDEODRIVER`:
+
+[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
+
+```bash
+export SDL_VIDEODRIVER=wayland
+scrcpy
+```
+
+Su alcune distribuzioni (almeno Fedora), il pacchetto `libdecor` deve essere installato manualmente.
+
+Vedi le issues [#2554] e [#2559].
+
+[#2554]: https://github.com/Genymobile/scrcpy/issues/2554
+[#2559]: https://github.com/Genymobile/scrcpy/issues/2559
+
 
 ### Crash del compositore KWin
 

FAQ.md

@@ -118,13 +118,17 @@ In developer options, enable:
 
 ### Special characters do not work
 
-Injecting text input is [limited to ASCII characters][text-input]. A trick
-allows to also inject some [accented characters][accented-characters], but
-that's all. See [#37].
+The default text injection method is [limited to ASCII characters][text-input].
+A trick allows to also inject some [accented characters][accented-characters],
+but that's all. See [#37].
+
+Since scrcpy v1.20 on Linux, it is possible to simulate a [physical
+keyboard][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
 
 
 ## Client issues
@@ -153,6 +157,26 @@ You may also need to configure the [scaling behavior]:
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 
 
+### Issue with Wayland
+
+By default, SDL uses x11 on Linux. The [video driver] can be changed via the
+`SDL_VIDEODRIVER` environment variable:
+
+[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
+
+```bash
+export SDL_VIDEODRIVER=wayland
+scrcpy
+```
+
+On some distributions (at least Fedora), the package `libdecor` must be
+installed manually.
+
+See issues [#2554] and [#2559].
+
+[#2554]: https://github.com/Genymobile/scrcpy/issues/2554
+[#2559]: https://github.com/Genymobile/scrcpy/issues/2559
+
 
 ### KWin compositor crashes
 
@@ -198,6 +222,27 @@ scrcpy -m 800
 You could also try another [encoder](README.md#encoder).
 
 
+If you encounter this exception on Android 12, then just upgrade to scrcpy >=
+1.18 (see [#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
+
+
 ## Command line on Windows
 
 Some Windows users are not familiar with the command line. Here is how to open a
@@ -238,5 +283,6 @@ to add some arguments.
 
 This FAQ is available in other languages:
 
- - [Italiano (Italiano, `it`) - v1.17](FAQ.it.md)
+ - [Italiano (Italiano, `it`) - v1.19](FAQ.it.md)
  - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md)
+ - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.18](FAQ.zh-Hans.md)

FAQ.zh-Hans.md

@@ -0,0 +1,240 @@
+只有原版的[FAQ](FAQ.md)会保持更新。
+本文根据[d6aaa5]翻译。
+
+[d6aaa5]:https://github.com/Genymobile/scrcpy/blob/d6aaa5bf9aa3710660c683b6e3e0ed971ee44af5/FAQ.md
+
+# 常见问题
+
+这里是一些常见的问题以及他们的状态。
+
+## `adb` 相关问题
+
+`scrcpy` 执行 `adb` 命令来初始化和设备之间的连接。如果`adb` 执行失败了， scrcpy 就无法工作。
+
+在这种情况中，将会输出这个错误:
+
+>     ERROR: "adb push" returned with value 1
+
+这通常不是 _scrcpy_ 的bug，而是你的环境的问题。
+
+要找出原因，请执行以下操作：
+
+```bash
+adb devices
+```
+
+### 找不到`adb`
+
+
+你的`PATH`中需要能访问到`adb`。
+
+在Windows上，当前目录会包含在`PATH`中，并且`adb.exe`也包含在发行版中，因此它应该是开箱即用（直接解压就可以）的。
+
+
+### 设备未授权
+
+参见这里 [stackoverflow][device-unauthorized].
+
+[device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
+
+
+### 未检测到设备
+
+>     adb: error: failed to get feature set: no devices/emulators found
+
+确认已经正确启用 [adb debugging][enable-adb].
+
+如果你的设备没有被检测到，你可能需要一些[驱动][drivers] (在 Windows上).
+
+[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
+[drivers]: https://developer.android.com/studio/run/oem-usb.html
+
+
+### 已连接多个设备
+
+如果连接了多个设备，您将遇到以下错误：
+
+>     adb: error: failed to get feature set: more than one device/emulator
+
+必须提供要镜像的设备的标识符：
+
+```bash
+scrcpy -s 01234567890abcdef
+```
+
+注意，如果你的设备是通过 TCP/IP 连接的， 你将会收到以下消息：
+
+>     adb: error: more than one device/emulator
+>     ERROR: "adb reverse" returned with value 1
+>     WARN: 'adb reverse' failed, fallback to 'adb forward'
+
+这是意料之中的 (由于旧版安卓的一个bug, 请参见 [#5])，但是在这种情况下，scrcpy会退回到另一种方法，这种方法应该可以起作用。
+
+[#5]: https://github.com/Genymobile/scrcpy/issues/5
+
+
+### adb版本之间冲突
+
+>     adb server version (41) doesn't match this client (39); killing...
+
+同时使用多个版本的`adb`时会发生此错误。你必须查找使用不同`adb`版本的程序，并在所有地方使用相同版本的`adb`。
+
+你可以覆盖另一个程序中的`adb`二进制文件，或者通过设置`ADB`环境变量来让 _scrcpy_ 使用特定的`adb`二进制文件。
+
+```bash
+set ADB=/path/to/your/adb
+scrcpy
+```
+
+
+### 设备断开连接
+
+如果 _scrcpy_ 在警告“设备连接断开”的情况下自动中止，那就意味着`adb`连接已经断开了。
+请尝试使用另一条USB线或者电脑上的另一个USB接口。
+请参看 [#281] 和 [#283]。
+
+[#281]: https://github.com/Genymobile/scrcpy/issues/281
+[#283]: https://github.com/Genymobile/scrcpy/issues/283
+
+## 控制相关问题
+
+### 鼠标和键盘不起作用
+
+
+在某些设备上，您可能需要启用一个选项以允许 [模拟输入][simulating input]。
+
+在开发者选项中，打开：
+
+> **USB调试 (安全设置)**  
+> _允许通过USB调试修改权限或模拟点击_
+
+[simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
+
+
+### 特殊字符不起作用
+
+可输入的文本[被限制为ASCII字符][text-input]。也可以用一些小技巧输入一些[带重音符号的字符][accented-characters]，但是仅此而已。参见[#37]。
+
+
+[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
+
+
+## 客户端相关问题
+
+### 效果很差
+
+如果你的客户端窗口分辨率比你的设备屏幕小，则可能出现效果差的问题，尤其是在文本上（参见 [#40]）。
+
+[#40]: https://github.com/Genymobile/scrcpy/issues/40
+
+
+为了提升降尺度的质量，如果渲染器是OpenGL并且支持mip映射，就会自动开启三线性过滤。
+
+在Windows上，你可能希望强制使用OpenGL：
+
+```
+scrcpy --render-driver=opengl
+```
+
+你可能还需要配置[缩放行为][scaling behavior]：
+
+> `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
+> Override high DPI scaling behavior > Scaling performed by: _Application_.
+
+[scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
+
+
+### Wayland相关的问题
+
+在Linux上，SDL默认使用x11。可以通过`SDL_VIDEODRIVER`环境变量来更改[视频驱动][video driver]：
+
+[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
+
+```bash
+export SDL_VIDEODRIVER=wayland
+scrcpy
+```
+
+在一些发行版上 (至少包括 Fedora)， `libdecor` 包必须手动安装。
+
+参见 [#2554] 和 [#2559]。
+
+[#2554]: https://github.com/Genymobile/scrcpy/issues/2554
+[#2559]: https://github.com/Genymobile/scrcpy/issues/2559
+
+
+### KWin compositor 崩溃
+
+在Plasma桌面中，当 _scrcpy_ 运行时，会禁用compositor。
+
+一种解决方法是， [禁用 "Block compositing"][kwin].
+
+[kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
+
+
+## 崩溃
+
+### 异常
+可能有很多原因。一个常见的原因是您的设备无法按给定清晰度进行编码：
+
+> ```
+> ERROR: Exception on thread Thread[main,5,main]
+> android.media.MediaCodec$CodecException: Error 0xfffffc0e
+> ...
+> Exit due to uncaughtException in main thread:
+> ERROR: Could not open video stream
+> INFO: Initial texture: 1080x2336
+> ```
+
+或者
+
+> ```
+> ERROR: Exception on thread Thread[main,5,main]
+> java.lang.IllegalStateException
+>         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
+> ```
+
+请尝试使用更低的清晰度：
+
+```
+scrcpy -m 1920
+scrcpy -m 1024
+scrcpy -m 800
+```
+
+你也可以尝试另一种 [编码器](README.md#encoder)。
+
+
+## Windows命令行
+
+一些Windows用户不熟悉命令行。以下是如何打开终端并带参数执行`scrcpy`：
+
+ 1. 按下 <kbd>Windows</kbd>+<kbd>r</kbd>，打开一个对话框。
+ 2. 输入 `cmd` 并按 <kbd>Enter</kbd>，这样就打开了一个终端。
+ 3. 通过输入以下命令，切换到你的 _scrcpy_ 所在的目录 （根据你的实际位置修改路径）:
+
+    ```bat
+    cd C:\Users\user\Downloads\scrcpy-win64-xxx
+    ```
+
+    然后按 <kbd>Enter</kbd>
+ 4. 输入你的命令。比如:
+
+    ```bat
+    scrcpy --record file.mkv
+    ```
+
+如果你打算总是使用相同的参数，在`scrcpy`目录创建一个文件 `myscrcpy.bat`
+（启用 [显示文件拓展名][show file extensions] 避免混淆），文件中包含你的命令。例如：
+
+```bat
+scrcpy --prefer-text --turn-screen-off --stay-awake
+```
+
+然后双击刚刚创建的文件。
+
+你也可以编辑 `scrcpy-console.bat` 或者 `scrcpy-noconsole.vbs`（的副本）来添加参数。
+
+[show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/

README.it.md

@@ -1,6 +1,6 @@
 _Apri il [README](README.md) originale e sempre aggiornato._
 
-# scrcpy (v1.17)
+# scrcpy (v1.19)
 
 Questa applicazione fornisce la visualizzazione e il controllo dei dispositivi Android collegati via USB (o [via TCP/IP][article-tcpip]). Non richiede alcun accesso _root_.
 Funziona su _GNU/Linux_, _Windows_ e _macOS_.
@@ -205,10 +205,11 @@ Se anche `--max-size` è specificata, il ridimensionamento è applicato dopo il
 Per bloccare l'orientamento della trasmissione:
 
 ```bash
-scrcpy --lock-video-orientation 0   # orientamento naturale
-scrcpy --lock-video-orientation 1   # 90° antiorario
-scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation 3   # 90° orario
+scrcpy --lock-video-orientation     # orientamento iniziale (corrente)
+scrcpy --lock-video-orientation=0   # orientamento naturale
+scrcpy --lock-video-orientation=1   # 90° antiorario
+scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation=3   # 90° orario
 ```
 
 Questo influisce sull'orientamento della registrazione.
@@ -231,7 +232,9 @@ Per elencare i codificatori disponibili puoi immettere un nome di codificatore n
 scrcpy --encoder _
 ```
 
-### Registrazione
+### Cattura
+
+#### Registrazione
 
 È possibile registrare lo schermo durante la trasmissione:
 
@@ -253,6 +256,75 @@ I "fotogrammi saltati" sono registrati nonostante non siano mostrati in tempo re
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 
 
+#### v4l2loopback
+
+Su Linux è possibile inviare il flusso video ad un dispositivo v4l2 loopback, cosicchè un dispositivo Android possa essere aperto come una webcam da qualsiasi strumento compatibile con v4l2.
+
+Il modulo `v4l2loopback` deve essere installato:
+
+```bash
+sudo apt install v4l2loopback-dkms
+```
+
+Per creare un dispositvo v4l2:
+
+```bash
+sudo modprobe v4l2loopback
+```
+
+Questo creerà un nuovo dispositivo video in `/dev/videoN` dove `N` è un intero (più [opzioni](https://github.com/umlaeute/v4l2loopback#options) sono disponibili per crere più dispositivi o dispositivi con ID specifici).
+
+Per elencare i dispositvi attivati:
+
+```bash
+# necessita del pacchetto v4l-utils
+v4l2-ctl --list-devices
+
+# semplice ma potrebbe essere sufficiente
+ls /dev/video*
+```
+
+Per avviare scrcpy utilizzando un v4l2 sink:
+
+```bash
+scrcpy --v4l2-sink=/dev/videoN
+scrcpy --v4l2-sink=/dev/videoN --no-display  # disabilita la finestra di trasmissione
+scrcpy --v4l2-sink=/dev/videoN -N            # versione corta
+```
+
+(sostituisci `N` con l'ID del dispositivo, controlla con `ls /dev/video*`)
+
+Una volta abilitato, puoi aprire il tuo flusso video con uno strumento compatibile con v4l2:
+
+```bash
+ffplay -i /dev/videoN
+vlc v4l2:///dev/videoN   # VLC potrebbe aggiungere del ritardo per il buffer
+```
+
+Per esempio potresti catturare il video in [OBS].
+
+[OBS]: https://obsproject.com/
+
+
+#### Buffering
+
+È possibile aggiungere del buffer. Questo aumenta la latenza ma riduce il jitter (vedi [#2464]).
+
+[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
+
+L'opzione è disponibile per il buffer della visualizzazione:
+
+```bash
+scrcpy --display-buffer=50  # aggiungi 50 ms di buffer per la visualizzazione
+```
+
+e per il V4L2 sink:
+
+```bash
+scrcpy --v4l2-buffer=500    #  aggiungi 50 ms di buffer per il v4l2 sink
+```
+
+
 ### Connessione
 
 #### Wireless
@@ -479,15 +551,6 @@ scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
 
-#### Renderizzare i fotogrammi scaduti
-
-Per minimizzare la latenza _scrcpy_ renderizza sempre l'ultimo fotogramma decodificato disponibile in maniera predefinita e tralascia quelli precedenti.
-
-Per forzare la renderizzazione di tutti i fotogrammi (a costo di una possibile latenza superiore), utilizzare:
-
-```bash
-scrcpy --render-expired-frames
-```
 
 #### Mostrare i tocchi
 
@@ -607,14 +670,14 @@ Non c'è alcuna risposta visiva, un log è stampato nella console.
 
 #### Trasferimento di file verso il dispositivo
 
-Per trasferire un file in `/sdcard/` del dispositivo trascina e rilascia un file (non APK) nella finestra di _scrcpy_.
+Per trasferire un file in `/sdcard/Download` del dispositivo trascina e rilascia un file (non APK) nella finestra di _scrcpy_.
 
 Non c'è alcuna risposta visiva, un log è stampato nella console.
 
 La cartella di destinazione può essere cambiata all'avvio:
 
 ```bash
-scrcpy --push-target=/sdcard/Download/
+scrcpy --push-target=/sdcard/Movies/
 ```
 
 
@@ -653,10 +716,10 @@ _<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
  | Rotazione schermo a sinistra                         | <kbd>MOD</kbd>+<kbd>←</kbd> _(sinistra)_
  | Rotazione schermo a destra                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(destra)_
  | Ridimensiona finestra a 1:1 (pixel-perfect)        | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Ridimensiona la finestra per rimuovere i bordi neri       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doppio click¹_
+ | Ridimensiona la finestra per rimuovere i bordi neri       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doppio click sinistro¹_
  | Premi il tasto `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Click centrale_
  | Premi il tasto `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Click destro²_
- | Premi il tasto `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd>
+ | Premi il tasto `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4° click³_
  | Premi il tasto `MENU` (sblocca lo schermo)             | <kbd>MOD</kbd>+<kbd>m</kbd>
  | Premi il tasto `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(su)_
  | Premi il tasto `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(giù)_
@@ -665,18 +728,26 @@ _<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
  | Spegni lo schermo del dispositivo (continua a trasmettere)     | <kbd>MOD</kbd>+<kbd>o</kbd>
  | Accendi lo schermo del dispositivo                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
  | Ruota lo schermo del dispositivo                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Espandi il pannello delle notifiche                   | <kbd>MOD</kbd>+<kbd>n</kbd>
- | Chiudi il pannello delle notifiche                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copia negli appunti³                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Taglia negli appunti³                           | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Sincronizza gli appunti e incolla³           | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | Espandi il pannello delle notifiche                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5° click³_
+ | Espandi il pannello delle impostazioni                   | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Doppio 5° click³_
+ | Chiudi pannelli                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copia negli appunti⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Taglia negli appunti⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Sincronizza gli appunti e incolla⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>
  | Inietta il testo degli appunti del computer              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
  | Abilita/Disabilita il contatore FPS (su stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
  | Pizzica per zoomare                               | <kbd>Ctrl</kbd>+_click e trascina_
 
 _¹Doppio click sui bordi neri per rimuoverli._  
 _²Il tasto destro accende lo schermo se era spento, preme BACK in caso contrario._  
-_³Solo in Android >= 7._
+_³4° e 5° pulsante del mouse, se il tuo mouse ne dispone._  
+_⁴Solo in Android >= 7._
+
+Le scorciatoie con pulsanti ripetuti sono eseguite rilasciando e premendo il pulsante una seconda volta. Per esempio, per eseguire "Espandi il pannello delle impostazioni":
+
+1. Premi e tieni premuto <kbd>MOD</kbd>.
+2. Poi premi due volte <kbd>n</kbd>.
+3. Infine rilascia <kbd>MOD</kbd>.
 
 Tutte le scorciatoie <kbd>Ctrl</kbd>+_tasto_ sono inoltrate al dispositivo, così sono gestite dall'applicazione attiva.
 

README.jp.md

@@ -1,6 +1,6 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._
 
-# scrcpy (v1.17)
+# scrcpy (v1.19)
 
 このアプリケーションはUSB(もしくは[TCP/IP経由][article-tcpip])で接続されたAndroidデバイスの表示と制御を提供します。このアプリケーションは _root_ でのアクセスを必要としません。このアプリケーションは _GNU/Linux_ 、 _Windows_ そして _macOS_ 上で動作します。
 
@@ -103,18 +103,21 @@ scoop install adb    # まだ入手していない場合
 brew install scrcpy
 ```
 
-`PATH`から`adb`へのアクセスが必要です。もしまだ持っていない場合:
+`PATH`からアクセス可能な`adb`が必要です。もし持っていない場合はインストールしてください。
 
 ```bash
-# Homebrew >= 2.6.0
-brew install --cask android-platform-tools
-
-# Homebrew < 2.6.0
-brew cask install android-platform-tools
+brew install android-platform-tools
 ```
 
-また、[アプリケーションをビルド][BUILD]することも可能です。
+`adb`は[MacPorts]からでもインストールできます。
 
+```bash
+sudo port install scrcpy
+```
+
+[MacPorts]: https://www.macports.org/
+
+また、[アプリケーションをビルド][BUILD]することも可能です。
 
 ## 実行
 
@@ -184,10 +187,11 @@ scrcpy --crop 1224:1440:0:0   # オフセット位置(0,0)で1224x1440
 ミラーリングの向きをロックするには:
 
 ```bash
-scrcpy --lock-video-orientation 0   # 自然な向き
-scrcpy --lock-video-orientation 1   # 90°反時計回り
-scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation 3   # 90°時計回り
+scrcpy --lock-video-orientation     # 現在の向き
+scrcpy --lock-video-orientation=0   # 自然な向き
+scrcpy --lock-video-orientation=1   # 90°反時計回り
+scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation=3   # 90°時計回り
 ```
 
 この設定は録画の向きに影響します。
@@ -210,7 +214,9 @@ scrcpy --encoder OMX.qcom.video.encoder.avc
 scrcpy --encoder _
 ```
 
-### 録画
+### キャプチャ
+
+#### 録画
 
 ミラーリング中に画面の録画をすることが可能です:
 
@@ -233,6 +239,77 @@ scrcpy -Nr file.mkv
 
 [パケット遅延のバリエーション]: https://en.wikipedia.org/wiki/Packet_delay_variation
 
+#### v4l2loopback
+
+Linuxでは、ビデオストリームをv4l2ループバックデバイスに送信することができます。
+v4l2loopbackのデバイスにビデオストリームを送信することで、Androidデバイスをウェブカメラのようにv4l2対応ツールで開くこともできます。
+
+`v4l2loopback` モジュールのインストールが必要です。
+
+```bash
+sudo apt install v4l2loopback-dkms
+```
+
+v4l2デバイスを作成する。
+
+```bash
+sudo modprobe v4l2loopback
+```
+
+これにより、新しいビデオデバイスが `/dev/videoN` に作成されます。（`N` は整数）
+(複数のデバイスや特定のIDのデバイスを作成するために、より多くの[オプション](https://github.com/umlaeute/v4l2loopback#options)が利用可能です。
+多くの[オプション]()が利用可能で複数のデバイスや特定のIDのデバイスを作成できます。
+
+
+有効なデバイスを一覧表示する:
+
+```bash
+# v4l-utilsパッケージが必要
+v4l2-ctl --list-devices
+
+# シンプルですが十分これで確認できます
+ls /dev/video*
+```
+
+v4l2シンクを使用してscrcpyを起動する。
+
+```bash
+scrcpy --v4l2-sink=/dev/videoN
+scrcpy --v4l2-sink=/dev/videoN --no-display  # ミラーリングウィンドウを無効化する
+scrcpy --v4l2-sink=/dev/videoN -N            # 短縮版
+```
+
+(`N` をデバイス ID に置き換えて、`ls /dev/video*` で確認してください)
+有効にすると、v4l2対応のツールでビデオストリームを開けます。
+
+```bash
+ffplay -i /dev/videoN
+vlc v4l2:///dev/videoN   # VLCではバッファリングの遅延が発生する場合があります
+```
+
+例えばですが [OBS]の中にこの映像を取り込めことができます。
+
+[OBS]: https://obsproject.com/
+
+
+#### Buffering
+
+バッファリングを追加することも可能です。これによりレイテンシーは増加しますが、ジッターは減少します。（参照
+[#2464])
+
+[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
+
+このオプションでディスプレイバッファリングを設定できます。
+
+```bash
+scrcpy --display-buffer=50  # ディスプレイに50msのバッファリングを追加する
+```
+
+V4L2の場合はこちらのオプションで設定できます。
+
+```bash
+scrcpy --v4l2-buffer=500    # add 500 ms buffering for v4l2 sink
+```
 
 ### 接続
 
@@ -457,16 +534,6 @@ scrcpy -Sw
 ```
 
 
-#### 期限切れフレームをレンダリングする
-
-初期状態では、待ち時間を最小限にするために、_scrcpy_ は最後にデコードされたフレームをレンダリングし、前のフレームを削除します。
-
-全フレームのレンダリングを強制するには(待ち時間が長くなる可能性があります):
-
-```bash
-scrcpy --render-expired-frames
-```
-
 #### タッチを表示
 
 プレゼンテーションの場合(物理デバイス上で)物理的なタッチを表示すると便利な場合があります。
@@ -586,14 +653,14 @@ APKをインストールするには、(`.apk`で終わる)APKファイルを _s
 
 #### デバイスにファイルを送る
 
-デバイスの`/sdcard/`ディレクトリにファイルを送るには、(APKではない)ファイルを _scrcpy_ の画面にドラッグ&ドロップします。
+デバイスの`/sdcard/Download`ディレクトリにファイルを送るには、(APKではない)ファイルを _scrcpy_ の画面にドラッグ&ドロップします。
 
 見た目のフィードバックはありません。コンソールにログが出力されます。
 
 転送先ディレクトリを起動時に変更することができます:
 
 ```bash
-scrcpy --push-target /sdcard/foo/bar/
+scrcpy --push-target=/sdcard/Movies/
 ```
 
 
@@ -634,7 +701,7 @@ _<kbd>[Super]</kbd>は通常<kbd>Windows</kbd>もしくは<kbd>Cmd</kbd>キー
  | ウィンドウサイズを変更して黒い境界線を削除      | <kbd>MOD</kbd>+<kbd>w</kbd> \| _ダブルクリック¹_
  | `HOME`をクリック                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _真ん中クリック_
  | `BACK`をクリック                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _右クリック²_
- | `APP_SWITCH`をクリック                       | <kbd>MOD</kbd>+<kbd>s</kbd>
+ | `APP_SWITCH`をクリック                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4クリック³_
  | `MENU` (画面のアンロック)をクリック            | <kbd>MOD</kbd>+<kbd>m</kbd>
  | `VOLUME_UP`をクリック                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上)_
  | `VOLUME_DOWN`をクリック                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下)_
@@ -643,7 +710,8 @@ _<kbd>[Super]</kbd>は通常<kbd>Windows</kbd>もしくは<kbd>Cmd</kbd>キー
  | デバイス画面をオフにする(ミラーリングしたまま)  | <kbd>MOD</kbd>+<kbd>o</kbd>
  | デバイス画面をオンにする                      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
  | デバイス画面を回転する                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | 通知パネルを展開する                          | <kbd>MOD</kbd>+<kbd>n</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>x</kbd>
@@ -654,11 +722,17 @@ _<kbd>[Super]</kbd>は通常<kbd>Windows</kbd>もしくは<kbd>Cmd</kbd>キー
 
 _¹黒い境界線を削除するため、境界線上でダブルクリック_  
 _²もしスクリーンがオフの場合、右クリックでスクリーンをオンする。それ以外の場合はBackを押します._  
-_³Android 7以上のみ._
+_³4と5はマウスのボタンです、もしあなたのマウスにボタンがあれば使えます._  
+_⁴Android 7以上のみ._
+
+キーを繰り返すショートカットはキーを離して2回目を押したら実行されます。例えば「設定パネルを展開する」を実行する場合は以下のように操作する。
+
+ 1. <kbd>MOD</kbd> キーを押し、押したままにする.
+ 2. その後に <kbd>n</kbd>キーを2回押す.
+ 3. 最後に <kbd>MOD</kbd>キーを離す.
 
 全ての<kbd>Ctrl</kbd>+_キー_ ショートカットはデバイスに転送されます、そのためアクティブなアプリケーションによって処理されます。
 
-
 ## カスタムパス
 
 特定の _adb_ バイナリを使用する場合、そのパスを環境変数`ADB`で構成します:

README.md

@@ -1,24 +1,37 @@
-# scrcpy (v1.18)
+# scrcpy (v1.20)
+
+<img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
 
 [Read in another language](#translations)
 
-This application provides display and control of Android devices connected on
-USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
+This application provides display and control of Android devices connected via
+USB (or [over TCP/IP](#wireless)). It does not require any _root_ access.
 It works on _GNU/Linux_, _Windows_ and _macOS_.
 
 ![screenshot](assets/screenshot-debian-600.jpg)
 
 It focuses on:
 
- - **lightness** (native, displays only the device screen)
- - **performance** (30~60fps)
- - **quality** (1920×1080 or above)
- - **low latency** ([35~70ms][lowlatency])
- - **low startup time** (~1 second to display the first image)
- - **non-intrusiveness** (nothing is left installed on the device)
+ - **lightness**: native, displays only the device screen
+ - **performance**: 30~120fps, depending on the device
+ - **quality**: 1920×1080 or above
+ - **low latency**: [35~70ms][lowlatency]
+ - **low startup time**: ~1 second to display the first image
+ - **non-intrusiveness**: nothing is left installed on the device
+ - **user benefits**: no account, no ads, no internet required
+ - **freedom**: free and open source software
 
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 
+Its features include:
+ - [recording](#recording)
+ - mirroring with [device screen off](#turn-screen-off)
+ - [copy-paste](#copy-paste) in both directions
+ - [configurable quality](#capture-configuration)
+ - device screen [as a webcam (V4L2)](#v4l2loopback) (Linux-only)
+ - [physical keyboard simulation (HID)](#physical-keyboard-simulation-hid)
+   (Linux-only)
+ - and more…
 
 ## Requirements
 
@@ -88,10 +101,10 @@ process][BUILD_simple]).
 For Windows, for simplicity, a prebuilt archive with all the dependencies
 (including `adb`) is available:
 
- - [`scrcpy-win64-v1.18.zip`][direct-win64]  
-   _(SHA-256: 37212f5087fe6f3e258f1d44fa5c02207496b30e1d7ec442cbcf8358910a5c63)_
+ - [`scrcpy-win64-v1.20.zip`][direct-win64]  
+   _(SHA-256: 548532b616288bcaeceff6881ad5e6f0928e5ae2b48c380385f03627401cfdba)_
 
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-win64-v1.18.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.20/scrcpy-win64-v1.20.zip
 
 It is also available in [Chocolatey]:
 
@@ -318,7 +331,27 @@ vlc v4l2:///dev/videoN   # VLC might add some buffering delay
 
 For example, you could capture the video within [OBS].
 
-[OBS]: https://obsproject.com/fr
+[OBS]: https://obsproject.com/
+
+
+#### Buffering
+
+It is possible to add buffering. This increases latency but reduces jitter (see
+[#2464]).
+
+[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
+
+The option is available for display buffering:
+
+```bash
+scrcpy --display-buffer=50  # add 50 ms buffering for display
+```
+
+and V4L2 sink:
+
+```bash
+scrcpy --v4l2-buffer=500    # add 500 ms buffering for v4l2 sink
+```
 
 
 ### Connection
@@ -383,17 +416,27 @@ autoadb scrcpy -s '{}'
 
 To connect to a remote device, it is possible to connect a local `adb` client to
 a remote `adb` server (provided they use the same version of the _adb_
-protocol):
+protocol).
+
+First, make sure the ADB server is running on the remote computer:
 
 ```bash
-adb kill-server    # kill the local adb server on 5037
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
+adb start-server
+```
+
+Then, establish a SSH tunnel:
+
+```bash
+# local  5038 --> remote  5037
+# local 27183 <-- remote 27183
+ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 
-From another terminal:
+From another terminal, run scrcpy:
 
 ```bash
+export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
 
@@ -401,14 +444,16 @@ To avoid enabling remote port forwarding, you could force a forward connection
 instead (notice the `-L` instead of `-R`):
 
 ```bash
-adb kill-server    # kill the local adb server on 5037
-ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
+# local  5038 --> remote  5037
+# local 27183 --> remote 27183
+ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 
-From another terminal:
+From another terminal, run scrcpy:
 
 ```bash
+export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
 
@@ -562,6 +607,14 @@ scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
 
+#### Power off on close
+
+To turn the device screen off when closing scrcpy:
+
+```bash
+scrcpy --power-off-on-close
+```
+
 
 #### Show touches
 
@@ -653,6 +706,39 @@ content (if supported by the app) relative to the center of the screen.
 Concretely, scrcpy generates additional touch events from a "virtual finger" at
 a location inverted through the center of the screen.
 
+#### Physical keyboard simulation (HID)
+
+By default, scrcpy uses Android key or text injection: it works everywhere, but
+is limited to ASCII.
+
+On Linux, scrcpy can simulate a physical USB keyboard on Android to provide a
+better input experience (using [USB HID over AOAv2][hid-aoav2]): the virtual
+keyboard is disabled and it works for all characters and IME.
+
+[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
+
+However, it only works if the device is connected by USB, and is currently only
+supported on Linux.
+
+To enable this mode:
+
+```bash
+scrcpy --hid-keyboard
+scrcpy -K  # short version
+```
+
+If it fails for some reason (for example because the device is not connected via
+USB), it automatically fallbacks to the default mode (with a log in the
+console). This allows to use the same command line options when connected over
+USB and TCP/IP.
+
+In this mode, raw key events (scancodes) are sent to the device, independently
+of the host key mapping. Therefore, if your keyboard layout does not match, it
+must be configured on the Android device, in Settings → System → Languages and
+input → [Physical keyboard].
+
+[Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
+
 
 #### Text injection preference
 
@@ -672,6 +758,9 @@ scrcpy --prefer-text
 
 (but this will break keyboard behavior in games)
 
+This option has no effect on HID keyboard (all key events are sent as
+scancodes in this mode).
+
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 
@@ -687,6 +776,9 @@ To avoid forwarding repeated key events:
 scrcpy --no-key-repeat
 ```
 
+This option has no effect on HID keyboard (key repeat is handled by Android
+directly in this mode).
+
 
 #### Right-click and middle-click
 
@@ -779,6 +871,8 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
  | 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_
+ | Drag & drop APK file                        | Install APK from computer
+ | Drag & drop non-APK file                    | [Push file to device](#push-file-to-device)
 
 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._  
@@ -808,7 +902,7 @@ ADB=/path/to/adb scrcpy
 To override the path of the `scrcpy-server` file, configure its path in
 `SCRCPY_SERVER_PATH`.
 
-[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
+To override the icon, configure its path in `SCRCPY_ICON_PATH`.
 
 
 ## Why _scrcpy_?
@@ -868,12 +962,13 @@ Read the [developers page].
 This README is available in other languages:
 
 - [Indonesian (Indonesia, `id`) - v1.16](README.id.md)
-- [Italiano (Italiano, `it`) - v1.17](README.it.md)
-- [日本語 (Japanese, `jp`) - v1.17](README.jp.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.17](README.pt-br.md)
+- [Português Brasileiro (Brazilian Portuguese, `pt-BR`) - v1.19](README.pt-br.md)
 - [Español (Spanish, `sp`) - v1.17](README.sp.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.17](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
+- [Turkish (Turkish, `tr`) - v1.18](README.tr.md)
 
 Only this README file is guaranteed to be up-to-date.

README.pt-br.md

@@ -1,6 +1,6 @@
 _Apenas o [README](README.md) original é garantido estar atualizado._
 
-# scrcpy (v1.17)
+# scrcpy (v1.19)
 
 Esta aplicação fornece exibição e controle de dispositivos Android conectados via
 USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso _root_.
@@ -38,6 +38,18 @@ controlá-lo usando teclado e mouse.
 
 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
 
+### Sumário
+
+ - Linux: `apt install scrcpy`
+ - Windows: [baixar][direct-win64]
+ - macOS: `brew install scrcpy`
+
+  Compilar pelos arquivos fontes: [BUILD] ([processo simplificado][BUILD_simple])
+
+[BUILD]: BUILD.md
+[BUILD_simple]: BUILD.md#simple
+
+
 ### Linux
 
 No Debian (_testing_ e _sid_ por enquanto) e Ubuntu (20.04):
@@ -67,9 +79,7 @@ Para Gentoo, uma [Ebuild] está disponível: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 
-Você também pode [compilar o app manualmente][BUILD] (não se preocupe, não é tão
-difícil).
-
+Você também pode [compilar o app manualmente][BUILD] ([processo simplificado][BUILD_simple]).
 
 
 ### Windows
@@ -113,13 +123,18 @@ brew install scrcpy
 Você precisa do `adb`, acessível pelo seu `PATH`. Se você ainda não o tem:
 
 ```bash
-# Homebrew >= 2.6.0
-brew install --cask android-platform-tools
-
-# Homebrew < 2.6.0
-brew cask install android-platform-tools
+brew install android-platform-tools
 ```
 
+Está também disponivel em [MacPorts], que prepara o adb para você:
+
+```bash
+sudo port install scrcpy
+```
+
+[MacPorts]: https://www.macports.org/
+
+
 Você também pode [compilar o app manualmente][BUILD].
 
 
@@ -195,10 +210,11 @@ Se `--max-size` também for especificado, o redimensionamento é aplicado após
 Para travar a orientação do espelhamento:
 
 ```bash
-scrcpy --lock-video-orientation 0   # orientação natural
-scrcpy --lock-video-orientation 1   # 90° sentido anti-horário
-scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation 3   # 90° sentido horário
+scrcpy --lock-video-orientation     # orientação inicial (Atual)
+scrcpy --lock-video-orientation=0   # orientação natural
+scrcpy --lock-video-orientation=1   # 90° sentido anti-horário
+scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation=3   # 90° sentido horário
 ```
 
 Isso afeta a orientação de gravação.
@@ -222,7 +238,9 @@ erro dará os encoders disponíveis:
 scrcpy --encoder _
 ```
 
-### Gravando
+### Captura
+
+#### Gravando
 
 É possível gravar a tela enquanto ocorre o espelhamento:
 
@@ -246,6 +264,79 @@ pacotes][packet delay variation] não impacta o arquivo gravado.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 
 
+#### v4l2loopback
+
+Em Linux, é possível enviar a transmissão do video para um disposiivo v4l2 loopback, assim
+o dispositivo Android pode ser aberto como uma webcam por qualquer ferramneta capaz de v4l2
+
+The module `v4l2loopback` must be installed:
+
+```bash
+sudo apt install v4l2loopback-dkms
+```
+
+Para criar um dispositivo v4l2:
+
+```bash
+sudo modprobe v4l2loopback
+```
+
+Isso criara um novo dispositivo de vídeo em `/dev/videoN`, onde `N` é uma integer
+(mais [opções](https://github.com/umlaeute/v4l2loopback#options) estão disponiveis
+para criar varios dispositivos ou dispositivos com IDs específicas).
+
+Para listar os dispositivos disponíveis:
+
+```bash
+# requer o pacote v4l-utils
+v4l2-ctl --list-devices
+
+# simples, mas pode ser suficiente
+ls /dev/video*
+```
+
+Para iniciar o scrcpy usando o coletor v4l2 (sink):
+
+```bash
+scrcpy --v4l2-sink=/dev/videoN
+scrcpy --v4l2-sink=/dev/videoN --no-display  # desativa a janela espelhada
+scrcpy --v4l2-sink=/dev/videoN -N            # versão curta
+```
+
+(troque `N` pelo ID do dipositivo, verifique com `ls /dev/video*`)
+
+Uma vez ativado, você pode abrir suas trasmissões de videos com uma ferramenta capaz de v4l2:
+
+```bash
+ffplay -i /dev/videoN
+vlc v4l2:///dev/videoN   # VLC pode adicionar um pouco de atraso de buffering
+```
+
+Por exemplo, você pode capturar o video dentro do [OBS].
+
+[OBS]: https://obsproject.com/
+
+
+#### Buffering
+
+É possivel adicionar buffering. Isso aumenta a latência, mas reduz a tenção (jitter) (veja
+[#2464]).
+
+[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
+
+A opção éta disponivel para buffering de exibição:
+
+```bash
+scrcpy --display-buffer=50  # adiciona 50 ms de buffering para a exibição
+```
+
+e coletor V4L2:
+
+```bash
+scrcpy --v4l2-buffer=500    # adiciona 500 ms de buffering para coletor V4L2
+```
+
+,
 ### Conexão
 
 #### Sem fio
@@ -488,18 +579,6 @@ scrcpy -Sw
 ```
 
 
-#### Renderizar frames expirados
-
-Por padrão, para minimizar a latência, _scrcpy_ sempre renderiza o último frame decodificado
-disponível, e descarta o anterior.
-
-Para forçar a renderização de todos os frames (com o custo de um possível aumento de
-latência), use:
-
-```bash
-scrcpy --render-expired-frames
-```
-
 #### Mostrar toques
 
 Para apresentações, pode ser útil mostrar toques físicos (no dispositivo
@@ -647,7 +726,7 @@ Não existe feedback visual, um log é imprimido no console.
 
 #### Enviar arquivo para dispositivo
 
-Para enviar um arquivo para `/sdcard/` no dispositivo, arraste e solte um arquivo (não-APK) para a
+Para enviar um arquivo para `/sdcard/Download/` no dispositivo, arraste e solte um arquivo (não-APK) para a
 janela do _scrcpy_.
 
 Não existe feedback visual, um log é imprimido no console.
@@ -694,12 +773,12 @@ _<kbd>[Super]</kbd> é tipicamente a tecla <kbd>Windows</kbd> ou <kbd>Cmd</kbd>.
  | Mudar modo de tela cheia                    | <kbd>MOD</kbd>+<kbd>f</kbd>
  | Rotacionar display para esquerda            | <kbd>MOD</kbd>+<kbd>←</kbd> _(esquerda)_
  | Rotacionar display para direita             | <kbd>MOD</kbd>+<kbd>→</kbd> _(direita)_
- | Redimensionar janela para 1:1 (pixel-perfect) | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Redimensionar janela para remover bordas pretas | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Clique-duplo¹_
+ | Redimensionar janela para 1:1 (pixel-perfeito) | <kbd>MOD</kbd>+<kbd>g</kbd>
+ | Redimensionar janela para remover bordas pretas | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Clique-duplo-esquerdo¹_
  | Clicar em `HOME`                            | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Clique-do-meio_
  | Clicar em `BACK`                            | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Clique-direito²_
- | Clicar em `APP_SWITCH`                      | <kbd>MOD</kbd>+<kbd>s</kbd>
- | Clicar em `MENU` (desbloquear tela          | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | Clicar em `APP_SWITCH`                      | <kbd>MOD</kbd>+<kbd>s</kbd> \| _Clique-do-4.°³_
+ | Clicar em `MENU` (desbloquear tela)         | <kbd>MOD</kbd>+<kbd>m</kbd>
  | Clicar em `VOLUME_UP`                       | <kbd>MOD</kbd>+<kbd>↑</kbd> _(cima)_
  | Clicar em `VOLUME_DOWN`                     | <kbd>MOD</kbd>+<kbd>↓</kbd> _(baixo)_
  | Clicar em `POWER`                           | <kbd>MOD</kbd>+<kbd>p</kbd>
@@ -707,18 +786,27 @@ _<kbd>[Super]</kbd> é tipicamente a tecla <kbd>Windows</kbd> ou <kbd>Cmd</kbd>.
  | Desligar tela do dispositivo (continuar espelhando) | <kbd>MOD</kbd>+<kbd>o</kbd>
  | Ligar tela do dispositivo                   | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
  | Rotacionar tela do dispositivo              | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Expandir painel de notificação              | <kbd>MOD</kbd>+<kbd>n</kbd>
- | Colapsar painel de notificação              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copiar para área de transferência³          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Recortar para área de transferência³        | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Sincronizar áreas de transferência e colar³ | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | Expandir painel de notificação              | <kbd>MOD</kbd>+<kbd>n</kbd> \| _Clique-do-5.°³_
+ | Expandir painel de configurção              | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Clique-duplo-do-5.°³_
+ | Colapsar paineis                            | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copiar para área de transferência⁴          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Recortar para área de transferência⁴        | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Sincronizar áreas de transferência e colar⁴ | <kbd>MOD</kbd>+<kbd>v</kbd>
  | Injetar texto da área de transferência do computador | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
  | Ativar/desativar contador de FPS (em stdout) | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Pinçar para dar zoom                        | <kbd>Ctrl</kbd>+_clicar-e-mover_
+ | Pinçar para dar zoom                        | <kbd>Ctrl</kbd>+_Clicar-e-mover_
 
-_¹Clique-duplo em bordas pretas para removê-las._  
-_²Clique-direito liga a tela se ela estiver desligada, pressiona BACK caso contrário._
-_³Apenas em Android >= 7._
+_¹Clique-duplo-esquerdo na borda preta para remove-la._  
+_²Clique-direito liga a tela caso esteja desligada, pressione BACK caso contrário._  
+_³4.° and 5.° botões do mouse, caso o mouse possua._  
+_⁴Apenas em Android >= 7._
+
+Atalhos com teclas reptidas são executados soltando e precionando a tecla
+uma segunda vez. Por exemplo, para executar "Expandir painel de Configurção":
+
+ 1. Mantenha pressionado <kbd>MOD</kbd>.
+ 2. Depois click duas vezes <kbd>n</kbd>.
+ 3. Finalmente, solte <kbd>MOD</kbd>.
 
 Todos os atalhos <kbd>Ctrl</kbd>+_tecla_ são encaminhados para o dispositivo, para que eles sejam
 tratados pela aplicação ativa.
@@ -729,7 +817,9 @@ tratados pela aplicação ativa.
 Para usar um binário _adb_ específico, configure seu caminho na variável de ambiente
 `ADB`:
 
+```bash
 ADB=/caminho/para/adb scrcpy
+```
 
 Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em
 `SCRCPY_SERVER_PATH`.
@@ -751,8 +841,6 @@ Um colega me desafiou a encontrar um nome tão impronunciável quanto [gnirehtet
 
 Veja [BUILD].
 
-[BUILD]: BUILD.md
-
 
 ## Problemas comuns
 

README.tr.md

@@ -0,0 +1,824 @@
+# scrcpy (v1.18)
+
+Bu uygulama Android cihazların USB (ya da [TCP/IP][article-tcpip]) üzerinden
+görüntülenmesini ve kontrol edilmesini sağlar. _root_ erişimine ihtiyaç duymaz.
+_GNU/Linux_, _Windows_ ve _macOS_ sistemlerinde çalışabilir.
+
+![screenshot](assets/screenshot-debian-600.jpg)
+
+Öne çıkan özellikler:
+
+- **hafiflik** (doğal, sadece cihazın ekranını gösterir)
+- **performans** (30~60fps)
+- **kalite** (1920×1080 ya da üzeri)
+- **düşük gecikme süresi** ([35~70ms][lowlatency])
+- **düşük başlangıç süresi** (~1 saniye ilk kareyi gösterme süresi)
+- **müdaheleci olmama** (cihazda kurulu yazılım kalmaz)
+
+[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
+
+## Gereksinimler
+
+Android cihaz en düşük API 21 (Android 5.0) olmalıdır.
+
+[Adb hata ayıklamasının][enable-adb] cihazınızda aktif olduğundan emin olun.
+
+[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
+
+Bazı cihazlarda klavye ve fare ile kontrol için [ilave bir seçenek][control] daha
+etkinleştirmeniz gerekebilir.
+
+[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
+
+## Uygulamayı indirin
+
+<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
+
+### Özet
+
+- Linux: `apt install scrcpy`
+- Windows: [indir][direct-win64]
+- macOS: `brew install scrcpy`
+
+Kaynak kodu derle: [BUILD] ([basitleştirilmiş süreç][build_simple])
+
+[build]: BUILD.md
+[build_simple]: BUILD.md#simple
+
+### Linux
+
+Debian (şimdilik _testing_ ve _sid_) ve Ubuntu (20.04) için:
+
+```
+apt install scrcpy
+```
+
+[Snap] paketi: [`scrcpy`][snap-link].
+
+[snap-link]: https://snapstats.org/snaps/scrcpy
+[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
+
+Fedora için, [COPR] paketi: [`scrcpy`][copr-link].
+
+[copr]: https://fedoraproject.org/wiki/Category:Copr
+[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
+
+Arch Linux için, [AUR] paketi: [`scrcpy`][aur-link].
+
+[aur]: https://wiki.archlinux.org/index.php/Arch_User_Repository
+[aur-link]: https://aur.archlinux.org/packages/scrcpy/
+
+Gentoo için, [Ebuild] mevcut: [`scrcpy/`][ebuild-link].
+
+[ebuild]: https://wiki.gentoo.org/wiki/Ebuild
+[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
+
+Ayrıca [uygulamayı el ile de derleyebilirsiniz][build] ([basitleştirilmiş süreç][build_simple]).
+
+### Windows
+
+Windows için (`adb` dahil) tüm gereksinimleri ile derlenmiş bir arşiv mevcut:
+
+ - [README](README.md#windows)
+
+[Chocolatey] ile kurulum:
+
+[chocolatey]: https://chocolatey.org/
+
+```bash
+choco install scrcpy
+choco install adb    # if you don't have it yet
+```
+
+[Scoop] ile kurulum:
+
+```bash
+scoop install scrcpy
+scoop install adb    # if you don't have it yet
+```
+
+[scoop]: https://scoop.sh
+
+Ayrıca [uygulamayı el ile de derleyebilirsiniz][build].
+
+### macOS
+
+Uygulama [Homebrew] içerisinde mevcut. Sadece kurun:
+
+[homebrew]: https://brew.sh/
+
+```bash
+brew install scrcpy
+```
+
+`adb`, `PATH` içerisinden erişilebilir olmalıdır. Eğer değilse:
+
+```bash
+brew install android-platform-tools
+```
+
+[MacPorts] kullanılarak adb ve uygulamanın birlikte kurulumu yapılabilir:
+
+```bash
+sudo port install scrcpy
+```
+
+[macports]: https://www.macports.org/
+
+Ayrıca [uygulamayı el ile de derleyebilirsiniz][build].
+
+## Çalıştırma
+
+Android cihazınızı bağlayın ve aşağıdaki komutu çalıştırın:
+
+```bash
+scrcpy
+```
+
+Komut satırı argümanları aşağıdaki komut ile listelenebilir:
+
+```bash
+scrcpy --help
+```
+
+## Özellikler
+
+### Ekran yakalama ayarları
+
+#### Boyut azaltma
+
+Bazen, Android cihaz ekranını daha düşük seviyede göstermek performansı artırabilir.
+
+Hem genişliği hem de yüksekliği bir değere sabitlemek için (ör. 1024):
+
+```bash
+scrcpy --max-size 1024
+scrcpy -m 1024  # kısa versiyon
+```
+
+Diğer boyut en-boy oranı korunacak şekilde hesaplanır.
+Bu şekilde ekran boyutu 1920x1080 olan bir cihaz 1024x576 olarak görünür.
+
+#### Bit-oranı değiştirme
+
+Varsayılan bit-oranı 8 Mbps'dir. Değiştirmek için (ör. 2 Mbps):
+
+```bash
+scrcpy --bit-rate 2M
+scrcpy -b 2M  # kısa versiyon
+```
+
+#### Çerçeve oranı sınırlama
+
+Ekran yakalama için maksimum çerçeve oranı için sınır koyulabilir:
+
+```bash
+scrcpy --max-fps 15
+```
+
+Bu özellik Android 10 ve sonrası sürümlerde resmi olarak desteklenmektedir,
+ancak daha önceki sürümlerde çalışmayabilir.
+
+#### Kesme
+
+Cihaz ekranının sadece bir kısmı görünecek şekilde kesilebilir.
+
+Bu özellik Oculus Go'nun bir gözünü yakalamak gibi durumlarda kullanışlı olur:
+
+```bash
+scrcpy --crop 1224:1440:0:0   # (0,0) noktasından 1224x1440
+```
+
+Eğer `--max-size` belirtilmişse yeniden boyutlandırma kesme işleminden sonra yapılır.
+
+#### Video yönünü kilitleme
+
+Videonun yönünü kilitlemek için:
+
+```bash
+scrcpy --lock-video-orientation     # başlangıç yönü
+scrcpy --lock-video-orientation=0   # doğal yön
+scrcpy --lock-video-orientation=1   # 90° saatin tersi yönü
+scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation=3   # 90° saat yönü
+```
+
+Bu özellik kaydetme yönünü de etkiler.
+
+[Pencere ayrı olarak döndürülmüş](#rotation) olabilir.
+
+#### Kodlayıcı
+
+Bazı cihazlar birden fazla kodlayıcıya sahiptir, ve bunların bazıları programın
+kapanmasına sebep olabilir. Bu durumda farklı bir kodlayıcı seçilebilir:
+
+```bash
+scrcpy --encoder OMX.qcom.video.encoder.avc
+```
+
+Mevcut kodlayıcıları listelemek için geçerli olmayan bir kodlayıcı ismi girebilirsiniz,
+hata mesajı mevcut kodlayıcıları listeleyecektir:
+
+```bash
+scrcpy --encoder _
+```
+
+### Yakalama
+
+#### Kaydetme
+
+Ekran yakalama sırasında kaydedilebilir:
+
+```bash
+scrcpy --record file.mp4
+scrcpy -r file.mkv
+```
+
+Yakalama olmadan kayıt için:
+
+```bash
+scrcpy --no-display --record file.mp4
+scrcpy -Nr file.mkv
+# Ctrl+C ile kayıt kesilebilir
+```
+
+"Atlanan kareler" gerçek zamanlı olarak gösterilmese (performans sebeplerinden ötürü) dahi kaydedilir.
+Kareler cihazda _zamandamgası_ ile saklanır, bu sayede [paket gecikme varyasyonu]
+kayıt edilen dosyayı etkilemez.
+
+[paket gecikme varyasyonu]: https://en.wikipedia.org/wiki/Packet_delay_variation
+
+#### v4l2loopback
+
+Linux'ta video akışı bir v4l2 loopback cihazına gönderilebilir. Bu sayede Android
+cihaz bir web kamerası gibi davranabilir.
+
+Bu işlem için `v4l2loopback` modülü kurulu olmalıdır:
+
+```bash
+sudo apt install v4l2loopback-dkms
+```
+
+v4l2 cihazı oluşturmak için:
+
+```bash
+sudo modprobe v4l2loopback
+```
+
+Bu komut `/dev/videoN` adresinde `N` yerine bir tamsayı koyarak yeni bir video
+cihazı oluşturacaktır.
+(birden fazla cihaz oluşturmak veya spesifik ID'ye sahip cihazlar için
+diğer [seçenekleri](https://github.com/umlaeute/v4l2loopback#options) inceleyebilirsiniz.)
+
+Aktif cihazları listelemek için:
+
+```bash
+# v4l-utils paketi ile
+v4l2-ctl --list-devices
+
+# daha basit ama yeterli olabilecek şekilde
+ls /dev/video*
+```
+
+v4l2 kullanarak scrpy kullanmaya başlamak için:
+
+```bash
+scrcpy --v4l2-sink=/dev/videoN
+scrcpy --v4l2-sink=/dev/videoN --no-display  # ayna penceresini kapatarak
+scrcpy --v4l2-sink=/dev/videoN -N            # kısa versiyon
+```
+
+(`N` harfini oluşturulan cihaz ID numarası ile değiştirin. `ls /dev/video*` cihaz ID'lerini görebilirsiniz.)
+
+Aktifleştirildikten sonra video akışını herhangi bir v4l2 özellikli araçla açabilirsiniz:
+
+```bash
+ffplay -i /dev/videoN
+vlc v4l2:///dev/videoN   # VLC kullanırken yükleme gecikmesi olabilir
+```
+
+Örneğin, [OBS] ile video akışını kullanabilirsiniz.
+
+[obs]: https://obsproject.com/
+
+### Bağlantı
+
+#### Kablosuz
+
+_Scrcpy_ cihazla iletişim kurmak için `adb`'yi kullanır, Ve `adb`
+bir cihaza TCP/IP kullanarak [bağlanabilir].
+
+1. Cihazınızı bilgisayarınızla aynı Wi-Fi ağına bağlayın.
+2. Cihazınızın IP adresini bulun. Ayarlar → Telefon Hakkında → Durum sekmesinden veya
+   aşağıdaki komutu çalıştırarak öğrenebilirsiniz:
+
+   ```bash
+   adb shell ip route | awk '{print $9}'
+   ```
+
+3. Cihazınızda TCP/IP üzerinden adb kullanımını etkinleştirin: `adb tcpip 5555`.
+4. Cihazınızı bilgisayarınızdan sökün.
+5. Cihazınıza bağlanın: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` değerini değiştirin)_.
+6. `scrcpy` komutunu normal olarak çalıştırın.
+
+Bit-oranını ve büyüklüğü azaltmak yararlı olabilir:
+
+```bash
+scrcpy --bit-rate 2M --max-size 800
+scrcpy -b2M -m800  # kısa version
+```
+
+[bağlanabilir]: https://developer.android.com/studio/command-line/adb.html#wireless
+
+#### Birden fazla cihaz
+
+Eğer `adb devices` komutu birden fazla cihaz listeliyorsa _serial_ değerini belirtmeniz gerekir:
+
+```bash
+scrcpy --serial 0123456789abcdef
+scrcpy -s 0123456789abcdef  # kısa versiyon
+```
+
+Eğer cihaz TCP/IP üzerinden bağlanmışsa:
+
+```bash
+scrcpy --serial 192.168.0.1:5555
+scrcpy -s 192.168.0.1:5555  # kısa version
+```
+
+Birden fazla cihaz için birden fazla _scrcpy_ uygulaması çalıştırabilirsiniz.
+
+#### Cihaz bağlantısı ile otomatik başlatma
+
+[AutoAdb] ile yapılabilir:
+
+```bash
+autoadb scrcpy -s '{}'
+```
+
+[autoadb]: https://github.com/rom1v/autoadb
+
+#### SSH Tünel
+
+Uzaktaki bir cihaza erişmek için lokal `adb` istemcisi, uzaktaki bir `adb` sunucusuna
+(aynı _adb_ sürümünü kullanmak şartı ile) bağlanabilir :
+
+```bash
+adb kill-server    # 5037 portunda çalışan lokal adb sunucusunu kapat
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
+# bunu açık tutun
+```
+
+Başka bir terminalde:
+
+```bash
+scrcpy
+```
+
+Uzaktan port yönlendirme ileri yönlü bağlantı kullanabilirsiniz
+(`-R` yerine `-L` olduğuna dikkat edin):
+
+```bash
+adb kill-server    # 5037 portunda çalışan lokal adb sunucusunu kapat
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
+# bunu açık tutun
+```
+
+Başka bir terminalde:
+
+```bash
+scrcpy --force-adb-forward
+```
+
+Kablosuz bağlantı gibi burada da kalite düşürmek faydalı olabilir:
+
+```
+scrcpy -b2M -m800 --max-fps 15
+```
+
+### Pencere ayarları
+
+#### İsim
+
+Cihaz modeli varsayılan pencere ismidir. Değiştirmek için:
+
+```bash
+scrcpy --window-title 'Benim cihazım'
+```
+
+#### Konum ve
+
+Pencerenin başlangıç konumu ve boyutu belirtilebilir:
+
+```bash
+scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
+```
+
+#### Kenarlıklar
+
+Pencere dekorasyonunu kapatmak için:
+
+```bash
+scrcpy --window-borderless
+```
+
+#### Her zaman üstte
+
+Scrcpy penceresini her zaman üstte tutmak için:
+
+```bash
+scrcpy --always-on-top
+```
+
+#### Tam ekran
+
+Uygulamayı tam ekran başlatmak için:
+
+```bash
+scrcpy --fullscreen
+scrcpy -f  # kısa versiyon
+```
+
+Tam ekran <kbd>MOD</kbd>+<kbd>f</kbd> ile dinamik olarak değiştirilebilir.
+
+#### Döndürme
+
+Pencere döndürülebilir:
+
+```bash
+scrcpy --rotation 1
+```
+
+Seçilebilecek değerler:
+
+- `0`: döndürme yok
+- `1`: 90 derece saat yönünün tersi
+- `2`: 180 derece
+- `3`: 90 derece saat yönü
+
+Döndürme <kbd>MOD</kbd>+<kbd>←</kbd>_(sol)_ ve
+<kbd>MOD</kbd>+<kbd>→</kbd> _(sağ)_ ile dinamik olarak değiştirilebilir.
+
+_scrcpy_'de 3 farklı döndürme olduğuna dikkat edin:
+
+- <kbd>MOD</kbd>+<kbd>r</kbd> cihazın yatay veya dikey modda çalışmasını sağlar.
+  (çalışan uygulama istenilen oryantasyonda çalışmayı desteklemiyorsa döndürme
+  işlemini reddedebilir.)
+- [`--lock-video-orientation`](#lock-video-orientation) görüntü yakalama oryantasyonunu
+  (cihazdan bilgisayara gelen video akışının oryantasyonu) değiştirir. Bu kayıt işlemini
+  etkiler.
+- `--rotation` (or <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
+  pencere içeriğini dönderir. Bu sadece canlı görüntüyü etkiler, kayıt işlemini etkilemez.
+
+### Diğer ekran yakalama seçenekleri
+
+#### Yazma korumalı
+
+Kontrolleri devre dışı bırakmak için (cihazla etkileşime geçebilecek her şey: klavye ve
+fare girdileri, dosya sürükleyip bırakma):
+
+```bash
+scrcpy --no-control
+scrcpy -n
+```
+
+#### Ekran
+
+Eğer cihazın birden fazla ekranı varsa hangi ekranın kullanılacağını seçebilirsiniz:
+
+```bash
+scrcpy --display 1
+```
+
+Kullanılabilecek ekranları listelemek için:
+
+```bash
+adb shell dumpsys display   # çıktı içerisinde "mDisplayId=" terimini arayın
+```
+
+İkinci ekran ancak cihaz Android sürümü 10 veya üzeri olmalıdır (değilse yazma korumalı
+olarak görüntülenir).
+
+#### Uyanık kalma
+
+Cihazın uyku moduna girmesini engellemek için:
+
+```bash
+scrcpy --stay-awake
+scrcpy -w
+```
+
+scrcpy kapandığında cihaz başlangıç durumuna geri döner.
+
+#### Ekranı kapatma
+
+Ekran yakalama sırasında cihazın ekranı kapatılabilir:
+
+```bash
+scrcpy --turn-screen-off
+scrcpy -S
+```
+
+Ya da <kbd>MOD</kbd>+<kbd>o</kbd> kısayolunu kullanabilirsiniz.
+
+Tekrar açmak için ise <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd> tuşlarına basın.
+
+Android'de, `GÜÇ` tuşu her zaman ekranı açar. Eğer `GÜÇ` sinyali scrcpy ile
+gönderilsiyse (sağ tık veya <kbd>MOD</kbd>+<kbd>p</kbd>), ekran kısa bir gecikme
+ile kapanacaktır. Fiziksel `GÜÇ` tuşuna basmak hala ekranın açılmasına sebep olacaktır.
+
+Bu cihazın uykuya geçmesini engellemek için kullanılabilir:
+
+```bash
+scrcpy --turn-screen-off --stay-awake
+scrcpy -Sw
+```
+
+#### Dokunuşları gösterme
+
+Sunumlar sırasında fiziksel dokunuşları (fiziksel cihazdaki) göstermek
+faydalı olabilir.
+
+Android'de bu özellik _Geliştici seçenekleri_ içerisinde bulunur.
+
+_Scrcpy_ bu özelliği çalışırken etkinleştirebilir ve kapanırken eski
+haline geri getirebilir:
+
+```bash
+scrcpy --show-touches
+scrcpy -t
+```
+
+Bu opsiyon sadece _fiziksel_ dokunuşları (cihaz ekranındaki) gösterir.
+
+#### Ekran koruyucuyu devre dışı bırakma
+
+Scrcpy varsayılan ayarlarında ekran koruyucuyu devre dışı bırakmaz.
+
+Bırakmak için:
+
+```bash
+scrcpy --disable-screensaver
+```
+
+### Girdi kontrolü
+
+#### Cihaz ekranını dönderme
+
+<kbd>MOD</kbd>+<kbd>r</kbd> tuşları ile yatay ve dikey modlar arasında
+geçiş yapabilirsiniz.
+
+Bu kısayol ancak çalışan uygulama desteklediği takdirde ekranı döndürecektir.
+
+#### Kopyala yapıştır
+
+Ne zaman Android cihazdaki pano değişse bilgisayardaki pano otomatik olarak
+senkronize edilir.
+
+Tüm <kbd>Ctrl</kbd> kısayolları cihaza iletilir:
+
+- <kbd>Ctrl</kbd>+<kbd>c</kbd> genelde kopyalar
+- <kbd>Ctrl</kbd>+<kbd>x</kbd> genelde keser
+- <kbd>Ctrl</kbd>+<kbd>v</kbd> genelde yapıştırır (bilgisayar ve cihaz arasındaki
+  pano senkronizasyonundan sonra)
+
+Bu kısayollar genelde beklediğiniz gibi çalışır.
+
+Ancak kısayolun gerçekten yaptığı eylemi açık olan uygulama belirler.
+Örneğin, _Termux_ <kbd>Ctrl</kbd>+<kbd>c</kbd> ile kopyalama yerine
+SIGINT sinyali gönderir, _K-9 Mail_ ise yeni mesaj oluşturur.
+
+Bu tip durumlarda kopyalama, kesme ve yapıştırma için (Android versiyon 7 ve
+üstü):
+
+- <kbd>MOD</kbd>+<kbd>c</kbd> `KOPYALA`
+- <kbd>MOD</kbd>+<kbd>x</kbd> `KES`
+- <kbd>MOD</kbd>+<kbd>v</kbd> `YAPIŞTIR` (bilgisayar ve cihaz arasındaki
+  pano senkronizasyonundan sonra)
+
+Bunlara ek olarak, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> tuşları
+bilgisayar pano içeriğini tuş basma eylemleri şeklinde gönderir. Bu metin
+yapıştırmayı desteklemeyen (_Termux_ gibi) uygulamar için kullanışlıdır,
+ancak ASCII olmayan içerikleri bozabilir.
+
+**UYARI:** Bilgisayar pano içeriğini cihaza yapıştırmak
+(<kbd>Ctrl</kbd>+<kbd>v</kbd> ya da <kbd>MOD</kbd>+<kbd>v</kbd> tuşları ile)
+içeriği cihaz panosuna kopyalar. Sonuç olarak, herhangi bir Android uygulaması
+içeriğe erişebilir. Hassas içerikler (parolalar gibi) için bu özelliği kullanmaktan
+kaçının.
+
+Bazı cihazlar pano değişikleri konusunda beklenilen şekilde çalışmayabilir.
+Bu durumlarda `--legacy-paste` argümanı kullanılabilir. Bu sayede
+<kbd>Ctrl</kbd>+<kbd>v</kbd> ve <kbd>MOD</kbd>+<kbd>v</kbd> tuşları da
+pano içeriğini tuş basma eylemleri şeklinde gönderir
+(<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> ile aynı şekilde).
+
+#### İki parmak ile yakınlaştırma
+
+"İki parmak ile yakınlaştırma" için: <kbd>Ctrl</kbd>+_tıkla-ve-sürükle_.
+
+Daha açıklayıcı şekilde, <kbd>Ctrl</kbd> tuşuna sol-tık ile birlikte basılı
+tutun. Sol-tık serbest bırakılıncaya kadar yapılan tüm fare hareketleri
+ekran içeriğini ekranın merkezini baz alarak dönderir, büyütür veya küçültür
+(eğer uygulama destekliyorsa).
+
+Scrcpy ekranın merkezinde bir "sanal parmak" varmış gibi davranır.
+
+#### Metin gönderme tercihi
+
+Metin girilirken ili çeşit [eylem][textevents] gerçekleştirilir:
+
+- _tuş eylemleri_, bir tuşa basıldığı sinyalini verir;
+- _metin eylemleri_, bir metin girildiği sinyalini verir.
+
+Varsayılan olarak, harfler tuş eylemleri kullanılarak gönderilir. Bu sayede
+klavye oyunlarda beklenilene uygun olarak çalışır (Genelde WASD tuşları).
+
+Ancak bu [bazı problemlere][prefertext] yol açabilir. Eğer bu problemler ile
+karşılaşırsanız metin eylemlerini tercih edebilirsiniz:
+
+```bash
+scrcpy --prefer-text
+```
+
+(Ama bu oyunlardaki klavye davranışlarını bozacaktır)
+
+[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
+[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
+
+#### Tuş tekrarı
+
+Varsayılan olarak, bir tuşa basılı tutmak tuş eylemini tekrarlar. Bu durum
+bazı oyunlarda problemlere yol açabilir.
+
+Tuş eylemlerinin tekrarını kapatmak için:
+
+```bash
+scrcpy --no-key-repeat
+```
+
+#### Sağ-tık ve Orta-tık
+
+Varsayılan olarak, sağ-tık GERİ (ya da GÜÇ açma) eylemlerini, orta-tık ise
+ANA EKRAN eylemini tetikler. Bu kısayolları devre dışı bırakmak için:
+
+```bash
+scrcpy --forward-all-clicks
+```
+
+### Dosya bırakma
+
+#### APK kurulumu
+
+APK kurmak için, bilgisayarınızdaki APK dosyasını (`.apk` ile biten) _scrcpy_
+penceresine sürükleyip bırakın.
+
+Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır.
+
+#### Dosyayı cihaza gönderme
+
+Bir dosyayı cihazdaki `/sdcard/Download/` dizinine atmak için, (APK olmayan)
+bir dosyayı _scrcpy_ penceresine sürükleyip bırakın.
+
+Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır.
+
+Hedef dizin uygulama başlatılırken değiştirilebilir:
+
+```bash
+scrcpy --push-target=/sdcard/Movies/
+```
+
+### Ses iletimi
+
+_Scrcpy_ ses iletimi yapmaz. Yerine [sndcpy] kullanabilirsiniz.
+
+Ayrıca bakınız [issue #14].
+
+[sndcpy]: https://github.com/rom1v/sndcpy
+[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
+
+## Kısayollar
+
+Aşağıdaki listede, <kbd>MOD</kbd> kısayol tamamlayıcısıdır. Varsayılan olarak
+(sol) <kbd>Alt</kbd> veya (sol) <kbd>Super</kbd> tuşudur.
+
+Bu tuş `--shortcut-mod` argümanı kullanılarak `lctrl`, `rctrl`,
+`lalt`, `ralt`, `lsuper` ve `rsuper` tuşlarından biri ile değiştirilebilir.
+Örneğin:
+
+```bash
+# Sağ Ctrl kullanmak için
+scrcpy --shortcut-mod=rctrl
+
+# Sol Ctrl, Sol Alt veya Sol Super tuşlarından birini kullanmak için
+scrcpy --shortcut-mod=lctrl+lalt,lsuper
+```
+
+_<kbd>[Super]</kbd> tuşu genelde <kbd>Windows</kbd> veya <kbd>Cmd</kbd> tuşudur._
+
+[super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
+
+| Action                                           | Shortcut                                                  |
+| ------------------------------------------------ | :-------------------------------------------------------- |
+| Tam ekran modunu değiştirme                      | <kbd>MOD</kbd>+<kbd>f</kbd>                               |
+| Ekranı sola çevirme                              | <kbd>MOD</kbd>+<kbd>←</kbd> _(sol)_                       |
+| Ekranı sağa çevirme                              | <kbd>MOD</kbd>+<kbd>→</kbd> _(sağ)_                       |
+| Pencereyi 1:1 oranına çevirme (pixel-perfect)    | <kbd>MOD</kbd>+<kbd>g</kbd>                               |
+| Penceredeki siyah kenarlıkları kaldırma          | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Çift-sol-tık¹_            |
+| `ANA EKRAN` tuşu                                 | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Orta-tık_                 |
+| `GERİ` tuşu                                      | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Sağ-tık²_                 |
+| `UYGULAMA_DEĞİŞTİR` tuşu                         | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4.tık³_                   |
+| `MENÜ` tuşu (ekran kilidini açma)                | <kbd>MOD</kbd>+<kbd>m</kbd>                               |
+| `SES_AÇ` tuşu                                    | <kbd>MOD</kbd>+<kbd>↑</kbd> _(yukarı)_                    |
+| `SES_KIS` tuşu                                   | <kbd>MOD</kbd>+<kbd>↓</kbd> _(aşağı)_                     |
+| `GÜÇ` tuşu                                       | <kbd>MOD</kbd>+<kbd>p</kbd>                               |
+| Gücü açma                                        | _Sağ-tık²_                                                |
+| Cihaz ekranını kapatma (ekran yakalama durmadan) | <kbd>MOD</kbd>+<kbd>o</kbd>                               |
+| Cihaz ekranını açma                              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>              |
+| Cihaz ekranını dönderme                          | <kbd>MOD</kbd>+<kbd>r</kbd>                               |
+| Bildirim panelini genişletme                     | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5.tık³_                   |
+| Ayarlar panelini genişletme                      | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Çift-5.tık³_ |
+| Panelleri kapatma                                | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>              |
+| Panoya kopyalama⁴                                | <kbd>MOD</kbd>+<kbd>c</kbd>                               |
+| Panoya kesme⁴                                    | <kbd>MOD</kbd>+<kbd>x</kbd>                               |
+| Panoları senkronize ederek yapıştırma⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>                               |
+| Bilgisayar panosundaki metini girme              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>              |
+| FPS sayacını açma/kapatma (terminalde)           | <kbd>MOD</kbd>+<kbd>i</kbd>                               |
+| İki parmakla yakınlaştırma                       | <kbd>Ctrl</kbd>+_tıkla-ve-sürükle_                        |
+
+_¹Siyah kenarlıkları silmek için üzerine çift tıklayın._  
+_²Sağ-tık ekran kapalıysa açar, değilse GERİ sinyali gönderir._  
+_³4. ve 5. fare tuşları (eğer varsa)._  
+_⁴Sadece Android 7 ve üzeri versiyonlarda._
+
+Tekrarlı tuşu olan kısayollar tuş bırakılıp tekrar basılarak tekrar çalıştırılır.
+Örneğin, "Ayarlar panelini genişletmek" için:
+
+1.  <kbd>MOD</kbd> tuşuna basın ve basılı tutun.
+2.  <kbd>n</kbd> tuşuna iki defa basın.
+3.  <kbd>MOD</kbd> tuşuna basmayı bırakın.
+
+Tüm <kbd>Ctrl</kbd>+_tuş_ kısayolları cihaza gönderilir. Bu sayede istenilen komut
+uygulama tarafından çalıştırılır.
+
+## Özel dizinler
+
+Varsayılandan farklı bir _adb_ programı çalıştırmak için `ADB` ortam değişkenini
+ayarlayın:
+
+```bash
+ADB=/path/to/adb scrcpy
+```
+
+`scrcpy-server` programının dizinini değiştirmek için `SCRCPY_SERVER_PATH`
+değişkenini ayarlayın.
+
+[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
+
+## Neden _scrcpy_?
+
+Bir meslektaşım [gnirehtet] gibi söylenmesi zor bir isim bulmam için bana meydan okudu.
+
+[`strcpy`] **str**ing kopyalıyor; `scrcpy` **scr**een kopyalıyor.
+
+[gnirehtet]: https://github.com/Genymobile/gnirehtet
+[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
+
+## Nasıl derlenir?
+
+Bakınız [BUILD].
+
+## Yaygın problemler
+
+Bakınız [FAQ](FAQ.md).
+
+## Geliştiriciler
+
+[Geliştiriciler sayfası]nı okuyun.
+
+[geliştiriciler sayfası]: DEVELOP.md
+
+## Lisans
+
+    Copyright (C) 2018 Genymobile
+    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.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+## Makaleler
+
+- [Introducing scrcpy][article-intro]
+- [Scrcpy now works wirelessly][article-tcpip]
+
+[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
+[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/

app/meson.build

@@ -1,36 +1,54 @@
 src = [
     'src/main.c',
     'src/adb.c',
+    'src/adb_tunnel.c',
     'src/cli.c',
+    'src/clock.c',
     'src/compat.c',
     'src/control_msg.c',
     'src/controller.c',
     'src/decoder.c',
     'src/device_msg.c',
-    'src/event_converter.c',
+    'src/icon.c',
     'src/file_handler.c',
     'src/fps_counter.c',
+    'src/frame_buffer.c',
     'src/input_manager.c',
+    'src/keyboard_inject.c',
+    'src/mouse_inject.c',
     'src/opengl.c',
+    'src/options.c',
     'src/receiver.c',
     'src/recorder.c',
     'src/scrcpy.c',
     'src/screen.c',
     'src/server.c',
     'src/stream.c',
-    'src/tiny_xpm.c',
     'src/video_buffer.c',
+    'src/util/file.c',
+    'src/util/intr.c',
     'src/util/log.c',
     'src/util/net.c',
+    'src/util/net_intr.c',
     'src/util/process.c',
-    'src/util/str_util.c',
+    'src/util/process_intr.c',
+    'src/util/strbuf.c',
+    'src/util/str.c',
+    'src/util/term.c',
     'src/util/thread.c',
+    'src/util/tick.c',
 ]
 
 if host_machine.system() == 'windows'
-    src += [ 'src/sys/win/process.c' ]
+    src += [
+        'src/sys/win/file.c',
+        'src/sys/win/process.c',
+    ]
 else
-    src += [ 'src/sys/unix/process.c' ]
+    src += [
+        'src/sys/unix/file.c',
+        'src/sys/unix/process.c',
+    ]
 endif
 
 v4l2_support = host_machine.system() == 'linux'
@@ -38,6 +56,14 @@ if v4l2_support
     src += [ 'src/v4l2_sink.c' ]
 endif
 
+aoa_hid_support = host_machine.system() == 'linux'
+if aoa_hid_support
+    src += [
+        'src/aoa_hid.c',
+        'src/hid_keyboard.c',
+    ]
+endif
+
 check_functions = [
     'strdup'
 ]
@@ -58,8 +84,11 @@ if not get_option('crossbuild_windows')
         dependencies += dependency('libavdevice')
     endif
 
-else
+    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/' + prebuilt_sdl2 + '/bin'
@@ -136,6 +165,9 @@ conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == '
 # enable V4L2 support (linux only)
 conf.set('HAVE_V4L2', v4l2_support)
 
+# enable HID over AOA support (linux only)
+conf.set('HAVE_AOA_HID', aoa_hid_support)
+
 configure_file(configuration: conf, output: 'config.h')
 
 src_dir = include_directories('src')
@@ -147,6 +179,9 @@ executable('scrcpy', src,
            c_args: [])
 
 install_man('scrcpy.1')
+install_data('../data/icon.png',
+             rename: 'scrcpy.png',
+             install_dir: 'share/icons/hicolor/256x256/apps')
 
 
 ### TESTS
@@ -163,12 +198,20 @@ if get_option('buildtype') == 'debug'
         ['test_cli', [
             'tests/test_cli.c',
             'src/cli.c',
-            'src/util/str_util.c',
+            'src/options.c',
+            'src/util/str.c',
+            'src/util/strbuf.c',
+            'src/util/term.c',
+        ]],
+        ['test_clock', [
+            'tests/test_clock.c',
+            'src/clock.c',
         ]],
         ['test_control_msg_serialize', [
             'tests/test_control_msg_serialize.c',
             'src/control_msg.c',
-            'src/util/str_util.c',
+            'src/util/str.c',
+            'src/util/strbuf.c',
         ]],
         ['test_device_msg_deserialize', [
             'tests/test_device_msg_deserialize.c',
@@ -177,9 +220,14 @@ if get_option('buildtype') == 'debug'
         ['test_queue', [
             'tests/test_queue.c',
         ]],
-        ['test_strutil', [
-            'tests/test_strutil.c',
-            'src/util/str_util.c',
+        ['test_strbuf', [
+            'tests/test_strbuf.c',
+            'src/util/strbuf.c',
+        ]],
+        ['test_str', [
+            'tests/test_str.c',
+            'src/util/str.c',
+            'src/util/strbuf.c',
         ]],
     ]
 

app/scrcpy.1

@@ -56,6 +56,12 @@ The list of possible display ids can be listed by "adb shell dumpsys display"
 
 Default is 0.
 
+.TP
+.BI "\-\-display\-buffer ms
+Add a buffering delay (in milliseconds) before displaying. This increases latency to compensate for jitter.
+
+Default is 0 (no buffering).
+
 .TP
 .BI "\-\-encoder " name
 Use a specific MediaCodec encoder (must be a H.264 encoder).
@@ -76,6 +82,14 @@ Start in fullscreen.
 .B \-h, \-\-help
 Print this help.
 
+.TP
+.B \-K, \-\-hid\-keyboard
+Simulate a physical keyboard by using HID over AOAv2.
+
+This provides a better experience for IME users, and allows to generate non-ASCII characters, contrary to the default injection method.
+
+It may only work over USB, and is currently only supported on Linux.
+
 .TP
 .B \-\-legacy\-paste
 Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+Shift+v).
@@ -83,8 +97,8 @@ Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+S
 This is a workaround for some devices not behaving as expected when setting the device clipboard programmatically.
 
 .TP
-.BI "\-\-lock\-video\-orientation " [value]
-Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
+.BI "\-\-lock\-video\-orientation[=value]
+Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees rotation counterclockwise.
 
 Default is "unlocked".
 
@@ -122,6 +136,10 @@ Set the TCP port (range) used by the client to listen.
 
 Default is 27183:27199.
 
+.TP
+.B \-\-power\-off\-on\-close
+Turn the device screen off when closing scrcpy.
+
 .TP
 .B \-\-prefer\-text
 Inject alpha characters and space as text events instead of key events.
@@ -189,7 +207,15 @@ It only shows physical touches (not clicks from scrcpy).
 .BI "\-\-v4l2-sink " /dev/videoN
 Output to v4l2loopback device.
 
-It requires to lock the video orientation (see --lock-video-orientation).
+It requires to lock the video orientation (see \fB\-\-lock\-video\-orientation\fR).
+
+.TP
+.BI "\-\-v4l2-buffer " ms
+Add a buffering delay (in milliseconds) before pushing frames. This increases latency to compensate for jitter.
+
+This option is similar to \fB\-\-display\-buffer\fR, but specific to V4L2 sink.
+
+Default is 0 (no buffering).
 
 .TP
 .BI "\-V, \-\-verbosity " value
@@ -240,7 +266,7 @@ Default is 0 (automatic).
 .SH SHORTCUTS
 
 In the following list, MOD is the shortcut modifier. By default, it's (left)
-Alt or (left) Super, but it can be configured by \-\-shortcut-mod (see above).
+Alt or (left) Super, but it can be configured by \fB\-\-shortcut\-mod\fR (see above).
 
 .TP
 .B MOD+f
@@ -342,6 +368,10 @@ Pinch-to-zoom from the center of the screen
 .B Drag & drop APK file
 Install APK from computer
 
+.TP
+.B Drag & drop non-APK file
+Push file to device (see \fB\-\-push\-target\fR)
+
 
 .SH Environment variables
 

app/src/adb.c

@@ -5,8 +5,10 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "util/file.h"
 #include "util/log.h"
-#include "util/str_util.h"
+#include "util/process_intr.h"
+#include "util/str.h"
 
 static const char *adb_command;
 
@@ -68,7 +70,7 @@ show_adb_installation_msg() {
         {"pacman", "pacman -S android-tools"},
     };
     for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
-        if (search_executable(pkg_managers[i].binary)) {
+        if (sc_file_executable_exists(pkg_managers[i].binary)) {
             LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
             return;
         }
@@ -80,7 +82,7 @@ show_adb_installation_msg() {
 }
 
 static void
-show_adb_err_msg(enum process_result err, const char *const argv[]) {
+show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
 #define MAX_COMMAND_STRING_LEN 1024
     char *buf = malloc(MAX_COMMAND_STRING_LEN);
     if (!buf) {
@@ -89,18 +91,18 @@ show_adb_err_msg(enum process_result err, const char *const argv[]) {
     }
 
     switch (err) {
-        case PROCESS_ERROR_GENERIC:
+        case SC_PROCESS_ERROR_GENERIC:
             argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
             LOGE("Failed to execute: %s", buf);
             break;
-        case PROCESS_ERROR_MISSING_BINARY:
+        case SC_PROCESS_ERROR_MISSING_BINARY:
             argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
             LOGE("Command not found: %s", buf);
             LOGE("(make 'adb' accessible from your PATH or define its full"
                  "path in the ADB environment variable)");
             show_adb_installation_msg();
             break;
-        case PROCESS_SUCCESS:
+        case SC_PROCESS_SUCCESS:
             // do nothing
             break;
     }
@@ -108,14 +110,15 @@ show_adb_err_msg(enum process_result err, const char *const argv[]) {
     free(buf);
 }
 
-process_t
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
+static sc_pid
+adb_execute_p(const char *serial, const char *const adb_cmd[],
+              size_t len, unsigned inherit, sc_pipe *pout) {
     int i;
-    process_t process;
+    sc_pid pid;
 
     const char **argv = malloc((len + 4) * sizeof(*argv));
     if (!argv) {
-        return PROCESS_NONE;
+        return SC_PROCESS_NONE;
     }
 
     argv[0] = get_adb_command();
@@ -129,98 +132,185 @@ adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
 
     memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
     argv[len + i] = NULL;
-    enum process_result r = process_execute(argv, &process);
-    if (r != PROCESS_SUCCESS) {
+    enum sc_process_result r =
+        sc_process_execute_p(argv, &pid, inherit, NULL, pout, NULL);
+    if (r != SC_PROCESS_SUCCESS) {
         show_adb_err_msg(r, argv);
-        process = PROCESS_NONE;
+        pid = SC_PROCESS_NONE;
     }
 
     free(argv);
-    return process;
+    return pid;
 }
 
-process_t
-adb_forward(const char *serial, uint16_t local_port,
-            const char *device_socket_name) {
+sc_pid
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
+            unsigned inherit) {
+    return adb_execute_p(serial, adb_cmd, len, inherit, NULL);
+}
+
+static sc_pid
+adb_exec_forward(const char *serial, uint16_t local_port,
+                 const char *device_socket_name, unsigned inherit) {
     char local[4 + 5 + 1]; // tcp:PORT
     char remote[108 + 14 + 1]; // localabstract:NAME
     sprintf(local, "tcp:%" PRIu16, local_port);
     snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
     const char *const adb_cmd[] = {"forward", local, remote};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 }
 
-process_t
-adb_forward_remove(const char *serial, uint16_t local_port) {
+static sc_pid
+adb_exec_forward_remove(const char *serial, uint16_t local_port,
+                        unsigned inherit) {
     char local[4 + 5 + 1]; // tcp:PORT
     sprintf(local, "tcp:%" PRIu16, local_port);
     const char *const adb_cmd[] = {"forward", "--remove", local};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 }
 
-process_t
-adb_reverse(const char *serial, const char *device_socket_name,
-            uint16_t local_port) {
+static sc_pid
+adb_exec_reverse(const char *serial, const char *device_socket_name,
+                 uint16_t local_port, unsigned inherit) {
     char local[4 + 5 + 1]; // tcp:PORT
     char remote[108 + 14 + 1]; // localabstract:NAME
     sprintf(local, "tcp:%" PRIu16, local_port);
     snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
     const char *const adb_cmd[] = {"reverse", remote, local};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 }
 
-process_t
-adb_reverse_remove(const char *serial, const char *device_socket_name) {
+static sc_pid
+adb_exec_reverse_remove(const char *serial, const char *device_socket_name,
+                        unsigned inherit) {
     char remote[108 + 14 + 1]; // localabstract:NAME
     snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
     const char *const adb_cmd[] = {"reverse", "--remove", remote};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 }
 
-process_t
-adb_push(const char *serial, const char *local, const char *remote) {
+static sc_pid
+adb_exec_push(const char *serial, const char *local, const char *remote,
+              unsigned inherit) {
 #ifdef __WINDOWS__
     // Windows will parse the string, so the paths must be quoted
     // (see sys/win/command.c)
-    local = strquote(local);
+    local = sc_str_quote(local);
     if (!local) {
-        return PROCESS_NONE;
+        return SC_PROCESS_NONE;
     }
-    remote = strquote(remote);
+    remote = sc_str_quote(remote);
     if (!remote) {
         free((void *) local);
-        return PROCESS_NONE;
+        return SC_PROCESS_NONE;
     }
 #endif
 
     const char *const adb_cmd[] = {"push", local, remote};
-    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 
 #ifdef __WINDOWS__
     free((void *) remote);
     free((void *) local);
 #endif
 
-    return proc;
+    return pid;
 }
 
-process_t
-adb_install(const char *serial, const char *local) {
+static sc_pid
+adb_exec_install(const char *serial, const char *local, unsigned inherit) {
 #ifdef __WINDOWS__
     // Windows will parse the string, so the local name must be quoted
     // (see sys/win/command.c)
-    local = strquote(local);
+    local = sc_str_quote(local);
     if (!local) {
-        return PROCESS_NONE;
+        return SC_PROCESS_NONE;
     }
 #endif
 
     const char *const adb_cmd[] = {"install", "-r", local};
-    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), inherit);
 
 #ifdef __WINDOWS__
     free((void *) local);
 #endif
 
-    return proc;
+    return pid;
+}
+
+static sc_pid
+adb_exec_get_serialno(unsigned inherit, sc_pipe *pout) {
+    const char *const adb_cmd[] = {"get-serialno"};
+    return adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), inherit, pout);
+}
+
+bool
+adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
+            const char *device_socket_name, unsigned inherit) {
+    sc_pid pid =
+        adb_exec_forward(serial, local_port, device_socket_name, inherit);
+    return sc_process_check_success_intr(intr, pid, "adb forward", true);
+}
+
+bool
+adb_forward_remove(struct sc_intr *intr, const char *serial,
+                   uint16_t local_port, unsigned inherit) {
+    sc_pid pid = adb_exec_forward_remove(serial, local_port, inherit);
+    return sc_process_check_success_intr(intr, pid, "adb forward --remove",
+                                         true);
+}
+
+bool
+adb_reverse(struct sc_intr *intr, const char *serial,
+            const char *device_socket_name, uint16_t local_port,
+            unsigned inherit) {
+    sc_pid pid =
+        adb_exec_reverse(serial, device_socket_name, local_port, inherit);
+    return sc_process_check_success_intr(intr, pid, "adb reverse", true);
+}
+
+bool
+adb_reverse_remove(struct sc_intr *intr, const char *serial,
+                   const char *device_socket_name, unsigned inherit) {
+    sc_pid pid = adb_exec_reverse_remove(serial, device_socket_name, inherit);
+    return sc_process_check_success_intr(intr, pid, "adb reverse --remove",
+                                         true);
+}
+
+bool
+adb_push(struct sc_intr *intr, const char *serial, const char *local,
+         const char *remote, unsigned inherit) {
+    sc_pid pid = adb_exec_push(serial, local, remote, inherit);
+    return sc_process_check_success_intr(intr, pid, "adb push", true);
+}
+
+bool
+adb_install(struct sc_intr *intr, const char *serial, const char *local,
+            unsigned inherit) {
+    sc_pid pid = adb_exec_install(serial, local, inherit);
+    return sc_process_check_success_intr(intr, pid, "adb install", true);
+}
+
+char *
+adb_get_serialno(struct sc_intr *intr, unsigned inherit) {
+    sc_pipe pout;
+    sc_pid pid = adb_exec_get_serialno(inherit, &pout);
+    if (pid == SC_PROCESS_NONE) {
+        LOGE("Could not execute \"adb get-serialno\"");
+        return NULL;
+    }
+
+    char buf[128];
+    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
+    sc_pipe_close(pout);
+
+    bool ok =
+        sc_process_check_success_intr(intr, pid, "adb get-serialno", true);
+    if (!ok) {
+        return NULL;
+    }
+
+    sc_str_truncate(buf, r, " \r\n");
+
+    return strdup(buf);
 }

app/src/adb.h

@@ -6,29 +6,43 @@
 #include <stdbool.h>
 #include <inttypes.h>
 
-#include "util/process.h"
+#include "util/intr.h"
 
-process_t
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
+sc_pid
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
+            unsigned inherit);
 
-process_t
-adb_forward(const char *serial, uint16_t local_port,
-            const char *device_socket_name);
+bool
+adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
+            const char *device_socket_name, unsigned inherit);
 
-process_t
-adb_forward_remove(const char *serial, uint16_t local_port);
+bool
+adb_forward_remove(struct sc_intr *intr, const char *serial,
+                   uint16_t local_port, unsigned inherit);
 
-process_t
-adb_reverse(const char *serial, const char *device_socket_name,
-            uint16_t local_port);
+bool
+adb_reverse(struct sc_intr *intr, const char *serial,
+            const char *device_socket_name, uint16_t local_port,
+            unsigned inherit);
 
-process_t
-adb_reverse_remove(const char *serial, const char *device_socket_name);
+bool
+adb_reverse_remove(struct sc_intr *intr, const char *serial,
+                   const char *device_socket_name, unsigned inherit);
 
-process_t
-adb_push(const char *serial, const char *local, const char *remote);
+bool
+adb_push(struct sc_intr *intr, const char *serial, const char *local,
+         const char *remote, unsigned inherit);
 
-process_t
-adb_install(const char *serial, const char *local);
+bool
+adb_install(struct sc_intr *intr, const char *serial, const char *local,
+            unsigned inherit);
+
+/**
+ * Execute `adb get-serialno`
+ *
+ * Return the result, to be freed by the caller, or NULL on error.
+ */
+char *
+adb_get_serialno(struct sc_intr *intr, unsigned inherit);
 
 #endif

app/src/adb_tunnel.c

@@ -0,0 +1,170 @@
+#include "adb_tunnel.h"
+
+#include <assert.h>
+
+#include "adb.h"
+#include "util/log.h"
+#include "util/net_intr.h"
+#include "util/process_intr.h"
+
+#define SC_SOCKET_NAME "scrcpy"
+
+static bool
+listen_on_port(struct sc_intr *intr, sc_socket socket, uint16_t port) {
+    return net_listen_intr(intr, socket, IPV4_LOCALHOST, port, 1);
+}
+
+static bool
+enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
+                               struct sc_intr *intr, const char *serial,
+                               struct sc_port_range port_range) {
+    uint16_t port = port_range.first;
+    for (;;) {
+        if (!adb_reverse(intr, serial, SC_SOCKET_NAME, port,
+                         SC_INHERIT_STDERR)) {
+            // the command itself failed, it will fail on any port
+            return false;
+        }
+
+        // At the application level, the device part is "the server" because it
+        // serves video stream and control. However, at the network level, the
+        // client listens and the server connects to the client. That way, the
+        // client can listen before starting the server app, so there is no
+        // need to try to connect until the server socket is listening on the
+        // device.
+        sc_socket server_socket = net_socket();
+        if (server_socket != SC_SOCKET_NONE) {
+            bool ok = listen_on_port(intr, server_socket, port);
+            if (ok) {
+                // success
+                tunnel->server_socket = server_socket;
+                tunnel->local_port = port;
+                tunnel->enabled = true;
+                return true;
+            }
+
+            net_close(server_socket);
+        }
+
+        if (sc_intr_is_interrupted(intr)) {
+            // Stop immediately
+            return false;
+        }
+
+        // failure, disable tunnel and try another port
+        if (!adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+                                SC_INHERIT_STDERR)) {
+            LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
+        }
+
+        // check before incrementing to avoid overflow on port 65535
+        if (port < port_range.last) {
+            LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
+                 port, (uint16_t) (port + 1));
+            port++;
+            continue;
+        }
+
+        if (port_range.first == port_range.last) {
+            LOGE("Could not listen on port %" PRIu16, port_range.first);
+        } else {
+            LOGE("Could not listen on any port in range %" PRIu16 ":%" PRIu16,
+                 port_range.first, port_range.last);
+        }
+        return false;
+    }
+}
+
+static bool
+enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
+                               struct sc_intr *intr, const char *serial,
+                               struct sc_port_range port_range) {
+    tunnel->forward = true;
+
+    uint16_t port = port_range.first;
+    for (;;) {
+        if (adb_forward(intr, serial, port, SC_SOCKET_NAME,
+                        SC_INHERIT_STDERR)) {
+            // success
+            tunnel->local_port = port;
+            tunnel->enabled = true;
+            return true;
+        }
+
+        if (sc_intr_is_interrupted(intr)) {
+            // Stop immediately
+            return false;
+        }
+
+        if (port < port_range.last) {
+            LOGW("Could not forward port %" PRIu16", retrying on %" PRIu16,
+                 port, (uint16_t) (port + 1));
+            port++;
+            continue;
+        }
+
+        if (port_range.first == port_range.last) {
+            LOGE("Could not forward port %" PRIu16, port_range.first);
+        } else {
+            LOGE("Could not forward any port in range %" PRIu16 ":%" PRIu16,
+                 port_range.first, port_range.last);
+        }
+        return false;
+    }
+}
+
+void
+sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel) {
+    tunnel->enabled = false;
+    tunnel->forward = false;
+    tunnel->server_socket = SC_SOCKET_NONE;
+    tunnel->local_port = 0;
+}
+
+bool
+sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
+                   const char *serial, struct sc_port_range port_range,
+                   bool force_adb_forward) {
+    assert(!tunnel->enabled);
+
+    if (!force_adb_forward) {
+        // Attempt to use "adb reverse"
+        if (enable_tunnel_reverse_any_port(tunnel, intr, serial, port_range)) {
+            return true;
+        }
+
+        // if "adb reverse" does not work (e.g. over "adb connect"), it
+        // fallbacks to "adb forward", so the app socket is the client
+
+        LOGW("'adb reverse' failed, fallback to 'adb forward'");
+    }
+
+    return enable_tunnel_forward_any_port(tunnel, intr, serial, port_range);
+}
+
+bool
+sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
+                    const char *serial) {
+    assert(tunnel->enabled);
+
+    bool ret;
+    if (tunnel->forward) {
+        ret = adb_forward_remove(intr, serial, tunnel->local_port,
+                                 SC_INHERIT_STDERR);
+    } else {
+        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+                                 SC_INHERIT_STDERR);
+
+        assert(tunnel->server_socket != SC_SOCKET_NONE);
+        if (!net_close(tunnel->server_socket)) {
+            LOGW("Could not close server socket");
+        }
+
+        // server_socket is never used anymore
+    }
+
+    // Consider tunnel disabled even if the command failed
+    tunnel->enabled = false;
+
+    return ret;
+}

app/src/adb_tunnel.h

@@ -0,0 +1,47 @@
+#ifndef SC_ADB_TUNNEL_H
+#define SC_ADB_TUNNEL_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "options.h"
+#include "util/intr.h"
+#include "util/net.h"
+
+struct sc_adb_tunnel {
+    bool enabled;
+    bool forward; // use "adb forward" instead of "adb reverse"
+    sc_socket server_socket; // only used if !forward
+    uint16_t local_port;
+};
+
+/**
+ * Initialize the adb tunnel struct to default values
+ */
+void
+sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel);
+
+/**
+ * Open a tunnel
+ *
+ * Blocking calls may be interrupted asynchronously via `intr`.
+ *
+ * If `force_adb_forward` is not set, then attempts to set up an "adb reverse"
+ * tunnel first. Only if it fails (typical on old Android version connected via
+ * TCP/IP), use "adb forward".
+ */
+bool
+sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
+                   const char *serial, struct sc_port_range port_range,
+                   bool force_adb_forward);
+
+/**
+ * Close the tunnel
+ */
+bool
+sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
+                    const char *serial);
+
+#endif

app/src/aoa_hid.c

@@ -0,0 +1,385 @@
+#include "util/log.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+#include "aoa_hid.h"
+
+// See <https://source.android.com/devices/accessories/aoa2#hid-support>.
+#define ACCESSORY_REGISTER_HID 54
+#define ACCESSORY_SET_HID_REPORT_DESC 56
+#define ACCESSORY_SEND_HID_EVENT 57
+#define ACCESSORY_UNREGISTER_HID 55
+
+#define DEFAULT_TIMEOUT 1000
+
+static void
+sc_hid_event_log(const struct sc_hid_event *event) {
+    // HID Event: [00] FF FF FF FF...
+    assert(event->size);
+    unsigned buffer_size = event->size * 3 + 1;
+    char *buffer = malloc(buffer_size);
+    if (!buffer) {
+        return;
+    }
+    for (unsigned i = 0; i < event->size; ++i) {
+        snprintf(buffer + i * 3, 4, " %02x", event->buffer[i]);
+    }
+    LOGV("HID Event: [%d]%s", event->accessory_id, buffer);
+    free(buffer);
+}
+
+void
+sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
+                  unsigned char *buffer, uint16_t buffer_size) {
+    hid_event->accessory_id = accessory_id;
+    hid_event->buffer = buffer;
+    hid_event->size = buffer_size;
+    hid_event->delay = 0;
+}
+
+void
+sc_hid_event_destroy(struct sc_hid_event *hid_event) {
+    free(hid_event->buffer);
+}
+
+static inline void
+log_libusb_error(enum libusb_error errcode) {
+    LOGW("libusb error: %s", libusb_strerror(errcode));
+}
+
+static bool
+accept_device(libusb_device *device, const char *serial) {
+    // do not log any USB error in this function, it is expected that many USB
+    // devices available on the computer have permission restrictions
+
+    struct libusb_device_descriptor desc;
+    libusb_get_device_descriptor(device, &desc);
+
+    if (!desc.iSerialNumber) {
+        return false;
+    }
+
+    libusb_device_handle *handle;
+    int result = libusb_open(device, &handle);
+    if (result < 0) {
+        return false;
+    }
+
+    char buffer[128];
+    result = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber,
+                                                (unsigned char *) buffer,
+                                                sizeof(buffer));
+    libusb_close(handle);
+    if (result < 0) {
+        return false;
+    }
+
+    buffer[sizeof(buffer) - 1] = '\0'; // just in case
+
+    // accept the device if its serial matches
+    return !strcmp(buffer, serial);
+}
+
+static libusb_device *
+sc_aoa_find_usb_device(const char *serial) {
+    if (!serial) {
+        return NULL;
+    }
+
+    libusb_device **list;
+    libusb_device *result = NULL;
+    ssize_t count = libusb_get_device_list(NULL, &list);
+    if (count < 0) {
+        log_libusb_error((enum libusb_error) count);
+        return NULL;
+    }
+
+    for (size_t i = 0; i < (size_t) count; ++i) {
+        libusb_device *device = list[i];
+
+        if (accept_device(device, serial)) {
+            result = libusb_ref_device(device);
+            break;
+        }
+    }
+    libusb_free_device_list(list, 1);
+    return result;
+}
+
+static int
+sc_aoa_open_usb_handle(libusb_device *device, libusb_device_handle **handle) {
+    int result = libusb_open(device, handle);
+    if (result < 0) {
+        log_libusb_error((enum libusb_error) result);
+        return result;
+    }
+    return 0;
+}
+
+bool
+sc_aoa_init(struct sc_aoa *aoa, const char *serial) {
+    cbuf_init(&aoa->queue);
+
+    if (!sc_mutex_init(&aoa->mutex)) {
+        return false;
+    }
+
+    if (!sc_cond_init(&aoa->event_cond)) {
+        sc_mutex_destroy(&aoa->mutex);
+        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;
+
+    return true;
+}
+
+void
+sc_aoa_destroy(struct sc_aoa *aoa) {
+    // Destroy remaining events
+    struct sc_hid_event event;
+    while (cbuf_take(&aoa->queue, &event)) {
+        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);
+}
+
+static bool
+sc_aoa_register_hid(struct sc_aoa *aoa, uint16_t accessory_id,
+                    uint16_t report_desc_size) {
+    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
+    uint8_t request = ACCESSORY_REGISTER_HID;
+    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
+    // value (arg0): accessory assigned ID for the HID device
+    // index (arg1): total length of the HID report descriptor
+    uint16_t value = accessory_id;
+    uint16_t index = report_desc_size;
+    unsigned char *buffer = NULL;
+    uint16_t length = 0;
+    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
+                                         value, index, buffer, length,
+                                         DEFAULT_TIMEOUT);
+    if (result < 0) {
+        log_libusb_error((enum libusb_error) result);
+        return false;
+    }
+
+    return true;
+}
+
+static bool
+sc_aoa_set_hid_report_desc(struct sc_aoa *aoa, uint16_t accessory_id,
+                           const unsigned char *report_desc,
+                           uint16_t report_desc_size) {
+    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
+    uint8_t request = ACCESSORY_SET_HID_REPORT_DESC;
+    /**
+     * If the HID descriptor is longer than the endpoint zero max packet size,
+     * the descriptor will be sent in multiple ACCESSORY_SET_HID_REPORT_DESC
+     * commands. The data for the descriptor must be sent sequentially
+     * if multiple packets are needed.
+     * <https://source.android.com/devices/accessories/aoa2.html#hid-support>
+     *
+     * libusb handles packet abstraction internally, so we don't need to care
+     * about bMaxPacketSize0 here.
+     *
+     * See <https://libusb.sourceforge.io/api-1.0/libusb_packetoverflow.html>
+     */
+    // value (arg0): accessory assigned ID for the HID device
+    // index (arg1): offset of data (buffer) in descriptor
+    uint16_t value = accessory_id;
+    uint16_t index = 0;
+    // libusb_control_transfer expects a pointer to non-const
+    unsigned char *buffer = (unsigned char *) report_desc;
+    uint16_t length = report_desc_size;
+    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
+                                         value, index, buffer, length,
+                                         DEFAULT_TIMEOUT);
+    if (result < 0) {
+        log_libusb_error((enum libusb_error) result);
+        return false;
+    }
+
+    return true;
+}
+
+bool
+sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
+                 const unsigned char *report_desc, uint16_t report_desc_size) {
+    bool ok = sc_aoa_register_hid(aoa, accessory_id, report_desc_size);
+    if (!ok) {
+        return false;
+    }
+
+    ok = sc_aoa_set_hid_report_desc(aoa, accessory_id, report_desc,
+                                    report_desc_size);
+    if (!ok) {
+        if (!sc_aoa_unregister_hid(aoa, accessory_id)) {
+            LOGW("Could not unregister HID");
+        }
+        return false;
+    }
+
+    return true;
+}
+
+static bool
+sc_aoa_send_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
+    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
+    uint8_t request = ACCESSORY_SEND_HID_EVENT;
+    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
+    // value (arg0): accessory assigned ID for the HID device
+    // index (arg1): 0 (unused)
+    uint16_t value = event->accessory_id;
+    uint16_t index = 0;
+    unsigned char *buffer = event->buffer;
+    uint16_t length = event->size;
+    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
+                                         value, index, buffer, length,
+                                         DEFAULT_TIMEOUT);
+    if (result < 0) {
+        log_libusb_error((enum libusb_error) result);
+        return false;
+    }
+
+    return true;
+}
+
+bool
+sc_aoa_unregister_hid(struct sc_aoa *aoa, const uint16_t accessory_id) {
+    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
+    uint8_t request = ACCESSORY_UNREGISTER_HID;
+    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
+    // value (arg0): accessory assigned ID for the HID device
+    // index (arg1): 0
+    uint16_t value = accessory_id;
+    uint16_t index = 0;
+    unsigned char *buffer = NULL;
+    uint16_t length = 0;
+    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
+                                         value, index, buffer, length,
+                                         DEFAULT_TIMEOUT);
+    if (result < 0) {
+        log_libusb_error((enum libusb_error) result);
+        return false;
+    }
+
+    return true;
+}
+
+bool
+sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
+    if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
+        sc_hid_event_log(event);
+    }
+
+    sc_mutex_lock(&aoa->mutex);
+    bool was_empty = cbuf_is_empty(&aoa->queue);
+    bool res = cbuf_push(&aoa->queue, *event);
+    if (was_empty) {
+        sc_cond_signal(&aoa->event_cond);
+    }
+    sc_mutex_unlock(&aoa->mutex);
+    return res;
+}
+
+static int
+run_aoa_thread(void *data) {
+    struct sc_aoa *aoa = data;
+
+    for (;;) {
+        sc_mutex_lock(&aoa->mutex);
+        while (!aoa->stopped && cbuf_is_empty(&aoa->queue)) {
+            sc_cond_wait(&aoa->event_cond, &aoa->mutex);
+        }
+        if (aoa->stopped) {
+            // Stop immediately, do not process further events
+            sc_mutex_unlock(&aoa->mutex);
+            break;
+        }
+        struct sc_hid_event event;
+        bool non_empty = cbuf_take(&aoa->queue, &event);
+        assert(non_empty);
+        (void) non_empty;
+
+        assert(event.delay >= 0);
+        if (event.delay) {
+            // Wait during the specified delay before injecting the HID event
+            sc_tick deadline = sc_tick_now() + event.delay;
+            bool timed_out = false;
+            while (!aoa->stopped && !timed_out) {
+                timed_out = !sc_cond_timedwait(&aoa->event_cond, &aoa->mutex,
+                                               deadline);
+            }
+            if (aoa->stopped) {
+                sc_mutex_unlock(&aoa->mutex);
+                break;
+            }
+        }
+
+        sc_mutex_unlock(&aoa->mutex);
+
+        bool ok = sc_aoa_send_hid_event(aoa, &event);
+        sc_hid_event_destroy(&event);
+        if (!ok) {
+            LOGW("Could not send HID event to USB device");
+        }
+    }
+    return 0;
+}
+
+bool
+sc_aoa_start(struct sc_aoa *aoa) {
+    LOGD("Starting AOA thread");
+
+    bool ok = sc_thread_create(&aoa->thread, run_aoa_thread, "aoa_thread", aoa);
+    if (!ok) {
+        LOGC("Could not start AOA thread");
+        return false;
+    }
+
+    return true;
+}
+
+void
+sc_aoa_stop(struct sc_aoa *aoa) {
+    sc_mutex_lock(&aoa->mutex);
+    aoa->stopped = true;
+    sc_cond_signal(&aoa->event_cond);
+    sc_mutex_unlock(&aoa->mutex);
+}
+
+void
+sc_aoa_join(struct sc_aoa *aoa) {
+    sc_thread_join(&aoa->thread, NULL);
+}

app/src/aoa_hid.h

@@ -0,0 +1,66 @@
+#ifndef SC_AOA_HID_H
+#define SC_AOA_HID_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <libusb-1.0/libusb.h>
+
+#include "util/cbuf.h"
+#include "util/thread.h"
+#include "util/tick.h"
+
+struct sc_hid_event {
+    uint16_t accessory_id;
+    unsigned char *buffer;
+    uint16_t size;
+    sc_tick delay;
+};
+
+// Takes ownership of buffer
+void
+sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
+                  unsigned char *buffer, uint16_t buffer_size);
+
+void
+sc_hid_event_destroy(struct sc_hid_event *hid_event);
+
+struct sc_hid_event_queue CBUF(struct sc_hid_event, 64);
+
+struct sc_aoa {
+    libusb_context *usb_context;
+    libusb_device *usb_device;
+    libusb_device_handle *usb_handle;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond event_cond;
+    bool stopped;
+    struct sc_hid_event_queue queue;
+};
+
+bool
+sc_aoa_init(struct sc_aoa *aoa, const char *serial);
+
+void
+sc_aoa_destroy(struct sc_aoa *aoa);
+
+bool
+sc_aoa_start(struct sc_aoa *aoa);
+
+void
+sc_aoa_stop(struct sc_aoa *aoa);
+
+void
+sc_aoa_join(struct sc_aoa *aoa);
+
+bool
+sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
+              const unsigned char *report_desc, uint16_t report_desc_size);
+
+bool
+sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id);
+
+bool
+sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event);
+
+#endif

app/src/cli.h

@@ -5,7 +5,7 @@
 
 #include <stdbool.h>
 
-#include "scrcpy.h"
+#include "options.h"
 
 struct scrcpy_cli_args {
     struct scrcpy_options opts;

app/src/clock.c

@@ -0,0 +1,111 @@
+#include "clock.h"
+
+#include "util/log.h"
+
+#define SC_CLOCK_NDEBUG // comment to debug
+
+void
+sc_clock_init(struct sc_clock *clock) {
+    clock->count = 0;
+    clock->head = 0;
+    clock->left_sum.system = 0;
+    clock->left_sum.stream = 0;
+    clock->right_sum.system = 0;
+    clock->right_sum.stream = 0;
+}
+
+// Estimate the affine function f(stream) = slope * stream + offset
+static void
+sc_clock_estimate(struct sc_clock *clock,
+                  double *out_slope, sc_tick *out_offset) {
+    assert(clock->count > 1); // two points are necessary
+
+    struct sc_clock_point left_avg = {
+        .system = clock->left_sum.system / (clock->count / 2),
+        .stream = clock->left_sum.stream / (clock->count / 2),
+    };
+    struct sc_clock_point right_avg = {
+        .system = clock->right_sum.system / ((clock->count + 1) / 2),
+        .stream = clock->right_sum.stream / ((clock->count + 1) / 2),
+    };
+
+    double slope = (double) (right_avg.system - left_avg.system)
+                 / (right_avg.stream - left_avg.stream);
+
+    if (clock->count < SC_CLOCK_RANGE) {
+        /* The first frames are typically received and decoded with more delay
+         * than the others, causing a wrong slope estimation on start. To
+         * compensate, assume an initial slope of 1, then progressively use the
+         * estimated slope. */
+        slope = (clock->count * slope + (SC_CLOCK_RANGE - clock->count))
+              / SC_CLOCK_RANGE;
+    }
+
+    struct sc_clock_point global_avg = {
+        .system = (clock->left_sum.system + clock->right_sum.system)
+                 / clock->count,
+        .stream = (clock->left_sum.stream + clock->right_sum.stream)
+                 / clock->count,
+    };
+
+    sc_tick offset = global_avg.system - (sc_tick) (global_avg.stream * slope);
+
+    *out_slope = slope;
+    *out_offset = offset;
+}
+
+void
+sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
+    struct sc_clock_point *point = &clock->points[clock->head];
+
+    if (clock->count == SC_CLOCK_RANGE || clock->count & 1) {
+        // One point passes from the right sum to the left sum
+
+        unsigned mid;
+        if (clock->count == SC_CLOCK_RANGE) {
+            mid = (clock->head + SC_CLOCK_RANGE / 2) % SC_CLOCK_RANGE;
+        } else {
+            // Only for the first frames
+            mid = clock->count / 2;
+        }
+
+        struct sc_clock_point *mid_point = &clock->points[mid];
+        clock->left_sum.system += mid_point->system;
+        clock->left_sum.stream += mid_point->stream;
+        clock->right_sum.system -= mid_point->system;
+        clock->right_sum.stream -= mid_point->stream;
+    }
+
+    if (clock->count == SC_CLOCK_RANGE) {
+        // The current point overwrites the previous value in the circular
+        // array, update the left sum accordingly
+        clock->left_sum.system -= point->system;
+        clock->left_sum.stream -= point->stream;
+    } else {
+        ++clock->count;
+    }
+
+    point->system = system;
+    point->stream = stream;
+
+    clock->right_sum.system += system;
+    clock->right_sum.stream += stream;
+
+    clock->head = (clock->head + 1) % SC_CLOCK_RANGE;
+
+    if (clock->count > 1) {
+        // Update estimation
+        sc_clock_estimate(clock, &clock->slope, &clock->offset);
+
+#ifndef SC_CLOCK_NDEBUG
+        LOGD("Clock estimation: %g * pts + %" PRItick,
+             clock->slope, clock->offset);
+#endif
+    }
+}
+
+sc_tick
+sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream) {
+    assert(clock->count > 1); // sc_clock_update() must have been called
+    return (sc_tick) (stream * clock->slope) + clock->offset;
+}

app/src/clock.h

@@ -0,0 +1,70 @@
+#ifndef SC_CLOCK_H
+#define SC_CLOCK_H
+
+#include "common.h"
+
+#include <assert.h>
+
+#include "util/tick.h"
+
+#define SC_CLOCK_RANGE 32
+static_assert(!(SC_CLOCK_RANGE & 1), "SC_CLOCK_RANGE must be even");
+
+struct sc_clock_point {
+    sc_tick system;
+    sc_tick stream;
+};
+
+/**
+ * The clock aims to estimate the affine relation between the stream (device)
+ * time and the system time:
+ *
+ *     f(stream) = slope * stream + offset
+ *
+ * To that end, it stores the SC_CLOCK_RANGE last clock points (the timestamps
+ * of a frame expressed both in stream time and system time) in a circular
+ * array.
+ *
+ * To estimate the slope, it splits the last SC_CLOCK_RANGE points into two
+ * sets of SC_CLOCK_RANGE/2 points, and computes their centroid ("average
+ * point"). The slope of the estimated affine function is that of the line
+ * passing through these two points.
+ *
+ * To estimate the offset, it computes the centroid of all the SC_CLOCK_RANGE
+ * points. The resulting affine function passes by this centroid.
+ *
+ * With a circular array, the rolling sums (and average) are quick to compute.
+ * In practice, the estimation is stable and the evolution is smooth.
+ */
+struct sc_clock {
+    // Circular array
+    struct sc_clock_point points[SC_CLOCK_RANGE];
+
+    // Number of points in the array (count <= SC_CLOCK_RANGE)
+    unsigned count;
+
+    // Index of the next point to write
+    unsigned head;
+
+    // Sum of the first count/2 points
+    struct sc_clock_point left_sum;
+
+    // Sum of the last (count+1)/2 points
+    struct sc_clock_point right_sum;
+
+    // Estimated slope and offset
+    // (computed on sc_clock_update(), used by sc_clock_to_system_time())
+    double slope;
+    sc_tick offset;
+};
+
+void
+sc_clock_init(struct sc_clock *clock);
+
+void
+sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream);
+
+sc_tick
+sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream);
+
+#endif

app/src/compat.h

@@ -43,6 +43,11 @@
 # define SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
 #endif
 
+#if SDL_VERSION_ATLEAST(2, 0, 6)
+// <https://github.com/libsdl-org/SDL/commit/d7a318de563125e5bb465b1000d6bc9576fbc6fc>
+# define SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
+#endif
+
 #if SDL_VERSION_ATLEAST(2, 0, 8)
 // <https://hg.libsdl.org/SDL/rev/dfde5d3f9781>
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR

app/src/control_msg.c

@@ -7,7 +7,7 @@
 
 #include "util/buffer_util.h"
 #include "util/log.h"
-#include "util/str_util.h"
+#include "util/str.h"
 
 /**
  * Map an enum value to a string based on an array, without crashing on an
@@ -56,7 +56,7 @@ static const char *const screen_power_mode_labels[] = {
 };
 
 static void
-write_position(uint8_t *buf, const struct position *position) {
+write_position(uint8_t *buf, const struct sc_position *position) {
     buffer_write32be(&buf[0], position->point.x);
     buffer_write32be(&buf[4], position->point.y);
     buffer_write16be(&buf[8], position->screen_size.width);
@@ -66,7 +66,7 @@ write_position(uint8_t *buf, const struct position *position) {
 // write length (2 bytes) + string (non nul-terminated)
 static size_t
 write_string(const char *utf8, size_t max_len, unsigned char *buf) {
-    size_t len = utf8_truncation_index(utf8, max_len);
+    size_t len = sc_str_utf8_truncation_index(utf8, max_len);
     buffer_write32be(buf, len);
     memcpy(&buf[4], utf8, len);
     return 4 + len;

app/src/control_msg.h

@@ -57,11 +57,11 @@ struct control_msg {
             enum android_motionevent_action action;
             enum android_motionevent_buttons buttons;
             uint64_t pointer_id;
-            struct position position;
+            struct sc_position position;
             float pressure;
         } inject_touch_event;
         struct {
-            struct position position;
+            struct sc_position position;
             int32_t hscroll;
             int32_t vscroll;
         } inject_scroll_event;

app/src/controller.c

@@ -5,7 +5,7 @@
 #include "util/log.h"
 
 bool
-controller_init(struct controller *controller, socket_t control_socket) {
+controller_init(struct controller *controller, sc_socket control_socket) {
     cbuf_init(&controller->queue);
 
     bool ok = receiver_init(&controller->receiver, control_socket);
@@ -63,14 +63,14 @@ controller_push_msg(struct controller *controller,
 }
 
 static bool
-process_msg(struct controller *controller,
-              const struct control_msg *msg) {
+process_msg(struct controller *controller, const struct control_msg *msg) {
     static unsigned char serialized_msg[CONTROL_MSG_MAX_SIZE];
     size_t length = control_msg_serialize(msg, serialized_msg);
     if (!length) {
         return false;
     }
-    int w = net_send_all(controller->control_socket, serialized_msg, length);
+    ssize_t w =
+        net_send_all(controller->control_socket, serialized_msg, length);
     return (size_t) w == length;
 }
 

app/src/controller.h

@@ -14,7 +14,7 @@
 struct control_msg_queue CBUF(struct control_msg, 64);
 
 struct controller {
-    socket_t control_socket;
+    sc_socket control_socket;
     sc_thread thread;
     sc_mutex mutex;
     sc_cond msg_cond;
@@ -24,7 +24,7 @@ struct controller {
 };
 
 bool
-controller_init(struct controller *controller, socket_t control_socket);
+controller_init(struct controller *controller, sc_socket control_socket);
 
 void
 controller_destroy(struct controller *controller);

app/src/coords.h

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

app/src/decoder.c

@@ -1,5 +1,6 @@
 #include "decoder.h"
 
+#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 
 #include "events.h"

app/src/event_converter.h

@@ -1,30 +0,0 @@
-#ifndef CONVERT_H
-#define CONVERT_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <SDL2/SDL_events.h>
-
-#include "control_msg.h"
-
-bool
-convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to);
-
-enum android_metastate
-convert_meta_state(SDL_Keymod mod);
-
-bool
-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
-                bool prefer_text);
-
-enum android_motionevent_buttons
-convert_mouse_buttons(uint32_t state);
-
-bool
-convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to);
-
-bool
-convert_touch_action(SDL_EventType from, enum android_motionevent_action *to);
-
-#endif

app/src/events.h

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

app/src/file_handler.c

@@ -5,6 +5,7 @@
 
 #include "adb.h"
 #include "util/log.h"
+#include "util/process_intr.h"
 
 #define DEFAULT_PUSH_TARGET "/sdcard/Download/"
 
@@ -16,6 +17,7 @@ file_handler_request_destroy(struct file_handler_request *req) {
 bool
 file_handler_init(struct file_handler *file_handler, const char *serial,
                   const char *push_target) {
+    assert(serial);
 
     cbuf_init(&file_handler->queue);
 
@@ -30,23 +32,26 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
         return false;
     }
 
-    if (serial) {
+    ok = sc_intr_init(&file_handler->intr);
+    if (!ok) {
+        LOGE("Could not create intr");
+        sc_cond_destroy(&file_handler->event_cond);
+        sc_mutex_destroy(&file_handler->mutex);
+    }
+
     file_handler->serial = strdup(serial);
     if (!file_handler->serial) {
-            LOGW("Could not strdup serial");
+        LOGE("Could not strdup serial");
+        sc_intr_destroy(&file_handler->intr);
         sc_cond_destroy(&file_handler->event_cond);
         sc_mutex_destroy(&file_handler->mutex);
         return false;
     }
-    } else {
-        file_handler->serial = NULL;
-    }
 
     // lazy initialization
     file_handler->initialized = false;
 
     file_handler->stopped = false;
-    file_handler->current_process = PROCESS_NONE;
 
     file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
 
@@ -57,6 +62,7 @@ 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;
@@ -65,16 +71,6 @@ file_handler_destroy(struct file_handler *file_handler) {
     }
 }
 
-static process_t
-install_apk(const char *serial, const char *file) {
-    return adb_install(serial, file);
-}
-
-static process_t
-push_file(const char *serial, const char *file, const char *push_target) {
-    return adb_push(serial, file, push_target);
-}
-
 bool
 file_handler_request(struct file_handler *file_handler,
                      file_handler_action_t action, char *file) {
@@ -106,10 +102,16 @@ file_handler_request(struct file_handler *file_handler,
 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);
-        file_handler->current_process = PROCESS_NONE;
         while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
             sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
         }
@@ -122,43 +124,28 @@ run_file_handler(void *data) {
         bool non_empty = cbuf_take(&file_handler->queue, &req);
         assert(non_empty);
         (void) non_empty;
-
-        process_t process;
-        if (req.action == ACTION_INSTALL_APK) {
-            LOGI("Installing %s...", req.file);
-            process = install_apk(file_handler->serial, req.file);
-        } else {
-            LOGI("Pushing %s...", req.file);
-            process = push_file(file_handler->serial, req.file,
-                                file_handler->push_target);
-        }
-        file_handler->current_process = process;
         sc_mutex_unlock(&file_handler->mutex);
 
         if (req.action == ACTION_INSTALL_APK) {
-            if (process_check_success(process, "adb install", false)) {
+            LOGI("Installing %s...", req.file);
+            bool ok = adb_install(intr, serial, req.file,
+                                  SC_INHERIT_STDOUT | SC_INHERIT_STDERR);
+            if (ok) {
                 LOGI("%s successfully installed", req.file);
             } else {
                 LOGE("Failed to install %s", req.file);
             }
         } else {
-            if (process_check_success(process, "adb push", false)) {
-                LOGI("%s successfully pushed to %s", req.file,
-                                                     file_handler->push_target);
+            LOGI("Pushing %s...", req.file);
+            bool ok = adb_push(intr, serial, req.file, push_target,
+                               SC_INHERIT_STDOUT | SC_INHERIT_STDERR);
+            if (ok) {
+                LOGI("%s successfully pushed to %s", req.file, push_target);
             } else {
-                LOGE("Failed to push %s to %s", req.file,
-                                                file_handler->push_target);
+                LOGE("Failed to push %s to %s", req.file, push_target);
             }
         }
 
-        sc_mutex_lock(&file_handler->mutex);
-        // Close the process (it is necessary already terminated)
-        // Execute this call with mutex locked to avoid race conditions with
-        // file_handler_stop()
-        process_close(file_handler->current_process);
-        file_handler->current_process = PROCESS_NONE;
-        sc_mutex_unlock(&file_handler->mutex);
-
         file_handler_request_destroy(&req);
     }
     return 0;
@@ -183,11 +170,7 @@ 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);
-    if (file_handler->current_process != PROCESS_NONE) {
-        if (!process_terminate(file_handler->current_process)) {
-            LOGW("Could not terminate push/install process");
-        }
-    }
+    sc_intr_interrupt(&file_handler->intr);
     sc_mutex_unlock(&file_handler->mutex);
 }
 

app/src/file_handler.h

@@ -8,6 +8,7 @@
 #include "adb.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
+#include "util/intr.h"
 
 typedef enum {
     ACTION_INSTALL_APK,
@@ -29,8 +30,9 @@ struct file_handler {
     sc_cond event_cond;
     bool stopped;
     bool initialized;
-    process_t current_process;
     struct file_handler_request_queue queue;
+
+    struct sc_intr intr;
 };
 
 bool

app/src/fps_counter.c

@@ -1,11 +1,10 @@
 #include "fps_counter.h"
 
 #include <assert.h>
-#include <SDL2/SDL_timer.h>
 
 #include "util/log.h"
 
-#define FPS_COUNTER_INTERVAL_MS 1000
+#define FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1)
 
 bool
 fps_counter_init(struct fps_counter *counter) {
@@ -47,7 +46,7 @@ set_started(struct fps_counter *counter, bool started) {
 static void
 display_fps(struct fps_counter *counter) {
     unsigned rendered_per_second =
-        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;
+        counter->nr_rendered * SC_TICK_FREQ / FPS_COUNTER_INTERVAL;
     if (counter->nr_skipped) {
         LOGI("%u fps (+%u frames skipped)", rendered_per_second,
                                             counter->nr_skipped);
@@ -68,8 +67,8 @@ check_interval_expired(struct fps_counter *counter, uint32_t now) {
     counter->nr_skipped = 0;
     // add a multiple of the interval
     uint32_t elapsed_slices =
-        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL_MS + 1;
-    counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;
+        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL + 1;
+    counter->next_timestamp += FPS_COUNTER_INTERVAL * elapsed_slices;
 }
 
 static int
@@ -82,14 +81,12 @@ run_fps_counter(void *data) {
             sc_cond_wait(&counter->state_cond, &counter->mutex);
         }
         while (!counter->interrupted && is_started(counter)) {
-            uint32_t now = SDL_GetTicks();
+            sc_tick now = sc_tick_now();
             check_interval_expired(counter, now);
 
-            assert(counter->next_timestamp > now);
-            uint32_t remaining = counter->next_timestamp - now;
-
             // ignore the reason (timeout or signaled), we just loop anyway
-            sc_cond_timedwait(&counter->state_cond, &counter->mutex, remaining);
+            sc_cond_timedwait(&counter->state_cond, &counter->mutex,
+                              counter->next_timestamp);
         }
     }
     sc_mutex_unlock(&counter->mutex);
@@ -99,7 +96,7 @@ run_fps_counter(void *data) {
 bool
 fps_counter_start(struct fps_counter *counter) {
     sc_mutex_lock(&counter->mutex);
-    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
+    counter->next_timestamp = sc_tick_now() + FPS_COUNTER_INTERVAL;
     counter->nr_rendered = 0;
     counter->nr_skipped = 0;
     sc_mutex_unlock(&counter->mutex);
@@ -165,7 +162,7 @@ fps_counter_add_rendered_frame(struct fps_counter *counter) {
     }
 
     sc_mutex_lock(&counter->mutex);
-    uint32_t now = SDL_GetTicks();
+    sc_tick now = sc_tick_now();
     check_interval_expired(counter, now);
     ++counter->nr_rendered;
     sc_mutex_unlock(&counter->mutex);
@@ -178,7 +175,7 @@ fps_counter_add_skipped_frame(struct fps_counter *counter) {
     }
 
     sc_mutex_lock(&counter->mutex);
-    uint32_t now = SDL_GetTicks();
+    sc_tick now = sc_tick_now();
     check_interval_expired(counter, now);
     ++counter->nr_skipped;
     sc_mutex_unlock(&counter->mutex);

app/src/fps_counter.h

@@ -24,7 +24,7 @@ struct fps_counter {
     bool interrupted;
     unsigned nr_rendered;
     unsigned nr_skipped;
-    uint32_t next_timestamp;
+    sc_tick next_timestamp;
 };
 
 bool

app/src/frame_buffer.c

@@ -0,0 +1,88 @@
+#include "frame_buffer.h"
+
+#include <assert.h>
+#include <libavutil/avutil.h>
+#include <libavformat/avformat.h>
+
+#include "util/log.h"
+
+bool
+sc_frame_buffer_init(struct sc_frame_buffer *fb) {
+    fb->pending_frame = av_frame_alloc();
+    if (!fb->pending_frame) {
+        return false;
+    }
+
+    fb->tmp_frame = av_frame_alloc();
+    if (!fb->tmp_frame) {
+        av_frame_free(&fb->pending_frame);
+        return false;
+    }
+
+    bool ok = sc_mutex_init(&fb->mutex);
+    if (!ok) {
+        av_frame_free(&fb->pending_frame);
+        av_frame_free(&fb->tmp_frame);
+        return false;
+    }
+
+    // there is initially no frame, so consider it has already been consumed
+    fb->pending_frame_consumed = true;
+
+    return true;
+}
+
+void
+sc_frame_buffer_destroy(struct sc_frame_buffer *fb) {
+    sc_mutex_destroy(&fb->mutex);
+    av_frame_free(&fb->pending_frame);
+    av_frame_free(&fb->tmp_frame);
+}
+
+static inline void
+swap_frames(AVFrame **lhs, AVFrame **rhs) {
+    AVFrame *tmp = *lhs;
+    *lhs = *rhs;
+    *rhs = tmp;
+}
+
+bool
+sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
+                  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);
+    if (r) {
+        LOGE("Could not ref frame: %d", r);
+        return false;
+    }
+
+    // Now that av_frame_ref() succeeded, we can replace the previous
+    // pending_frame
+    swap_frames(&fb->pending_frame, &fb->tmp_frame);
+    av_frame_unref(fb->tmp_frame);
+
+    if (previous_frame_skipped) {
+        *previous_frame_skipped = !fb->pending_frame_consumed;
+    }
+    fb->pending_frame_consumed = false;
+
+    sc_mutex_unlock(&fb->mutex);
+
+    return true;
+}
+
+void
+sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst) {
+    sc_mutex_lock(&fb->mutex);
+    assert(!fb->pending_frame_consumed);
+    fb->pending_frame_consumed = true;
+
+    av_frame_move_ref(dst, fb->pending_frame);
+    // av_frame_move_ref() resets its source frame, so no need to call
+    // av_frame_unref()
+
+    sc_mutex_unlock(&fb->mutex);
+}

app/src/frame_buffer.h

@@ -0,0 +1,44 @@
+#ifndef SC_FRAME_BUFFER_H
+#define SC_FRAME_BUFFER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "util/thread.h"
+
+// forward declarations
+typedef struct AVFrame AVFrame;
+
+/**
+ * A frame buffer holds 1 pending frame, which is the last frame received from
+ * the producer (typically, the decoder).
+ *
+ * If a pending frame has not been consumed when the producer pushes a new
+ * frame, then it is lost. The intent is to always provide access to the very
+ * last frame to minimize latency.
+ */
+
+struct sc_frame_buffer {
+    AVFrame *pending_frame;
+    AVFrame *tmp_frame; // To preserve the pending frame on error
+
+    sc_mutex mutex;
+
+    bool pending_frame_consumed;
+};
+
+bool
+sc_frame_buffer_init(struct sc_frame_buffer *fb);
+
+void
+sc_frame_buffer_destroy(struct sc_frame_buffer *fb);
+
+bool
+sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
+                     bool *skipped);
+
+void
+sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst);
+
+#endif

app/src/hid_keyboard.c

@@ -0,0 +1,363 @@
+#include "hid_keyboard.h"
+
+#include <assert.h>
+#include <SDL2/SDL_events.h>
+
+#include "util/log.h"
+
+/** Downcast key processor to hid_keyboard */
+#define DOWNCAST(KP) container_of(KP, struct sc_hid_keyboard, key_processor)
+
+#define HID_KEYBOARD_ACCESSORY_ID 1
+
+#define HID_MODIFIER_NONE 0x00
+#define HID_MODIFIER_LEFT_CONTROL (1 << 0)
+#define HID_MODIFIER_LEFT_SHIFT (1 << 1)
+#define HID_MODIFIER_LEFT_ALT (1 << 2)
+#define HID_MODIFIER_LEFT_GUI (1 << 3)
+#define HID_MODIFIER_RIGHT_CONTROL (1 << 4)
+#define HID_MODIFIER_RIGHT_SHIFT (1 << 5)
+#define HID_MODIFIER_RIGHT_ALT (1 << 6)
+#define HID_MODIFIER_RIGHT_GUI (1 << 7)
+
+#define HID_KEYBOARD_INDEX_MODIFIER 0
+#define HID_KEYBOARD_INDEX_KEYS 2
+
+// USB HID protocol says 6 keys in an event is the requirement for BIOS
+// keyboard support, though OS could support more keys via modifying the report
+// desc. 6 should be enough for scrcpy.
+#define HID_KEYBOARD_MAX_KEYS 6
+#define HID_KEYBOARD_EVENT_SIZE (2 + HID_KEYBOARD_MAX_KEYS)
+
+#define HID_RESERVED 0x00
+#define HID_ERROR_ROLL_OVER 0x01
+
+/**
+ * For HID over AOAv2, only report descriptor is needed.
+ *
+ * The specification is available here:
+ * <https://www.usb.org/sites/default/files/hid1_11.pdf>
+ *
+ * In particular, read:
+ *  - 6.2.2 Report Descriptor
+ *  - Appendix B.1 Protocol 1 (Keyboard)
+ *  - Appendix C: Keyboard Implementation
+ *
+ * Normally a basic HID keyboard uses 8 bytes:
+ *     Modifier Reserved Key Key Key Key Key Key
+ *
+ * You can dump your device's report descriptor with:
+ *
+ *     sudo usbhid-dump -m vid:pid -e descriptor
+ *
+ * (change vid:pid' to your device's vendor ID and product ID).
+ */
+static const unsigned char keyboard_report_desc[]  = {
+    // Usage Page (Generic Desktop)
+    0x05, 0x01,
+    // Usage (Keyboard)
+    0x09, 0x06,
+
+    // Collection (Application)
+    0xA1, 0x01,
+
+    // Usage Page (Key Codes)
+    0x05, 0x07,
+    // Usage Minimum (224)
+    0x19, 0xE0,
+     // Usage Maximum (231)
+    0x29, 0xE7,
+    // Logical Minimum (0)
+    0x15, 0x00,
+    // Logical Maximum (1)
+    0x25, 0x01,
+    // Report Size (1)
+    0x75, 0x01,
+    // Report Count (8)
+    0x95, 0x08,
+    // Input (Data, Variable, Absolute): Modifier byte
+    0x81, 0x02,
+
+    // Report Size (8)
+    0x75, 0x08,
+    // Report Count (1)
+    0x95, 0x01,
+    // Input (Constant): Reserved byte
+    0x81, 0x01,
+
+    // Usage Page (LEDs)
+    0x05, 0x08,
+    // Usage Minimum (1)
+    0x19, 0x01,
+    // Usage Maximum (5)
+    0x29, 0x05,
+    // Report Size (1)
+    0x75, 0x01,
+    // Report Count (5)
+    0x95, 0x05,
+    // Output (Data, Variable, Absolute): LED report
+    0x91, 0x02,
+
+    // Report Size (3)
+    0x75, 0x03,
+    // Report Count (1)
+    0x95, 0x01,
+    // Output (Constant): LED report padding
+    0x91, 0x01,
+
+    // Usage Page (Key Codes)
+    0x05, 0x07,
+    // Usage Minimum (0)
+    0x19, 0x00,
+    // Usage Maximum (101)
+    0x29, SC_HID_KEYBOARD_KEYS - 1,
+    // Logical Minimum (0)
+    0x15, 0x00,
+    // Logical Maximum(101)
+    0x25, SC_HID_KEYBOARD_KEYS - 1,
+    // Report Size (8)
+    0x75, 0x08,
+    // Report Count (6)
+    0x95, HID_KEYBOARD_MAX_KEYS,
+    // Input (Data, Array): Keys
+    0x81, 0x00,
+
+    // End Collection
+    0xC0
+};
+
+static unsigned char
+sdl_keymod_to_hid_modifiers(SDL_Keymod mod) {
+    unsigned char modifiers = HID_MODIFIER_NONE;
+    if (mod & KMOD_LCTRL) {
+        modifiers |= HID_MODIFIER_LEFT_CONTROL;
+    }
+    if (mod & KMOD_LSHIFT) {
+        modifiers |= HID_MODIFIER_LEFT_SHIFT;
+    }
+    if (mod & KMOD_LALT) {
+        modifiers |= HID_MODIFIER_LEFT_ALT;
+    }
+    if (mod & KMOD_LGUI) {
+        modifiers |= HID_MODIFIER_LEFT_GUI;
+    }
+    if (mod & KMOD_RCTRL) {
+        modifiers |= HID_MODIFIER_RIGHT_CONTROL;
+    }
+    if (mod & KMOD_RSHIFT) {
+        modifiers |= HID_MODIFIER_RIGHT_SHIFT;
+    }
+    if (mod & KMOD_RALT) {
+        modifiers |= HID_MODIFIER_RIGHT_ALT;
+    }
+    if (mod & KMOD_RGUI) {
+        modifiers |= HID_MODIFIER_RIGHT_GUI;
+    }
+    return modifiers;
+}
+
+static bool
+sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) {
+    unsigned char *buffer = malloc(HID_KEYBOARD_EVENT_SIZE);
+    if (!buffer) {
+        return false;
+    }
+
+    buffer[HID_KEYBOARD_INDEX_MODIFIER] = HID_MODIFIER_NONE;
+    buffer[1] = HID_RESERVED;
+    memset(&buffer[HID_KEYBOARD_INDEX_KEYS], 0, HID_KEYBOARD_MAX_KEYS);
+
+    sc_hid_event_init(hid_event, HID_KEYBOARD_ACCESSORY_ID, buffer,
+                      HID_KEYBOARD_EVENT_SIZE);
+    return true;
+}
+
+static inline bool
+scancode_is_modifier(SDL_Scancode scancode) {
+    return scancode >= SDL_SCANCODE_LCTRL && scancode <= SDL_SCANCODE_RGUI;
+}
+
+static bool
+convert_hid_keyboard_event(struct sc_hid_keyboard *kb,
+                           struct sc_hid_event *hid_event,
+                           const SDL_KeyboardEvent *event) {
+    SDL_Scancode scancode = event->keysym.scancode;
+    assert(scancode >= 0);
+
+    // SDL also generates events when only modifiers are pressed, we cannot
+    // ignore them totally, for example press 'a' first then press 'Control',
+    // if we ignore 'Control' event, only 'a' is sent.
+    if (scancode >= SC_HID_KEYBOARD_KEYS && !scancode_is_modifier(scancode)) {
+        // Scancode to ignore
+        return false;
+    }
+
+    if (!sc_hid_keyboard_event_init(hid_event)) {
+        LOGW("Could not initialize HID keyboard event");
+        return false;
+    }
+
+    unsigned char modifiers = sdl_keymod_to_hid_modifiers(event->keysym.mod);
+
+    if (scancode < SC_HID_KEYBOARD_KEYS) {
+        // Pressed is true and released is false
+        kb->keys[scancode] = (event->type == SDL_KEYDOWN);
+        LOGV("keys[%02x] = %s", scancode,
+             kb->keys[scancode] ? "true" : "false");
+    }
+
+    hid_event->buffer[HID_KEYBOARD_INDEX_MODIFIER] = modifiers;
+
+    unsigned char *keys_buffer = &hid_event->buffer[HID_KEYBOARD_INDEX_KEYS];
+    // Re-calculate pressed keys every time
+    int keys_pressed_count = 0;
+    for (int i = 0; i < SC_HID_KEYBOARD_KEYS; ++i) {
+        if (kb->keys[i]) {
+            // USB HID protocol says that if keys exceeds report count, a
+            // phantom state should be reported
+            if (keys_pressed_count >= HID_KEYBOARD_MAX_KEYS) {
+                // Pantom state:
+                //  - Modifiers
+                //  - Reserved
+                //  - ErrorRollOver * HID_MAX_KEYS
+                memset(keys_buffer, HID_ERROR_ROLL_OVER, HID_KEYBOARD_MAX_KEYS);
+                goto end;
+            }
+
+            keys_buffer[keys_pressed_count] = i;
+            ++keys_pressed_count;
+        }
+    }
+
+end:
+    LOGV("hid keyboard: key %-4s scancode=%02x (%u) mod=%02x",
+         event->type == SDL_KEYDOWN ? "down" : "up", event->keysym.scancode,
+         event->keysym.scancode, modifiers);
+
+    return true;
+}
+
+
+static bool
+push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) {
+    bool capslock = sdl_mod & KMOD_CAPS;
+    bool numlock = sdl_mod & KMOD_NUM;
+    if (!capslock && !numlock) {
+        // Nothing to do
+        return true;
+    }
+
+    struct sc_hid_event hid_event;
+    if (!sc_hid_keyboard_event_init(&hid_event)) {
+        LOGW("Could not initialize HID keyboard event");
+        return false;
+    }
+
+#define SC_SCANCODE_CAPSLOCK SDL_SCANCODE_CAPSLOCK
+#define SC_SCANCODE_NUMLOCK SDL_SCANCODE_NUMLOCKCLEAR
+    unsigned i = 0;
+    if (capslock) {
+        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;
+        ++i;
+    }
+    if (numlock) {
+        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_NUMLOCK;
+        ++i;
+    }
+
+    if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
+        sc_hid_event_destroy(&hid_event);
+        LOGW("Could request HID event");
+        return false;
+    }
+
+    LOGD("HID keyboard state synchronized");
+
+    return true;
+}
+
+static void
+sc_key_processor_process_key(struct sc_key_processor *kp,
+                             const SDL_KeyboardEvent *event) {
+    if (event->repeat) {
+        // In USB HID protocol, key repeat is handled by the host (Android), so
+        // just ignore key repeat here.
+        return;
+    }
+
+    struct sc_hid_keyboard *kb = DOWNCAST(kp);
+
+    struct sc_hid_event hid_event;
+    // Not all keys are supported, just ignore unsupported keys
+    if (convert_hid_keyboard_event(kb, &hid_event, event)) {
+        if (!kb->mod_lock_synchronized) {
+            // Inject CAPSLOCK and/or NUMLOCK if necessary to synchronize
+            // keyboard state
+            if (push_mod_lock_state(kb, event->keysym.mod)) {
+                kb->mod_lock_synchronized = true;
+            }
+        }
+
+        SDL_Keycode keycode = event->keysym.sym;
+        bool down = event->type == SDL_KEYDOWN;
+        bool ctrl = event->keysym.mod & KMOD_CTRL;
+        bool shift = event->keysym.mod & KMOD_SHIFT;
+        if (ctrl && !shift && keycode == SDLK_v && down) {
+            // Ctrl+v is pressed, so clipboard synchronization has been
+            // requested. Wait a bit so that the clipboard is set before
+            // injecting Ctrl+v via HID, otherwise it would paste the old
+            // clipboard content.
+            hid_event.delay = SC_TICK_FROM_MS(5);
+        }
+
+        if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
+            sc_hid_event_destroy(&hid_event);
+            LOGW("Could request HID event");
+        }
+    }
+}
+
+static void
+sc_key_processor_process_text(struct sc_key_processor *kp,
+                              const SDL_TextInputEvent *event) {
+    (void) kp;
+    (void) event;
+
+    // Never forward text input via HID (all the keys are injected separately)
+}
+
+bool
+sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa) {
+    kb->aoa = aoa;
+
+    bool ok = sc_aoa_setup_hid(aoa, HID_KEYBOARD_ACCESSORY_ID,
+                               keyboard_report_desc,
+                               ARRAY_LEN(keyboard_report_desc));
+    if (!ok) {
+        LOGW("Register HID keyboard failed");
+        return false;
+    }
+
+    // Reset all states
+    memset(kb->keys, false, SC_HID_KEYBOARD_KEYS);
+
+    kb->mod_lock_synchronized = false;
+
+    static const struct sc_key_processor_ops ops = {
+        .process_key = sc_key_processor_process_key,
+        .process_text = sc_key_processor_process_text,
+    };
+
+    kb->key_processor.ops = &ops;
+
+    return true;
+}
+
+void
+sc_hid_keyboard_destroy(struct sc_hid_keyboard *kb) {
+    // Unregister HID keyboard so the soft keyboard shows again on Android
+    bool ok = sc_aoa_unregister_hid(kb->aoa, HID_KEYBOARD_ACCESSORY_ID);
+    if (!ok) {
+        LOGW("Could not unregister HID keyboard");
+    }
+}

app/src/hid_keyboard.h

@@ -0,0 +1,44 @@
+#ifndef SC_HID_KEYBOARD_H
+#define SC_HID_KEYBOARD_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "aoa_hid.h"
+#include "trait/key_processor.h"
+
+// See "SDL2/SDL_scancode.h".
+// Maybe SDL_Keycode is used by most people, but SDL_Scancode is taken from USB
+// HID protocol.
+// 0x65 is Application, typically AT-101 Keyboard ends here.
+#define SC_HID_KEYBOARD_KEYS 0x66
+
+/**
+ * HID keyboard events are sequence-based, every time keyboard state changes
+ * it sends an array of currently pressed keys, the host is responsible for
+ * compare events and determine which key becomes pressed and which key becomes
+ * released. In order to convert SDL_KeyboardEvent to HID events, we first use
+ * an array of keys to save each keys' state. And when a SDL_KeyboardEvent was
+ * emitted, we updated our state, and then we use a loop to generate HID
+ * events. The sequence of array elements is unimportant and when too much keys
+ * pressed at the same time (more than report count), we should generate
+ * phantom state. Don't forget that modifiers should be updated too, even for
+ * phantom state.
+ */
+struct sc_hid_keyboard {
+    struct sc_key_processor key_processor; // key processor trait
+
+    struct sc_aoa *aoa;
+    bool keys[SC_HID_KEYBOARD_KEYS];
+
+    bool mod_lock_synchronized;
+};
+
+bool
+sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa);
+
+void
+sc_hid_keyboard_destroy(struct sc_hid_keyboard *kb);
+
+#endif

app/src/icon.c

@@ -0,0 +1,290 @@
+#include "icon.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <libavformat/avformat.h>
+#include <libavutil/pixdesc.h>
+#include <libavutil/pixfmt.h>
+
+#include "config.h"
+#include "compat.h"
+#include "util/file.h"
+#include "util/log.h"
+#include "util/str.h"
+
+#define SCRCPY_PORTABLE_ICON_FILENAME "icon.png"
+#define SCRCPY_DEFAULT_ICON_PATH \
+    PREFIX "/share/icons/hicolor/256x256/apps/scrcpy.png"
+
+static char *
+get_icon_path(void) {
+#ifdef __WINDOWS__
+    const wchar_t *icon_path_env = _wgetenv(L"SCRCPY_ICON_PATH");
+#else
+    const char *icon_path_env = getenv("SCRCPY_ICON_PATH");
+#endif
+    if (icon_path_env) {
+        // if the envvar is set, use it
+#ifdef __WINDOWS__
+        char *icon_path = sc_str_from_wchars(icon_path_env);
+#else
+        char *icon_path = strdup(icon_path_env);
+#endif
+        if (!icon_path) {
+            LOGE("Could not allocate memory");
+            return NULL;
+        }
+        LOGD("Using SCRCPY_ICON_PATH: %s", icon_path);
+        return icon_path;
+    }
+
+#ifndef PORTABLE
+    LOGD("Using icon: " SCRCPY_DEFAULT_ICON_PATH);
+    char *icon_path = strdup(SCRCPY_DEFAULT_ICON_PATH);
+    if (!icon_path) {
+        LOGE("Could not allocate memory");
+        return NULL;
+    }
+#else
+    char *icon_path = sc_file_get_local_path(SCRCPY_PORTABLE_ICON_FILENAME);
+    if (!icon_path) {
+        LOGE("Could not get icon path");
+        return NULL;
+    }
+    LOGD("Using icon (portable): %s", icon_path);
+#endif
+
+    return icon_path;
+}
+
+static AVFrame *
+decode_image(const char *path) {
+    AVFrame *result = NULL;
+
+    AVFormatContext *ctx = avformat_alloc_context();
+    if (!ctx) {
+        LOGE("Could not allocate image decoder context");
+        return NULL;
+    }
+
+    if (avformat_open_input(&ctx, path, NULL, NULL) < 0) {
+        LOGE("Could not open image codec: %s", path);
+        goto free_ctx;
+    }
+
+    if (avformat_find_stream_info(ctx, NULL) < 0) {
+        LOGE("Could not find image stream info");
+        goto close_input;
+    }
+
+    int stream = av_find_best_stream(ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
+    if (stream < 0 ) {
+        LOGE("Could not find best image stream");
+        goto close_input;
+    }
+
+    AVCodecParameters *params = ctx->streams[stream]->codecpar;
+
+    AVCodec *codec = avcodec_find_decoder(params->codec_id);
+    if (!codec) {
+        LOGE("Could not find image decoder");
+        goto close_input;
+    }
+
+    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
+    if (!codec_ctx) {
+        LOGE("Could not allocate codec context");
+        goto close_input;
+    }
+
+    if (avcodec_parameters_to_context(codec_ctx, params) < 0) {
+        LOGE("Could not fill codec context");
+        goto free_codec_ctx;
+    }
+
+    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
+        LOGE("Could not open image codec");
+        goto free_codec_ctx;
+    }
+
+    AVFrame *frame = av_frame_alloc();
+    if (!frame) {
+        LOGE("Could not allocate frame");
+        goto close_codec;
+    }
+
+    AVPacket *packet = av_packet_alloc();
+    if (!packet) {
+        LOGE("Could not allocate packet");
+        av_frame_free(&frame);
+        goto close_codec;
+    }
+
+    if (av_read_frame(ctx, packet) < 0) {
+        LOGE("Could not read frame");
+        av_packet_free(&packet);
+        av_frame_free(&frame);
+        goto close_codec;
+    }
+
+    int ret;
+    if ((ret = avcodec_send_packet(codec_ctx, packet)) < 0) {
+        LOGE("Could not send icon packet: %d", ret);
+        av_packet_free(&packet);
+        av_frame_free(&frame);
+        goto close_codec;
+    }
+
+    if ((ret = avcodec_receive_frame(codec_ctx, frame)) != 0) {
+        LOGE("Could not receive icon frame: %d", ret);
+        av_packet_free(&packet);
+        av_frame_free(&frame);
+        goto close_codec;
+    }
+
+    av_packet_free(&packet);
+
+    result = frame;
+
+close_codec:
+    avcodec_close(codec_ctx);
+free_codec_ctx:
+    avcodec_free_context(&codec_ctx);
+close_input:
+    avformat_close_input(&ctx);
+free_ctx:
+    avformat_free_context(ctx);
+
+    return result;
+}
+
+#if !SDL_VERSION_ATLEAST(2, 0, 10)
+// SDL_PixelFormatEnum has been introduced in SDL 2.0.10. Use int for older SDL
+// versions.
+typedef int SDL_PixelFormatEnum;
+#endif
+
+static SDL_PixelFormatEnum
+to_sdl_pixel_format(enum AVPixelFormat fmt) {
+    switch (fmt) {
+        case AV_PIX_FMT_RGB24: return SDL_PIXELFORMAT_RGB24;
+        case AV_PIX_FMT_BGR24: return SDL_PIXELFORMAT_BGR24;
+        case AV_PIX_FMT_ARGB: return SDL_PIXELFORMAT_ARGB32;
+        case AV_PIX_FMT_RGBA: return SDL_PIXELFORMAT_RGBA32;
+        case AV_PIX_FMT_ABGR: return SDL_PIXELFORMAT_ABGR32;
+        case AV_PIX_FMT_BGRA: return SDL_PIXELFORMAT_BGRA32;
+        case AV_PIX_FMT_RGB565BE: return SDL_PIXELFORMAT_RGB565;
+        case AV_PIX_FMT_RGB555BE: return SDL_PIXELFORMAT_RGB555;
+        case AV_PIX_FMT_BGR565BE: return SDL_PIXELFORMAT_BGR565;
+        case AV_PIX_FMT_BGR555BE: return SDL_PIXELFORMAT_BGR555;
+        case AV_PIX_FMT_RGB444BE: return SDL_PIXELFORMAT_RGB444;
+#if SDL_VERSION_ATLEAST(2, 0, 12)
+        case AV_PIX_FMT_BGR444BE: return SDL_PIXELFORMAT_BGR444;
+#endif
+        case AV_PIX_FMT_PAL8: return SDL_PIXELFORMAT_INDEX8;
+        default: return SDL_PIXELFORMAT_UNKNOWN;
+    }
+}
+
+static SDL_Surface *
+load_from_path(const char *path) {
+    AVFrame *frame = decode_image(path);
+    if (!frame) {
+        return NULL;
+    }
+
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
+    if (!desc) {
+        LOGE("Could not get icon format descriptor");
+        goto error;
+    }
+
+    bool is_packed = !(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
+    if (!is_packed) {
+        LOGE("Could not load non-packed icon");
+        goto error;
+    }
+
+    SDL_PixelFormatEnum format = to_sdl_pixel_format(frame->format);
+    if (format == SDL_PIXELFORMAT_UNKNOWN) {
+        LOGE("Unsupported icon pixel format: %s (%d)", desc->name,
+                                                       frame->format);
+        goto error;
+    }
+
+    int bits_per_pixel = av_get_bits_per_pixel(desc);
+    SDL_Surface *surface =
+        SDL_CreateRGBSurfaceWithFormatFrom(frame->data[0],
+                                           frame->width, frame->height,
+                                           bits_per_pixel,
+                                           frame->linesize[0],
+                                           format);
+
+    if (!surface) {
+        LOGE("Could not create icon surface");
+        goto error;
+    }
+
+    if (frame->format == AV_PIX_FMT_PAL8) {
+        // Initialize the SDL palette
+        uint8_t *data = frame->data[1];
+        SDL_Color colors[256];
+        for (int i = 0; i < 256; ++i) {
+            SDL_Color *color = &colors[i];
+
+            // The palette is transported in AVFrame.data[1], is 1024 bytes
+            // long (256 4-byte entries) and is formatted the same as in
+            // AV_PIX_FMT_RGB32 described above (i.e., it is also
+            // endian-specific).
+            // <https://ffmpeg.org/doxygen/4.1/pixfmt_8h.html#a9a8e335cf3be472042bc9f0cf80cd4c5>
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+            color->a = data[i * 4];
+            color->r = data[i * 4 + 1];
+            color->g = data[i * 4 + 2];
+            color->b = data[i * 4 + 3];
+#else
+            color->a = data[i * 4 + 3];
+            color->r = data[i * 4 + 2];
+            color->g = data[i * 4 + 1];
+            color->b = data[i * 4];
+#endif
+        }
+
+        SDL_Palette *palette = surface->format->palette;
+        assert(palette);
+        int ret = SDL_SetPaletteColors(palette, colors, 0, 256);
+        if (ret) {
+            LOGE("Could not set palette colors");
+            SDL_FreeSurface(surface);
+            goto error;
+        }
+    }
+
+    surface->userdata = frame; // frame owns the data
+
+    return surface;
+
+error:
+    av_frame_free(&frame);
+    return NULL;
+}
+
+SDL_Surface *
+scrcpy_icon_load() {
+    char *icon_path = get_icon_path();
+    if (!icon_path) {
+        return NULL;
+    }
+
+    SDL_Surface *icon = load_from_path(icon_path);
+    free(icon_path);
+    return icon;
+}
+
+void
+scrcpy_icon_destroy(SDL_Surface *icon) {
+    AVFrame *frame = icon->userdata;
+    assert(frame);
+    av_frame_free(&frame);
+    SDL_FreeSurface(icon);
+}

app/src/icon.h

@@ -0,0 +1,16 @@
+#ifndef ICON_H
+#define ICON_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <SDL2/SDL.h>
+#include <libavformat/avformat.h>
+
+SDL_Surface *
+scrcpy_icon_load(void);
+
+void
+scrcpy_icon_destroy(SDL_Surface *icon);
+
+#endif

app/src/icon.xpm

@@ -1,53 +0,0 @@
-/* XPM */
-static char * icon_xpm[] = {
-"48 48 2 1",
-" 	c None",
-".	c #96C13E",
-"              ..                ..              ",
-"              ...              ...              ",
-"               ...   ......   ...               ",
-"                ................                ",
-"                 ..............                 ",
-"                ................                ",
-"               ..................               ",
-"              ....................              ",
-"             .....  ........  .....             ",
-"             .....  ........  .....             ",
-"             ......................             ",
-"            ........................            ",
-"            ........................            ",
-"            ........................            ",
-"                                                ",
-"                                                ",
-"     ....   ........................   ....     ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"     ....   ........................   ....     ",
-"            ........................            ",
-"             ......................             ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                 ....      ....                 "};

app/src/input_manager.c

@@ -3,7 +3,6 @@
 #include <assert.h>
 #include <SDL2/SDL_keycode.h>
 
-#include "event_converter.h"
 #include "util/log.h"
 
 static const int ACTION_DOWN = 1;
@@ -53,15 +52,18 @@ is_shortcut_mod(struct input_manager *im, uint16_t sdl_mod) {
 
 void
 input_manager_init(struct input_manager *im, struct controller *controller,
-                   struct screen *screen,
+                   struct screen *screen, struct sc_key_processor *kp,
+                   struct sc_mouse_processor *mp,
                    const struct scrcpy_options *options) {
+    assert(!options->control || (kp && kp->ops));
+    assert(!options->control || (mp && mp->ops));
+
     im->controller = controller;
     im->screen = screen;
-    im->repeat = 0;
+    im->kp = kp;
+    im->mp = mp;
 
     im->control = options->control;
-    im->forward_key_repeat = options->forward_key_repeat;
-    im->prefer_text = options->prefer_text;
     im->forward_all_clicks = options->forward_all_clicks;
     im->legacy_paste = options->legacy_paste;
 
@@ -323,32 +325,14 @@ input_manager_process_text_input(struct input_manager *im,
         // A shortcut must never generate text events
         return;
     }
-    if (!im->prefer_text) {
-        char c = event->text[0];
-        if (isalpha(c) || c == ' ') {
-            assert(event->text[1] == '\0');
-            // letters and space are handled as raw key event
-            return;
-        }
-    }
 
-    struct control_msg msg;
-    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 (!controller_push_msg(im->controller, &msg)) {
-        free(msg.inject_text.text);
-        LOGW("Could not request 'inject text'");
-    }
+    im->kp->ops->process_text(im->kp, event);
 }
 
 static bool
 simulate_virtual_finger(struct input_manager *im,
                         enum android_motionevent_action action,
-                        struct point point) {
+                        struct sc_point point) {
     bool up = action == AMOTION_EVENT_ACTION_UP;
 
     struct control_msg msg;
@@ -368,34 +352,13 @@ simulate_virtual_finger(struct input_manager *im,
     return true;
 }
 
-static struct point
-inverse_point(struct point point, struct size size) {
+static struct sc_point
+inverse_point(struct sc_point point, struct sc_size size) {
     point.x = size.width - point.x;
     point.y = size.height - point.y;
     return point;
 }
 
-static bool
-convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
-                  bool prefer_text, uint32_t repeat) {
-    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
-
-    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
-        return false;
-    }
-
-    uint16_t mod = from->keysym.mod;
-    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod,
-                         prefer_text)) {
-        return false;
-    }
-
-    to->inject_keycode.repeat = repeat;
-    to->inject_keycode.metastate = convert_meta_state(mod);
-
-    return true;
-}
-
 static void
 input_manager_process_key(struct input_manager *im,
                           const SDL_KeyboardEvent *event) {
@@ -549,15 +512,6 @@ input_manager_process_key(struct input_manager *im,
         return;
     }
 
-    if (event->repeat) {
-        if (!im->forward_key_repeat) {
-            return;
-        }
-        ++im->repeat;
-    } else {
-        im->repeat = 0;
-    }
-
     if (ctrl && !shift && keycode == SDLK_v && down && !repeat) {
         if (im->legacy_paste) {
             // inject the text as input events
@@ -569,27 +523,7 @@ input_manager_process_key(struct input_manager *im,
         set_device_clipboard(controller, false);
     }
 
-    struct control_msg msg;
-    if (convert_input_key(event, &msg, im->prefer_text, im->repeat)) {
-        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'inject keycode'");
-        }
-    }
-}
-
-static bool
-convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
-                     struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
-        screen_convert_window_to_frame_coords(screen, from->x, from->y);
-    to->inject_touch_event.pressure = 1.f;
-    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
-
-    return true;
+    im->kp->ops->process_key(im->kp, event);
 }
 
 static void
@@ -607,79 +541,22 @@ input_manager_process_mouse_motion(struct input_manager *im,
         // simulated from touch events, so it's a duplicate
         return;
     }
-    struct control_msg msg;
-    if (!convert_mouse_motion(event, im->screen, &msg)) {
-        return;
-    }
 
-    if (!controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request 'inject mouse motion event'");
-    }
+    im->mp->ops->process_mouse_motion(im->mp, event);
 
     if (im->vfinger_down) {
-        struct point mouse = msg.inject_touch_event.position.point;
-        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
+        struct sc_point mouse =
+            screen_convert_window_to_frame_coords(im->screen, event->x,
+                                                  event->y);
+        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
         simulate_virtual_finger(im, AMOTION_EVENT_ACTION_MOVE, vfinger);
     }
 }
 
-static bool
-convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
-              struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-
-    if (!convert_touch_action(from->type, &to->inject_touch_event.action)) {
-        return false;
-    }
-
-    to->inject_touch_event.pointer_id = from->fingerId;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-
-    int dw;
-    int dh;
-    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
-
-    // SDL touch event coordinates are normalized in the range [0; 1]
-    int32_t x = from->x * dw;
-    int32_t y = from->y * dh;
-    to->inject_touch_event.position.point =
-        screen_convert_drawable_to_frame_coords(screen, x, y);
-
-    to->inject_touch_event.pressure = from->pressure;
-    to->inject_touch_event.buttons = 0;
-    return true;
-}
-
 static void
 input_manager_process_touch(struct input_manager *im,
                             const SDL_TouchFingerEvent *event) {
-    struct control_msg msg;
-    if (convert_touch(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject touch event'");
-        }
-    }
-}
-
-static bool
-convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
-                     struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-
-    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
-        return false;
-    }
-
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
-        screen_convert_window_to_frame_coords(screen, from->x, from->y);
-    to->inject_touch_event.pressure =
-        from->type == SDL_MOUSEBUTTONDOWN ? 1.f : 0.f;
-    to->inject_touch_event.buttons =
-        convert_mouse_buttons(SDL_BUTTON(from->button));
-
-    return true;
+    im->mp->ops->process_touch(im->mp, event);
 }
 
 static void
@@ -739,15 +616,7 @@ input_manager_process_mouse_button(struct input_manager *im,
         return;
     }
 
-    struct control_msg msg;
-    if (!convert_mouse_button(event, im->screen, &msg)) {
-        return;
-    }
-
-    if (!controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request 'inject mouse button event'");
-        return;
-    }
+    im->mp->ops->process_mouse_button(im->mp, event);
 
     // Pinch-to-zoom simulation.
     //
@@ -761,8 +630,10 @@ input_manager_process_mouse_button(struct input_manager *im,
 #define CTRL_PRESSED (SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL))
     if ((down && !im->vfinger_down && CTRL_PRESSED)
             || (!down && im->vfinger_down)) {
-        struct point mouse = msg.inject_touch_event.position.point;
-        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
+        struct sc_point mouse =
+            screen_convert_window_to_frame_coords(im->screen, event->x,
+                                                              event->y);
+        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
         enum android_motionevent_action action = down
                                                ? AMOTION_EVENT_ACTION_DOWN
                                                : AMOTION_EVENT_ACTION_UP;
@@ -773,39 +644,10 @@ input_manager_process_mouse_button(struct input_manager *im,
     }
 }
 
-static bool
-convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
-                    struct control_msg *to) {
-
-    // mouse_x and mouse_y are expressed in pixels relative to the window
-    int mouse_x;
-    int mouse_y;
-    SDL_GetMouseState(&mouse_x, &mouse_y);
-
-    struct position position = {
-        .screen_size = screen->frame_size,
-        .point = screen_convert_window_to_frame_coords(screen,
-                                                       mouse_x, mouse_y),
-    };
-
-    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
-
-    to->inject_scroll_event.position = position;
-    to->inject_scroll_event.hscroll = from->x;
-    to->inject_scroll_event.vscroll = from->y;
-
-    return true;
-}
-
 static void
 input_manager_process_mouse_wheel(struct input_manager *im,
                                   const SDL_MouseWheelEvent *event) {
-    struct control_msg msg;
-    if (convert_mouse_wheel(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject mouse wheel event'");
-        }
-    }
+    im->mp->ops->process_mouse_wheel(im->mp, event);
 }
 
 bool

app/src/input_manager.h

@@ -9,20 +9,19 @@
 
 #include "controller.h"
 #include "fps_counter.h"
-#include "scrcpy.h"
+#include "options.h"
 #include "screen.h"
+#include "trait/key_processor.h"
+#include "trait/mouse_processor.h"
 
 struct input_manager {
     struct controller *controller;
     struct screen *screen;
 
-    // SDL reports repeated events as a boolean, but Android expects the actual
-    // number of repetitions. This variable keeps track of the count.
-    unsigned repeat;
+    struct sc_key_processor *kp;
+    struct sc_mouse_processor *mp;
 
     bool control;
-    bool forward_key_repeat;
-    bool prefer_text;
     bool forward_all_clicks;
     bool legacy_paste;
 
@@ -43,7 +42,9 @@ struct input_manager {
 
 void
 input_manager_init(struct input_manager *im, struct controller *controller,
-                   struct screen *screen, const struct scrcpy_options *options);
+                   struct screen *screen, struct sc_key_processor *kp,
+                   struct sc_mouse_processor *mp,
+                   const struct scrcpy_options *options);
 
 bool
 input_manager_handle_event(struct input_manager *im, SDL_Event *event);

app/src/keyboard_inject.c

@@ -1,9 +1,20 @@
-#include "event_converter.h"
+#include "keyboard_inject.h"
+
+#include <assert.h>
+#include <SDL2/SDL_events.h>
+
+#include "android/input.h"
+#include "control_msg.h"
+#include "controller.h"
+#include "util/log.h"
+
+/** Downcast key processor to sc_keyboard_inject */
+#define DOWNCAST(KP) \
+    container_of(KP, struct sc_keyboard_inject, key_processor)
 
 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false
-
-bool
+static bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
     switch (from) {
         MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
@@ -12,67 +23,7 @@ convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
     }
 }
 
-static enum android_metastate
-autocomplete_metastate(enum android_metastate metastate) {
-    // fill dependent flags
-    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
-        metastate |= AMETA_SHIFT_ON;
-    }
-    if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
-        metastate |= AMETA_CTRL_ON;
-    }
-    if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
-        metastate |= AMETA_ALT_ON;
-    }
-    if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
-        metastate |= AMETA_META_ON;
-    }
-
-    return metastate;
-}
-
-enum android_metastate
-convert_meta_state(SDL_Keymod mod) {
-    enum android_metastate metastate = 0;
-    if (mod & KMOD_LSHIFT) {
-        metastate |= AMETA_SHIFT_LEFT_ON;
-    }
-    if (mod & KMOD_RSHIFT) {
-        metastate |= AMETA_SHIFT_RIGHT_ON;
-    }
-    if (mod & KMOD_LCTRL) {
-        metastate |= AMETA_CTRL_LEFT_ON;
-    }
-    if (mod & KMOD_RCTRL) {
-        metastate |= AMETA_CTRL_RIGHT_ON;
-    }
-    if (mod & KMOD_LALT) {
-        metastate |= AMETA_ALT_LEFT_ON;
-    }
-    if (mod & KMOD_RALT) {
-        metastate |= AMETA_ALT_RIGHT_ON;
-    }
-    if (mod & KMOD_LGUI) { // Windows key
-        metastate |= AMETA_META_LEFT_ON;
-    }
-    if (mod & KMOD_RGUI) { // Windows key
-        metastate |= AMETA_META_RIGHT_ON;
-    }
-    if (mod & KMOD_NUM) {
-        metastate |= AMETA_NUM_LOCK_ON;
-    }
-    if (mod & KMOD_CAPS) {
-        metastate |= AMETA_CAPS_LOCK_ON;
-    }
-    if (mod & KMOD_MODE) { // Alt Gr
-        // no mapping?
-    }
-
-    // fill the dependent fields
-    return autocomplete_metastate(metastate);
-}
-
-bool
+static bool
 convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
                 bool prefer_text) {
     switch (from) {
@@ -154,42 +105,150 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
     }
 }
 
-enum android_motionevent_buttons
-convert_mouse_buttons(uint32_t state) {
-    enum android_motionevent_buttons buttons = 0;
-    if (state & SDL_BUTTON_LMASK) {
-        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
+static enum android_metastate
+autocomplete_metastate(enum android_metastate metastate) {
+    // fill dependent flags
+    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
+        metastate |= AMETA_SHIFT_ON;
     }
-    if (state & SDL_BUTTON_RMASK) {
-        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
+    if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
+        metastate |= AMETA_CTRL_ON;
     }
-    if (state & SDL_BUTTON_MMASK) {
-        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
+    if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
+        metastate |= AMETA_ALT_ON;
     }
-    if (state & SDL_BUTTON_X1MASK) {
-        buttons |= AMOTION_EVENT_BUTTON_BACK;
-    }
-    if (state & SDL_BUTTON_X2MASK) {
-        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
-    }
-    return buttons;
+    if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
+        metastate |= AMETA_META_ON;
     }
 
-bool
-convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
-    switch (from) {
-        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
-        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
-        FAIL;
+    return metastate;
+}
+
+static enum android_metastate
+convert_meta_state(SDL_Keymod mod) {
+    enum android_metastate metastate = 0;
+    if (mod & KMOD_LSHIFT) {
+        metastate |= AMETA_SHIFT_LEFT_ON;
+    }
+    if (mod & KMOD_RSHIFT) {
+        metastate |= AMETA_SHIFT_RIGHT_ON;
+    }
+    if (mod & KMOD_LCTRL) {
+        metastate |= AMETA_CTRL_LEFT_ON;
+    }
+    if (mod & KMOD_RCTRL) {
+        metastate |= AMETA_CTRL_RIGHT_ON;
+    }
+    if (mod & KMOD_LALT) {
+        metastate |= AMETA_ALT_LEFT_ON;
+    }
+    if (mod & KMOD_RALT) {
+        metastate |= AMETA_ALT_RIGHT_ON;
+    }
+    if (mod & KMOD_LGUI) { // Windows key
+        metastate |= AMETA_META_LEFT_ON;
+    }
+    if (mod & KMOD_RGUI) { // Windows key
+        metastate |= AMETA_META_RIGHT_ON;
+    }
+    if (mod & KMOD_NUM) {
+        metastate |= AMETA_NUM_LOCK_ON;
+    }
+    if (mod & KMOD_CAPS) {
+        metastate |= AMETA_CAPS_LOCK_ON;
+    }
+    if (mod & KMOD_MODE) { // Alt Gr
+        // no mapping?
+    }
+
+    // fill the dependent fields
+    return autocomplete_metastate(metastate);
+}
+
+static bool
+convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
+                  bool prefer_text, uint32_t repeat) {
+    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
+
+    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
+        return false;
+    }
+
+    uint16_t mod = from->keysym.mod;
+    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod,
+                         prefer_text)) {
+        return false;
+    }
+
+    to->inject_keycode.repeat = repeat;
+    to->inject_keycode.metastate = convert_meta_state(mod);
+
+    return true;
+}
+
+static void
+sc_key_processor_process_key(struct sc_key_processor *kp,
+                             const SDL_KeyboardEvent *event) {
+    struct sc_keyboard_inject *ki = DOWNCAST(kp);
+
+    if (event->repeat) {
+        if (!ki->forward_key_repeat) {
+            return;
+        }
+        ++ki->repeat;
+    } else {
+        ki->repeat = 0;
+    }
+
+    struct control_msg msg;
+    if (convert_input_key(event, &msg, ki->prefer_text, ki->repeat)) {
+        if (!controller_push_msg(ki->controller, &msg)) {
+            LOGW("Could not request 'inject keycode'");
+        }
     }
 }
 
-bool
-convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
-    switch (from) {
-        MAP(SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE);
-        MAP(SDL_FINGERDOWN,   AMOTION_EVENT_ACTION_DOWN);
-        MAP(SDL_FINGERUP,     AMOTION_EVENT_ACTION_UP);
-        FAIL;
+static void
+sc_key_processor_process_text(struct sc_key_processor *kp,
+                              const SDL_TextInputEvent *event) {
+    struct sc_keyboard_inject *ki = DOWNCAST(kp);
+
+    if (!ki->prefer_text) {
+        char c = event->text[0];
+        if (isalpha(c) || c == ' ') {
+            assert(event->text[1] == '\0');
+            // letters and space are handled as raw key event
+            return;
         }
     }
+
+    struct control_msg msg;
+    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 (!controller_push_msg(ki->controller, &msg)) {
+        free(msg.inject_text.text);
+        LOGW("Could not request 'inject text'");
+    }
+}
+
+void
+sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
+                        struct controller *controller,
+                        const struct scrcpy_options *options) {
+    ki->controller = controller;
+    ki->prefer_text = options->prefer_text;
+    ki->forward_key_repeat = options->forward_key_repeat;
+
+    ki->repeat = 0;
+
+    static const struct sc_key_processor_ops ops = {
+        .process_key = sc_key_processor_process_key,
+        .process_text = sc_key_processor_process_text,
+    };
+
+    ki->key_processor.ops = &ops;
+}

app/src/keyboard_inject.h

@@ -0,0 +1,30 @@
+#ifndef SC_KEYBOARD_INJECT_H
+#define SC_KEYBOARD_INJECT_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "controller.h"
+#include "options.h"
+#include "trait/key_processor.h"
+
+struct sc_keyboard_inject {
+    struct sc_key_processor key_processor; // key processor trait
+
+    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.
+    unsigned repeat;
+
+    bool prefer_text;
+    bool forward_key_repeat;
+};
+
+void
+sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
+                        struct controller *controller,
+                        const struct scrcpy_options *options);
+
+#endif

app/src/main.c

@@ -1,5 +1,3 @@
-#include "scrcpy.h"
-
 #include "common.h"
 
 #include <assert.h>
@@ -13,6 +11,8 @@
 #include <SDL2/SDL.h>
 
 #include "cli.h"
+#include "options.h"
+#include "scrcpy.h"
 #include "util/log.h"
 
 static void
@@ -47,8 +47,11 @@ main(int argc, char *argv[]) {
     setbuf(stderr, NULL);
 #endif
 
+    printf("scrcpy " SCRCPY_VERSION
+           " <https://github.com/Genymobile/scrcpy>\n");
+
     struct scrcpy_cli_args args = {
-        .opts = SCRCPY_OPTIONS_DEFAULT,
+        .opts = scrcpy_options_default,
         .help = false,
         .version = false,
     };
@@ -73,8 +76,6 @@ main(int argc, char *argv[]) {
         return 0;
     }
 
-    LOGI("scrcpy " SCRCPY_VERSION " <https://github.com/Genymobile/scrcpy>");
-
 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
     av_register_all();
 #endif

app/src/mouse_inject.c

@@ -0,0 +1,211 @@
+#include "mouse_inject.h"
+
+#include <assert.h>
+#include <SDL2/SDL_events.h>
+
+#include "android/input.h"
+#include "control_msg.h"
+#include "controller.h"
+#include "util/log.h"
+
+/** Downcast mouse processor to sc_mouse_inject */
+#define DOWNCAST(MP) container_of(MP, struct sc_mouse_inject, mouse_processor)
+
+static enum android_motionevent_buttons
+convert_mouse_buttons(uint32_t state) {
+    enum android_motionevent_buttons buttons = 0;
+    if (state & SDL_BUTTON_LMASK) {
+        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
+    }
+    if (state & SDL_BUTTON_RMASK) {
+        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
+    }
+    if (state & SDL_BUTTON_MMASK) {
+        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
+    }
+    if (state & SDL_BUTTON_X1MASK) {
+        buttons |= AMOTION_EVENT_BUTTON_BACK;
+    }
+    if (state & SDL_BUTTON_X2MASK) {
+        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
+    }
+    return buttons;
+}
+
+#define MAP(FROM, TO) case FROM: *to = TO; return true
+#define FAIL default: return false
+static bool
+convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
+    switch (from) {
+        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
+        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
+        FAIL;
+    }
+}
+
+static bool
+convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
+    switch (from) {
+        MAP(SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE);
+        MAP(SDL_FINGERDOWN,   AMOTION_EVENT_ACTION_DOWN);
+        MAP(SDL_FINGERUP,     AMOTION_EVENT_ACTION_UP);
+        FAIL;
+    }
+}
+
+static bool
+convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
+                     struct control_msg *to) {
+    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
+    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
+    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
+    to->inject_touch_event.position.screen_size = screen->frame_size;
+    to->inject_touch_event.position.point =
+        screen_convert_window_to_frame_coords(screen, from->x, from->y);
+    to->inject_touch_event.pressure = 1.f;
+    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
+
+    return true;
+}
+
+static bool
+convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
+              struct control_msg *to) {
+    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
+
+    if (!convert_touch_action(from->type, &to->inject_touch_event.action)) {
+        return false;
+    }
+
+    to->inject_touch_event.pointer_id = from->fingerId;
+    to->inject_touch_event.position.screen_size = screen->frame_size;
+
+    int dw;
+    int dh;
+    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
+
+    // SDL touch event coordinates are normalized in the range [0; 1]
+    int32_t x = from->x * dw;
+    int32_t y = from->y * dh;
+    to->inject_touch_event.position.point =
+        screen_convert_drawable_to_frame_coords(screen, x, y);
+
+    to->inject_touch_event.pressure = from->pressure;
+    to->inject_touch_event.buttons = 0;
+    return true;
+}
+
+static bool
+convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
+                     struct control_msg *to) {
+    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
+
+    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
+        return false;
+    }
+
+    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
+    to->inject_touch_event.position.screen_size = screen->frame_size;
+    to->inject_touch_event.position.point =
+        screen_convert_window_to_frame_coords(screen, from->x, from->y);
+    to->inject_touch_event.pressure =
+        from->type == SDL_MOUSEBUTTONDOWN ? 1.f : 0.f;
+    to->inject_touch_event.buttons =
+        convert_mouse_buttons(SDL_BUTTON(from->button));
+
+    return true;
+}
+
+static bool
+convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
+                    struct control_msg *to) {
+
+    // mouse_x and mouse_y are expressed in pixels relative to the window
+    int mouse_x;
+    int mouse_y;
+    SDL_GetMouseState(&mouse_x, &mouse_y);
+
+    struct sc_position position = {
+        .screen_size = screen->frame_size,
+        .point = screen_convert_window_to_frame_coords(screen,
+                                                       mouse_x, mouse_y),
+    };
+
+    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
+
+    to->inject_scroll_event.position = position;
+    to->inject_scroll_event.hscroll = from->x;
+    to->inject_scroll_event.vscroll = from->y;
+
+    return true;
+}
+
+static void
+sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
+                                        const SDL_MouseMotionEvent *event) {
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
+
+    struct control_msg msg;
+    if (!convert_mouse_motion(event, mi->screen, &msg)) {
+        return;
+    }
+
+    if (!controller_push_msg(mi->controller, &msg)) {
+        LOGW("Could not request 'inject mouse motion event'");
+    }
+}
+
+static void
+sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
+                                 const SDL_TouchFingerEvent *event) {
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
+
+    struct control_msg msg;
+    if (convert_touch(event, mi->screen, &msg)) {
+        if (!controller_push_msg(mi->controller, &msg)) {
+            LOGW("Could not request 'inject touch event'");
+        }
+    }
+}
+
+static void
+sc_mouse_processor_process_mouse_button(struct sc_mouse_processor *mp,
+                                        const SDL_MouseButtonEvent *event) {
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
+
+    struct control_msg msg;
+    if (convert_mouse_button(event, mi->screen, &msg)) {
+        if (!controller_push_msg(mi->controller, &msg)) {
+            LOGW("Could not request 'inject mouse button event'");
+        }
+    }
+}
+
+static void
+sc_mouse_processor_process_mouse_wheel(struct sc_mouse_processor *mp,
+                                       const SDL_MouseWheelEvent *event) {
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
+
+    struct control_msg msg;
+    if (convert_mouse_wheel(event, mi->screen, &msg)) {
+        if (!controller_push_msg(mi->controller, &msg)) {
+            LOGW("Could not request 'inject mouse wheel event'");
+        }
+    }
+}
+
+void
+sc_mouse_inject_init(struct sc_mouse_inject *mi, struct controller *controller,
+                     struct screen *screen) {
+    mi->controller = controller;
+    mi->screen = screen;
+
+    static const struct sc_mouse_processor_ops ops = {
+        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
+        .process_touch = sc_mouse_processor_process_touch,
+        .process_mouse_button = sc_mouse_processor_process_mouse_button,
+        .process_mouse_wheel = sc_mouse_processor_process_mouse_wheel,
+    };
+
+    mi->mouse_processor.ops = &ops;
+}

app/src/mouse_inject.h

@@ -0,0 +1,23 @@
+#ifndef SC_MOUSE_INJECT_H
+#define SC_MOUSE_INJECT_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "controller.h"
+#include "screen.h"
+#include "trait/mouse_processor.h"
+
+struct sc_mouse_inject {
+    struct sc_mouse_processor mouse_processor; // mouse processor trait
+
+    struct controller *controller;
+    struct screen *screen;
+};
+
+void
+sc_mouse_inject_init(struct sc_mouse_inject *mi, struct controller *controller,
+                     struct screen *screen);
+
+#endif

app/src/options.c

@@ -0,0 +1,54 @@
+#include "options.h"
+
+const struct scrcpy_options scrcpy_options_default = {
+    .serial = NULL,
+    .crop = NULL,
+    .record_filename = NULL,
+    .window_title = NULL,
+    .push_target = NULL,
+    .render_driver = NULL,
+    .codec_options = NULL,
+    .encoder_name = NULL,
+#ifdef HAVE_V4L2
+    .v4l2_device = NULL,
+#endif
+    .log_level = SC_LOG_LEVEL_INFO,
+    .record_format = SC_RECORD_FORMAT_AUTO,
+    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
+    .port_range = {
+        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
+        .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
+    },
+    .shortcut_mods = {
+        .data = {SC_MOD_LALT, SC_MOD_LSUPER},
+        .count = 2,
+    },
+    .max_size = 0,
+    .bit_rate = DEFAULT_BIT_RATE,
+    .max_fps = 0,
+    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
+    .rotation = 0,
+    .window_x = SC_WINDOW_POSITION_UNDEFINED,
+    .window_y = SC_WINDOW_POSITION_UNDEFINED,
+    .window_width = 0,
+    .window_height = 0,
+    .display_id = 0,
+    .display_buffer = 0,
+    .v4l2_buffer = 0,
+    .show_touches = false,
+    .fullscreen = false,
+    .always_on_top = false,
+    .control = true,
+    .display = true,
+    .turn_screen_off = false,
+    .prefer_text = false,
+    .window_borderless = false,
+    .mipmaps = true,
+    .stay_awake = false,
+    .force_adb_forward = false,
+    .disable_screensaver = false,
+    .forward_key_repeat = true,
+    .forward_all_clicks = false,
+    .legacy_paste = false,
+    .power_off_on_close = false,
+};

app/src/options.h

@@ -0,0 +1,113 @@
+#ifndef SCRCPY_OPTIONS_H
+#define SCRCPY_OPTIONS_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "util/tick.h"
+
+enum sc_log_level {
+    SC_LOG_LEVEL_VERBOSE,
+    SC_LOG_LEVEL_DEBUG,
+    SC_LOG_LEVEL_INFO,
+    SC_LOG_LEVEL_WARN,
+    SC_LOG_LEVEL_ERROR,
+};
+
+enum sc_record_format {
+    SC_RECORD_FORMAT_AUTO,
+    SC_RECORD_FORMAT_MP4,
+    SC_RECORD_FORMAT_MKV,
+};
+
+enum sc_lock_video_orientation {
+    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
+    // lock the current orientation when scrcpy starts
+    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
+    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
+    SC_LOCK_VIDEO_ORIENTATION_1,
+    SC_LOCK_VIDEO_ORIENTATION_2,
+    SC_LOCK_VIDEO_ORIENTATION_3,
+};
+
+enum sc_keyboard_input_mode {
+    SC_KEYBOARD_INPUT_MODE_INJECT,
+    SC_KEYBOARD_INPUT_MODE_HID,
+};
+
+#define SC_MAX_SHORTCUT_MODS 8
+
+enum sc_shortcut_mod {
+    SC_MOD_LCTRL = 1 << 0,
+    SC_MOD_RCTRL = 1 << 1,
+    SC_MOD_LALT = 1 << 2,
+    SC_MOD_RALT = 1 << 3,
+    SC_MOD_LSUPER = 1 << 4,
+    SC_MOD_RSUPER = 1 << 5,
+};
+
+struct sc_shortcut_mods {
+    unsigned data[SC_MAX_SHORTCUT_MODS];
+    unsigned count;
+};
+
+struct sc_port_range {
+    uint16_t first;
+    uint16_t last;
+};
+
+#define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
+
+struct scrcpy_options {
+    const char *serial;
+    const char *crop;
+    const char *record_filename;
+    const char *window_title;
+    const char *push_target;
+    const char *render_driver;
+    const char *codec_options;
+    const char *encoder_name;
+#ifdef HAVE_V4L2
+    const char *v4l2_device;
+#endif
+    enum sc_log_level log_level;
+    enum sc_record_format record_format;
+    enum sc_keyboard_input_mode keyboard_input_mode;
+    struct sc_port_range port_range;
+    struct sc_shortcut_mods shortcut_mods;
+    uint16_t max_size;
+    uint32_t bit_rate;
+    uint16_t max_fps;
+    enum sc_lock_video_orientation lock_video_orientation;
+    uint8_t rotation;
+    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
+    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
+    uint16_t window_width;
+    uint16_t window_height;
+    uint32_t display_id;
+    sc_tick display_buffer;
+    sc_tick v4l2_buffer;
+    bool show_touches;
+    bool fullscreen;
+    bool always_on_top;
+    bool control;
+    bool display;
+    bool turn_screen_off;
+    bool prefer_text;
+    bool window_borderless;
+    bool mipmaps;
+    bool stay_awake;
+    bool force_adb_forward;
+    bool disable_screensaver;
+    bool forward_key_repeat;
+    bool forward_all_clicks;
+    bool legacy_paste;
+    bool power_off_on_close;
+};
+
+extern const struct scrcpy_options scrcpy_options_default;
+
+#endif

app/src/receiver.c

@@ -7,7 +7,7 @@
 #include "util/log.h"
 
 bool
-receiver_init(struct receiver *receiver, socket_t control_socket) {
+receiver_init(struct receiver *receiver, sc_socket control_socket) {
     bool ok = sc_mutex_init(&receiver->mutex);
     if (!ok) {
         return false;

app/src/receiver.h

@@ -11,13 +11,13 @@
 // receive events from the device
 // managed by the controller
 struct receiver {
-    socket_t control_socket;
+    sc_socket control_socket;
     sc_thread thread;
     sc_mutex mutex;
 };
 
 bool
-receiver_init(struct receiver *receiver, socket_t control_socket);
+receiver_init(struct receiver *receiver, sc_socket control_socket);
 
 void
 receiver_destroy(struct receiver *receiver);

app/src/recorder.c

@@ -1,10 +1,12 @@
 #include "recorder.h"
 
 #include <assert.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
 #include <libavutil/time.h>
 
 #include "util/log.h"
-#include "util/str_util.h"
+#include "util/str.h"
 
 /** Downcast packet_sink to recorder */
 #define DOWNCAST(SINK) container_of(SINK, struct recorder, packet_sink)
@@ -24,7 +26,7 @@ find_muxer(const char *name) {
         oformat = av_oformat_next(oformat);
 #endif
         // until null or containing the requested name
-    } while (oformat && !strlist_contains(oformat->name, ',', name));
+    } while (oformat && !sc_str_list_contains(oformat->name, ',', name));
     return oformat;
 }
 
@@ -51,16 +53,15 @@ record_packet_new(const AVPacket *packet) {
 
 static void
 record_packet_delete(struct record_packet *rec) {
-    av_packet_unref(rec->packet);
     av_packet_free(&rec->packet);
     free(rec);
 }
 
 static void
 recorder_queue_clear(struct recorder_queue *queue) {
-    while (!queue_is_empty(queue)) {
+    while (!sc_queue_is_empty(queue)) {
         struct record_packet *rec;
-        queue_take(queue, next, &rec);
+        sc_queue_take(queue, next, &rec);
         record_packet_delete(rec);
     }
 }
@@ -136,14 +137,14 @@ run_recorder(void *data) {
     for (;;) {
         sc_mutex_lock(&recorder->mutex);
 
-        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
+        while (!recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
             sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
         }
 
         // if stopped is set, continue to process the remaining events (to
         // finish the recording) before actually stopping
 
-        if (recorder->stopped && queue_is_empty(&recorder->queue)) {
+        if (recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
             sc_mutex_unlock(&recorder->mutex);
             struct record_packet *last = recorder->previous;
             if (last) {
@@ -162,7 +163,7 @@ run_recorder(void *data) {
         }
 
         struct record_packet *rec;
-        queue_take(&recorder->queue, next, &rec);
+        sc_queue_take(&recorder->queue, next, &rec);
 
         sc_mutex_unlock(&recorder->mutex);
 
@@ -214,7 +215,8 @@ run_recorder(void *data) {
         LOGE("Recording failed to %s", recorder->filename);
     } else {
         const char *format_name = recorder_get_format_name(recorder->format);
-        LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
+        LOGI("Recording complete to %s file: %s", format_name,
+                                                  recorder->filename);
     }
 
     LOGD("Recorder thread ended");
@@ -236,7 +238,7 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
         goto error_mutex_destroy;
     }
 
-    queue_init(&recorder->queue);
+    sc_queue_init(&recorder->queue);
     recorder->stopped = false;
     recorder->failed = false;
     recorder->header_written = false;
@@ -341,7 +343,7 @@ recorder_push(struct recorder *recorder, const AVPacket *packet) {
         return false;
     }
 
-    queue_push(&recorder->queue, next, rec);
+    sc_queue_push(&recorder->queue, next, rec);
     sc_cond_signal(&recorder->queue_cond);
 
     sc_mutex_unlock(&recorder->mutex);
@@ -370,7 +372,7 @@ bool
 recorder_init(struct recorder *recorder,
               const char *filename,
               enum sc_record_format format,
-              struct size declared_frame_size) {
+              struct sc_size declared_frame_size) {
     recorder->filename = strdup(filename);
     if (!recorder->filename) {
         LOGE("Could not strdup filename");

app/src/recorder.h

@@ -7,7 +7,7 @@
 #include <libavformat/avformat.h>
 
 #include "coords.h"
-#include "scrcpy.h"
+#include "options.h"
 #include "trait/packet_sink.h"
 #include "util/queue.h"
 #include "util/thread.h"
@@ -17,7 +17,7 @@ struct record_packet {
     struct record_packet *next;
 };
 
-struct recorder_queue QUEUE(struct record_packet);
+struct recorder_queue SC_QUEUE(struct record_packet);
 
 struct recorder {
     struct sc_packet_sink packet_sink; // packet sink trait
@@ -25,7 +25,7 @@ struct recorder {
     char *filename;
     enum sc_record_format format;
     AVFormatContext *ctx;
-    struct size declared_frame_size;
+    struct sc_size declared_frame_size;
     bool header_written;
 
     sc_thread thread;
@@ -44,7 +44,7 @@ struct recorder {
 
 bool
 recorder_init(struct recorder *recorder, const char *filename,
-              enum sc_record_format format, struct size declared_frame_size);
+              enum sc_record_format format, struct sc_size declared_frame_size);
 
 void
 recorder_destroy(struct recorder *recorder);

app/src/scrcpy.c

@@ -18,11 +18,15 @@
 #include "events.h"
 #include "file_handler.h"
 #include "input_manager.h"
+#ifdef HAVE_AOA_HID
+# include "hid_keyboard.h"
+#endif
+#include "keyboard_inject.h"
+#include "mouse_inject.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
 #include "stream.h"
-#include "tiny_xpm.h"
 #include "util/log.h"
 #include "util/net.h"
 #ifdef HAVE_V4L2
@@ -30,7 +34,7 @@
 #endif
 
 struct scrcpy {
-    struct server server;
+    struct sc_server server;
     struct screen screen;
     struct stream stream;
     struct decoder decoder;
@@ -40,44 +44,43 @@ struct scrcpy {
 #endif
     struct controller controller;
     struct file_handler file_handler;
+#ifdef HAVE_AOA_HID
+    struct sc_aoa aoa;
+#endif
+    union {
+        struct sc_keyboard_inject keyboard_inject;
+#ifdef HAVE_AOA_HID
+        struct sc_hid_keyboard keyboard_hid;
+#endif
+    };
+    struct sc_mouse_inject mouse_inject;
     struct input_manager input_manager;
 };
 
+static inline void
+push_event(uint32_t type, const char *name) {
+    SDL_Event event;
+    event.type = type;
+    int ret = SDL_PushEvent(&event);
+    if (ret < 0) {
+        LOGE("Could not post %s event: %s", name, SDL_GetError());
+        // What could we do?
+    }
+}
+#define PUSH_EVENT(TYPE) push_event(TYPE, # TYPE)
+
 #ifdef _WIN32
 BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
     if (ctrl_type == CTRL_C_EVENT) {
-        SDL_Event event;
-        event.type = SDL_QUIT;
-        SDL_PushEvent(&event);
+        PUSH_EVENT(SDL_QUIT);
         return TRUE;
     }
     return FALSE;
 }
 #endif // _WIN32
 
-// init SDL and set appropriate hints
-static bool
-sdl_init_and_configure(bool display, const char *render_driver,
-                       bool disable_screensaver) {
-    uint32_t flags = display ? SDL_INIT_VIDEO : SDL_INIT_EVENTS;
-    if (SDL_Init(flags)) {
-        LOGC("Could not initialize SDL: %s", SDL_GetError());
-        return false;
-    }
-
-    atexit(SDL_Quit);
-
-#ifdef _WIN32
-    // Clean up properly on Ctrl+C on Windows
-    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
-    if (!ok) {
-        LOGW("Could not set Ctrl+C handler");
-    }
-#endif // _WIN32
-
-    if (!display) {
-        return true;
-    }
+static void
+sdl_set_hints(const char *render_driver) {
 
     if (render_driver && !SDL_SetHint(SDL_HINT_RENDER_DRIVER, render_driver)) {
         LOGW("Could not set render driver");
@@ -95,6 +98,15 @@ sdl_init_and_configure(bool display, const char *render_driver,
     }
 #endif
 
+#ifdef SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
+    // Disable synthetic mouse events from touch events
+    // Touch events with id SDL_TOUCH_MOUSEID are ignored anyway, but it is
+    // better not to generate them in the first place.
+    if (!SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0")) {
+        LOGW("Could not disable synthetic mouse events");
+    }
+#endif
+
 #ifdef SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
     // Disable compositor bypassing on X11
     if (!SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0")) {
@@ -106,6 +118,21 @@ sdl_init_and_configure(bool display, const char *render_driver,
     if (!SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0")) {
         LOGW("Could not disable minimize on focus loss");
     }
+}
+
+static void
+sdl_configure(bool display, bool disable_screensaver) {
+#ifdef _WIN32
+    // Clean up properly on Ctrl+C on Windows
+    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
+    if (!ok) {
+        LOGW("Could not set Ctrl+C handler");
+    }
+#endif // _WIN32
+
+    if (!display) {
+        return;
+    }
 
     if (disable_screensaver) {
         LOGD("Screensaver disabled");
@@ -114,8 +141,6 @@ sdl_init_and_configure(bool display, const char *render_driver,
         LOGD("Screensaver enabled");
         SDL_EnableScreenSaver();
     }
-
-    return true;
 }
 
 static bool
@@ -192,6 +217,29 @@ event_loop(struct scrcpy *s, const struct scrcpy_options *options) {
     return false;
 }
 
+static bool
+await_for_server(void) {
+    SDL_Event event;
+    while (SDL_WaitEvent(&event)) {
+        switch (event.type) {
+            case SDL_QUIT:
+                LOGD("User requested to quit");
+                return false;
+            case EVENT_SERVER_CONNECTION_FAILED:
+                LOGE("Server connection failed");
+                return false;
+            case EVENT_SERVER_CONNECTED:
+                LOGD("Server connected");
+                return true;
+            default:
+                break;
+        }
+    }
+
+    LOGE("SDL_WaitEvent() error: %s", SDL_GetError());
+    return false;
+}
+
 static SDL_LogPriority
 sdl_priority_from_av_level(int level) {
     switch (level) {
@@ -234,20 +282,48 @@ stream_on_eos(struct stream *stream, void *userdata) {
     (void) stream;
     (void) userdata;
 
-    SDL_Event stop_event;
-    stop_event.type = EVENT_STREAM_STOPPED;
-    SDL_PushEvent(&stop_event);
+    PUSH_EVENT(EVENT_STREAM_STOPPED);
+}
+
+static void
+sc_server_on_connection_failed(struct sc_server *server, void *userdata) {
+    (void) server;
+    (void) userdata;
+
+    PUSH_EVENT(EVENT_SERVER_CONNECTION_FAILED);
+}
+
+static void
+sc_server_on_connected(struct sc_server *server, void *userdata) {
+    (void) server;
+    (void) userdata;
+
+    PUSH_EVENT(EVENT_SERVER_CONNECTED);
+}
+
+static void
+sc_server_on_disconnected(struct sc_server *server, void *userdata) {
+    (void) server;
+    (void) userdata;
+
+    LOGD("Server disconnected");
+    // Do nothing, the disconnection will be handled by the "stream stopped"
+    // event
 }
 
 bool
-scrcpy(const struct scrcpy_options *options) {
+scrcpy(struct scrcpy_options *options) {
     static struct scrcpy scrcpy;
     struct scrcpy *s = &scrcpy;
 
-    if (!server_init(&s->server)) {
+    // Minimal SDL initialization
+    if (SDL_Init(SDL_INIT_EVENTS)) {
+        LOGC("Could not initialize SDL: %s", SDL_GetError());
         return false;
     }
 
+    atexit(SDL_Quit);
+
     bool ret = false;
 
     bool server_started = false;
@@ -257,12 +333,14 @@ scrcpy(const struct scrcpy_options *options) {
     bool v4l2_sink_initialized = false;
 #endif
     bool stream_started = false;
+#ifdef HAVE_AOA_HID
+    bool aoa_hid_initialized = false;
+#endif
     bool controller_initialized = false;
     bool controller_started = false;
     bool screen_initialized = false;
 
-    bool record = !!options->record_filename;
-    struct server_params params = {
+    struct sc_server_params params = {
         .serial = options->serial,
         .log_level = options->log_level,
         .crop = options->crop,
@@ -280,26 +358,47 @@ scrcpy(const struct scrcpy_options *options) {
         .force_adb_forward = options->force_adb_forward,
         .power_off_on_close = options->power_off_on_close,
     };
-    if (!server_start(&s->server, &params)) {
+
+    static const struct sc_server_callbacks cbs = {
+        .on_connection_failed = sc_server_on_connection_failed,
+        .on_connected = sc_server_on_connected,
+        .on_disconnected = sc_server_on_disconnected,
+    };
+    if (!sc_server_init(&s->server, &params, &cbs, NULL)) {
+        return false;
+    }
+
+    if (!sc_server_start(&s->server)) {
         goto end;
     }
 
     server_started = true;
 
-    if (!sdl_init_and_configure(options->display, options->render_driver,
-                                options->disable_screensaver)) {
+    if (options->display) {
+        sdl_set_hints(options->render_driver);
+    }
+
+    // Initialize SDL video in addition if display is enabled
+    if (options->display && SDL_Init(SDL_INIT_VIDEO)) {
+        LOGC("Could not initialize SDL: %s", SDL_GetError());
         goto end;
     }
 
-    char device_name[DEVICE_NAME_FIELD_LENGTH];
-    struct size frame_size;
+    sdl_configure(options->display, options->disable_screensaver);
 
-    if (!server_connect_to(&s->server, device_name, &frame_size)) {
+    // Await for server without blocking Ctrl+C handling
+    if (!await_for_server()) {
         goto end;
     }
 
+    // It is necessarily initialized here, since the device is connected
+    struct sc_server_info *info = &s->server.info;
+
+    const char *serial = s->server.params.serial;
+    assert(serial);
+
     if (options->display && options->control) {
-        if (!file_handler_init(&s->file_handler, s->server.serial,
+        if (!file_handler_init(&s->file_handler, serial,
                                options->push_target)) {
             goto end;
         }
@@ -317,11 +416,11 @@ scrcpy(const struct scrcpy_options *options) {
     }
 
     struct recorder *rec = NULL;
-    if (record) {
+    if (options->record_filename) {
         if (!recorder_init(&s->recorder,
                            options->record_filename,
                            options->record_format,
-                           frame_size)) {
+                           info->frame_size)) {
             goto end;
         }
         rec = &s->recorder;
@@ -330,7 +429,7 @@ scrcpy(const struct scrcpy_options *options) {
 
     av_log_set_callback(av_log_callback);
 
-    const struct stream_callbacks stream_cbs = {
+    static const struct stream_callbacks stream_cbs = {
         .on_eos = stream_on_eos,
     };
     stream_init(&s->stream, s->server.video_socket, &stream_cbs, NULL);
@@ -367,11 +466,11 @@ scrcpy(const struct scrcpy_options *options) {
 
     if (options->display) {
         const char *window_title =
-            options->window_title ? options->window_title : device_name;
+            options->window_title ? options->window_title : info->device_name;
 
         struct screen_params screen_params = {
             .window_title = window_title,
-            .frame_size = frame_size,
+            .frame_size = info->frame_size,
             .always_on_top = options->always_on_top,
             .window_x = options->window_x,
             .window_y = options->window_y,
@@ -381,6 +480,7 @@ scrcpy(const struct scrcpy_options *options) {
             .rotation = options->rotation,
             .mipmaps = options->mipmaps,
             .fullscreen = options->fullscreen,
+            .buffering_time = options->display_buffer,
         };
 
         if (!screen_init(&s->screen, &screen_params)) {
@@ -393,7 +493,8 @@ scrcpy(const struct scrcpy_options *options) {
 
 #ifdef HAVE_V4L2
     if (options->v4l2_device) {
-        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device, frame_size)) {
+        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device,
+                               info->frame_size, options->v4l2_buffer)) {
             goto end;
         }
 
@@ -410,7 +511,63 @@ scrcpy(const struct scrcpy_options *options) {
     }
     stream_started = true;
 
-    input_manager_init(&s->input_manager, &s->controller, &s->screen, options);
+    struct sc_key_processor *kp = NULL;
+    struct sc_mouse_processor *mp = NULL;
+
+    if (options->control) {
+        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID) {
+#ifdef HAVE_AOA_HID
+            bool aoa_hid_ok = false;
+
+            bool ok = sc_aoa_init(&s->aoa, serial);
+            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, &s->screen);
+        mp = &s->mouse_inject.mouse_processor;
+    }
+
+    input_manager_init(&s->input_manager, &s->controller, &s->screen, kp, mp,
+                       options);
 
     ret = event_loop(s, options);
     LOGD("quit...");
@@ -422,6 +579,12 @@ scrcpy(const struct scrcpy_options *options) {
 end:
     // The stream is not stopped explicitly, because it will stop by itself on
     // end-of-stream
+#ifdef HAVE_AOA_HID
+    if (aoa_hid_initialized) {
+        sc_hid_keyboard_destroy(&s->keyboard_hid);
+        sc_aoa_stop(&s->aoa);
+    }
+#endif
     if (controller_started) {
         controller_stop(&s->controller);
     }
@@ -434,7 +597,7 @@ end:
 
     if (server_started) {
         // shutdown the sockets and kill the server
-        server_stop(&s->server);
+        sc_server_stop(&s->server);
     }
 
     // now that the sockets are shutdown, the stream and controller are
@@ -449,6 +612,13 @@ end:
     }
 #endif
 
+#ifdef HAVE_AOA_HID
+    if (aoa_hid_initialized) {
+        sc_aoa_join(&s->aoa);
+        sc_aoa_destroy(&s->aoa);
+    }
+#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) {
@@ -472,7 +642,7 @@ end:
         file_handler_destroy(&s->file_handler);
     }
 
-    server_destroy(&s->server);
+    sc_server_destroy(&s->server);
 
     return ret;
 }

app/src/scrcpy.h

@@ -4,147 +4,9 @@
 #include "common.h"
 
 #include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-enum sc_log_level {
-    SC_LOG_LEVEL_VERBOSE,
-    SC_LOG_LEVEL_DEBUG,
-    SC_LOG_LEVEL_INFO,
-    SC_LOG_LEVEL_WARN,
-    SC_LOG_LEVEL_ERROR,
-};
-
-enum sc_record_format {
-    SC_RECORD_FORMAT_AUTO,
-    SC_RECORD_FORMAT_MP4,
-    SC_RECORD_FORMAT_MKV,
-};
-
-enum sc_lock_video_orientation {
-    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
-    // lock the current orientation when scrcpy starts
-    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
-    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
-    SC_LOCK_VIDEO_ORIENTATION_1,
-    SC_LOCK_VIDEO_ORIENTATION_2,
-    SC_LOCK_VIDEO_ORIENTATION_3,
-};
-
-#define SC_MAX_SHORTCUT_MODS 8
-
-enum sc_shortcut_mod {
-    SC_MOD_LCTRL = 1 << 0,
-    SC_MOD_RCTRL = 1 << 1,
-    SC_MOD_LALT = 1 << 2,
-    SC_MOD_RALT = 1 << 3,
-    SC_MOD_LSUPER = 1 << 4,
-    SC_MOD_RSUPER = 1 << 5,
-};
-
-struct sc_shortcut_mods {
-    unsigned data[SC_MAX_SHORTCUT_MODS];
-    unsigned count;
-};
-
-struct sc_port_range {
-    uint16_t first;
-    uint16_t last;
-};
-
-#define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
-
-struct scrcpy_options {
-    const char *serial;
-    const char *crop;
-    const char *record_filename;
-    const char *window_title;
-    const char *push_target;
-    const char *render_driver;
-    const char *codec_options;
-    const char *encoder_name;
-    const char *v4l2_device;
-    enum sc_log_level log_level;
-    enum sc_record_format record_format;
-    struct sc_port_range port_range;
-    struct sc_shortcut_mods shortcut_mods;
-    uint16_t max_size;
-    uint32_t bit_rate;
-    uint16_t max_fps;
-    enum sc_lock_video_orientation lock_video_orientation;
-    uint8_t rotation;
-    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
-    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
-    uint16_t window_width;
-    uint16_t window_height;
-    uint32_t display_id;
-    bool show_touches;
-    bool fullscreen;
-    bool always_on_top;
-    bool control;
-    bool display;
-    bool turn_screen_off;
-    bool prefer_text;
-    bool window_borderless;
-    bool mipmaps;
-    bool stay_awake;
-    bool force_adb_forward;
-    bool disable_screensaver;
-    bool forward_key_repeat;
-    bool forward_all_clicks;
-    bool legacy_paste;
-    bool power_off_on_close;
-};
-
-#define SCRCPY_OPTIONS_DEFAULT { \
-    .serial = NULL, \
-    .crop = NULL, \
-    .record_filename = NULL, \
-    .window_title = NULL, \
-    .push_target = NULL, \
-    .render_driver = NULL, \
-    .codec_options = NULL, \
-    .encoder_name = NULL, \
-    .v4l2_device = NULL, \
-    .log_level = SC_LOG_LEVEL_INFO, \
-    .record_format = SC_RECORD_FORMAT_AUTO, \
-    .port_range = { \
-        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
-        .last = DEFAULT_LOCAL_PORT_RANGE_LAST, \
-    }, \
-    .shortcut_mods = { \
-        .data = {SC_MOD_LALT, SC_MOD_LSUPER}, \
-        .count = 2, \
-    }, \
-    .max_size = 0, \
-    .bit_rate = DEFAULT_BIT_RATE, \
-    .max_fps = 0, \
-    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED, \
-    .rotation = 0, \
-    .window_x = SC_WINDOW_POSITION_UNDEFINED, \
-    .window_y = SC_WINDOW_POSITION_UNDEFINED, \
-    .window_width = 0, \
-    .window_height = 0, \
-    .display_id = 0, \
-    .show_touches = false, \
-    .fullscreen = false, \
-    .always_on_top = false, \
-    .control = true, \
-    .display = true, \
-    .turn_screen_off = false, \
-    .prefer_text = false, \
-    .window_borderless = false, \
-    .mipmaps = true, \
-    .stay_awake = false, \
-    .force_adb_forward = false, \
-    .disable_screensaver = false, \
-    .forward_key_repeat = true, \
-    .forward_all_clicks = false, \
-    .legacy_paste = false, \
-    .power_off_on_close = false, \
-}
+#include "options.h"
 
 bool
-scrcpy(const struct scrcpy_options *options);
+scrcpy(struct scrcpy_options *options);
 
 #endif

app/src/screen.c

@@ -5,9 +5,8 @@
 #include <SDL2/SDL.h>
 
 #include "events.h"
-#include "icon.xpm"
-#include "scrcpy.h"
-#include "tiny_xpm.h"
+#include "icon.h"
+#include "options.h"
 #include "video_buffer.h"
 #include "util/log.h"
 
@@ -15,9 +14,9 @@
 
 #define DOWNCAST(SINK) container_of(SINK, struct screen, frame_sink)
 
-static inline struct size
-get_rotated_size(struct size size, int rotation) {
-    struct size rotated_size;
+static inline struct sc_size
+get_rotated_size(struct sc_size size, int rotation) {
+    struct sc_size rotated_size;
     if (rotation & 1) {
         rotated_size.width = size.height;
         rotated_size.height = size.width;
@@ -28,26 +27,26 @@ get_rotated_size(struct size size, int rotation) {
     return rotated_size;
 }
 
-// get the window size in a struct size
-static struct size
+// get the window size in a struct sc_size
+static struct sc_size
 get_window_size(const struct screen *screen) {
     int width;
     int height;
     SDL_GetWindowSize(screen->window, &width, &height);
 
-    struct size size;
+    struct sc_size size;
     size.width = width;
     size.height = height;
     return size;
 }
 
-static struct point
+static struct sc_point
 get_window_position(const struct screen *screen) {
     int x;
     int y;
     SDL_GetWindowPosition(screen->window, &x, &y);
 
-    struct point point;
+    struct sc_point point;
     point.x = x;
     point.y = y;
     return point;
@@ -55,7 +54,7 @@ get_window_position(const struct screen *screen) {
 
 // set the window size to be applied when fullscreen is disabled
 static void
-set_window_size(struct screen *screen, struct 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);
@@ -63,7 +62,7 @@ set_window_size(struct screen *screen, struct size new_size) {
 
 // get the preferred display bounds (i.e. the screen bounds with some margins)
 static bool
-get_preferred_display_bounds(struct size *bounds) {
+get_preferred_display_bounds(struct sc_size *bounds) {
     SDL_Rect rect;
 #ifdef SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
 # define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayUsableBounds((i), (r))
@@ -81,7 +80,7 @@ get_preferred_display_bounds(struct size *bounds) {
 }
 
 static bool
-is_optimal_size(struct size current_size, struct size content_size) {
+is_optimal_size(struct sc_size current_size, struct sc_size content_size) {
     // The size is optimal if we can recompute one dimension of the current
     // size from the other
     return current_size.height == current_size.width * content_size.height
@@ -95,16 +94,16 @@ is_optimal_size(struct size current_size, struct size content_size) {
 //    crops the black borders)
 //  - it keeps the aspect ratio
 //  - it scales down to make it fit in the display_size
-static struct size
-get_optimal_size(struct size current_size, struct size content_size) {
+static struct sc_size
+get_optimal_size(struct sc_size current_size, struct sc_size content_size) {
     if (content_size.width == 0 || content_size.height == 0) {
         // avoid division by 0
         return current_size;
     }
 
-    struct size window_size;
+    struct sc_size window_size;
 
-    struct size display_size;
+    struct sc_size display_size;
     if (!get_preferred_display_bounds(&display_size)) {
         // could not get display bounds, do not constraint the size
         window_size.width = current_size.width;
@@ -136,10 +135,10 @@ get_optimal_size(struct size current_size, struct size content_size) {
 
 // initially, there is no current size, so use the frame size as current size
 // req_width and req_height, if not 0, are the sizes requested by the user
-static inline struct size
-get_initial_optimal_size(struct size content_size, uint16_t req_width,
+static inline struct sc_size
+get_initial_optimal_size(struct sc_size content_size, uint16_t req_width,
                          uint16_t req_height) {
-    struct size window_size;
+    struct sc_size window_size;
     if (!req_width && !req_height) {
         window_size = get_optimal_size(content_size, content_size);
     } else {
@@ -167,9 +166,9 @@ screen_update_content_rect(struct screen *screen) {
     int dh;
     SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
 
-    struct size content_size = screen->content_size;
+    struct sc_size content_size = screen->content_size;
     // The drawable size is the window size * the HiDPI scale
-    struct size drawable_size = {dw, dh};
+    struct sc_size drawable_size = {dw, dh};
 
     SDL_Rect *rect = &screen->rect;
 
@@ -201,7 +200,7 @@ screen_update_content_rect(struct screen *screen) {
 static inline SDL_Texture *
 create_texture(struct screen *screen) {
     SDL_Renderer *renderer = screen->renderer;
-    struct size size = screen->frame_size;
+    struct sc_size size = screen->frame_size;
     SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
                                              SDL_TEXTUREACCESS_STREAMING,
                                              size.width, size.height);
@@ -225,6 +224,45 @@ create_texture(struct screen *screen) {
     return texture;
 }
 
+// render the texture to the renderer
+//
+// Set the update_content_rect flag if the window or content size may have
+// changed, so that the content rectangle is recomputed
+static void
+screen_render(struct screen *screen, bool update_content_rect) {
+    if (update_content_rect) {
+        screen_update_content_rect(screen);
+    }
+
+    SDL_RenderClear(screen->renderer);
+    if (screen->rotation == 0) {
+        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
+    } else {
+        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
+        // counterclockwise (to be consistent with --lock-video-orientation)
+        int cw_rotation = (4 - screen->rotation) % 4;
+        double angle = 90 * cw_rotation;
+
+        SDL_Rect *dstrect = NULL;
+        SDL_Rect rect;
+        if (screen->rotation & 1) {
+            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
+            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
+            rect.w = screen->rect.h;
+            rect.h = screen->rect.w;
+            dstrect = &rect;
+        } else {
+            assert(screen->rotation == 2);
+            dstrect = &screen->rect;
+        }
+
+        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
+                         angle, NULL, 0);
+    }
+    SDL_RenderPresent(screen->renderer);
+}
+
+
 #if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif
@@ -274,27 +312,43 @@ screen_frame_sink_close(struct sc_frame_sink *sink) {
 static bool
 screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
     struct screen *screen = DOWNCAST(sink);
-
-    bool previous_frame_skipped;
-    bool ok = video_buffer_push(&screen->vb, frame, &previous_frame_skipped);
-    if (!ok) {
-        return false;
+    return sc_video_buffer_push(&screen->vb, frame);
 }
 
-    if (previous_frame_skipped) {
+static void
+sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
+                             void *userdata) {
+    (void) vb;
+    struct screen *screen = userdata;
+
+    // event_failed implies previous_skipped (the previous frame may not have
+    // been consumed if the event was not sent)
+    assert(!screen->event_failed || previous_skipped);
+
+    bool need_new_event;
+    if (previous_skipped) {
         fps_counter_add_skipped_frame(&screen->fps_counter);
         // The EVENT_NEW_FRAME triggered for the previous frame will consume
-        // this new frame instead
+        // this new frame instead, unless the previous event failed
+        need_new_event = screen->event_failed;
     } else {
+        need_new_event = true;
+    }
+
+    if (need_new_event) {
         static SDL_Event new_frame_event = {
             .type = EVENT_NEW_FRAME,
         };
 
         // Post the event on the UI thread
-        SDL_PushEvent(&new_frame_event);
+        int ret = SDL_PushEvent(&new_frame_event);
+        if (ret < 0) {
+            LOGW("Could not post new frame event: %s", SDL_GetError());
+            screen->event_failed = true;
+        } else {
+            screen->event_failed = false;
+        }
     }
-
-    return true;
 }
 
 bool
@@ -303,16 +357,28 @@ screen_init(struct screen *screen, const struct screen_params *params) {
     screen->has_frame = false;
     screen->fullscreen = false;
     screen->maximized = false;
+    screen->event_failed = false;
 
-    bool ok = video_buffer_init(&screen->vb);
+    static const struct sc_video_buffer_callbacks cbs = {
+        .on_new_frame = sc_video_buffer_on_new_frame,
+    };
+
+    bool ok = sc_video_buffer_init(&screen->vb, params->buffering_time, &cbs,
+                                   screen);
     if (!ok) {
         LOGE("Could not initialize video buffer");
         return false;
     }
 
+    ok = sc_video_buffer_start(&screen->vb);
+    if (!ok) {
+        LOGE("Could not start video_buffer");
+        goto error_destroy_video_buffer;
+    }
+
     if (!fps_counter_init(&screen->fps_counter)) {
         LOGE("Could not initialize FPS counter");
-        goto error_destroy_video_buffer;
+        goto error_stop_and_join_video_buffer;
     }
 
     screen->frame_size = params->frame_size;
@@ -320,12 +386,12 @@ screen_init(struct screen *screen, const struct screen_params *params) {
     if (screen->rotation) {
         LOGI("Initial display rotation set to %u", screen->rotation);
     }
-    struct size content_size =
+    struct sc_size content_size =
         get_rotated_size(screen->frame_size, screen->rotation);
     screen->content_size = content_size;
 
-    struct size window_size = get_initial_optimal_size(content_size,
-                                                       params->window_width,
+    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
@@ -394,10 +460,10 @@ screen_init(struct screen *screen, const struct screen_params *params) {
         LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
     }
 
-    SDL_Surface *icon = read_xpm(icon_xpm);
+    SDL_Surface *icon = scrcpy_icon_load();
     if (icon) {
         SDL_SetWindowIcon(screen->window, icon);
-        SDL_FreeSurface(icon);
+        scrcpy_icon_destroy(icon);
     } else {
         LOGW("Could not load icon");
     }
@@ -453,8 +519,11 @@ error_destroy_window:
     SDL_DestroyWindow(screen->window);
 error_destroy_fps_counter:
     fps_counter_destroy(&screen->fps_counter);
+error_stop_and_join_video_buffer:
+    sc_video_buffer_stop(&screen->vb);
+    sc_video_buffer_join(&screen->vb);
 error_destroy_video_buffer:
-    video_buffer_destroy(&screen->vb);
+    sc_video_buffer_destroy(&screen->vb);
 
     return false;
 }
@@ -471,11 +540,13 @@ screen_hide_window(struct screen *screen) {
 
 void
 screen_interrupt(struct screen *screen) {
+    sc_video_buffer_stop(&screen->vb);
     fps_counter_interrupt(&screen->fps_counter);
 }
 
 void
 screen_join(struct screen *screen) {
+    sc_video_buffer_join(&screen->vb);
     fps_counter_join(&screen->fps_counter);
 }
 
@@ -489,14 +560,14 @@ screen_destroy(struct screen *screen) {
     SDL_DestroyRenderer(screen->renderer);
     SDL_DestroyWindow(screen->window);
     fps_counter_destroy(&screen->fps_counter);
-    video_buffer_destroy(&screen->vb);
+    sc_video_buffer_destroy(&screen->vb);
 }
 
 static void
-resize_for_content(struct screen *screen, struct size old_content_size,
-                                                 struct size new_content_size) {
-    struct size window_size = get_window_size(screen);
-    struct size target_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 = {
         .width = (uint32_t) window_size.width * new_content_size.width
                 / old_content_size.width,
         .height = (uint32_t) window_size.height * new_content_size.height
@@ -507,7 +578,7 @@ resize_for_content(struct screen *screen, struct size old_content_size,
 }
 
 static void
-set_content_size(struct screen *screen, struct 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) {
@@ -538,7 +609,7 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
         return;
     }
 
-    struct size new_content_size =
+    struct sc_size new_content_size =
         get_rotated_size(screen->frame_size, rotation);
 
     set_content_size(screen, new_content_size);
@@ -551,7 +622,7 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
 
 // recreate the texture and resize the window if the frame size has changed
 static bool
-prepare_for_frame(struct screen *screen, struct 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
@@ -559,7 +630,7 @@ prepare_for_frame(struct screen *screen, struct size new_frame_size) {
 
         screen->frame_size = new_frame_size;
 
-        struct size new_content_size =
+        struct sc_size new_content_size =
             get_rotated_size(new_frame_size, screen->rotation);
         set_content_size(screen, new_content_size);
 
@@ -595,12 +666,12 @@ update_texture(struct screen *screen, const AVFrame *frame) {
 static bool
 screen_update_frame(struct screen *screen) {
     av_frame_unref(screen->frame);
-    video_buffer_consume(&screen->vb, screen->frame);
+    sc_video_buffer_consume(&screen->vb, screen->frame);
     AVFrame *frame = screen->frame;
 
     fps_counter_add_rendered_frame(&screen->fps_counter);
 
-    struct size new_frame_size = {frame->width, frame->height};
+    struct sc_size new_frame_size = {frame->width, frame->height};
     if (!prepare_for_frame(screen, new_frame_size)) {
         return false;
     }
@@ -610,40 +681,6 @@ screen_update_frame(struct screen *screen) {
     return true;
 }
 
-void
-screen_render(struct screen *screen, bool update_content_rect) {
-    if (update_content_rect) {
-        screen_update_content_rect(screen);
-    }
-
-    SDL_RenderClear(screen->renderer);
-    if (screen->rotation == 0) {
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
-    } else {
-        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
-        // counterclockwise (to be consistent with --lock-video-orientation)
-        int cw_rotation = (4 - screen->rotation) % 4;
-        double angle = 90 * cw_rotation;
-
-        SDL_Rect *dstrect = NULL;
-        SDL_Rect rect;
-        if (screen->rotation & 1) {
-            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
-            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
-            rect.w = screen->rect.h;
-            rect.h = screen->rect.w;
-            dstrect = &rect;
-        } else {
-            assert(screen->rotation == 2);
-            dstrect = &screen->rect;
-        }
-
-        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
-                         angle, NULL, 0);
-    }
-    SDL_RenderPresent(screen->renderer);
-}
-
 void
 screen_switch_fullscreen(struct screen *screen) {
     uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
@@ -667,10 +704,10 @@ screen_resize_to_fit(struct screen *screen) {
         return;
     }
 
-    struct point point = get_window_position(screen);
-    struct size window_size = get_window_size(screen);
+    struct sc_point point = get_window_position(screen);
+    struct sc_size window_size = get_window_size(screen);
 
-    struct size optimal_size =
+    struct sc_size optimal_size =
         get_optimal_size(window_size, screen->content_size);
 
     // Center the window related to the device screen
@@ -696,7 +733,7 @@ screen_resize_to_pixel_perfect(struct screen *screen) {
         screen->maximized = false;
     }
 
-    struct size content_size = screen->content_size;
+    struct sc_size content_size = screen->content_size;
     SDL_SetWindowSize(screen->window, content_size.width, content_size.height);
     LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
                                             content_size.height);
@@ -751,7 +788,7 @@ screen_handle_event(struct screen *screen, SDL_Event *event) {
     return false;
 }
 
-struct point
+struct sc_point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                         int32_t x, int32_t y) {
     unsigned rotation = screen->rotation;
@@ -765,7 +802,7 @@ screen_convert_drawable_to_frame_coords(struct screen *screen,
     y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;
 
     // rotate
-    struct point result;
+    struct sc_point result;
     switch (rotation) {
         case 0:
             result.x = x;
@@ -788,7 +825,7 @@ screen_convert_drawable_to_frame_coords(struct screen *screen,
     return result;
 }
 
-struct point
+struct sc_point
 screen_convert_window_to_frame_coords(struct screen *screen,
                                       int32_t x, int32_t y) {
     screen_hidpi_scale_coords(screen, &x, &y);

app/src/screen.h

@@ -8,6 +8,7 @@
 #include <libavformat/avformat.h>
 
 #include "coords.h"
+#include "fps_counter.h"
 #include "opengl.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
@@ -19,20 +20,20 @@ struct screen {
     bool open; // track the open/close state to assert correct behavior
 #endif
 
-    struct video_buffer vb;
+    struct sc_video_buffer vb;
     struct fps_counter fps_counter;
 
     SDL_Window *window;
     SDL_Renderer *renderer;
     SDL_Texture *texture;
     struct sc_opengl gl;
-    struct size frame_size;
-    struct size content_size; // rotated frame_size
+    struct sc_size frame_size;
+    struct sc_size content_size; // rotated frame_size
 
     bool resize_pending; // resize requested while fullscreen or maximized
     // The content size the last time the window was not maximized or
     // fullscreen (meaningful only when resize_pending is true)
-    struct size windowed_content_size;
+    struct sc_size windowed_content_size;
 
     // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
     unsigned rotation;
@@ -43,12 +44,14 @@ struct screen {
     bool maximized;
     bool mipmaps;
 
+    bool event_failed; // in case SDL_PushEvent() returned an error
+
     AVFrame *frame;
 };
 
 struct screen_params {
     const char *window_title;
-    struct size frame_size;
+    struct sc_size frame_size;
     bool always_on_top;
 
     int16_t window_x;
@@ -62,6 +65,8 @@ struct screen_params {
     bool mipmaps;
 
     bool fullscreen;
+
+    sc_tick buffering_time;
 };
 
 // initialize screen, create window, renderer and texture (window is hidden)
@@ -88,13 +93,6 @@ screen_destroy(struct screen *screen);
 void
 screen_hide_window(struct screen *screen);
 
-// render the texture to the renderer
-//
-// Set the update_content_rect flag if the window or content size may have
-// changed, so that the content rectangle is recomputed
-void
-screen_render(struct screen *screen, bool update_content_rect);
-
 // switch the fullscreen mode
 void
 screen_switch_fullscreen(struct screen *screen);
@@ -117,13 +115,13 @@ 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 point
+struct sc_point
 screen_convert_window_to_frame_coords(struct screen *screen,
                                       int32_t x, int32_t y);
 
 // convert point from drawable coordinates to frame coordinates
 // x and y are expressed in pixels
-struct point
+struct sc_point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                         int32_t x, int32_t y);
 

app/src/server.c

@@ -3,21 +3,21 @@
 #include <assert.h>
 #include <errno.h>
 #include <inttypes.h>
-#include <libgen.h>
 #include <stdio.h>
 #include <SDL2/SDL_timer.h>
 #include <SDL2/SDL_platform.h>
 
 #include "adb.h"
+#include "util/file.h"
 #include "util/log.h"
-#include "util/net.h"
-#include "util/str_util.h"
+#include "util/net_intr.h"
+#include "util/process_intr.h"
+#include "util/str.h"
 
-#define SOCKET_NAME "scrcpy"
-#define SERVER_FILENAME "scrcpy-server"
+#define SC_SERVER_FILENAME "scrcpy-server"
 
-#define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FILENAME
-#define DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"
+#define SC_SERVER_PATH_DEFAULT PREFIX "/share/scrcpy/" SC_SERVER_FILENAME
+#define SC_DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"
 
 static char *
 get_server_path(void) {
@@ -29,7 +29,7 @@ get_server_path(void) {
     if (server_path_env) {
         // if the envvar is set, use it
 #ifdef __WINDOWS__
-        char *server_path = utf8_from_wide_char(server_path_env);
+        char *server_path = sc_str_from_wchars(server_path_env);
 #else
         char *server_path = strdup(server_path_env);
 #endif
@@ -42,194 +42,80 @@ get_server_path(void) {
     }
 
 #ifndef PORTABLE
-    LOGD("Using server: " DEFAULT_SERVER_PATH);
-    char *server_path = strdup(DEFAULT_SERVER_PATH);
+    LOGD("Using server: " SC_SERVER_PATH_DEFAULT);
+    char *server_path = strdup(SC_SERVER_PATH_DEFAULT);
     if (!server_path) {
         LOGE("Could not allocate memory");
         return NULL;
     }
-    // the absolute path is hardcoded
-    return server_path;
 #else
-
-    // use scrcpy-server in the same directory as the executable
-    char *executable_path = get_executable_path();
-    if (!executable_path) {
-        LOGE("Could not get executable path, "
-             "using " SERVER_FILENAME " from current directory");
-        // not found, use current directory
-        return strdup(SERVER_FILENAME);
-    }
-    char *dir = dirname(executable_path);
-    size_t dirlen = strlen(dir);
-
-    // sizeof(SERVER_FILENAME) gives statically the size including the null byte
-    size_t len = dirlen + 1 + sizeof(SERVER_FILENAME);
-    char *server_path = malloc(len);
+    char *server_path = sc_file_get_local_path(SC_SERVER_FILENAME);
     if (!server_path) {
-        LOGE("Could not alloc server path string, "
-             "using " SERVER_FILENAME " from current directory");
-        free(executable_path);
-        return strdup(SERVER_FILENAME);
+        LOGE("Could not get local file path, "
+             "using " SC_SERVER_FILENAME " from current directory");
+        return strdup(SC_SERVER_FILENAME);
     }
 
-    memcpy(server_path, dir, dirlen);
-    server_path[dirlen] = PATH_SEPARATOR;
-    memcpy(&server_path[dirlen + 1], SERVER_FILENAME, sizeof(SERVER_FILENAME));
-    // the final null byte has been copied with SERVER_FILENAME
-
-    free(executable_path);
-
     LOGD("Using server (portable): %s", server_path);
-    return server_path;
 #endif
+
+    return server_path;
+}
+
+static void
+sc_server_params_destroy(struct sc_server_params *params) {
+    // The server stores a copy of the params provided by the user
+    free((char *) params->serial);
+    free((char *) params->crop);
+    free((char *) params->codec_options);
+    free((char *) params->encoder_name);
 }
 
 static bool
-push_server(const char *serial) {
+sc_server_params_copy(struct sc_server_params *dst,
+                      const struct sc_server_params *src) {
+    *dst = *src;
+
+    // The params reference user-allocated memory, so we must copy them to
+    // handle them from another thread
+
+#define COPY(FIELD) \
+    dst->FIELD = NULL; \
+    if (src->FIELD) { \
+        dst->FIELD = strdup(src->FIELD); \
+        if (!dst->FIELD) { \
+            goto error; \
+        } \
+    }
+
+    COPY(serial);
+    COPY(crop);
+    COPY(codec_options);
+    COPY(encoder_name);
+#undef COPY
+
+    return true;
+
+error:
+    sc_server_params_destroy(dst);
+    return false;
+}
+
+static bool
+push_server(struct sc_intr *intr, const char *serial) {
     char *server_path = get_server_path();
     if (!server_path) {
         return false;
     }
-    if (!is_regular_file(server_path)) {
+    if (!sc_file_is_regular(server_path)) {
         LOGE("'%s' does not exist or is not a regular file\n", server_path);
         free(server_path);
         return false;
     }
-    process_t process = adb_push(serial, server_path, DEVICE_SERVER_PATH);
+    bool ok = adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH,
+                       SC_INHERIT_STDERR);
     free(server_path);
-    return process_check_success(process, "adb push", true);
-}
-
-static bool
-enable_tunnel_reverse(const char *serial, uint16_t local_port) {
-    process_t process = adb_reverse(serial, SOCKET_NAME, local_port);
-    return process_check_success(process, "adb reverse", true);
-}
-
-static bool
-disable_tunnel_reverse(const char *serial) {
-    process_t process = adb_reverse_remove(serial, SOCKET_NAME);
-    return process_check_success(process, "adb reverse --remove", true);
-}
-
-static bool
-enable_tunnel_forward(const char *serial, uint16_t local_port) {
-    process_t process = adb_forward(serial, local_port, SOCKET_NAME);
-    return process_check_success(process, "adb forward", true);
-}
-
-static bool
-disable_tunnel_forward(const char *serial, uint16_t local_port) {
-    process_t process = adb_forward_remove(serial, local_port);
-    return process_check_success(process, "adb forward --remove", true);
-}
-
-static bool
-disable_tunnel(struct server *server) {
-    if (server->tunnel_forward) {
-        return disable_tunnel_forward(server->serial, server->local_port);
-    }
-    return disable_tunnel_reverse(server->serial);
-}
-
-static socket_t
-listen_on_port(uint16_t port) {
-#define IPV4_LOCALHOST 0x7F000001
-    return net_listen(IPV4_LOCALHOST, port, 1);
-}
-
-static bool
-enable_tunnel_reverse_any_port(struct server *server,
-                               struct sc_port_range port_range) {
-    uint16_t port = port_range.first;
-    for (;;) {
-        if (!enable_tunnel_reverse(server->serial, port)) {
-            // the command itself failed, it will fail on any port
-            return false;
-        }
-
-        // At the application level, the device part is "the server" because it
-        // serves video stream and control. However, at the network level, the
-        // client listens and the server connects to the client. That way, the
-        // client can listen before starting the server app, so there is no
-        // need to try to connect until the server socket is listening on the
-        // device.
-        server->server_socket = listen_on_port(port);
-        if (server->server_socket != INVALID_SOCKET) {
-            // success
-            server->local_port = port;
-            return true;
-        }
-
-        // failure, disable tunnel and try another port
-        if (!disable_tunnel_reverse(server->serial)) {
-            LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
-        }
-
-        // check before incrementing to avoid overflow on port 65535
-        if (port < port_range.last) {
-            LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
-                 port, (uint16_t) (port + 1));
-            port++;
-            continue;
-        }
-
-        if (port_range.first == port_range.last) {
-            LOGE("Could not listen on port %" PRIu16, port_range.first);
-        } else {
-            LOGE("Could not listen on any port in range %" PRIu16 ":%" PRIu16,
-                 port_range.first, port_range.last);
-        }
-        return false;
-    }
-}
-
-static bool
-enable_tunnel_forward_any_port(struct server *server,
-                               struct sc_port_range port_range) {
-    server->tunnel_forward = true;
-    uint16_t port = port_range.first;
-    for (;;) {
-        if (enable_tunnel_forward(server->serial, port)) {
-            // success
-            server->local_port = port;
-            return true;
-        }
-
-        if (port < port_range.last) {
-            LOGW("Could not forward port %" PRIu16", retrying on %" PRIu16,
-                 port, (uint16_t) (port + 1));
-            port++;
-            continue;
-        }
-
-        if (port_range.first == port_range.last) {
-            LOGE("Could not forward port %" PRIu16, port_range.first);
-        } else {
-            LOGE("Could not forward any port in range %" PRIu16 ":%" PRIu16,
-                 port_range.first, port_range.last);
-        }
-        return false;
-    }
-}
-
-static bool
-enable_tunnel_any_port(struct server *server, struct sc_port_range port_range,
-                       bool force_adb_forward) {
-    if (!force_adb_forward) {
-        // Attempt to use "adb reverse"
-        if (enable_tunnel_reverse_any_port(server, port_range)) {
-            return true;
-        }
-
-        // if "adb reverse" does not work (e.g. over "adb connect"), it
-        // fallbacks to "adb forward", so the app socket is the client
-
-        LOGW("'adb reverse' failed, fallback to 'adb forward'");
-    }
-
-    return enable_tunnel_forward_any_port(server, port_range);
+    return ok;
 }
 
 static const char *
@@ -251,8 +137,11 @@ log_level_to_server_string(enum sc_log_level level) {
     }
 }
 
-static process_t
-execute_server(struct server *server, const struct server_params *params) {
+static sc_pid
+execute_server(struct sc_server *server,
+               const struct sc_server_params *params) {
+    const char *serial = server->params.serial;
+
     char max_size_string[6];
     char bit_rate_string[11];
     char max_fps_string[6];
@@ -261,17 +150,19 @@ execute_server(struct server *server, const struct server_params *params) {
     sprintf(max_size_string, "%"PRIu16, params->max_size);
     sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
     sprintf(max_fps_string, "%"PRIu16, params->max_fps);
-    sprintf(lock_video_orientation_string, "%"PRIi8, params->lock_video_orientation);
+    sprintf(lock_video_orientation_string, "%"PRIi8,
+            params->lock_video_orientation);
     sprintf(display_id_string, "%"PRIu32, params->display_id);
     const char *const cmd[] = {
         "shell",
-        "CLASSPATH=" DEVICE_SERVER_PATH,
+        "CLASSPATH=" SC_DEVICE_SERVER_PATH,
         "app_process",
 #ifdef SERVER_DEBUGGER
 # define SERVER_DEBUGGER_PORT "5005"
 # ifdef SERVER_DEBUGGER_METHOD_NEW
         /* Android 9 and above */
-        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,server=y,address="
+        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,"
+        "server=y,address="
 # else
         /* Android 8 and below */
         "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
@@ -286,7 +177,7 @@ execute_server(struct server *server, const struct server_params *params) {
         bit_rate_string,
         max_fps_string,
         lock_video_orientation_string,
-        server->tunnel_forward ? "true" : "false",
+        server->tunnel.forward ? "true" : "false",
         params->crop ? params->crop : "-",
         "true", // always send frame meta (packet boundaries + timestamp)
         params->control ? "true" : "false",
@@ -308,276 +199,369 @@ execute_server(struct server *server, const struct server_params *params) {
     //     Port: 5005
     // Then click on "Debug"
 #endif
-    return adb_execute(server->serial, cmd, ARRAY_LEN(cmd));
+    // Inherit both stdout and stderr (all server logs are printed to stdout)
+    return adb_execute(serial, cmd, ARRAY_LEN(cmd),
+                       SC_INHERIT_STDOUT | SC_INHERIT_STDERR);
 }
 
-static socket_t
-connect_and_read_byte(uint16_t port) {
-    socket_t socket = net_connect(IPV4_LOCALHOST, port);
-    if (socket == INVALID_SOCKET) {
-        return INVALID_SOCKET;
+static bool
+connect_and_read_byte(struct sc_intr *intr, sc_socket socket, uint16_t port) {
+    bool ok = net_connect_intr(intr, socket, IPV4_LOCALHOST, port);
+    if (!ok) {
+        return false;
     }
 
     char byte;
     // the connection may succeed even if the server behind the "adb tunnel"
     // is not listening, so read one byte to detect a working connection
-    if (net_recv(socket, &byte, 1) != 1) {
+    if (net_recv_intr(intr, socket, &byte, 1) != 1) {
         // the server is not listening yet behind the adb tunnel
-        net_close(socket);
-        return INVALID_SOCKET;
-    }
-    return socket;
+        return false;
     }
 
-static socket_t
-connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
+    return true;
+}
+
+static sc_socket
+connect_to_server(struct sc_server *server, uint32_t attempts, sc_tick delay) {
+    uint16_t port = server->tunnel.local_port;
     do {
         LOGD("Remaining connection attempts: %d", (int) attempts);
-        socket_t socket = connect_and_read_byte(port);
-        if (socket != INVALID_SOCKET) {
+        sc_socket socket = net_socket();
+        if (socket != SC_SOCKET_NONE) {
+            bool ok = connect_and_read_byte(&server->intr, socket, port);
+            if (ok) {
                 // it worked!
                 return socket;
             }
-        if (attempts) {
-            SDL_Delay(delay);
-        }
-    } while (--attempts > 0);
-    return INVALID_SOCKET;
+
+            net_close(socket);
         }
 
-static void
-close_socket(socket_t socket) {
-    assert(socket != INVALID_SOCKET);
-    net_shutdown(socket, SHUT_RDWR);
-    if (!net_close(socket)) {
-        LOGW("Could not close socket");
+        if (sc_intr_is_interrupted(&server->intr)) {
+            // Stop immediately
+            break;
         }
+
+        if (attempts) {
+            sc_mutex_lock(&server->mutex);
+            sc_tick deadline = sc_tick_now() + delay;
+            bool timed_out = false;
+            while (!server->stopped && !timed_out) {
+                timed_out = !sc_cond_timedwait(&server->cond_stopped,
+                                               &server->mutex, deadline);
+            }
+            bool stopped = server->stopped;
+            sc_mutex_unlock(&server->mutex);
+
+            if (stopped) {
+                LOGI("Connection attempt stopped");
+                break;
+            }
+        }
+    } while (--attempts > 0);
+    return SC_SOCKET_NONE;
 }
 
 bool
-server_init(struct server *server) {
-    server->serial = NULL;
-    server->process = PROCESS_NONE;
-    atomic_flag_clear_explicit(&server->server_socket_closed,
-                               memory_order_relaxed);
-
-    bool ok = sc_mutex_init(&server->mutex);
+sc_server_init(struct sc_server *server, const struct sc_server_params *params,
+              const struct sc_server_callbacks *cbs, void *cbs_userdata) {
+    bool ok = sc_server_params_copy(&server->params, params);
     if (!ok) {
+        LOGE("Could not copy server params");
         return false;
     }
 
-    ok = sc_cond_init(&server->process_terminated_cond);
+    ok = sc_mutex_init(&server->mutex);
     if (!ok) {
+        LOGE("Could not create server mutex");
+        sc_server_params_destroy(&server->params);
+        return false;
+    }
+
+    ok = sc_cond_init(&server->cond_stopped);
+    if (!ok) {
+        LOGE("Could not create server cond_stopped");
         sc_mutex_destroy(&server->mutex);
+        sc_server_params_destroy(&server->params);
         return false;
     }
 
-    server->process_terminated = false;
+    ok = sc_intr_init(&server->intr);
+    if (!ok) {
+        LOGE("Could not create intr");
+        sc_cond_destroy(&server->cond_stopped);
+        sc_mutex_destroy(&server->mutex);
+        sc_server_params_destroy(&server->params);
+        return false;
+    }
 
-    server->server_socket = INVALID_SOCKET;
-    server->video_socket = INVALID_SOCKET;
-    server->control_socket = INVALID_SOCKET;
+    server->stopped = false;
 
-    server->local_port = 0;
+    server->video_socket = SC_SOCKET_NONE;
+    server->control_socket = SC_SOCKET_NONE;
 
-    server->tunnel_enabled = false;
-    server->tunnel_forward = false;
+    sc_adb_tunnel_init(&server->tunnel);
+
+    assert(cbs);
+    assert(cbs->on_connection_failed);
+    assert(cbs->on_connected);
+    assert(cbs->on_disconnected);
+
+    server->cbs = cbs;
+    server->cbs_userdata = cbs_userdata;
+
+    return true;
+}
+
+static bool
+device_read_info(struct sc_intr *intr, sc_socket device_socket,
+                 struct sc_server_info *info) {
+    unsigned char buf[SC_DEVICE_NAME_FIELD_LENGTH + 4];
+    ssize_t r = net_recv_all_intr(intr, device_socket, buf, sizeof(buf));
+    if (r < SC_DEVICE_NAME_FIELD_LENGTH + 4) {
+        LOGE("Could not retrieve device information");
+        return false;
+    }
+    // in case the client sends garbage
+    buf[SC_DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
+    memcpy(info->device_name, (char *) buf, sizeof(info->device_name));
+
+    info->frame_size.width = (buf[SC_DEVICE_NAME_FIELD_LENGTH] << 8)
+                           | buf[SC_DEVICE_NAME_FIELD_LENGTH + 1];
+    info->frame_size.height = (buf[SC_DEVICE_NAME_FIELD_LENGTH + 2] << 8)
+                            | buf[SC_DEVICE_NAME_FIELD_LENGTH + 3];
+    return true;
+}
+
+static bool
+sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
+    struct sc_adb_tunnel *tunnel = &server->tunnel;
+
+    assert(tunnel->enabled);
+
+    const char *serial = server->params.serial;
+
+    sc_socket video_socket = SC_SOCKET_NONE;
+    sc_socket control_socket = SC_SOCKET_NONE;
+    if (!tunnel->forward) {
+        video_socket = net_accept_intr(&server->intr, tunnel->server_socket);
+        if (video_socket == SC_SOCKET_NONE) {
+            goto fail;
+        }
+
+        control_socket = net_accept_intr(&server->intr, tunnel->server_socket);
+        if (control_socket == SC_SOCKET_NONE) {
+            goto fail;
+        }
+    } else {
+        uint32_t attempts = 100;
+        sc_tick delay = SC_TICK_FROM_MS(100);
+        video_socket = connect_to_server(server, attempts, delay);
+        if (video_socket == SC_SOCKET_NONE) {
+            goto fail;
+        }
+
+        // we know that the device is listening, we don't need several attempts
+        control_socket = net_socket();
+        if (control_socket == SC_SOCKET_NONE) {
+            goto fail;
+        }
+        bool ok = net_connect_intr(&server->intr, control_socket,
+                                   IPV4_LOCALHOST, tunnel->local_port);
+        if (!ok) {
+            goto fail;
+        }
+    }
+
+    // we don't need the adb tunnel anymore
+    sc_adb_tunnel_close(tunnel, &server->intr, serial);
+
+    // The sockets will be closed on stop if device_read_info() fails
+    bool ok = device_read_info(&server->intr, video_socket, info);
+    if (!ok) {
+        goto fail;
+    }
+
+    assert(video_socket != SC_SOCKET_NONE);
+    assert(control_socket != SC_SOCKET_NONE);
+
+    server->video_socket = video_socket;
+    server->control_socket = control_socket;
+
+    return true;
+
+fail:
+    if (video_socket != SC_SOCKET_NONE) {
+        if (!net_close(video_socket)) {
+            LOGW("Could not close video socket");
+        }
+    }
+
+    if (control_socket != SC_SOCKET_NONE) {
+        if (!net_close(control_socket)) {
+            LOGW("Could not close control socket");
+        }
+    }
+
+    // Always leave this function with tunnel disabled
+    sc_adb_tunnel_close(tunnel, &server->intr, serial);
+
+    return false;
+}
+
+static void
+sc_server_on_terminated(void *userdata) {
+    struct sc_server *server = userdata;
+
+    // If the server process dies before connecting to the server socket,
+    // then the client will be stuck forever on accept(). To avoid the problem,
+    // wake up the accept() call (or any other) when the server dies, like on
+    // stop() (it is safe to call interrupt() twice).
+    sc_intr_interrupt(&server->intr);
+
+    server->cbs->on_disconnected(server, server->cbs_userdata);
+
+    LOGD("Server terminated");
+}
+
+static bool
+sc_server_fill_serial(struct sc_server *server) {
+    // Retrieve the actual device immediately if not provided, so that all
+    // future adb commands are executed for this specific device, even if other
+    // devices are connected afterwards (without "more than one
+    // device/emulator" error)
+    if (!server->params.serial) {
+        // The serial is owned by sc_server_params, and will be freed on destroy
+        server->params.serial = adb_get_serialno(&server->intr,
+                                                 SC_INHERIT_STDERR);
+        if (!server->params.serial) {
+            LOGE("Could not get device serial");
+            return false;
+        }
+    }
 
     return true;
 }
 
 static int
-run_wait_server(void *data) {
-    struct server *server = data;
-    process_wait(server->process, false); // ignore exit code
+run_server(void *data) {
+    struct sc_server *server = data;
 
-    sc_mutex_lock(&server->mutex);
-    server->process_terminated = true;
-    sc_cond_signal(&server->process_terminated_cond);
-    sc_mutex_unlock(&server->mutex);
-
-    // no need for synchronization, server_socket is initialized before this
-    // thread was created
-    if (server->server_socket != INVALID_SOCKET
-            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
-        // On Linux, accept() is unblocked by shutdown(), but on Windows, it is
-        // unblocked by closesocket(). Therefore, call both (close_socket()).
-        close_socket(server->server_socket);
-    }
-    LOGD("Server terminated");
-    return 0;
+    if (!sc_server_fill_serial(server)) {
+        goto error_connection_failed;
     }
 
-bool
-server_start(struct server *server, const struct server_params *params) {
-    if (params->serial) {
-        server->serial = strdup(params->serial);
-        if (!server->serial) {
-            return false;
-        }
+    const struct sc_server_params *params = &server->params;
+
+    LOGD("Device serial: %s", params->serial);
+
+    bool ok = push_server(&server->intr, params->serial);
+    if (!ok) {
+        goto error_connection_failed;
     }
 
-    if (!push_server(params->serial)) {
-        /* server->serial will be freed on server_destroy() */
-        return false;
-    }
+    LOGI("Server pushed");
 
-    if (!enable_tunnel_any_port(server, params->port_range,
-                                params->force_adb_forward)) {
-        return false;
+    ok = sc_adb_tunnel_open(&server->tunnel, &server->intr, params->serial,
+                            params->port_range, params->force_adb_forward);
+    if (!ok) {
+        goto error_connection_failed;
     }
 
     // server will connect to our server socket
-    server->process = execute_server(server, params);
-    if (server->process == PROCESS_NONE) {
-        goto error;
+    sc_pid pid = execute_server(server, params);
+    if (pid == SC_PROCESS_NONE) {
+        sc_adb_tunnel_close(&server->tunnel, &server->intr, params->serial);
+        goto error_connection_failed;
     }
 
-    // If the server process dies before connecting to the server socket, then
-    // the client will be stuck forever on accept(). To avoid the problem, we
-    // must be able to wake up the accept() call when the server dies. To keep
-    // things simple and multiplatform, just spawn a new thread waiting for the
-    // server process and calling shutdown()/close() on the server socket if
-    // necessary to wake up any accept() blocking call.
-    bool ok = sc_thread_create(&server->wait_server_thread, run_wait_server,
-                               "wait-server", server);
+    static const struct sc_process_listener listener = {
+        .on_terminated = sc_server_on_terminated,
+    };
+    struct sc_process_observer observer;
+    ok = sc_process_observer_init(&observer, pid, &listener, server);
     if (!ok) {
-        process_terminate(server->process);
-        process_wait(server->process, true); // ignore exit code
-        goto error;
+        sc_process_terminate(pid);
+        sc_process_wait(pid, true); // ignore exit code
+        sc_adb_tunnel_close(&server->tunnel, &server->intr, params->serial);
+        goto error_connection_failed;
     }
 
-    server->tunnel_enabled = true;
-
-    return true;
-
-error:
-    if (!server->tunnel_forward) {
-        bool was_closed =
-            atomic_flag_test_and_set(&server->server_socket_closed);
-        // the thread is not started, the flag could not be already set
-        assert(!was_closed);
-        (void) was_closed;
-        close_socket(server->server_socket);
-    }
-    disable_tunnel(server);
-
-    return false;
+    ok = sc_server_connect_to(server, &server->info);
+    // The tunnel is always closed by server_connect_to()
+    if (!ok) {
+        sc_process_terminate(pid);
+        sc_process_wait(pid, true); // ignore exit code
+        sc_process_observer_join(&observer);
+        sc_process_observer_destroy(&observer);
+        goto error_connection_failed;
     }
 
-static bool
-device_read_info(socket_t device_socket, char *device_name, struct size *size) {
-    unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
-    int r = net_recv_all(device_socket, buf, sizeof(buf));
-    if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
-        LOGE("Could not retrieve device information");
-        return false;
-    }
-    // in case the client sends garbage
-    buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
-    // strcpy is safe here, since name contains at least
-    // DEVICE_NAME_FIELD_LENGTH bytes and strlen(buf) < DEVICE_NAME_FIELD_LENGTH
-    strcpy(device_name, (char *) buf);
-    size->width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
-            | buf[DEVICE_NAME_FIELD_LENGTH + 1];
-    size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
-            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
-    return true;
-}
+    // Now connected
+    server->cbs->on_connected(server, server->cbs_userdata);
 
-bool
-server_connect_to(struct server *server, char *device_name, struct size *size) {
-    if (!server->tunnel_forward) {
-        server->video_socket = net_accept(server->server_socket);
-        if (server->video_socket == INVALID_SOCKET) {
-            return false;
-        }
-
-        server->control_socket = net_accept(server->server_socket);
-        if (server->control_socket == INVALID_SOCKET) {
-            // the video_socket will be cleaned up on destroy
-            return false;
-        }
-
-        // we don't need the server socket anymore
-        if (!atomic_flag_test_and_set(&server->server_socket_closed)) {
-            // close it from here
-            close_socket(server->server_socket);
-            // otherwise, it is closed by run_wait_server()
-        }
-    } else {
-        uint32_t attempts = 100;
-        uint32_t delay = 100; // ms
-        server->video_socket =
-            connect_to_server(server->local_port, attempts, delay);
-        if (server->video_socket == INVALID_SOCKET) {
-            return false;
-        }
-
-        // we know that the device is listening, we don't need several attempts
-        server->control_socket =
-            net_connect(IPV4_LOCALHOST, server->local_port);
-        if (server->control_socket == INVALID_SOCKET) {
-            return false;
-        }
-    }
-
-    // we don't need the adb tunnel anymore
-    disable_tunnel(server); // ignore failure
-    server->tunnel_enabled = false;
-
-    // The sockets will be closed on stop if device_read_info() fails
-    return device_read_info(server->video_socket, device_name, size);
-}
-
-void
-server_stop(struct server *server) {
-    if (server->server_socket != INVALID_SOCKET
-            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
-        close_socket(server->server_socket);
-    }
-    if (server->video_socket != INVALID_SOCKET) {
-        close_socket(server->video_socket);
-    }
-    if (server->control_socket != INVALID_SOCKET) {
-        close_socket(server->control_socket);
-    }
-
-    assert(server->process != PROCESS_NONE);
-
-    if (server->tunnel_enabled) {
-        // ignore failure
-        disable_tunnel(server);
-    }
-
-    // Give some delay for the server to terminate properly
+    // Wait for server_stop()
     sc_mutex_lock(&server->mutex);
-    bool signaled = false;
-    if (!server->process_terminated) {
-#define WATCHDOG_DELAY_MS 1000
-        signaled = sc_cond_timedwait(&server->process_terminated_cond,
-                                     &server->mutex,
-                                     WATCHDOG_DELAY_MS);
+    while (!server->stopped) {
+        sc_cond_wait(&server->cond_stopped, &server->mutex);
     }
     sc_mutex_unlock(&server->mutex);
 
+    // Give some delay for the server to terminate properly
+#define WATCHDOG_DELAY SC_TICK_FROM_SEC(1)
+    sc_tick deadline = sc_tick_now() + WATCHDOG_DELAY;
+    bool terminated = sc_process_observer_timedwait(&observer, deadline);
+
     // After this delay, kill the server if it's not dead already.
     // On some devices, closing the sockets is not sufficient to wake up the
     // blocking calls while the device is asleep.
-    if (!signaled) {
-        // The process is terminated, but not reaped (closed) yet, so its PID
-        // is still valid.
+    if (!terminated) {
+        // The process may have terminated since the check, but it is not
+        // reaped (closed) yet, so its PID is still valid, and it is ok to call
+        // sc_process_terminate() even in that case.
         LOGW("Killing the server...");
-        process_terminate(server->process);
+        sc_process_terminate(pid);
     }
 
-    sc_thread_join(&server->wait_server_thread, NULL);
-    process_close(server->process);
+    sc_process_observer_join(&observer);
+    sc_process_observer_destroy(&observer);
+
+    sc_process_close(pid);
+
+    return 0;
+
+error_connection_failed:
+    server->cbs->on_connection_failed(server, server->cbs_userdata);
+    return -1;
+}
+
+bool
+sc_server_start(struct sc_server *server) {
+    bool ok = sc_thread_create(&server->thread, run_server, "server", server);
+    if (!ok) {
+        LOGE("Could not create server thread");
+        return false;
+    }
+
+    return true;
 }
 
 void
-server_destroy(struct server *server) {
-    free(server->serial);
-    sc_cond_destroy(&server->process_terminated_cond);
+sc_server_stop(struct sc_server *server) {
+    sc_mutex_lock(&server->mutex);
+    server->stopped = true;
+    sc_cond_signal(&server->cond_stopped);
+    sc_intr_interrupt(&server->intr);
+    sc_mutex_unlock(&server->mutex);
+
+    sc_thread_join(&server->thread, NULL);
+}
+
+void
+sc_server_destroy(struct sc_server *server) {
+    sc_server_params_destroy(&server->params);
+    sc_intr_destroy(&server->intr);
+    sc_cond_destroy(&server->cond_stopped);
     sc_mutex_destroy(&server->mutex);
 }

app/src/server.h

@@ -8,31 +8,21 @@
 #include <stdint.h>
 
 #include "adb.h"
+#include "adb_tunnel.h"
 #include "coords.h"
-#include "scrcpy.h"
+#include "options.h"
+#include "util/intr.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/thread.h"
 
-struct server {
-    char *serial;
-    process_t process;
-    sc_thread wait_server_thread;
-    atomic_flag server_socket_closed;
-
-    sc_mutex mutex;
-    sc_cond process_terminated_cond;
-    bool process_terminated;
-
-    socket_t server_socket; // only used if !tunnel_forward
-    socket_t video_socket;
-    socket_t control_socket;
-    uint16_t local_port; // selected from port_range
-    bool tunnel_enabled;
-    bool tunnel_forward; // use "adb forward" instead of "adb reverse"
+#define SC_DEVICE_NAME_FIELD_LENGTH 64
+struct sc_server_info {
+    char device_name[SC_DEVICE_NAME_FIELD_LENGTH];
+    struct sc_size frame_size;
 };
 
-struct server_params {
+struct sc_server_params {
     const char *serial;
     enum sc_log_level log_level;
     const char *crop;
@@ -51,26 +41,62 @@ struct server_params {
     bool power_off_on_close;
 };
 
-// init default values
-bool
-server_init(struct server *server);
+struct sc_server {
+    // The internal allocated strings are copies owned by the server
+    struct sc_server_params params;
 
-// push, enable tunnel et start the server
-bool
-server_start(struct server *server, const struct server_params *params);
+    sc_thread thread;
+    struct sc_server_info info; // initialized once connected
 
-#define DEVICE_NAME_FIELD_LENGTH 64
-// block until the communication with the server is established
-// device_name must point to a buffer of at least DEVICE_NAME_FIELD_LENGTH bytes
+    sc_mutex mutex;
+    sc_cond cond_stopped;
+    bool stopped;
+
+    struct sc_intr intr;
+    struct sc_adb_tunnel tunnel;
+
+    sc_socket video_socket;
+    sc_socket control_socket;
+
+    const struct sc_server_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+struct sc_server_callbacks {
+    /**
+     * Called when the server failed to connect
+     *
+     * If it is called, then on_connected() and on_disconnected() will never be
+     * called.
+     */
+    void (*on_connection_failed)(struct sc_server *server, void *userdata);
+
+    /**
+     * Called on server connection
+     */
+    void (*on_connected)(struct sc_server *server, void *userdata);
+
+    /**
+     * Called on server disconnection (after it has been connected)
+     */
+    void (*on_disconnected)(struct sc_server *server, void *userdata);
+};
+
+// init the server with the given params
 bool
-server_connect_to(struct server *server, char *device_name, struct size *size);
+sc_server_init(struct sc_server *server, const struct sc_server_params *params,
+               const struct sc_server_callbacks *cbs, void *cbs_userdata);
+
+// start the server asynchronously
+bool
+sc_server_start(struct sc_server *server);
 
 // disconnect and kill the server process
 void
-server_stop(struct server *server);
+sc_server_stop(struct sc_server *server);
 
 // close and release sockets
 void
-server_destroy(struct server *server);
+sc_server_destroy(struct sc_server *server);
 
 #endif

app/src/stream.c

@@ -151,7 +151,6 @@ stream_push_packet(struct stream *stream, AVPacket *packet) {
 
         if (stream->pending) {
             // the pending packet must be discarded (consumed or error)
-            av_packet_unref(stream->pending);
             av_packet_free(&stream->pending);
         }
 
@@ -244,7 +243,6 @@ run_stream(void *data) {
     LOGD("End of frames");
 
     if (stream->pending) {
-        av_packet_unref(stream->pending);
         av_packet_free(&stream->pending);
     }
 
@@ -262,7 +260,7 @@ end:
 }
 
 void
-stream_init(struct stream *stream, socket_t socket,
+stream_init(struct stream *stream, sc_socket socket,
             const struct stream_callbacks *cbs, void *cbs_userdata) {
     stream->socket = socket;
     stream->pending = NULL;

app/src/stream.h

@@ -14,7 +14,7 @@
 #define STREAM_MAX_SINKS 2
 
 struct stream {
-    socket_t socket;
+    sc_socket socket;
     sc_thread thread;
 
     struct sc_packet_sink *sinks[STREAM_MAX_SINKS];
@@ -35,7 +35,7 @@ struct stream_callbacks {
 };
 
 void
-stream_init(struct stream *stream, socket_t socket,
+stream_init(struct stream *stream, sc_socket socket,
             const struct stream_callbacks *cbs, void *cbs_userdata);
 
 void

app/src/sys/unix/file.c

@@ -0,0 +1,75 @@
+#include "util/file.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+bool
+sc_file_executable_exists(const char *file) {
+    char *path = getenv("PATH");
+    if (!path)
+        return false;
+    path = strdup(path);
+    if (!path)
+        return false;
+
+    bool ret = false;
+    size_t file_len = strlen(file);
+    char *saveptr;
+    for (char *dir = strtok_r(path, ":", &saveptr); dir;
+            dir = strtok_r(NULL, ":", &saveptr)) {
+        size_t dir_len = strlen(dir);
+        char *fullpath = malloc(dir_len + file_len + 2);
+        if (!fullpath)
+            continue;
+        memcpy(fullpath, dir, dir_len);
+        fullpath[dir_len] = '/';
+        memcpy(fullpath + dir_len + 1, file, file_len + 1);
+
+        struct stat sb;
+        bool fullpath_executable = stat(fullpath, &sb) == 0 &&
+            sb.st_mode & S_IXUSR;
+        free(fullpath);
+        if (fullpath_executable) {
+            ret = true;
+            break;
+        }
+    }
+
+    free(path);
+    return ret;
+}
+
+char *
+sc_file_get_executable_path(void) {
+// <https://stackoverflow.com/a/1024937/1987178>
+#ifdef __linux__
+    char buf[PATH_MAX + 1]; // +1 for the null byte
+    ssize_t len = readlink("/proc/self/exe", buf, PATH_MAX);
+    if (len == -1) {
+        perror("readlink");
+        return NULL;
+    }
+    buf[len] = '\0';
+    return strdup(buf);
+#else
+    // in practice, we only need this feature for portable builds, only used on
+    // Windows, so we don't care implementing it for every platform
+    // (it's useful to have a working version on Linux for debugging though)
+    return NULL;
+#endif
+}
+
+bool
+sc_file_is_regular(const char *path) {
+    struct stat path_stat;
+
+    if (stat(path, &path_stat)) {
+        perror("stat");
+        return false;
+    }
+    return S_ISREG(path_stat.st_mode);
+}
+

app/src/sys/unix/process.c

@@ -1,118 +1,179 @@
 #include "util/process.h"
 
+#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <limits.h>
 #include <signal.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include "util/log.h"
 
-bool
-search_executable(const char *file) {
-    char *path = getenv("PATH");
-    if (!path)
-        return false;
-    path = strdup(path);
-    if (!path)
-        return false;
+enum sc_process_result
+sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned inherit,
+                     int *pin, int *pout, int *perr) {
+    bool inherit_stdout = inherit & SC_INHERIT_STDOUT;
+    bool inherit_stderr = inherit & SC_INHERIT_STDERR;
 
-    bool ret = false;
-    size_t file_len = strlen(file);
-    char *saveptr;
-    for (char *dir = strtok_r(path, ":", &saveptr); dir;
-            dir = strtok_r(NULL, ":", &saveptr)) {
-        size_t dir_len = strlen(dir);
-        char *fullpath = malloc(dir_len + file_len + 2);
-        if (!fullpath)
-            continue;
-        memcpy(fullpath, dir, dir_len);
-        fullpath[dir_len] = '/';
-        memcpy(fullpath + dir_len + 1, file, file_len + 1);
+    // If pout is defined, then inherit MUST NOT contain SC_INHERIT_STDOUT.
+    assert(!pout || !inherit_stdout);
+    // If perr is defined, then inherit MUST NOT contain SC_INHERIT_STDERR.
+    assert(!perr || !inherit_stderr);
 
-        struct stat sb;
-        bool fullpath_executable = stat(fullpath, &sb) == 0 &&
-            sb.st_mode & S_IXUSR;
-        free(fullpath);
-        if (fullpath_executable) {
-            ret = true;
-            break;
-        }
-    }
+    int in[2];
+    int out[2];
+    int err[2];
+    int internal[2]; // communication between parent and children
 
-    free(path);
-    return ret;
-}
-
-enum process_result
-process_execute(const char *const argv[], pid_t *pid) {
-    int fd[2];
-
-    if (pipe(fd) == -1) {
+    if (pipe(internal) == -1) {
         perror("pipe");
-        return PROCESS_ERROR_GENERIC;
+        return SC_PROCESS_ERROR_GENERIC;
+    }
+    if (pin) {
+        if (pipe(in) == -1) {
+            perror("pipe");
+            close(internal[0]);
+            close(internal[1]);
+            return SC_PROCESS_ERROR_GENERIC;
+        }
+    }
+    if (pout) {
+        if (pipe(out) == -1) {
+            perror("pipe");
+            // clean up
+            if (pin) {
+                close(in[0]);
+                close(in[1]);
+            }
+            close(internal[0]);
+            close(internal[1]);
+            return SC_PROCESS_ERROR_GENERIC;
+        }
+    }
+    if (perr) {
+        if (pipe(err) == -1) {
+            perror("pipe");
+            // clean up
+            if (pout) {
+                close(out[0]);
+                close(out[1]);
+            }
+            if (pin) {
+                close(in[0]);
+                close(in[1]);
+            }
+            close(internal[0]);
+            close(internal[1]);
+            return SC_PROCESS_ERROR_GENERIC;
+        }
     }
-
-    enum process_result ret = PROCESS_SUCCESS;
 
     *pid = fork();
     if (*pid == -1) {
         perror("fork");
-        ret = PROCESS_ERROR_GENERIC;
-        goto end;
+        // clean up
+        if (perr) {
+            close(err[0]);
+            close(err[1]);
+        }
+        if (pout) {
+            close(out[0]);
+            close(out[1]);
+        }
+        if (pin) {
+            close(in[0]);
+            close(in[1]);
+        }
+        close(internal[0]);
+        close(internal[1]);
+        return SC_PROCESS_ERROR_GENERIC;
     }
 
-    if (*pid > 0) {
-        // parent close write side
-        close(fd[1]);
-        fd[1] = -1;
-        // wait for EOF or receive errno from child
-        if (read(fd[0], &ret, sizeof(ret)) == -1) {
-            perror("read");
-            ret = PROCESS_ERROR_GENERIC;
-            goto end;
+    if (*pid == 0) {
+        if (pin) {
+            if (in[0] != STDIN_FILENO) {
+                dup2(in[0], STDIN_FILENO);
+                close(in[0]);
             }
-    } else if (*pid == 0) {
-        // child close read side
-        close(fd[0]);
-        if (fcntl(fd[1], F_SETFD, FD_CLOEXEC) == 0) {
+            close(in[1]);
+        }
+        // Do not close stdin in the child process, this makes adb fail on
+        // Linux
+
+        if (pout) {
+            if (out[1] != STDOUT_FILENO) {
+                dup2(out[1], STDOUT_FILENO);
+                close(out[1]);
+            }
+            close(out[0]);
+        } else if (!inherit_stdout) {
+            // Close stdout in the child process
+            close(STDOUT_FILENO);
+        }
+
+        if (perr) {
+            if (err[1] != STDERR_FILENO) {
+                dup2(err[1], STDERR_FILENO);
+                close(err[1]);
+            }
+            close(err[0]);
+        } else if (!inherit_stderr) {
+            // Close stderr in the child process
+            close(STDERR_FILENO);
+        }
+
+        close(internal[0]);
+        enum sc_process_result err;
+        if (fcntl(internal[1], F_SETFD, FD_CLOEXEC) == 0) {
             execvp(argv[0], (char *const *) argv);
-            if (errno == ENOENT) {
-                ret = PROCESS_ERROR_MISSING_BINARY;
-            } else {
-                ret = PROCESS_ERROR_GENERIC;
-            }
             perror("exec");
+            err = errno == ENOENT ? SC_PROCESS_ERROR_MISSING_BINARY
+                                  : SC_PROCESS_ERROR_GENERIC;
         } else {
             perror("fcntl");
-            ret = PROCESS_ERROR_GENERIC;
+            err = SC_PROCESS_ERROR_GENERIC;
         }
-        // send ret to the parent
-        if (write(fd[1], &ret, sizeof(ret)) == -1) {
+        // send err to the parent
+        if (write(internal[1], &err, sizeof(err)) == -1) {
             perror("write");
         }
-        // close write side before exiting
-        close(fd[1]);
+        close(internal[1]);
         _exit(1);
     }
 
-end:
-    if (fd[0] != -1) {
-        close(fd[0]);
+    // parent
+    assert(*pid > 0);
+
+    close(internal[1]);
+
+    enum sc_process_result res = SC_PROCESS_SUCCESS;
+    // wait for EOF or receive err from child
+    if (read(internal[0], &res, sizeof(res)) == -1) {
+        perror("read");
+        res = SC_PROCESS_ERROR_GENERIC;
     }
-    if (fd[1] != -1) {
-        close(fd[1]);
+
+    close(internal[0]);
+
+    if (pin) {
+        close(in[0]);
+        *pin = in[1];
     }
-    return ret;
+    if (pout) {
+        *pout = out[0];
+        close(out[1]);
+    }
+    if (perr) {
+        *perr = err[0];
+        close(err[1]);
+    }
+
+    return res;
 }
 
 bool
-process_terminate(pid_t pid) {
+sc_process_terminate(pid_t pid) {
     if (pid <= 0) {
         LOGC("Requested to kill %d, this is an error. Please report the bug.\n",
              (int) pid);
@@ -121,8 +182,8 @@ process_terminate(pid_t pid) {
     return kill(pid, SIGKILL) != -1;
 }
 
-exit_code_t
-process_wait(pid_t pid, bool close) {
+sc_exit_code
+sc_process_wait(pid_t pid, bool close) {
     int code;
     int options = WEXITED;
     if (!close) {
@@ -133,7 +194,7 @@ process_wait(pid_t pid, bool close) {
     int r = waitid(P_PID, pid, &info, options);
     if (r == -1 || info.si_code != CLD_EXITED) {
         // could not wait, or exited unexpectedly, probably by a signal
-        code = NO_EXIT_CODE;
+        code = SC_EXIT_CODE_NONE;
     } else {
         code = info.si_status;
     }
@@ -141,37 +202,18 @@ process_wait(pid_t pid, bool close) {
 }
 
 void
-process_close(pid_t pid) {
-    process_wait(pid, true); // ignore exit code
+sc_process_close(pid_t pid) {
+    sc_process_wait(pid, true); // ignore exit code
 }
 
-char *
-get_executable_path(void) {
-// <https://stackoverflow.com/a/1024937/1987178>
-#ifdef __linux__
-    char buf[PATH_MAX + 1]; // +1 for the null byte
-    ssize_t len = readlink("/proc/self/exe", buf, PATH_MAX);
-    if (len == -1) {
-        perror("readlink");
-        return NULL;
-    }
-    buf[len] = '\0';
-    return strdup(buf);
-#else
-    // in practice, we only need this feature for portable builds, only used on
-    // Windows, so we don't care implementing it for every platform
-    // (it's useful to have a working version on Linux for debugging though)
-    return NULL;
-#endif
+ssize_t
+sc_pipe_read(int pipe, char *data, size_t len) {
+    return read(pipe, data, len);
 }
 
-bool
-is_regular_file(const char *path) {
-    struct stat path_stat;
-
-    if (stat(path, &path_stat)) {
-        perror("stat");
-        return false;
+void
+sc_pipe_close(int pipe) {
+    if (close(pipe)) {
+        perror("close pipe");
     }
-    return S_ISREG(path_stat.st_mode);
 }

app/src/sys/win/file.c

@@ -0,0 +1,43 @@
+#include "util/file.h"
+
+#include <windows.h>
+
+#include <sys/stat.h>
+
+#include "util/log.h"
+#include "util/str.h"
+
+char *
+sc_file_get_executable_path(void) {
+    HMODULE hModule = GetModuleHandleW(NULL);
+    if (!hModule) {
+        return NULL;
+    }
+    WCHAR buf[MAX_PATH + 1]; // +1 for the null byte
+    int len = GetModuleFileNameW(hModule, buf, MAX_PATH);
+    if (!len) {
+        return NULL;
+    }
+    buf[len] = '\0';
+    return sc_str_from_wchars(buf);
+}
+
+bool
+sc_file_is_regular(const char *path) {
+    wchar_t *wide_path = sc_str_to_wchars(path);
+    if (!wide_path) {
+        LOGC("Could not allocate wide char string");
+        return false;
+    }
+
+    struct _stat path_stat;
+    int r = _wstat(wide_path, &path_stat);
+    free(wide_path);
+
+    if (r) {
+        perror("stat");
+        return false;
+    }
+    return S_ISREG(path_stat.st_mode);
+}
+

app/src/sys/win/process.c

@@ -1,10 +1,14 @@
+// <https://devblogs.microsoft.com/oldnewthing/20111216-00/?p=8873>
+#define _WIN32_WINNT 0x0600 // For extended process API
+
 #include "util/process.h"
 
+#include <processthreadsapi.h>
+
 #include <assert.h>
-#include <sys/stat.h>
 
 #include "util/log.h"
-#include "util/str_util.h"
+#include "util/str.h"
 
 #define CMD_MAX_LEN 8192
 
@@ -14,61 +18,199 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
     // <http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS>
     // only make it work for this very specific program
     // (don't handle escaping nor quotes)
-    size_t ret = xstrjoin(cmd, argv, ' ', len);
+    size_t ret = sc_str_join(cmd, argv, ' ', len);
     if (ret >= len) {
-        LOGE("Command too long (%" PRIsizet " chars)", len - 1);
+        LOGE("Command too long (%" SC_PRIsizet " chars)", len - 1);
         return false;
     }
     return true;
 }
 
-enum process_result
-process_execute(const char *const argv[], HANDLE *handle) {
-    STARTUPINFOW si;
+enum sc_process_result
+sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned inherit,
+                     HANDLE *pin, HANDLE *pout, HANDLE *perr) {
+    bool inherit_stdout = inherit & SC_INHERIT_STDOUT;
+    bool inherit_stderr = inherit & SC_INHERIT_STDERR;
+
+    // If pout is defined, then inherit MUST NOT contain SC_INHERIT_STDOUT.
+    assert(!pout || !inherit_stdout);
+    // If perr is defined, then inherit MUST NOT contain SC_INHERIT_STDERR.
+    assert(!perr || !inherit_stderr);
+
+    enum sc_process_result ret = SC_PROCESS_ERROR_GENERIC;
+
+    SECURITY_ATTRIBUTES sa;
+    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+    sa.lpSecurityDescriptor = NULL;
+    sa.bInheritHandle = TRUE;
+
+    HANDLE stdin_read_handle;
+    HANDLE stdout_write_handle;
+    HANDLE stderr_write_handle;
+    if (pin) {
+        if (!CreatePipe(&stdin_read_handle, pin, &sa, 0)) {
+            perror("pipe");
+            return SC_PROCESS_ERROR_GENERIC;
+        }
+        if (!SetHandleInformation(*pin, HANDLE_FLAG_INHERIT, 0)) {
+            LOGE("SetHandleInformation stdin failed");
+            goto error_close_stdin;
+        }
+    }
+    if (pout) {
+        if (!CreatePipe(pout, &stdout_write_handle, &sa, 0)) {
+            perror("pipe");
+            goto error_close_stdin;
+        }
+        if (!SetHandleInformation(*pout, HANDLE_FLAG_INHERIT, 0)) {
+            LOGE("SetHandleInformation stdout failed");
+            goto error_close_stdout;
+        }
+    }
+    if (perr) {
+        if (!CreatePipe(perr, &stderr_write_handle, &sa, 0)) {
+            perror("pipe");
+            goto error_close_stdout;
+        }
+        if (!SetHandleInformation(*perr, HANDLE_FLAG_INHERIT, 0)) {
+            LOGE("SetHandleInformation stderr failed");
+            goto error_close_stderr;
+        }
+    }
+
+    STARTUPINFOEXW si;
     PROCESS_INFORMATION pi;
     memset(&si, 0, sizeof(si));
-    si.cb = sizeof(si);
+    si.StartupInfo.cb = sizeof(si);
+    HANDLE handles[3];
+
+    LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList = NULL;
+    si.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
+
+    unsigned handle_count = 0;
+    if (pin) {
+        si.StartupInfo.hStdInput = stdin_read_handle;
+        handles[handle_count++] = si.StartupInfo.hStdInput;
+    }
+    if (pout || inherit_stdout) {
+        si.StartupInfo.hStdOutput = pout ? stdout_write_handle
+                                         : GetStdHandle(STD_OUTPUT_HANDLE);
+        handles[handle_count++] = si.StartupInfo.hStdOutput;
+    }
+    if (perr || inherit_stderr) {
+        si.StartupInfo.hStdError = perr ? stderr_write_handle
+                                        : GetStdHandle(STD_ERROR_HANDLE);
+        handles[handle_count++] = si.StartupInfo.hStdError;
+    }
+
+    SIZE_T size;
+    // Call it once to know the required buffer size
+    BOOL ok =
+        InitializeProcThreadAttributeList(NULL, 1, 0, &size)
+            || GetLastError() == ERROR_INSUFFICIENT_BUFFER;
+    if (!ok) {
+        goto error_close_stderr;
+    }
+
+    lpAttributeList = malloc(size);
+    if (!lpAttributeList) {
+        goto error_close_stderr;
+    }
+
+    ok = InitializeProcThreadAttributeList(lpAttributeList, 1, 0, &size);
+    if (!ok) {
+        free(lpAttributeList);
+        goto error_close_stderr;
+    }
+
+    ok = UpdateProcThreadAttribute(lpAttributeList, 0,
+                                   PROC_THREAD_ATTRIBUTE_HANDLE_LIST, handles,
+                                   handle_count * sizeof(HANDLE), NULL, NULL);
+    if (!ok) {
+        goto error_free_attribute_list;
+    }
+
+    si.lpAttributeList = lpAttributeList;
 
     char *cmd = malloc(CMD_MAX_LEN);
     if (!cmd || !build_cmd(cmd, CMD_MAX_LEN, argv)) {
-        *handle = NULL;
-        return PROCESS_ERROR_GENERIC;
+        goto error_free_attribute_list;
     }
 
-    wchar_t *wide = utf8_to_wide_char(cmd);
+    wchar_t *wide = sc_str_to_wchars(cmd);
     free(cmd);
     if (!wide) {
         LOGC("Could not allocate wide char string");
-        return PROCESS_ERROR_GENERIC;
+        goto error_free_attribute_list;
     }
 
-    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, 0, NULL, NULL, &si,
-                        &pi)) {
+    ok = CreateProcessW(NULL, wide, NULL, NULL, TRUE,
+                        EXTENDED_STARTUPINFO_PRESENT, NULL, NULL,
+                        &si.StartupInfo, &pi);
     free(wide);
-        *handle = NULL;
+    if (!ok) {
         if (GetLastError() == ERROR_FILE_NOT_FOUND) {
-            return PROCESS_ERROR_MISSING_BINARY;
+            ret = SC_PROCESS_ERROR_MISSING_BINARY;
         }
-        return PROCESS_ERROR_GENERIC;
+        goto error_free_attribute_list;
+    }
+
+    if (lpAttributeList) {
+        DeleteProcThreadAttributeList(lpAttributeList);
+        free(lpAttributeList);
+    }
+
+    // These handles are used by the child process, close them for this process
+    if (pin) {
+        CloseHandle(stdin_read_handle);
+    }
+    if (pout) {
+        CloseHandle(stdout_write_handle);
+    }
+    if (perr) {
+        CloseHandle(stderr_write_handle);
     }
 
-    free(wide);
     *handle = pi.hProcess;
-    return PROCESS_SUCCESS;
+
+    return SC_PROCESS_SUCCESS;
+
+error_free_attribute_list:
+    if (lpAttributeList) {
+        DeleteProcThreadAttributeList(lpAttributeList);
+        free(lpAttributeList);
+    }
+error_close_stderr:
+    if (perr) {
+        CloseHandle(*perr);
+        CloseHandle(stderr_write_handle);
+    }
+error_close_stdout:
+    if (pout) {
+        CloseHandle(*pout);
+        CloseHandle(stdout_write_handle);
+    }
+error_close_stdin:
+    if (pin) {
+        CloseHandle(*pin);
+        CloseHandle(stdin_read_handle);
+    }
+
+    return ret;
 }
 
 bool
-process_terminate(HANDLE handle) {
+sc_process_terminate(HANDLE handle) {
     return TerminateProcess(handle, 1);
 }
 
-exit_code_t
-process_wait(HANDLE handle, bool close) {
+sc_exit_code
+sc_process_wait(HANDLE handle, bool close) {
     DWORD code;
     if (WaitForSingleObject(handle, INFINITE) != WAIT_OBJECT_0
             || !GetExitCodeProcess(handle, &code)) {
         // could not wait or retrieve the exit code
-        code = NO_EXIT_CODE; // max value, it's unsigned
+        code = SC_EXIT_CODE_NONE;
     }
     if (close) {
         CloseHandle(handle);
@@ -77,42 +219,24 @@ process_wait(HANDLE handle, bool close) {
 }
 
 void
-process_close(HANDLE handle) {
+sc_process_close(HANDLE handle) {
     bool closed = CloseHandle(handle);
     assert(closed);
     (void) closed;
 }
 
-char *
-get_executable_path(void) {
-    HMODULE hModule = GetModuleHandleW(NULL);
-    if (!hModule) {
-        return NULL;
+ssize_t
+sc_pipe_read(HANDLE pipe, char *data, size_t len) {
+    DWORD r;
+    if (!ReadFile(pipe, data, len, &r, NULL)) {
+        return -1;
     }
-    WCHAR buf[MAX_PATH + 1]; // +1 for the null byte
-    int len = GetModuleFileNameW(hModule, buf, MAX_PATH);
-    if (!len) {
-        return NULL;
-    }
-    buf[len] = '\0';
-    return utf8_from_wide_char(buf);
+    return r;
 }
 
-bool
-is_regular_file(const char *path) {
-    wchar_t *wide_path = utf8_to_wide_char(path);
-    if (!wide_path) {
-        LOGC("Could not allocate wide char string");
-        return false;
+void
+sc_pipe_close(HANDLE pipe) {
+    if (!CloseHandle(pipe)) {
+        LOGW("Cannot close pipe");
     }
-
-    struct _stat path_stat;
-    int r = _wstat(wide_path, &path_stat);
-    free(wide_path);
-
-    if (r) {
-        perror("stat");
-        return false;
-    }
-    return S_ISREG(path_stat.st_mode);
 }

app/src/tiny_xpm.c

@@ -1,119 +0,0 @@
-#include "tiny_xpm.h"
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "util/log.h"
-
-struct index {
-    char c;
-    uint32_t color;
-};
-
-static bool
-find_color(struct index *index, int len, char c, uint32_t *color) {
-    // there are typically very few color, so it's ok to iterate over the array
-    for (int i = 0; i < len; ++i) {
-        if (index[i].c == c) {
-            *color = index[i].color;
-            return true;
-        }
-    }
-    *color = 0;
-    return false;
-}
-
-// We encounter some problems with SDL2_image on MSYS2 (Windows),
-// so here is our own XPM parsing not to depend on SDL_image.
-//
-// We do not hardcode the binary image to keep some flexibility to replace the
-// icon easily (just by replacing icon.xpm).
-//
-// Parameter is not "const char *" because XPM formats are generally stored in a
-// (non-const) "char *"
-SDL_Surface *
-read_xpm(char *xpm[]) {
-#ifndef NDEBUG
-    // patch the XPM to change the icon color in debug mode
-    xpm[2] = ".	c #CC00CC";
-#endif
-
-    char *endptr;
-    // *** No error handling, assume the XPM source is valid ***
-    // (it's in our source repo)
-    // Assertions are only checked in debug
-    int width = strtol(xpm[0], &endptr, 10);
-    int height = strtol(endptr + 1, &endptr, 10);
-    int colors = strtol(endptr + 1, &endptr, 10);
-    int chars = strtol(endptr + 1, &endptr, 10);
-
-    // sanity checks
-    assert(0 <= width && width < 256);
-    assert(0 <= height && height < 256);
-    assert(0 <= colors && colors < 256);
-    assert(chars == 1); // this implementation does not support more
-
-    (void) chars;
-
-    // init index
-    struct index index[colors];
-    for (int i = 0; i < colors; ++i) {
-        const char *line = xpm[1+i];
-        index[i].c = line[0];
-        assert(line[1] == '\t');
-        assert(line[2] == 'c');
-        assert(line[3] == ' ');
-        if (line[4] == '#') {
-            index[i].color = 0xff000000 | strtol(&line[5], &endptr, 0x10);
-            assert(*endptr == '\0');
-        } else {
-            assert(!strcmp("None", &line[4]));
-            index[i].color = 0;
-        }
-    }
-
-    // parse image
-    uint32_t *pixels = SDL_malloc(4 * width * height);
-    if (!pixels) {
-        LOGE("Could not allocate icon memory");
-        return NULL;
-    }
-    for (int y = 0; y < height; ++y) {
-        const char *line = xpm[1 + colors + y];
-        for (int x = 0; x < width; ++x) {
-            char c = line[x];
-            uint32_t color;
-            bool color_found = find_color(index, colors, c, &color);
-            assert(color_found);
-            (void) color_found;
-            pixels[y * width + x] = color;
-        }
-    }
-
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    uint32_t amask = 0x000000ff;
-    uint32_t rmask = 0x0000ff00;
-    uint32_t gmask = 0x00ff0000;
-    uint32_t bmask = 0xff000000;
-#else // little endian, like x86
-    uint32_t amask = 0xff000000;
-    uint32_t rmask = 0x00ff0000;
-    uint32_t gmask = 0x0000ff00;
-    uint32_t bmask = 0x000000ff;
-#endif
-
-    SDL_Surface *surface = SDL_CreateRGBSurfaceFrom(pixels,
-                                                    width, height,
-                                                    32, 4 * width,
-                                                    rmask, gmask, bmask, amask);
-    if (!surface) {
-        LOGE("Could not create icon surface");
-        return NULL;
-    }
-    // make the surface own the raw pixels
-    surface->flags &= ~SDL_PREALLOC;
-    return surface;
-}

app/src/tiny_xpm.h

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

app/src/trait/frame_sink.h

@@ -1,5 +1,5 @@
-#ifndef SC_FRAME_SINK
-#define SC_FRAME_SINK
+#ifndef SC_FRAME_SINK_H
+#define SC_FRAME_SINK_H
 
 #include "common.h"
 

app/src/trait/key_processor.h

@@ -0,0 +1,29 @@
+#ifndef SC_KEY_PROCESSOR_H
+#define SC_KEY_PROCESSOR_H
+
+#include "common.h"
+
+#include <assert.h>
+#include <stdbool.h>
+
+#include <SDL2/SDL_events.h>
+
+/**
+ * Key processor trait.
+ *
+ * Component able to process and inject keys should implement this trait.
+ */
+struct sc_key_processor {
+    const struct sc_key_processor_ops *ops;
+};
+
+struct sc_key_processor_ops {
+    void
+    (*process_key)(struct sc_key_processor *kp, const SDL_KeyboardEvent *event);
+
+    void
+    (*process_text)(struct sc_key_processor *kp,
+                    const SDL_TextInputEvent *event);
+};
+
+#endif

app/src/trait/mouse_processor.h

@@ -0,0 +1,39 @@
+#ifndef SC_MOUSE_PROCESSOR_H
+#define SC_MOUSE_PROCESSOR_H
+
+#include "common.h"
+
+#include <assert.h>
+#include <stdbool.h>
+
+#include <SDL2/SDL_events.h>
+
+/**
+ * Mouse processor trait.
+ *
+ * Component able to process and inject mouse events should implement this
+ * trait.
+ */
+struct sc_mouse_processor {
+    const struct sc_mouse_processor_ops *ops;
+};
+
+struct sc_mouse_processor_ops {
+    void
+    (*process_mouse_motion)(struct sc_mouse_processor *mp,
+                            const SDL_MouseMotionEvent *event);
+
+    void
+    (*process_touch)(struct sc_mouse_processor *mp,
+                     const SDL_TouchFingerEvent *event);
+
+    void
+    (*process_mouse_button)(struct sc_mouse_processor *mp,
+                            const SDL_MouseButtonEvent *event);
+
+    void
+    (*process_mouse_wheel)(struct sc_mouse_processor *mp,
+                           const SDL_MouseWheelEvent *event);
+};
+
+#endif

app/src/trait/packet_sink.h

@@ -1,5 +1,5 @@
-#ifndef SC_PACKET_SINK
-#define SC_PACKET_SINK
+#ifndef SC_PACKET_SINK_H
+#define SC_PACKET_SINK_H
 
 #include "common.h"
 

app/src/util/file.c

@@ -0,0 +1,48 @@
+#include "file.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "util/log.h"
+
+char *
+sc_file_get_local_path(const char *name) {
+    char *executable_path = sc_file_get_executable_path();
+    if (!executable_path) {
+        return NULL;
+    }
+
+    // dirname() does not work correctly everywhere, so get the parent
+    // directory manually.
+    // See <https://github.com/Genymobile/scrcpy/issues/2619>
+    char *p = strrchr(executable_path, SC_PATH_SEPARATOR);
+    if (!p) {
+        LOGE("Unexpected executable path: \"%s\" (it should contain a '%c')",
+             executable_path, SC_PATH_SEPARATOR);
+        free(executable_path);
+        return NULL;
+    }
+
+    *p = '\0'; // modify executable_path in place
+    char *dir = executable_path;
+    size_t dirlen = strlen(dir);
+    size_t namelen = strlen(name);
+
+    size_t len = dirlen + namelen + 2; // +2: '/' and '\0'
+    char *file_path = malloc(len);
+    if (!file_path) {
+        LOGE("Could not alloc path");
+        free(executable_path);
+        return NULL;
+    }
+
+    memcpy(file_path, dir, dirlen);
+    file_path[dirlen] = SC_PATH_SEPARATOR;
+    // namelen + 1 to copy the final '\0'
+    memcpy(&file_path[dirlen + 1], name, namelen + 1);
+
+    free(executable_path);
+
+    return file_path;
+}
+

app/src/util/file.h

@@ -0,0 +1,49 @@
+#ifndef SC_FILE_H
+#define SC_FILE_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#ifdef _WIN32
+# define SC_PATH_SEPARATOR '\\'
+#else
+# define SC_PATH_SEPARATOR '/'
+#endif
+
+#ifndef _WIN32
+/**
+ * Indicate if an executable exists using $PATH
+ *
+ * In practice, it is only used to know if a package manager is available on
+ * the system. It is only implemented on Linux.
+ */
+bool
+sc_file_executable_exists(const char *file);
+#endif
+
+/**
+ * Return the absolute path of the executable (the scrcpy binary)
+ *
+ * The result must be freed by the caller using free(). It may return NULL on
+ * error.
+ */
+char *
+sc_file_get_executable_path(void);
+
+/**
+ * Return the absolute path of a file in the same directory as the executable
+ *
+ * The result must be freed by the caller using free(). It may return NULL on
+ * error.
+ */
+char *
+sc_file_get_local_path(const char *name);
+
+/**
+ * Indicate if the file exists and is not a directory
+ */
+bool
+sc_file_is_regular(const char *path);
+
+#endif

app/src/util/intr.c

@@ -0,0 +1,83 @@
+#include "intr.h"
+
+#include "util/log.h"
+
+#include <assert.h>
+
+bool
+sc_intr_init(struct sc_intr *intr) {
+    bool ok = sc_mutex_init(&intr->mutex);
+    if (!ok) {
+        LOGE("Could not init intr mutex");
+        return false;
+    }
+
+    intr->socket = SC_SOCKET_NONE;
+    intr->process = SC_PROCESS_NONE;
+
+    atomic_store_explicit(&intr->interrupted, false, memory_order_relaxed);
+
+    return true;
+}
+
+bool
+sc_intr_set_socket(struct sc_intr *intr, sc_socket socket) {
+    assert(intr->process == SC_PROCESS_NONE);
+
+    sc_mutex_lock(&intr->mutex);
+    bool interrupted =
+        atomic_load_explicit(&intr->interrupted, memory_order_relaxed);
+    if (!interrupted) {
+        intr->socket = socket;
+    }
+    sc_mutex_unlock(&intr->mutex);
+
+    return !interrupted;
+}
+
+bool
+sc_intr_set_process(struct sc_intr *intr, sc_pid pid) {
+    assert(intr->socket == SC_SOCKET_NONE);
+
+    sc_mutex_lock(&intr->mutex);
+    bool interrupted =
+        atomic_load_explicit(&intr->interrupted, memory_order_relaxed);
+    if (!interrupted) {
+        intr->process = pid;
+    }
+    sc_mutex_unlock(&intr->mutex);
+
+    return !interrupted;
+}
+
+void
+sc_intr_interrupt(struct sc_intr *intr) {
+    sc_mutex_lock(&intr->mutex);
+
+    atomic_store_explicit(&intr->interrupted, true, memory_order_relaxed);
+
+    // No more than one component to interrupt
+    assert(intr->socket == SC_SOCKET_NONE ||
+           intr->process == SC_PROCESS_NONE);
+
+    if (intr->socket != SC_SOCKET_NONE) {
+        LOGD("Interrupting socket");
+        net_interrupt(intr->socket);
+        intr->socket = SC_SOCKET_NONE;
+    }
+    if (intr->process != SC_PROCESS_NONE) {
+        LOGD("Interrupting process");
+        sc_process_terminate(intr->process);
+        intr->process = SC_PROCESS_NONE;
+    }
+
+    sc_mutex_unlock(&intr->mutex);
+}
+
+void
+sc_intr_destroy(struct sc_intr *intr) {
+    assert(intr->socket == SC_SOCKET_NONE);
+    assert(intr->process == SC_PROCESS_NONE);
+
+    sc_mutex_destroy(&intr->mutex);
+}

app/src/util/intr.h

@@ -0,0 +1,78 @@
+#ifndef SC_INTR_H
+#define SC_INTR_H
+
+#include "common.h"
+
+#include <stdatomic.h>
+#include <stdbool.h>
+
+#include "net.h"
+#include "process.h"
+#include "thread.h"
+
+/**
+ * Interruptor to wake up a blocking call from another thread
+ *
+ * It allows to register a socket or a process before a blocking call, and
+ * interrupt/close from another thread to wake up the blocking call.
+ */
+struct sc_intr {
+    sc_mutex mutex;
+
+    sc_socket socket;
+    sc_pid process;
+
+    // Written protected by the mutex to avoid race conditions against
+    // sc_intr_set_socket() and sc_intr_set_process(), but can be read
+    // (atomically) without mutex
+    atomic_bool interrupted;
+};
+
+/**
+ * Initialize an interruptor
+ */
+bool
+sc_intr_init(struct sc_intr *intr);
+
+/**
+ * Set a socket as the interruptible component
+ *
+ * Call with SC_SOCKET_NONE to unset.
+ */
+bool
+sc_intr_set_socket(struct sc_intr *intr, sc_socket socket);
+
+/**
+ * Set a process as the interruptible component
+ *
+ * Call with SC_PROCESS_NONE to unset.
+ */
+bool
+sc_intr_set_process(struct sc_intr *intr, sc_pid socket);
+
+/**
+ * Interrupt the current interruptible component
+ *
+ * Must be called from a different thread.
+ */
+void
+sc_intr_interrupt(struct sc_intr *intr);
+
+/**
+ * Read the interrupted state
+ *
+ * It is exposed as a static inline function because it just loads from an
+ * atomic.
+ */
+static inline bool
+sc_intr_is_interrupted(struct sc_intr *intr) {
+    return atomic_load_explicit(&intr->interrupted, memory_order_relaxed);
+}
+
+/**
+ * Destroy the interruptor
+ */
+void
+sc_intr_destroy(struct sc_intr *intr);
+
+#endif

app/src/util/log.h

@@ -5,7 +5,7 @@
 
 #include <SDL2/SDL_log.h>
 
-#include "scrcpy.h"
+#include "options.h"
 
 #define LOGV(...) SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)

app/src/util/net.c

@@ -1,5 +1,6 @@
 #include "net.h"
 
+#include <assert.h>
 #include <stdio.h>
 #include <SDL2/SDL_platform.h>
 
@@ -7,6 +8,7 @@
 
 #ifdef __WINDOWS__
   typedef int socklen_t;
+  typedef SOCKET sc_raw_socket;
 #else
 # include <sys/types.h>
 # include <sys/socket.h>
@@ -17,105 +19,9 @@
   typedef struct sockaddr_in SOCKADDR_IN;
   typedef struct sockaddr SOCKADDR;
   typedef struct in_addr IN_ADDR;
+  typedef int sc_raw_socket;
 #endif
 
-socket_t
-net_connect(uint32_t addr, uint16_t port) {
-    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
-    if (sock == INVALID_SOCKET) {
-        perror("socket");
-        return INVALID_SOCKET;
-    }
-
-    SOCKADDR_IN sin;
-    sin.sin_family = AF_INET;
-    sin.sin_addr.s_addr = htonl(addr);
-    sin.sin_port = htons(port);
-
-    if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
-        perror("connect");
-        net_close(sock);
-        return INVALID_SOCKET;
-    }
-
-    return sock;
-}
-
-socket_t
-net_listen(uint32_t addr, uint16_t port, int backlog) {
-    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
-    if (sock == INVALID_SOCKET) {
-        perror("socket");
-        return INVALID_SOCKET;
-    }
-
-    int reuse = 1;
-    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
-                   sizeof(reuse)) == -1) {
-        perror("setsockopt(SO_REUSEADDR)");
-    }
-
-    SOCKADDR_IN sin;
-    sin.sin_family = AF_INET;
-    sin.sin_addr.s_addr = htonl(addr); // htonl() harmless on INADDR_ANY
-    sin.sin_port = htons(port);
-
-    if (bind(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
-        perror("bind");
-        net_close(sock);
-        return INVALID_SOCKET;
-    }
-
-    if (listen(sock, backlog) == SOCKET_ERROR) {
-        perror("listen");
-        net_close(sock);
-        return INVALID_SOCKET;
-    }
-
-    return sock;
-}
-
-socket_t
-net_accept(socket_t server_socket) {
-    SOCKADDR_IN csin;
-    socklen_t sinsize = sizeof(csin);
-    return accept(server_socket, (SOCKADDR *) &csin, &sinsize);
-}
-
-ssize_t
-net_recv(socket_t socket, void *buf, size_t len) {
-    return recv(socket, buf, len, 0);
-}
-
-ssize_t
-net_recv_all(socket_t socket, void *buf, size_t len) {
-    return recv(socket, buf, len, MSG_WAITALL);
-}
-
-ssize_t
-net_send(socket_t socket, const void *buf, size_t len) {
-    return send(socket, buf, len, 0);
-}
-
-ssize_t
-net_send_all(socket_t socket, const void *buf, size_t len) {
-    ssize_t w = 0;
-    while (len > 0) {
-        w = send(socket, buf, len, 0);
-        if (w == -1) {
-            return -1;
-        }
-        len -= w;
-        buf = (char *) buf + w;
-    }
-    return w;
-}
-
-bool
-net_shutdown(socket_t socket, int how) {
-    return !shutdown(socket, how);
-}
-
 bool
 net_init(void) {
 #ifdef __WINDOWS__
@@ -136,11 +42,186 @@ net_cleanup(void) {
 #endif
 }
 
-bool
-net_close(socket_t socket) {
+static inline sc_socket
+wrap(sc_raw_socket sock) {
 #ifdef __WINDOWS__
-    return !closesocket(socket);
+    if (sock == INVALID_SOCKET) {
+        return SC_SOCKET_NONE;
+    }
+
+    struct sc_socket_windows *socket = malloc(sizeof(*socket));
+    if (!socket) {
+        closesocket(sock);
+        return SC_SOCKET_NONE;
+    }
+
+    socket->socket = sock;
+    socket->closed = (atomic_flag) ATOMIC_FLAG_INIT;
+
+    return socket;
 #else
-    return !close(socket);
+    return sock;
+#endif
+}
+
+static inline sc_raw_socket
+unwrap(sc_socket socket) {
+#ifdef __WINDOWS__
+    if (socket == SC_SOCKET_NONE) {
+        return INVALID_SOCKET;
+    }
+
+    return socket->socket;
+#else
+    return socket;
+#endif
+}
+
+static void
+net_perror(const char *s) {
+#ifdef _WIN32
+    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
+}
+
+sc_socket
+net_socket(void) {
+    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
+    sc_socket sock = wrap(raw_sock);
+    if (sock == SC_SOCKET_NONE) {
+        net_perror("socket");
+    }
+    return sock;
+}
+
+bool
+net_connect(sc_socket socket, uint32_t addr, uint16_t port) {
+    sc_raw_socket raw_sock = unwrap(socket);
+
+    SOCKADDR_IN sin;
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = htonl(addr);
+    sin.sin_port = htons(port);
+
+    if (connect(raw_sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
+        net_perror("connect");
+        return false;
+    }
+
+    return true;
+}
+
+bool
+net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog) {
+    sc_raw_socket raw_sock = unwrap(socket);
+
+    int reuse = 1;
+    if (setsockopt(raw_sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
+                   sizeof(reuse)) == -1) {
+        net_perror("setsockopt(SO_REUSEADDR)");
+    }
+
+    SOCKADDR_IN sin;
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = htonl(addr); // htonl() harmless on INADDR_ANY
+    sin.sin_port = htons(port);
+
+    if (bind(raw_sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
+        net_perror("bind");
+        return false;
+    }
+
+    if (listen(raw_sock, backlog) == SOCKET_ERROR) {
+        net_perror("listen");
+        return false;
+    }
+
+    return true;
+}
+
+sc_socket
+net_accept(sc_socket server_socket) {
+    sc_raw_socket raw_server_socket = unwrap(server_socket);
+
+    SOCKADDR_IN csin;
+    socklen_t sinsize = sizeof(csin);
+    sc_raw_socket raw_sock =
+        accept(raw_server_socket, (SOCKADDR *) &csin, &sinsize);
+
+    return wrap(raw_sock);
+}
+
+ssize_t
+net_recv(sc_socket socket, void *buf, size_t len) {
+    sc_raw_socket raw_sock = unwrap(socket);
+    return recv(raw_sock, buf, len, 0);
+}
+
+ssize_t
+net_recv_all(sc_socket socket, void *buf, size_t len) {
+    sc_raw_socket raw_sock = unwrap(socket);
+    return recv(raw_sock, buf, len, MSG_WAITALL);
+}
+
+ssize_t
+net_send(sc_socket socket, const void *buf, size_t len) {
+    sc_raw_socket raw_sock = unwrap(socket);
+    return send(raw_sock, buf, len, 0);
+}
+
+ssize_t
+net_send_all(sc_socket socket, const void *buf, size_t len) {
+    size_t copied = 0;
+    while (len > 0) {
+        ssize_t w = net_send(socket, buf, len);
+        if (w == -1) {
+            return copied ? (ssize_t) copied : -1;
+        }
+        len -= w;
+        buf = (char *) buf + w;
+        copied += w;
+    }
+    return copied;
+}
+
+bool
+net_interrupt(sc_socket socket) {
+    assert(socket != SC_SOCKET_NONE);
+
+    sc_raw_socket raw_sock = unwrap(socket);
+
+#ifdef __WINDOWS__
+    if (!atomic_flag_test_and_set(&socket->closed)) {
+        return !closesocket(raw_sock);
+    }
+    return true;
+#else
+    return !shutdown(raw_sock, SHUT_RDWR);
+#endif
+}
+
+#include <errno.h>
+bool
+net_close(sc_socket socket) {
+    sc_raw_socket raw_sock = unwrap(socket);
+
+#ifdef __WINDOWS__
+    bool ret = true;
+    if (!atomic_flag_test_and_set(&socket->closed)) {
+        ret = !closesocket(raw_sock);
+    }
+    free(socket);
+    return ret;
+#else
+    return !close(raw_sock);
 #endif
 }

app/src/util/net.h

@@ -8,50 +8,64 @@
 #include <SDL2/SDL_platform.h>
 
 #ifdef __WINDOWS__
+
 # include <winsock2.h>
-  #define SHUT_RD SD_RECEIVE
-  #define SHUT_WR SD_SEND
-  #define SHUT_RDWR SD_BOTH
-  typedef SOCKET socket_t;
-#else
+# include <stdatomic.h>
+# define SC_SOCKET_NONE NULL
+  typedef struct sc_socket_windows {
+      SOCKET socket;
+      atomic_flag closed;
+  } *sc_socket;
+
+#else // not __WINDOWS__
+
 # include <sys/socket.h>
-# define INVALID_SOCKET -1
-  typedef int socket_t;
+# define SC_SOCKET_NONE -1
+  typedef int sc_socket;
+
 #endif
 
+#define IPV4_LOCALHOST 0x7F000001
+
 bool
 net_init(void);
 
 void
 net_cleanup(void);
 
-socket_t
-net_connect(uint32_t addr, uint16_t port);
+sc_socket
+net_socket(void);
 
-socket_t
-net_listen(uint32_t addr, uint16_t port, int backlog);
+bool
+net_connect(sc_socket socket, uint32_t addr, uint16_t port);
 
-socket_t
-net_accept(socket_t server_socket);
+bool
+net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog);
+
+sc_socket
+net_accept(sc_socket server_socket);
 
 // the _all versions wait/retry until len bytes have been written/read
 ssize_t
-net_recv(socket_t socket, void *buf, size_t len);
+net_recv(sc_socket socket, void *buf, size_t len);
 
 ssize_t
-net_recv_all(socket_t socket, void *buf, size_t len);
+net_recv_all(sc_socket socket, void *buf, size_t len);
 
 ssize_t
-net_send(socket_t socket, const void *buf, size_t len);
+net_send(sc_socket socket, const void *buf, size_t len);
 
 ssize_t
-net_send_all(socket_t socket, const void *buf, size_t len);
+net_send_all(sc_socket socket, const void *buf, size_t len);
 
-// how is SHUT_RD (read), SHUT_WR (write) or SHUT_RDWR (both)
+// Shutdown the socket (or close on Windows) so that any blocking send() or
+// recv() are interrupted.
 bool
-net_shutdown(socket_t socket, int how);
+net_interrupt(sc_socket socket);
 
+// Close the socket.
+// A socket must always be closed, even if net_interrupt() has been called.
 bool
-net_close(socket_t socket);
+net_close(sc_socket socket);
 
 #endif

app/src/util/net_intr.c

@@ -0,0 +1,97 @@
+#include "net_intr.h"
+
+bool
+net_connect_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
+                 uint16_t port) {
+    if (!sc_intr_set_socket(intr, socket)) {
+        // Already interrupted
+        return false;
+    }
+
+    bool ret = net_connect(socket, addr, port);
+
+    sc_intr_set_socket(intr, SC_SOCKET_NONE);
+    return ret;
+}
+
+bool
+net_listen_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
+                uint16_t port, int backlog) {
+    if (!sc_intr_set_socket(intr, socket)) {
+        // Already interrupted
+        return false;
+    }
+
+    bool ret = net_listen(socket, addr, port, backlog);
+
+    sc_intr_set_socket(intr, SC_SOCKET_NONE);
+    return ret;
+}
+
+sc_socket
+net_accept_intr(struct sc_intr *intr, sc_socket server_socket) {
+    if (!sc_intr_set_socket(intr, server_socket)) {
+        // Already interrupted
+        return SC_SOCKET_NONE;
+    }
+
+    sc_socket socket = net_accept(server_socket);
+
+    sc_intr_set_socket(intr, SC_SOCKET_NONE);
+    return socket;
+}
+
+ssize_t
+net_recv_intr(struct sc_intr *intr, sc_socket socket, void *buf, size_t len) {
+    if (!sc_intr_set_socket(intr, socket)) {
+        // Already interrupted
+        return -1;
+    }
+
+    ssize_t r = net_recv(socket, buf, len);
+
+    sc_intr_set_socket(intr, SC_SOCKET_NONE);
+    return r;
+}
+
+ssize_t
+net_recv_all_intr(struct sc_intr *intr, sc_socket socket, void *buf,
+                  size_t len) {
+    if (!sc_intr_set_socket(intr, socket)) {
+        // Already interrupted
+        return -1;
+    }
+
+    ssize_t r = net_recv_all(socket, buf, len);
+
+    sc_intr_set_socket(intr, SC_SOCKET_NONE);
+    return r;
+}
+
+ssize_t
+net_send_intr(struct sc_intr *intr, sc_socket socket, const void *buf,
+              size_t len) {
+    if (!sc_intr_set_socket(intr, socket)) {
+        // Already interrupted
+        return -1;
+    }
+
+    ssize_t w = net_send(socket, buf, len);
+
+    sc_intr_set_socket(intr, SC_SOCKET_NONE);
+    return w;
+}
+
+ssize_t
+net_send_all_intr(struct sc_intr *intr, sc_socket socket, const void *buf,
+                  size_t len) {
+    if (!sc_intr_set_socket(intr, socket)) {
+        // Already interrupted
+        return -1;
+    }
+
+    ssize_t w = net_send_all(socket, buf, len);
+
+    sc_intr_set_socket(intr, SC_SOCKET_NONE);
+    return w;
+}

app/src/util/net_intr.h

@@ -0,0 +1,35 @@
+#ifndef SC_NET_INTR_H
+#define SC_NET_INTR_H
+
+#include "common.h"
+
+#include "intr.h"
+#include "net.h"
+
+bool
+net_connect_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
+                 uint16_t port);
+
+bool
+net_listen_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
+                uint16_t port, int backlog);
+
+sc_socket
+net_accept_intr(struct sc_intr *intr, sc_socket server_socket);
+
+ssize_t
+net_recv_intr(struct sc_intr *intr, sc_socket socket, void *buf, size_t len);
+
+ssize_t
+net_recv_all_intr(struct sc_intr *intr, sc_socket socket, void *buf,
+                  size_t len);
+
+ssize_t
+net_send_intr(struct sc_intr *intr, sc_socket socket, const void *buf,
+              size_t len);
+
+ssize_t
+net_send_all_intr(struct sc_intr *intr, sc_socket socket, const void *buf,
+                  size_t len);
+
+#endif

app/src/util/process.c

@@ -1,17 +1,25 @@
 #include "process.h"
 
+#include <assert.h>
+#include <libgen.h>
 #include "log.h"
 
+enum sc_process_result
+sc_process_execute(const char *const argv[], sc_pid *pid, unsigned inherit) {
+    return sc_process_execute_p(argv, pid, inherit, NULL, NULL, NULL);
+}
+
 bool
-process_check_success(process_t proc, const char *name, bool close) {
-    if (proc == PROCESS_NONE) {
+sc_process_check_success(sc_pid pid, const char *name, bool close) {
+    if (pid == SC_PROCESS_NONE) {
         LOGE("Could not execute \"%s\"", name);
         return false;
     }
-    exit_code_t exit_code = process_wait(proc, close);
+    sc_exit_code exit_code = sc_process_wait(pid, close);
     if (exit_code) {
-        if (exit_code != NO_EXIT_CODE) {
-            LOGE("\"%s\" returned with value %" PRIexitcode, name, exit_code);
+        if (exit_code != SC_EXIT_CODE_NONE) {
+            LOGE("\"%s\" returned with value %" SC_PRIexitcode, name,
+                 exit_code);
         } else {
             LOGE("\"%s\" exited unexpectedly", name);
         }
@@ -19,3 +27,95 @@ process_check_success(process_t proc, const char *name, bool close) {
     }
     return true;
 }
+
+ssize_t
+sc_pipe_read_all(sc_pipe pipe, char *data, size_t len) {
+    size_t copied = 0;
+    while (len > 0) {
+        ssize_t r = sc_pipe_read(pipe, data, len);
+        if (r <= 0) {
+            return copied ? (ssize_t) copied : r;
+        }
+        len -= r;
+        data += r;
+        copied += r;
+    }
+    return copied;
+}
+
+static int
+run_observer(void *data) {
+    struct sc_process_observer *observer = data;
+    sc_process_wait(observer->pid, false); // ignore exit code
+
+    sc_mutex_lock(&observer->mutex);
+    observer->terminated = true;
+    sc_cond_signal(&observer->cond_terminated);
+    sc_mutex_unlock(&observer->mutex);
+
+    if (observer->listener) {
+        observer->listener->on_terminated(observer->listener_userdata);
+    }
+
+    return 0;
+}
+
+bool
+sc_process_observer_init(struct sc_process_observer *observer, sc_pid pid,
+                         const struct sc_process_listener *listener,
+                         void *listener_userdata) {
+    // Either no listener, or on_terminated() is defined
+    assert(!listener || listener->on_terminated);
+
+    bool ok = sc_mutex_init(&observer->mutex);
+    if (!ok) {
+        return false;
+    }
+
+    ok = sc_cond_init(&observer->cond_terminated);
+    if (!ok) {
+        sc_mutex_destroy(&observer->mutex);
+        return false;
+    }
+
+    observer->pid = pid;
+    observer->listener = listener;
+    observer->listener_userdata = listener_userdata;
+    observer->terminated = false;
+
+    ok = sc_thread_create(&observer->thread, run_observer, "process_observer",
+                          observer);
+    if (!ok) {
+        sc_cond_destroy(&observer->cond_terminated);
+        sc_mutex_destroy(&observer->mutex);
+        return false;
+    }
+
+    return true;
+}
+
+bool
+sc_process_observer_timedwait(struct sc_process_observer *observer,
+                              sc_tick deadline) {
+    sc_mutex_lock(&observer->mutex);
+    bool timed_out = false;
+    while (!observer->terminated && !timed_out) {
+        timed_out = !sc_cond_timedwait(&observer->cond_terminated,
+                                       &observer->mutex, deadline);
+    }
+    bool terminated = observer->terminated;
+    sc_mutex_unlock(&observer->mutex);
+
+    return terminated;
+}
+
+void
+sc_process_observer_join(struct sc_process_observer *observer) {
+    sc_thread_join(&observer->thread, NULL);
+}
+
+void
+sc_process_observer_destroy(struct sc_process_observer *observer) {
+    sc_cond_destroy(&observer->cond_terminated);
+    sc_mutex_destroy(&observer->mutex);
+}

app/src/util/process.h

@@ -4,78 +4,185 @@
 #include "common.h"
 
 #include <stdbool.h>
+#include "util/thread.h"
 
 #ifdef _WIN32
 
  // not needed here, but winsock2.h must never be included AFTER windows.h
 # include <winsock2.h>
 # include <windows.h>
-# define PATH_SEPARATOR '\\'
-# define PRIexitcode "lu"
+# define SC_PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
-# define PRIsizet "Iu"
-# define PROCESS_NONE NULL
-# define NO_EXIT_CODE -1u // max value as unsigned
-  typedef HANDLE process_t;
-  typedef DWORD exit_code_t;
+# define SC_PRIsizet "Iu"
+# define SC_PROCESS_NONE NULL
+# define SC_EXIT_CODE_NONE -1u // max value as unsigned
+  typedef HANDLE sc_pid;
+  typedef DWORD sc_exit_code;
+  typedef HANDLE sc_pipe;
 
 #else
 
 # include <sys/types.h>
-# define PATH_SEPARATOR '/'
-# define PRIsizet "zu"
-# define PRIexitcode "d"
-# define PROCESS_NONE -1
-# define NO_EXIT_CODE -1
-  typedef pid_t process_t;
-  typedef int exit_code_t;
+# define SC_PRIsizet "zu"
+# define SC_PRIexitcode "d"
+# define SC_PROCESS_NONE -1
+# define SC_EXIT_CODE_NONE -1
+  typedef pid_t sc_pid;
+  typedef int sc_exit_code;
+  typedef int sc_pipe;
 
 #endif
 
-enum process_result {
-    PROCESS_SUCCESS,
-    PROCESS_ERROR_GENERIC,
-    PROCESS_ERROR_MISSING_BINARY,
+struct sc_process_listener {
+    void (*on_terminated)(void *userdata);
 };
 
-// execute the command and write the result to the output parameter "process"
-enum process_result
-process_execute(const char *const argv[], process_t *process);
+/**
+ * Tool to observe process termination
+ *
+ * To keep things simple and multiplatform, it runs a separate thread to wait
+ * for process termination (without closing the process to avoid race
+ * conditions).
+ *
+ * It allows a caller to block until the process is terminated (with a
+ * timeout), and to be notified asynchronously from the observer thread.
+ *
+ * The process is not owned by the observer (the observer will never close it).
+ */
+struct sc_process_observer {
+    sc_pid pid;
 
-// kill the process
+    sc_mutex mutex;
+    sc_cond cond_terminated;
+    bool terminated;
+
+    sc_thread thread;
+    const struct sc_process_listener *listener;
+    void *listener_userdata;
+};
+
+enum sc_process_result {
+    SC_PROCESS_SUCCESS,
+    SC_PROCESS_ERROR_GENERIC,
+    SC_PROCESS_ERROR_MISSING_BINARY,
+};
+
+#define SC_INHERIT_NONE    0
+#define SC_INHERIT_STDOUT (1 << 0)
+#define SC_INHERIT_STDERR (1 << 1)
+
+/**
+ * Execute the command and write the process id to `pid`
+ *
+ * The parameter `inherit` is a ORed value of SC_INHERIT_* flags. It indicates
+ * if stdout and stderr must be inherited from the scrcpy process (in other
+ * words, if the process must output to the scrcpy console).
+ */
+enum sc_process_result
+sc_process_execute(const char *const argv[], sc_pid *pid, unsigned inherit);
+
+/**
+ * Execute the command and write the process id to `pid`
+ *
+ * If not NULL, provide a pipe for stdin (`pin`), stdout (`pout`) and stderr
+ * (`perr`).
+ *
+ * The parameter `inherit` has the same semantics as in `sc_process_execute()`.
+ * If `pout` is not NULL, then `inherit` MUST NOT contain SC_INHERIT_STDOUT.
+ * If `perr` is not NULL, then `inherit` MUST NOT contain SC_INHERIT_STDERR.
+ */
+enum sc_process_result
+sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned inherit,
+                     sc_pipe *pin, sc_pipe *pout, sc_pipe *perr);
+
+/**
+ * Kill the process
+ */
 bool
-process_terminate(process_t pid);
+sc_process_terminate(sc_pid pid);
 
-// wait and close the process (like waitpid())
-// the "close" flag indicates if the process must be "closed" (reaped)
-// (passing false is equivalent to enable WNOWAIT in waitid())
-exit_code_t
-process_wait(process_t pid, bool close);
+/**
+ * Wait and close the process (similar to waitpid())
+ *
+ * The `close` flag indicates if the process must be _closed_ (reaped) (passing
+ * false is equivalent to enable WNOWAIT in waitid()).
+ */
+sc_exit_code
+sc_process_wait(sc_pid pid, bool close);
 
-// close the process
-//
-// Semantically, process_wait(close) = process_wait(noclose) + process_close
+/**
+ * Close (reap) the process
+ *
+ * Semantically:
+ *    sc_process_wait(close) = sc_process_wait(noclose) + sc_process_close()
+ */
 void
-process_close(process_t pid);
+sc_process_close(sc_pid pid);
 
-// convenience function to wait for a successful process execution
-// automatically log process errors with the provided process name
+/**
+ * Convenience function to wait for a successful process execution
+ *
+ * Automatically log process errors with the provided process name.
+ */
 bool
-process_check_success(process_t proc, const char *name, bool close);
+sc_process_check_success(sc_pid pid, const char *name, bool close);
 
-#ifndef _WIN32
-// only used to find package manager, not implemented for Windows
+/**
+ * Read from the pipe
+ *
+ * Same semantic as read().
+ */
+ssize_t
+sc_pipe_read(sc_pipe pipe, char *data, size_t len);
+
+/**
+ * Read exactly `len` chars from a pipe (unless EOF)
+ */
+ssize_t
+sc_pipe_read_all(sc_pipe pipe, char *data, size_t len);
+
+/**
+ * Close the pipe
+ */
+void
+sc_pipe_close(sc_pipe pipe);
+
+/**
+ * Start observing process
+ *
+ * The listener is optional. If set, its callback will be called from the
+ * observer thread once the process is terminated.
+ */
 bool
-search_executable(const char *file);
-#endif
+sc_process_observer_init(struct sc_process_observer *observer, sc_pid pid,
+                         const struct sc_process_listener *listener,
+                         void *listener_userdata);
 
-// return the absolute path of the executable (the scrcpy binary)
-// may be NULL on error; to be freed by free()
-char *
-get_executable_path(void);
-
-// returns true if the file exists and is not a directory
+/**
+ * Wait for process termination until a deadline
+ *
+ * Return true if the process is already terminated. Return false if the
+ * process terminatation has not been detected yet (however, it may have
+ * terminated in the meantime).
+ *
+ * To wait without timeout/deadline, just use sc_process_wait() instead.
+ */
 bool
-is_regular_file(const char *path);
+sc_process_observer_timedwait(struct sc_process_observer *observer,
+                              sc_tick deadline);
+
+/**
+ * Join the observer thread
+ */
+void
+sc_process_observer_join(struct sc_process_observer *observer);
+
+/**
+ * Destroy the observer
+ *
+ * This does not close the associated process.
+ */
+void
+sc_process_observer_destroy(struct sc_process_observer *observer);
 
 #endif

app/src/util/process_intr.c

@@ -0,0 +1,50 @@
+#include "process_intr.h"
+
+bool
+sc_process_check_success_intr(struct sc_intr *intr, sc_pid pid,
+                              const char *name, bool close) {
+    if (!sc_intr_set_process(intr, pid)) {
+        // Already interrupted
+        return false;
+    }
+
+    // Always pass close=false, interrupting would be racy otherwise
+    bool ret = sc_process_check_success(pid, name, false);
+
+    sc_intr_set_process(intr, SC_PROCESS_NONE);
+
+    if (close) {
+        // Close separately
+        sc_process_close(pid);
+    }
+
+    return ret;
+}
+
+ssize_t
+sc_pipe_read_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe, char *data,
+                  size_t len) {
+    if (!sc_intr_set_process(intr, pid)) {
+        // Already interrupted
+        return false;
+    }
+
+    ssize_t ret = sc_pipe_read(pipe, data, len);
+
+    sc_intr_set_process(intr, SC_PROCESS_NONE);
+    return ret;
+}
+
+ssize_t
+sc_pipe_read_all_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe,
+                      char *data, size_t len) {
+    if (!sc_intr_set_process(intr, pid)) {
+        // Already interrupted
+        return false;
+    }
+
+    ssize_t ret = sc_pipe_read_all(pipe, data, len);
+
+    sc_intr_set_process(intr, SC_PROCESS_NONE);
+    return ret;
+}

app/src/util/process_intr.h

@@ -0,0 +1,21 @@
+#ifndef SC_PROCESS_INTR_H
+#define SC_PROCESS_INTR_H
+
+#include "common.h"
+
+#include "intr.h"
+#include "process.h"
+
+bool
+sc_process_check_success_intr(struct sc_intr *intr, sc_pid pid,
+                              const char *name, bool close);
+
+ssize_t
+sc_pipe_read_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe, char *data,
+                  size_t len);
+
+ssize_t
+sc_pipe_read_all_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe,
+                      char *data, size_t len);
+
+#endif

app/src/util/queue.h

@@ -1,6 +1,6 @@
 // generic intrusive FIFO queue
-#ifndef QUEUE_H
-#define QUEUE_H
+#ifndef SC_QUEUE_H
+#define SC_QUEUE_H
 
 #include "common.h"
 
@@ -10,15 +10,15 @@
 
 // To define a queue type of "struct foo":
 //    struct queue_foo QUEUE(struct foo);
-#define QUEUE(TYPE) { \
+#define SC_QUEUE(TYPE) { \
     TYPE *first; \
     TYPE *last; \
 }
 
-#define queue_init(PQ) \
+#define sc_queue_init(PQ) \
     (void) ((PQ)->first = (PQ)->last = NULL)
 
-#define queue_is_empty(PQ) \
+#define sc_queue_is_empty(PQ) \
     !(PQ)->first
 
 // NEXTFIELD is the field in the ITEM type used for intrusive linked-list
@@ -30,30 +30,30 @@
 //    };
 //
 //    // define the type "struct my_queue"
-//    struct my_queue QUEUE(struct foo);
+//    struct my_queue SC_QUEUE(struct foo);
 //
 //    struct my_queue queue;
-//    queue_init(&queue);
+//    sc_queue_init(&queue);
 //
 //    struct foo v1 = { .value = 42 };
 //    struct foo v2 = { .value = 27 };
 //
-//    queue_push(&queue, next, v1);
-//    queue_push(&queue, next, v2);
+//    sc_queue_push(&queue, next, v1);
+//    sc_queue_push(&queue, next, v2);
 //
 //    struct foo *foo;
-//    queue_take(&queue, next, &foo);
+//    sc_queue_take(&queue, next, &foo);
 //    assert(foo->value == 42);
-//    queue_take(&queue, next, &foo);
+//    sc_queue_take(&queue, next, &foo);
 //    assert(foo->value == 27);
-//    assert(queue_is_empty(&queue));
+//    assert(sc_queue_is_empty(&queue));
 //
 
 // push a new item into the queue
-#define queue_push(PQ, NEXTFIELD, ITEM) \
+#define sc_queue_push(PQ, NEXTFIELD, ITEM) \
     (void) ({ \
         (ITEM)->NEXTFIELD = NULL; \
-        if (queue_is_empty(PQ)) { \
+        if (sc_queue_is_empty(PQ)) { \
             (PQ)->first = (PQ)->last = (ITEM); \
         } else { \
             (PQ)->last->NEXTFIELD = (ITEM); \
@@ -65,9 +65,9 @@
 // the result is stored in *(PITEM)
 // (without typeof(), we could not store a local variable having the correct
 // type so that we can "return" it)
-#define queue_take(PQ, NEXTFIELD, PITEM) \
+#define sc_queue_take(PQ, NEXTFIELD, PITEM) \
     (void) ({ \
-        assert(!queue_is_empty(PQ)); \
+        assert(!sc_queue_is_empty(PQ)); \
         *(PITEM) = (PQ)->first; \
         (PQ)->first = (PQ)->first->NEXTFIELD; \
     })

app/src/util/str.c

@@ -1,9 +1,11 @@
-#include "str_util.h"
+#include "str.h"
 
+#include <assert.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
+#include "util/strbuf.h"
 
 #ifdef _WIN32
 # include <windows.h>
@@ -11,7 +13,7 @@
 #endif
 
 size_t
-xstrncpy(char *dest, const char *src, size_t n) {
+sc_strncpy(char *dest, const char *src, size_t n) {
     size_t i;
     for (i = 0; i < n - 1 && src[i] != '\0'; ++i)
         dest[i] = src[i];
@@ -21,7 +23,7 @@ xstrncpy(char *dest, const char *src, size_t n) {
 }
 
 size_t
-xstrjoin(char *dst, const char *const tokens[], char sep, size_t n) {
+sc_str_join(char *dst, const char *const tokens[], char sep, size_t n) {
     const char *const *remaining = tokens;
     const char *token = *remaining++;
     size_t i = 0;
@@ -31,7 +33,7 @@ xstrjoin(char *dst, const char *const tokens[], char sep, size_t n) {
             if (i == n)
                 goto truncated;
         }
-        size_t w = xstrncpy(dst + i, token, n - i);
+        size_t w = sc_strncpy(dst + i, token, n - i);
         if (w >= n - i)
             goto truncated;
         i += w;
@@ -45,7 +47,7 @@ truncated:
 }
 
 char *
-strquote(const char *src) {
+sc_str_quote(const char *src) {
     size_t len = strlen(src);
     char *quoted = malloc(len + 3);
     if (!quoted) {
@@ -59,7 +61,7 @@ strquote(const char *src) {
 }
 
 bool
-parse_integer(const char *s, long *out) {
+sc_str_parse_integer(const char *s, long *out) {
     char *endptr;
     if (*s == '\0') {
         return false;
@@ -78,7 +80,8 @@ parse_integer(const char *s, long *out) {
 }
 
 size_t
-parse_integers(const char *s, const char sep, size_t max_items, long *out) {
+sc_str_parse_integers(const char *s, const char sep, size_t max_items,
+                      long *out) {
     size_t count = 0;
     char *endptr;
     do {
@@ -107,7 +110,7 @@ parse_integers(const char *s, const char sep, size_t max_items, long *out) {
 }
 
 bool
-parse_integer_with_suffix(const char *s, long *out) {
+sc_str_parse_integer_with_suffix(const char *s, long *out) {
     char *endptr;
     if (*s == '\0') {
         return false;
@@ -141,7 +144,7 @@ parse_integer_with_suffix(const char *s, long *out) {
 }
 
 bool
-strlist_contains(const char *list, char sep, const char *s) {
+sc_str_list_contains(const char *list, char sep, const char *s) {
     char *p;
     do {
         p = strchr(list, sep);
@@ -159,7 +162,7 @@ strlist_contains(const char *list, char sep, const char *s) {
 }
 
 size_t
-utf8_truncation_index(const char *utf8, size_t max_len) {
+sc_str_utf8_truncation_index(const char *utf8, size_t max_len) {
     size_t len = strlen(utf8);
     if (len <= max_len) {
         return len;
@@ -177,7 +180,7 @@ utf8_truncation_index(const char *utf8, size_t max_len) {
 #ifdef _WIN32
 
 wchar_t *
-utf8_to_wide_char(const char *utf8) {
+sc_str_to_wchars(const char *utf8) {
     int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
     if (!len) {
         return NULL;
@@ -193,7 +196,7 @@ utf8_to_wide_char(const char *utf8) {
 }
 
 char *
-utf8_from_wide_char(const wchar_t *ws) {
+sc_str_from_wchars(const wchar_t *ws) {
     int len = WideCharToMultiByte(CP_UTF8, 0, ws, -1, NULL, 0, NULL, NULL);
     if (!len) {
         return NULL;
@@ -209,3 +212,90 @@ utf8_from_wide_char(const wchar_t *ws) {
 }
 
 #endif
+
+char *
+sc_str_wrap_lines(const char *input, unsigned columns, unsigned indent) {
+    assert(indent < columns);
+
+    struct sc_strbuf buf;
+
+    // The output string should not be much longer than the input string (just
+    // a few '\n' added), so this initial capacity should hopefully almost
+    // always avoid internal realloc() in string buffer
+    size_t cap = strlen(input) * 3 / 2;
+
+    if (!sc_strbuf_init(&buf, cap)) {
+        return false;
+    }
+
+#define APPEND(S,N) if (!sc_strbuf_append(&buf, S, N)) goto error
+#define APPEND_CHAR(C) if (!sc_strbuf_append_char(&buf, C)) goto error
+#define APPEND_N(C,N) if (!sc_strbuf_append_n(&buf, C, N)) goto error
+#define APPEND_INDENT() if (indent) APPEND_N(' ', indent)
+
+    APPEND_INDENT();
+
+    // The last separator encountered, it must be inserted only conditionnaly,
+    // depending on the next token
+    char pending = 0;
+
+    // col tracks the current column in the current line
+    size_t col = indent;
+    while (*input) {
+        size_t sep_idx = strcspn(input, "\n ");
+        size_t new_col = col + sep_idx;
+        if (pending == ' ') {
+            // The pending space counts
+            ++new_col;
+        }
+        bool wrap = new_col > columns;
+
+        char sep = input[sep_idx];
+        if (sep == ' ')
+            sep = ' ';
+
+        if (wrap) {
+            APPEND_CHAR('\n');
+            APPEND_INDENT();
+            col = indent;
+        } else if (pending) {
+            APPEND_CHAR(pending);
+            ++col;
+            if (pending == '\n')
+            {
+                APPEND_INDENT();
+                col = indent;
+            }
+        }
+
+        if (sep_idx) {
+            APPEND(input, sep_idx);
+            col += sep_idx;
+        }
+
+        pending = sep;
+
+        input += sep_idx;
+        if (*input != '\0') {
+            // Skip the separator
+            ++input;
+        }
+    }
+
+    if (pending)
+        APPEND_CHAR(pending);
+
+    return buf.s;
+
+error:
+    free(buf.s);
+    return NULL;
+}
+
+size_t
+sc_str_truncate(char *data, size_t len, const char *endchars) {
+    data[len - 1] = '\0';
+    size_t idx = strcspn(data, endchars);
+    data[idx] = '\0';
+    return idx;
+}

app/src/util/str.h

@@ -0,0 +1,117 @@
+#ifndef SC_STR_H
+#define SC_STR_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+/**
+ * Like strncpy(), except:
+ *  - it copies at most n-1 chars
+ *  - the dest string is nul-terminated
+ *  - it does not write useless bytes if strlen(src) < n
+ *  - it returns the number of chars actually written (max n-1) if src has
+ *    been copied completely, or n if src has been truncated
+ */
+size_t
+sc_strncpy(char *dest, const char *src, size_t n);
+
+/**
+ * Join tokens by separator `sep` into `dst`
+ *
+ * Return the number of chars actually written (max n-1) if no truncation
+ * occurred, or n if truncated.
+ */
+size_t
+sc_str_join(char *dst, const char *const tokens[], char sep, size_t n);
+
+/**
+ * Quote a string
+ *
+ * Return a new allocated string, surrounded with quotes (`"`).
+ */
+char *
+sc_str_quote(const char *src);
+
+/**
+ * Parse `s` as an integer into `out`
+ *
+ * Return true if the conversion succeeded, false otherwise.
+ */
+bool
+sc_str_parse_integer(const char *s, long *out);
+
+/**
+ * Parse `s` as integers separated by `sep` (for example `1234:2000`) into `out`
+ *
+ * Returns the number of integers on success, 0 on failure.
+ */
+size_t
+sc_str_parse_integers(const char *s, const char sep, size_t max_items,
+                      long *out);
+
+/**
+ * Parse `s` as an integer into `out`
+ *
+ * Like `sc_str_parse_integer()`, but accept 'k'/'K' (x1000) and 'm'/'M'
+ * (x1000000) as suffixes.
+ *
+ * Return true if the conversion succeeded, false otherwise.
+ */
+bool
+sc_str_parse_integer_with_suffix(const char *s, long *out);
+
+/**
+ * Search `s` in the list separated by `sep`
+ *
+ * For example, sc_str_list_contains("a,bc,def", ',', "bc") returns true.
+ */
+bool
+sc_str_list_contains(const char *list, char sep, const char *s);
+
+/**
+ * Return the index to truncate a UTF-8 string at a valid position
+ */
+size_t
+sc_str_utf8_truncation_index(const char *utf8, size_t max_len);
+
+#ifdef _WIN32
+/**
+ * Convert a UTF-8 string to a wchar_t string
+ *
+ * Return the new allocated string, to be freed by the caller.
+ */
+wchar_t *
+sc_str_to_wchars(const char *utf8);
+
+/**
+ * Convert a wchar_t string to a UTF-8 string
+ *
+ * Return the new allocated string, to be freed by the caller.
+ */
+char *
+sc_str_from_wchars(const wchar_t *s);
+#endif
+
+/**
+ * Wrap input lines to fit in `columns` columns
+ *
+ * Break input lines at word boundaries (spaces) so that they fit in `columns`
+ * columns, left-indented by `indent` spaces.
+ */
+char *
+sc_str_wrap_lines(const char *input, unsigned columns, unsigned indent);
+
+/**
+ * Truncate the data after any of the characters from `endchars`
+ *
+ * An '\0' is always written at the end of the data, even if no newline
+ * character is encountered.
+ *
+ * Return the size of the resulting line.
+ */
+size_t
+sc_str_truncate(char *data, size_t len, const char *endchars);
+
+#endif

app/src/util/str_util.h

@@ -1,65 +0,0 @@
-#ifndef STRUTIL_H
-#define STRUTIL_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-
-// like strncpy, except:
-//  - it copies at most n-1 chars
-//  - the dest string is nul-terminated
-//  - it does not write useless bytes if strlen(src) < n
-//  - it returns the number of chars actually written (max n-1) if src has
-//    been copied completely, or n if src has been truncated
-size_t
-xstrncpy(char *dest, const char *src, size_t n);
-
-// join tokens by sep into dst
-// returns the number of chars actually written (max n-1) if no truncation
-// occurred, or n if truncated
-size_t
-xstrjoin(char *dst, const char *const tokens[], char sep, size_t n);
-
-// quote a string
-// returns the new allocated string, to be freed by the caller
-char *
-strquote(const char *src);
-
-// parse s as an integer into value
-// returns true if the conversion succeeded, false otherwise
-bool
-parse_integer(const char *s, long *out);
-
-// parse s as integers separated by sep (for example '1234:2000')
-// returns the number of integers on success, 0 on failure
-size_t
-parse_integers(const char *s, const char sep, size_t max_items, long *out);
-
-// parse s as an integer into value
-// like parse_integer(), but accept 'k'/'K' (x1000) and 'm'/'M' (x1000000) as
-// suffix
-// returns true if the conversion succeeded, false otherwise
-bool
-parse_integer_with_suffix(const char *s, long *out);
-
-// search s in the list separated by sep
-// for example, strlist_contains("a,bc,def", ',', "bc") returns true
-bool
-strlist_contains(const char *list, char sep, const char *s);
-
-// return the index to truncate a UTF-8 string at a valid position
-size_t
-utf8_truncation_index(const char *utf8, size_t max_len);
-
-#ifdef _WIN32
-// convert a UTF-8 string to a wchar_t string
-// returns the new allocated string, to be freed by the caller
-wchar_t *
-utf8_to_wide_char(const char *utf8);
-
-char *
-utf8_from_wide_char(const wchar_t *s);
-#endif
-
-#endif

app/src/util/strbuf.c

@@ -0,0 +1,87 @@
+#include "strbuf.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <stdio.h>
+
+bool
+sc_strbuf_init(struct sc_strbuf *buf, size_t init_cap) {
+    buf->s = malloc(init_cap + 1); // +1 for '\0'
+    if (!buf->s) {
+        return false;
+    }
+
+    buf->len = 0;
+    buf->cap = init_cap;
+    return true;
+}
+
+static bool
+sc_strbuf_reserve(struct sc_strbuf *buf, size_t len) {
+    if (buf->len + len > buf->cap) {
+        size_t new_cap = buf->cap * 3 / 2 + len;
+        char *s = realloc(buf->s, new_cap + 1); // +1 for '\0'
+        if (!s) {
+            // Leave the old buf->s
+            return false;
+        }
+        buf->s = s;
+        buf->cap = new_cap;
+    }
+    return true;
+}
+
+bool
+sc_strbuf_append(struct sc_strbuf *buf, const char *s, size_t len) {
+    assert(s);
+    assert(*s);
+    assert(strlen(s) >= len);
+    if (!sc_strbuf_reserve(buf, len)) {
+        return false;
+    }
+
+    memcpy(&buf->s[buf->len], s, len);
+    buf->len += len;
+    buf->s[buf->len] = '\0';
+
+    return true;
+}
+
+bool
+sc_strbuf_append_char(struct sc_strbuf *buf, const char c) {
+    if (!sc_strbuf_reserve(buf, 1)) {
+        return false;
+    }
+
+    buf->s[buf->len] = c;
+    buf->len ++;
+    buf->s[buf->len] = '\0';
+
+    return true;
+}
+
+bool
+sc_strbuf_append_n(struct sc_strbuf *buf, const char c, size_t n) {
+    if (!sc_strbuf_reserve(buf, n)) {
+        return false;
+    }
+
+    memset(&buf->s[buf->len], c, n);
+    buf->len += n;
+    buf->s[buf->len] = '\0';
+
+    return true;
+}
+
+void
+sc_strbuf_shrink(struct sc_strbuf *buf) {
+    assert(buf->len <= buf->cap);
+    if (buf->len != buf->cap) {
+        char *s = realloc(buf->s, buf->len + 1); // +1 for '\0'
+        assert(s); // decreasing the size may not fail
+        buf->s = s;
+        buf->cap = buf->len;
+    }
+}

app/src/util/strbuf.h

@@ -0,0 +1,73 @@
+#ifndef SC_STRBUF_H
+#define SC_STRBUF_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+
+struct sc_strbuf {
+    char *s;
+    size_t len;
+    size_t cap;
+};
+
+/**
+ * Initialize the string buffer
+ *
+ * `buf->s` must be manually freed by the caller.
+ */
+bool
+sc_strbuf_init(struct sc_strbuf *buf, size_t init_cap);
+
+/**
+ * Append a string
+ *
+ * Append `len` characters from `s` to the buffer.
+ */
+bool
+sc_strbuf_append(struct sc_strbuf *buf, const char *s, size_t len);
+
+/**
+ * Append a char
+ *
+ * Append a single character to the buffer.
+ */
+bool
+sc_strbuf_append_char(struct sc_strbuf *buf, const char c);
+
+/**
+ * Append a char `n` times
+ *
+ * Append the same characters `n` times to the buffer.
+ */
+bool
+sc_strbuf_append_n(struct sc_strbuf *buf, const char c, size_t n);
+
+/**
+ * Append a NUL-terminated string
+ */
+static inline bool
+sc_strbuf_append_str(struct sc_strbuf *buf, const char *s) {
+    return sc_strbuf_append(buf, s, strlen(s));
+}
+
+/**
+ * Append a static string
+ *
+ * Append a string whose size is known at compile time (for
+ * example a string literal).
+ */
+#define sc_strbuf_append_staticstr(BUF, S) \
+    sc_strbuf_append(BUF, S, sizeof(S) - 1)
+
+/**
+ * Shrink the buffer capacity to its current length
+ *
+ * This resizes `buf->s` to fit the content.
+ */
+void
+sc_strbuf_shrink(struct sc_strbuf *buf);
+
+#endif

app/src/util/term.c

@@ -0,0 +1,51 @@
+#include "term.h"
+
+#include <assert.h>
+
+#ifdef _WIN32
+# include <windows.h>
+#else
+# include <unistd.h>
+# include <sys/ioctl.h>
+#endif
+
+bool
+sc_term_get_size(unsigned *rows, unsigned *cols) {
+#ifdef _WIN32
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+
+    bool ok =
+        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
+    if (!ok) {
+        return false;
+    }
+
+    if (rows) {
+        assert(csbi.srWindow.Bottom >= csbi.srWindow.Top);
+        *rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+    }
+
+    if (cols) {
+        assert(csbi.srWindow.Right >= csbi.srWindow.Left);
+        *cols = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+    }
+
+    return true;
+#else
+    struct winsize ws;
+    int r = ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
+    if (r == -1) {
+        return false;
+    }
+
+    if (rows) {
+        *rows = ws.ws_row;
+    }
+
+    if (cols) {
+        *cols = ws.ws_col;
+    }
+
+    return true;
+#endif
+}

app/src/util/term.h

@@ -0,0 +1,21 @@
+#ifndef SC_TERM_H
+#define SC_TERM_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+/**
+ * Return the terminal dimensions
+ *
+ * Return false if the dimensions could not be retrieved.
+ *
+ * Otherwise, return true, and:
+ *  - if `rows` is not NULL, then the number of rows is written to `*rows`.
+ *  - if `columns` is not NULL, then the number of columns is written to
+ *    `*columns`.
+ */
+bool
+sc_term_get_size(unsigned *rows, unsigned *cols);
+
+#endif

app/src/util/thread.c

@@ -31,7 +31,7 @@ sc_mutex_init(sc_mutex *mutex) {
 
     mutex->mutex = sdl_mutex;
 #ifndef NDEBUG
-    mutex->locker = 0;
+    atomic_init(&mutex->locker, 0);
 #endif
     return true;
 }
@@ -52,7 +52,8 @@ sc_mutex_lock(sc_mutex *mutex) {
         abort();
     }
 
-    mutex->locker = sc_thread_get_id();
+    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
+                          memory_order_relaxed);
 #else
     (void) r;
 #endif
@@ -62,7 +63,7 @@ void
 sc_mutex_unlock(sc_mutex *mutex) {
 #ifndef NDEBUG
     assert(sc_mutex_held(mutex));
-    mutex->locker = 0;
+    atomic_store_explicit(&mutex->locker, 0, memory_order_relaxed);
 #endif
     int r = SDL_UnlockMutex(mutex->mutex);
 #ifndef NDEBUG
@@ -83,7 +84,9 @@ sc_thread_get_id(void) {
 #ifndef NDEBUG
 bool
 sc_mutex_held(struct sc_mutex *mutex) {
-    return mutex->locker == sc_thread_get_id();
+    sc_thread_id locker_id =
+        atomic_load_explicit(&mutex->locker, memory_order_relaxed);
+    return locker_id == sc_thread_get_id();
 }
 #endif
 
@@ -112,14 +115,21 @@ sc_cond_wait(sc_cond *cond, sc_mutex *mutex) {
         abort();
     }
 
-    mutex->locker = sc_thread_get_id();
+    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
+                          memory_order_relaxed);
 #else
     (void) r;
 #endif
 }
 
 bool
-sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms) {
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline) {
+    sc_tick now = sc_tick_now();
+    if (deadline <= now) {
+        return false; // timeout
+    }
+
+    uint32_t ms = SC_TICK_TO_MS(deadline - now);
     int r = SDL_CondWaitTimeout(cond->cond, mutex->mutex, ms);
 #ifndef NDEBUG
     if (r < 0) {
@@ -127,7 +137,8 @@ sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms) {
         abort();
     }
 
-    mutex->locker = sc_thread_get_id();
+    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
+                          memory_order_relaxed);
 #endif
     assert(r == 0 || r == SDL_MUTEX_TIMEDOUT);
     return r == 0;

app/src/util/thread.h

@@ -3,8 +3,10 @@
 
 #include "common.h"
 
+#include <stdatomic.h>
 #include <stdbool.h>
-#include <stdint.h>
+
+#include "tick.h"
 
 /* Forward declarations */
 typedef struct SDL_Thread SDL_Thread;
@@ -12,7 +14,8 @@ typedef struct SDL_mutex SDL_mutex;
 typedef struct SDL_cond SDL_cond;
 
 typedef int sc_thread_fn(void *);
-typedef unsigned int sc_thread_id;
+typedef unsigned sc_thread_id;
+typedef atomic_uint sc_atomic_thread_id;
 
 typedef struct sc_thread {
     SDL_Thread *thread;
@@ -21,7 +24,7 @@ typedef struct sc_thread {
 typedef struct sc_mutex {
     SDL_mutex *mutex;
 #ifndef NDEBUG
-    sc_thread_id locker;
+    sc_atomic_thread_id locker;
 #endif
 } sc_mutex;
 
@@ -70,7 +73,7 @@ sc_cond_wait(sc_cond *cond, sc_mutex *mutex);
 
 // return true on signaled, false on timeout
 bool
-sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms);
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline);
 
 void
 sc_cond_signal(sc_cond *cond);

app/src/util/tick.c

@@ -0,0 +1,16 @@
+#include "tick.h"
+
+#include <SDL2/SDL_timer.h>
+
+sc_tick
+sc_tick_now(void) {
+    // SDL_GetTicks() resolution is in milliseconds, but sc_tick are expressed
+    // in microseconds to store PTS without precision loss.
+    //
+    // As an alternative, SDL_GetPerformanceCounter() and
+    // SDL_GetPerformanceFrequency() could be used, but:
+    //  - the conversions (avoiding overflow) are expansive, since the
+    //    frequency is not known at compile time;
+    //  - in practice, we don't need more precision for now.
+    return (sc_tick) SDL_GetTicks() * 1000;
+}

app/src/util/tick.h

@@ -0,0 +1,23 @@
+#ifndef SC_TICK_H
+#define SC_TICK_H
+
+#include "common.h"
+
+#include <stdint.h>
+
+typedef int64_t sc_tick;
+#define PRItick PRIi64
+#define SC_TICK_FREQ 1000000 // microsecond
+
+// To be adapted if SC_TICK_FREQ changes
+#define SC_TICK_TO_US(tick) (tick)
+#define SC_TICK_TO_MS(tick) ((tick) / 1000)
+#define SC_TICK_TO_SEC(tick) ((tick) / 1000000)
+#define SC_TICK_FROM_US(us) (us)
+#define SC_TICK_FROM_MS(ms) ((ms) * 1000)
+#define SC_TICK_FROM_SEC(sec) ((sec) * 1000000)
+
+sc_tick
+sc_tick_now(void);
+
+#endif

app/src/v4l2_sink.c

@@ -1,7 +1,7 @@
 #include "v4l2_sink.h"
 
 #include "util/log.h"
-#include "util/str_util.h"
+#include "util/str.h"
 
 /** Downcast frame_sink to sc_v4l2_sink */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_v4l2_sink, frame_sink)
@@ -21,7 +21,7 @@ find_muxer(const char *name) {
         oformat = av_oformat_next(oformat);
 #endif
         // until null or containing the requested name
-    } while (oformat && !strlist_contains(oformat->name, ',', name));
+    } while (oformat && !sc_str_list_contains(oformat->name, ',', name));
     return oformat;
 }
 
@@ -112,7 +112,7 @@ run_v4l2_sink(void *data) {
     for (;;) {
         sc_mutex_lock(&vs->mutex);
 
-        while (!vs->stopped && vs->vb.pending_frame_consumed) {
+        while (!vs->stopped && !vs->has_frame) {
             sc_cond_wait(&vs->cond, &vs->mutex);
         }
 
@@ -121,9 +121,11 @@ run_v4l2_sink(void *data) {
             break;
         }
 
+        vs->has_frame = false;
         sc_mutex_unlock(&vs->mutex);
 
-        video_buffer_consume(&vs->vb, vs->frame);
+        sc_video_buffer_consume(&vs->vb, vs->frame);
+
         bool ok = encode_and_write_frame(vs, vs->frame);
         av_frame_unref(vs->frame);
         if (!ok) {
@@ -137,17 +139,42 @@ run_v4l2_sink(void *data) {
     return 0;
 }
 
+static void
+sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
+                             void *userdata) {
+    (void) vb;
+    struct sc_v4l2_sink *vs = userdata;
+
+    if (!previous_skipped) {
+        sc_mutex_lock(&vs->mutex);
+        vs->has_frame = true;
+        sc_cond_signal(&vs->cond);
+        sc_mutex_unlock(&vs->mutex);
+    }
+}
+
 static bool
 sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
-    bool ok = video_buffer_init(&vs->vb);
+    static const struct sc_video_buffer_callbacks cbs = {
+        .on_new_frame = sc_video_buffer_on_new_frame,
+    };
+
+    bool ok = sc_video_buffer_init(&vs->vb, vs->buffering_time, &cbs, vs);
     if (!ok) {
+        LOGE("Could not initialize video buffer");
         return false;
     }
 
+    ok = sc_video_buffer_start(&vs->vb);
+    if (!ok) {
+        LOGE("Could not start video buffer");
+        goto error_video_buffer_destroy;
+    }
+
     ok = sc_mutex_init(&vs->mutex);
     if (!ok) {
         LOGC("Could not create mutex");
-        goto error_video_buffer_destroy;
+        goto error_video_buffer_stop_and_join;
     }
 
     ok = sc_cond_init(&vs->cond);
@@ -156,8 +183,11 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
         goto error_mutex_destroy;
     }
 
-    // FIXME
-    const AVOutputFormat *format = find_muxer("video4linux2,v4l2");
+    const AVOutputFormat *format = find_muxer("v4l2");
+    if (!format) {
+        // Alternative name
+        format = find_muxer("video4linux2");
+    }
     if (!format) {
         LOGE("Could not find v4l2 muxer");
         goto error_cond_destroy;
@@ -241,6 +271,10 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
         goto error_av_frame_free;
     }
 
+    vs->has_frame = false;
+    vs->header_written = false;
+    vs->stopped = false;
+
     LOGD("Starting v4l2 thread");
     ok = sc_thread_create(&vs->thread, run_v4l2_sink, "v4l2", vs);
     if (!ok) {
@@ -248,9 +282,6 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
         goto error_av_packet_free;
     }
 
-    vs->header_written = false;
-    vs->stopped = false;
-
     LOGI("v4l2 sink started to device: %s", vs->device_name);
 
     return true;
@@ -271,8 +302,11 @@ error_cond_destroy:
     sc_cond_destroy(&vs->cond);
 error_mutex_destroy:
     sc_mutex_destroy(&vs->mutex);
+error_video_buffer_stop_and_join:
+    sc_video_buffer_stop(&vs->vb);
+    sc_video_buffer_join(&vs->vb);
 error_video_buffer_destroy:
-    video_buffer_destroy(&vs->vb);
+    sc_video_buffer_destroy(&vs->vb);
 
     return false;
 }
@@ -284,7 +318,10 @@ sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
     sc_cond_signal(&vs->cond);
     sc_mutex_unlock(&vs->mutex);
 
+    sc_video_buffer_stop(&vs->vb);
+
     sc_thread_join(&vs->thread, NULL);
+    sc_video_buffer_join(&vs->vb);
 
     av_packet_free(&vs->packet);
     av_frame_free(&vs->frame);
@@ -294,20 +331,12 @@ sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
     avformat_free_context(vs->format_ctx);
     sc_cond_destroy(&vs->cond);
     sc_mutex_destroy(&vs->mutex);
-    video_buffer_destroy(&vs->vb);
+    sc_video_buffer_destroy(&vs->vb);
 }
 
 static bool
 sc_v4l2_sink_push(struct sc_v4l2_sink *vs, const AVFrame *frame) {
-    bool ok = video_buffer_push(&vs->vb, frame, NULL);
-    if (!ok) {
-        return false;
-    }
-
-    // signal possible change of vs->vb.pending_frame_consumed
-    sc_cond_signal(&vs->cond);
-
-    return true;
+    return sc_video_buffer_push(&vs->vb, frame);
 }
 
 static bool
@@ -330,7 +359,7 @@ sc_v4l2_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
 
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct size frame_size) {
+                  struct sc_size frame_size, sc_tick buffering_time) {
     vs->device_name = strdup(device_name);
     if (!vs->device_name) {
         LOGE("Could not strdup v4l2 device name");
@@ -338,6 +367,7 @@ sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
     }
 
     vs->frame_size = frame_size;
+    vs->buffering_time = buffering_time;
 
     static const struct sc_frame_sink_ops ops = {
         .open = sc_v4l2_frame_sink_open,

app/src/v4l2_sink.h

@@ -6,22 +6,25 @@
 #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
 
-    struct video_buffer vb;
+    struct sc_video_buffer vb;
     AVFormatContext *format_ctx;
     AVCodecContext *encoder_ctx;
 
     char *device_name;
-    struct size frame_size;
+    struct sc_size frame_size;
+    sc_tick buffering_time;
 
     sc_thread thread;
     sc_mutex mutex;
     sc_cond cond;
+    bool has_frame;
     bool stopped;
     bool header_written;
 
@@ -31,7 +34,7 @@ struct sc_v4l2_sink {
 
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct size frame_size);
+                  struct sc_size frame_size, sc_tick buffering_time);
 
 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);