wip

buffering_thread
Add missing error log
2021-07-04 23:48:10 +02:00 · 2021-07-04 17:29:50 +02:00 · 2021-07-04 17:29:50 +02:00 · 2021-07-04 17:29:50 +02:00 · 2021-07-04 17:29:50 +02:00 · 2021-07-04 17:29:50 +02:00
142 changed files with 2930 additions and 9041 deletions
--- a/BUILD.md
+++ b/BUILD.md
@@ -14,8 +14,7 @@ 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
@@ -89,12 +88,11 @@ Install the required packages from your package manager.
 ```bash
 # runtime dependencies
-sudo apt install ffmpeg libsdl2-2.0-0 adb libusb-1.0-0
+sudo apt install ffmpeg libsdl2-2.0-0 adb
 # 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
@@ -116,7 +114,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 libusb-devel meson gcc make
+sudo dnf install SDL2-devel ffms2-devel meson gcc make
 # server build dependencies
 sudo dnf install java-devel
@@ -270,10 +268,10 @@ install` must be run as root)._
 #### Option 2: Use prebuilt server
- - [`scrcpy-server-v1.20`][direct-scrcpy-server]  
+ - [`scrcpy-server-v1.18`][direct-scrcpy-server]  
-   _(SHA-256: b20aee4951f99b060c4a44000ba94de973f9604758ef62beb253b371aad3df34)_
+   _(SHA-256: 641c5c6beda9399dfae72d116f5ff43b5ed1059d871c9ebc3f47610fd33c51a3)_
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.20/scrcpy-server-v1.20
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-server-v1.18
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/DEVELOP.md
+++ b/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 messages_
+ - the **receiver** thread (managed by the controller), sending _device messges_
   to the clients (currently, it is only used to send the device clipboard
   content).
--- a/FAQ.it.md
+++ b/FAQ.it.md
@@ -140,24 +140,6 @@ 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
--- a/FAQ.md
+++ b/FAQ.md
@@ -118,17 +118,13 @@ In developer options, enable:
 ### Special characters do not work
-The default text injection method is [limited to ASCII characters][text-input].
+Injecting text input is [limited to ASCII characters][text-input]. A trick
-A trick allows to also inject some [accented characters][accented-characters],
+allows to also inject some [accented characters][accented-characters], but
-but that's all. See [#37].
+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
@@ -157,26 +153,6 @@ 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
@@ -222,27 +198,6 @@ 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
@@ -283,6 +238,5 @@ to add some arguments.
 This FAQ is available in other languages:
- - [Italiano (Italiano, `it`) - v1.19](FAQ.it.md)
+ - [Italiano (Italiano, `it`) - v1.17](FAQ.it.md)
 - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.18](FAQ.zh-Hans.md)
--- a/FAQ.zh-Hans.md
+++ b/FAQ.zh-Hans.md
@@ -1,240 +0,0 @@
 只有原版的[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/
--- a/README.it.md
+++ b/README.it.md
@@ -1,6 +1,6 @@
 _Apri il [README](README.md) originale e sempre aggiornato._
-# scrcpy (v1.19)
+# scrcpy (v1.17)
 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,11 +205,10 @@ Se anche `--max-size` è specificata, il ridimensionamento è applicato dopo il
 Per bloccare l'orientamento della trasmissione:
 ```bash
-scrcpy --lock-video-orientation     # orientamento iniziale (corrente)
+scrcpy --lock-video-orientation 0   # orientamento naturale
-scrcpy --lock-video-orientation=0   # orientamento naturale
+scrcpy --lock-video-orientation 1   # 90° antiorario
-scrcpy --lock-video-orientation=1   # 90° antiorario
+scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation 3   # 90° orario
 scrcpy --lock-video-orientation=3   # 90° orario
 ```
 Questo influisce sull'orientamento della registrazione.
@@ -232,9 +231,7 @@ Per elencare i codificatori disponibili puoi immettere un nome di codificatore n
 scrcpy --encoder _
 ```
-### Cattura
+### Registrazione
 #### Registrazione
 È possibile registrare lo schermo durante la trasmissione:
@@ -256,75 +253,6 @@ 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
@@ -551,6 +479,15 @@ 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
@@ -670,14 +607,14 @@ Non c'è alcuna risposta visiva, un log è stampato nella console.
 #### Trasferimento di file verso il dispositivo
-Per trasferire un file in `/sdcard/Download` del dispositivo trascina e rilascia un file (non APK) nella finestra di _scrcpy_.
+Per trasferire un file in `/sdcard/` 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/Movies/
+scrcpy --push-target=/sdcard/Download/
 ```
@@ -716,10 +653,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 sinistro¹_
+ | Ridimensiona la finestra per rimuovere i bordi neri       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doppio click¹_
 | 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> \| _4° click³_
+ | Premi il tasto `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd>
 | 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ù)_
@@ -728,26 +665,18 @@ _<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> \| _5° click³_
+ | Espandi il pannello delle notifiche                   | <kbd>MOD</kbd>+<kbd>n</kbd>
- | Espandi il pannello delle impostazioni                   | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Doppio 5° click³_
+ | Chiudi il pannello delle notifiche                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Chiudi pannelli                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copia negli appunti³                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Copia negli appunti⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Taglia negli appunti³                           | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Taglia negli appunti⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Sincronizza gli appunti e incolla³           | <kbd>MOD</kbd>+<kbd>v</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._  
-_³4° e 5° pulsante del mouse, se il tuo mouse ne dispone._  
+_³Solo in Android >= 7._
 _⁴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.
--- a/README.jp.md
+++ b/README.jp.md
@@ -1,6 +1,6 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._
-# scrcpy (v1.19)
+# scrcpy (v1.17)
 このアプリケーションはUSB(もしくは[TCP/IP経由][article-tcpip])で接続されたAndroidデバイスの表示と制御を提供します。このアプリケーションは _root_ でのアクセスを必要としません。このアプリケーションは _GNU/Linux_ 、 _Windows_ そして _macOS_ 上で動作します。
@@ -103,22 +103,19 @@ scoop install adb    # まだ入手していない場合
 brew install scrcpy
 ```
-`PATH`からアクセス可能な`adb`が必要です。もし持っていない場合はインストールしてください。
+`PATH`から`adb`へのアクセスが必要です。もしまだ持っていない場合:
 ```bash
-brew install android-platform-tools
+# Homebrew >= 2.6.0
 brew install --cask android-platform-tools
 # Homebrew < 2.6.0
 brew cask install android-platform-tools
 ```
 `adb`は[MacPorts]からでもインストールできます。
 ```bash
 sudo port install scrcpy
 ```
 [MacPorts]: https://www.macports.org/
 また、[アプリケーションをビルド][BUILD]することも可能です。
 ## 実行
 Androidデバイスを接続し、実行:
@@ -187,11 +184,10 @@ scrcpy --crop 1224:1440:0:0   # オフセット位置(0,0)で1224x1440
 ミラーリングの向きをロックするには:
 ```bash
-scrcpy --lock-video-orientation     # 現在の向き
+scrcpy --lock-video-orientation 0   # 自然な向き
-scrcpy --lock-video-orientation=0   # 自然な向き
+scrcpy --lock-video-orientation 1   # 90°反時計回り
-scrcpy --lock-video-orientation=1   # 90°反時計回り
+scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation 3   # 90°時計回り
 scrcpy --lock-video-orientation=3   # 90°時計回り
 ```
 この設定は録画の向きに影響します。
@@ -214,9 +210,7 @@ scrcpy --encoder OMX.qcom.video.encoder.avc
 scrcpy --encoder _
 ```
-### キャプチャ
+### 録画
 #### 録画
 ミラーリング中に画面の録画をすることが可能です:
@@ -239,77 +233,6 @@ 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
 ```
 ### 接続
@@ -534,6 +457,16 @@ scrcpy -Sw
 ```
 #### 期限切れフレームをレンダリングする
 初期状態では、待ち時間を最小限にするために、_scrcpy_ は最後にデコードされたフレームをレンダリングし、前のフレームを削除します。
 全フレームのレンダリングを強制するには(待ち時間が長くなる可能性があります):
 ```bash
 scrcpy --render-expired-frames
 ```
 #### タッチを表示
 プレゼンテーションの場合(物理デバイス上で)物理的なタッチを表示すると便利な場合があります。
@@ -653,14 +586,14 @@ APKをインストールするには、(`.apk`で終わる)APKファイルを _s
 #### デバイスにファイルを送る
-デバイスの`/sdcard/Download`ディレクトリにファイルを送るには、(APKではない)ファイルを _scrcpy_ の画面にドラッグ&ドロップします。
+デバイスの`/sdcard/`ディレクトリにファイルを送るには、(APKではない)ファイルを _scrcpy_ の画面にドラッグ&ドロップします。
 見た目のフィードバックはありません。コンソールにログが出力されます。
 転送先ディレクトリを起動時に変更することができます:
 ```bash
-scrcpy --push-target=/sdcard/Movies/
+scrcpy --push-target /sdcard/foo/bar/
 ```
@@ -701,7 +634,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> \| _4クリック³_
+ | `APP_SWITCH`をクリック                       | <kbd>MOD</kbd>+<kbd>s</kbd>
 | `MENU` (画面のアンロック)をクリック            | <kbd>MOD</kbd>+<kbd>m</kbd>
 | `VOLUME_UP`をクリック                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上)_
 | `VOLUME_DOWN`をクリック                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下)_
@@ -710,8 +643,7 @@ _<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> \| _5ボタンクリック³_
+ | 通知パネルを展開する                          | <kbd>MOD</kbd>+<kbd>n</kbd>
 | 設定パネルを展開する                          | <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>
@@ -722,17 +654,11 @@ _<kbd>[Super]</kbd>は通常<kbd>Windows</kbd>もしくは<kbd>Cmd</kbd>キー
 _¹黒い境界線を削除するため、境界線上でダブルクリック_  
 _²もしスクリーンがオフの場合、右クリックでスクリーンをオンする。それ以外の場合はBackを押します._  
-_³4と5はマウスのボタンです、もしあなたのマウスにボタンがあれば使えます._  
+_³Android 7以上のみ._
 _⁴Android 7以上のみ._
 キーを繰り返すショートカットはキーを離して2回目を押したら実行されます。例えば「設定パネルを展開する」を実行する場合は以下のように操作する。
 1. <kbd>MOD</kbd> キーを押し、押したままにする.
 2. その後に <kbd>n</kbd>キーを2回押す.
 3. 最後に <kbd>MOD</kbd>キーを離す.
 全ての<kbd>Ctrl</kbd>+_キー_ ショートカットはデバイスに転送されます、そのためアクティブなアプリケーションによって処理されます。
 ## カスタムパス
 特定の _adb_ バイナリを使用する場合、そのパスを環境変数`ADB`で構成します:
--- a/README.md
+++ b/README.md
@@ -1,37 +1,24 @@
-# scrcpy (v1.20)
+# scrcpy (v1.18)
 <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 via
+This application provides display and control of Android devices connected on
-USB (or [over TCP/IP](#wireless)). It does not require any _root_ access.
+USB (or [over TCP/IP][article-tcpip]). 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
+ - **lightness** (native, displays only the device screen)
- - **performance**: 30~120fps, depending on the device
+ - **performance** (30~60fps)
- - **quality**: 1920×1080 or above
+ - **quality** (1920×1080 or above)
- - **low latency**: [35~70ms][lowlatency]
+ - **low latency** ([35~70ms][lowlatency])
- - **low startup time**: ~1 second to display the first image
+ - **low startup time** (~1 second to display the first image)
- - **non-intrusiveness**: nothing is left installed on the device
+ - **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
@@ -101,10 +88,10 @@ process][BUILD_simple]).
 For Windows, for simplicity, a prebuilt archive with all the dependencies
 (including `adb`) is available:
- - [`scrcpy-win64-v1.20.zip`][direct-win64]  
+ - [`scrcpy-win64-v1.18.zip`][direct-win64]  
-   _(SHA-256: 548532b616288bcaeceff6881ad5e6f0928e5ae2b48c380385f03627401cfdba)_
+   _(SHA-256: 37212f5087fe6f3e258f1d44fa5c02207496b30e1d7ec442cbcf8358910a5c63)_
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.20/scrcpy-win64-v1.20.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-win64-v1.18.zip
 It is also available in [Chocolatey]:
@@ -331,27 +318,7 @@ vlc v4l2:///dev/videoN   # VLC might add some buffering delay
 For example, you could capture the video within [OBS].
-[OBS]: https://obsproject.com/
+[OBS]: https://obsproject.com/fr
 #### 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
@@ -412,66 +379,21 @@ autoadb scrcpy -s '{}'
 [AutoAdb]: https://github.com/rom1v/autoadb
-#### Tunnels
+#### SSH tunnel
 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):
 ##### Remote ADB server
 To connect to a remote ADB server, make the server listen on all interfaces:
 ```bash
-adb kill-server
+adb kill-server    # kill the local adb server on 5037
-adb -a nodaemon server start
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # keep this open
 ```
-**Warning: all communications between clients and ADB server are unencrypted.**
+From another terminal:
 Suppose that this server is accessible at 192.168.1.2. Then, from another
 terminal, run scrcpy:
 ```bash
 export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
 scrcpy --tunnel-host=192.168.1.2
 ```
 By default, scrcpy uses the local port used for `adb forward` tunnel
 establishment (typically `27183`, see `--port`). It is also possible to force a
 different tunnel port (it may be useful in more complex situations, when more
 redirections are involved):
 ```
 scrcpy --tunnel-port=1234
 ```
 ##### SSH tunnel
 To communicate with a remote ADB server securely, it is preferable to use a SSH
 tunnel.
 First, make sure the ADB server is running on the remote computer:
 ```bash
 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, run scrcpy:
 ```bash
 export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
@@ -479,16 +401,14 @@ To avoid enabling remote port forwarding, you could force a forward connection
 instead (notice the `-L` instead of `-R`):
 ```bash
-# local  5038 --> remote  5037
+adb kill-server    # kill the local adb server on 5037
-# local 27183 --> remote 27183
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # keep this open
 ```
-From another terminal, run scrcpy:
+From another terminal:
 ```bash
 export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
@@ -642,14 +562,6 @@ 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
@@ -741,39 +653,6 @@ 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
@@ -793,9 +672,6 @@ 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
@@ -811,9 +687,6 @@ 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
@@ -898,7 +771,7 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
 | Turn device screen on                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Rotate device screen                        | <kbd>MOD</kbd>+<kbd>r</kbd>
 | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5th-click³_
- | Expand settings panel                       | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Double-5th-click³_
+ | Expand settings panel                       |  <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Double-5th-click³_
 | Collapse panels                             | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | Copy to clipboard⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
 | Cut to clipboard⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
@@ -906,8 +779,6 @@ _<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._  
@@ -937,7 +808,7 @@ ADB=/path/to/adb scrcpy
 To override the path of the `scrcpy-server` file, configure its path in
 `SCRCPY_SERVER_PATH`.
-To override the icon, configure its path in `SCRCPY_ICON_PATH`.
+[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## Why _scrcpy_?
@@ -997,13 +868,12 @@ Read the [developers page].
 This README is available in other languages:
 - [Indonesian (Indonesia, `id`) - v1.16](README.id.md)
- [Italiano (Italiano, `it`) - v1.19](README.it.md)
+- [Italiano (Italiano, `it`) - v1.17](README.it.md)
- [日本語 (Japanese, `jp`) - v1.19](README.jp.md)
+- [日本語 (Japanese, `jp`) - v1.17](README.jp.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
- [Português Brasileiro (Brazilian Portuguese, `pt-BR`) - v1.19](README.pt-br.md)
+- [português brasileiro (Brazilian Portuguese, `pt-BR`) - v1.17](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.
--- a/README.pt-br.md
+++ b/README.pt-br.md
@@ -1,6 +1,6 @@
 _Apenas o [README](README.md) original é garantido estar atualizado._
-# scrcpy (v1.19)
+# scrcpy (v1.17)
 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,18 +38,6 @@ 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):
@@ -79,7 +67,9 @@ 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] ([processo simplificado][BUILD_simple]).
+Você também pode [compilar o app manualmente][BUILD] (não se preocupe, não é tão
 difícil).
 ### Windows
@@ -123,18 +113,13 @@ brew install scrcpy
 Você precisa do `adb`, acessível pelo seu `PATH`. Se você ainda não o tem:
 ```bash
-brew install android-platform-tools
+# Homebrew >= 2.6.0
 brew install --cask android-platform-tools
 # Homebrew < 2.6.0
 brew cask 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].
@@ -210,11 +195,10 @@ Se `--max-size` também for especificado, o redimensionamento é aplicado após
 Para travar a orientação do espelhamento:
 ```bash
-scrcpy --lock-video-orientation     # orientação inicial (Atual)
+scrcpy --lock-video-orientation 0   # orientação natural
-scrcpy --lock-video-orientation=0   # orientação natural
+scrcpy --lock-video-orientation 1   # 90° sentido anti-horário
-scrcpy --lock-video-orientation=1   # 90° sentido anti-horário
+scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation 3   # 90° sentido horário
 scrcpy --lock-video-orientation=3   # 90° sentido horário
 ```
 Isso afeta a orientação de gravação.
@@ -238,9 +222,7 @@ erro dará os encoders disponíveis:
 scrcpy --encoder _
 ```
-### Captura
+### Gravando
 #### Gravando
 É possível gravar a tela enquanto ocorre o espelhamento:
@@ -264,79 +246,6 @@ 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
@@ -579,6 +488,18 @@ 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
@@ -726,7 +647,7 @@ Não existe feedback visual, um log é imprimido no console.
 #### Enviar arquivo para dispositivo
-Para enviar um arquivo para `/sdcard/Download/` no dispositivo, arraste e solte um arquivo (não-APK) para a
+Para enviar um arquivo para `/sdcard/` 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.
@@ -773,12 +694,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-perfeito) | <kbd>MOD</kbd>+<kbd>g</kbd>
+ | 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-esquerdo¹_
+ | Redimensionar janela para remover bordas pretas | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Clique-duplo¹_
 | 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> \| _Clique-do-4.°³_
+ | Clicar em `APP_SWITCH`                      | <kbd>MOD</kbd>+<kbd>s</kbd>
- | Clicar em `MENU` (desbloquear tela)         | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | 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>
@@ -786,27 +707,18 @@ _<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> \| _Clique-do-5.°³_
+ | Expandir painel de notificação              | <kbd>MOD</kbd>+<kbd>n</kbd>
- | Expandir painel de configurção              | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Clique-duplo-do-5.°³_
+ | Colapsar painel de notificação              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Colapsar paineis                            | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copiar para área de transferência³          | <kbd>MOD</kbd>+<kbd>c</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>
- | 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>
 | 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-esquerdo na borda preta para remove-la._  
+_¹Clique-duplo em bordas pretas para removê-las._  
-_²Clique-direito liga a tela caso esteja desligada, pressione BACK caso contrário._  
+_²Clique-direito liga a tela se ela estiver desligada, pressiona BACK caso contrário._
-_³4.° and 5.° botões do mouse, caso o mouse possua._  
+_³Apenas em Android >= 7._
 _⁴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.
@@ -817,9 +729,7 @@ 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
 ADB=/caminho/para/adb scrcpy
 ```
 Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em
 `SCRCPY_SERVER_PATH`.
@@ -841,6 +751,8 @@ Um colega me desafiou a encontrar um nome tão impronunciável quanto [gnirehtet
 Veja [BUILD].
 [BUILD]: BUILD.md
 ## Problemas comuns
--- a/README.tr.md
+++ b/README.tr.md
@@ -1,824 +0,0 @@
 # 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/
--- a/app/meson.build
+++ b/app/meson.build
@@ -1,65 +1,37 @@
 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/icon.c',
+    'src/event_converter.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/acksync.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/process_intr.c',
+    'src/util/str_util.c',
    'src/util/strbuf.c',
    'src/util/str.c',
    'src/util/term.c',
    'src/util/thread.c',
    'src/util/tick.c',
 ]
 conf = configuration_data()
 if host_machine.system() == 'windows'
-    src += [
+    src += [ 'src/sys/win/process.c' ]
        'src/sys/win/file.c',
        'src/sys/win/process.c',
    ]
    conf.set('_WIN32_WINNT', '0x0600')
    conf.set('WINVER', '0x0600')
 else
-    src += [
+    src += [ 'src/sys/unix/process.c' ]
        'src/sys/unix/file.c',
        'src/sys/unix/process.c',
    ]
    conf.set('_POSIX_C_SOURCE', '200809L')
    conf.set('_XOPEN_SOURCE', '700')
    conf.set('_GNU_SOURCE', true)
    if host_machine.system() == 'darwin'
        conf.set('_DARWIN_C_SOURCE', true)
    endif
 endif
 v4l2_support = host_machine.system() == 'linux'
@@ -67,14 +39,6 @@ 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'
 ]
@@ -95,11 +59,8 @@ if not get_option('crossbuild_windows')
        dependencies += dependency('libavdevice')
    endif
    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'
@@ -139,6 +100,8 @@ if host_machine.system() == 'windows'
    dependencies += cc.find_library('ws2_32')
 endif
 conf = configuration_data()
 foreach f : check_functions
  if cc.has_function(f)
    define = 'HAVE_' + f.underscorify().to_upper()
@@ -174,9 +137,6 @@ 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')
@@ -188,9 +148,6 @@ 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
@@ -207,21 +164,12 @@ if get_option('buildtype') == 'debug'
        ['test_cli', [
            'tests/test_cli.c',
            'src/cli.c',
-            'src/options.c',
+            'src/util/str_util.c',
            'src/util/net.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.c',
+            'src/util/str_util.c',
            'src/util/strbuf.c',
        ]],
        ['test_device_msg_deserialize', [
            'tests/test_device_msg_deserialize.c',
@@ -230,14 +178,9 @@ if get_option('buildtype') == 'debug'
        ['test_queue', [
            'tests/test_queue.c',
        ]],
-        ['test_strbuf', [
+        ['test_strutil', [
-            'tests/test_strbuf.c',
+            'tests/test_strutil.c',
-            'src/util/strbuf.c',
+            'src/util/str_util.c',
        ]],
        ['test_str', [
            'tests/test_str.c',
            'src/util/str.c',
            'src/util/strbuf.c',
        ]],
    ]
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -56,12 +56,6 @@ 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).
@@ -82,14 +76,6 @@ 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).
@@ -97,8 +83,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]
+.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.
+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.
 Default is "unlocked".
@@ -136,10 +122,6 @@ 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.
@@ -203,31 +185,11 @@ Enable "show touches" on start, restore the initial value on exit.
 It only shows physical touches (not clicks from scrcpy).
 .TP
 .BI "\-\-tunnel\-host " ip
 Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
 Default is localhost.
 .TP
 .BI "\-\-tunnel\-port " port
 Set the TCP port of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
 Default is 0 (not forced): the local port used for establishing the tunnel will be used.
 .TP
 .BI "\-\-v4l2-sink " /dev/videoN
 Output to v4l2loopback device.
-It requires to lock the video orientation (see \fB\-\-lock\-video\-orientation\fR).
+It requires to lock the video orientation (see --lock-video-orientation).
 .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
@@ -278,7 +240,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 \fB\-\-shortcut\-mod\fR (see above).
+Alt or (left) Super, but it can be configured by \-\-shortcut-mod (see above).
 .TP
 .B MOD+f
@@ -380,10 +342,6 @@ 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
--- a/app/src/adb.c
+++ b/app/src/adb.c
@@ -5,10 +5,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include "util/file.h"
 #include "util/log.h"
-#include "util/process_intr.h"
+#include "util/str_util.h"
 #include "util/str.h"
 static const char *adb_command;
@@ -70,7 +68,7 @@ show_adb_installation_msg() {
        {"pacman", "pacman -S android-tools"},
    };
    for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
-        if (sc_file_executable_exists(pkg_managers[i].binary)) {
+        if (search_executable(pkg_managers[i].binary)) {
            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
            return;
        }
@@ -82,7 +80,7 @@ show_adb_installation_msg() {
 }
 static void
-show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
+show_adb_err_msg(enum process_result err, const char *const argv[]) {
 #define MAX_COMMAND_STRING_LEN 1024
    char *buf = malloc(MAX_COMMAND_STRING_LEN);
    if (!buf) {
@@ -91,18 +89,18 @@ show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
    }
    switch (err) {
-        case SC_PROCESS_ERROR_GENERIC:
+        case PROCESS_ERROR_GENERIC:
            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
            LOGE("Failed to execute: %s", buf);
            break;
-        case SC_PROCESS_ERROR_MISSING_BINARY:
+        case 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 SC_PROCESS_SUCCESS:
+        case PROCESS_SUCCESS:
            // do nothing
            break;
    }
@@ -110,15 +108,14 @@ show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
    free(buf);
 }
-static sc_pid
+process_t
-adb_execute_p(const char *serial, const char *const adb_cmd[],
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
              size_t len, sc_pipe *pout) {
    int i;
-    sc_pid pid;
+    process_t process;
    const char **argv = malloc((len + 4) * sizeof(*argv));
    if (!argv) {
-        return SC_PROCESS_NONE;
+        return PROCESS_NONE;
    }
    argv[0] = get_adb_command();
@@ -132,25 +129,19 @@ adb_execute_p(const char *serial, const char *const adb_cmd[],
    memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
    argv[len + i] = NULL;
-    enum sc_process_result r =
+    enum process_result r = process_execute(argv, &process);
-        sc_process_execute_p(argv, &pid, NULL, pout, NULL);
+    if (r != PROCESS_SUCCESS) {
    if (r != SC_PROCESS_SUCCESS) {
        show_adb_err_msg(r, argv);
-        pid = SC_PROCESS_NONE;
+        process = PROCESS_NONE;
    }
    free(argv);
-    return pid;
+    return process;
 }
-sc_pid
+process_t
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
+adb_forward(const char *serial, uint16_t local_port,
-    return adb_execute_p(serial, adb_cmd, len, NULL);
+            const char *device_socket_name) {
 }
 static sc_pid
 adb_exec_forward(const char *serial, uint16_t local_port,
                 const char *device_socket_name) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
    sprintf(local, "tcp:%" PRIu16, local_port);
@@ -159,17 +150,17 @@ adb_exec_forward(const char *serial, uint16_t local_port,
    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
-static sc_pid
+process_t
-adb_exec_forward_remove(const char *serial, uint16_t local_port) {
+adb_forward_remove(const char *serial, uint16_t local_port) {
    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));
 }
-static sc_pid
+process_t
-adb_exec_reverse(const char *serial, const char *device_socket_name,
+adb_reverse(const char *serial, const char *device_socket_name,
-                 uint16_t local_port) {
+            uint16_t local_port) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
    sprintf(local, "tcp:%" PRIu16, local_port);
@@ -178,131 +169,58 @@ adb_exec_reverse(const char *serial, const char *device_socket_name,
    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
-static sc_pid
+process_t
-adb_exec_reverse_remove(const char *serial, const char *device_socket_name) {
+adb_reverse_remove(const char *serial, const char *device_socket_name) {
    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));
 }
-static sc_pid
+process_t
-adb_exec_push(const char *serial, const char *local, const char *remote) {
+adb_push(const char *serial, const char *local, const char *remote) {
 #ifdef __WINDOWS__
    // Windows will parse the string, so the paths must be quoted
    // (see sys/win/command.c)
-    local = sc_str_quote(local);
+    local = strquote(local);
    if (!local) {
-        return SC_PROCESS_NONE;
+        return PROCESS_NONE;
    }
-    remote = sc_str_quote(remote);
+    remote = strquote(remote);
    if (!remote) {
        free((void *) local);
-        return SC_PROCESS_NONE;
+        return PROCESS_NONE;
    }
 #endif
    const char *const adb_cmd[] = {"push", local, remote};
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 #ifdef __WINDOWS__
    free((void *) remote);
    free((void *) local);
 #endif
-    return pid;
+    return proc;
 }
-static sc_pid
+process_t
-adb_exec_install(const char *serial, const char *local) {
+adb_install(const char *serial, const char *local) {
 #ifdef __WINDOWS__
    // Windows will parse the string, so the local name must be quoted
    // (see sys/win/command.c)
-    local = sc_str_quote(local);
+    local = strquote(local);
    if (!local) {
-        return SC_PROCESS_NONE;
+        return PROCESS_NONE;
    }
 #endif
    const char *const adb_cmd[] = {"install", "-r", local};
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 #ifdef __WINDOWS__
    free((void *) local);
 #endif
-    return pid;
+    return proc;
 }
 static sc_pid
 adb_exec_get_serialno(sc_pipe *pout) {
    const char *const adb_cmd[] = {"get-serialno"};
    return adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), pout);
 }
 bool
 adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
            const char *device_socket_name) {
    sc_pid pid = adb_exec_forward(serial, local_port, device_socket_name);
    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) {
    sc_pid pid = adb_exec_forward_remove(serial, local_port);
    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) {
    sc_pid pid = adb_exec_reverse(serial, device_socket_name, local_port);
    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) {
    sc_pid pid = adb_exec_reverse_remove(serial, device_socket_name);
    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) {
    sc_pid pid = adb_exec_push(serial, local, remote);
    return sc_process_check_success_intr(intr, pid, "adb push", true);
 }
 bool
 adb_install(struct sc_intr *intr, const char *serial, const char *local) {
    sc_pid pid = adb_exec_install(serial, local);
    return sc_process_check_success_intr(intr, pid, "adb install", true);
 }
 char *
 adb_get_serialno(struct sc_intr *intr) {
    sc_pipe pout;
    sc_pid pid = adb_exec_get_serialno(&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);
 }
--- a/app/src/adb.h
+++ b/app/src/adb.h
@@ -6,40 +6,29 @@
 #include <stdbool.h>
 #include <inttypes.h>
-#include "util/intr.h"
+#include "util/process.h"
-sc_pid
+process_t
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
-bool
+process_t
-adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
+adb_forward(const char *serial, uint16_t local_port,
            const char *device_socket_name);
-bool
+process_t
-adb_forward_remove(struct sc_intr *intr, const char *serial,
+adb_forward_remove(const char *serial, uint16_t local_port);
                   uint16_t local_port);
-bool
+process_t
-adb_reverse(struct sc_intr *intr, const char *serial,
+adb_reverse(const char *serial, const char *device_socket_name,
-            const char *device_socket_name, uint16_t local_port);
+            uint16_t local_port);
-bool
+process_t
-adb_reverse_remove(struct sc_intr *intr, const char *serial,
+adb_reverse_remove(const char *serial, const char *device_socket_name);
                   const char *device_socket_name);
-bool
+process_t
-adb_push(struct sc_intr *intr, const char *serial, const char *local,
+adb_push(const char *serial, const char *local, const char *remote);
         const char *remote);
-bool
+process_t
-adb_install(struct sc_intr *intr, const char *serial, const char *local);
+adb_install(const char *serial, const char *local);
 /**
 * 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);
 #endif
--- a/app/src/adb_tunnel.c
+++ b/app/src/adb_tunnel.c
@@ -1,165 +0,0 @@
 #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)) {
            // 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)) {
            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)) {
            // 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);
    } else {
        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME);
        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;
 }
--- a/app/src/adb_tunnel.h
+++ b/app/src/adb_tunnel.h
@@ -1,47 +0,0 @@
 #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
--- a/app/src/aoa_hid.c
+++ b/app/src/aoa_hid.c
@@ -1,396 +0,0 @@
 #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->ack_to_wait = SC_SEQUENCE_INVALID;
 }
 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,
            struct sc_acksync *acksync) {
    assert(acksync);
    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;
    aoa->acksync = acksync;
    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;
        uint64_t ack_to_wait = event.ack_to_wait;
        sc_mutex_unlock(&aoa->mutex);
        if (ack_to_wait != SC_SEQUENCE_INVALID) {
            LOGD("Waiting ack from server sequence=%" PRIu64_, ack_to_wait);
            // Do not block the loop indefinitely if the ack never comes (it should
            // never happen)
            sc_tick deadline = sc_tick_now() + SC_TICK_FROM_MS(500);
            enum sc_acksync_wait_result result =
                sc_acksync_wait(aoa->acksync, ack_to_wait, deadline);
            if (result == SC_ACKSYNC_WAIT_TIMEOUT) {
                LOGW("Ack not received after 500ms, discarding HID event");
                sc_hid_event_destroy(&event);
                continue;
            } else if (result == SC_ACKSYNC_WAIT_INTR) {
                // stopped
                sc_hid_event_destroy(&event);
                break;
            }
        }
        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);
    sc_acksync_interrupt(aoa->acksync);
 }
 void
 sc_aoa_join(struct sc_aoa *aoa) {
    sc_thread_join(&aoa->thread, NULL);
 }
--- a/app/src/aoa_hid.h
+++ b/app/src/aoa_hid.h
@@ -1,69 +0,0 @@
 #ifndef SC_AOA_HID_H
 #define SC_AOA_HID_H
 #include <stdint.h>
 #include <stdbool.h>
 #include <libusb-1.0/libusb.h>
 #include "util/acksync.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;
    uint64_t ack_to_wait;
 };
 // 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;
    struct sc_acksync *acksync;
 };
 bool
 sc_aoa_init(struct sc_aoa *aoa, const char *serial, struct sc_acksync *acksync);
 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
--- a/app/src/cli.c
+++ b/app/src/cli.c
--- a/app/src/cli.h
+++ b/app/src/cli.h
@@ -5,7 +5,7 @@
 #include <stdbool.h>
-#include "options.h"
+#include "scrcpy.h"
 struct scrcpy_cli_args {
    struct scrcpy_options opts;
--- a/app/src/clock.c
+++ b/app/src/clock.c
@@ -1,111 +0,0 @@
 #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;
 }
--- a/app/src/clock.h
+++ b/app/src/clock.h
@@ -1,70 +0,0 @@
 #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
--- a/app/src/compat.h
+++ b/app/src/compat.h
@@ -1,17 +1,16 @@
 #ifndef COMPAT_H
 #define COMPAT_H
-#include "config.h"
+#define _POSIX_C_SOURCE 200809L
 #define _XOPEN_SOURCE 700
 #define _GNU_SOURCE
 #ifdef __APPLE__
 # define _DARWIN_C_SOURCE
 #endif
 #include <libavformat/version.h>
 #include <SDL2/SDL_version.h>
 #ifndef __WIN32
 # define PRIu64_ PRIu64
 #else
 # define PRIu64_ "I64u"  // Windows...
 #endif
 // In ffmpeg/doc/APIchanges:
 // 2018-02-06 - 0694d87024 - lavf 58.9.100 - avformat.h
 //   Deprecate use of av_register_input_format(), av_register_output_format(),
@@ -44,11 +43,6 @@
 # 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
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@@ -7,7 +7,7 @@
 #include "util/buffer_util.h"
 #include "util/log.h"
-#include "util/str.h"
+#include "util/str_util.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 sc_position *position) {
+write_position(uint8_t *buf, const struct 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 sc_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 = sc_str_utf8_truncation_index(utf8, max_len);
+    size_t len = utf8_truncation_index(utf8, max_len);
    buffer_write32be(buf, len);
    memcpy(&buf[4], utf8, len);
    return 4 + len;
@@ -118,12 +118,11 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
            buf[1] = msg->inject_keycode.action;
            return 2;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
-            buffer_write64be(&buf[1], msg->set_clipboard.sequence);
+            buf[1] = !!msg->set_clipboard.paste;
            buf[9] = !!msg->set_clipboard.paste;
            size_t len = write_string(msg->set_clipboard.text,
                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-                                      &buf[10]);
+                                      &buf[2]);
-            return 10 + len;
+            return 2 + len;
        }
        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
            buf[1] = msg->set_screen_power_mode.mode;
@@ -171,6 +170,11 @@ control_msg_log(const struct control_msg *msg) {
                         (long) msg->inject_touch_event.buttons);
            } else {
                // numeric pointer id
 #ifndef __WIN32
 # define PRIu64_ PRIu64
 #else
 # define PRIu64_ "I64u"  // Windows...
 #endif
                LOG_CMSG("touch [id=%" PRIu64_ "] %-4s position=%" PRIi32 ",%"
                             PRIi32 " pressure=%g buttons=%06lx",
                         id,
@@ -195,8 +199,7 @@ control_msg_log(const struct control_msg *msg) {
                     KEYEVENT_ACTION_LABEL(msg->inject_keycode.action));
            break;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
-            LOG_CMSG("clipboard %" PRIu64_ " %s \"%s\"",
+            LOG_CMSG("clipboard %s \"%s\"",
                     msg->set_clipboard.sequence,
                     msg->set_clipboard.paste ? "paste" : "copy",
                     msg->set_clipboard.text);
            break;
--- a/app/src/control_msg.h
+++ b/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 sc_position position;
+            struct position position;
            float pressure;
        } inject_touch_event;
        struct {
-            struct sc_position position;
+            struct position position;
            int32_t hscroll;
            int32_t vscroll;
        } inject_scroll_event;
@@ -70,7 +70,6 @@ struct control_msg {
            // screen may only be turned on on ACTION_DOWN
        } back_or_screen_on;
        struct {
            uint64_t sequence;
            char *text; // owned, to be freed by free()
            bool paste;
        } set_clipboard;
--- a/app/src/controller.c
+++ b/app/src/controller.c
@@ -5,11 +5,10 @@
 #include "util/log.h"
 bool
-controller_init(struct controller *controller, sc_socket control_socket,
+controller_init(struct controller *controller, socket_t control_socket) {
                struct sc_acksync *acksync) {
    cbuf_init(&controller->queue);
-    bool ok = receiver_init(&controller->receiver, control_socket, acksync);
+    bool ok = receiver_init(&controller->receiver, control_socket);
    if (!ok) {
        return false;
    }
@@ -48,7 +47,7 @@ controller_destroy(struct controller *controller) {
 bool
 controller_push_msg(struct controller *controller,
-                    const struct control_msg *msg) {
+                      const struct control_msg *msg) {
    if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
        control_msg_log(msg);
    }
@@ -64,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;
    }
-    ssize_t w =
+    int w = net_send_all(controller->control_socket, serialized_msg, length);
        net_send_all(controller->control_socket, serialized_msg, length);
    return (size_t) w == length;
 }
--- a/app/src/controller.h
+++ b/app/src/controller.h
@@ -7,7 +7,6 @@
 #include "control_msg.h"
 #include "receiver.h"
 #include "util/acksync.h"
 #include "util/cbuf.h"
 #include "util/net.h"
 #include "util/thread.h"
@@ -15,7 +14,7 @@
 struct control_msg_queue CBUF(struct control_msg, 64);
 struct controller {
-    sc_socket control_socket;
+    socket_t control_socket;
    sc_thread thread;
    sc_mutex mutex;
    sc_cond msg_cond;
@@ -25,8 +24,7 @@ struct controller {
 };
 bool
-controller_init(struct controller *controller, sc_socket control_socket,
+controller_init(struct controller *controller, socket_t control_socket);
                struct sc_acksync *acksync);
 void
 controller_destroy(struct controller *controller);
--- a/app/src/coords.h
+++ b/app/src/coords.h
@@ -3,22 +3,22 @@
 #include <stdint.h>
-struct sc_size {
+struct size {
    uint16_t width;
    uint16_t height;
 };
-struct sc_point {
+struct point {
    int32_t x;
    int32_t y;
 };
-struct sc_position {
+struct 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 sc_size screen_size;
+    struct size screen_size;
-    struct sc_point point;
+    struct point point;
 };
 #endif
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@@ -1,6 +1,5 @@
 #include "decoder.h"
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include "events.h"
--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@@ -1,6 +1,5 @@
 #include "device_msg.h"
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ -35,11 +34,6 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
            msg->clipboard.text = text;
            return 5 + clipboard_len;
        }
        case DEVICE_MSG_TYPE_ACK_CLIPBOARD: {
            uint64_t sequence = buffer_read64be(&buf[1]);
            msg->ack_clipboard.sequence = sequence;
            return 9;
        }
        default:
            LOGW("Unknown device message type: %d", (int) msg->type);
            return -1; // error, we cannot recover
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@@ -13,7 +13,6 @@
 enum device_msg_type {
    DEVICE_MSG_TYPE_CLIPBOARD,
    DEVICE_MSG_TYPE_ACK_CLIPBOARD,
 };
 struct device_msg {
@@ -22,9 +21,6 @@ struct device_msg {
        struct {
            char *text; // owned, to be freed by free()
        } clipboard;
        struct {
            uint64_t sequence;
        } ack_clipboard;
    };
 };
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@@ -1,20 +1,9 @@
-#include "keyboard_inject.h"
+#include "event_converter.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
-static bool
+
 bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
    switch (from) {
        MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
@@ -23,7 +12,67 @@ convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
    }
 }
-static bool
+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
 convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
                bool prefer_text) {
    switch (from) {
@@ -105,158 +154,42 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
    }
 }
-static enum android_metastate
+enum android_motionevent_buttons
-autocomplete_metastate(enum android_metastate metastate) {
+convert_mouse_buttons(uint32_t state) {
-    // fill dependent flags
+    enum android_motionevent_buttons buttons = 0;
-    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
+    if (state & SDL_BUTTON_LMASK) {
-        metastate |= AMETA_SHIFT_ON;
+        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
    }
-    if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
+    if (state & SDL_BUTTON_RMASK) {
-        metastate |= AMETA_CTRL_ON;
+        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
    }
-    if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
+    if (state & SDL_BUTTON_MMASK) {
-        metastate |= AMETA_ALT_ON;
+        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
    }
-    if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
+    if (state & SDL_BUTTON_X1MASK) {
-        metastate |= AMETA_META_ON;
+        buttons |= AMOTION_EVENT_BUTTON_BACK;
    }
-
+    if (state & SDL_BUTTON_X2MASK) {
-    return metastate;
+        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
    }
    return buttons;
 }
-static enum android_metastate
+bool
-convert_meta_state(SDL_Keymod mod) {
+convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
-    enum android_metastate metastate = 0;
+    switch (from) {
-    if (mod & KMOD_LSHIFT) {
+        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
-        metastate |= AMETA_SHIFT_LEFT_ON;
+        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
-    }
+        FAIL;
    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,
                             uint64_t ack_to_wait) {
    // The device clipboard synchronization and the key event messages are
    // serialized, there is nothing special to do to ensure that the clipboard
    // is set before injecting Ctrl+v.
    (void) ack_to_wait;
    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'");
        }
    }
 }
-static void
+bool
-sc_key_processor_process_text(struct sc_key_processor *kp,
+convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
-                              const SDL_TextInputEvent *event) {
+    switch (from) {
-    struct sc_keyboard_inject *ki = DOWNCAST(kp);
+        MAP(SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE);
-
+        MAP(SDL_FINGERDOWN,   AMOTION_EVENT_ACTION_DOWN);
-    if (!ki->prefer_text) {
+        MAP(SDL_FINGERUP,     AMOTION_EVENT_ACTION_UP);
-        char c = event->text[0];
+        FAIL;
        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,
    };
    // Key injection and clipboard synchronization are serialized
    ki->key_processor.async_paste = false;
    ki->key_processor.ops = &ops;
 }
--- a/app/src/event_converter.h
+++ b/app/src/event_converter.h
@@ -0,0 +1,30 @@
 #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
--- a/app/src/events.h
+++ b/app/src/events.h
@@ -1,4 +1,2 @@
-#define EVENT_NEW_FRAME                 SDL_USEREVENT
+#define EVENT_NEW_FRAME       SDL_USEREVENT
-#define EVENT_STREAM_STOPPED           (SDL_USEREVENT + 1)
+#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 1)
 #define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
 #define EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@@ -5,7 +5,6 @@
 #include "adb.h"
 #include "util/log.h"
 #include "util/process_intr.h"
 #define DEFAULT_PUSH_TARGET "/sdcard/Download/"
@@ -17,7 +16,6 @@ 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);
@@ -32,26 +30,23 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
        return false;
    }
-    ok = sc_intr_init(&file_handler->intr);
+    if (serial) {
-    if (!ok) {
+        file_handler->serial = strdup(serial);
-        LOGE("Could not create intr");
+        if (!file_handler->serial) {
-        sc_cond_destroy(&file_handler->event_cond);
+            LOGW("Could not strdup serial");
-        sc_mutex_destroy(&file_handler->mutex);
+            sc_cond_destroy(&file_handler->event_cond);
-    }
+            sc_mutex_destroy(&file_handler->mutex);
-
+            return false;
-    file_handler->serial = strdup(serial);
+        }
-    if (!file_handler->serial) {
+    } else {
-        LOGE("Could not strdup serial");
+        file_handler->serial = NULL;
        sc_intr_destroy(&file_handler->intr);
        sc_cond_destroy(&file_handler->event_cond);
        sc_mutex_destroy(&file_handler->mutex);
        return false;
    }
    // lazy initialization
    file_handler->initialized = false;
    file_handler->stopped = false;
    file_handler->current_process = PROCESS_NONE;
    file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
@@ -62,7 +57,6 @@ 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;
@@ -71,6 +65,16 @@ 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) {
@@ -102,16 +106,10 @@ 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);
        }
@@ -124,26 +122,43 @@ 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) {
-            LOGI("Installing %s...", req.file);
+            if (process_check_success(process, "adb install", false)) {
            bool ok = adb_install(intr, serial, req.file);
            if (ok) {
                LOGI("%s successfully installed", req.file);
            } else {
                LOGE("Failed to install %s", req.file);
            }
        } else {
-            LOGI("Pushing %s...", req.file);
+            if (process_check_success(process, "adb push", false)) {
-            bool ok = adb_push(intr, serial, req.file, push_target);
+                LOGI("%s successfully pushed to %s", req.file,
-            if (ok) {
+                                                     file_handler->push_target);
                LOGI("%s successfully pushed to %s", req.file, push_target);
            } else {
-                LOGE("Failed to push %s to %s", req.file, push_target);
+                LOGE("Failed to push %s to %s", req.file,
                                                file_handler->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;
@@ -168,7 +183,11 @@ file_handler_stop(struct file_handler *file_handler) {
    sc_mutex_lock(&file_handler->mutex);
    file_handler->stopped = true;
    sc_cond_signal(&file_handler->event_cond);
-    sc_intr_interrupt(&file_handler->intr);
+    if (file_handler->current_process != PROCESS_NONE) {
        if (!process_terminate(file_handler->current_process)) {
            LOGW("Could not terminate push/install process");
        }
    }
    sc_mutex_unlock(&file_handler->mutex);
 }
--- a/app/src/file_handler.h
+++ b/app/src/file_handler.h
@@ -8,7 +8,6 @@
 #include "adb.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
 #include "util/intr.h"
 typedef enum {
    ACTION_INSTALL_APK,
@@ -30,9 +29,8 @@ 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
--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@@ -4,7 +4,7 @@
 #include "util/log.h"
-#define FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1)
+#define FPS_COUNTER_INTERVAL_MS 1000
 bool
 fps_counter_init(struct fps_counter *counter) {
@@ -46,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 * SC_TICK_FREQ / FPS_COUNTER_INTERVAL;
+        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;
    if (counter->nr_skipped) {
        LOGI("%u fps (+%u frames skipped)", rendered_per_second,
                                            counter->nr_skipped);
@@ -67,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 + 1;
+        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL_MS + 1;
-    counter->next_timestamp += FPS_COUNTER_INTERVAL * elapsed_slices;
+    counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;
 }
 static int
@@ -96,7 +96,7 @@ run_fps_counter(void *data) {
 bool
 fps_counter_start(struct fps_counter *counter) {
    sc_mutex_lock(&counter->mutex);
-    counter->next_timestamp = sc_tick_now() + FPS_COUNTER_INTERVAL;
+    counter->next_timestamp = sc_tick_now() + FPS_COUNTER_INTERVAL_MS;
    counter->nr_rendered = 0;
    counter->nr_skipped = 0;
    sc_mutex_unlock(&counter->mutex);
--- a/app/src/hid_keyboard.c
+++ b/app/src/hid_keyboard.c
@@ -1,364 +0,0 @@
 #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,
                             uint64_t ack_to_wait) {
    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;
            }
        }
        if (ack_to_wait) {
            // Ctrl+v is pressed, so clipboard synchronization has been
            // requested. Wait until clipboard synchronization is acknowledged
            // by the server, otherwise it could paste the old clipboard
            // content.
            hid_event.ack_to_wait = ack_to_wait;
        }
        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,
    };
    // Clipboard synchronization is requested over the control socket, while HID
    // events are sent over AOA, so it must wait for clipboard synchronization
    // to be acknowledged by the device before injecting Ctrl+v.
    kb->key_processor.async_paste = true;
    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");
    }
 }
--- a/app/src/hid_keyboard.h
+++ b/app/src/hid_keyboard.h
@@ -1,44 +0,0 @@
 #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
--- a/app/src/icon.c
+++ b/app/src/icon.c
@@ -1,290 +0,0 @@
 #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);
 }
--- a/app/src/icon.h
+++ b/app/src/icon.h
@@ -1,16 +0,0 @@
 #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
--- a/app/src/icon.xpm
+++ b/app/src/icon.xpm
@@ -0,0 +1,53 @@
 /* XPM */
 static char * icon_xpm[] = {
 "48 48 2 1",
 " 	c None",
 ".	c #96C13E",
 "              ..                ..              ",
 "              ...              ...              ",
 "               ...   ......   ...               ",
 "                ................                ",
 "                 ..............                 ",
 "                ................                ",
 "               ..................               ",
 "              ....................              ",
 "             .....  ........  .....             ",
 "             .....  ........  .....             ",
 "             ......................             ",
 "            ........................            ",
 "            ........................            ",
 "            ........................            ",
 "                                                ",
 "                                                ",
 "     ....   ........................   ....     ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "     ....   ........................   ....     ",
 "            ........................            ",
 "             ......................             ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                 ....      ....                 "};
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@@ -3,6 +3,7 @@
 #include <assert.h>
 #include <SDL2/SDL_keycode.h>
 #include "event_converter.h"
 #include "util/log.h"
 static const int ACTION_DOWN = 1;
@@ -52,18 +53,15 @@ 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 sc_key_processor *kp,
+                   struct screen *screen,
                   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->kp = kp;
+    im->repeat = 0;
    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;
@@ -82,8 +80,6 @@ input_manager_init(struct input_manager *im, struct controller *controller,
    im->last_keycode = SDLK_UNKNOWN;
    im->last_mod = 0;
    im->key_repeat = 0;
    im->next_sequence = 1; // 0 is reserved for SC_SEQUENCE_INVALID
 }
 static void
@@ -210,35 +206,35 @@ collapse_panels(struct controller *controller) {
    }
 }
-static bool
+static void
-set_device_clipboard(struct controller *controller, bool paste,
+set_device_clipboard(struct controller *controller, bool paste) {
                     uint64_t sequence) {
    char *text = SDL_GetClipboardText();
    if (!text) {
        LOGW("Could not get clipboard text: %s", SDL_GetError());
-        return false;
+        return;
    }
    if (!*text) {
        // empty text
        SDL_free(text);
        return;
    }
    char *text_dup = strdup(text);
    SDL_free(text);
    if (!text_dup) {
        LOGW("Could not strdup input text");
-        return false;
+        return;
    }
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
    msg.set_clipboard.sequence = sequence;
    msg.set_clipboard.text = text_dup;
    msg.set_clipboard.paste = paste;
    if (!controller_push_msg(controller, &msg)) {
        free(text_dup);
        LOGW("Could not request 'set device clipboard'");
        return false;
    }
    return true;
 }
 static void
@@ -327,14 +323,32 @@ 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;
        }
    }
-    im->kp->ops->process_text(im->kp, event);
+    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'");
    }
 }
 static bool
 simulate_virtual_finger(struct input_manager *im,
                        enum android_motionevent_action action,
-                        struct sc_point point) {
+                        struct point point) {
    bool up = action == AMOTION_EVENT_ACTION_UP;
    struct control_msg msg;
@@ -354,13 +368,34 @@ simulate_virtual_finger(struct input_manager *im,
    return true;
 }
-static struct sc_point
+static struct point
-inverse_point(struct sc_point point, struct sc_size size) {
+inverse_point(struct point point, struct 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) {
@@ -464,10 +499,8 @@ input_manager_process_key(struct input_manager *im,
                        // inject the text as input events
                        clipboard_paste(controller);
                    } else {
-                        // store the text in the device clipboard and paste,
+                        // store the text in the device clipboard and paste
-                        // without requesting an acknowledgment
+                        set_device_clipboard(controller, true);
                        set_device_clipboard(controller, true,
                                             SC_SEQUENCE_INVALID);
                    }
                }
                return;
@@ -516,36 +549,47 @@ input_manager_process_key(struct input_manager *im,
        return;
    }
-    uint64_t ack_to_wait = SC_SEQUENCE_INVALID;
+    if (event->repeat) {
-    bool is_ctrl_v = ctrl && !shift && keycode == SDLK_v && down && !repeat;
+        if (!im->forward_key_repeat) {
-    if (is_ctrl_v) {
+            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
            clipboard_paste(controller);
            return;
        }
        // Request an acknowledgement only if necessary
        uint64_t sequence = im->kp->async_paste ? im->next_sequence
                                                : SC_SEQUENCE_INVALID;
        // Synchronize the computer clipboard to the device clipboard before
        // sending Ctrl+v, to allow seamless copy-paste.
-        bool ok = set_device_clipboard(controller, false, sequence);
+        set_device_clipboard(controller, false);
        if (!ok) {
            LOGW("Clipboard could not be synchronized, Ctrl+v not injected");
            return;
        }
        if (im->kp->async_paste) {
            // The key processor must wait for this ack before injecting Ctrl+v
            ack_to_wait = sequence;
            // Increment only when the request succeeded
            ++im->next_sequence;
        }
    }
-    im->kp->ops->process_key(im->kp, event, ack_to_wait);
+    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;
 }
 static void
@@ -563,22 +607,79 @@ 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;
    }
-    im->mp->ops->process_mouse_motion(im->mp, event);
+    if (!controller_push_msg(im->controller, &msg)) {
        LOGW("Could not request 'inject mouse motion event'");
    }
    if (im->vfinger_down) {
-        struct sc_point mouse =
+        struct point mouse = msg.inject_touch_event.position.point;
-            screen_convert_window_to_frame_coords(im->screen, event->x,
+        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
                                                  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) {
-    im->mp->ops->process_touch(im->mp, 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;
 }
 static void
@@ -638,7 +739,15 @@ input_manager_process_mouse_button(struct input_manager *im,
        return;
    }
-    im->mp->ops->process_mouse_button(im->mp, event);
+    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;
    }
    // Pinch-to-zoom simulation.
    //
@@ -652,10 +761,8 @@ 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 sc_point mouse =
+        struct point mouse = msg.inject_touch_event.position.point;
-            screen_convert_window_to_frame_coords(im->screen, event->x,
+        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
                                                              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;
@@ -666,10 +773,39 @@ 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) {
-    im->mp->ops->process_mouse_wheel(im->mp, 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'");
        }
    }
 }
 bool
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@@ -9,19 +9,20 @@
 #include "controller.h"
 #include "fps_counter.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "screen.h"
 #include "trait/key_processor.h"
 #include "trait/mouse_processor.h"
 struct input_manager {
    struct controller *controller;
    struct screen *screen;
-    struct sc_key_processor *kp;
+    // SDL reports repeated events as a boolean, but Android expects the actual
-    struct sc_mouse_processor *mp;
+    // number of repetitions. This variable keeps track of the count.
    unsigned repeat;
    bool control;
    bool forward_key_repeat;
    bool prefer_text;
    bool forward_all_clicks;
    bool legacy_paste;
@@ -38,15 +39,11 @@ struct input_manager {
    unsigned key_repeat;
    SDL_Keycode last_keycode;
    uint16_t last_mod;
    uint64_t next_sequence; // used for request acknowledgements
 };
 void
 input_manager_init(struct input_manager *im, struct controller *controller,
-                   struct screen *screen, struct sc_key_processor *kp,
+                   struct screen *screen, const struct scrcpy_options *options);
                   struct sc_mouse_processor *mp,
                   const struct scrcpy_options *options);
 bool
 input_manager_handle_event(struct input_manager *im, SDL_Event *event);
--- a/app/src/keyboard_inject.h
+++ b/app/src/keyboard_inject.h
@@ -1,30 +0,0 @@
 #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
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -1,3 +1,5 @@
 #include "scrcpy.h"
 #include "common.h"
 #include <assert.h>
@@ -11,8 +13,6 @@
 #include <SDL2/SDL.h>
 #include "cli.h"
 #include "options.h"
 #include "scrcpy.h"
 #include "util/log.h"
 static void
@@ -47,11 +47,8 @@ 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,
    };
@@ -76,6 +73,8 @@ 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
--- a/app/src/mouse_inject.c
+++ b/app/src/mouse_inject.c
@@ -1,211 +0,0 @@
 #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;
 }
--- a/app/src/mouse_inject.h
+++ b/app/src/mouse_inject.h
@@ -1,23 +0,0 @@
 #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
--- a/app/src/options.c
+++ b/app/src/options.c
@@ -1,56 +0,0 @@
 #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,
    },
    .tunnel_host = 0,
    .tunnel_port = 0,
    .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,
 };
--- a/app/src/options.h
+++ b/app/src/options.h
@@ -1,115 +0,0 @@
 #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;
    uint32_t tunnel_host;
    uint16_t tunnel_port;
    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
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@@ -7,16 +7,12 @@
 #include "util/log.h"
 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
+receiver_init(struct receiver *receiver, socket_t control_socket) {
              struct sc_acksync *acksync) {
    bool ok = sc_mutex_init(&receiver->mutex);
    if (!ok) {
        return false;
    }
    receiver->control_socket = control_socket;
    receiver->acksync = acksync;
    return true;
 }
@@ -26,7 +22,7 @@ receiver_destroy(struct receiver *receiver) {
 }
 static void
-process_msg(struct receiver *receiver, struct device_msg *msg) {
+process_msg(struct device_msg *msg) {
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
            char *current = SDL_GetClipboardText();
@@ -41,17 +37,11 @@ process_msg(struct receiver *receiver, struct device_msg *msg) {
            SDL_SetClipboardText(msg->clipboard.text);
            break;
        }
        case DEVICE_MSG_TYPE_ACK_CLIPBOARD:
            assert(receiver->acksync);
            LOGD("Ack device clipboard sequence=%" PRIu64_,
                 msg->ack_clipboard.sequence);
            sc_acksync_ack(receiver->acksync, msg->ack_clipboard.sequence);
            break;
    }
 }
 static ssize_t
-process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
+process_msgs(const unsigned char *buf, size_t len) {
    size_t head = 0;
    for (;;) {
        struct device_msg msg;
@@ -63,7 +53,7 @@ process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
            return head;
        }
-        process_msg(receiver, &msg);
+        process_msg(&msg);
        device_msg_destroy(&msg);
        head += r;
@@ -91,7 +81,7 @@ run_receiver(void *data) {
        }
        head += r;
-        ssize_t consumed = process_msgs(receiver, buf, head);
+        ssize_t consumed = process_msgs(buf, head);
        if (consumed == -1) {
            // an error occurred
            break;
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@@ -5,23 +5,19 @@
 #include <stdbool.h>
 #include "util/acksync.h"
 #include "util/net.h"
 #include "util/thread.h"
 // receive events from the device
 // managed by the controller
 struct receiver {
-    sc_socket control_socket;
+    socket_t control_socket;
    sc_thread thread;
    sc_mutex mutex;
    struct sc_acksync *acksync;
 };
 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
+receiver_init(struct receiver *receiver, socket_t control_socket);
              struct sc_acksync *acksync);
 void
 receiver_destroy(struct receiver *receiver);
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@@ -1,12 +1,10 @@
 #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.h"
+#include "util/str_util.h"
 /** Downcast packet_sink to recorder */
 #define DOWNCAST(SINK) container_of(SINK, struct recorder, packet_sink)
@@ -26,7 +24,7 @@ find_muxer(const char *name) {
        oformat = av_oformat_next(oformat);
 #endif
        // until null or containing the requested name
-    } while (oformat && !sc_str_list_contains(oformat->name, ',', name));
+    } while (oformat && !strlist_contains(oformat->name, ',', name));
    return oformat;
 }
@@ -215,8 +213,7 @@ 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,
+        LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
                                                  recorder->filename);
    }
    LOGD("Recorder thread ended");
@@ -372,7 +369,7 @@ bool
 recorder_init(struct recorder *recorder,
              const char *filename,
              enum sc_record_format format,
-              struct sc_size declared_frame_size) {
+              struct size declared_frame_size) {
    recorder->filename = strdup(filename);
    if (!recorder->filename) {
        LOGE("Could not strdup filename");
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@@ -7,7 +7,7 @@
 #include <libavformat/avformat.h>
 #include "coords.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "trait/packet_sink.h"
 #include "util/queue.h"
 #include "util/thread.h"
@@ -25,7 +25,7 @@ struct recorder {
    char *filename;
    enum sc_record_format format;
    AVFormatContext *ctx;
-    struct sc_size declared_frame_size;
+    struct 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 sc_size declared_frame_size);
+              enum sc_record_format format, struct size declared_frame_size);
 void
 recorder_destroy(struct recorder *recorder);
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -18,16 +18,11 @@
 #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 "util/acksync.h"
+#include "tiny_xpm.h"
 #include "util/log.h"
 #include "util/net.h"
 #ifdef HAVE_V4L2
@@ -35,7 +30,7 @@
 #endif
 struct scrcpy {
-    struct sc_server server;
+    struct server server;
    struct screen screen;
    struct stream stream;
    struct decoder decoder;
@@ -45,45 +40,44 @@ struct scrcpy {
 #endif
    struct controller controller;
    struct file_handler file_handler;
 #ifdef HAVE_AOA_HID
    struct sc_aoa aoa;
    // sequence/ack helper to synchronize clipboard and Ctrl+v via HID
    struct sc_acksync acksync;
 #endif
    union {
        struct sc_keyboard_inject keyboard_inject;
 #ifdef HAVE_AOA_HID
        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) {
-        PUSH_EVENT(SDL_QUIT);
+        SDL_Event event;
        event.type = SDL_QUIT;
        SDL_PushEvent(&event);
        return TRUE;
    }
    return FALSE;
 }
 #endif // _WIN32
-static void
+// init SDL and set appropriate hints
-sdl_set_hints(const char *render_driver) {
+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;
    }
    if (render_driver && !SDL_SetHint(SDL_HINT_RENDER_DRIVER, render_driver)) {
        LOGW("Could not set render driver");
@@ -101,15 +95,6 @@ sdl_set_hints(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")) {
@@ -121,21 +106,6 @@ sdl_set_hints(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");
@@ -144,6 +114,8 @@ sdl_configure(bool display, bool disable_screensaver) {
        LOGD("Screensaver enabled");
        SDL_EnableScreenSaver();
    }
    return true;
 }
 static bool
@@ -220,29 +192,6 @@ 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) {
@@ -285,48 +234,20 @@ stream_on_eos(struct stream *stream, void *userdata) {
    (void) stream;
    (void) userdata;
-    PUSH_EVENT(EVENT_STREAM_STOPPED);
+    SDL_Event stop_event;
-}
+    stop_event.type = EVENT_STREAM_STOPPED;
-
+    SDL_PushEvent(&stop_event);
 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(struct scrcpy_options *options) {
+scrcpy(const struct scrcpy_options *options) {
    static struct scrcpy scrcpy;
    struct scrcpy *s = &scrcpy;
-    // Minimal SDL initialization
+    if (!server_init(&s->server)) {
    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;
@@ -336,22 +257,16 @@ scrcpy(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;
-    struct sc_acksync *acksync = NULL;
+    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,
        .port_range = options->port_range,
        .tunnel_host = options->tunnel_host,
        .tunnel_port = options->tunnel_port,
        .max_size = options->max_size,
        .bit_rate = options->bit_rate,
        .max_fps = options->max_fps,
@@ -365,47 +280,26 @@ scrcpy(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 (options->display) {
+    if (!sdl_init_and_configure(options->display, options->render_driver,
-        sdl_set_hints(options->render_driver);
+                                options->disable_screensaver)) {
    }
    // 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;
    }
-    sdl_configure(options->display, options->disable_screensaver);
+    char device_name[DEVICE_NAME_FIELD_LENGTH];
    struct size frame_size;
-    // Await for server without blocking Ctrl+C handling
+    if (!server_connect_to(&s->server, device_name, &frame_size)) {
    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, serial,
+        if (!file_handler_init(&s->file_handler, s->server.serial,
                               options->push_target)) {
            goto end;
        }
@@ -423,11 +317,11 @@ scrcpy(struct scrcpy_options *options) {
    }
    struct recorder *rec = NULL;
-    if (options->record_filename) {
+    if (record) {
        if (!recorder_init(&s->recorder,
                           options->record_filename,
                           options->record_format,
-                           info->frame_size)) {
+                           frame_size)) {
            goto end;
        }
        rec = &s->recorder;
@@ -436,7 +330,7 @@ scrcpy(struct scrcpy_options *options) {
    av_log_set_callback(av_log_callback);
-    static const struct stream_callbacks stream_cbs = {
+    const struct stream_callbacks stream_cbs = {
        .on_eos = stream_on_eos,
    };
    stream_init(&s->stream, s->server.video_socket, &stream_cbs, NULL);
@@ -450,18 +344,7 @@ scrcpy(struct scrcpy_options *options) {
    }
    if (options->control) {
-#ifdef HAVE_AOA_HID
+        if (!controller_init(&s->controller, s->server.control_socket)) {
        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID) {
            bool ok = sc_acksync_init(&s->acksync);
            if (!ok) {
                goto end;
            }
            acksync = &s->acksync;
        }
 #endif
        if (!controller_init(&s->controller, s->server.control_socket,
                             acksync)) {
            goto end;
        }
        controller_initialized = true;
@@ -484,11 +367,11 @@ scrcpy(struct scrcpy_options *options) {
    if (options->display) {
        const char *window_title =
-            options->window_title ? options->window_title : info->device_name;
+            options->window_title ? options->window_title : device_name;
        struct screen_params screen_params = {
            .window_title = window_title,
-            .frame_size = info->frame_size,
+            .frame_size = frame_size,
            .always_on_top = options->always_on_top,
            .window_x = options->window_x,
            .window_y = options->window_y,
@@ -498,7 +381,6 @@ scrcpy(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)) {
@@ -511,8 +393,7 @@ scrcpy(struct scrcpy_options *options) {
 #ifdef HAVE_V4L2
    if (options->v4l2_device) {
-        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device,
+        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device, frame_size)) {
                               info->frame_size, options->v4l2_buffer)) {
            goto end;
        }
@@ -529,63 +410,7 @@ scrcpy(struct scrcpy_options *options) {
    }
    stream_started = true;
-    struct sc_key_processor *kp = NULL;
+    input_manager_init(&s->input_manager, &s->controller, &s->screen, options);
    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, acksync);
            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...");
@@ -597,15 +422,6 @@ aoa_hid_end:
 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);
    }
    if (acksync) {
        sc_acksync_destroy(acksync);
    }
 #endif
    if (controller_started) {
        controller_stop(&s->controller);
    }
@@ -618,7 +434,7 @@ end:
    if (server_started) {
        // shutdown the sockets and kill the server
-        sc_server_stop(&s->server);
+        server_stop(&s->server);
    }
    // now that the sockets are shutdown, the stream and controller are
@@ -633,13 +449,6 @@ 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) {
@@ -663,7 +472,7 @@ end:
        file_handler_destroy(&s->file_handler);
    }
-    sc_server_destroy(&s->server);
+    server_destroy(&s->server);
    return ret;
 }
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@@ -4,9 +4,147 @@
 #include "common.h"
 #include <stdbool.h>
-#include "options.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, \
 }
 bool
-scrcpy(struct scrcpy_options *options);
+scrcpy(const struct scrcpy_options *options);
 #endif
--- a/app/src/screen.c
+++ b/app/src/screen.c
@@ -5,8 +5,9 @@
 #include <SDL2/SDL.h>
 #include "events.h"
-#include "icon.h"
+#include "icon.xpm"
-#include "options.h"
+#include "scrcpy.h"
 #include "tiny_xpm.h"
 #include "video_buffer.h"
 #include "util/log.h"
@@ -14,9 +15,9 @@
 #define DOWNCAST(SINK) container_of(SINK, struct screen, frame_sink)
-static inline struct sc_size
+static inline struct size
-get_rotated_size(struct sc_size size, int rotation) {
+get_rotated_size(struct size size, int rotation) {
-    struct sc_size rotated_size;
+    struct size rotated_size;
    if (rotation & 1) {
        rotated_size.width = size.height;
        rotated_size.height = size.width;
@@ -27,26 +28,26 @@ get_rotated_size(struct sc_size size, int rotation) {
    return rotated_size;
 }
-// get the window size in a struct sc_size
+// get the window size in a struct size
-static struct sc_size
+static struct size
 get_window_size(const struct screen *screen) {
    int width;
    int height;
    SDL_GetWindowSize(screen->window, &width, &height);
-    struct sc_size size;
+    struct size size;
    size.width = width;
    size.height = height;
    return size;
 }
-static struct sc_point
+static struct point
 get_window_position(const struct screen *screen) {
    int x;
    int y;
    SDL_GetWindowPosition(screen->window, &x, &y);
-    struct sc_point point;
+    struct point point;
    point.x = x;
    point.y = y;
    return point;
@@ -54,7 +55,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 sc_size new_size) {
+set_window_size(struct screen *screen, struct size new_size) {
    assert(!screen->fullscreen);
    assert(!screen->maximized);
    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
@@ -62,7 +63,7 @@ set_window_size(struct screen *screen, struct sc_size new_size) {
 // get the preferred display bounds (i.e. the screen bounds with some margins)
 static bool
-get_preferred_display_bounds(struct sc_size *bounds) {
+get_preferred_display_bounds(struct size *bounds) {
    SDL_Rect rect;
 #ifdef SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
 # define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayUsableBounds((i), (r))
@@ -80,7 +81,7 @@ get_preferred_display_bounds(struct sc_size *bounds) {
 }
 static bool
-is_optimal_size(struct sc_size current_size, struct sc_size content_size) {
+is_optimal_size(struct size current_size, struct 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
@@ -94,16 +95,16 @@ is_optimal_size(struct sc_size current_size, struct sc_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 sc_size
+static struct size
-get_optimal_size(struct sc_size current_size, struct sc_size content_size) {
+get_optimal_size(struct size current_size, struct size content_size) {
    if (content_size.width == 0 || content_size.height == 0) {
        // avoid division by 0
        return current_size;
    }
-    struct sc_size window_size;
+    struct size window_size;
-    struct sc_size display_size;
+    struct 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;
@@ -135,10 +136,10 @@ get_optimal_size(struct sc_size current_size, struct sc_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 sc_size
+static inline struct size
-get_initial_optimal_size(struct sc_size content_size, uint16_t req_width,
+get_initial_optimal_size(struct size content_size, uint16_t req_width,
                         uint16_t req_height) {
-    struct sc_size window_size;
+    struct size window_size;
    if (!req_width && !req_height) {
        window_size = get_optimal_size(content_size, content_size);
    } else {
@@ -166,9 +167,9 @@ screen_update_content_rect(struct screen *screen) {
    int dh;
    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
-    struct sc_size content_size = screen->content_size;
+    struct size content_size = screen->content_size;
    // The drawable size is the window size * the HiDPI scale
-    struct sc_size drawable_size = {dw, dh};
+    struct size drawable_size = {dw, dh};
    SDL_Rect *rect = &screen->rect;
@@ -200,7 +201,7 @@ screen_update_content_rect(struct screen *screen) {
 static inline SDL_Texture *
 create_texture(struct screen *screen) {
    SDL_Renderer *renderer = screen->renderer;
-    struct sc_size size = screen->frame_size;
+    struct size size = screen->frame_size;
    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
                                             SDL_TEXTUREACCESS_STREAMING,
                                             size.width, size.height);
@@ -224,45 +225,6 @@ 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
@@ -321,33 +283,17 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
    (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, unless the previous event failed
+        // this new frame instead
        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
-        int ret = SDL_PushEvent(&new_frame_event);
+        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;
        }
    }
 }
@@ -357,14 +303,12 @@ screen_init(struct screen *screen, const struct screen_params *params) {
    screen->has_frame = false;
    screen->fullscreen = false;
    screen->maximized = false;
    screen->event_failed = false;
    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,
+    bool ok = sc_video_buffer_init(&screen->vb, 2000, &cbs, screen);
                                   screen);
    if (!ok) {
        LOGE("Could not initialize video buffer");
        return false;
@@ -386,13 +330,13 @@ screen_init(struct screen *screen, const struct screen_params *params) {
    if (screen->rotation) {
        LOGI("Initial display rotation set to %u", screen->rotation);
    }
-    struct sc_size content_size =
+    struct size content_size =
        get_rotated_size(screen->frame_size, screen->rotation);
    screen->content_size = content_size;
-    struct sc_size window_size =
+    struct size window_size = get_initial_optimal_size(content_size,
-        get_initial_optimal_size(content_size,params->window_width,
+                                                       params->window_width,
-                                 params->window_height);
+                                                       params->window_height);
    uint32_t window_flags = SDL_WINDOW_HIDDEN
                          | SDL_WINDOW_RESIZABLE
                          | SDL_WINDOW_ALLOW_HIGHDPI;
@@ -460,10 +404,10 @@ screen_init(struct screen *screen, const struct screen_params *params) {
        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
    }
-    SDL_Surface *icon = scrcpy_icon_load();
+    SDL_Surface *icon = read_xpm(icon_xpm);
    if (icon) {
        SDL_SetWindowIcon(screen->window, icon);
-        scrcpy_icon_destroy(icon);
+        SDL_FreeSurface(icon);
    } else {
        LOGW("Could not load icon");
    }
@@ -564,10 +508,10 @@ screen_destroy(struct screen *screen) {
 }
 static void
-resize_for_content(struct screen *screen, struct sc_size old_content_size,
+resize_for_content(struct screen *screen, struct size old_content_size,
-                   struct sc_size new_content_size) {
+                                                 struct size new_content_size) {
-    struct sc_size window_size = get_window_size(screen);
+    struct size window_size = get_window_size(screen);
-    struct sc_size target_size = {
+    struct 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
@@ -578,7 +522,7 @@ resize_for_content(struct screen *screen, struct sc_size old_content_size,
 }
 static void
-set_content_size(struct screen *screen, struct sc_size new_content_size) {
+set_content_size(struct screen *screen, struct size new_content_size) {
    if (!screen->fullscreen && !screen->maximized) {
        resize_for_content(screen, screen->content_size, new_content_size);
    } else if (!screen->resize_pending) {
@@ -609,7 +553,7 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
        return;
    }
-    struct sc_size new_content_size =
+    struct size new_content_size =
        get_rotated_size(screen->frame_size, rotation);
    set_content_size(screen, new_content_size);
@@ -622,7 +566,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 sc_size new_frame_size) {
+prepare_for_frame(struct screen *screen, struct 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
@@ -630,7 +574,7 @@ prepare_for_frame(struct screen *screen, struct sc_size new_frame_size) {
        screen->frame_size = new_frame_size;
-        struct sc_size new_content_size =
+        struct size new_content_size =
            get_rotated_size(new_frame_size, screen->rotation);
        set_content_size(screen, new_content_size);
@@ -671,7 +615,7 @@ screen_update_frame(struct screen *screen) {
    fps_counter_add_rendered_frame(&screen->fps_counter);
-    struct sc_size new_frame_size = {frame->width, frame->height};
+    struct size new_frame_size = {frame->width, frame->height};
    if (!prepare_for_frame(screen, new_frame_size)) {
        return false;
    }
@@ -681,6 +625,40 @@ 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;
@@ -704,10 +682,10 @@ screen_resize_to_fit(struct screen *screen) {
        return;
    }
-    struct sc_point point = get_window_position(screen);
+    struct point point = get_window_position(screen);
-    struct sc_size window_size = get_window_size(screen);
+    struct size window_size = get_window_size(screen);
-    struct sc_size optimal_size =
+    struct size optimal_size =
        get_optimal_size(window_size, screen->content_size);
    // Center the window related to the device screen
@@ -733,7 +711,7 @@ screen_resize_to_pixel_perfect(struct screen *screen) {
        screen->maximized = false;
    }
-    struct sc_size content_size = screen->content_size;
+    struct 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);
@@ -788,7 +766,7 @@ screen_handle_event(struct screen *screen, SDL_Event *event) {
    return false;
 }
-struct sc_point
+struct point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                        int32_t x, int32_t y) {
    unsigned rotation = screen->rotation;
@@ -802,7 +780,7 @@ screen_convert_drawable_to_frame_coords(struct screen *screen,
    y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;
    // rotate
-    struct sc_point result;
+    struct point result;
    switch (rotation) {
        case 0:
            result.x = x;
@@ -825,7 +803,7 @@ screen_convert_drawable_to_frame_coords(struct screen *screen,
    return result;
 }
-struct sc_point
+struct point
 screen_convert_window_to_frame_coords(struct screen *screen,
                                      int32_t x, int32_t y) {
    screen_hidpi_scale_coords(screen, &x, &y);
--- a/app/src/screen.h
+++ b/app/src/screen.h
@@ -27,13 +27,13 @@ struct screen {
    SDL_Renderer *renderer;
    SDL_Texture *texture;
    struct sc_opengl gl;
-    struct sc_size frame_size;
+    struct size frame_size;
-    struct sc_size content_size; // rotated frame_size
+    struct 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 sc_size windowed_content_size;
+    struct size windowed_content_size;
    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
    unsigned rotation;
@@ -44,14 +44,12 @@ 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 sc_size frame_size;
+    struct size frame_size;
    bool always_on_top;
    int16_t window_x;
@@ -65,8 +63,6 @@ struct screen_params {
    bool mipmaps;
    bool fullscreen;
    sc_tick buffering_time;
 };
 // initialize screen, create window, renderer and texture (window is hidden)
@@ -93,6 +89,13 @@ 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);
@@ -115,13 +118,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 sc_point
+struct 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 sc_point
+struct point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                        int32_t x, int32_t y);
--- a/app/src/server.c
+++ b/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_intr.h"
+#include "util/net.h"
-#include "util/process_intr.h"
+#include "util/str_util.h"
 #include "util/str.h"
-#define SC_SERVER_FILENAME "scrcpy-server"
+#define SOCKET_NAME "scrcpy"
 #define SERVER_FILENAME "scrcpy-server"
-#define SC_SERVER_PATH_DEFAULT PREFIX "/share/scrcpy/" SC_SERVER_FILENAME
+#define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FILENAME
-#define SC_DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"
+#define 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 = sc_str_from_wchars(server_path_env);
+        char *server_path = utf8_from_wide_char(server_path_env);
 #else
        char *server_path = strdup(server_path_env);
 #endif
@@ -42,79 +42,194 @@ get_server_path(void) {
    }
 #ifndef PORTABLE
-    LOGD("Using server: " SC_SERVER_PATH_DEFAULT);
+    LOGD("Using server: " DEFAULT_SERVER_PATH);
-    char *server_path = strdup(SC_SERVER_PATH_DEFAULT);
+    char *server_path = strdup(DEFAULT_SERVER_PATH);
    if (!server_path) {
        LOGE("Could not allocate memory");
        return NULL;
    }
    // the absolute path is hardcoded
    return server_path;
 #else
-    char *server_path = sc_file_get_local_path(SC_SERVER_FILENAME);
+
-    if (!server_path) {
+    // use scrcpy-server in the same directory as the executable
-        LOGE("Could not get local file path, "
+    char *executable_path = get_executable_path();
-             "using " SC_SERVER_FILENAME " from current directory");
+    if (!executable_path) {
-        return strdup(SC_SERVER_FILENAME);
+        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);
    if (!server_path) {
        LOGE("Could not alloc server path string, "
             "using " SERVER_FILENAME " from current directory");
        free(executable_path);
        return strdup(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);
 #endif
    return server_path;
-}
+#endif
 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
-sc_server_params_copy(struct sc_server_params *dst,
+push_server(const char *serial) {
                      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 (!sc_file_is_regular(server_path)) {
+    if (!is_regular_file(server_path)) {
        LOGE("'%s' does not exist or is not a regular file\n", server_path);
        free(server_path);
        return false;
    }
-    bool ok = adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH);
+    process_t process = adb_push(serial, server_path, DEVICE_SERVER_PATH);
    free(server_path);
-    return ok;
+    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);
 }
 static const char *
@@ -136,11 +251,8 @@ log_level_to_server_string(enum sc_log_level level) {
    }
 }
-static sc_pid
+static process_t
-execute_server(struct sc_server *server,
+execute_server(struct server *server, const struct server_params *params) {
               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];
@@ -149,19 +261,17 @@ execute_server(struct sc_server *server,
    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,
+    sprintf(lock_video_orientation_string, "%"PRIi8, params->lock_video_orientation);
            params->lock_video_orientation);
    sprintf(display_id_string, "%"PRIu32, params->display_id);
    const char *const cmd[] = {
        "shell",
-        "CLASSPATH=" SC_DEVICE_SERVER_PATH,
+        "CLASSPATH=" 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,"
+        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,server=y,address="
        "server=y,address="
 # else
        /* Android 8 and below */
        "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
@@ -176,7 +286,7 @@ execute_server(struct sc_server *server,
        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",
@@ -198,376 +308,276 @@ execute_server(struct sc_server *server,
    //     Port: 5005
    // Then click on "Debug"
 #endif
-    return adb_execute(serial, cmd, ARRAY_LEN(cmd));
+    return adb_execute(server->serial, cmd, ARRAY_LEN(cmd));
 }
-static bool
+static socket_t
-connect_and_read_byte(struct sc_intr *intr, sc_socket socket,
+connect_and_read_byte(uint16_t port) {
-                      uint32_t tunnel_host, uint16_t tunnel_port) {
+    socket_t socket = net_connect(IPV4_LOCALHOST, port);
-    bool ok = net_connect_intr(intr, socket, tunnel_host, tunnel_port);
+    if (socket == INVALID_SOCKET) {
-    if (!ok) {
+        return INVALID_SOCKET;
        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_intr(intr, socket, &byte, 1) != 1) {
+    if (net_recv(socket, &byte, 1) != 1) {
        // the server is not listening yet behind the adb tunnel
-        return false;
+        net_close(socket);
        return INVALID_SOCKET;
    }
-
+    return socket;
    return true;
 }
-static sc_socket
+static socket_t
-connect_to_server(struct sc_server *server, uint32_t attempts, sc_tick delay,
+connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
                  uint32_t host, uint16_t port) {
    do {
        LOGD("Remaining connection attempts: %d", (int) attempts);
-        sc_socket socket = net_socket();
+        socket_t socket = connect_and_read_byte(port);
-        if (socket != SC_SOCKET_NONE) {
+        if (socket != INVALID_SOCKET) {
-            bool ok = connect_and_read_byte(&server->intr, socket, host, port);
+            // it worked!
-            if (ok) {
+            return socket;
                // it worked!
                return socket;
            }
            net_close(socket);
        }
        if (sc_intr_is_interrupted(&server->intr)) {
            // Stop immediately
            break;
        }
        if (attempts) {
-            sc_mutex_lock(&server->mutex);
+            SDL_Delay(delay);
            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;
+    return INVALID_SOCKET;
 }
 bool
 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_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;
    }
    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->stopped = false;
    server->video_socket = SC_SOCKET_NONE;
    server->control_socket = SC_SOCKET_NONE;
    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 tunnel_host = server->params.tunnel_host;
        if (!tunnel_host) {
            tunnel_host = IPV4_LOCALHOST;
        }
        uint16_t tunnel_port = server->params.tunnel_port;
        if (!tunnel_port) {
            tunnel_port = tunnel->local_port;
        }
        uint32_t attempts = 100;
        sc_tick delay = SC_TICK_FROM_MS(100);
        video_socket = connect_to_server(server, attempts, delay, tunnel_host,
                                         tunnel_port);
        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, tunnel_host,
                                   tunnel_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) {
+close_socket(socket_t socket) {
-    struct sc_server *server = userdata;
+    assert(socket != INVALID_SOCKET);
-
+    net_shutdown(socket, SHUT_RDWR);
-    // If the server process dies before connecting to the server socket,
+    if (!net_close(socket)) {
-    // then the client will be stuck forever on accept(). To avoid the problem,
+        LOGW("Could not close socket");
-    // 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
+bool
-sc_server_fill_serial(struct sc_server *server) {
+server_init(struct server *server) {
-    // Retrieve the actual device immediately if not provided, so that all
+    server->serial = NULL;
-    // future adb commands are executed for this specific device, even if other
+    server->process = PROCESS_NONE;
-    // devices are connected afterwards (without "more than one
+    atomic_flag_clear_explicit(&server->server_socket_closed,
-    // device/emulator" error)
+                               memory_order_relaxed);
-    if (!server->params.serial) {
+
-        // The serial is owned by sc_server_params, and will be freed on destroy
+    bool ok = sc_mutex_init(&server->mutex);
-        server->params.serial = adb_get_serialno(&server->intr);
+    if (!ok) {
-        if (!server->params.serial) {
+        return false;
            LOGE("Could not get device serial");
            return false;
        }
    }
    ok = sc_cond_init(&server->process_terminated_cond);
    if (!ok) {
        sc_mutex_destroy(&server->mutex);
        return false;
    }
    server->process_terminated = false;
    server->server_socket = INVALID_SOCKET;
    server->video_socket = INVALID_SOCKET;
    server->control_socket = INVALID_SOCKET;
    server->local_port = 0;
    server->tunnel_enabled = false;
    server->tunnel_forward = false;
    return true;
 }
 static int
-run_server(void *data) {
+run_wait_server(void *data) {
-    struct sc_server *server = data;
+    struct server *server = data;
    process_wait(server->process, false); // ignore exit code
-    if (!sc_server_fill_serial(server)) {
+    sc_mutex_lock(&server->mutex);
-        goto error_connection_failed;
+    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;
 }
 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;
+    if (!push_server(params->serial)) {
-
+        /* server->serial will be freed on server_destroy() */
-    LOGD("Device serial: %s", params->serial);
+        return false;
    bool ok = push_server(&server->intr, params->serial);
    if (!ok) {
        goto error_connection_failed;
    }
-    ok = sc_adb_tunnel_open(&server->tunnel, &server->intr, params->serial,
+    if (!enable_tunnel_any_port(server, params->port_range,
-                            params->port_range, params->force_adb_forward);
+                                params->force_adb_forward)) {
-    if (!ok) {
+        return false;
        goto error_connection_failed;
    }
    // server will connect to our server socket
-    sc_pid pid = execute_server(server, params);
+    server->process = execute_server(server, params);
-    if (pid == SC_PROCESS_NONE) {
+    if (server->process == PROCESS_NONE) {
-        sc_adb_tunnel_close(&server->tunnel, &server->intr, params->serial);
+        goto error;
        goto error_connection_failed;
    }
-    static const struct sc_process_listener listener = {
+    // If the server process dies before connecting to the server socket, then
-        .on_terminated = sc_server_on_terminated,
+    // 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
-    struct sc_process_observer observer;
+    // things simple and multiplatform, just spawn a new thread waiting for the
-    ok = sc_process_observer_init(&observer, pid, &listener, server);
+    // 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);
    if (!ok) {
-        sc_process_terminate(pid);
+        process_terminate(server->process);
-        sc_process_wait(pid, true); // ignore exit code
+        process_wait(server->process, true); // ignore exit code
-        sc_adb_tunnel_close(&server->tunnel, &server->intr, params->serial);
+        goto error;
        goto error_connection_failed;
    }
-    ok = sc_server_connect_to(server, &server->info);
+    server->tunnel_enabled = true;
-    // The tunnel is always closed by server_connect_to()
+
-    if (!ok) {
+    return true;
-        sc_process_terminate(pid);
+
-        sc_process_wait(pid, true); // ignore exit code
+error:
-        sc_process_observer_join(&observer);
+    if (!server->tunnel_forward) {
-        sc_process_observer_destroy(&observer);
+        bool was_closed =
-        goto error_connection_failed;
+            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;
 }
 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;
 }
 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;
        }
    }
-    // Now connected
+    // we don't need the adb tunnel anymore
-    server->cbs->on_connected(server, server->cbs_userdata);
+    disable_tunnel(server); // ignore failure
    server->tunnel_enabled = false;
-    // Wait for server_stop()
+    // The sockets will be closed on stop if device_read_info() fails
-    sc_mutex_lock(&server->mutex);
+    return device_read_info(server->video_socket, device_name, size);
-    while (!server->stopped) {
+}
-        sc_cond_wait(&server->cond_stopped, &server->mutex);
+
 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);
    }
    sc_mutex_unlock(&server->mutex);
    // Give some delay for the server to terminate properly
-#define WATCHDOG_DELAY SC_TICK_FROM_SEC(1)
+    sc_mutex_lock(&server->mutex);
-    sc_tick deadline = sc_tick_now() + WATCHDOG_DELAY;
+    bool signaled = false;
-    bool terminated = sc_process_observer_timedwait(&observer, deadline);
+    if (!server->process_terminated) {
 #define WATCHDOG_DELAY_MS 1000
        signaled = sc_cond_timedwait(&server->process_terminated_cond,
                                     &server->mutex,
                                     sc_tick_now() + WATCHDOG_DELAY_MS);
    }
    sc_mutex_unlock(&server->mutex);
    // After this delay, kill the server if it's not dead already.
    // On some devices, closing the sockets is not sufficient to wake up the
    // blocking calls while the device is asleep.
-    if (!terminated) {
+    if (!signaled) {
-        // The process may have terminated since the check, but it is not
+        // The process is terminated, but not reaped (closed) yet, so its PID
-        // reaped (closed) yet, so its PID is still valid, and it is ok to call
+        // is still valid.
        // sc_process_terminate() even in that case.
        LOGW("Killing the server...");
-        sc_process_terminate(pid);
+        process_terminate(server->process);
    }
-    sc_process_observer_join(&observer);
+    sc_thread_join(&server->wait_server_thread, NULL);
-    sc_process_observer_destroy(&observer);
+    process_close(server->process);
    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
-sc_server_stop(struct sc_server *server) {
+server_destroy(struct server *server) {
-    sc_mutex_lock(&server->mutex);
+    free(server->serial);
-    server->stopped = true;
+    sc_cond_destroy(&server->process_terminated_cond);
    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);
 }
--- a/app/src/server.h
+++ b/app/src/server.h
@@ -8,29 +8,37 @@
 #include <stdint.h>
 #include "adb.h"
 #include "adb_tunnel.h"
 #include "coords.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "util/intr.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/thread.h"
-#define SC_DEVICE_NAME_FIELD_LENGTH 64
+struct server {
-struct sc_server_info {
+    char *serial;
-    char device_name[SC_DEVICE_NAME_FIELD_LENGTH];
+    process_t process;
-    struct sc_size frame_size;
+    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"
 };
-struct sc_server_params {
+struct server_params {
    const char *serial;
    enum sc_log_level log_level;
    const char *crop;
    const char *codec_options;
    const char *encoder_name;
    struct sc_port_range port_range;
    uint32_t tunnel_host;
    uint16_t tunnel_port;
    uint16_t max_size;
    uint32_t bit_rate;
    uint16_t max_fps;
@@ -43,62 +51,26 @@ struct sc_server_params {
    bool power_off_on_close;
 };
-struct sc_server {
+// init default values
    // The internal allocated strings are copies owned by the server
    struct sc_server_params params;
    sc_thread thread;
    struct sc_server_info info; // initialized once connected
    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
-sc_server_init(struct sc_server *server, const struct sc_server_params *params,
+server_init(struct server *server);
               const struct sc_server_callbacks *cbs, void *cbs_userdata);
-// start the server asynchronously
+// push, enable tunnel et start the server
 bool
-sc_server_start(struct sc_server *server);
+server_start(struct server *server, const struct server_params *params);
 #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
 bool
 server_connect_to(struct server *server, char *device_name, struct size *size);
 // disconnect and kill the server process
 void
-sc_server_stop(struct sc_server *server);
+server_stop(struct server *server);
 // close and release sockets
 void
-sc_server_destroy(struct sc_server *server);
+server_destroy(struct server *server);
 #endif
--- a/app/src/stream.c
+++ b/app/src/stream.c
@@ -260,7 +260,7 @@ end:
 }
 void
-stream_init(struct stream *stream, sc_socket socket,
+stream_init(struct stream *stream, socket_t socket,
            const struct stream_callbacks *cbs, void *cbs_userdata) {
    stream->socket = socket;
    stream->pending = NULL;
--- a/app/src/stream.h
+++ b/app/src/stream.h
@@ -14,7 +14,7 @@
 #define STREAM_MAX_SINKS 2
 struct stream {
-    sc_socket socket;
+    socket_t 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, sc_socket socket,
+stream_init(struct stream *stream, socket_t socket,
            const struct stream_callbacks *cbs, void *cbs_userdata);
 void
--- a/app/src/sys/unix/file.c
+++ b/app/src/sys/unix/file.c
@@ -1,75 +0,0 @@
 #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);
 }
--- a/app/src/sys/unix/process.c
+++ b/app/src/sys/unix/process.c
@@ -1,160 +1,118 @@
 #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"
-enum sc_process_result
+bool
-sc_process_execute_p(const char *const argv[], sc_pid *pid,
+search_executable(const char *file) {
-                     int *pin, int *pout, int *perr) {
+    char *path = getenv("PATH");
-    int in[2];
+    if (!path)
-    int out[2];
+        return false;
-    int err[2];
+    path = strdup(path);
-    int internal[2]; // communication between parent and children
+    if (!path)
        return false;
-    if (pipe(internal) == -1) {
+    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;
 }
 enum process_result
 process_execute(const char *const argv[], pid_t *pid) {
    int fd[2];
    if (pipe(fd) == -1) {
        perror("pipe");
-        return SC_PROCESS_ERROR_GENERIC;
+        return 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");
-        // clean up
+        ret = PROCESS_ERROR_GENERIC;
-        if (perr) {
+        goto end;
            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) {
+    if (*pid > 0) {
-        if (pin) {
+        // parent close write side
-            if (in[0] != STDIN_FILENO) {
+        close(fd[1]);
-                dup2(in[0], STDIN_FILENO);
+        fd[1] = -1;
-                close(in[0]);
+        // wait for EOF or receive errno from child
-            }
+        if (read(fd[0], &ret, sizeof(ret)) == -1) {
-            close(in[1]);
+            perror("read");
            ret = PROCESS_ERROR_GENERIC;
            goto end;
        }
-        if (pout) {
+    } else if (*pid == 0) {
-            if (out[1] != STDOUT_FILENO) {
+        // child close read side
-                dup2(out[1], STDOUT_FILENO);
+        close(fd[0]);
-                close(out[1]);
+        if (fcntl(fd[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;
            }
            close(out[0]);
        }
        if (perr) {
            if (err[1] != STDERR_FILENO) {
                dup2(err[1], STDERR_FILENO);
                close(err[1]);
            }
            close(err[0]);
        }
        close(internal[0]);
        enum sc_process_result err;
        if (fcntl(internal[1], F_SETFD, FD_CLOEXEC) == 0) {
            execvp(argv[0], (char *const *) argv);
            perror("exec");
            err = errno == ENOENT ? SC_PROCESS_ERROR_MISSING_BINARY
                                  : SC_PROCESS_ERROR_GENERIC;
        } else {
            perror("fcntl");
-            err = SC_PROCESS_ERROR_GENERIC;
+            ret = PROCESS_ERROR_GENERIC;
        }
-        // send err to the parent
+        // send ret to the parent
-        if (write(internal[1], &err, sizeof(err)) == -1) {
+        if (write(fd[1], &ret, sizeof(ret)) == -1) {
            perror("write");
        }
-        close(internal[1]);
+        // close write side before exiting
        close(fd[1]);
        _exit(1);
    }
-    // parent
+end:
-    assert(*pid > 0);
+    if (fd[0] != -1) {
-
+        close(fd[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(internal[0]);
+        close(fd[1]);
    if (pin) {
        close(in[0]);
        *pin = in[1];
    }
-    if (pout) {
+    return ret;
        *pout = out[0];
        close(out[1]);
    }
    if (perr) {
        *perr = err[0];
        close(err[1]);
    }
    return res;
 }
 bool
-sc_process_terminate(pid_t pid) {
+process_terminate(pid_t pid) {
    if (pid <= 0) {
        LOGC("Requested to kill %d, this is an error. Please report the bug.\n",
             (int) pid);
@@ -163,8 +121,8 @@ sc_process_terminate(pid_t pid) {
    return kill(pid, SIGKILL) != -1;
 }
-sc_exit_code
+exit_code_t
-sc_process_wait(pid_t pid, bool close) {
+process_wait(pid_t pid, bool close) {
    int code;
    int options = WEXITED;
    if (!close) {
@@ -175,7 +133,7 @@ sc_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 = SC_EXIT_CODE_NONE;
+        code = NO_EXIT_CODE;
    } else {
        code = info.si_status;
    }
@@ -183,18 +141,37 @@ sc_process_wait(pid_t pid, bool close) {
 }
 void
-sc_process_close(pid_t pid) {
+process_close(pid_t pid) {
-    sc_process_wait(pid, true); // ignore exit code
+    process_wait(pid, true); // ignore exit code
 }
-ssize_t
+char *
-sc_pipe_read(int pipe, char *data, size_t len) {
+get_executable_path(void) {
-    return read(pipe, data, len);
+// <https://stackoverflow.com/a/1024937/1987178>
-}
+#ifdef __linux__
-
+    char buf[PATH_MAX + 1]; // +1 for the null byte
-void
+    ssize_t len = readlink("/proc/self/exe", buf, PATH_MAX);
-sc_pipe_close(int pipe) {
+    if (len == -1) {
-    if (close(pipe)) {
+        perror("readlink");
-        perror("close pipe");
+        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
 is_regular_file(const char *path) {
    struct stat path_stat;
    if (stat(path, &path_stat)) {
        perror("stat");
        return false;
    }
    return S_ISREG(path_stat.st_mode);
 }
--- a/app/src/sys/win/file.c
+++ b/app/src/sys/win/file.c
@@ -1,43 +0,0 @@
 #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);
 }
--- a/app/src/sys/win/process.c
+++ b/app/src/sys/win/process.c
@@ -1,11 +1,10 @@
 #include "util/process.h"
 #include <processthreadsapi.h>
 #include <assert.h>
 #include <sys/stat.h>
 #include "util/log.h"
-#include "util/str.h"
+#include "util/str_util.h"
 #define CMD_MAX_LEN 8192
@@ -15,202 +14,61 @@ 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 = sc_str_join(cmd, argv, ' ', len);
+    size_t ret = xstrjoin(cmd, argv, ' ', len);
    if (ret >= len) {
-        LOGE("Command too long (%" SC_PRIsizet " chars)", len - 1);
+        LOGE("Command too long (%" PRIsizet " chars)", len - 1);
        return false;
    }
    return true;
 }
-enum sc_process_result
+enum process_result
-sc_process_execute_p(const char *const argv[], HANDLE *handle,
+process_execute(const char *const argv[], HANDLE *handle) {
-                     HANDLE *pin, HANDLE *pout, HANDLE *perr) {
+    STARTUPINFOW si;
    enum sc_process_result ret = SC_PROCESS_ERROR_GENERIC;
    // Add 1 per non-NULL pointer
    unsigned handle_count = !!pin + !!pout + !!perr;
    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.StartupInfo.cb = sizeof(si);
+    si.cb = sizeof(si);
    HANDLE handles[3];
    LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList = NULL;
    if (handle_count) {
        si.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
        if (pin) {
            si.StartupInfo.hStdInput = stdin_read_handle;
        }
        if (pout) {
            si.StartupInfo.hStdOutput = stdout_write_handle;
        }
        if (perr) {
            si.StartupInfo.hStdError = stderr_write_handle;
        }
        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;
        }
        // Explicitly pass the HANDLEs that must be inherited
        unsigned i = 0;
        if (pin) {
            handles[i++] = stdin_read_handle;
        }
        if (pout) {
            handles[i++] = stdout_write_handle;
        }
        if (perr) {
            handles[i++] = stderr_write_handle;
        }
        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)) {
-        goto error_free_attribute_list;
+        *handle = NULL;
        return PROCESS_ERROR_GENERIC;
    }
-    wchar_t *wide = sc_str_to_wchars(cmd);
+    wchar_t *wide = utf8_to_wide_char(cmd);
    free(cmd);
    if (!wide) {
        LOGC("Could not allocate wide char string");
-        goto error_free_attribute_list;
+        return PROCESS_ERROR_GENERIC;
    }
-    BOOL bInheritHandles = handle_count > 0;
+    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, 0, NULL, NULL, &si,
-    DWORD dwCreationFlags = handle_count > 0 ? EXTENDED_STARTUPINFO_PRESENT : 0;
+                        &pi)) {
-    BOOL ok = CreateProcessW(NULL, wide, NULL, NULL, bInheritHandles,
+        free(wide);
-                             dwCreationFlags, NULL, NULL, &si.StartupInfo, &pi);
+        *handle = NULL;
    free(wide);
    if (!ok) {
        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
-            ret = SC_PROCESS_ERROR_MISSING_BINARY;
+            return PROCESS_ERROR_MISSING_BINARY;
        }
-        goto error_free_attribute_list;
+        return PROCESS_ERROR_GENERIC;
    }
    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
-sc_process_terminate(HANDLE handle) {
+process_terminate(HANDLE handle) {
    return TerminateProcess(handle, 1);
 }
-sc_exit_code
+exit_code_t
-sc_process_wait(HANDLE handle, bool close) {
+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 = SC_EXIT_CODE_NONE;
+        code = NO_EXIT_CODE; // max value, it's unsigned
    }
    if (close) {
        CloseHandle(handle);
@@ -219,24 +77,42 @@ sc_process_wait(HANDLE handle, bool close) {
 }
 void
-sc_process_close(HANDLE handle) {
+process_close(HANDLE handle) {
    bool closed = CloseHandle(handle);
    assert(closed);
    (void) closed;
 }
-ssize_t
+char *
-sc_pipe_read(HANDLE pipe, char *data, size_t len) {
+get_executable_path(void) {
-    DWORD r;
+    HMODULE hModule = GetModuleHandleW(NULL);
-    if (!ReadFile(pipe, data, len, &r, NULL)) {
+    if (!hModule) {
-        return -1;
+        return NULL;
    }
-    return r;
+    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);
 }
-void
+bool
-sc_pipe_close(HANDLE pipe) {
+is_regular_file(const char *path) {
-    if (!CloseHandle(pipe)) {
+    wchar_t *wide_path = utf8_to_wide_char(path);
-        LOGW("Cannot close pipe");
+    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);
 }
--- a/app/src/tiny_xpm.c
+++ b/app/src/tiny_xpm.c
@@ -0,0 +1,119 @@
 #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;
 }
--- a/app/src/tiny_xpm.h
+++ b/app/src/tiny_xpm.h
@@ -0,0 +1,11 @@
 #ifndef TINYXPM_H
 #define TINYXPM_H
 #include "common.h"
 #include <SDL2/SDL.h>
 SDL_Surface *
 read_xpm(char *xpm[]);
 #endif
--- a/app/src/trait/frame_sink.h
+++ b/app/src/trait/frame_sink.h
@@ -1,5 +1,5 @@
-#ifndef SC_FRAME_SINK_H
+#ifndef SC_FRAME_SINK
-#define SC_FRAME_SINK_H
+#define SC_FRAME_SINK
 #include "common.h"
--- a/app/src/trait/key_processor.h
+++ b/app/src/trait/key_processor.h
@@ -1,48 +0,0 @@
 #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 {
    /**
     * Set by the implementation to indicate that it must explicitly wait for
     * the clipboard to be set on the device before injecting Ctrl+v to avoid
     * race conditions. If it is set, the input_manager will pass a valid
     * ack_to_wait to process_key() in case of clipboard synchronization
     * resulting of the key event.
     */
    bool async_paste;
    const struct sc_key_processor_ops *ops;
 };
 struct sc_key_processor_ops {
    /**
     * Process the keyboard event
     *
     * The `sequence` number (if different from `SC_SEQUENCE_INVALID`) indicates
     * the acknowledgement number to wait for before injecting this event.
     * This allows to ensure that the device clipboard is set before injecting
     * Ctrl+v on the device.
     */
    void
    (*process_key)(struct sc_key_processor *kp, const SDL_KeyboardEvent *event,
                   uint64_t ack_to_wait);
    void
    (*process_text)(struct sc_key_processor *kp,
                    const SDL_TextInputEvent *event);
 };
 #endif
--- a/app/src/trait/mouse_processor.h
+++ b/app/src/trait/mouse_processor.h
@@ -1,39 +0,0 @@
 #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
--- a/app/src/trait/packet_sink.h
+++ b/app/src/trait/packet_sink.h
@@ -1,5 +1,5 @@
-#ifndef SC_PACKET_SINK_H
+#ifndef SC_PACKET_SINK
-#define SC_PACKET_SINK_H
+#define SC_PACKET_SINK
 #include "common.h"
--- a/app/src/util/acksync.c
+++ b/app/src/util/acksync.c
@@ -1,76 +0,0 @@
 #include "acksync.h"
 #include <assert.h>
 #include "util/log.h"
 bool
 sc_acksync_init(struct sc_acksync *as) {
    bool ok = sc_mutex_init(&as->mutex);
    if (!ok) {
        return false;
    }
    ok = sc_cond_init(&as->cond);
    if (!ok) {
        sc_mutex_destroy(&as->mutex);
        return false;
    }
    as->stopped = false;
    as->ack = SC_SEQUENCE_INVALID;
    return true;
 }
 void
 sc_acksync_destroy(struct sc_acksync *as) {
    sc_cond_destroy(&as->cond);
    sc_mutex_destroy(&as->mutex);
 }
 void
 sc_acksync_ack(struct sc_acksync *as, uint64_t sequence) {
    sc_mutex_lock(&as->mutex);
    // Acknowledgements must be monotonic
    assert(sequence >= as->ack);
    as->ack = sequence;
    sc_cond_signal(&as->cond);
    sc_mutex_unlock(&as->mutex);
 }
 enum sc_acksync_wait_result
 sc_acksync_wait(struct sc_acksync *as, uint64_t ack, sc_tick deadline) {
    sc_mutex_lock(&as->mutex);
    bool timed_out = false;
    while (!as->stopped && as->ack < ack && !timed_out) {
        timed_out = !sc_cond_timedwait(&as->cond, &as->mutex, deadline);
    }
    enum sc_acksync_wait_result ret;
    if (as->stopped) {
        ret = SC_ACKSYNC_WAIT_INTR;
    } else if (as->ack >= ack) {
        ret = SC_ACKSYNC_WAIT_OK;
    } else {
        assert(timed_out);
        ret = SC_ACKSYNC_WAIT_TIMEOUT;
    }
    sc_mutex_unlock(&as->mutex);
    return ret;
 }
 /**
 * Interrupt any `sc_acksync_wait()`
 */
 void
 sc_acksync_interrupt(struct sc_acksync *as) {
    sc_mutex_lock(&as->mutex);
    as->stopped = true;
    sc_cond_signal(&as->cond);
    sc_mutex_unlock(&as->mutex);
 }
--- a/app/src/util/acksync.h
+++ b/app/src/util/acksync.h
@@ -1,66 +0,0 @@
 #ifndef SC_ACK_SYNC_H
 #define SC_ACK_SYNC_H
 #include "common.h"
 #include "thread.h"
 #define SC_SEQUENCE_INVALID 0
 /**
 * Helper to wait for acknowledgments
 *
 * In practice, it is used to wait for device clipboard acknowledgement from the
 * server before injecting Ctrl+v via AOA HID, in order to avoid pasting the
 * content of the old device clipboard (if Ctrl+v was injected before the
 * clipboard content was actually set).
 */
 struct sc_acksync {
    sc_mutex mutex;
    sc_cond cond;
    bool stopped;
    // Last acked value, initially SC_SEQUENCE_INVALID
    uint64_t ack;
 };
 enum sc_acksync_wait_result {
    // Acknowledgment received
    SC_ACKSYNC_WAIT_OK,
    // Timeout expired
    SC_ACKSYNC_WAIT_TIMEOUT,
    // Interrupted from another thread by sc_acksync_interrupt()
    SC_ACKSYNC_WAIT_INTR,
 };
 bool
 sc_acksync_init(struct sc_acksync *as);
 void
 sc_acksync_destroy(struct sc_acksync *as);
 /**
 * Acknowledge `sequence`
 *
 * The `sequence` must be greater than (or equal to) any previous acknowledged
 * sequence.
 */
 void
 sc_acksync_ack(struct sc_acksync *as, uint64_t sequence);
 /**
 * Wait for acknowledgment of sequence `ack` (or higher)
 */
 enum sc_acksync_wait_result
 sc_acksync_wait(struct sc_acksync *as, uint64_t ack, sc_tick deadline);
 /**
 * Interrupt any `sc_acksync_wait()`
 */
 void
 sc_acksync_interrupt(struct sc_acksync *as);
 #endif
--- a/app/src/util/file.c
+++ b/app/src/util/file.c
@@ -1,48 +0,0 @@
 #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;
 }
--- a/app/src/util/file.h
+++ b/app/src/util/file.h
@@ -1,49 +0,0 @@
 #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
--- a/app/src/util/intr.c
+++ b/app/src/util/intr.c
@@ -1,83 +0,0 @@
 #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);
 }
--- a/app/src/util/intr.h
+++ b/app/src/util/intr.h
@@ -1,78 +0,0 @@
 #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
--- a/app/src/util/log.h
+++ b/app/src/util/log.h
@@ -5,7 +5,7 @@
 #include <SDL2/SDL_log.h>
-#include "options.h"
+#include "scrcpy.h"
 #define LOGV(...) SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
--- a/app/src/util/net.c
+++ b/app/src/util/net.c
@@ -1,15 +1,12 @@
 #include "net.h"
 #include <assert.h>
 #include <stdio.h>
 #include <SDL2/SDL_platform.h>
 #include "log.h"
 #ifdef __WINDOWS__
 # include <ws2tcpip.h>
  typedef int socklen_t;
  typedef SOCKET sc_raw_socket;
 #else
 # include <sys/types.h>
 # include <sys/socket.h>
@@ -20,9 +17,105 @@
  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__
@@ -43,198 +136,11 @@ net_cleanup(void) {
 #endif
 }
-static inline sc_socket
+bool
-wrap(sc_raw_socket sock) {
+net_close(socket_t socket) {
 #ifdef __WINDOWS__
-    if (sock == INVALID_SOCKET) {
+    return !closesocket(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 sock;
+    return !close(socket);
 #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
 }
 bool
 net_parse_ipv4(const char *s, uint32_t *ipv4) {
    struct in_addr addr;
    if (!inet_pton(AF_INET, s, &addr)) {
        LOGE("Invalid IPv4 address: %s", s);
        return false;
    }
    *ipv4 = ntohl(addr.s_addr);
    return true;
 }
--- a/app/src/util/net.h
+++ b/app/src/util/net.h
@@ -8,70 +8,50 @@
 #include <SDL2/SDL_platform.h>
 #ifdef __WINDOWS__
 # include <winsock2.h>
-# include <stdatomic.h>
+  #define SHUT_RD SD_RECEIVE
-# define SC_SOCKET_NONE NULL
+  #define SHUT_WR SD_SEND
-  typedef struct sc_socket_windows {
+  #define SHUT_RDWR SD_BOTH
-      SOCKET socket;
+  typedef SOCKET socket_t;
-      atomic_flag closed;
+#else
  } *sc_socket;
 #else // not __WINDOWS__
 # include <sys/socket.h>
-# define SC_SOCKET_NONE -1
+# define INVALID_SOCKET -1
-  typedef int sc_socket;
+  typedef int socket_t;
 #endif
 #define IPV4_LOCALHOST 0x7F000001
 bool
 net_init(void);
 void
 net_cleanup(void);
-sc_socket
+socket_t
-net_socket(void);
+net_connect(uint32_t addr, uint16_t port);
-bool
+socket_t
-net_connect(sc_socket socket, uint32_t addr, uint16_t port);
+net_listen(uint32_t addr, uint16_t port, int backlog);
-bool
+socket_t
-net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog);
+net_accept(socket_t server_socket);
 sc_socket
 net_accept(sc_socket server_socket);
 // the _all versions wait/retry until len bytes have been written/read
 ssize_t
-net_recv(sc_socket socket, void *buf, size_t len);
+net_recv(socket_t socket, void *buf, size_t len);
 ssize_t
-net_recv_all(sc_socket socket, void *buf, size_t len);
+net_recv_all(socket_t socket, void *buf, size_t len);
 ssize_t
-net_send(sc_socket socket, const void *buf, size_t len);
+net_send(socket_t socket, const void *buf, size_t len);
 ssize_t
-net_send_all(sc_socket socket, const void *buf, size_t len);
+net_send_all(socket_t socket, const void *buf, size_t len);
-// Shutdown the socket (or close on Windows) so that any blocking send() or
+// how is SHUT_RD (read), SHUT_WR (write) or SHUT_RDWR (both)
 // recv() are interrupted.
 bool
-net_interrupt(sc_socket socket);
+net_shutdown(socket_t socket, int how);
 // Close the socket.
 // A socket must always be closed, even if net_interrupt() has been called.
 bool
-net_close(sc_socket socket);
+net_close(socket_t socket);
 /**
 * Parse `ip` "xxx.xxx.xxx.xxx" to an IPv4 host representation
 */
 bool
 net_parse_ipv4(const char *ip, uint32_t *ipv4);
 #endif
--- a/app/src/util/net_intr.c
+++ b/app/src/util/net_intr.c
@@ -1,97 +0,0 @@
 #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;
 }
--- a/app/src/util/net_intr.h
+++ b/app/src/util/net_intr.h
@@ -1,35 +0,0 @@
 #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
--- a/app/src/util/process.c
+++ b/app/src/util/process.c
@@ -1,25 +1,17 @@
 #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) {
    return sc_process_execute_p(argv, pid, NULL, NULL, NULL);
 }
 bool
-sc_process_check_success(sc_pid pid, const char *name, bool close) {
+process_check_success(process_t proc, const char *name, bool close) {
-    if (pid == SC_PROCESS_NONE) {
+    if (proc == PROCESS_NONE) {
        LOGE("Could not execute \"%s\"", name);
        return false;
    }
-    sc_exit_code exit_code = sc_process_wait(pid, close);
+    exit_code_t exit_code = process_wait(proc, close);
    if (exit_code) {
-        if (exit_code != SC_EXIT_CODE_NONE) {
+        if (exit_code != NO_EXIT_CODE) {
-            LOGE("\"%s\" returned with value %" SC_PRIexitcode, name,
+            LOGE("\"%s\" returned with value %" PRIexitcode, name, exit_code);
                 exit_code);
        } else {
            LOGE("\"%s\" exited unexpectedly", name);
        }
@@ -27,95 +19,3 @@ sc_process_check_success(sc_pid pid, 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);
 }
--- a/app/src/util/process.h
+++ b/app/src/util/process.h
@@ -4,173 +4,78 @@
 #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 SC_PRIexitcode "lu"
+# define PATH_SEPARATOR '\\'
 # define PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
-# define SC_PRIsizet "Iu"
+# define PRIsizet "Iu"
-# define SC_PROCESS_NONE NULL
+# define PROCESS_NONE NULL
-# define SC_EXIT_CODE_NONE -1u // max value as unsigned
+# define NO_EXIT_CODE -1u // max value as unsigned
-  typedef HANDLE sc_pid;
+  typedef HANDLE process_t;
-  typedef DWORD sc_exit_code;
+  typedef DWORD exit_code_t;
  typedef HANDLE sc_pipe;
 #else
 # include <sys/types.h>
-# define SC_PRIsizet "zu"
+# define PATH_SEPARATOR '/'
-# define SC_PRIexitcode "d"
+# define PRIsizet "zu"
-# define SC_PROCESS_NONE -1
+# define PRIexitcode "d"
-# define SC_EXIT_CODE_NONE -1
+# define PROCESS_NONE -1
-  typedef pid_t sc_pid;
+# define NO_EXIT_CODE -1
-  typedef int sc_exit_code;
+  typedef pid_t process_t;
-  typedef int sc_pipe;
+  typedef int exit_code_t;
 #endif
-struct sc_process_listener {
+enum process_result {
-    void (*on_terminated)(void *userdata);
+    PROCESS_SUCCESS,
    PROCESS_ERROR_GENERIC,
    PROCESS_ERROR_MISSING_BINARY,
 };
-/**
+// execute the command and write the result to the output parameter "process"
- * Tool to observe process termination
+enum process_result
- *
+process_execute(const char *const argv[], process_t *process);
 * 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;
-    sc_mutex mutex;
+// kill the process
    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,
 };
 /**
 * Execute the command and write the process id to `pid`
 */
 enum sc_process_result
 sc_process_execute(const char *const argv[], sc_pid *pid);
 /**
 * Execute the command and write the process id to `pid`
 *
 * If not NULL, provide a pipe for stdin (`pin`), stdout (`pout`) and stderr
 * (`perr`).
 */
 enum sc_process_result
 sc_process_execute_p(const char *const argv[], sc_pid *pid,
                     sc_pipe *pin, sc_pipe *pout, sc_pipe *perr);
 /**
 * Kill the process
 */
 bool
-sc_process_terminate(sc_pid pid);
+process_terminate(process_t pid);
-/**
+// wait and close the process (like waitpid())
- * 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())
- * The `close` flag indicates if the process must be _closed_ (reaped) (passing
+exit_code_t
- * false is equivalent to enable WNOWAIT in waitid()).
+process_wait(process_t pid, bool close);
 */
 sc_exit_code
 sc_process_wait(sc_pid pid, bool close);
-/**
+// close the process
- * Close (reap) the process
+//
- *
+// Semantically, process_wait(close) = process_wait(noclose) + process_close
 * Semantically:
 *    sc_process_wait(close) = sc_process_wait(noclose) + sc_process_close()
 */
 void
-sc_process_close(sc_pid pid);
+process_close(process_t pid);
-/**
+// convenience function to wait for a successful process execution
- * Convenience function to wait for a successful process execution
+// automatically log process errors with the provided process name
 *
 * Automatically log process errors with the provided process name.
 */
 bool
-sc_process_check_success(sc_pid pid, const char *name, bool close);
+process_check_success(process_t proc, const char *name, bool close);
-/**
+#ifndef _WIN32
- * Read from the pipe
+// only used to find package manager, not implemented for Windows
 *
 * 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
-sc_process_observer_init(struct sc_process_observer *observer, sc_pid pid,
+search_executable(const char *file);
-                         const struct sc_process_listener *listener,
+#endif
                         void *listener_userdata);
-/**
+// return the absolute path of the executable (the scrcpy binary)
- * Wait for process termination until a deadline
+// may be NULL on error; to be freed by free()
- *
+char *
- * Return true if the process is already terminated. Return false if the
+get_executable_path(void);
- * process terminatation has not been detected yet (however, it may have
+
- * terminated in the meantime).
+// returns true if the file exists and is not a directory
 *
 * To wait without timeout/deadline, just use sc_process_wait() instead.
 */
 bool
-sc_process_observer_timedwait(struct sc_process_observer *observer,
+is_regular_file(const char *path);
                              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
--- a/app/src/util/process_intr.c
+++ b/app/src/util/process_intr.c
@@ -1,50 +0,0 @@
 #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;
 }
--- a/app/src/util/process_intr.h
+++ b/app/src/util/process_intr.h
@@ -1,21 +0,0 @@
 #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
--- a/app/src/util/str.h
+++ b/app/src/util/str.h
@@ -1,117 +0,0 @@
 #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
--- a/app/src/util/str_util.c
+++ b/app/src/util/str_util.c
@@ -1,11 +1,9 @@
-#include "str.h"
+#include "str_util.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>
@@ -13,7 +11,7 @@
 #endif
 size_t
-sc_strncpy(char *dest, const char *src, size_t n) {
+xstrncpy(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];
@@ -23,7 +21,7 @@ sc_strncpy(char *dest, const char *src, size_t n) {
 }
 size_t
-sc_str_join(char *dst, const char *const tokens[], char sep, size_t n) {
+xstrjoin(char *dst, const char *const tokens[], char sep, size_t n) {
    const char *const *remaining = tokens;
    const char *token = *remaining++;
    size_t i = 0;
@@ -33,7 +31,7 @@ sc_str_join(char *dst, const char *const tokens[], char sep, size_t n) {
            if (i == n)
                goto truncated;
        }
-        size_t w = sc_strncpy(dst + i, token, n - i);
+        size_t w = xstrncpy(dst + i, token, n - i);
        if (w >= n - i)
            goto truncated;
        i += w;
@@ -47,7 +45,7 @@ truncated:
 }
 char *
-sc_str_quote(const char *src) {
+strquote(const char *src) {
    size_t len = strlen(src);
    char *quoted = malloc(len + 3);
    if (!quoted) {
@@ -61,7 +59,7 @@ sc_str_quote(const char *src) {
 }
 bool
-sc_str_parse_integer(const char *s, long *out) {
+parse_integer(const char *s, long *out) {
    char *endptr;
    if (*s == '\0') {
        return false;
@@ -80,8 +78,7 @@ sc_str_parse_integer(const char *s, long *out) {
 }
 size_t
-sc_str_parse_integers(const char *s, const char sep, size_t max_items,
+parse_integers(const char *s, const char sep, size_t max_items, long *out) {
                      long *out) {
    size_t count = 0;
    char *endptr;
    do {
@@ -110,7 +107,7 @@ sc_str_parse_integers(const char *s, const char sep, size_t max_items,
 }
 bool
-sc_str_parse_integer_with_suffix(const char *s, long *out) {
+parse_integer_with_suffix(const char *s, long *out) {
    char *endptr;
    if (*s == '\0') {
        return false;
@@ -144,7 +141,7 @@ sc_str_parse_integer_with_suffix(const char *s, long *out) {
 }
 bool
-sc_str_list_contains(const char *list, char sep, const char *s) {
+strlist_contains(const char *list, char sep, const char *s) {
    char *p;
    do {
        p = strchr(list, sep);
@@ -162,7 +159,7 @@ sc_str_list_contains(const char *list, char sep, const char *s) {
 }
 size_t
-sc_str_utf8_truncation_index(const char *utf8, size_t max_len) {
+utf8_truncation_index(const char *utf8, size_t max_len) {
    size_t len = strlen(utf8);
    if (len <= max_len) {
        return len;
@@ -180,7 +177,7 @@ sc_str_utf8_truncation_index(const char *utf8, size_t max_len) {
 #ifdef _WIN32
 wchar_t *
-sc_str_to_wchars(const char *utf8) {
+utf8_to_wide_char(const char *utf8) {
    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    if (!len) {
        return NULL;
@@ -196,7 +193,7 @@ sc_str_to_wchars(const char *utf8) {
 }
 char *
-sc_str_from_wchars(const wchar_t *ws) {
+utf8_from_wide_char(const wchar_t *ws) {
    int len = WideCharToMultiByte(CP_UTF8, 0, ws, -1, NULL, 0, NULL, NULL);
    if (!len) {
        return NULL;
@@ -212,90 +209,3 @@ sc_str_from_wchars(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;
 }
--- a/app/src/util/str_util.h
+++ b/app/src/util/str_util.h
@@ -0,0 +1,65 @@
 #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
--- a/app/src/util/strbuf.c
+++ b/app/src/util/strbuf.c
@@ -1,87 +0,0 @@
 #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;
    }
 }
--- a/app/src/util/strbuf.h
+++ b/app/src/util/strbuf.h
@@ -1,73 +0,0 @@
 #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
--- a/app/src/util/term.c
+++ b/app/src/util/term.c
@@ -1,51 +0,0 @@
 #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
 }
--- a/app/src/util/term.h
+++ b/app/src/util/term.h
@@ -1,21 +0,0 @@
 #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
--- a/app/src/util/thread.c
+++ b/app/src/util/thread.c
@@ -2,6 +2,7 @@
 #include <assert.h>
 #include <SDL2/SDL_thread.h>
 #include <SDL2/SDL_timer.h>
 #include "log.h"
@@ -129,8 +130,8 @@ sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline) {
        return false; // timeout
    }
-    uint32_t ms = SC_TICK_TO_MS(deadline - now);
+    sc_tick delay = deadline - now;
-    int r = SDL_CondWaitTimeout(cond->cond, mutex->mutex, ms);
+    int r = SDL_CondWaitTimeout(cond->cond, mutex->mutex, delay);
 #ifndef NDEBUG
    if (r < 0) {
        LOGC("Could not wait on condition with timeout: %s", SDL_GetError());
@@ -169,3 +170,11 @@ sc_cond_broadcast(sc_cond *cond) {
    (void) r;
 #endif
 }
 sc_tick
 sc_tick_now(void) {
    // SDL ticks is an unsigned 32 bits, but this is an implementation detail.
    // It wraps if the program runs for more than ~49 days, but in practice we
    // can assume it does not.
    return (sc_tick) SDL_GetTicks();
 }
--- a/app/src/util/thread.h
+++ b/app/src/util/thread.h
@@ -5,8 +5,7 @@
 #include <stdatomic.h>
 #include <stdbool.h>
-
+#include <stdint.h>
 #include "tick.h"
 /* Forward declarations */
 typedef struct SDL_Thread SDL_Thread;
@@ -17,6 +16,8 @@ typedef int sc_thread_fn(void *);
 typedef unsigned sc_thread_id;
 typedef atomic_uint sc_atomic_thread_id;
 typedef int64_t sc_tick;
 typedef struct sc_thread {
    SDL_Thread *thread;
 } sc_thread;
@@ -81,4 +82,7 @@ sc_cond_signal(sc_cond *cond);
 void
 sc_cond_broadcast(sc_cond *cond);
 sc_tick
 sc_tick_now(void);
 #endif
--- a/app/src/util/tick.c
+++ b/app/src/util/tick.c
@@ -1,16 +0,0 @@
 #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;
 }
--- a/app/src/util/tick.h
+++ b/app/src/util/tick.h
@@ -1,23 +0,0 @@
 #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
--- a/app/src/v4l2_sink.c
+++ b/app/src/v4l2_sink.c
@@ -1,7 +1,7 @@
 #include "v4l2_sink.h"
 #include "util/log.h"
-#include "util/str.h"
+#include "util/str_util.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 && !sc_str_list_contains(oformat->name, ',', name));
+    } while (oformat && !strlist_contains(oformat->name, ',', name));
    return oformat;
 }
@@ -159,7 +159,7 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
        .on_new_frame = sc_video_buffer_on_new_frame,
    };
-    bool ok = sc_video_buffer_init(&vs->vb, vs->buffering_time, &cbs, vs);
+    bool ok = sc_video_buffer_init(&vs->vb, 1, &cbs, vs);
    if (!ok) {
        LOGE("Could not initialize video buffer");
        return false;
@@ -183,11 +183,8 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
        goto error_mutex_destroy;
    }
-    const AVOutputFormat *format = find_muxer("v4l2");
+    // FIXME
-    if (!format) {
+    const AVOutputFormat *format = find_muxer("video4linux2,v4l2");
        // Alternative name
        format = find_muxer("video4linux2");
    }
    if (!format) {
        LOGE("Could not find v4l2 muxer");
        goto error_cond_destroy;
@@ -359,7 +356,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 sc_size frame_size, sc_tick buffering_time) {
+                  struct size frame_size) {
    vs->device_name = strdup(device_name);
    if (!vs->device_name) {
        LOGE("Could not strdup v4l2 device name");
@@ -367,7 +364,6 @@ 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,
--- a/app/src/v4l2_sink.h
+++ b/app/src/v4l2_sink.h
@@ -6,7 +6,6 @@
 #include "coords.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
 #include "util/tick.h"
 #include <libavformat/avformat.h>
@@ -18,8 +17,7 @@ struct sc_v4l2_sink {
    AVCodecContext *encoder_ctx;
    char *device_name;
-    struct sc_size frame_size;
+    struct size frame_size;
    sc_tick buffering_time;
    sc_thread thread;
    sc_mutex mutex;
@@ -34,7 +32,7 @@ struct sc_v4l2_sink {
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct sc_size frame_size, sc_tick buffering_time);
+                  struct size frame_size);
 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Romain Vimont	729be4eef7	wip	2021-07-04 23:48:10 +02:00
Romain Vimont	40721126e2	buffering_thread	2021-07-04 17:29:50 +02:00
Romain Vimont	05c8ed1640	Add missing error log Log video buffer initialization failure in v4l2_sink.	2021-07-04 17:29:50 +02:00
Romain Vimont	5caeb2f624	Notify new frames via callbacks Currently, a frame is available to the consumer as soon as it is pushed by the producer (which can detect if the previous frame is skipped). Notify the new frames (and frame skipped) via callbacks instead. This paves the way to add (optional) buffering, which will introduce a delay between the time when the frame is produced and the time it is available to be consumed.	2021-07-04 17:29:50 +02:00
Romain Vimont	e0fc1b80d2	Extract current video_buffer to frame_buffer The current video buffer only stores one pending frame. In order to add a new buffering feature, move this part to a separate "frame buffer". Keep the video_buffer, which currently delegates all its calls to the frame_buffer.	2021-07-04 17:29:50 +02:00
Romain Vimont	b9a7bd049d	Rename video_buffer to sc_video_buffer Add a scrcpy-specific prefix.	2021-07-04 17:29:50 +02:00
Romain Vimont	5009735032	Relax v4l2_sink lock constraints To fix a data race, commit `5caeab5f6d` called video_buffer_push() and video_buffer_consume() under the v4l2_sink lock. Instead, use the previous_skipped indication (initialized with video buffer locked) to lock only for protecting the has_frame flag. This enables the possibility for the video_buffer to notify new frames via callbacks without lock inversion issues.	2021-07-04 17:29:50 +02:00
Romain Vimont	f2da6662b5	Move include fps_counter The fps_counter is not used from video_buffer.	2021-07-04 17:29:50 +02:00
Romain Vimont	59dc46d35c	Remove obsolete comment Commit `2a94a2b119` removed video_buffer callbacks, the comment is now meaningless.	2021-07-04 17:29:50 +02:00
Romain Vimont	cf9889c5b7	Rename queue to sc_queue Add a scrcpy-specific prefix.	2021-07-04 17:29:50 +02:00
Romain Vimont	0faadc7590	Replace delay by deadline in timedwait() The function sc_cond_timedwait() accepted a parameter representing the max duration to wait, because it internally uses SDL_CondWaitTimeout(). Instead, accept a deadline, to be consistent with pthread_cond_timedwait().	2021-07-04 17:29:50 +02:00
Romain Vimont	1dcd3f295d	Wrap tick API This avoids to use the SDL timer API directly, and will allow to handle generic ticks (possibly negative).	2021-07-04 17:29:14 +02:00