Adapt call() on ContentProvider for Android 12

Android 12 changed one of the call() overloads with a new parameter AttributionSource. Adapt the wrapper. Fixes #2402 <https://github.com/Genymobile/scrcpy/issues/2402>
2021-06-19 09:16:54 +02:00
170 changed files with 3555 additions and 14655 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-1.0-0-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-1.0-0-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.21`][direct-scrcpy-server]  
+ - [`scrcpy-server-v1.17`][direct-scrcpy-server]  
-   _(SHA-256: dbcccab523ee26796e55ea33652649e4b7af498edae9aa75e4d4d7869c0ab848)_
+   _(SHA-256: 11b5ad2d1bc9b9730fb7254a78efd71a8ff46b1938ff468e47a21b653a1b6725)_
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.21/scrcpy-server-v1.21
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-server-v1.17
 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
@@ -1,235 +0,0 @@
 _Apri le [FAQ](FAQ.md) originali e sempre aggiornate._
 # Domande Frequenti (FAQ)
 Questi sono i problemi più comuni riportati e i loro stati.
 ## Problemi di `adb`
 `scrcpy` esegue comandi `adb` per inizializzare la connessione con il dispositivo. Se `adb` fallisce, scrcpy non funzionerà.
 In questo caso sarà stampato questo errore:
 >     ERROR: "adb push" returned with value 1
 Questo solitamente non è un bug di _scrcpy_, ma un problema del tuo ambiente.
 Per trovare la causa, esegui:
 ```bash
 adb devices
 ```
 ### `adb` not found (`adb` non trovato)
 È necessario che `adb` sia accessibile dal tuo `PATH`.
 In Windows, la cartella corrente è nel tuo `PATH` e `adb.exe` è incluso nella release, perciò dovrebbe già essere pronto all'uso.
 ### Device unauthorized (Dispositivo non autorizzato)
 Controlla [stackoverflow][device-unauthorized] (in inglese).
 [device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
 ### Device not detected (Dispositivo non rilevato)
 >     adb: error: failed to get feature set: no devices/emulators found
 Controlla di aver abilitato correttamente il [debug con adb][enable-adb] (link in inglese).
 Se il tuo dispositivo non è rilevato, potresti avere bisogno dei [driver][drivers] (link in inglese) (in Windows).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
 ### Più dispositivi connessi
 Se più dispositivi sono connessi, riscontrerai questo errore:
 >     adb: error: failed to get feature set: more than one device/emulator
 l'identificatore del tuo dispositivo deve essere fornito:
 ```bash
 scrcpy -s 01234567890abcdef
 ```
 Notare che se il tuo dispositivo è connesso mediante TCP/IP, riscontrerai questo messaggio:
 >     adb: error: more than one device/emulator
 >     ERROR: "adb reverse" returned with value 1
 >     WARN: 'adb reverse' failed, fallback to 'adb forward'
 Questo è un problema atteso (a causa di un bug di una vecchia versione di Android, vedi [#5] (link in inglese)), ma in quel caso scrcpy ripiega su un metodo differente, il quale dovrebbe funzionare.
 [#5]: https://github.com/Genymobile/scrcpy/issues/5
 ### Conflitti tra versioni di adb
 >     adb server version (41) doesn't match this client (39); killing...
 L'errore compare quando usi più versioni di `adb` simultaneamente. Devi trovare il programma che sta utilizzando una versione differente di `adb` e utilizzare la stessa versione dappertutto.
 Puoi sovrascrivere i binari di `adb` nell'altro programma, oppure chiedere a _scrcpy_ di usare un binario specifico di `adb`, impostando la variabile d'ambiente `ADB`:
 ```bash
 set ADB=/path/to/your/adb
 scrcpy
 ```
 ### Device disconnected (Dispositivo disconnesso)
 Se _scrcpy_ si interrompe con l'avviso "Device disconnected", allora la connessione `adb` è stata chiusa.
 Prova con un altro cavo USB o inseriscilo in un'altra porta USB. Vedi [#281] (in inglese) e [#283] (in inglese).
 [#281]: https://github.com/Genymobile/scrcpy/issues/281
 [#283]: https://github.com/Genymobile/scrcpy/issues/283
 ## Problemi di controllo
 ### Mouse e tastiera non funzionano
 Su alcuni dispositivi potresti dover abilitare un opzione che permette l'[input simulato][simulating input] (link in inglese). Nelle opzioni sviluppatore, abilita:
 > **Debug USB (Impostazioni di sicurezza)**
 > _Permetti la concessione dei permessi e la simulazione degli input mediante il debug USB_
 <!--- Ho tradotto personalmente il testo sopra, non conosco esattamente il testo reale --->
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ### I caratteri speciali non funzionano
 Iniettare del testo in input è [limitato ai caratteri ASCII][text-input] (link in inglese). Un trucco permette di iniettare dei [caratteri accentati][accented-characters] (link in inglese), ma questo è tutto. Vedi [#37] (link in inglese).
 [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
 ## Problemi del client
 ### La qualità è bassa
 Se la definizione della finestra del tuo client è minore di quella del tuo dispositivo, allora potresti avere una bassa qualità di visualizzazione, specialmente individuabile nei testi (vedi [#40] (link in inglese)).
 [#40]: https://github.com/Genymobile/scrcpy/issues/40
 Per migliorare la qualità di ridimensionamento (downscaling), il filtro trilineare è applicato automaticamente se il renderizzatore è OpenGL e se supporta la creazione di mipmap.
 In Windows, potresti voler forzare OpenGL:
 ```
 scrcpy --render-driver=opengl
 ```
 Potresti anche dover configurare il [comportamento di ridimensionamento][scaling behavior] (link in inglese):
 > `scrcpy.exe` > Propietà > Compatibilità > Modifica impostazioni DPI elevati > Esegui l'override del comportamento di ridimensionamento DPI elevati >  Ridimensionamento eseguito per:  _Applicazione_.
 [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
 In Plasma Desktop, il compositore è disabilitato mentre _scrcpy_ è in esecuzione.
 Come soluzione alternativa, [disattiva la "composizione dei blocchi"][kwin] (link in inglese).
 <!--- Non sono sicuro di aver tradotto correttamente la stringa di testo del pulsante --->
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
 ## Crash
 ### Eccezione
 Ci potrebbero essere molte ragioni. Una causa comune è che il codificatore hardware del tuo dispositivo non riesce a codificare alla definizione selezionata:
 > ```
 > 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
 > ```
 o
 > ```
 > ERROR: Exception on thread Thread[main,5,main]
 > java.lang.IllegalStateException
 >         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
 > ```
 Prova con una definizione inferiore:
 ```
 scrcpy -m 1920
 scrcpy -m 1024
 scrcpy -m 800
 ```
 Potresti anche provare un altro [codificatore](README.it.md#codificatore).
 ## Linea di comando in Windows
 Alcuni utenti Windows non sono familiari con la riga di comando. Qui è descritto come aprire un terminale ed eseguire `scrcpy` con gli argomenti:
 1. Premi <kbd>Windows</kbd>+<kbd>r</kbd>, questo apre una finestra di dialogo.
 2. Scrivi `cmd` e premi <kbd>Enter</kbd>, questo apre un terminale.
 3. Vai nella tua cartella di _scrcpy_ scrivendo (adatta il percorso):
    ```bat
    cd C:\Users\user\Downloads\scrcpy-win64-xxx
    ```
    e premi <kbd>Enter</kbd>
 4. Scrivi il tuo comando. Per esempio:
    ```bat
    scrcpy --record file.mkv
    ```
 Se pianifichi di utilizzare sempre gli stessi argomenti, crea un file `myscrcpy.bat` (abilita mostra [estensioni nomi file][show file extensions] per evitare di far confusione) contenente il tuo comando nella cartella di `scrcpy`. Per esempio:
 ```bat
 scrcpy --prefer-text --turn-screen-off --stay-awake
 ```
 Poi fai doppio click su quel file.
 Potresti anche modificare (una copia di) `scrcpy-console.bat` o `scrcpy-noconsole.vbs` per aggiungere alcuni argomenti.
 [show file extensions]: https://www.techpedia.it/14-windows/windows-10/171-visualizzare-le-estensioni-nomi-file-con-windows-10
--- a/FAQ.md
+++ b/FAQ.md
@@ -1,7 +1,5 @@
 # Frequently Asked Questions
 [Read in another language](#translations)
 Here are the common reported problems and their status.
@@ -118,17 +116,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 +151,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 +196,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
@@ -277,12 +230,3 @@ You could also edit (a copy of) `scrcpy-console.bat` or `scrcpy-noconsole.vbs`
 to add some arguments.
 [show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/
 ## Translations
 This FAQ is available in other languages:
 - [Italiano (Italiano, `it`) - v1.19](FAQ.it.md)
 - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.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,813 +0,0 @@
 _Apri il [README](README.md) originale e sempre aggiornato._
 # scrcpy (v1.19)
 Questa applicazione fornisce la visualizzazione e il controllo dei dispositivi Android collegati via USB (o [via TCP/IP][article-tcpip]). Non richiede alcun accesso _root_.
 Funziona su _GNU/Linux_, _Windows_ e _macOS_.
 ![screenshot](assets/screenshot-debian-600.jpg)
 Si concentra su:
 - **leggerezza** (nativo, mostra solo lo schermo del dispositivo)
 - **prestazioni** (30~60fps)
 - **qualità** (1920×1080 o superiore)
 - **bassa latenza** ([35~70ms][lowlatency])
 - **tempo di avvio basso** (~ 1secondo per visualizzare la prima immagine)
 - **non invadenza** (nulla viene lasciato installato sul dispositivo)
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 ## Requisiti
 Il dispositivo Android richiede almeno le API 21 (Android 5.0).
 Assiucurati di aver [attivato il debug usb][enable-adb] sul(/i) tuo(i) dispositivo(/i).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 In alcuni dispositivi, devi anche abilitare [un'opzione aggiuntiva][control] per controllarli con tastiera e mouse.
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ## Ottieni l'app
 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
 ### Sommario
 - Linux: `apt install scrcpy`
 - Windows: [download](README.md#windows)
 - macOS: `brew install scrcpy`
 Compila dai sorgenti: [BUILD] (in inglese) ([procedimento semplificato][BUILD_simple] (in inglese))
 [BUILD]: BUILD.md
 [BUILD_simple]: BUILD.md#simple
 ### Linux
 Su Debian (_testing_ e _sid_ per ora) e Ubuntu (20.04):
 ```
 apt install scrcpy
 ```
 È disponibile anche un pacchetto [Snap]: [`scrcpy`][snap-link].
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://it.wikipedia.org/wiki/Snappy_(gestore_pacchetti)
 Per Fedora, è disponibile un pacchetto [COPR]: [`scrcpy`][copr-link].
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 Per Arch Linux, è disponibile un pacchetto [AUR]: [`scrcpy`][aur-link].
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 [aur-link]: https://aur.archlinux.org/packages/scrcpy/
 Per Gentoo, è disponibile una [Ebuild]: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 Puoi anche [compilare l'app manualmente][BUILD] (in inglese) ([procedimento semplificato][BUILD_simple] (in inglese)).
 ### Windows
 Per Windows, per semplicità è disponibile un archivio precompilato con tutte le dipendenze (incluso `adb`):
 - [README](README.md#windows) (Link al README originale per l'ultima versione)
 È anche disponibile in [Chocolatey]:
 [Chocolatey]: https://chocolatey.org/
 ```bash
 choco install scrcpy
 choco install adb    # se non lo hai già
 ```
 E in [Scoop]:
 ```bash
 scoop install scrcpy
 scoop install adb    # se non lo hai già
 ```
 [Scoop]: https://scoop.sh
 Puoi anche [compilare l'app manualmente][BUILD] (in inglese).
 ### macOS
 L'applicazione è disponibile in [Homebrew]. Basta installarlo:
 [Homebrew]: https://brew.sh/
 ```bash
 brew install scrcpy
 ```
 Serve che `adb` sia accessibile dal tuo `PATH`. Se non lo hai già:
 ```bash
 brew install android-platform-tools
 ```
 È anche disponibile in [MacPorts], che imposta adb per te:
 ```bash
 sudo port install scrcpy
 ```
 [MacPorts]: https://www.macports.org/
 Puoi anche [compilare l'app manualmente][BUILD] (in inglese).
 ## Esecuzione
 Collega un dispositivo Android ed esegui:
 ```bash
 scrcpy
 ```
 Scrcpy accetta argomenti da riga di comando, essi sono listati con:
 ```bash
 scrcpy --help
 ```
 ## Funzionalità
 ### Configurazione di acquisizione
 #### Riduci dimensione
 Qualche volta è utile trasmettere un dispositvo Android ad una definizione inferiore per aumentare le prestazioni.
 Per limitare sia larghezza che altezza ad un certo valore (ad es. 1024):
 ```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # versione breve
 ```
 L'altra dimensione è calcolata in modo tale che il rapporto di forma del dispositivo sia preservato.
 In questo esempio un dispositivo in 1920x1080 viene trasmesso a 1024x576.
 #### Cambia bit-rate (velocità di trasmissione)
 Il bit-rate predefinito è 8 Mbps. Per cambiare il bitrate video (ad es. a 2 Mbps):
 ```bash
 scrcpy --bit-rate 2M
 scrcpy -b 2M  # versione breve
 ```
 #### Limitare il frame rate (frequenza di fotogrammi)
 Il frame rate di acquisizione può essere limitato:
 ```bash
 scrcpy --max-fps 15
 ```
 Questo è supportato ufficialmente a partire da Android 10, ma potrebbe funzionare in versioni precedenti.
 #### Ritaglio
 Lo schermo del dispositivo può essere ritagliato per visualizzare solo parte di esso.
 Questo può essere utile, per esempio, per trasmettere solo un occhio dell'Oculus Go:
 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
 ```
 Se anche `--max-size` è specificata, il ridimensionamento è applicato dopo il ritaglio.
 #### Blocca orientamento del video
 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=1   # 90° antiorario
 scrcpy --lock-video-orientation=2   # 180°
 scrcpy --lock-video-orientation=3   # 90° orario
 ```
 Questo influisce sull'orientamento della registrazione.
 La [finestra può anche essere ruotata](#rotazione) indipendentemente.
 #### Codificatore
 Alcuni dispositivi hanno più di un codificatore e alcuni di questi possono provocare problemi o crash. È possibile selezionare un encoder diverso:
 ```bash
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```
 Per elencare i codificatori disponibili puoi immettere un nome di codificatore non valido e l'errore mostrerà i codificatori disponibili:
 ```bash
 scrcpy --encoder _
 ```
 ### Cattura
 #### Registrazione
 È possibile registrare lo schermo durante la trasmissione:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 Per disabilitare la trasmissione durante la registrazione:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrompere la registrazione con Ctrl+C
 ```
 I "fotogrammi saltati" sono registrati nonostante non siano mostrati in tempo reale (per motivi di prestazioni). I fotogrammi sono _datati_ sul dispositivo, così una [variazione di latenza dei pacchetti][packet delay variation] non impatta il file registrato.
 [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
 _Scrcpy_ usa `adb` per comunicare col dispositivo e `adb` può [connettersi][connect] al dispositivo mediante TCP/IP:
 1. Connetti il dispositivo alla stessa rete Wi-Fi del tuo computer.
 2. Trova l'indirizzo IP del tuo dispositivo in Impostazioni → Informazioni sul telefono → Stato, oppure   eseguendo questo comando:
    ```bash
    adb shell ip route | awk '{print $9}'
    ```
 3. Abilita adb via TCP/IP sul tuo dispositivo: `adb tcpip 5555`.
 4. Scollega il tuo dispositivo.
 5. Connetti il tuo dispositivo: `adb connect IP_DISPOSITVO:5555` _(rimpiazza `IP_DISPOSITIVO`)_.
 6. Esegui `scrcpy` come al solito.
 Potrebbe essere utile diminuire il bit-rate e la definizione
 ```bash
 scrcpy --bit-rate 2M --max-size 800
 scrcpy -b2M -m800  # versione breve
 ```
 [connect]: https://developer.android.com/studio/command-line/adb.html#wireless
 #### Multi dispositivo
 Se in `adb devices` sono listati più dispositivi, è necessario specificare il _seriale_:
 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # versione breve
 ```
 Se il dispositivo è collegato mediante TCP/IP:
 ```bash
 scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # versione breve
 ```
 Puoi avviare più istanze di _scrcpy_ per diversi dispositivi.
 #### Avvio automativo alla connessione del dispositivo
 Potresti usare [AutoAdb]:
 ```bash
 autoadb scrcpy -s '{}'
 ```
 [AutoAdb]: https://github.com/rom1v/autoadb
 #### Tunnel SSH
 Per connettersi a un dispositivo remoto è possibile collegare un client `adb` locale ad un server `adb` remoto (assunto che entrambi stiano usando la stessa versione del protocollo _adb_):
 ```bash
 adb kill-server    # termina il server adb locale su 5037
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # tieni questo aperto
 ```
 Da un altro terminale:
 ```bash
 scrcpy
 ```
 Per evitare l'abilitazione dell'apertura porte remota potresti invece forzare una "forward connection" (notare il `-L` invece di `-R`)
 ```bash
 adb kill-server    # termina il server adb locale su 5037
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # tieni questo aperto
 ```
 Da un altro terminale:
 ```bash
 scrcpy --force-adb-forward
 ```
 Come per le connessioni wireless potrebbe essere utile ridurre la qualità:
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### Configurazione della finestra
 #### Titolo
 Il titolo della finestra è il modello del dispositivo per impostazione predefinita. Esso può essere cambiato:
 ```bash
 scrcpy --window-title 'My device'
 ```
 #### Posizione e dimensione
 La posizione e la dimensione iniziale della finestra può essere specificata:
 ```bash
 scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 ```
 #### Senza bordi
 Per disabilitare le decorazioni della finestra:
 ```bash
 scrcpy --window-borderless
 ```
 #### Sempre in primo piano
 Per tenere scrcpy sempre in primo piano:
 ```bash
 scrcpy --always-on-top
 ```
 #### Schermo intero
 L'app può essere avviata direttamente a schermo intero:
 ```bash
 scrcpy --fullscreen
 scrcpy -f  # versione breve
 ```
 Lo schermo intero può anche essere attivato/disattivato con <kbd>MOD</kbd>+<kbd>f</kbd>.
 #### Rotazione
 La finestra può essere ruotata:
 ```bash
 scrcpy --rotation 1
 ```
 I valori possibili sono:
 - `0`: nessuna rotazione
 - `1`: 90 gradi antiorari
 - `2`: 180 gradi
 - `3`: 90 gradi orari
 La rotazione può anche essere cambiata dinamicamente con <kbd>MOD</kbd>+<kbd>←</kbd>
 _(sinistra)_ e <kbd>MOD</kbd>+<kbd>→</kbd> _(destra)_.
 Notare che _scrcpy_ gestisce 3 diversi tipi di rotazione:
 - <kbd>MOD</kbd>+<kbd>r</kbd> richiede al dispositvo di cambiare tra orientamento verticale (portrait) e orizzontale (landscape) (l'app in uso potrebbe rifiutarsi se non supporta l'orientamento richiesto).
 - [`--lock-video-orientation`](#blocca-orientamento-del-video) cambia l'orientamento della trasmissione (l'orientamento del video inviato dal dispositivo al computer). Questo influenza la registrazione.
 - `--rotation` (o <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) ruota solo il contenuto della finestra. Questo influenza solo la visualizzazione, non la registrazione.
 ### Altre opzioni di trasmissione
 #### "Sola lettura"
 Per disabilitare i controlli (tutto ciò che può interagire col dispositivo: tasti di input, eventi del mouse, trascina e rilascia (drag&drop) file):
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
 #### Schermo
 Se sono disponibili più schermi, è possibile selezionare lo schermo da trasmettere:
 ```bash
 scrcpy --display 1
 ```
 La lista degli id schermo può essere ricavata da:
 ```bash
 adb shell dumpsys display   # cerca "mDisplayId=" nell'output
 ```
 Lo schermo secondario potrebbe essere possibile controllarlo solo se il dispositivo esegue almeno Android 10 (in caso contrario è trasmesso in modalità sola lettura).
 #### Mantenere sbloccato
 Per evitare che il dispositivo si blocchi dopo un po' che il dispositivo è collegato:
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
 Lo stato iniziale è ripristinato quando scrcpy viene chiuso.
 #### Spegnere lo schermo
 È possibile spegnere lo schermo del dispositivo durante la trasmissione con un'opzione da riga di comando:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
 Oppure premendo <kbd>MOD</kbd>+<kbd>o</kbd> in qualsiasi momento.
 Per riaccenderlo premere <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
 In Android il pulsante `POWER` (tasto di accensione) accende sempre lo schermo. Per comodità, se `POWER` è inviato via scrcpy (con click destro o con <kbd>MOD</kbd>+<kbd>p</kbd>), si forza il dispositivo a spegnere lo schermo dopo un piccolo ritardo (appena possibile).
 Il pulsante fisico `POWER` continuerà ad accendere lo schermo normalmente.
 Può anche essere utile evitare il blocco del dispositivo:
 ```bash
 scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
 #### Mostrare i tocchi
 Per le presentazioni può essere utile mostrare i tocchi fisici (sul dispositivo fisico).
 Android fornisce questa funzionalità nelle _Opzioni sviluppatore_.
 _Scrcpy_ fornisce un'opzione per abilitare questa funzionalità all'avvio e ripristinare il valore iniziale alla chiusura:
 ```bash
 scrcpy --show-touches
 scrcpy -t
 ```
 Notare che mostra solo i tocchi _fisici_ (con le dita sul dispositivo).
 #### Disabilitare il salvaschermo
 In maniera predefinita scrcpy non previene l'attivazione del salvaschermo del computer.
 Per disabilitarlo:
 ```bash
 scrcpy --disable-screensaver
 ```
 ### Input di controlli
 #### Rotazione dello schermo del dispostivo
 Premere <kbd>MOD</kbd>+<kbd>r</kbd> per cambiare tra le modalità verticale (portrait) e orizzontale (landscape).
 Notare che la rotazione avviene solo se l'applicazione in primo piano supporta l'orientamento richiesto.
 #### Copia-incolla
 Quando gli appunti di Android cambiano, essi vengono automaticamente sincronizzati con gli appunti del computer.
 Qualsiasi scorciatoia <kbd>Ctrl</kbd> viene inoltrata al dispositivo. In particolare:
 - <kbd>Ctrl</kbd>+<kbd>c</kbd> copia
 - <kbd>Ctrl</kbd>+<kbd>x</kbd> taglia
 - <kbd>Ctrl</kbd>+<kbd>v</kbd> incolla (dopo la sincronizzazione degli appunti da computer a dispositivo)
 Questo solitamente funziona nella maniera più comune.
 Il comportamento reale, però, dipende dall'applicazione attiva. Per esempio _Termux_ invia SIGINT con <kbd>Ctrl</kbd>+<kbd>c</kbd>, e _K-9 Mail_ compone un nuovo messaggio.
 Per copiare, tagliare e incollare in questi casi (ma è solo supportato in Android >= 7):
 - <kbd>MOD</kbd>+<kbd>c</kbd> inietta `COPY`
 - <kbd>MOD</kbd>+<kbd>x</kbd> inietta `CUT`
 - <kbd>MOD</kbd>+<kbd>v</kbd> inietta `PASTE` (dopo la sincronizzazione degli appunti da computer a dispositivo)
 In aggiunta, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permette l'iniezione del testo degli appunti del computer come una sequenza di eventi pressione dei tasti. Questo è utile quando il componente non accetta l'incollaggio di testo (per esempio in _Termux_), ma questo può rompere il contenuto non ASCII.
 **AVVISO:** Incollare gli appunti del computer nel dispositivo (sia con <kbd>Ctrl</kbd>+<kbd>v</kbd> che con <kbd>MOD</kbd>+<kbd>v</kbd>) copia il contenuto negli appunti del dispositivo. Come conseguenza, qualsiasi applicazione Android potrebbe leggere il suo contenuto. Dovresti evitare di incollare contenuti sensibili (come password) in questa maniera.
 Alcuni dispositivi non si comportano come aspettato quando si modificano gli appunti del dispositivo a livello di codice. L'opzione `--legacy-paste` è fornita per cambiare il comportamento di <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> in modo tale che anch'essi iniettino il testo gli appunti del computer come una sequenza di eventi pressione dei tasti (nella stessa maniera di <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
 #### Pizzica per zoomare (pinch-to-zoom)
 Per simulare il "pizzica per zoomare": <kbd>Ctrl</kbd>+_click e trascina_.
 Più precisamente, tieni premuto <kbd>Ctrl</kbd> mentre premi il pulsante sinistro. Finchè il pulsante non sarà rilasciato, tutti i movimenti del mouse ridimensioneranno e ruoteranno il contenuto (se supportato dall'applicazione) relativamente al centro dello schermo.
 Concretamente scrcpy genera degli eventi di tocco addizionali di un "dito virtuale" nella posizione simmetricamente opposta rispetto al centro dello schermo.
 #### Preferenze di iniezione del testo
 Ci sono due tipi di [eventi][textevents] generati quando si scrive testo:
 - _eventi di pressione_, segnalano che tasto è stato premuto o rilasciato;
 - _eventi di testo_, segnalano che del testo è stato inserito.
 In maniera predefinita le lettere sono "iniettate" usando gli eventi di pressione, in maniera tale che la tastiera si comporti come aspettato nei giochi (come accade solitamente per i tasti WASD).
 Questo, però, può [causare problemi][prefertext]. Se incontri un problema del genere, puoi evitarlo con:
 ```bash
 scrcpy --prefer-text
 ```
 (ma questo romperà il normale funzionamento della tastiera nei giochi)
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 #### Ripetizione di tasti
 In maniera predefinita tenere premuto un tasto genera una ripetizione degli eventi di pressione di tale tasto. Questo può creare problemi di performance in alcuni giochi, dove questi eventi sono inutilizzati.
 Per prevenire l'inoltro ripetuto degli eventi di pressione:
 ```bash
 scrcpy --no-key-repeat
 ```
 #### Click destro e click centrale
 In maniera predefinita, click destro aziona BACK (indietro) e il click centrale aziona HOME. Per disabilitare queste scorciatoie e, invece, inviare i click al dispositivo:
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### Rilascio di file
 #### Installare APK
 Per installare un APK, trascina e rilascia un file APK (finisce con `.apk`) nella finestra di _scrcpy_.
 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_.
 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/
 ```
 ### Inoltro dell'audio
 L'audio non è inoltrato da _scrcpy_. Usa [sndcpy].
 Vedi anche la [issue #14].
 [sndcpy]: https://github.com/rom1v/sndcpy
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## Scociatoie
 Nella lista seguente, <kbd>MOD</kbd> è il modificatore delle scorciatoie. In maniera predefinita è <kbd>Alt</kbd> (sinistro) o <kbd>Super</kbd> (sinistro).
 Può essere cambiato usando `--shortcut-mod`. I tasti possibili sono `lctrl`, `rctrl`, `lalt`, `ralt`, `lsuper` and `rsuper` (`l` significa sinistro e `r` significa destro). Per esempio:
 ```bash
 # usa ctrl destro per le scorciatoie
 scrcpy --shortcut-mod=rctrl
 # use sia "ctrl sinistro"+"alt sinistro" che "super sinistro" per le scorciatoie
 scrcpy --shortcut-mod=lctrl+lalt,lsuper
 ```
 _<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
 [Super]: https://it.wikipedia.org/wiki/Tasto_Windows
 <!-- https://en.wikipedia.org/wiki/Super_key_(keyboard_button) è la pagina originale di Wikipedia inglese, l'ho sostituita con una simile in quello italiano -->
 | Azione                                      |   Scorciatoia
 | ------------------------------------------- |:-----------------------------
 | Schermo intero                      | <kbd>MOD</kbd>+<kbd>f</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¹_
 | 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 `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ù)_
 | Premi il tasto `POWER`                            | <kbd>MOD</kbd>+<kbd>p</kbd>
 | Accendi                                    | _Click destro²_
 | 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 impostazioni                   | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Doppio 5° click³_
 | Chiudi pannelli                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | Copia negli appunti⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
 | Taglia negli appunti⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
 | Sincronizza gli appunti e incolla⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Inietta il testo degli appunti del computer              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Abilita/Disabilita il contatore FPS (su stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
 | Pizzica per zoomare                               | <kbd>Ctrl</kbd>+_click e trascina_
 _¹Doppio click sui bordi neri per rimuoverli._  
 _²Il tasto destro accende lo schermo se era spento, preme BACK in caso contrario._  
 _³4° e 5° pulsante del mouse, se il tuo mouse ne dispone._  
 _⁴Solo in Android >= 7._
 Le scorciatoie con pulsanti ripetuti sono eseguite rilasciando e premendo il pulsante una seconda volta. Per esempio, per eseguire "Espandi il pannello delle impostazioni":
 1. Premi e tieni premuto <kbd>MOD</kbd>.
 2. Poi premi due volte <kbd>n</kbd>.
 3. Infine rilascia <kbd>MOD</kbd>.
 Tutte le scorciatoie <kbd>Ctrl</kbd>+_tasto_ sono inoltrate al dispositivo, così sono gestite dall'applicazione attiva.
 ## Path personalizzati
 Per utilizzare dei binari _adb_ specifici, configura il suo path nella variabile d'ambente `ADB`:
 ```bash
 ADB=/percorso/per/adb scrcpy
 ```
 Per sovrascrivere il percorso del file `scrcpy-server`, configura il percorso in `SCRCPY_SERVER_PATH`.
 ## Perchè _scrcpy_?
 Un collega mi ha sfidato a trovare un nome tanto impronunciabile quanto [gnirehtet].
 [`strcpy`] copia una **str**ing (stringa); `scrcpy` copia uno **scr**een (schermo).
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## Come compilare?
 Vedi [BUILD] (in inglese).
 ## Problemi comuni
 Vedi le [FAQ](FAQ.it.md).
 ## Sviluppatori
 Leggi la [pagina per sviluppatori].
 [pagina per sviluppatori]: DEVELOP.md
 ## Licenza (in inglese)
    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.
 ## Articoli (in inglese)
 - [Introducendo scrcpy][article-intro]
 - [Scrcpy ora funziona wireless][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/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.21)
+# scrcpy (v1.17)
 <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](#tcpip-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
@@ -65,7 +52,7 @@ Build from sources: [BUILD] ([simplified process][BUILD_simple])
 ### Linux
-On Debian and Ubuntu:
+On Debian (_testing_ and _sid_ for now) and Ubuntu (20.04):
 ```
 apt install scrcpy
@@ -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.21.zip`][direct-win64]  
+ - [`scrcpy-win64-v1.17.zip`][direct-win64]  
-   _(SHA-256: fdab0c1421353b592a9bbcebd6e252675eadccca65cca8105686feaa9c1ded53)_
+   _(SHA-256: 8b9e57993c707367ed10ebfe0e1ef563c7a29d9af4a355cd8b6a52a317c73eea)_
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.21/scrcpy-win64-v1.21.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-win64-v1.17.zip
 It is also available in [Chocolatey]:
@@ -331,64 +318,15 @@ 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
-#### TCP/IP (wireless)
+#### Wireless
 _Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
-device over TCP/IP. The device must be connected on the same network as the
+device over TCP/IP:
 computer.
 ##### Automatic
 An option `--tcpip` allows to configure the connection automatically. There are
 two variants.
 If the device (accessible at 192.168.1.1 in this example) already listens on a
 port (typically 5555) for incoming adb connections, then run:
 ```bash
 scrcpy --tcpip=192.168.1.1       # default port is 5555
 scrcpy --tcpip=192.168.1.1:5555
 ```
 If adb TCP/IP mode is disabled on the device (or if you don't know the IP
 address), connect the device over USB, then run:
 ```bash
 scrcpy --tcpip    # without arguments
 ```
 It will automatically find the device IP address, enable TCP/IP mode, then
 connect to the device before starting.
 ##### Manual
 Alternatively, it is possible to enable the TCP/IP connection manually using
 `adb`:
 1. Connect the device to the same Wi-Fi as your computer.
 2. Get your device IP address, in Settings → About phone → Status, or by
@@ -441,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
 ```
@@ -508,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
 ```
@@ -625,7 +516,7 @@ scrcpy --display 1
 The list of display ids can be retrieved by:
-```bash
+```
 adb shell dumpsys display   # search "mDisplayId=" in the output
 ```
@@ -671,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
@@ -759,9 +642,6 @@ of <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> so that they
 also inject the computer clipboard text as a sequence of key events (the same
 way as <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
 To disable automatic clipboard synchronization, use
 `--no-clipboard-autosync`.
 #### Pinch-to-zoom
 To simulate "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-and-move_.
@@ -773,48 +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].
 This settings page can be started directly:
 ```bash
 adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
 ```
 However, the option is only available when the HID keyboard is enabled (or when
 a physical keyboard is connected).
 [Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
 #### Text injection preference
@@ -834,15 +672,6 @@ scrcpy --prefer-text
 (but this will break keyboard behavior in games)
 On the contrary, you could force to always inject raw key events:
 ```bash
 scrcpy --raw-key-events
 ```
 These options have 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
@@ -858,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
@@ -953,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._  
@@ -977,14 +801,12 @@ handled by the active application.
 To use a specific _adb_ binary, configure its path in the environment variable
 `ADB`:
 ```bash
    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_?
@@ -1044,13 +866,10 @@ 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)
+- [日本語 (Japanese, `jp`) - v1.17](README.jp.md)
 - [日本語 (Japanese, `jp`) - v1.19](README.jp.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
- [Português Brasileiro (Brazilian Portuguese, `pt-BR`) - v1.19](README.pt-br.md)
+- [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)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.20](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
 - [Turkish (Turkish, `tr`) - v1.18](README.tr.md)
 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
 ```
 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.sp.md
+++ b/README.sp.md
@@ -1,743 +0,0 @@
 Solo se garantiza que el archivo [README](README.md) original esté actualizado.
 # scrcpy (v1.17)
 Esta aplicación proporciona imagen y control de un dispositivo Android conectado
 por USB (o [por TCP/IP][article-tcpip]). No requiere acceso _root_.
 Compatible con _GNU/Linux_, _Windows_ y _macOS_.
 ![screenshot](assets/screenshot-debian-600.jpg)
 Sus características principales son:
 - **ligero** (nativo, solo muestra la imagen del dispositivo)
 - **desempeño** (30~60fps)
 - **calidad** (1920×1080 o superior)
 - **baja latencia** ([35~70ms][lowlatency])
 - **corto tiempo de inicio** (~1 segundo para mostrar la primera imagen)
 - **no intrusivo** (no se deja nada instalado en el dispositivo)
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 ## Requisitos
 El dispositivo Android requiere como mínimo API 21 (Android 5.0).
 Asegurate de [habilitar el adb debugging][enable-adb] en tu(s) dispositivo(s).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 En algunos dispositivos, también necesitas habilitar [una opción adicional][control] para controlarlo con el teclado y ratón.
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ## Consigue la app
 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
 ### Resumen
 - Linux: `apt install scrcpy`
 - Windows: [download](README.md#windows)
 - macOS: `brew install scrcpy`
 Construir desde la fuente: [BUILD] ([proceso simplificado][BUILD_simple])
 [BUILD]: BUILD.md
 [BUILD_simple]: BUILD.md#simple
 ### Linux
 En Debian (_test_ y _sid_ por ahora) y Ubuntu (20.04):
 ```
 apt install scrcpy
 ```
 Hay un paquete [Snap]: [`scrcpy`][snap-link].
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
 Para Fedora, hay un paquete [COPR]: [`scrcpy`][copr-link].
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 Para Arch Linux, hay un paquete [AUR]: [`scrcpy`][aur-link].
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 [aur-link]: https://aur.archlinux.org/packages/scrcpy/
 Para Gentoo, hay un paquete [Ebuild]: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 También puedes [construir la aplicación manualmente][BUILD] ([proceso simplificado][BUILD_simple]).
 ### Windows
 Para Windows, por simplicidad, hay un pre-compilado con todas las dependencias
 (incluyendo `adb`):
 - [README](README.md#windows)
 También está disponible en [Chocolatey]:
 [Chocolatey]: https://chocolatey.org/
 ```bash
 choco install scrcpy
 choco install adb    # si aún no está instalado
 ```
 Y en [Scoop]:
 ```bash
 scoop install scrcpy
 scoop install adb    # si aún no está instalado
 ```
 [Scoop]: https://scoop.sh
 También puedes [construir la aplicación manualmente][BUILD].
 ### macOS
 La aplicación está disponible en [Homebrew]. Solo instalala:
 [Homebrew]: https://brew.sh/
 ```bash
 brew install scrcpy
 ```
 Necesitarás `adb`, accesible desde `PATH`. Si aún no lo tienes:
 ```bash
 brew install android-platform-tools
 ```
 También está disponible en [MacPorts], que configurará el adb automáticamente:
 ```bash
 sudo port install scrcpy
 ```
 [MacPorts]: https://www.macports.org/
 También puedes [construir la aplicación manualmente][BUILD].
 ## Ejecutar
 Enchufa el dispositivo Android, y ejecuta:
 ```bash
 scrcpy
 ```
 Acepta argumentos desde la línea de comandos, listados en:
 ```bash
 scrcpy --help
 ```
 ## Características
 ### Capturar configuración
 #### Reducir la definición
 A veces es útil reducir la definición de la imagen del dispositivo Android para aumentar el desempeño.
 Para limitar el ancho y la altura a un valor específico (ej. 1024):
 ```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # versión breve
 ```
 La otra dimensión es calculada para conservar el aspect ratio del dispositivo.
 De esta forma, un dispositivo en 1920×1080 será transmitido a 1024×576.
 #### Cambiar el bit-rate
 El bit-rate por defecto es 8 Mbps. Para cambiar el bit-rate del video (ej. a 2 Mbps):
 ```bash
 scrcpy --bit-rate 2M
 scrcpy -b 2M  # versión breve
 ```
 #### Limitar los fps
 El fps puede ser limitado:
 ```bash
 scrcpy --max-fps 15
 ```
 Es oficialmente soportado desde Android 10, pero puede funcionar en versiones anteriores.
 #### Recortar
 La imagen del dispositivo puede ser recortada para transmitir solo una parte de la pantalla.
 Por ejemplo, puede ser útil para transmitir la imagen de un solo ojo del Oculus Go:
 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 con coordenadas de origen en (0,0)
 ```
 Si `--max-size` también está especificado, el cambio de tamaño es aplicado después de cortar.
 #### Fijar la rotación del video
 Para fijar la rotación de la transmisión:
 ```bash
 scrcpy --lock-video-orientation 0   # orientación normal
 scrcpy --lock-video-orientation 1   # 90° contrarreloj
 scrcpy --lock-video-orientation 2   # 180°
 scrcpy --lock-video-orientation 3   # 90° sentido de las agujas del reloj
 ```
 Esto afecta la rotación de la grabación.
 La [ventana también puede ser rotada](#rotación) independientemente.
 #### Codificador
 Algunos dispositivos pueden tener más de una rotación, y algunos pueden causar problemas o errores. Es posible seleccionar un codificador diferente:
 ```bash
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```
 Para listar los codificadores disponibles, puedes pasar un nombre de codificador inválido, el error te dará los codificadores disponibles:
 ```bash
 scrcpy --encoder _
 ```
 ### Grabación
 Es posible grabar la pantalla mientras se transmite:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 Para grabar sin transmitir la pantalla:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrumpe la grabación con Ctrl+C
 ```
 "Skipped frames" son grabados, incluso si no son mostrados en tiempo real (por razones de desempeño). Los frames tienen _marcas de tiempo_ en el dispositivo, por lo que el "[packet delay
 variation]" no impacta el archivo grabado.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 ### Conexión
 #### Inalámbrica
 _Scrcpy_ usa `adb` para comunicarse con el dispositivo, y `adb` puede [conectarse] vía TCP/IP:
 1. Conecta el dispositivo al mismo Wi-Fi que tu computadora.
 2. Obtén la dirección IP del dispositivo, en Ajustes → Acerca del dispositivo → Estado, o ejecutando este comando:
    ```bash
    adb shell ip route | awk '{print $9}'
    ```
 3. Habilita adb vía TCP/IP en el dispositivo: `adb tcpip 5555`.
 4. Desenchufa el dispositivo.
 5. Conéctate a tu dispositivo: `adb connect IP_DEL_DISPOSITIVO:5555` _(reemplaza `IP_DEL_DISPOSITIVO`)_.
 6. Ejecuta `scrcpy` con normalidad.
 Podría resultar útil reducir el bit-rate y la definición:
 ```bash
 scrcpy --bit-rate 2M --max-size 800
 scrcpy -b2M -m800  # versión breve
 ```
 [conectarse]: https://developer.android.com/studio/command-line/adb.html#wireless
 #### Múltiples dispositivos
 Si hay muchos dispositivos listados en `adb devices`, será necesario especificar el _número de serie_:
 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # versión breve
 ```
 Si el dispositivo está conectado por TCP/IP:
 ```bash
 scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # versión breve
 ```
 Puedes iniciar múltiples instancias de _scrcpy_ para múltiples dispositivos.
 #### Autoiniciar al detectar dispositivo
 Puedes utilizar [AutoAdb]:
 ```bash
 autoadb scrcpy -s '{}'
 ```
 [AutoAdb]: https://github.com/rom1v/autoadb
 #### Túnel SSH
 Para conectarse a un dispositivo remoto, es posible conectar un cliente local de `adb` a un servidor remoto `adb` (siempre y cuando utilicen la misma versión de protocolos _adb_):
 ```bash
 adb kill-server    # cierra el servidor local adb en 5037
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # conserva este servidor abierto
 ```
 Desde otra terminal:
 ```bash
 scrcpy
 ```
 Para evitar habilitar "remote port forwarding", puedes forzar una "forward connection" (nótese el argumento `-L` en vez de `-R`):
 ```bash
 adb kill-server    # cierra el servidor local adb en 5037
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # conserva este servidor abierto
 ```
 Desde otra terminal:
 ```bash
 scrcpy --force-adb-forward
 ```
 Al igual que las conexiones inalámbricas, puede resultar útil reducir la calidad:
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### Configuración de la ventana
 #### Título
 Por defecto, el título de la ventana es el modelo del dispositivo. Puede ser modificado:
 ```bash
 scrcpy --window-title 'My device'
 ```
 #### Posición y tamaño
 La posición y tamaño inicial de la ventana puede ser especificado:
 ```bash
 scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 ```
 #### Sin bordes
 Para deshabilitar el diseño de la ventana:
 ```bash
 scrcpy --window-borderless
 ```
 #### Siempre adelante
 Para mantener la ventana de scrcpy siempre adelante:
 ```bash
 scrcpy --always-on-top
 ```
 #### Pantalla completa
 La aplicación puede ser iniciada en pantalla completa:
 ```bash
 scrcpy --fullscreen
 scrcpy -f  # versión breve
 ```
 Puede entrar y salir de la pantalla completa con la combinación <kbd>MOD</kbd>+<kbd>f</kbd>.
 #### Rotación
 Se puede rotar la ventana:
 ```bash
 scrcpy --rotation 1
 ```
 Los valores posibles son:
 - `0`: sin rotación
 - `1`: 90 grados contrarreloj
 - `2`: 180 grados
 - `3`: 90 grados en sentido de las agujas del reloj
 La rotación también puede ser modificada con la combinación de teclas <kbd>MOD</kbd>+<kbd>←</kbd> _(izquierda)_ y <kbd>MOD</kbd>+<kbd>→</kbd> _(derecha)_.
 Nótese que _scrcpy_ maneja 3 diferentes rotaciones:
 - <kbd>MOD</kbd>+<kbd>r</kbd> solicita al dispositivo cambiar entre vertical y horizontal (la aplicación en uso puede rechazarlo si no soporta la orientación solicitada).
 - [`--lock-video-orientation`](#fijar-la-rotación-del-video) cambia la rotación de la transmisión (la orientación del video enviado a la PC). Esto afecta a la grabación.
 - `--rotation` (o <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) rota solo el contenido de la imagen. Esto solo afecta a la imagen mostrada, no a la grabación.
 ### Otras opciones menores
 #### Solo lectura ("Read-only")
 Para deshabilitar los controles (todo lo que interactúe con el dispositivo: eventos del teclado, eventos del mouse, arrastrar y soltar archivos):
 ```bash
 scrcpy --no-control
 scrcpy -n  # versión breve
 ```
 #### Pantalla
 Si múltiples pantallas están disponibles, es posible elegir cual transmitir:
 ```bash
 scrcpy --display 1
 ```
 Los ids de las pantallas se pueden obtener con el siguiente comando:
 ```bash
 adb shell dumpsys display   # busque "mDisplayId=" en la respuesta
 ```
 La segunda pantalla solo puede ser manejada si el dispositivo cuenta con Android 10 (en caso contrario será transmitida en el modo solo lectura).
 #### Permanecer activo
 Para evitar que el dispositivo descanse después de un tiempo mientras está conectado:
 ```bash
 scrcpy --stay-awake
 scrcpy -w  # versión breve
 ```
 La configuración original se restaura al cerrar scrcpy.
 #### Apagar la pantalla
 Es posible apagar la pantalla mientras se transmite al iniciar con el siguiente comando:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S  # versión breve
 ```
 O presionando <kbd>MOD</kbd>+<kbd>o</kbd> en cualquier momento.
 Para volver a prenderla, presione <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
 En Android, el botón de `POWER` siempre prende la pantalla. Por conveniencia, si `POWER` es enviado vía scrcpy (con click-derecho o <kbd>MOD</kbd>+<kbd>p</kbd>), esto forzará a apagar la pantalla con un poco de atraso (en la mejor de las situaciones). El botón físico `POWER` seguirá prendiendo la pantalla.
 También puede resultar útil para evitar que el dispositivo entre en inactividad:
 ```bash
 scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw  # versión breve
 ```
 #### Renderizar frames vencidos
 Por defecto, para minimizar la latencia, _scrcpy_ siempre renderiza el último frame disponible decodificado, e ignora cualquier frame anterior.
 Para forzar el renderizado de todos los frames (a costo de posible aumento de latencia), use:
 ```bash
 scrcpy --render-expired-frames
 ```
 #### Mostrar clicks
 Para presentaciones, puede resultar útil mostrar los clicks físicos (en el dispositivo físicamente).
 Android provee esta opción en _Opciones para desarrolladores_.
 _Scrcpy_ provee una opción para habilitar esta función al iniciar la aplicación y restaurar el valor original al salir:
 ```bash
 scrcpy --show-touches
 scrcpy -t  # versión breve
 ```
 Nótese que solo muestra los clicks _físicos_ (con el dedo en el dispositivo).
 #### Desactivar protector de pantalla
 Por defecto, scrcpy no evita que el protector de pantalla se active en la computadora.
 Para deshabilitarlo:
 ```bash
 scrcpy --disable-screensaver
 ```
 ### Control
 #### Rotar pantalla del dispositivo
 Presione <kbd>MOD</kbd>+<kbd>r</kbd> para cambiar entre posición vertical y horizontal.
 Nótese que solo rotará si la aplicación activa soporta la orientación solicitada.
 #### Copiar y pegar
 Cuando que el portapapeles de Android cambia, automáticamente se sincroniza al portapapeles de la computadora.
 Cualquier shortcut con <kbd>Ctrl</kbd> es enviado al dispositivo. En particular:
 - <kbd>Ctrl</kbd>+<kbd>c</kbd> normalmente copia
 - <kbd>Ctrl</kbd>+<kbd>x</kbd> normalmente corta
 - <kbd>Ctrl</kbd>+<kbd>v</kbd> normalmente pega (después de la sincronización de portapapeles entre la computadora y el dispositivo)
 Esto normalmente funciona como es esperado.
 Sin embargo, este comportamiento depende de la aplicación en uso. Por ejemplo, _Termux_ envía SIGINT con <kbd>Ctrl</kbd>+<kbd>c</kbd>, y _K-9 Mail_ crea un nuevo mensaje.
 Para copiar, cortar y pegar, en tales casos (solo soportado en Android >= 7):
 - <kbd>MOD</kbd>+<kbd>c</kbd> inyecta `COPY`
 - <kbd>MOD</kbd>+<kbd>x</kbd> inyecta `CUT`
 - <kbd>MOD</kbd>+<kbd>v</kbd> inyecta `PASTE` (después de la sincronización de portapapeles entre la computadora y el dispositivo)
 Además, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permite inyectar el texto en el portapapeles de la computadora como una secuencia de teclas. Esto es útil cuando el componente no acepta pegado de texto (por ejemplo en _Termux_), pero puede romper caracteres no pertenecientes a ASCII.
 **AVISO:** Pegar de la computadora al dispositivo (tanto con <kbd>Ctrl</kbd>+<kbd>v</kbd> o <kbd>MOD</kbd>+<kbd>v</kbd>) copia el contenido al portapapeles del dispositivo. Como consecuencia, cualquier aplicación de Android puede leer su contenido. Debería evitar pegar contenido sensible (como contraseñas) de esta forma.
 Algunos dispositivos no se comportan como es esperado al establecer el portapapeles programáticamente. La opción `--legacy-paste` está disponible para cambiar el comportamiento de <kbd>Ctrl</kbd>+<kbd>v</kbd> y <kbd>MOD</kbd>+<kbd>v</kbd> para que también inyecten el texto del portapapeles de la computadora como una secuencia de teclas (de la misma forma que <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
 #### Pellizcar para zoom
 Para simular "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-y-mover_.
 Más precisamente, mantén <kbd>Ctrl</kbd> mientras presionas botón izquierdo. Hasta que no se suelte el botón, todos los movimientos del mouse cambiarán el tamaño y rotación del contenido (si es soportado por la app en uso) respecto al centro de la pantalla.
 Concretamente, scrcpy genera clicks adicionales con un "dedo virtual" en la posición invertida respecto al centro de la pantalla.
 #### Preferencias de inyección de texto
 Existen dos tipos de [eventos][textevents] generados al escribir texto:
 - _key events_, marcando si la tecla es presionada o soltada;
 - _text events_, marcando si un texto fue introducido.
 Por defecto, las letras son inyectadas usando _key events_, para que el teclado funcione como es esperado en juegos (típicamente las teclas WASD).
 Pero esto puede [causar problemas][prefertext]. Si encuentras tales problemas, los puedes evitar con:
 ```bash
 scrcpy --prefer-text
 ```
 (Pero esto romperá el comportamiento del teclado en los juegos)
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 #### Repetir tecla
 Por defecto, mantener una tecla presionada genera múltiples _key events_. Esto puede causar problemas de desempeño en algunos juegos, donde estos eventos no tienen sentido de todos modos.
 Para evitar enviar _key events_ repetidos:
 ```bash
 scrcpy --no-key-repeat
 ```
 #### Botón derecho y botón del medio
 Por defecto, botón derecho ejecuta RETROCEDER (o ENCENDIDO) y botón del medio INICIO. Para inhabilitar estos atajos y enviar los clicks al dispositivo:
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### Arrastrar y soltar archivos
 #### Instalar APKs
 Para instalar un APK, arrastre y suelte el archivo APK (terminado en `.apk`) a la ventana de _scrcpy_.
 No hay respuesta visual, un mensaje se escribirá en la consola.
 #### Enviar archivos al dispositivo
 Para enviar un archivo a `/sdcard/` en el dispositivo, arrastre y suelte un archivo (no APK) a la ventana de _scrcpy_.
 No hay respuesta visual, un mensaje se escribirá en la consola.
 El directorio de destino puede ser modificado al iniciar:
 ```bash
 scrcpy --push-target=/sdcard/Download/
 ```
 ### Envío de Audio
 _Scrcpy_ no envía el audio. Use [sndcpy].
 También lea [issue #14].
 [sndcpy]: https://github.com/rom1v/sndcpy
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## Atajos
 En la siguiente lista, <kbd>MOD</kbd> es el atajo modificador. Por defecto es <kbd>Alt</kbd> (izquierdo) o <kbd>Super</kbd> (izquierdo).
 Se puede modificar usando `--shortcut-mod`. Las posibles teclas son `lctrl` (izquierdo), `rctrl` (derecho), `lalt` (izquierdo), `ralt` (derecho), `lsuper` (izquierdo) y `rsuper` (derecho). Por ejemplo:
 ```bash
 # use RCtrl para los atajos
 scrcpy --shortcut-mod=rctrl
 # use tanto LCtrl+LAlt o LSuper para los atajos
 scrcpy --shortcut-mod=lctrl+lalt,lsuper
 ```
 _<kbd>[Super]</kbd> es generalmente la tecla <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
 [Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
 | Acción                                      |   Atajo
 | ------------------------------------------- |:-----------------------------
 | Alterne entre pantalla compelta             | <kbd>MOD</kbd>+<kbd>f</kbd>
 | Rotar pantalla hacia la izquierda           | <kbd>MOD</kbd>+<kbd>←</kbd> _(izquierda)_
 | Rotar pantalla hacia la derecha             | <kbd>MOD</kbd>+<kbd>→</kbd> _(derecha)_
 | Ajustar ventana a 1:1 ("pixel-perfect")     | <kbd>MOD</kbd>+<kbd>g</kbd>
 | Ajustar ventana para quitar los bordes negros| <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doble click¹_
 | Click en `INICIO`                           | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Botón del medio_
 | Click en `RETROCEDER`                       | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Botón derecho²_
 | Click en `CAMBIAR APLICACIÓN`               | <kbd>MOD</kbd>+<kbd>s</kbd>
 | Click en `MENÚ` (desbloquear pantalla)      | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Click en `SUBIR VOLUMEN`                    | <kbd>MOD</kbd>+<kbd>↑</kbd> _(arriba)_
 | Click en `BAJAR VOLUME`                     | <kbd>MOD</kbd>+<kbd>↓</kbd> _(abajo)_
 | Click en `ENCENDIDO`                        | <kbd>MOD</kbd>+<kbd>p</kbd>
 | Encendido                                   | _Botón derecho²_
 | Apagar pantalla (manteniendo la transmisión)| <kbd>MOD</kbd>+<kbd>o</kbd>
 | Encender pantalla                           | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Rotar pantalla del dispositivo              | <kbd>MOD</kbd>+<kbd>r</kbd>
 | Abrir panel de notificaciones               | <kbd>MOD</kbd>+<kbd>n</kbd>
 | Cerrar panel de notificaciones              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | Copiar al portapapeles³                     | <kbd>MOD</kbd>+<kbd>c</kbd>
 | Cortar al portapapeles³                     | <kbd>MOD</kbd>+<kbd>x</kbd>
 | Synchronizar portapapeles y pegar³          | <kbd>MOD</kbd>+<kbd>v</kbd>
 | inyectar texto del portapapeles de la PC    | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Habilitar/Deshabilitar contador de FPS (en stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
 | Pellizcar para zoom                         | <kbd>Ctrl</kbd>+_click-y-mover_
 _¹Doble click en los bordes negros para eliminarlos._  
 _²Botón derecho enciende la pantalla si estaba apagada, sino ejecuta RETROCEDER._  
 _³Solo en Android >= 7._
 Todos los atajos <kbd>Ctrl</kbd>+_tecla_ son enviados al dispositivo para que sean manejados por la aplicación activa.
 ## Path personalizado
 Para usar un binario de _adb_ en particular, configure el path `ADB` en las variables de entorno:
 ```bash
 ADB=/path/to/adb scrcpy
 ```
 Para sobreescribir el path del archivo `scrcpy-server`, configure el path en `SCRCPY_SERVER_PATH`.
 ## ¿Por qué _scrcpy_?
 Un colega me retó a encontrar un nombre tan impronunciable como [gnirehtet].
 [`strcpy`] copia un **str**ing; `scrcpy` copia un **scr**een.
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## ¿Cómo construir (BUILD)?
 Véase [BUILD] (en inglés).
 ## Problemas generales
 Vea las [preguntas frecuentes (en inglés)](FAQ.md).
 ## Desarrolladores
 Lea la [hoja de desarrolladores (en inglés)](DEVELOP.md).
 ## Licencia
    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.
 ## Artículos
 - [Introducing scrcpy][article-intro] (en inglés)
 - [Scrcpy now works wirelessly][article-tcpip] (en inglés)
 [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/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/README.zh-Hans.md
+++ b/README.zh-Hans.md
@@ -2,41 +2,27 @@ _Only the original [README](README.md) is guaranteed to be up-to-date._
 只有原版的[README](README.md)会保持最新。
-Current version is based on [65b023a]
+本文根据[ed130e05]进行翻译。
-本文根据[65b023a]进行翻译。
+[ed130e05]: https://github.com/Genymobile/scrcpy/blob/ed130e05d55615d6014d93f15cfcb92ad62b01d8/README.md
-[65b023a]: https://github.com/Genymobile/scrcpy/blob/65b023ac6d586593193fd5290f65e25603b68e02/README.md
+# scrcpy (v1.17)
 # scrcpy (v1.20)
 <img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
 本应用程序可以显示并控制通过 USB (或 [TCP/IP][article-tcpip]) 连接的安卓设备，且不需要任何 _root_ 权限。本程序支持 _GNU/Linux_, _Windows_ 和 _macOS_。
 ![screenshot](assets/screenshot-debian-600.jpg)
-本应用专注于：
+它专注于：
- - **轻量**： 原生，仅显示设备屏幕
+ - **轻量** (原生，仅显示设备屏幕)
- - **性能**： 30~120fps，取决于设备
+ - **性能** (30~60fps)
- - **质量**： 分辨率可达 1920×1080 或更高
+ - **质量** (分辨率可达 1920×1080 或更高)
- - **低延迟**： [35~70ms][lowlatency]
+ - **低延迟** ([35~70ms][lowlatency])
- - **快速启动**： 最快 1 秒内即可显示第一帧
+ - **快速启动** (最快 1 秒内即可显示第一帧)
- - **无侵入性**： 不会在设备上遗留任何程序
+ - **无侵入性** (不会在设备上遗留任何程序)
 - **用户利益**： 无需帐号，无广告，无需联网
 - **自由**： 自由和开源软件
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 功能：
 - [屏幕录制](#屏幕录制)
 - 镜像时[关闭设备屏幕](#关闭设备屏幕)
 - 双向[复制粘贴](#复制粘贴)
 - [可配置显示质量](#采集设置)
 - 以设备屏幕[作为摄像头(V4L2)](#v4l2loopback) (仅限 Linux)
 - [模拟物理键盘 (HID)](#物理键盘模拟-hid) (仅限 Linux)
 - 更多 ……
 ## 系统要求
@@ -55,17 +41,6 @@ Current version is based on [65b023a]
 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
 ### 概要
 - Linux: `apt install scrcpy`
 - Windows: [下载][direct-win64]
 - macOS: `brew install scrcpy`
 从源代码编译: [构建][BUILD] ([简化过程][BUILD_simple])
 [BUILD]: BUILD.md
 [BUILD_simple]: BUILD.md#simple
 ### Linux
 在 Debian (目前仅支持 _testing_ 和 _sid_ 分支) 和Ubuntu (20.04) 上：
@@ -95,12 +70,13 @@ apt install scrcpy
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-您也可以[自行构建][BUILD] ([简化过程][BUILD_simple])。
+您也可以[自行构建][BUILD] (不必担心，这并不困难)。
 ### Windows
-在 Windows 上，为简便起见，我们提供包含了所有依赖 (包括 `adb`) 的预编译包。
+在 Windows 上，简便起见，我们提供包含了所有依赖 (包括 `adb`) 的预编译包。
 - [README](README.md#windows)
@@ -138,17 +114,13 @@ brew install scrcpy
 你还需要在 `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
 ```
 或者通过 [MacPorts]，该方法同时设置好 adb：
 ```bash
 sudo port install scrcpy
 ```
 [MacPorts]: https://www.macports.org/
 您也可以[自行构建][BUILD]。
@@ -168,7 +140,7 @@ scrcpy --help
 ## 功能介绍
-### 采集设置
+### 捕获设置
 #### 降低分辨率
@@ -186,7 +158,7 @@ scrcpy -m 1024  # 简写
 #### 修改码率
-默认码率是 8 Mbps。改变视频码率 (例如改为 2 Mbps)：
+默认码率是 8Mbps。要改变视频的码率 (例如改为 2Mbps)：
 ```bash
 scrcpy --bit-rate 2M
@@ -195,7 +167,7 @@ scrcpy -b 2M  # 简写
 #### 限制帧率
-要限制采集的帧率：
+要限制捕获的帧率：
 ```bash
 scrcpy --max-fps 15
@@ -222,11 +194,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°
 ```
 只影响录制的方向。
@@ -248,9 +219,7 @@ scrcpy --encoder OMX.qcom.video.encoder.avc
 scrcpy --encoder _
 ```
-### 采集
+### 屏幕录制
 #### 屏幕录制
 可以在镜像的同时录制视频：
@@ -272,75 +241,6 @@ scrcpy -Nr file.mkv
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 #### v4l2loopback
 在 Linux 上，可以将视频流发送至 v4l2 回环 (loopback) 设备，因此可以使用任何 v4l2 工具像摄像头一样打开安卓设备。
 需安装 `v4l2loopback` 模块：
 ```bash
 sudo apt install v4l2loopback-dkms
 ```
 创建一个 v4l2 设备：
 ```bash
 sudo modprobe v4l2loopback
 ```
 这样会在 `/dev/videoN` 创建一个新的视频设备，其中 `N` 是整数。 ([更多选项](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/
 #### 缓冲
 可以加入缓冲，会增加延迟，但可以减少抖动 (见 [#2464])。
 [#2464]: https://github.com/Genymobile/scrcpy/issues/2464
 对于显示缓冲：
 ```bash
 scrcpy --display-buffer=50  # 为显示增加 50 毫秒的缓冲
 ```
 对于 V4L2 漏:
 ```bash
 scrcpy --v4l2-buffer=500    # 为 v4l2 漏增加 500 毫秒的缓冲
 ```
 ### 连接
 #### 无线
@@ -349,17 +249,16 @@ _Scrcpy_ 使用 `adb` 与设备通信，并且 `adb` 支持通过 TCP/IP [连接
 1. 将设备和电脑连接至同一 Wi-Fi。
 2. 打开 设置 → 关于手机 → 状态信息，获取设备的 IP 地址，也可以执行以下的命令：
    ```bash
    adb shell ip route | awk '{print $9}'
    ```
-3. 启用设备的网络 adb 功能： `adb tcpip 5555`。
+3. 启用设备的网络 adb 功能 `adb tcpip 5555`。
 4. 断开设备的 USB 连接。
-5. 连接到您的设备：`adb connect DEVICE_IP:5555` _(将 `DEVICE_IP` 替换为设备 IP)_。
+5. 连接到您的设备：`adb connect DEVICE_IP:5555` _(将 `DEVICE_IP` 替换为设备 IP)_.
 6. 正常运行 `scrcpy`。
-可能降低码率和分辨率会更好一些：
+可能需要降低码率和分辨率：
 ```bash
 scrcpy --bit-rate 2M --max-size 800
@@ -428,7 +327,7 @@ scrcpy --force-adb-forward
 ```
-类似地，对于无线连接，可能需要降低画面质量：
+类似无线网络连接，可能需要降低画面质量：
 ```
 scrcpy -b2M -m800 --max-fps 15
@@ -454,7 +353,7 @@ scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 #### 无边框
-禁用窗口边框：
+关闭边框：
 ```bash
 scrcpy --window-borderless
@@ -495,7 +394,7 @@ scrcpy --rotation 1
 也可以使用 <kbd>MOD</kbd>+<kbd>←</kbd> _(左箭头)_ 和 <kbd>MOD</kbd>+<kbd>→</kbd> _(右箭头)_ 随时更改。
-需要注意的是， _scrcpy_ 中有三类旋转方向：
+需要注意的是， _scrcpy_ 有三个不同的方向：
 - <kbd>MOD</kbd>+<kbd>r</kbd> 请求设备在竖屏和横屏之间切换 (如果前台应用程序不支持请求的朝向，可能会拒绝该请求)。
 - [`--lock-video-orientation`](#锁定屏幕方向) 改变镜像的朝向 (设备传输到电脑的画面的朝向)。这会影响录制。
 - `--rotation` (或 <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) 只旋转窗口的内容。这只影响显示，不影响录制。
@@ -505,7 +404,7 @@ scrcpy --rotation 1
 #### 只读
-禁用电脑对设备的控制 (任何可与设备交互的方式：如键盘输入、鼠标事件和文件拖放)：
+禁用电脑对设备的控制 (如键盘输入、鼠标事件和文件拖放)：
 ```bash
 scrcpy --no-control
@@ -531,14 +430,14 @@ adb shell dumpsys display   # 在输出中搜索 “mDisplayId=”
 #### 保持常亮
-阻止设备在连接时一段时间后休眠：
+阻止设备在连接时休眠：
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
-scrcpy 关闭时会恢复设备原来的设置。
+程序关闭时会恢复设备原来的设置。
 #### 关闭设备屏幕
@@ -552,7 +451,7 @@ scrcpy -S
 或者在任何时候按 <kbd>MOD</kbd>+<kbd>o</kbd>。
-要重新打开屏幕，按下 <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>。
+要重新打开屏幕，按下 <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
 在Android上，`电源` 按钮始终能把屏幕打开。为了方便，对于在 _scrcpy_ 中发出的 `电源` 事件 (通过鼠标右键或 <kbd>MOD</kbd>+<kbd>p</kbd>)，会 (尽最大的努力) 在短暂的延迟后将屏幕关闭。设备上的 `电源` 按钮仍然能打开设备屏幕。
@@ -563,17 +462,20 @@ scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
 #### 退出时息屏
-scrcpy 退出时关闭设备屏幕：
+#### 渲染过期帧
 默认状态下，为了降低延迟， _scrcpy_ 永远渲染解码成功的最近一帧，并跳过前面任意帧。
 强制渲染所有帧 (可能导致延迟变高)：
 ```bash
-scrcpy --power-off-on-close
+scrcpy --render-expired-frames
 ```
 #### 显示触摸
-在演示时，可能会需要显示 (在物理设备上的) 物理触摸点。
+在演示时，可能会需要显示物理触摸点 (在物理设备上的触摸点)。
 Android 在 _开发者选项_ 中提供了这项功能。
@@ -636,32 +538,10 @@ scrcpy --disable-screensaver
 更准确的说，在按住鼠标左键时按住 <kbd>Ctrl</kbd>。直到松开鼠标左键，所有鼠标移动将以屏幕中心为原点，缩放或旋转内容 (如果应用支持)。
-实际上，_scrcpy_ 会在关于屏幕中心对称的位置上用“虚拟手指”发出触摸事件。
+实际上，_scrcpy_ 会在以屏幕中心对称的位置上生成由“虚拟手指”发出的额外触摸事件。
 #### 物理键盘模拟 (HID)
-默认情况下，scrcpy 使用安卓按键或文本注入，这在任何情况都可以使用，但仅限于ASCII字符。
+#### 文字注入偏好
 在 Linux 上，scrcpy 可以模拟为 Android 上的物理 USB 键盘，以提供更好地输入体验 (使用 [USB HID over AOAv2][hid-aoav2])：禁用虚拟键盘，并适用于任何字符和输入法。
 [hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
 不过，这种方法仅支持 USB 连接以及 Linux平台。
 启用 HID 模式：
 ```bash
 scrcpy --hid-keyboard
 scrcpy -K  # 简写
 ```
 如果失败了 (如设备未通过 USB 连接)，则自动回退至默认模式 (终端中会输出日志)。这即允许通过 USB 和 TCP/IP 连接时使用相同的命令行参数。
 在这种模式下，原始按键事件 (扫描码) 被发送给设备，而与宿主机按键映射无关。因此，若键盘布局不匹配，需要在 Android 设备上进行配置，具体为 设置 → 系统 → 语言和输入法 → [实体键盘]。
 [Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
 #### 文本注入偏好
 打字的时候，系统会产生两种[事件][textevents]：
 - _按键事件_ ，代表一个按键被按下或松开。
@@ -677,15 +557,13 @@ scrcpy --prefer-text
 (这会导致键盘在游戏中工作不正常)
 该选项不影响 HID 键盘 (该模式下，所有按键都发送为扫描码)。
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 #### 按键重复
-默认状态下，按住一个按键不放会生成多个重复按键事件。在某些游戏中这通常没有实际用途，且可能会导致性能问题。
+默认状态下，按住一个按键不放会生成多个重复按键事件。在某些游戏中这可能会导致性能问题。
 避免转发重复按键事件：
@@ -693,11 +571,10 @@ scrcpy --prefer-text
 scrcpy --no-key-repeat
 ```
 该选项不影响 HID 键盘 (该模式下，按键重复由 Android 直接管理)。
 #### 右键和中键
-默认状态下，右键会触发返回键 (或电源键开启)，中键会触发 HOME 键。要禁用这些快捷键并把所有点击转发到设备：
+默认状态下，右键会触发返回键 (或电源键)，中键会触发 HOME 键。要禁用这些快捷键并把所有点击转发到设备：
 ```bash
 scrcpy --forward-all-clicks
@@ -710,27 +587,27 @@ scrcpy --forward-all-clicks
 将 APK 文件 (文件名以 `.apk` 结尾) 拖放到 _scrcpy_ 窗口来安装。
-不会有视觉反馈，终端会输出一条日志。
+该操作在屏幕上不会出现任何变化，而会在控制台输出一条日志。
 #### 将文件推送至设备
-要推送文件到设备的 `/sdcard/Download/`，将 (非 APK) 文件拖放至 _scrcpy_ 窗口。
+要推送文件到设备的 `/sdcard/`，将 (非 APK) 文件拖放至 _scrcpy_ 窗口。
-不会有视觉反馈，终端会输出一条日志。
+该操作没有可见的响应，只会在控制台输出日志。
 在启动时可以修改目标目录：
 ```bash
-scrcpy --push-target=/sdcard/Movies/
+scrcpy --push-target /sdcard/foo/bar/
 ```
 ### 音频转发
-_Scrcpy_ 不支持音频。请使用 [sndcpy]。
+_Scrcpy_ 不支持音频。请使用 [sndcpy].
-另见 [issue #14]。
+另外请阅读 [issue #14]。
 [sndcpy]: https://github.com/rom1v/sndcpy
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
@@ -755,46 +632,36 @@ _<kbd>[Super]</kbd> 键通常是指 <kbd>Windows</kbd> 或 <kbd>Cmd</kbd> 键。
 [Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
- | 操作                              | 快捷键
+ | 操作                              | 快捷键                                       |
- | --------------------------------- | :-------------------------------------------
+ | --------------------------------- | :------------------------------------------- |
- | 全屏                              | <kbd>MOD</kbd>+<kbd>f</kbd>
+ | 全屏                              | <kbd>MOD</kbd>+<kbd>f</kbd>                  |
- | 向左旋转屏幕                      | <kbd>MOD</kbd>+<kbd>←</kbd> _(左箭头)_
+ | 向左旋转屏幕                      | <kbd>MOD</kbd>+<kbd>←</kbd> _(左箭头)_       |
- | 向右旋转屏幕                      | <kbd>MOD</kbd>+<kbd>→</kbd> _(右箭头)_
+ | 向右旋转屏幕                      | <kbd>MOD</kbd>+<kbd>→</kbd> _(右箭头)_       |
- | 将窗口大小重置为1:1 (匹配像素)    | <kbd>MOD</kbd>+<kbd>g</kbd>
+ | 将窗口大小重置为1:1 (匹配像素)    | <kbd>MOD</kbd>+<kbd>g</kbd>                  |
- | 将窗口大小重置为消除黑边          | <kbd>MOD</kbd>+<kbd>w</kbd> \| _双击左键¹_
+ | 将窗口大小重置为消除黑边          | <kbd>MOD</kbd>+<kbd>w</kbd> \| _双击¹_       |
- | 点按 `主屏幕`                     | <kbd>MOD</kbd>+<kbd>h</kbd> \| _中键_
+ | 点按 `主屏幕`                     | <kbd>MOD</kbd>+<kbd>h</kbd> \| _鼠标中键_    |
- | 点按 `返回`                       | <kbd>MOD</kbd>+<kbd>b</kbd> \| _右键²_
+ | 点按 `返回`                       | <kbd>MOD</kbd>+<kbd>b</kbd> \| _鼠标右键²_   |
- | 点按 `切换应用`                   | <kbd>MOD</kbd>+<kbd>s</kbd> \| _第4键³_
+ | 点按 `切换应用`                   | <kbd>MOD</kbd>+<kbd>s</kbd>                  |
- | 点按 `菜单` (解锁屏幕)            | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | 点按 `菜单` (解锁屏幕)            | <kbd>MOD</kbd>+<kbd>m</kbd>                  |
- | 点按 `音量+`                      | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上箭头)_
+ | 点按 `音量+`                      | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上箭头)_       |
- | 点按 `音量-`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下箭头)_
+ | 点按 `音量-`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下箭头)_       |
- | 点按 `电源`                       | <kbd>MOD</kbd>+<kbd>p</kbd>
+ | 点按 `电源`                       | <kbd>MOD</kbd>+<kbd>p</kbd>                  |
- | 打开屏幕                          | _鼠标右键²_
+ | 打开屏幕                          | _鼠标右键²_                                  |
- | 关闭设备屏幕 (但继续在电脑上显示) | <kbd>MOD</kbd>+<kbd>o</kbd>
+ | 关闭设备屏幕 (但继续在电脑上显示) | <kbd>MOD</kbd>+<kbd>o</kbd>                  |
- | 打开设备屏幕                      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
+ | 打开设备屏幕                      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd> |
- | 旋转设备屏幕                      | <kbd>MOD</kbd>+<kbd>r</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>Shift</kbd>+<kbd>n</kbd>
+ | 复制到剪贴板³                     | <kbd>MOD</kbd>+<kbd>c</kbd>                  |
- | 复制到剪贴板⁴                     | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | 剪切到剪贴板³                     | <kbd>MOD</kbd>+<kbd>x</kbd>                  |
- | 剪切到剪贴板⁴                     | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | 同步剪贴板并粘贴³                 | <kbd>MOD</kbd>+<kbd>v</kbd>                  |
- | 同步剪贴板并粘贴⁴                 | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | 注入电脑剪贴板文本                | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> |
- | 注入电脑剪贴板文本                | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
+ | 打开/关闭FPS显示 (在 stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>                  |
- | 打开/关闭FPS显示 (至标准输出)     | <kbd>MOD</kbd>+<kbd>i</kbd>
+ | 捏拉缩放                          | <kbd>Ctrl</kbd>+_按住并移动鼠标_             |
 | 捏拉缩放                          | <kbd>Ctrl</kbd>+_按住并移动鼠标_
 | 拖放 APK 文件                     | 从电脑安装 APK 文件
 | 拖放非 APK 文件                   | [将文件推送至设备](#push-file-to-device)
-_¹双击黑边可以去除黑边。_  
+_¹双击黑边可以去除黑边_
 _²点击鼠标右键将在屏幕熄灭时点亮屏幕，其余情况则视为按下返回键 。_
-_³鼠标的第4键和第5键。_  
+_³需要安卓版本 Android >= 7。_
 _⁴需要安卓版本 Android >= 7。_
 有重复按键的快捷键通过松开再按下一个按键来进行，如“展开设置面板”：
 1. 按下 <kbd>MOD</kbd> 不放。
 2. 双击 <kbd>n</kbd>。
 3. 松开 <kbd>MOD</kbd>。
 所有的 <kbd>Ctrl</kbd>+_按键_ 的快捷键都会被转发到设备，所以会由当前应用程序进行处理。
@@ -803,20 +670,18 @@ _⁴需要安卓版本 Android >= 7。_
 要使用指定的 _adb_ 二进制文件，可以设置环境变量 `ADB`：
 ```bash
    ADB=/path/to/adb scrcpy
 ```
 要覆盖 `scrcpy-server` 的路径，可以设置 `SCRCPY_SERVER_PATH`。
-要覆盖图标，可以设置其路径至 `SCRCPY_ICON_PATH`。
+[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## 为什么叫 _scrcpy_ ？
 一个同事让我找出一个和 [gnirehtet] 一样难以发音的名字。
-[`strcpy`] 复制一个 **str**ing （字符串）； `scrcpy` 复制一个 **scr**een （屏幕）。
+[`strcpy`] 复制一个 **str**ing； `scrcpy` 复制一个 **scr**een。
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
@@ -826,6 +691,8 @@ ADB=/path/to/adb scrcpy
 请查看[BUILD]。
 [BUILD]: BUILD.md
 ## 常见问题
--- a/app/meson.build
+++ b/app/meson.build
@@ -1,70 +1,35 @@
 src = [
    'src/main.c',
    'src/adb.c',
    'src/adb_parser.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/intmap.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()
 conf.set('_POSIX_C_SOURCE', '200809L')
 conf.set('_XOPEN_SOURCE', '700')
 conf.set('_GNU_SOURCE', true)
 if host_machine.system() == 'windows'
-    windows = import('windows')
+    src += [ 'src/sys/win/process.c' ]
    src += [
        'src/sys/win/file.c',
        'src/sys/win/process.c',
        windows.compile_resources('scrcpy-windows.rc'),
    ]
    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',
    ]
    if host_machine.system() == 'darwin'
        conf.set('_DARWIN_C_SOURCE', true)
    endif
 endif
 v4l2_support = host_machine.system() == 'linux'
@@ -72,38 +37,28 @@ if v4l2_support
    src += [ 'src/v4l2_sink.c' ]
 endif
-aoa_hid_support = host_machine.system() == 'linux'
+check_functions = [
-if aoa_hid_support
+    'strdup'
    src += [
        'src/aoa_hid.c',
        'src/hid_keyboard.c',
        'src/hid_mouse.c',
 ]
 endif
 cc = meson.get_compiler('c')
-crossbuild_windows = meson.is_cross_build() and host_machine.system() == 'windows'
+if not get_option('crossbuild_windows')
 if not crossbuild_windows
    # native build
    dependencies = [
-        dependency('libavformat', version: '>= 57.33'),
+        dependency('libavformat'),
-        dependency('libavcodec', version: '>= 57.37'),
+        dependency('libavcodec'),
        dependency('libavutil'),
-        dependency('sdl2', version: '>= 2.0.5'),
+        dependency('sdl2'),
    ]
    if v4l2_support
        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'
@@ -143,11 +98,7 @@ if host_machine.system() == 'windows'
    dependencies += cc.find_library('ws2_32')
 endif
-check_functions = [
+conf = configuration_data()
    'strdup',
    'asprintf',
    'vasprintf',
 ]
 foreach f : check_functions
  if cc.has_function(f)
@@ -156,9 +107,6 @@ foreach f : check_functions
  endif
 endforeach
 conf.set('HAVE_SOCK_CLOEXEC', host_machine.system() != 'windows' and
                              cc.has_header_symbol('sys/socket.h', 'SOCK_CLOEXEC'))
 # the version, updated on release
 conf.set_quoted('SCRCPY_VERSION', meson.project_version())
@@ -187,9 +135,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')
@@ -201,9 +146,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
@@ -211,14 +153,8 @@ install_data('../data/icon.png',
 # do not build tests in release (assertions would not be executed at all)
 if get_option('buildtype') == 'debug'
    tests = [
        ['test_adb_parser', [
            'tests/test_adb_parser.c',
            'src/adb_parser.c',
            'src/util/str.c',
            'src/util/strbuf.c',
        ]],
        ['test_buffer_util', [
-            'tests/test_buffer_util.c',
+            'tests/test_buffer_util.c'
        ]],
        ['test_cbuf', [
            'tests/test_cbuf.c',
@@ -226,21 +162,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',
@@ -249,14 +176,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-windows.manifest
+++ b/app/scrcpy-windows.manifest
@@ -1,9 +0,0 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
  <asmv3:application>
    <asmv3:windowsSettings>
      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
    </asmv3:windowsSettings>
  </asmv3:application>
 </assembly>
--- a/app/scrcpy-windows.rc
+++ b/app/scrcpy-windows.rc
@@ -1,23 +0,0 @@
 #include <winuser.h>
 0 ICON "../data/icon.ico"
 1 RT_MANIFEST "scrcpy-windows.manifest"
 2 VERSIONINFO
 BEGIN
  BLOCK "StringFileInfo"
  BEGIN
    BLOCK "040904E4"
    BEGIN
      VALUE "FileDescription", "Display and control your Android device"
      VALUE "InternalName", "scrcpy"
      VALUE "LegalCopyright", "Romain Vimont, Genymobile"
      VALUE "OriginalFilename", "scrcpy.exe"
      VALUE "ProductName", "scrcpy"
      VALUE "ProductVersion", "1.21"
    END
  END
  BLOCK "VarFileInfo"
  BEGIN
    VALUE "Translation", 0x409, 1252
  END
 END
--- 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,20 +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.
 The keyboard layout must be configured (once and for all) on the device, via Settings -> System -> Languages and input -> Physical keyboard. This settings page can be started directly:
    adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
 However, the option is only available when the HID keyboard is enabled (or a physical keyboard is connected).
 .TP
 .B \-\-legacy\-paste
 Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+Shift+v).
@@ -103,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".
@@ -120,12 +100,6 @@ Limit both the width and height of the video to \fIvalue\fR. The other dimension
 Default is 0 (unlimited).
 .TP
 .B \-\-no\-clipboard\-autosync
 By default, scrcpy automatically synchronizes the computer clipboard to the device clipboard before injecting Ctrl+v, and the device clipboard to the computer clipboard whenever it changes.
 This option disables this automatic synchronization.
 .TP
 .B \-n, \-\-no\-control
 Disable device control (mirror the device in read\-only).
@@ -148,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.
@@ -165,10 +135,6 @@ Set the target directory for pushing files to the device by drag & drop. It is p
 Default is "/sdcard/Download/".
 .TP
 .B \-\-raw\-key\-events
 Inject key events for all input keys, and ignore text events.
 .TP
 .BI "\-r, \-\-record " file
 Record screen to
@@ -209,14 +175,6 @@ For example, to use either LCtrl+LAlt or LSuper for scrcpy shortcuts, pass "lctr
 Default is "lalt,lsuper" (left-Alt or left-Super).
 .TP
 .BI "\-\-tcpip[=ip[:port]]
 Configure and reconnect the device over TCP/IP.
 If a destination address is provided, then scrcpy connects to this address before starting. The device must listen on the given TCP port (default is 5555).
 If no destination address is provided, then scrcpy attempts to find the IP address of the current device (typically connected over USB), enables TCP/IP mode, then connects to this address before starting.
 .TP
 .B \-S, \-\-turn\-screen\-off
 Turn the device screen off immediately.
@@ -227,35 +185,15 @@ 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
-Set the log level ("verbose", "debug", "info", "warn" or "error").
+Set the log level ("debug", "info", "warn" or "error").
 Default is "info" for release builds, "debug" for debug builds.
@@ -302,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
@@ -404,24 +342,16 @@ 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
 .TP
 .B ADB
-Path to adb.
+Specify the path to adb.
 .TP
 .B SCRCPY_ICON_PATH
 Path to the program icon.
 .TP
 .B SCRCPY_SERVER_PATH
-Path to the server binary.
+Specify the path to server binary.
 .SH AUTHORS
@@ -446,7 +376,7 @@ Copyright \(co 2018 Genymobile
 Genymobile
 .UE
-Copyright \(co 2018\-2021
+Copyright \(co 2018\-2020
 .MT rom@rom1v.com
 Romain Vimont
 .ME
--- a/app/src/adb.c
+++ b/app/src/adb.c
@@ -5,11 +5,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include "adb_parser.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;
@@ -71,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;
        }
@@ -83,389 +80,132 @@ 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[512];
    char *buf = malloc(MAX_COMMAND_STRING_LEN);
    if (!buf) {
        LOG_OOM();
        LOGE("Failed to execute");
        return;
    }
    switch (err) {
-        case SC_PROCESS_ERROR_GENERIC:
+        case PROCESS_ERROR_GENERIC:
-            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
+            argv_to_string(argv, buf, sizeof(buf));
            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);
+            argv_to_string(argv, buf, sizeof(buf));
            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;
    }
    free(buf);
 }
-static bool
+process_t
-process_check_success_internal(sc_pid pid, const char *name, bool close,
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
-                               unsigned flags) {
+    const char *cmd[len + 4];
    bool log_errors = !(flags & SC_ADB_NO_LOGERR);
    if (pid == SC_PROCESS_NONE) {
        if (log_errors) {
            LOGE("Could not execute \"%s\"", name);
        }
        return false;
    }
    sc_exit_code exit_code = sc_process_wait(pid, close);
    if (exit_code) {
        if (log_errors) {
            if (exit_code != SC_EXIT_CODE_NONE) {
                LOGE("\"%s\" returned with value %" SC_PRIexitcode, name,
                     exit_code);
            } else {
                LOGE("\"%s\" exited unexpectedly", name);
            }
        }
        return false;
    }
    return true;
 }
 static bool
 process_check_success_intr(struct sc_intr *intr, sc_pid pid, const char *name,
                           unsigned flags) {
    if (!sc_intr_set_process(intr, pid)) {
        // Already interrupted
        return false;
    }
    // Always pass close=false, interrupting would be racy otherwise
    bool ret = process_check_success_internal(pid, name, false, flags);
    sc_intr_set_process(intr, SC_PROCESS_NONE);
    // Close separately
    sc_process_close(pid);
    return ret;
 }
 static const char **
 adb_create_argv(const char *serial, const char *const adb_cmd[], size_t len) {
    const char **argv = malloc((len + 4) * sizeof(*argv));
    if (!argv) {
        LOG_OOM();
        return NULL;
    }
    argv[0] = get_adb_command();
    int i;
    process_t process;
    cmd[0] = get_adb_command();
    if (serial) {
-        argv[1] = "-s";
+        cmd[1] = "-s";
-        argv[2] = serial;
+        cmd[2] = serial;
        i = 3;
    } else {
        i = 1;
    }
-    memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
+    memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
-    argv[len + i] = NULL;
+    cmd[len + i] = NULL;
-    return argv;
+    enum process_result r = process_execute(cmd, &process);
    if (r != PROCESS_SUCCESS) {
        show_adb_err_msg(r, cmd);
        return PROCESS_NONE;
    }
    return process;
 }
-static sc_pid
+process_t
-adb_execute_p(const char *serial, const char *const adb_cmd[], size_t len,
+adb_forward(const char *serial, uint16_t local_port,
-              unsigned flags, sc_pipe *pout) {
+            const char *device_socket_name) {
    const char **argv = adb_create_argv(serial, adb_cmd, len);
    if (!argv) {
        return SC_PROCESS_NONE;
    }
    unsigned process_flags = 0;
    if (flags & SC_ADB_NO_STDOUT) {
        process_flags |= SC_PROCESS_NO_STDOUT;
    }
    if (flags & SC_ADB_NO_STDERR) {
        process_flags |= SC_PROCESS_NO_STDERR;
    }
    sc_pid pid;
    enum sc_process_result r =
        sc_process_execute_p(argv, &pid, process_flags, NULL, pout, NULL);
    if (r != SC_PROCESS_SUCCESS) {
        // If the execution itself failed (not the command exit code), log the
        // error in all cases
        show_adb_err_msg(r, argv);
        pid = SC_PROCESS_NONE;
    }
    free(argv);
    return pid;
 }
 sc_pid
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
            unsigned flags) {
    return adb_execute_p(serial, adb_cmd, len, flags, NULL);
 }
 bool
 adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
            const char *device_socket_name, unsigned flags) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
    sprintf(local, "tcp:%" PRIu16, local_port);
    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
    const char *const adb_cmd[] = {"forward", local, remote};
-
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
    return process_check_success_intr(intr, pid, "adb forward", flags);
 }
-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, unsigned flags) {
    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));
    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
    return process_check_success_intr(intr, pid, "adb forward --remove", flags);
 }
-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) {
            unsigned flags) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
    sprintf(local, "tcp:%" PRIu16, local_port);
    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
    const char *const adb_cmd[] = {"reverse", remote, local};
-
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
    return process_check_success_intr(intr, pid, "adb reverse", flags);
 }
-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, unsigned flags) {
    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));
    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
    return process_check_success_intr(intr, pid, "adb reverse --remove", flags);
 }
-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, unsigned flags) {
 #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), flags);
+    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 #ifdef __WINDOWS__
    free((void *) remote);
    free((void *) local);
 #endif
-    return process_check_success_intr(intr, pid, "adb push", flags);
+    return proc;
 }
-bool
+process_t
-adb_install(struct sc_intr *intr, const char *serial, const char *local,
+adb_install(const char *serial, const char *local) {
            unsigned flags) {
 #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), flags);
+    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 #ifdef __WINDOWS__
    free((void *) local);
 #endif
-    return process_check_success_intr(intr, pid, "adb install", flags);
+    return proc;
 }
 bool
 adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
          unsigned flags) {
    char port_string[5 + 1];
    sprintf(port_string, "%" PRIu16, port);
    const char *const adb_cmd[] = {"tcpip", port_string};
    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
    return process_check_success_intr(intr, pid, "adb tcpip", flags);
 }
 bool
 adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
    const char *const adb_cmd[] = {"connect", ip_port};
    sc_pipe pout;
    sc_pid pid = adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), flags, &pout);
    if (pid == SC_PROCESS_NONE) {
        LOGE("Could not execute \"adb connect\"");
        return false;
    }
    // "adb connect" always returns successfully (with exit code 0), even in
    // case of failure. As a workaround, check if its output starts with
    // "connected".
    char buf[128];
    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
    sc_pipe_close(pout);
    bool ok = process_check_success_intr(intr, pid, "adb connect", flags);
    if (!ok) {
        return false;
    }
    if (r == -1) {
        return false;
    }
    ok = !strncmp("connected", buf, sizeof("connected") - 1);
    if (!ok && !(flags & SC_ADB_NO_STDERR)) {
        // "adb connect" also prints errors to stdout. Since we capture it,
        // re-print the error to stderr.
        sc_str_truncate(buf, r, "\r\n");
        fprintf(stderr, "%s\n", buf);
    }
    return ok;
 }
 bool
 adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
    const char *const adb_cmd[] = {"disconnect", ip_port};
    size_t len = ip_port ? ARRAY_LEN(adb_cmd)
                         : ARRAY_LEN(adb_cmd) - 1;
    sc_pid pid = adb_execute(NULL, adb_cmd, len, flags);
    return process_check_success_intr(intr, pid, "adb disconnect", flags);
 }
 char *
 adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
            unsigned flags) {
    const char *const adb_cmd[] = {"shell", "getprop", prop};
    sc_pipe pout;
    sc_pid pid =
        adb_execute_p(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags, &pout);
    if (pid == SC_PROCESS_NONE) {
        LOGE("Could not execute \"adb getprop\"");
        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 = process_check_success_intr(intr, pid, "adb getprop", flags);
    if (!ok) {
        return NULL;
    }
    if (r == -1) {
        return NULL;
    }
    sc_str_truncate(buf, r, " \r\n");
    return strdup(buf);
 }
 char *
 adb_get_serialno(struct sc_intr *intr, unsigned flags) {
    const char *const adb_cmd[] = {"get-serialno"};
    sc_pipe pout;
    sc_pid pid = adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), flags, &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 = process_check_success_intr(intr, pid, "adb get-serialno", flags);
    if (!ok) {
        return NULL;
    }
    if (r == -1) {
        return false;
    }
    sc_str_truncate(buf, r, " \r\n");
    return strdup(buf);
 }
 char *
 adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
    const char *const cmd[] = {"shell", "ip", "route"};
    sc_pipe pout;
    sc_pid pid = adb_execute_p(serial, cmd, ARRAY_LEN(cmd), flags, &pout);
    if (pid == SC_PROCESS_NONE) {
        LOGD("Could not execute \"ip route\"");
        return NULL;
    }
    // "adb shell ip route" output should contain only a few lines
    char buf[1024];
    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
    sc_pipe_close(pout);
    bool ok = process_check_success_intr(intr, pid, "ip route", flags);
    if (!ok) {
        return NULL;
    }
    if (r == -1) {
        return false;
    }
    assert((size_t) r <= sizeof(buf));
    if (r == sizeof(buf) && buf[sizeof(buf) - 1] != '\0')  {
        // The implementation assumes that the output of "ip route" fits in the
        // buffer in a single pass
        LOGW("Result of \"ip route\" does not fit in 1Kb. "
             "Please report an issue.\n");
        return NULL;
    }
    return sc_adb_parse_device_ip_from_output(buf, r);
 }
--- a/app/src/adb.h
+++ b/app/src/adb.h
@@ -6,89 +6,29 @@
 #include <stdbool.h>
 #include <inttypes.h>
-#include "util/intr.h"
+#include "util/process.h"
-#define SC_ADB_NO_STDOUT (1 << 0)
+process_t
-#define SC_ADB_NO_STDERR (1 << 1)
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
 #define SC_ADB_NO_LOGERR (1 << 2)
-#define SC_ADB_SILENT (SC_ADB_NO_STDOUT | SC_ADB_NO_STDERR | SC_ADB_NO_LOGERR)
+process_t
 adb_forward(const char *serial, uint16_t local_port,
            const char *device_socket_name);
-sc_pid
+process_t
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
+adb_forward_remove(const char *serial, uint16_t local_port);
            unsigned flags);
-bool
+process_t
-adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
+adb_reverse(const char *serial, const char *device_socket_name,
-            const char *device_socket_name, unsigned flags);
+            uint16_t local_port);
-bool
+process_t
-adb_forward_remove(struct sc_intr *intr, const char *serial,
+adb_reverse_remove(const char *serial, const char *device_socket_name);
                   uint16_t local_port, unsigned flags);
-bool
+process_t
-adb_reverse(struct sc_intr *intr, const char *serial,
+adb_push(const char *serial, const char *local, const char *remote);
            const char *device_socket_name, uint16_t local_port,
            unsigned flags);
-bool
+process_t
-adb_reverse_remove(struct sc_intr *intr, const char *serial,
+adb_install(const char *serial, const char *local);
                   const char *device_socket_name, unsigned flags);
 bool
 adb_push(struct sc_intr *intr, const char *serial, const char *local,
         const char *remote, unsigned flags);
 bool
 adb_install(struct sc_intr *intr, const char *serial, const char *local,
            unsigned flags);
 /**
 * Execute `adb tcpip <port>`
 */
 bool
 adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
          unsigned flags);
 /**
 * Execute `adb connect <ip_port>`
 *
 * `ip_port` may not be NULL.
 */
 bool
 adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags);
 /**
 * Execute `adb disconnect [<ip_port>]`
 *
 * If `ip_port` is NULL, execute `adb disconnect`.
 * Otherwise, execute `adb disconnect <ip_port>`.
 */
 bool
 adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags);
 /**
 * Execute `adb getprop <prop>`
 */
 char *
 adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
            unsigned flags);
 /**
 * Execute `adb get-serialno`
 *
 * Return the result, to be freed by the caller, or NULL on error.
 */
 char *
 adb_get_serialno(struct sc_intr *intr, unsigned flags);
 /**
 * Attempt to retrieve the device IP
 *
 * Return the IP as a string of the form "xxx.xxx.xxx.xxx", to be freed by the
 * caller, or NULL on error.
 */
 char *
 adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags);
 #endif
--- a/app/src/adb_parser.c
+++ b/app/src/adb_parser.c
@@ -1,65 +0,0 @@
 #include "adb_parser.h"
 #include <assert.h>
 #include <string.h>
 #include "util/log.h"
 #include "util/str.h"
 static char *
 sc_adb_parse_device_ip_from_line(char *line, size_t len) {
    // One line from "ip route" looks lile:
    // "192.168.1.0/24 dev wlan0  proto kernel  scope link  src 192.168.1.x"
    // Get the location of the device name (index of "wlan0" in the example)
    ssize_t idx_dev_name = sc_str_index_of_column(line, 2, " ");
    if (idx_dev_name == -1) {
        return NULL;
    }
    // Get the location of the ip address (column 8, but column 6 if we start
    // from column 2). Must be computed before truncating individual columns.
    ssize_t idx_ip = sc_str_index_of_column(&line[idx_dev_name], 6, " ");
    if (idx_ip == -1) {
        return NULL;
    }
    // idx_ip is searched from &line[idx_dev_name]
    idx_ip += idx_dev_name;
    char *dev_name = &line[idx_dev_name];
    sc_str_truncate(dev_name, len - idx_dev_name + 1, " \t");
    char *ip = &line[idx_ip];
    sc_str_truncate(ip, len - idx_ip + 1, " \t");
    // Only consider lines where the device name starts with "wlan"
    if (strncmp(dev_name, "wlan", sizeof("wlan") - 1)) {
        LOGD("Device ip lookup: ignoring %s (%s)", ip, dev_name);
        return NULL;
    }
    return strdup(ip);
 }
 char *
 sc_adb_parse_device_ip_from_output(char *buf, size_t buf_len) {
    size_t idx_line = 0;
    while (idx_line < buf_len && buf[idx_line] != '\0') {
        char *line = &buf[idx_line];
        size_t len = sc_str_truncate(line, buf_len - idx_line, "\n");
        // The same, but without any trailing '\r'
        size_t line_len = sc_str_remove_trailing_cr(line, len);
        char *ip = sc_adb_parse_device_ip_from_line(line, line_len);
        if (ip) {
            // Found
            return ip;
        }
        // The next line starts after the '\n' (replaced by `\0`)
        idx_line += len + 1;
    }
    return NULL;
 }
--- a/app/src/adb_parser.h
+++ b/app/src/adb_parser.h
@@ -1,14 +0,0 @@
 #ifndef SC_ADB_PARSER_H
 #define SC_ADB_PARSER_H
 #include "common.h"
 #include "stddef.h"
 /**
 * Parse the ip from the output of `adb shell ip route`
 */
 char *
 sc_adb_parse_device_ip_from_output(char *buf, size_t buf_len);
 #endif
--- a/app/src/adb_tunnel.c
+++ b/app/src/adb_tunnel.c
@@ -1,169 +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,
                         SC_ADB_NO_STDOUT)) {
            // the command itself failed, it will fail on any port
            return false;
        }
        // At the application level, the device part is "the server" because it
        // serves video stream and control. However, at the network level, the
        // client listens and the server connects to the client. That way, the
        // client can listen before starting the server app, so there is no
        // need to try to connect until the server socket is listening on the
        // device.
        sc_socket server_socket = net_socket();
        if (server_socket != SC_SOCKET_NONE) {
            bool ok = listen_on_port(intr, server_socket, port);
            if (ok) {
                // success
                tunnel->server_socket = server_socket;
                tunnel->local_port = port;
                tunnel->enabled = true;
                return true;
            }
            net_close(server_socket);
        }
        if (sc_intr_is_interrupted(intr)) {
            // Stop immediately
            return false;
        }
        // failure, disable tunnel and try another port
        if (!adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
                                SC_ADB_NO_STDOUT)) {
            LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
        }
        // check before incrementing to avoid overflow on port 65535
        if (port < port_range.last) {
            LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
                 port, (uint16_t) (port + 1));
            port++;
            continue;
        }
        if (port_range.first == port_range.last) {
            LOGE("Could not listen on port %" PRIu16, port_range.first);
        } else {
            LOGE("Could not listen on any port in range %" PRIu16 ":%" PRIu16,
                 port_range.first, port_range.last);
        }
        return false;
    }
 }
 static bool
 enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
                               struct sc_intr *intr, const char *serial,
                               struct sc_port_range port_range) {
    tunnel->forward = true;
    uint16_t port = port_range.first;
    for (;;) {
        if (adb_forward(intr, serial, port, SC_SOCKET_NAME, SC_ADB_NO_STDOUT)) {
            // success
            tunnel->local_port = port;
            tunnel->enabled = true;
            return true;
        }
        if (sc_intr_is_interrupted(intr)) {
            // Stop immediately
            return false;
        }
        if (port < port_range.last) {
            LOGW("Could not forward port %" PRIu16", retrying on %" PRIu16,
                 port, (uint16_t) (port + 1));
            port++;
            continue;
        }
        if (port_range.first == port_range.last) {
            LOGE("Could not forward port %" PRIu16, port_range.first);
        } else {
            LOGE("Could not forward any port in range %" PRIu16 ":%" PRIu16,
                 port_range.first, port_range.last);
        }
        return false;
    }
 }
 void
 sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel) {
    tunnel->enabled = false;
    tunnel->forward = false;
    tunnel->server_socket = SC_SOCKET_NONE;
    tunnel->local_port = 0;
 }
 bool
 sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
                   const char *serial, struct sc_port_range port_range,
                   bool force_adb_forward) {
    assert(!tunnel->enabled);
    if (!force_adb_forward) {
        // Attempt to use "adb reverse"
        if (enable_tunnel_reverse_any_port(tunnel, intr, serial, port_range)) {
            return true;
        }
        // if "adb reverse" does not work (e.g. over "adb connect"), it
        // fallbacks to "adb forward", so the app socket is the client
        LOGW("'adb reverse' failed, fallback to 'adb forward'");
    }
    return enable_tunnel_forward_any_port(tunnel, intr, serial, port_range);
 }
 bool
 sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
                    const char *serial) {
    assert(tunnel->enabled);
    bool ret;
    if (tunnel->forward) {
        ret = adb_forward_remove(intr, serial, tunnel->local_port,
                                 SC_ADB_NO_STDOUT);
    } else {
        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
                                 SC_ADB_NO_STDOUT);
        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,398 +0,0 @@
 #include "util/log.h"
 #include <assert.h>
 #include <stdio.h>
 #include "aoa_hid.h"
 #include "util/log.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) {
        LOG_OOM();
        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, "scrcpy-aoa", 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/common.h
+++ b/app/src/common.h
@@ -7,7 +7,6 @@
 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
 #define MIN(X,Y) (X) < (Y) ? (X) : (Y)
 #define MAX(X,Y) (X) > (Y) ? (X) : (Y)
 #define CLAMP(V,X,Y) MIN( MAX((V),(X)), (Y) )
 #define container_of(ptr, type, member) \
    ((type *) (((char *) (ptr)) - offsetof(type, member)))
--- a/app/src/compat.c
+++ b/app/src/compat.c
@@ -2,12 +2,6 @@
 #include "config.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
 #ifndef HAVE_STRDUP
 char *strdup(const char *s) {
    size_t size = strlen(s) + 1;
@@ -18,36 +12,3 @@ char *strdup(const char *s) {
    return dup;
 }
 #endif
 #ifndef HAVE_ASPRINTF
 int asprintf(char **strp, const char *fmt, ...) {
    va_list va;
    va_start(va, fmt);
    int ret = vasprintf(strp, fmt, va);
    va_end(va);
    return ret;
 }
 #endif
 #ifndef HAVE_VASPRINTF
 int vasprintf(char **strp, const char *fmt, va_list ap) {
    va_list va;
    va_copy(va, ap);
    int len = vsnprintf(NULL, 0, fmt, va);
    va_end(va);
    char *str = malloc(len + 1);
    if (!str) {
        return -1;
    }
    va_copy(va, ap);
    int len2 = vsnprintf(str, len + 1, fmt, va);
    (void) len2;
    assert(len == len2);
    va_end(va);
    *strp = str;
    return len;
 }
 #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(),
@@ -35,9 +34,13 @@
 # define SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
 #endif
-#if SDL_VERSION_ATLEAST(2, 0, 6)
+#if SDL_VERSION_ATLEAST(2, 0, 5)
-// <https://github.com/libsdl-org/SDL/commit/d7a318de563125e5bb465b1000d6bc9576fbc6fc>
+// <https://wiki.libsdl.org/SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH>
-# define SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
+# define SCRCPY_SDL_HAS_HINT_MOUSE_FOCUS_CLICKTHROUGH
 // <https://wiki.libsdl.org/SDL_GetDisplayUsableBounds>
 # define SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
 // <https://wiki.libsdl.org/SDL_WindowFlags>
 # define SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
 #endif
 #if SDL_VERSION_ATLEAST(2, 0, 8)
@@ -49,12 +52,4 @@
 char *strdup(const char *s);
 #endif
 #ifndef HAVE_ASPRINTF
 int asprintf(char **strp, const char *fmt, ...);
 #endif
 #ifndef HAVE_VASPRINTF
 int vasprintf(char **strp, const char *fmt, va_list ap);
 #endif
 #endif
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@@ -1,78 +1,25 @@
 #include "control_msg.h"
 #include <assert.h>
 #include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
 #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
 * out-of-bounds index.
 */
 #define ENUM_TO_LABEL(labels, value) \
    ((size_t) (value) < ARRAY_LEN(labels) ? labels[value] : "???")
 #define KEYEVENT_ACTION_LABEL(value) \
    ENUM_TO_LABEL(android_keyevent_action_labels, value)
 #define MOTIONEVENT_ACTION_LABEL(value) \
    ENUM_TO_LABEL(android_motionevent_action_labels, value)
 #define SCREEN_POWER_MODE_LABEL(value) \
    ENUM_TO_LABEL(screen_power_mode_labels, value)
 static const char *const android_keyevent_action_labels[] = {
    "down",
    "up",
    "multi",
 };
 static const char *const android_motionevent_action_labels[] = {
    "down",
    "up",
    "move",
    "cancel",
    "outside",
    "ponter-down",
    "pointer-up",
    "hover-move",
    "scroll",
    "hover-enter",
    "hover-exit",
    "btn-press",
    "btn-release",
 };
 static const char *const screen_power_mode_labels[] = {
    "off",
    "doze",
    "normal",
    "doze-suspend",
    "suspend",
 };
 static const char *const copy_key_labels[] = {
    "none",
    "copy",
    "cut",
 };
 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);
    buffer_write16be(&buf[10], position->screen_size.height);
 }
-// write length (4 bytes) + string (non null-terminated)
+// 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;
@@ -119,21 +66,16 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
                             (uint32_t) msg->inject_scroll_event.hscroll);
            buffer_write32be(&buf[17],
                             (uint32_t) msg->inject_scroll_event.vscroll);
-            buffer_write32be(&buf[21], msg->inject_scroll_event.buttons);
+            return 21;
            return 25;
        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
            buf[1] = msg->inject_keycode.action;
            return 2;
        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
            buf[1] = msg->get_clipboard.copy_key;
            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;
@@ -141,6 +83,7 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
            // no additional data
            return 1;
@@ -150,92 +93,6 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
    }
 }
 void
 control_msg_log(const struct control_msg *msg) {
 #define LOG_CMSG(fmt, ...) LOGV("input: " fmt, ## __VA_ARGS__)
    switch (msg->type) {
        case CONTROL_MSG_TYPE_INJECT_KEYCODE:
            LOG_CMSG("key %-4s code=%d repeat=%" PRIu32 " meta=%06lx",
                     KEYEVENT_ACTION_LABEL(msg->inject_keycode.action),
                     (int) msg->inject_keycode.keycode,
                     msg->inject_keycode.repeat,
                     (long) msg->inject_keycode.metastate);
            break;
        case CONTROL_MSG_TYPE_INJECT_TEXT:
            LOG_CMSG("text \"%s\"", msg->inject_text.text);
            break;
        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: {
            int action = msg->inject_touch_event.action
                       & AMOTION_EVENT_ACTION_MASK;
            uint64_t id = msg->inject_touch_event.pointer_id;
            if (id == POINTER_ID_MOUSE || id == POINTER_ID_VIRTUAL_FINGER) {
                // string pointer id
                LOG_CMSG("touch [id=%s] %-4s position=%" PRIi32 ",%" PRIi32
                             " pressure=%g buttons=%06lx",
                         id == POINTER_ID_MOUSE ? "mouse" : "vfinger",
                         MOTIONEVENT_ACTION_LABEL(action),
                         msg->inject_touch_event.position.point.x,
                         msg->inject_touch_event.position.point.y,
                         msg->inject_touch_event.pressure,
                         (long) msg->inject_touch_event.buttons);
            } else {
                // numeric pointer id
                LOG_CMSG("touch [id=%" PRIu64_ "] %-4s position=%" PRIi32 ",%"
                             PRIi32 " pressure=%g buttons=%06lx",
                         id,
                         MOTIONEVENT_ACTION_LABEL(action),
                         msg->inject_touch_event.position.point.x,
                         msg->inject_touch_event.position.point.y,
                         msg->inject_touch_event.pressure,
                         (long) msg->inject_touch_event.buttons);
            }
            break;
        }
        case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
            LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%" PRIi32
                         " vscroll=%" PRIi32 " buttons=%06lx",
                     msg->inject_scroll_event.position.point.x,
                     msg->inject_scroll_event.position.point.y,
                     msg->inject_scroll_event.hscroll,
                     msg->inject_scroll_event.vscroll,
                     (long) msg->inject_scroll_event.buttons);
            break;
        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
            LOG_CMSG("back-or-screen-on %s",
                     KEYEVENT_ACTION_LABEL(msg->inject_keycode.action));
            break;
        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
            LOG_CMSG("get clipboard copy_key=%s",
                     copy_key_labels[msg->get_clipboard.copy_key]);
            break;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
            LOG_CMSG("clipboard %" PRIu64_ " %s \"%s\"",
                     msg->set_clipboard.sequence,
                     msg->set_clipboard.paste ? "paste" : "nopaste",
                     msg->set_clipboard.text);
            break;
        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
            LOG_CMSG("power mode %s",
                     SCREEN_POWER_MODE_LABEL(msg->set_screen_power_mode.mode));
            break;
        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
            LOG_CMSG("expand notification panel");
            break;
        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
            LOG_CMSG("expand settings panel");
            break;
        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
            LOG_CMSG("collapse panels");
            break;
        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
            LOG_CMSG("rotate device");
            break;
        default:
            LOG_CMSG("unknown type: %u", (unsigned) msg->type);
            break;
    }
 }
 void
 control_msg_destroy(struct control_msg *msg) {
    switch (msg->type) {
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@@ -14,11 +14,11 @@
 #define CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
 #define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
-// type: 1 byte; sequence: 8 bytes; paste flag: 1 byte; length: 4 bytes
+// type: 1 byte; paste flag: 1 byte; length: 4 bytes
-#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (CONTROL_MSG_MAX_SIZE - 14)
+#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (CONTROL_MSG_MAX_SIZE - 6)
-#define POINTER_ID_MOUSE UINT64_C(-1)
+#define POINTER_ID_MOUSE UINT64_C(-1);
-#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2)
+#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2);
 enum control_msg_type {
    CONTROL_MSG_TYPE_INJECT_KEYCODE,
@@ -41,12 +41,6 @@ enum screen_power_mode {
    SCREEN_POWER_MODE_NORMAL = 2,
 };
 enum get_clipboard_copy_key {
    GET_CLIPBOARD_COPY_KEY_NONE,
    GET_CLIPBOARD_COPY_KEY_COPY,
    GET_CLIPBOARD_COPY_KEY_CUT,
 };
 struct control_msg {
    enum control_msg_type type;
    union {
@@ -63,24 +57,19 @@ 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;
            enum android_motionevent_buttons buttons;
        } inject_scroll_event;
        struct {
            enum android_keyevent_action action; // action for the BACK key
            // screen may only be turned on on ACTION_DOWN
        } back_or_screen_on;
        struct {
            enum get_clipboard_copy_key copy_key;
        } get_clipboard;
        struct {
            uint64_t sequence;
            char *text; // owned, to be freed by free()
            bool paste;
        } set_clipboard;
@@ -95,9 +84,6 @@ struct control_msg {
 size_t
 control_msg_serialize(const struct control_msg *msg, unsigned char *buf);
 void
 control_msg_log(const struct control_msg *msg);
 void
 control_msg_destroy(struct control_msg *msg);
--- 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;
    }
@@ -49,10 +48,6 @@ controller_destroy(struct controller *controller) {
 bool
 controller_push_msg(struct controller *controller,
                      const struct control_msg *msg) {
    if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
        control_msg_log(msg);
    }
    sc_mutex_lock(&controller->mutex);
    bool was_empty = cbuf_is_empty(&controller->queue);
    bool res = cbuf_push(&controller->queue, *msg);
@@ -64,14 +59,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;
 }
@@ -110,7 +105,7 @@ controller_start(struct controller *controller) {
    LOGD("Starting controller thread");
    bool ok = sc_thread_create(&controller->thread, run_controller,
-                               "scrcpy-ctl", controller);
+                               "controller", controller);
    if (!ok) {
        LOGC("Could not start controller thread");
        return false;
--- 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"
@@ -42,12 +41,10 @@ static bool
 decoder_open(struct decoder *decoder, const AVCodec *codec) {
    decoder->codec_ctx = avcodec_alloc_context3(codec);
    if (!decoder->codec_ctx) {
-        LOG_OOM();
+        LOGC("Could not allocate decoder context");
        return false;
    }
    decoder->codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;
    if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
        LOGE("Could not open codec");
        avcodec_free_context(&decoder->codec_ctx);
@@ -56,7 +53,7 @@ decoder_open(struct decoder *decoder, const AVCodec *codec) {
    decoder->frame = av_frame_alloc();
    if (!decoder->frame) {
-        LOG_OOM();
+        LOGE("Could not create decoder frame");
        avcodec_close(decoder->codec_ctx);
        avcodec_free_context(&decoder->codec_ctx);
        return false;
--- 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>
@@ -24,7 +23,7 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
            }
            char *text = malloc(clipboard_len + 1);
            if (!text) {
-                LOG_OOM();
+                LOGW("Could not allocate text for clipboard");
                return -1;
            }
            if (clipboard_len) {
@@ -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
@@ -0,0 +1,195 @@
 #include "event_converter.h"
 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false
 bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
    switch (from) {
        MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
        MAP(SDL_KEYUP,   AKEY_EVENT_ACTION_UP);
        FAIL;
    }
 }
 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) {
        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
        MAP(SDLK_ESCAPE,       AKEYCODE_ESCAPE);
        MAP(SDLK_BACKSPACE,    AKEYCODE_DEL);
        MAP(SDLK_TAB,          AKEYCODE_TAB);
        MAP(SDLK_PAGEUP,       AKEYCODE_PAGE_UP);
        MAP(SDLK_DELETE,       AKEYCODE_FORWARD_DEL);
        MAP(SDLK_HOME,         AKEYCODE_MOVE_HOME);
        MAP(SDLK_END,          AKEYCODE_MOVE_END);
        MAP(SDLK_PAGEDOWN,     AKEYCODE_PAGE_DOWN);
        MAP(SDLK_RIGHT,        AKEYCODE_DPAD_RIGHT);
        MAP(SDLK_LEFT,         AKEYCODE_DPAD_LEFT);
        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
        MAP(SDLK_LCTRL,        AKEYCODE_CTRL_LEFT);
        MAP(SDLK_RCTRL,        AKEYCODE_CTRL_RIGHT);
        MAP(SDLK_LSHIFT,       AKEYCODE_SHIFT_LEFT);
        MAP(SDLK_RSHIFT,       AKEYCODE_SHIFT_RIGHT);
    }
    if (!(mod & (KMOD_NUM | KMOD_SHIFT))) {
        // Handle Numpad events when Num Lock is disabled
        // If SHIFT is pressed, a text event will be sent instead
        switch(from) {
            MAP(SDLK_KP_0,            AKEYCODE_INSERT);
            MAP(SDLK_KP_1,            AKEYCODE_MOVE_END);
            MAP(SDLK_KP_2,            AKEYCODE_DPAD_DOWN);
            MAP(SDLK_KP_3,            AKEYCODE_PAGE_DOWN);
            MAP(SDLK_KP_4,            AKEYCODE_DPAD_LEFT);
            MAP(SDLK_KP_6,            AKEYCODE_DPAD_RIGHT);
            MAP(SDLK_KP_7,            AKEYCODE_MOVE_HOME);
            MAP(SDLK_KP_8,            AKEYCODE_DPAD_UP);
            MAP(SDLK_KP_9,            AKEYCODE_PAGE_UP);
            MAP(SDLK_KP_PERIOD,       AKEYCODE_FORWARD_DEL);
        }
    }
    if (prefer_text && !(mod & KMOD_CTRL)) {
        // do not forward alpha and space key events (unless Ctrl is pressed)
        return false;
    }
    if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
        return false;
    }
    // if ALT and META are not pressed, also handle letters and space
    switch (from) {
        MAP(SDLK_a,            AKEYCODE_A);
        MAP(SDLK_b,            AKEYCODE_B);
        MAP(SDLK_c,            AKEYCODE_C);
        MAP(SDLK_d,            AKEYCODE_D);
        MAP(SDLK_e,            AKEYCODE_E);
        MAP(SDLK_f,            AKEYCODE_F);
        MAP(SDLK_g,            AKEYCODE_G);
        MAP(SDLK_h,            AKEYCODE_H);
        MAP(SDLK_i,            AKEYCODE_I);
        MAP(SDLK_j,            AKEYCODE_J);
        MAP(SDLK_k,            AKEYCODE_K);
        MAP(SDLK_l,            AKEYCODE_L);
        MAP(SDLK_m,            AKEYCODE_M);
        MAP(SDLK_n,            AKEYCODE_N);
        MAP(SDLK_o,            AKEYCODE_O);
        MAP(SDLK_p,            AKEYCODE_P);
        MAP(SDLK_q,            AKEYCODE_Q);
        MAP(SDLK_r,            AKEYCODE_R);
        MAP(SDLK_s,            AKEYCODE_S);
        MAP(SDLK_t,            AKEYCODE_T);
        MAP(SDLK_u,            AKEYCODE_U);
        MAP(SDLK_v,            AKEYCODE_V);
        MAP(SDLK_w,            AKEYCODE_W);
        MAP(SDLK_x,            AKEYCODE_X);
        MAP(SDLK_y,            AKEYCODE_Y);
        MAP(SDLK_z,            AKEYCODE_Z);
        MAP(SDLK_SPACE,        AKEYCODE_SPACE);
        FAIL;
    }
 }
 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;
 }
 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;
    }
 }
 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;
    }
 }
--- 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_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);
        if (!file_handler->serial) {
            LOGW("Could not strdup serial");
            sc_cond_destroy(&file_handler->event_cond);
            sc_mutex_destroy(&file_handler->mutex);
            return false;
        }
-
+    } else {
-    file_handler->serial = strdup(serial);
+        file_handler->serial = NULL;
    if (!file_handler->serial) {
        LOG_OOM();
        sc_intr_destroy(&file_handler->intr);
        sc_cond_destroy(&file_handler->event_cond);
        sc_mutex_destroy(&file_handler->mutex);
        return false;
    }
    // lazy initialization
    file_handler->initialized = false;
    file_handler->stopped = false;
    file_handler->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, 0);
            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, 0);
+                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;
@@ -154,7 +169,7 @@ file_handler_start(struct file_handler *file_handler) {
    LOGD("Starting file_handler thread");
    bool ok = sc_thread_create(&file_handler->thread, run_file_handler,
-                               "scrcpy-file", file_handler);
+                               "file_handler", file_handler);
    if (!ok) {
        LOGC("Could not start file_handler thread");
        return false;
@@ -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
@@ -1,10 +1,11 @@
 #include "fps_counter.h"
 #include <assert.h>
 #include <SDL2/SDL_timer.h>
 #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 +47,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 +68,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
@@ -81,12 +82,14 @@ run_fps_counter(void *data) {
            sc_cond_wait(&counter->state_cond, &counter->mutex);
        }
        while (!counter->interrupted && is_started(counter)) {
-            sc_tick now = sc_tick_now();
+            uint32_t now = SDL_GetTicks();
            check_interval_expired(counter, now);
            assert(counter->next_timestamp > now);
            uint32_t remaining = counter->next_timestamp - now;
            // ignore the reason (timeout or signaled), we just loop anyway
-            sc_cond_timedwait(&counter->state_cond, &counter->mutex,
+            sc_cond_timedwait(&counter->state_cond, &counter->mutex, remaining);
                              counter->next_timestamp);
        }
    }
    sc_mutex_unlock(&counter->mutex);
@@ -96,7 +99,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 = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
    counter->nr_rendered = 0;
    counter->nr_skipped = 0;
    sc_mutex_unlock(&counter->mutex);
@@ -108,7 +111,7 @@ fps_counter_start(struct fps_counter *counter) {
    // same thread, no need to lock
    if (!counter->thread_started) {
        bool ok = sc_thread_create(&counter->thread, run_fps_counter,
-                                   "scrcpy-fps", counter);
+                                   "fps counter", counter);
        if (!ok) {
            LOGE("Could not start FPS counter thread");
            return false;
@@ -162,7 +165,7 @@ fps_counter_add_rendered_frame(struct fps_counter *counter) {
    }
    sc_mutex_lock(&counter->mutex);
-    sc_tick now = sc_tick_now();
+    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_rendered;
    sc_mutex_unlock(&counter->mutex);
@@ -175,7 +178,7 @@ fps_counter_add_skipped_frame(struct fps_counter *counter) {
    }
    sc_mutex_lock(&counter->mutex);
-    sc_tick now = sc_tick_now();
+    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_skipped;
    sc_mutex_unlock(&counter->mutex);
--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@@ -24,7 +24,7 @@ struct fps_counter {
    bool interrupted;
    unsigned nr_rendered;
    unsigned nr_skipped;
-    sc_tick next_timestamp;
+    uint32_t next_timestamp;
 };
 bool
--- a/app/src/frame_buffer.c
+++ b/app/src/frame_buffer.c
@@ -1,90 +0,0 @@
 #include "frame_buffer.h"
 #include <assert.h>
 #include <libavutil/avutil.h>
 #include <libavformat/avformat.h>
 #include "util/log.h"
 bool
 sc_frame_buffer_init(struct sc_frame_buffer *fb) {
    fb->pending_frame = av_frame_alloc();
    if (!fb->pending_frame) {
        LOG_OOM();
        return false;
    }
    fb->tmp_frame = av_frame_alloc();
    if (!fb->tmp_frame) {
        LOG_OOM();
        av_frame_free(&fb->pending_frame);
        return false;
    }
    bool ok = sc_mutex_init(&fb->mutex);
    if (!ok) {
        av_frame_free(&fb->pending_frame);
        av_frame_free(&fb->tmp_frame);
        return false;
    }
    // there is initially no frame, so consider it has already been consumed
    fb->pending_frame_consumed = true;
    return true;
 }
 void
 sc_frame_buffer_destroy(struct sc_frame_buffer *fb) {
    sc_mutex_destroy(&fb->mutex);
    av_frame_free(&fb->pending_frame);
    av_frame_free(&fb->tmp_frame);
 }
 static inline void
 swap_frames(AVFrame **lhs, AVFrame **rhs) {
    AVFrame *tmp = *lhs;
    *lhs = *rhs;
    *rhs = tmp;
 }
 bool
 sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
                  bool *previous_frame_skipped) {
    sc_mutex_lock(&fb->mutex);
    // Use a temporary frame to preserve pending_frame in case of error.
    // tmp_frame is an empty frame, no need to call av_frame_unref() beforehand.
    int r = av_frame_ref(fb->tmp_frame, frame);
    if (r) {
        LOGE("Could not ref frame: %d", r);
        return false;
    }
    // Now that av_frame_ref() succeeded, we can replace the previous
    // pending_frame
    swap_frames(&fb->pending_frame, &fb->tmp_frame);
    av_frame_unref(fb->tmp_frame);
    if (previous_frame_skipped) {
        *previous_frame_skipped = !fb->pending_frame_consumed;
    }
    fb->pending_frame_consumed = false;
    sc_mutex_unlock(&fb->mutex);
    return true;
 }
 void
 sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst) {
    sc_mutex_lock(&fb->mutex);
    assert(!fb->pending_frame_consumed);
    fb->pending_frame_consumed = true;
    av_frame_move_ref(dst, fb->pending_frame);
    // av_frame_move_ref() resets its source frame, so no need to call
    // av_frame_unref()
    sc_mutex_unlock(&fb->mutex);
 }
--- a/app/src/frame_buffer.h
+++ b/app/src/frame_buffer.h
@@ -1,44 +0,0 @@
 #ifndef SC_FRAME_BUFFER_H
 #define SC_FRAME_BUFFER_H
 #include "common.h"
 #include <stdbool.h>
 #include "util/thread.h"
 // forward declarations
 typedef struct AVFrame AVFrame;
 /**
 * A frame buffer holds 1 pending frame, which is the last frame received from
 * the producer (typically, the decoder).
 *
 * If a pending frame has not been consumed when the producer pushes a new
 * frame, then it is lost. The intent is to always provide access to the very
 * last frame to minimize latency.
 */
 struct sc_frame_buffer {
    AVFrame *pending_frame;
    AVFrame *tmp_frame; // To preserve the pending frame on error
    sc_mutex mutex;
    bool pending_frame_consumed;
 };
 bool
 sc_frame_buffer_init(struct sc_frame_buffer *fb);
 void
 sc_frame_buffer_destroy(struct sc_frame_buffer *fb);
 bool
 sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
                     bool *skipped);
 void
 sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst);
 #endif
--- a/app/src/hid_keyboard.c
+++ b/app/src/hid_keyboard.c
@@ -1,430 +0,0 @@
 #include "hid_keyboard.h"
 #include <assert.h>
 #include "input_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
 };
 /**
 * A keyboard HID event is 8 bytes long:
 *
 *  - byte 0: modifiers (1 flag per modifier key, 8 possible modifier keys)
 *  - byte 1: reserved (always 0)
 *  - bytes 2 to 7: pressed keys (6 at most)
 *
 *                   7 6 5 4 3 2 1 0
 *                  +---------------+
 *         byte 0:  |. . . . . . . .| modifiers
 *                  +---------------+
 *                   ^ ^ ^ ^ ^ ^ ^ ^
 *                   | | | | | | | `- left Ctrl
 *                   | | | | | | `--- left Shift
 *                   | | | | | `----- left Alt
 *                   | | | | `------- left Gui
 *                   | | | `--------- right Ctrl
 *                   | | `----------- right Shift
 *                   | `------------- right Alt
 *                   `--------------- right Gui
 *
 *                  +---------------+
 *         byte 1:  |0 0 0 0 0 0 0 0| reserved
 *                  +---------------+
 *
 *                  +---------------+
 *   bytes 2 to 7:  |. . . . . . . .| scancode of 1st key pressed
 *                  +---------------+
 *                  |. . . . . . . .| scancode of 2nd key pressed
 *                  +---------------+
 *                  |. . . . . . . .| scancode of 3rd key pressed
 *                  +---------------+
 *                  |. . . . . . . .| scancode of 4th key pressed
 *                  +---------------+
 *                  |. . . . . . . .| scancode of 5th key pressed
 *                  +---------------+
 *                  |. . . . . . . .| scancode of 6th key pressed
 *                  +---------------+
 *
 * If there are less than 6 keys pressed, the last items are set to 0.
 * For example, if A and W are pressed:
 *
 *                  +---------------+
 *   bytes 2 to 7:  |0 0 0 0 0 1 0 0| A is pressed (scancode = 4)
 *                  +---------------+
 *                  |0 0 0 1 1 0 1 0| W is pressed (scancode = 26)
 *                  +---------------+
 *                  |0 0 0 0 0 0 0 0| ^
 *                  +---------------+ |  only 2 keys are pressed, the
 *                  |0 0 0 0 0 0 0 0| |  remaining items are set to 0
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 0| |
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 0| v
 *                  +---------------+
 *
 * Pressing more than 6 keys is not supported. If this happens (typically,
 * never in practice), report a "phantom state":
 *
 *                  +---------------+
 *   bytes 2 to 7:  |0 0 0 0 0 0 0 1| ^
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 1| |  more than 6 keys pressed:
 *                  +---------------+ |  the list is filled with a special
 *                  |0 0 0 0 0 0 0 1| |  rollover error code (0x01)
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 1| |
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 1| |
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 1| v
 *                  +---------------+
 */
 static unsigned char
 sdl_keymod_to_hid_modifiers(uint16_t mod) {
    unsigned char modifiers = HID_MODIFIER_NONE;
    if (mod & SC_MOD_LCTRL) {
        modifiers |= HID_MODIFIER_LEFT_CONTROL;
    }
    if (mod & SC_MOD_LSHIFT) {
        modifiers |= HID_MODIFIER_LEFT_SHIFT;
    }
    if (mod & SC_MOD_LALT) {
        modifiers |= HID_MODIFIER_LEFT_ALT;
    }
    if (mod & SC_MOD_LGUI) {
        modifiers |= HID_MODIFIER_LEFT_GUI;
    }
    if (mod & SC_MOD_RCTRL) {
        modifiers |= HID_MODIFIER_RIGHT_CONTROL;
    }
    if (mod & SC_MOD_RSHIFT) {
        modifiers |= HID_MODIFIER_RIGHT_SHIFT;
    }
    if (mod & SC_MOD_RALT) {
        modifiers |= HID_MODIFIER_RIGHT_ALT;
    }
    if (mod & SC_MOD_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) {
        LOG_OOM();
        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(enum sc_scancode scancode) {
    return scancode >= SC_SCANCODE_LCTRL && scancode <= SC_SCANCODE_RGUI;
 }
 static bool
 convert_hid_keyboard_event(struct sc_hid_keyboard *kb,
                           struct sc_hid_event *hid_event,
                           const struct sc_key_event *event) {
    enum sc_scancode scancode = event->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->mods_state);
    if (scancode < SC_HID_KEYBOARD_KEYS) {
        // Pressed is true and released is false
        kb->keys[scancode] = (event->action == SC_ACTION_DOWN);
        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) {
                // Phantom 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->action == SC_ACTION_DOWN ? "down" : "up", event->scancode,
         event->scancode, modifiers);
    return true;
 }
 static bool
 push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t mods_state) {
    bool capslock = mods_state & SC_MOD_CAPS;
    bool numlock = mods_state & SC_MOD_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;
    }
    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 struct sc_key_event *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->mods_state)) {
                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");
        }
    }
 }
 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,
        // Never forward text input via HID (all the keys are injected
        // separately)
        .process_text = NULL,
    };
    // 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/hid_mouse.c
+++ b/app/src/hid_mouse.c
@@ -1,267 +0,0 @@
 #include "hid_mouse.h"
 #include <assert.h>
 #include "input_events.h"
 #include "util/log.h"
 /** Downcast mouse processor to hid_mouse */
 #define DOWNCAST(MP) container_of(MP, struct sc_hid_mouse, mouse_processor)
 #define HID_MOUSE_ACCESSORY_ID 2
 // 1 byte for buttons + padding, 1 byte for X position, 1 byte for Y position
 #define HID_MOUSE_EVENT_SIZE 4
 /**
 * Mouse descriptor from the specification:
 * <https://www.usb.org/sites/default/files/hid1_11.pdf>
 *
 * Appendix E (p71): §E.10 Report Descriptor (Mouse)
 *
 * The usage tags (like Wheel) are listed in "HID Usage Tables":
 * <https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf>
 * §4 Generic Desktop Page (0x01) (p26)
 */
 static const unsigned char mouse_report_desc[]  = {
    // Usage Page (Generic Desktop)
    0x05, 0x01,
    // Usage (Mouse)
    0x09, 0x02,
    // Collection (Application)
    0xA1, 0x01,
    // Usage (Pointer)
    0x09, 0x01,
    // Collection (Physical)
    0xA1, 0x00,
    // Usage Page (Buttons)
    0x05, 0x09,
    // Usage Minimum (1)
    0x19, 0x01,
     // Usage Maximum (5)
    0x29, 0x05,
    // Logical Minimum (0)
    0x15, 0x00,
    // Logical Maximum (1)
    0x25, 0x01,
    // Report Count (5)
    0x95, 0x05,
    // Report Size (1)
    0x75, 0x01,
    // Input (Data, Variable, Absolute): 5 buttons bits
    0x81, 0x02,
    // Report Count (1)
    0x95, 0x01,
    // Report Size (3)
    0x75, 0x03,
    // Input (Constant): 3 bits padding
    0x81, 0x01,
    // Usage Page (Generic Desktop)
    0x05, 0x01,
    // Usage (X)
    0x09, 0x30,
    // Usage (Y)
    0x09, 0x31,
    // Usage (Wheel)
    0x09, 0x38,
    // Local Minimum (-127)
    0x15, 0x81,
    // Local Maximum (127)
    0x25, 0x7F,
    // Report Size (8)
    0x75, 0x08,
    // Report Count (3)
    0x95, 0x03,
    // Input (Data, Variable, Relative): 3 position bytes (X, Y, Wheel)
    0x81, 0x06,
    // End Collection
    0xC0,
    // End Collection
    0xC0,
 };
 /**
 * A mouse HID event is 3 bytes long:
 *
 *  - byte 0: buttons state
 *  - byte 1: relative x motion (signed byte from -127 to 127)
 *  - byte 2: relative y motion (signed byte from -127 to 127)
 *
 *                   7 6 5 4 3 2 1 0
 *                  +---------------+
 *         byte 0:  |0 0 0 . . . . .| buttons state
 *                  +---------------+
 *                         ^ ^ ^ ^ ^
 *                         | | | | `- left button
 *                         | | | `--- right button
 *                         | | `----- middle button
 *                         | `------- button 4
 *                         `--------- button 5
 *
 *                  +---------------+
 *         byte 1:  |. . . . . . . .| relative x motion
 *                  +---------------+
 *         byte 2:  |. . . . . . . .| relative y motion
 *                  +---------------+
 *         byte 3:  |. . . . . . . .| wheel motion (-1, 0 or 1)
 *                  +---------------+
 *
 * As an example, here is the report for a motion of (x=5, y=-4) with left
 * button pressed:
 *
 *                  +---------------+
 *                  |0 0 0 0 0 0 0 1| left button pressed
 *                  +---------------+
 *                  |0 0 0 0 0 1 0 1| horizontal motion (x = 5)
 *                  +---------------+
 *                  |1 1 1 1 1 1 0 0| relative y motion (y = -4)
 *                  +---------------+
 *                  |0 0 0 0 0 0 0 0| wheel motion
 *                  +---------------+
 */
 static bool
 sc_hid_mouse_event_init(struct sc_hid_event *hid_event) {
    unsigned char *buffer = calloc(1, HID_MOUSE_EVENT_SIZE);
    if (!buffer) {
        LOG_OOM();
        return false;
    }
    sc_hid_event_init(hid_event, HID_MOUSE_ACCESSORY_ID, buffer,
                      HID_MOUSE_EVENT_SIZE);
    return true;
 }
 static unsigned char
 buttons_state_to_hid_buttons(uint8_t buttons_state) {
    unsigned char c = 0;
    if (buttons_state & SC_MOUSE_BUTTON_LEFT) {
        c |= 1 << 0;
    }
    if (buttons_state & SC_MOUSE_BUTTON_RIGHT) {
        c |= 1 << 1;
    }
    if (buttons_state & SC_MOUSE_BUTTON_MIDDLE) {
        c |= 1 << 2;
    }
    if (buttons_state & SC_MOUSE_BUTTON_X1) {
        c |= 1 << 3;
    }
    if (buttons_state & SC_MOUSE_BUTTON_X2) {
        c |= 1 << 4;
    }
    return c;
 }
 static void
 sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
                                    const struct sc_mouse_motion_event *event) {
    struct sc_hid_mouse *mouse = DOWNCAST(mp);
    struct sc_hid_event hid_event;
    if (!sc_hid_mouse_event_init(&hid_event)) {
        return;
    }
    unsigned char *buffer = hid_event.buffer;
    buffer[0] = buttons_state_to_hid_buttons(event->buttons_state);
    buffer[1] = CLAMP(event->xrel, -127, 127);
    buffer[2] = CLAMP(event->yrel, -127, 127);
    buffer[3] = 0; // wheel coordinates only used for scrolling
    if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
        sc_hid_event_destroy(&hid_event);
        LOGW("Could request HID event");
    }
 }
 static void
 sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
                                   const struct sc_mouse_click_event *event) {
    struct sc_hid_mouse *mouse = DOWNCAST(mp);
    struct sc_hid_event hid_event;
    if (!sc_hid_mouse_event_init(&hid_event)) {
        return;
    }
    unsigned char *buffer = hid_event.buffer;
    buffer[0] = buttons_state_to_hid_buttons(event->buttons_state);
    buffer[1] = 0; // no x motion
    buffer[2] = 0; // no y motion
    buffer[3] = 0; // wheel coordinates only used for scrolling
    if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
        sc_hid_event_destroy(&hid_event);
        LOGW("Could request HID event");
    }
 }
 static void
 sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
                                    const struct sc_mouse_scroll_event *event) {
    struct sc_hid_mouse *mouse = DOWNCAST(mp);
    struct sc_hid_event hid_event;
    if (!sc_hid_mouse_event_init(&hid_event)) {
        return;
    }
    unsigned char *buffer = hid_event.buffer;
    buffer[0] = 0; // buttons state irrelevant (and unknown)
    buffer[1] = 0; // no x motion
    buffer[2] = 0; // no y motion
    // In practice, vscroll is always -1, 0 or 1, but in theory other values
    // are possible
    buffer[3] = CLAMP(event->vscroll, -127, 127);
    // Horizontal scrolling ignored
    if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
        sc_hid_event_destroy(&hid_event);
        LOGW("Could request HID event");
    }
 }
 bool
 sc_hid_mouse_init(struct sc_hid_mouse *mouse, struct sc_aoa *aoa) {
    mouse->aoa = aoa;
    bool ok = sc_aoa_setup_hid(aoa, HID_MOUSE_ACCESSORY_ID, mouse_report_desc,
                               ARRAY_LEN(mouse_report_desc));
    if (!ok) {
        LOGW("Register HID mouse failed");
        return false;
    }
    static const struct sc_mouse_processor_ops ops = {
        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
        .process_mouse_click = sc_mouse_processor_process_mouse_click,
        .process_mouse_scroll = sc_mouse_processor_process_mouse_scroll,
        // Touch events not supported (coordinates are not relative)
        .process_touch = NULL,
    };
    mouse->mouse_processor.ops = &ops;
    mouse->mouse_processor.relative_mode = true;
    return true;
 }
 void
 sc_hid_mouse_destroy(struct sc_hid_mouse *mouse) {
    bool ok = sc_aoa_unregister_hid(mouse->aoa, HID_MOUSE_ACCESSORY_ID);
    if (!ok) {
        LOGW("Could not unregister HID");
    }
 }
--- a/app/src/hid_mouse.h
+++ b/app/src/hid_mouse.h
@@ -1,23 +0,0 @@
 #ifndef HID_MOUSE_H
 #define HID_MOUSE_H
 #include "common.h"
 #include <stdbool.h>
 #include "aoa_hid.h"
 #include "trait/mouse_processor.h"
 struct sc_hid_mouse {
    struct sc_mouse_processor mouse_processor; // mouse processor trait
    struct sc_aoa *aoa;
 };
 bool
 sc_hid_mouse_init(struct sc_hid_mouse *mouse, struct sc_aoa *aoa);
 void
 sc_hid_mouse_destroy(struct sc_hid_mouse *mouse);
 #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) {
            LOG_OOM();
            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) {
        LOG_OOM();
        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) {
        LOG_OOM();
        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) {
        LOG_OOM();
        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) {
        LOG_OOM();
        goto close_codec;
    }
    AVPacket *packet = av_packet_alloc();
    if (!packet) {
        LOG_OOM();
        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_events.h
+++ b/app/src/input_events.h
@@ -1,381 +0,0 @@
 #ifndef SC_INPUT_EVENTS_H
 #define SC_INPUT_EVENTS_H
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <SDL2/SDL_events.h>
 #include "coords.h"
 /* The representation of input events in scrcpy is very close to the SDL API,
 * for simplicity.
 *
 * This scrcpy input events API is designed to be consumed by input event
 * processors (sc_key_processor and sc_mouse_processor, see app/src/trait/).
 *
 * One major semantic difference between SDL input events and scrcpy input
 * events is their frame of reference (for mouse and touch events): SDL events
 * coordinates are expressed in SDL window coordinates (the visible UI), while
 * scrcpy events are expressed in device frame coordinates.
 *
 * In particular, the window may be visually scaled or rotated (with --rotation
 * or MOD+Left/Right), but this does not impact scrcpy input events (contrary
 * to SDL input events). This allows to abstract these display details from the
 * input event processors (and to make them independent from the "screen").
 *
 * For many enums below, the values are purposely the same as the SDL
 * constants (though not all SDL values are represented), so that the
 * implementation to convert from the SDL version to the scrcpy version is
 * straightforward.
 *
 * In practice, there are 3 levels of input events:
 *  1. SDL input events (as received from SDL)
 *  2. scrcpy input events (this API)
 *  3. the key/mouse processors input events (Android API or HID events)
 *
 * An input event is first received (1), then (if accepted) converted to an
 * scrcpy input event (2), then submitted to the relevant key/mouse processor,
 * which (if accepted) is converted to an Android event (to be sent to the
 * server) or to an HID event (to be sent over USB/AOA directly).
 */
 enum sc_mod {
    SC_MOD_LSHIFT = KMOD_LSHIFT,
    SC_MOD_RSHIFT = KMOD_RSHIFT,
    SC_MOD_LCTRL = KMOD_LCTRL,
    SC_MOD_RCTRL = KMOD_RCTRL,
    SC_MOD_LALT = KMOD_LALT,
    SC_MOD_RALT = KMOD_RALT,
    SC_MOD_LGUI = KMOD_LGUI,
    SC_MOD_RGUI = KMOD_RGUI,
    SC_MOD_NUM = KMOD_NUM,
    SC_MOD_CAPS = KMOD_CAPS,
    SC_MOD_SCROLL = KMOD_SCROLL,
 };
 enum sc_action {
    SC_ACTION_DOWN, // key or button pressed
    SC_ACTION_UP, // key or button released
 };
 enum sc_keycode {
    SC_KEYCODE_UNKNOWN = SDLK_UNKNOWN,
    SC_KEYCODE_RETURN = SDLK_RETURN,
    SC_KEYCODE_ESCAPE = SDLK_ESCAPE,
    SC_KEYCODE_BACKSPACE = SDLK_BACKSPACE,
    SC_KEYCODE_TAB = SDLK_TAB,
    SC_KEYCODE_SPACE = SDLK_SPACE,
    SC_KEYCODE_EXCLAIM = SDLK_EXCLAIM,
    SC_KEYCODE_QUOTEDBL = SDLK_QUOTEDBL,
    SC_KEYCODE_HASH = SDLK_HASH,
    SC_KEYCODE_PERCENT = SDLK_PERCENT,
    SC_KEYCODE_DOLLAR = SDLK_DOLLAR,
    SC_KEYCODE_AMPERSAND = SDLK_AMPERSAND,
    SC_KEYCODE_QUOTE = SDLK_QUOTE,
    SC_KEYCODE_LEFTPAREN = SDLK_LEFTPAREN,
    SC_KEYCODE_RIGHTPAREN = SDLK_RIGHTPAREN,
    SC_KEYCODE_ASTERISK = SDLK_ASTERISK,
    SC_KEYCODE_PLUS = SDLK_PLUS,
    SC_KEYCODE_COMMA = SDLK_COMMA,
    SC_KEYCODE_MINUS = SDLK_MINUS,
    SC_KEYCODE_PERIOD = SDLK_PERIOD,
    SC_KEYCODE_SLASH = SDLK_SLASH,
    SC_KEYCODE_0 = SDLK_0,
    SC_KEYCODE_1 = SDLK_1,
    SC_KEYCODE_2 = SDLK_2,
    SC_KEYCODE_3 = SDLK_3,
    SC_KEYCODE_4 = SDLK_4,
    SC_KEYCODE_5 = SDLK_5,
    SC_KEYCODE_6 = SDLK_6,
    SC_KEYCODE_7 = SDLK_7,
    SC_KEYCODE_8 = SDLK_8,
    SC_KEYCODE_9 = SDLK_9,
    SC_KEYCODE_COLON = SDLK_COLON,
    SC_KEYCODE_SEMICOLON = SDLK_SEMICOLON,
    SC_KEYCODE_LESS = SDLK_LESS,
    SC_KEYCODE_EQUALS = SDLK_EQUALS,
    SC_KEYCODE_GREATER = SDLK_GREATER,
    SC_KEYCODE_QUESTION = SDLK_QUESTION,
    SC_KEYCODE_AT = SDLK_AT,
    SC_KEYCODE_LEFTBRACKET = SDLK_LEFTBRACKET,
    SC_KEYCODE_BACKSLASH = SDLK_BACKSLASH,
    SC_KEYCODE_RIGHTBRACKET = SDLK_RIGHTBRACKET,
    SC_KEYCODE_CARET = SDLK_CARET,
    SC_KEYCODE_UNDERSCORE = SDLK_UNDERSCORE,
    SC_KEYCODE_BACKQUOTE = SDLK_BACKQUOTE,
    SC_KEYCODE_a = SDLK_a,
    SC_KEYCODE_b = SDLK_b,
    SC_KEYCODE_c = SDLK_c,
    SC_KEYCODE_d = SDLK_d,
    SC_KEYCODE_e = SDLK_e,
    SC_KEYCODE_f = SDLK_f,
    SC_KEYCODE_g = SDLK_g,
    SC_KEYCODE_h = SDLK_h,
    SC_KEYCODE_i = SDLK_i,
    SC_KEYCODE_j = SDLK_j,
    SC_KEYCODE_k = SDLK_k,
    SC_KEYCODE_l = SDLK_l,
    SC_KEYCODE_m = SDLK_m,
    SC_KEYCODE_n = SDLK_n,
    SC_KEYCODE_o = SDLK_o,
    SC_KEYCODE_p = SDLK_p,
    SC_KEYCODE_q = SDLK_q,
    SC_KEYCODE_r = SDLK_r,
    SC_KEYCODE_s = SDLK_s,
    SC_KEYCODE_t = SDLK_t,
    SC_KEYCODE_u = SDLK_u,
    SC_KEYCODE_v = SDLK_v,
    SC_KEYCODE_w = SDLK_w,
    SC_KEYCODE_x = SDLK_x,
    SC_KEYCODE_y = SDLK_y,
    SC_KEYCODE_z = SDLK_z,
    SC_KEYCODE_CAPSLOCK = SDLK_CAPSLOCK,
    SC_KEYCODE_F1 = SDLK_F1,
    SC_KEYCODE_F2 = SDLK_F2,
    SC_KEYCODE_F3 = SDLK_F3,
    SC_KEYCODE_F4 = SDLK_F4,
    SC_KEYCODE_F5 = SDLK_F5,
    SC_KEYCODE_F6 = SDLK_F6,
    SC_KEYCODE_F7 = SDLK_F7,
    SC_KEYCODE_F8 = SDLK_F8,
    SC_KEYCODE_F9 = SDLK_F9,
    SC_KEYCODE_F10 = SDLK_F10,
    SC_KEYCODE_F11 = SDLK_F11,
    SC_KEYCODE_F12 = SDLK_F12,
    SC_KEYCODE_PRINTSCREEN = SDLK_PRINTSCREEN,
    SC_KEYCODE_SCROLLLOCK = SDLK_SCROLLLOCK,
    SC_KEYCODE_PAUSE = SDLK_PAUSE,
    SC_KEYCODE_INSERT = SDLK_INSERT,
    SC_KEYCODE_HOME = SDLK_HOME,
    SC_KEYCODE_PAGEUP = SDLK_PAGEUP,
    SC_KEYCODE_DELETE = SDLK_DELETE,
    SC_KEYCODE_END = SDLK_END,
    SC_KEYCODE_PAGEDOWN = SDLK_PAGEDOWN,
    SC_KEYCODE_RIGHT = SDLK_RIGHT,
    SC_KEYCODE_LEFT = SDLK_LEFT,
    SC_KEYCODE_DOWN = SDLK_DOWN,
    SC_KEYCODE_UP = SDLK_UP,
    SC_KEYCODE_KP_DIVIDE = SDLK_KP_DIVIDE,
    SC_KEYCODE_KP_MULTIPLY = SDLK_KP_MULTIPLY,
    SC_KEYCODE_KP_MINUS = SDLK_KP_MINUS,
    SC_KEYCODE_KP_PLUS = SDLK_KP_PLUS,
    SC_KEYCODE_KP_ENTER = SDLK_KP_ENTER,
    SC_KEYCODE_KP_1 = SDLK_KP_1,
    SC_KEYCODE_KP_2 = SDLK_KP_2,
    SC_KEYCODE_KP_3 = SDLK_KP_3,
    SC_KEYCODE_KP_4 = SDLK_KP_4,
    SC_KEYCODE_KP_5 = SDLK_KP_5,
    SC_KEYCODE_KP_6 = SDLK_KP_6,
    SC_KEYCODE_KP_7 = SDLK_KP_7,
    SC_KEYCODE_KP_8 = SDLK_KP_8,
    SC_KEYCODE_KP_9 = SDLK_KP_9,
    SC_KEYCODE_KP_0 = SDLK_KP_0,
    SC_KEYCODE_KP_PERIOD = SDLK_KP_PERIOD,
    SC_KEYCODE_KP_EQUALS = SDLK_KP_EQUALS,
    SC_KEYCODE_KP_LEFTPAREN = SDLK_KP_LEFTPAREN,
    SC_KEYCODE_KP_RIGHTPAREN = SDLK_KP_RIGHTPAREN,
    SC_KEYCODE_LCTRL = SDLK_LCTRL,
    SC_KEYCODE_LSHIFT = SDLK_LSHIFT,
    SC_KEYCODE_LALT = SDLK_LALT,
    SC_KEYCODE_LGUI = SDLK_LGUI,
    SC_KEYCODE_RCTRL = SDLK_RCTRL,
    SC_KEYCODE_RSHIFT = SDLK_RSHIFT,
    SC_KEYCODE_RALT = SDLK_RALT,
    SC_KEYCODE_RGUI = SDLK_RGUI,
 };
 enum sc_scancode {
    SC_SCANCODE_UNKNOWN = SDL_SCANCODE_UNKNOWN,
    SC_SCANCODE_A = SDL_SCANCODE_A,
    SC_SCANCODE_B = SDL_SCANCODE_B,
    SC_SCANCODE_C = SDL_SCANCODE_C,
    SC_SCANCODE_D = SDL_SCANCODE_D,
    SC_SCANCODE_E = SDL_SCANCODE_E,
    SC_SCANCODE_F = SDL_SCANCODE_F,
    SC_SCANCODE_G = SDL_SCANCODE_G,
    SC_SCANCODE_H = SDL_SCANCODE_H,
    SC_SCANCODE_I = SDL_SCANCODE_I,
    SC_SCANCODE_J = SDL_SCANCODE_J,
    SC_SCANCODE_K = SDL_SCANCODE_K,
    SC_SCANCODE_L = SDL_SCANCODE_L,
    SC_SCANCODE_M = SDL_SCANCODE_M,
    SC_SCANCODE_N = SDL_SCANCODE_N,
    SC_SCANCODE_O = SDL_SCANCODE_O,
    SC_SCANCODE_P = SDL_SCANCODE_P,
    SC_SCANCODE_Q = SDL_SCANCODE_Q,
    SC_SCANCODE_R = SDL_SCANCODE_R,
    SC_SCANCODE_S = SDL_SCANCODE_S,
    SC_SCANCODE_T = SDL_SCANCODE_T,
    SC_SCANCODE_U = SDL_SCANCODE_U,
    SC_SCANCODE_V = SDL_SCANCODE_V,
    SC_SCANCODE_W = SDL_SCANCODE_W,
    SC_SCANCODE_X = SDL_SCANCODE_X,
    SC_SCANCODE_Y = SDL_SCANCODE_Y,
    SC_SCANCODE_Z = SDL_SCANCODE_Z,
    SC_SCANCODE_1 = SDL_SCANCODE_1,
    SC_SCANCODE_2 = SDL_SCANCODE_2,
    SC_SCANCODE_3 = SDL_SCANCODE_3,
    SC_SCANCODE_4 = SDL_SCANCODE_4,
    SC_SCANCODE_5 = SDL_SCANCODE_5,
    SC_SCANCODE_6 = SDL_SCANCODE_6,
    SC_SCANCODE_7 = SDL_SCANCODE_7,
    SC_SCANCODE_8 = SDL_SCANCODE_8,
    SC_SCANCODE_9 = SDL_SCANCODE_9,
    SC_SCANCODE_0 = SDL_SCANCODE_0,
    SC_SCANCODE_RETURN = SDL_SCANCODE_RETURN,
    SC_SCANCODE_ESCAPE = SDL_SCANCODE_ESCAPE,
    SC_SCANCODE_BACKSPACE = SDL_SCANCODE_BACKSPACE,
    SC_SCANCODE_TAB = SDL_SCANCODE_TAB,
    SC_SCANCODE_SPACE = SDL_SCANCODE_SPACE,
    SC_SCANCODE_MINUS = SDL_SCANCODE_MINUS,
    SC_SCANCODE_EQUALS = SDL_SCANCODE_EQUALS,
    SC_SCANCODE_LEFTBRACKET = SDL_SCANCODE_LEFTBRACKET,
    SC_SCANCODE_RIGHTBRACKET = SDL_SCANCODE_RIGHTBRACKET,
    SC_SCANCODE_BACKSLASH = SDL_SCANCODE_BACKSLASH,
    SC_SCANCODE_NONUSHASH = SDL_SCANCODE_NONUSHASH,
    SC_SCANCODE_SEMICOLON = SDL_SCANCODE_SEMICOLON,
    SC_SCANCODE_APOSTROPHE = SDL_SCANCODE_APOSTROPHE,
    SC_SCANCODE_GRAVE = SDL_SCANCODE_GRAVE,
    SC_SCANCODE_COMMA = SDL_SCANCODE_COMMA,
    SC_SCANCODE_PERIOD = SDL_SCANCODE_PERIOD,
    SC_SCANCODE_SLASH = SDL_SCANCODE_SLASH,
    SC_SCANCODE_CAPSLOCK = SDL_SCANCODE_CAPSLOCK,
    SC_SCANCODE_F1 = SDL_SCANCODE_F1,
    SC_SCANCODE_F2 = SDL_SCANCODE_F2,
    SC_SCANCODE_F3 = SDL_SCANCODE_F3,
    SC_SCANCODE_F4 = SDL_SCANCODE_F4,
    SC_SCANCODE_F5 = SDL_SCANCODE_F5,
    SC_SCANCODE_F6 = SDL_SCANCODE_F6,
    SC_SCANCODE_F7 = SDL_SCANCODE_F7,
    SC_SCANCODE_F8 = SDL_SCANCODE_F8,
    SC_SCANCODE_F9 = SDL_SCANCODE_F9,
    SC_SCANCODE_F10 = SDL_SCANCODE_F10,
    SC_SCANCODE_F11 = SDL_SCANCODE_F11,
    SC_SCANCODE_F12 = SDL_SCANCODE_F12,
    SC_SCANCODE_PRINTSCREEN = SDL_SCANCODE_PRINTSCREEN,
    SC_SCANCODE_SCROLLLOCK = SDL_SCANCODE_SCROLLLOCK,
    SC_SCANCODE_PAUSE = SDL_SCANCODE_PAUSE,
    SC_SCANCODE_INSERT = SDL_SCANCODE_INSERT,
    SC_SCANCODE_HOME = SDL_SCANCODE_HOME,
    SC_SCANCODE_PAGEUP = SDL_SCANCODE_PAGEUP,
    SC_SCANCODE_DELETE = SDL_SCANCODE_DELETE,
    SC_SCANCODE_END = SDL_SCANCODE_END,
    SC_SCANCODE_PAGEDOWN = SDL_SCANCODE_PAGEDOWN,
    SC_SCANCODE_RIGHT = SDL_SCANCODE_RIGHT,
    SC_SCANCODE_LEFT = SDL_SCANCODE_LEFT,
    SC_SCANCODE_DOWN = SDL_SCANCODE_DOWN,
    SC_SCANCODE_UP = SDL_SCANCODE_UP,
    SC_SCANCODE_NUMLOCK = SDL_SCANCODE_NUMLOCKCLEAR,
    SC_SCANCODE_KP_DIVIDE = SDL_SCANCODE_KP_DIVIDE,
    SC_SCANCODE_KP_MULTIPLY = SDL_SCANCODE_KP_MULTIPLY,
    SC_SCANCODE_KP_MINUS = SDL_SCANCODE_KP_MINUS,
    SC_SCANCODE_KP_PLUS = SDL_SCANCODE_KP_PLUS,
    SC_SCANCODE_KP_ENTER = SDL_SCANCODE_KP_ENTER,
    SC_SCANCODE_KP_1 = SDL_SCANCODE_KP_1,
    SC_SCANCODE_KP_2 = SDL_SCANCODE_KP_2,
    SC_SCANCODE_KP_3 = SDL_SCANCODE_KP_3,
    SC_SCANCODE_KP_4 = SDL_SCANCODE_KP_4,
    SC_SCANCODE_KP_5 = SDL_SCANCODE_KP_5,
    SC_SCANCODE_KP_6 = SDL_SCANCODE_KP_6,
    SC_SCANCODE_KP_7 = SDL_SCANCODE_KP_7,
    SC_SCANCODE_KP_8 = SDL_SCANCODE_KP_8,
    SC_SCANCODE_KP_9 = SDL_SCANCODE_KP_9,
    SC_SCANCODE_KP_0 = SDL_SCANCODE_KP_0,
    SC_SCANCODE_KP_PERIOD = SDL_SCANCODE_KP_PERIOD,
    SC_SCANCODE_LCTRL = SDL_SCANCODE_LCTRL,
    SC_SCANCODE_LSHIFT = SDL_SCANCODE_LSHIFT,
    SC_SCANCODE_LALT = SDL_SCANCODE_LALT,
    SC_SCANCODE_LGUI = SDL_SCANCODE_LGUI,
    SC_SCANCODE_RCTRL = SDL_SCANCODE_RCTRL,
    SC_SCANCODE_RSHIFT = SDL_SCANCODE_RSHIFT,
    SC_SCANCODE_RALT = SDL_SCANCODE_RALT,
    SC_SCANCODE_RGUI = SDL_SCANCODE_RGUI,
 };
 // On purpose, only use the "mask" values (1, 2, 4, 8, 16) for a single button,
 // to avoid unnecessary conversions (and confusion).
 enum sc_mouse_button {
    SC_MOUSE_BUTTON_UNKNOWN = 0,
    SC_MOUSE_BUTTON_LEFT = SDL_BUTTON(SDL_BUTTON_LEFT),
    SC_MOUSE_BUTTON_RIGHT = SDL_BUTTON(SDL_BUTTON_RIGHT),
    SC_MOUSE_BUTTON_MIDDLE = SDL_BUTTON(SDL_BUTTON_MIDDLE),
    SC_MOUSE_BUTTON_X1 = SDL_BUTTON(SDL_BUTTON_X1),
    SC_MOUSE_BUTTON_X2 = SDL_BUTTON(SDL_BUTTON_X2),
 };
 static_assert(sizeof(enum sc_mod) >= sizeof(SDL_Keymod),
              "SDL_Keymod must be convertible to sc_mod");
 static_assert(sizeof(enum sc_keycode) >= sizeof(SDL_Keycode),
              "SDL_Keycode must be convertible to sc_keycode");
 static_assert(sizeof(enum sc_scancode) >= sizeof(SDL_Scancode),
              "SDL_Scancode must be convertible to sc_scancode");
 enum sc_touch_action {
    SC_TOUCH_ACTION_MOVE,
    SC_TOUCH_ACTION_DOWN,
    SC_TOUCH_ACTION_UP,
 };
 struct sc_key_event {
    enum sc_action action;
    enum sc_keycode keycode;
    enum sc_scancode scancode;
    uint16_t mods_state; // bitwise-OR of sc_mod values
    bool repeat;
 };
 struct sc_text_event {
    const char *text; // not owned
 };
 struct sc_mouse_click_event {
    struct sc_position position;
    enum sc_action action;
    enum sc_mouse_button button;
    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
 };
 struct sc_mouse_scroll_event {
    struct sc_position position;
    int32_t hscroll;
    int32_t vscroll;
    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
 };
 struct sc_mouse_motion_event {
    struct sc_position position;
    int32_t xrel;
    int32_t yrel;
    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
 };
 struct sc_touch_event {
    struct sc_position position;
    enum sc_touch_action action;
    uint64_t pointer_id;
    float pressure;
 };
 #endif
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@@ -3,103 +3,33 @@
 #include <assert.h>
 #include <SDL2/SDL_keycode.h>
-#include "input_events.h"
+#include "event_converter.h"
 #include "screen.h"
 #include "util/log.h"
-static inline uint16_t
+static const int ACTION_DOWN = 1;
-sc_mods_state_from_sdl(uint16_t mods_state) {
+static const int ACTION_UP = 1 << 1;
    return mods_state;
 }
 static inline enum sc_keycode
 sc_keycode_from_sdl(SDL_Keycode keycode) {
    return (enum sc_keycode) keycode;
 }
 static inline enum sc_scancode
 sc_scancode_from_sdl(SDL_Scancode scancode) {
    return (enum sc_scancode) scancode;
 }
 static inline enum sc_action
 sc_action_from_sdl_keyboard_type(uint32_t type) {
    assert(type == SDL_KEYDOWN || type == SDL_KEYUP);
    if (type == SDL_KEYDOWN) {
        return SC_ACTION_DOWN;
    }
    return SC_ACTION_UP;
 }
 static inline enum sc_action
 sc_action_from_sdl_mousebutton_type(uint32_t type) {
    assert(type == SDL_MOUSEBUTTONDOWN || type == SDL_MOUSEBUTTONUP);
    if (type == SDL_MOUSEBUTTONDOWN) {
        return SC_ACTION_DOWN;
    }
    return SC_ACTION_UP;
 }
 static inline enum sc_touch_action
 sc_touch_action_from_sdl(uint32_t type) {
    assert(type == SDL_FINGERMOTION || type == SDL_FINGERDOWN ||
           type == SDL_FINGERUP);
    if (type == SDL_FINGERMOTION) {
        return SC_TOUCH_ACTION_MOVE;
    }
    if (type == SDL_FINGERDOWN) {
        return SC_TOUCH_ACTION_DOWN;
    }
    return SC_TOUCH_ACTION_UP;
 }
 static inline enum sc_mouse_button
 sc_mouse_button_from_sdl(uint8_t button) {
    if (button >= SDL_BUTTON_LEFT && button <= SDL_BUTTON_X2) {
        // SC_MOUSE_BUTTON_* constants are initialized from SDL_BUTTON(index)
        return SDL_BUTTON(button);
    }
    return SC_MOUSE_BUTTON_UNKNOWN;
 }
 static inline uint8_t
 sc_mouse_buttons_state_from_sdl(uint32_t buttons_state,
                                bool forward_all_clicks) {
    assert(buttons_state < 0x100); // fits in uint8_t
    uint8_t mask = SC_MOUSE_BUTTON_LEFT;
    if (forward_all_clicks) {
        mask |= SC_MOUSE_BUTTON_RIGHT
              | SC_MOUSE_BUTTON_MIDDLE
              | SC_MOUSE_BUTTON_X1
              | SC_MOUSE_BUTTON_X2;
    }
    return buttons_state & mask;
 }
 #define SC_SDL_SHORTCUT_MODS_MASK (KMOD_CTRL | KMOD_ALT | KMOD_GUI)
 static inline uint16_t
-to_sdl_mod(unsigned shortcut_mod) {
+to_sdl_mod(unsigned mod) {
    uint16_t sdl_mod = 0;
-    if (shortcut_mod & SC_SHORTCUT_MOD_LCTRL) {
+    if (mod & SC_MOD_LCTRL) {
        sdl_mod |= KMOD_LCTRL;
    }
-    if (shortcut_mod & SC_SHORTCUT_MOD_RCTRL) {
+    if (mod & SC_MOD_RCTRL) {
        sdl_mod |= KMOD_RCTRL;
    }
-    if (shortcut_mod & SC_SHORTCUT_MOD_LALT) {
+    if (mod & SC_MOD_LALT) {
        sdl_mod |= KMOD_LALT;
    }
-    if (shortcut_mod & SC_SHORTCUT_MOD_RALT) {
+    if (mod & SC_MOD_RALT) {
        sdl_mod |= KMOD_RALT;
    }
-    if (shortcut_mod & SC_SHORTCUT_MOD_LSUPER) {
+    if (mod & SC_MOD_LSUPER) {
        sdl_mod |= KMOD_LGUI;
    }
-    if (shortcut_mod & SC_SHORTCUT_MOD_RSUPER) {
+    if (mod & SC_MOD_RSUPER) {
        sdl_mod |= KMOD_RGUI;
    }
    return sdl_mod;
@@ -122,22 +52,20 @@ is_shortcut_mod(struct input_manager *im, uint16_t sdl_mod) {
 }
 void
-input_manager_init(struct input_manager *im,
+input_manager_init(struct input_manager *im, struct controller *controller,
-                   const struct input_manager_params *params) {
+                   struct screen *screen,
-    assert(!params->control || (params->kp && params->kp->ops));
+                   const struct scrcpy_options *options) {
-    assert(!params->control || (params->mp && params->mp->ops));
+    im->controller = controller;
    im->screen = screen;
    im->repeat = 0;
-    im->controller = params->controller;
+    im->control = options->control;
-    im->screen = params->screen;
+    im->forward_key_repeat = options->forward_key_repeat;
-    im->kp = params->kp;
+    im->prefer_text = options->prefer_text;
-    im->mp = params->mp;
+    im->forward_all_clicks = options->forward_all_clicks;
    im->legacy_paste = options->legacy_paste;
-    im->control = params->control;
+    const struct sc_shortcut_mods *shortcut_mods = &options->shortcut_mods;
    im->forward_all_clicks = params->forward_all_clicks;
    im->legacy_paste = params->legacy_paste;
    im->clipboard_autosync = params->clipboard_autosync;
    const struct sc_shortcut_mods *shortcut_mods = params->shortcut_mods;
    assert(shortcut_mods->count);
    assert(shortcut_mods->count < SC_MAX_SHORTCUT_MODS);
    for (unsigned i = 0; i < shortcut_mods->count; ++i) {
@@ -152,81 +80,102 @@ input_manager_init(struct input_manager *im,
    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
 send_keycode(struct controller *controller, enum android_keycode keycode,
-             enum sc_action action, const char *name) {
+             int actions, const char *name) {
    // send DOWN event
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
    msg.inject_keycode.action = action == SC_ACTION_DOWN
                              ? AKEY_EVENT_ACTION_DOWN
                              : AKEY_EVENT_ACTION_UP;
    msg.inject_keycode.keycode = keycode;
    msg.inject_keycode.metastate = 0;
    msg.inject_keycode.repeat = 0;
    if (actions & ACTION_DOWN) {
        msg.inject_keycode.action = AKEY_EVENT_ACTION_DOWN;
        if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request 'inject %s'", name);
+            LOGW("Could not request 'inject %s (DOWN)'", name);
            return;
        }
    }
-static inline void
+    if (actions & ACTION_UP) {
-action_home(struct controller *controller, enum sc_action action) {
+        msg.inject_keycode.action = AKEY_EVENT_ACTION_UP;
-    send_keycode(controller, AKEYCODE_HOME, action, "HOME");
+        if (!controller_push_msg(controller, &msg)) {
            LOGW("Could not request 'inject %s (UP)'", name);
        }
    }
 }
 static inline void
-action_back(struct controller *controller, enum sc_action action) {
+action_home(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_BACK, action, "BACK");
+    send_keycode(controller, AKEYCODE_HOME, actions, "HOME");
 }
 static inline void
-action_app_switch(struct controller *controller, enum sc_action action) {
+action_back(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_APP_SWITCH, action, "APP_SWITCH");
+    send_keycode(controller, AKEYCODE_BACK, actions, "BACK");
 }
 static inline void
-action_power(struct controller *controller, enum sc_action action) {
+action_app_switch(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_POWER, action, "POWER");
+    send_keycode(controller, AKEYCODE_APP_SWITCH, actions, "APP_SWITCH");
 }
 static inline void
-action_volume_up(struct controller *controller, enum sc_action action) {
+action_power(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_VOLUME_UP, action, "VOLUME_UP");
+    send_keycode(controller, AKEYCODE_POWER, actions, "POWER");
 }
 static inline void
-action_volume_down(struct controller *controller, enum sc_action action) {
+action_volume_up(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_VOLUME_DOWN, action, "VOLUME_DOWN");
+    send_keycode(controller, AKEYCODE_VOLUME_UP, actions, "VOLUME_UP");
 }
 static inline void
-action_menu(struct controller *controller, enum sc_action action) {
+action_volume_down(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_MENU, action, "MENU");
+    send_keycode(controller, AKEYCODE_VOLUME_DOWN, actions, "VOLUME_DOWN");
 }
 static inline void
 action_menu(struct controller *controller, int actions) {
    send_keycode(controller, AKEYCODE_MENU, actions, "MENU");
 }
 static inline void
 action_copy(struct controller *controller, int actions) {
    send_keycode(controller, AKEYCODE_COPY, actions, "COPY");
 }
 static inline void
 action_cut(struct controller *controller, int actions) {
    send_keycode(controller, AKEYCODE_CUT, actions, "CUT");
 }
 // turn the screen on if it was off, press BACK otherwise
 // If the screen is off, it is turned on only on ACTION_DOWN
 static void
-press_back_or_turn_screen_on(struct controller *controller,
+press_back_or_turn_screen_on(struct controller *controller, int actions) {
                             enum sc_action action) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
    msg.back_or_screen_on.action = action == SC_ACTION_DOWN
                                 ? AKEY_EVENT_ACTION_DOWN
                                 : AKEY_EVENT_ACTION_UP;
    if (actions & ACTION_DOWN) {
        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_DOWN;
        if (!controller_push_msg(controller, &msg)) {
            LOGW("Could not request 'press back or turn screen on'");
            return;
        }
    }
    if (actions & ACTION_UP) {
        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_UP;
        if (!controller_push_msg(controller, &msg)) {
            LOGW("Could not request 'press back or turn screen on'");
        }
    }
 }
 static void
 expand_notification_panel(struct controller *controller) {
    struct control_msg msg;
@@ -257,50 +206,35 @@ collapse_panels(struct controller *controller) {
    }
 }
-static bool
+static void
-get_device_clipboard(struct controller *controller,
+set_device_clipboard(struct controller *controller, bool paste) {
                     enum get_clipboard_copy_key copy_key) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_GET_CLIPBOARD;
    msg.get_clipboard.copy_key = copy_key;
    if (!controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'get device clipboard'");
        return false;
    }
    return true;
 }
 static bool
 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
@@ -385,27 +319,36 @@ rotate_client_right(struct screen *screen) {
 static void
 input_manager_process_text_input(struct input_manager *im,
                                 const SDL_TextInputEvent *event) {
    if (!im->kp->ops->process_text) {
        // The key processor does not support text input
        return;
    }
    if (is_shortcut_mod(im, SDL_GetModState())) {
        // A shortcut must never generate text events
        return;
    }
    if (!im->prefer_text) {
        char c = event->text[0];
        if (isalpha(c) || c == ' ') {
            assert(event->text[1] == '\0');
            // letters and space are handled as raw key event
            return;
        }
    }
-    struct sc_text_event evt = {
+    struct control_msg msg;
-        .text = event->text,
+    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    };
+    msg.inject_text.text = strdup(event->text);
-
+    if (!msg.inject_text.text) {
-    im->kp->ops->process_text(im->kp, &evt);
+        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;
@@ -425,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) {
@@ -461,7 +425,7 @@ input_manager_process_key(struct input_manager *im,
    // The shortcut modifier is pressed
    if (smod) {
-        enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
+        int action = down ? ACTION_DOWN : ACTION_UP;
        switch (keycode) {
            case SDLK_h:
                if (control && !shift && !repeat) {
@@ -520,15 +484,13 @@ input_manager_process_key(struct input_manager *im,
                }
                return;
            case SDLK_c:
-                if (control && !shift && !repeat && down) {
+                if (control && !shift && !repeat) {
-                    get_device_clipboard(controller,
+                    action_copy(controller, action);
                                         GET_CLIPBOARD_COPY_KEY_COPY);
                }
                return;
            case SDLK_x:
-                if (control && !shift && !repeat && down) {
+                if (control && !shift && !repeat) {
-                    get_device_clipboard(controller,
+                    action_cut(controller, action);
                                         GET_CLIPBOARD_COPY_KEY_CUT);
                }
                return;
            case SDLK_v:
@@ -537,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;
@@ -589,116 +549,133 @@ 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 (im->clipboard_autosync && 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) {
+    struct control_msg msg;
-            // The key processor must wait for this ack before injecting Ctrl+v
+    if (convert_input_key(event, &msg, im->prefer_text, im->repeat)) {
-            ack_to_wait = sequence;
+        if (!controller_push_msg(controller, &msg)) {
-            // Increment only when the request succeeded
+            LOGW("Could not request 'inject keycode'");
-            ++im->next_sequence;
+        }
    }
 }
-    struct sc_key_event evt = {
+static bool
-        .action = sc_action_from_sdl_keyboard_type(event->type),
+convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
-        .keycode = sc_keycode_from_sdl(event->keysym.sym),
+                     struct control_msg *to) {
-        .scancode = sc_scancode_from_sdl(event->keysym.scancode),
+    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-        .repeat = event->repeat,
+    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
-        .mods_state = sc_mods_state_from_sdl(event->keysym.mod),
+    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);
-    assert(im->kp->ops->process_key);
+    return true;
    im->kp->ops->process_key(im->kp, &evt, ack_to_wait);
 }
 static void
 input_manager_process_mouse_motion(struct input_manager *im,
                                   const SDL_MouseMotionEvent *event) {
-
+    if (!event->state) {
-    uint32_t mask = SDL_BUTTON_LMASK;
+        // do not send motion events when no button is pressed
-    if (im->forward_all_clicks) {
+        return;
        mask |= SDL_BUTTON_MMASK | SDL_BUTTON_RMASK;
    }
    //if (!(event->state & mask)) {
    //    // do not send motion events when no click is pressed
    //    return;
    //}
    if (event->which == SDL_TOUCH_MOUSEID) {
        // simulated from touch events, so it's a duplicate
        return;
    }
    struct control_msg msg;
    if (!convert_mouse_motion(event, im->screen, &msg)) {
        return;
    }
-    struct sc_mouse_motion_event evt = {
+    if (!controller_push_msg(im->controller, &msg)) {
-        .position = {
+        LOGW("Could not request 'inject mouse motion event'");
-            .screen_size = im->screen->frame_size,
+    }
            .point = screen_convert_window_to_frame_coords(im->screen,
                                                           event->x, event->y),
        },
        .xrel = event->xrel,
        .yrel = event->yrel,
        .buttons_state =
            sc_mouse_buttons_state_from_sdl(event->state,
                                            im->forward_all_clicks),
    };
    assert(im->mp->ops->process_mouse_motion);
    im->mp->ops->process_mouse_motion(im->mp, &evt);
    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) {
-    if (!im->mp->ops->process_touch) {
+    struct control_msg msg;
-        // The mouse processor does not support touch events
+    if (convert_touch(event, im->screen, &msg)) {
-        return;
+        if (!controller_push_msg(im->controller, &msg)) {
            LOGW("Could not request 'inject touch event'");
        }
    }
 }
-    int dw;
+static bool
-    int dh;
+convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
-    SDL_GL_GetDrawableSize(im->screen->window, &dw, &dh);
+                     struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-    // SDL touch event coordinates are normalized in the range [0; 1]
+    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
-    int32_t x = event->x * dw;
+        return false;
-    int32_t y = event->y * dh;
+    }
-    struct sc_touch_event evt = {
+    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-        .position = {
+    to->inject_touch_event.position.screen_size = screen->frame_size;
-            .screen_size = im->screen->frame_size,
+    to->inject_touch_event.position.point =
-            .point = screen_convert_drawable_to_frame_coords(im->screen, x, y),
+        screen_convert_window_to_frame_coords(screen, from->x, from->y);
-        },
+    to->inject_touch_event.pressure =
-        .action = sc_touch_action_from_sdl(event->type),
+        from->type == SDL_MOUSEBUTTONDOWN ? 1.f : 0.f;
-        .pointer_id = event->fingerId,
+    to->inject_touch_event.buttons =
-        .pressure = event->pressure,
+        convert_mouse_buttons(SDL_BUTTON(from->button));
    };
-    im->mp->ops->process_touch(im->mp, &evt);
+    return true;
 }
 static void
@@ -713,7 +690,7 @@ input_manager_process_mouse_button(struct input_manager *im,
    bool down = event->type == SDL_MOUSEBUTTONDOWN;
    if (!im->forward_all_clicks) {
-        enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
+        int action = down ? ACTION_DOWN : ACTION_UP;
        if (control && event->button == SDL_BUTTON_X1) {
            action_app_switch(im->controller, action);
@@ -758,27 +735,13 @@ input_manager_process_mouse_button(struct input_manager *im,
        return;
    }
-    uint32_t sdl_buttons_state = SDL_GetMouseState(NULL, NULL);
+    struct control_msg msg;
    if (!convert_mouse_button(event, im->screen, &msg)) {
        return;
    }
-    struct sc_mouse_click_event evt = {
+    if (!controller_push_msg(im->controller, &msg)) {
-        .position = {
+        LOGW("Could not request 'inject mouse button event'");
            .screen_size = im->screen->frame_size,
            .point = screen_convert_window_to_frame_coords(im->screen, event->x,
                                                           event->y),
        },
        .action = sc_action_from_sdl_mousebutton_type(event->type),
        .button = sc_mouse_button_from_sdl(event->button),
        .buttons_state =
            sc_mouse_buttons_state_from_sdl(sdl_buttons_state,
                                            im->forward_all_clicks),
    };
    assert(im->mp->ops->process_mouse_click);
    im->mp->ops->process_mouse_click(im->mp, &evt);
    if (im->mp->relative_mode) {
        assert(!im->vfinger_down); // vfinger must not be used in relative mode
        // No pinch-to-zoom simulation
        return;
    }
@@ -794,10 +757,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;
@@ -808,32 +769,39 @@ input_manager_process_mouse_button(struct input_manager *im,
    }
 }
-static void
+static bool
-input_manager_process_mouse_wheel(struct input_manager *im,
+convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
-                                  const SDL_MouseWheelEvent *event) {
+                    struct control_msg *to) {
    if (!im->mp->ops->process_mouse_scroll) {
        // The mouse processor does not support scroll events
        return;
    }
    // mouse_x and mouse_y are expressed in pixels relative to the window
    int mouse_x;
    int mouse_y;
-    uint32_t buttons = SDL_GetMouseState(&mouse_x, &mouse_y);
+    SDL_GetMouseState(&mouse_x, &mouse_y);
-    struct sc_mouse_scroll_event evt = {
+    struct position position = {
-        .position = {
+        .screen_size = screen->frame_size,
-            .screen_size = im->screen->frame_size,
+        .point = screen_convert_window_to_frame_coords(screen,
            .point = screen_convert_window_to_frame_coords(im->screen,
                                                       mouse_x, mouse_y),
        },
        .hscroll = event->x,
        .vscroll = event->y,
        .buttons_state =
            sc_mouse_buttons_state_from_sdl(buttons, im->forward_all_clicks),
    };
-    im->mp->ops->process_mouse_scroll(im->mp, &evt);
+    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
    to->inject_scroll_event.position = position;
    to->inject_scroll_event.hscroll = from->x;
    to->inject_scroll_event.vscroll = from->y;
    return true;
 }
 static void
 input_manager_process_mouse_wheel(struct input_manager *im,
                                  const SDL_MouseWheelEvent *event) {
    struct control_msg msg;
    if (convert_mouse_wheel(event, im->screen, &msg)) {
        if (!controller_push_msg(im->controller, &msg)) {
            LOGW("Could not request 'inject mouse wheel event'");
        }
    }
 }
 bool
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@@ -9,23 +9,22 @@
 #include "controller.h"
 #include "fps_counter.h"
-#include "options.h"
+#include "scrcpy.h"
-#include "trait/key_processor.h"
+#include "screen.h"
 #include "trait/mouse_processor.h"
 struct screen; // forward declaration to avoid cycle
 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;
    bool clipboard_autosync;
    struct {
        unsigned data[SC_MAX_SHORTCUT_MODS];
@@ -40,26 +39,11 @@ struct input_manager {
    unsigned key_repeat;
    SDL_Keycode last_keycode;
    uint16_t last_mod;
    uint64_t next_sequence; // used for request acknowledgements
 };
 struct input_manager_params {
    struct controller *controller;
    struct screen *screen;
    struct sc_key_processor *kp;
    struct sc_mouse_processor *mp;
    bool control;
    bool forward_all_clicks;
    bool legacy_paste;
    bool clipboard_autosync;
    const struct sc_shortcut_mods *shortcut_mods;
 };
 void
-input_manager_init(struct input_manager *im,
+input_manager_init(struct input_manager *im, struct controller *controller,
-                   const struct input_manager_params *params);
+                   struct screen *screen, const struct scrcpy_options *options);
 bool
 input_manager_handle_event(struct input_manager *im, SDL_Event *event);
--- a/app/src/keyboard_inject.c
+++ b/app/src/keyboard_inject.c
@@ -1,343 +0,0 @@
 #include "keyboard_inject.h"
 #include <assert.h>
 #include "android/input.h"
 #include "control_msg.h"
 #include "controller.h"
 #include "input_events.h"
 #include "util/intmap.h"
 #include "util/log.h"
 /** Downcast key processor to sc_keyboard_inject */
 #define DOWNCAST(KP) container_of(KP, struct sc_keyboard_inject, key_processor)
 static enum android_keyevent_action
 convert_keycode_action(enum sc_action action) {
    if (action == SC_ACTION_DOWN) {
        return AKEY_EVENT_ACTION_DOWN;
    }
    assert(action == SC_ACTION_UP);
    return AKEY_EVENT_ACTION_UP;
 }
 static bool
 convert_keycode(enum sc_keycode from, enum android_keycode *to, uint16_t mod,
                enum sc_key_inject_mode key_inject_mode) {
    // Navigation keys and ENTER.
    // Used in all modes.
    static const struct sc_intmap_entry special_keys[] = {
        {SC_KEYCODE_RETURN,    AKEYCODE_ENTER},
        {SC_KEYCODE_KP_ENTER,  AKEYCODE_NUMPAD_ENTER},
        {SC_KEYCODE_ESCAPE,    AKEYCODE_ESCAPE},
        {SC_KEYCODE_BACKSPACE, AKEYCODE_DEL},
        {SC_KEYCODE_TAB,       AKEYCODE_TAB},
        {SC_KEYCODE_PAGEUP,    AKEYCODE_PAGE_UP},
        {SC_KEYCODE_DELETE,    AKEYCODE_FORWARD_DEL},
        {SC_KEYCODE_HOME,      AKEYCODE_MOVE_HOME},
        {SC_KEYCODE_END,       AKEYCODE_MOVE_END},
        {SC_KEYCODE_PAGEDOWN,  AKEYCODE_PAGE_DOWN},
        {SC_KEYCODE_RIGHT,     AKEYCODE_DPAD_RIGHT},
        {SC_KEYCODE_LEFT,      AKEYCODE_DPAD_LEFT},
        {SC_KEYCODE_DOWN,      AKEYCODE_DPAD_DOWN},
        {SC_KEYCODE_UP,        AKEYCODE_DPAD_UP},
        {SC_KEYCODE_LCTRL,     AKEYCODE_CTRL_LEFT},
        {SC_KEYCODE_RCTRL,     AKEYCODE_CTRL_RIGHT},
        {SC_KEYCODE_LSHIFT,    AKEYCODE_SHIFT_LEFT},
        {SC_KEYCODE_RSHIFT,    AKEYCODE_SHIFT_RIGHT},
    };
    // Numpad navigation keys.
    // Used in all modes, when NumLock and Shift are disabled.
    static const struct sc_intmap_entry kp_nav_keys[] = {
        {SC_KEYCODE_KP_0,      AKEYCODE_INSERT},
        {SC_KEYCODE_KP_1,      AKEYCODE_MOVE_END},
        {SC_KEYCODE_KP_2,      AKEYCODE_DPAD_DOWN},
        {SC_KEYCODE_KP_3,      AKEYCODE_PAGE_DOWN},
        {SC_KEYCODE_KP_4,      AKEYCODE_DPAD_LEFT},
        {SC_KEYCODE_KP_6,      AKEYCODE_DPAD_RIGHT},
        {SC_KEYCODE_KP_7,      AKEYCODE_MOVE_HOME},
        {SC_KEYCODE_KP_8,      AKEYCODE_DPAD_UP},
        {SC_KEYCODE_KP_9,      AKEYCODE_PAGE_UP},
        {SC_KEYCODE_KP_PERIOD, AKEYCODE_FORWARD_DEL},
    };
    // Letters and space.
    // Used in non-text mode.
    static const struct sc_intmap_entry alphaspace_keys[] = {
        {SC_KEYCODE_a,         AKEYCODE_A},
        {SC_KEYCODE_b,         AKEYCODE_B},
        {SC_KEYCODE_c,         AKEYCODE_C},
        {SC_KEYCODE_d,         AKEYCODE_D},
        {SC_KEYCODE_e,         AKEYCODE_E},
        {SC_KEYCODE_f,         AKEYCODE_F},
        {SC_KEYCODE_g,         AKEYCODE_G},
        {SC_KEYCODE_h,         AKEYCODE_H},
        {SC_KEYCODE_i,         AKEYCODE_I},
        {SC_KEYCODE_j,         AKEYCODE_J},
        {SC_KEYCODE_k,         AKEYCODE_K},
        {SC_KEYCODE_l,         AKEYCODE_L},
        {SC_KEYCODE_m,         AKEYCODE_M},
        {SC_KEYCODE_n,         AKEYCODE_N},
        {SC_KEYCODE_o,         AKEYCODE_O},
        {SC_KEYCODE_p,         AKEYCODE_P},
        {SC_KEYCODE_q,         AKEYCODE_Q},
        {SC_KEYCODE_r,         AKEYCODE_R},
        {SC_KEYCODE_s,         AKEYCODE_S},
        {SC_KEYCODE_t,         AKEYCODE_T},
        {SC_KEYCODE_u,         AKEYCODE_U},
        {SC_KEYCODE_v,         AKEYCODE_V},
        {SC_KEYCODE_w,         AKEYCODE_W},
        {SC_KEYCODE_x,         AKEYCODE_X},
        {SC_KEYCODE_y,         AKEYCODE_Y},
        {SC_KEYCODE_z,         AKEYCODE_Z},
        {SC_KEYCODE_SPACE,     AKEYCODE_SPACE},
    };
    // Numbers and punctuation keys.
    // Used in raw mode only.
    static const struct sc_intmap_entry numbers_punct_keys[] = {
        {SC_KEYCODE_HASH,          AKEYCODE_POUND},
        {SC_KEYCODE_PERCENT,       AKEYCODE_PERIOD},
        {SC_KEYCODE_QUOTE,         AKEYCODE_APOSTROPHE},
        {SC_KEYCODE_ASTERISK,      AKEYCODE_STAR},
        {SC_KEYCODE_PLUS,          AKEYCODE_PLUS},
        {SC_KEYCODE_COMMA,         AKEYCODE_COMMA},
        {SC_KEYCODE_MINUS,         AKEYCODE_MINUS},
        {SC_KEYCODE_PERIOD,        AKEYCODE_PERIOD},
        {SC_KEYCODE_SLASH,         AKEYCODE_SLASH},
        {SC_KEYCODE_0,             AKEYCODE_0},
        {SC_KEYCODE_1,             AKEYCODE_1},
        {SC_KEYCODE_2,             AKEYCODE_2},
        {SC_KEYCODE_3,             AKEYCODE_3},
        {SC_KEYCODE_4,             AKEYCODE_4},
        {SC_KEYCODE_5,             AKEYCODE_5},
        {SC_KEYCODE_6,             AKEYCODE_6},
        {SC_KEYCODE_7,             AKEYCODE_7},
        {SC_KEYCODE_8,             AKEYCODE_8},
        {SC_KEYCODE_9,             AKEYCODE_9},
        {SC_KEYCODE_SEMICOLON,     AKEYCODE_SEMICOLON},
        {SC_KEYCODE_EQUALS,        AKEYCODE_EQUALS},
        {SC_KEYCODE_AT,            AKEYCODE_AT},
        {SC_KEYCODE_LEFTBRACKET,   AKEYCODE_LEFT_BRACKET},
        {SC_KEYCODE_BACKSLASH,     AKEYCODE_BACKSLASH},
        {SC_KEYCODE_RIGHTBRACKET,  AKEYCODE_RIGHT_BRACKET},
        {SC_KEYCODE_BACKQUOTE,     AKEYCODE_GRAVE},
        {SC_KEYCODE_KP_1,          AKEYCODE_NUMPAD_1},
        {SC_KEYCODE_KP_2,          AKEYCODE_NUMPAD_2},
        {SC_KEYCODE_KP_3,          AKEYCODE_NUMPAD_3},
        {SC_KEYCODE_KP_4,          AKEYCODE_NUMPAD_4},
        {SC_KEYCODE_KP_5,          AKEYCODE_NUMPAD_5},
        {SC_KEYCODE_KP_6,          AKEYCODE_NUMPAD_6},
        {SC_KEYCODE_KP_7,          AKEYCODE_NUMPAD_7},
        {SC_KEYCODE_KP_8,          AKEYCODE_NUMPAD_8},
        {SC_KEYCODE_KP_9,          AKEYCODE_NUMPAD_9},
        {SC_KEYCODE_KP_0,          AKEYCODE_NUMPAD_0},
        {SC_KEYCODE_KP_DIVIDE,     AKEYCODE_NUMPAD_DIVIDE},
        {SC_KEYCODE_KP_MULTIPLY,   AKEYCODE_NUMPAD_MULTIPLY},
        {SC_KEYCODE_KP_MINUS,      AKEYCODE_NUMPAD_SUBTRACT},
        {SC_KEYCODE_KP_PLUS,       AKEYCODE_NUMPAD_ADD},
        {SC_KEYCODE_KP_PERIOD,     AKEYCODE_NUMPAD_DOT},
        {SC_KEYCODE_KP_EQUALS,     AKEYCODE_NUMPAD_EQUALS},
        {SC_KEYCODE_KP_LEFTPAREN,  AKEYCODE_NUMPAD_LEFT_PAREN},
        {SC_KEYCODE_KP_RIGHTPAREN, AKEYCODE_NUMPAD_RIGHT_PAREN},
    };
    const struct sc_intmap_entry *entry =
        SC_INTMAP_FIND_ENTRY(special_keys, from);
    if (entry) {
        *to = entry->value;
        return true;
    }
    if (!(mod & (SC_MOD_NUM | SC_MOD_LSHIFT | SC_MOD_RSHIFT))) {
        // Handle Numpad events when Num Lock is disabled
        // If SHIFT is pressed, a text event will be sent instead
        entry = SC_INTMAP_FIND_ENTRY(kp_nav_keys, from);
        if (entry) {
            *to = entry->value;
            return true;
        }
    }
    if (key_inject_mode == SC_KEY_INJECT_MODE_TEXT &&
            !(mod & (SC_MOD_LCTRL | SC_MOD_RCTRL))) {
        // do not forward alpha and space key events (unless Ctrl is pressed)
        return false;
    }
    if (mod & (SC_MOD_LALT | SC_MOD_RALT | SC_MOD_LGUI | SC_MOD_RGUI)) {
        return false;
    }
    // if ALT and META are not pressed, also handle letters and space
    entry = SC_INTMAP_FIND_ENTRY(alphaspace_keys, from);
    if (entry) {
        *to = entry->value;
        return true;
    }
    if (key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
        entry = SC_INTMAP_FIND_ENTRY(numbers_punct_keys, from);
        if (entry) {
            *to = entry->value;
            return true;
        }
    }
    return false;
 }
 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;
 }
 static enum android_metastate
 convert_meta_state(uint16_t mod) {
    enum android_metastate metastate = 0;
    if (mod & SC_MOD_LSHIFT) {
        metastate |= AMETA_SHIFT_LEFT_ON;
    }
    if (mod & SC_MOD_RSHIFT) {
        metastate |= AMETA_SHIFT_RIGHT_ON;
    }
    if (mod & SC_MOD_LCTRL) {
        metastate |= AMETA_CTRL_LEFT_ON;
    }
    if (mod & SC_MOD_RCTRL) {
        metastate |= AMETA_CTRL_RIGHT_ON;
    }
    if (mod & SC_MOD_LALT) {
        metastate |= AMETA_ALT_LEFT_ON;
    }
    if (mod & SC_MOD_RALT) {
        metastate |= AMETA_ALT_RIGHT_ON;
    }
    if (mod & SC_MOD_LGUI) { // Windows key
        metastate |= AMETA_META_LEFT_ON;
    }
    if (mod & SC_MOD_RGUI) { // Windows key
        metastate |= AMETA_META_RIGHT_ON;
    }
    if (mod & SC_MOD_NUM) {
        metastate |= AMETA_NUM_LOCK_ON;
    }
    if (mod & SC_MOD_CAPS) {
        metastate |= AMETA_CAPS_LOCK_ON;
    }
    // fill the dependent fields
    return autocomplete_metastate(metastate);
 }
 static bool
 convert_input_key(const struct sc_key_event *event, struct control_msg *msg,
                  enum sc_key_inject_mode key_inject_mode, uint32_t repeat) {
    msg->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
    if (!convert_keycode(event->keycode, &msg->inject_keycode.keycode,
                         event->mods_state, key_inject_mode)) {
        return false;
    }
    msg->inject_keycode.action = convert_keycode_action(event->action);
    msg->inject_keycode.repeat = repeat;
    msg->inject_keycode.metastate = convert_meta_state(event->mods_state);
    return true;
 }
 static void
 sc_key_processor_process_key(struct sc_key_processor *kp,
                             const struct sc_key_event *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->key_inject_mode, ki->repeat)) {
        if (!controller_push_msg(ki->controller, &msg)) {
            LOGW("Could not request 'inject keycode'");
        }
    }
 }
 static void
 sc_key_processor_process_text(struct sc_key_processor *kp,
                              const struct sc_text_event *event) {
    struct sc_keyboard_inject *ki = DOWNCAST(kp);
    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
        // Never inject text events
        return;
    }
    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_MIXED) {
        char c = event->text[0];
        if (isalpha(c) || c == ' ') {
            assert(event->text[1] == '\0');
            // Letters and space are handled as raw key events
            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->key_inject_mode = options->key_inject_mode;
    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/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;
    enum sc_key_inject_mode key_inject_mode;
    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
@@ -38,6 +38,24 @@ print_version(void) {
 #endif
 }
 static SDL_LogPriority
 convert_log_level_to_sdl(enum sc_log_level level) {
    switch (level) {
        case SC_LOG_LEVEL_DEBUG:
            return SDL_LOG_PRIORITY_DEBUG;
        case SC_LOG_LEVEL_INFO:
            return SDL_LOG_PRIORITY_INFO;
        case SC_LOG_LEVEL_WARN:
            return SDL_LOG_PRIORITY_WARN;
        case SC_LOG_LEVEL_ERROR:
            return SDL_LOG_PRIORITY_ERROR;
        default:
            assert(!"unexpected log level");
            return SDL_LOG_PRIORITY_INFO;
    }
 }
 int
 main(int argc, char *argv[]) {
 #ifdef __WINDOWS__
@@ -47,11 +65,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,
    };
@@ -64,7 +79,8 @@ main(int argc, char *argv[]) {
        return 1;
    }
-    sc_set_log_level(args.opts.log_level);
+    SDL_LogPriority sdl_log = convert_log_level_to_sdl(args.opts.log_level);
    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, sdl_log);
    if (args.help) {
        scrcpy_print_usage(argv[0]);
@@ -76,6 +92,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,156 +0,0 @@
 #include "mouse_inject.h"
 #include <assert.h>
 #include "android/input.h"
 #include "control_msg.h"
 #include "controller.h"
 #include "input_events.h"
 #include "util/intmap.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 & SC_MOUSE_BUTTON_LEFT) {
        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
    }
    if (state & SC_MOUSE_BUTTON_RIGHT) {
        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
    }
    if (state & SC_MOUSE_BUTTON_MIDDLE) {
        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
    }
    if (state & SC_MOUSE_BUTTON_X1) {
        buttons |= AMOTION_EVENT_BUTTON_BACK;
    }
    if (state & SC_MOUSE_BUTTON_X2) {
        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
    }
    return buttons;
 }
 static enum android_motionevent_action
 convert_mouse_action(enum sc_action action) {
    if (action == SC_ACTION_DOWN) {
        return AMOTION_EVENT_ACTION_DOWN;
    }
    assert(action == SC_ACTION_UP);
    return AMOTION_EVENT_ACTION_UP;
 }
 static enum android_motionevent_action
 convert_touch_action(enum sc_touch_action action) {
    switch (action) {
        case SC_TOUCH_ACTION_MOVE:
            return AMOTION_EVENT_ACTION_MOVE;
        case SC_TOUCH_ACTION_DOWN:
            return AMOTION_EVENT_ACTION_DOWN;
        default:
            assert(action == SC_TOUCH_ACTION_UP);
            return AMOTION_EVENT_ACTION_UP;
    }
 }
 static void
 sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
                                    const struct sc_mouse_motion_event *event) {
    struct sc_mouse_inject *mi = DOWNCAST(mp);
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
        .inject_touch_event = {
            .action = AMOTION_EVENT_ACTION_MOVE,
            .pointer_id = POINTER_ID_MOUSE,
            .position = event->position,
            .pressure = 1.f,
            .buttons = convert_mouse_buttons(event->buttons_state),
        },
    };
    if (!controller_push_msg(mi->controller, &msg)) {
        LOGW("Could not request 'inject mouse motion event'");
    }
 }
 static void
 sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
                                    const struct sc_mouse_click_event *event) {
    struct sc_mouse_inject *mi = DOWNCAST(mp);
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
        .inject_touch_event = {
            .action = convert_mouse_action(event->action),
            .pointer_id = POINTER_ID_MOUSE,
            .position = event->position,
            .pressure = event->action == SC_ACTION_DOWN ? 1.f : 0.f,
            .buttons = convert_mouse_buttons(event->buttons_state),
        },
    };
    if (!controller_push_msg(mi->controller, &msg)) {
        LOGW("Could not request 'inject mouse click event'");
    }
 }
 static void
 sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
                                   const struct sc_mouse_scroll_event *event) {
    struct sc_mouse_inject *mi = DOWNCAST(mp);
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
        .inject_scroll_event = {
            .position = event->position,
            .hscroll = event->hscroll,
            .vscroll = event->vscroll,
            .buttons = convert_mouse_buttons(event->buttons_state),
        },
    };
    if (!controller_push_msg(mi->controller, &msg)) {
        LOGW("Could not request 'inject mouse scroll event'");
    }
 }
 static void
 sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
                                 const struct sc_touch_event *event) {
    struct sc_mouse_inject *mi = DOWNCAST(mp);
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
        .inject_touch_event = {
            .action = convert_touch_action(event->action),
            .pointer_id = event->pointer_id,
            .position = event->position,
            .pressure = event->pressure,
            .buttons = 0,
        },
    };
    if (!controller_push_msg(mi->controller, &msg)) {
        LOGW("Could not request 'inject touch event'");
    }
 }
 void
 sc_mouse_inject_init(struct sc_mouse_inject *mi,
                     struct controller *controller) {
    mi->controller = controller;
    static const struct sc_mouse_processor_ops ops = {
        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
        .process_mouse_click = sc_mouse_processor_process_mouse_click,
        .process_mouse_scroll = sc_mouse_processor_process_mouse_scroll,
        .process_touch = sc_mouse_processor_process_touch,
    };
    mi->mouse_processor.ops = &ops;
    mi->mouse_processor.relative_mode = false;
 }
--- a/app/src/mouse_inject.h
+++ b/app/src/mouse_inject.h
@@ -1,21 +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;
 };
 void
 sc_mouse_inject_init(struct sc_mouse_inject *mi, struct controller *controller);
 #endif
--- a/app/src/options.c
+++ b/app/src/options.c
@@ -1,59 +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_SHORTCUT_MOD_LALT, SC_SHORTCUT_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,
    .key_inject_mode = SC_KEY_INJECT_MODE_MIXED,
    .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,
    .clipboard_autosync = true,
    .tcpip = false,
    .tcpip_dst = NULL,
 };
--- a/app/src/options.h
+++ b/app/src/options.h
@@ -1,132 +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,
 };
 enum sc_key_inject_mode {
    // Inject special keys, letters and space as key events.
    // Inject numbers and punctuation as text events.
    // This is the default mode.
    SC_KEY_INJECT_MODE_MIXED,
    // Inject special keys as key events.
    // Inject letters and space, numbers and punctuation as text events.
    SC_KEY_INJECT_MODE_TEXT,
    // Inject everything as key events.
    SC_KEY_INJECT_MODE_RAW,
 };
 #define SC_MAX_SHORTCUT_MODS 8
 enum sc_shortcut_mod {
    SC_SHORTCUT_MOD_LCTRL = 1 << 0,
    SC_SHORTCUT_MOD_RCTRL = 1 << 1,
    SC_SHORTCUT_MOD_LALT = 1 << 2,
    SC_SHORTCUT_MOD_RALT = 1 << 3,
    SC_SHORTCUT_MOD_LSUPER = 1 << 4,
    SC_SHORTCUT_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;
    enum sc_key_inject_mode key_inject_mode;
    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;
    bool clipboard_autosync;
    bool tcpip;
    const char *tcpip_dst;
 };
 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;
@@ -111,8 +101,8 @@ bool
 receiver_start(struct receiver *receiver) {
    LOGD("Starting receiver thread");
-    bool ok = sc_thread_create(&receiver->thread, run_receiver,
+    bool ok = sc_thread_create(&receiver->thread, run_receiver, "receiver",
-                               "scrcpy-receiver", receiver);
+                               receiver);
    if (!ok) {
        LOGC("Could not start receiver thread");
        return false;
--- 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;
 }
@@ -34,13 +32,11 @@ static struct record_packet *
 record_packet_new(const AVPacket *packet) {
    struct record_packet *rec = malloc(sizeof(*rec));
    if (!rec) {
        LOG_OOM();
        return NULL;
    }
    rec->packet = av_packet_alloc();
    if (!rec->packet) {
        LOG_OOM();
        free(rec);
        return NULL;
    }
@@ -55,15 +51,16 @@ record_packet_new(const AVPacket *packet) {
 static void
 record_packet_delete(struct record_packet *rec) {
    av_packet_unref(rec->packet);
    av_packet_free(&rec->packet);
    free(rec);
 }
 static void
 recorder_queue_clear(struct recorder_queue *queue) {
-    while (!sc_queue_is_empty(queue)) {
+    while (!queue_is_empty(queue)) {
        struct record_packet *rec;
-        sc_queue_take(queue, next, &rec);
+        queue_take(queue, next, &rec);
        record_packet_delete(rec);
    }
 }
@@ -83,7 +80,7 @@ recorder_write_header(struct recorder *recorder, const AVPacket *packet) {
    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
    if (!extradata) {
-        LOG_OOM();
+        LOGC("Could not allocate extradata");
        return false;
    }
@@ -139,14 +136,14 @@ run_recorder(void *data) {
    for (;;) {
        sc_mutex_lock(&recorder->mutex);
-        while (!recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
+        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
        }
        // if stopped is set, continue to process the remaining events (to
        // finish the recording) before actually stopping
-        if (recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
+        if (recorder->stopped && queue_is_empty(&recorder->queue)) {
            sc_mutex_unlock(&recorder->mutex);
            struct record_packet *last = recorder->previous;
            if (last) {
@@ -165,7 +162,7 @@ run_recorder(void *data) {
        }
        struct record_packet *rec;
-        sc_queue_take(&recorder->queue, next, &rec);
+        queue_take(&recorder->queue, next, &rec);
        sc_mutex_unlock(&recorder->mutex);
@@ -217,8 +214,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");
@@ -230,15 +226,17 @@ static bool
 recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    bool ok = sc_mutex_init(&recorder->mutex);
    if (!ok) {
        LOGC("Could not create mutex");
        return false;
    }
    ok = sc_cond_init(&recorder->queue_cond);
    if (!ok) {
        LOGC("Could not create cond");
        goto error_mutex_destroy;
    }
-    sc_queue_init(&recorder->queue);
+    queue_init(&recorder->queue);
    recorder->stopped = false;
    recorder->failed = false;
    recorder->header_written = false;
@@ -254,7 +252,7 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    recorder->ctx = avformat_alloc_context();
    if (!recorder->ctx) {
-        LOG_OOM();
+        LOGE("Could not allocate output context");
        goto error_cond_destroy;
    }
@@ -287,7 +285,7 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    }
    LOGD("Starting recorder thread");
-    ok = sc_thread_create(&recorder->thread, run_recorder, "scrcpy-recorder",
+    ok = sc_thread_create(&recorder->thread, run_recorder, "recorder",
                               recorder);
    if (!ok) {
        LOGC("Could not start recorder thread");
@@ -338,12 +336,12 @@ recorder_push(struct recorder *recorder, const AVPacket *packet) {
    struct record_packet *rec = record_packet_new(packet);
    if (!rec) {
-        LOG_OOM();
+        LOGC("Could not allocate record packet");
        sc_mutex_unlock(&recorder->mutex);
        return false;
    }
-    sc_queue_push(&recorder->queue, next, rec);
+    queue_push(&recorder->queue, next, rec);
    sc_cond_signal(&recorder->queue_cond);
    sc_mutex_unlock(&recorder->mutex);
@@ -372,10 +370,10 @@ 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) {
-        LOG_OOM();
+        LOGE("Could not strdup filename");
        return false;
    }
--- 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"
@@ -17,7 +17,7 @@ struct record_packet {
    struct record_packet *next;
 };
-struct recorder_queue SC_QUEUE(struct record_packet);
+struct recorder_queue QUEUE(struct record_packet);
 struct recorder {
    struct sc_packet_sink packet_sink; // packet sink trait
@@ -25,7 +25,7 @@ struct recorder {
    char *filename;
    enum sc_record_format format;
    AVFormatContext *ctx;
-    struct 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
@@ -17,17 +17,12 @@
 #include "decoder.h"
 #include "events.h"
 #include "file_handler.h"
-#ifdef HAVE_AOA_HID
+#include "input_manager.h"
 # include "hid_keyboard.h"
 # include "hid_mouse.h"
 #endif
 #include "keyboard_inject.h"
 #include "mouse_inject.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
 #include "stream.h"
-#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,49 +40,44 @@ struct scrcpy {
 #endif
    struct controller controller;
    struct file_handler file_handler;
-#ifdef HAVE_AOA_HID
+    struct input_manager input_manager;
    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
 };
    union {
        struct sc_mouse_inject mouse_inject;
 #ifdef HAVE_AOA_HID
        struct sc_hid_mouse mouse_hid;
 #endif
    };
 };
 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");
@@ -98,18 +88,11 @@ sdl_set_hints(const char *render_driver) {
        LOGW("Could not enable linear filtering");
    }
 #ifdef SCRCPY_SDL_HAS_HINT_MOUSE_FOCUS_CLICKTHROUGH
    // Handle a click to gain focus as any other click
    if (!SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1")) {
        LOGW("Could not enable mouse focus clickthrough");
    }
 #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
@@ -123,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");
@@ -146,6 +114,8 @@ sdl_configure(bool display, bool disable_screensaver) {
        LOGD("Screensaver enabled");
        SDL_EnableScreenSaver();
    }
    return true;
 }
 static bool
@@ -193,6 +163,11 @@ handle_event(struct scrcpy *s, const struct scrcpy_options *options,
    }
    bool consumed = screen_handle_event(&s->screen, event);
    if (consumed) {
        goto end;
    }
    consumed = input_manager_handle_event(&s->input_manager, event);
    (void) consumed;
 end:
@@ -217,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) {
@@ -264,15 +216,14 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
    if (priority == 0) {
        return;
    }
-
+    char *local_fmt = malloc(strlen(fmt) + 10);
    size_t fmt_len = strlen(fmt);
    char *local_fmt = malloc(fmt_len + 10);
    if (!local_fmt) {
-        LOG_OOM();
+        LOGC("Could not allocate string");
        return;
    }
-    memcpy(local_fmt, "[FFmpeg] ", 9); // do not write the final '\0'
+    // strcpy is safe here, the destination is large enough
-    memcpy(local_fmt + 9, fmt, fmt_len + 1); // include '\0'
+    strcpy(local_fmt, "[FFmpeg] ");
    strcpy(local_fmt + 9, fmt);
    SDL_LogMessageV(SDL_LOG_CATEGORY_VIDEO, priority, local_fmt, vl);
    free(local_fmt);
 }
@@ -282,48 +233,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;
@@ -333,22 +256,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,
@@ -361,51 +278,27 @@ scrcpy(struct scrcpy_options *options) {
        .encoder_name = options->encoder_name,
        .force_adb_forward = options->force_adb_forward,
        .power_off_on_close = options->power_off_on_close,
        .clipboard_autosync = options->clipboard_autosync,
        .tcpip = options->tcpip,
        .tcpip_dst = options->tcpip_dst,
    };
-
+    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 +316,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 +329,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);
@@ -449,22 +342,9 @@ scrcpy(struct scrcpy_options *options) {
        stream_add_sink(&s->stream, &rec->packet_sink);
    }
-    struct sc_key_processor *kp = NULL;
+    if (options->display) {
    struct sc_mouse_processor *mp = NULL;
        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;
@@ -473,6 +353,31 @@ scrcpy(struct scrcpy_options *options) {
                goto end;
            }
            controller_started = true;
        }
        const char *window_title =
            options->window_title ? options->window_title : device_name;
        struct screen_params screen_params = {
            .window_title = window_title,
            .frame_size = frame_size,
            .always_on_top = options->always_on_top,
            .window_x = options->window_x,
            .window_y = options->window_y,
            .window_width = options->window_width,
            .window_height = options->window_height,
            .window_borderless = options->window_borderless,
            .rotation = options->rotation,
            .mipmaps = options->mipmaps,
            .fullscreen = options->fullscreen,
        };
        if (!screen_init(&s->screen, &screen_params)) {
            goto end;
        }
        screen_initialized = true;
        decoder_add_sink(&s->decoder, &s->screen.frame_sink);
        if (options->turn_screen_off) {
            struct control_msg msg;
@@ -483,98 +388,11 @@ scrcpy(struct scrcpy_options *options) {
                LOGW("Could not request 'set screen power mode'");
            }
        }
        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID) {
 #ifdef HAVE_AOA_HID
            bool aoa_hid_ok = false;
            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);
        sc_hid_mouse_init(&s->mouse_hid, &s->aoa);
        mp = &s->mouse_hid.mouse_processor;
    }
    if (options->display) {
        const char *window_title =
            options->window_title ? options->window_title : info->device_name;
        struct screen_params screen_params = {
            .controller = &s->controller,
            .kp = kp,
            .mp = mp,
            .control = options->control,
            .forward_all_clicks = options->forward_all_clicks,
            .legacy_paste = options->legacy_paste,
            .clipboard_autosync = options->clipboard_autosync,
            .shortcut_mods = &options->shortcut_mods,
            .window_title = window_title,
            .frame_size = info->frame_size,
            .always_on_top = options->always_on_top,
            .window_x = options->window_x,
            .window_y = options->window_y,
            .window_width = options->window_width,
            .window_height = options->window_height,
            .window_borderless = options->window_borderless,
            .rotation = options->rotation,
            .mipmaps = options->mipmaps,
            .fullscreen = options->fullscreen,
            .buffering_time = options->display_buffer,
        };
        if (!screen_init(&s->screen, &screen_params)) {
            goto end;
        }
        screen_initialized = true;
        decoder_add_sink(&s->decoder, &s->screen.frame_sink);
    }
 #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;
        }
@@ -591,6 +409,8 @@ aoa_hid_end:
    }
    stream_started = true;
    input_manager_init(&s->input_manager, &s->controller, &s->screen, options);
    ret = event_loop(s, options);
    LOGD("quit...");
@@ -601,15 +421,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);
    }
@@ -622,7 +433,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
@@ -637,13 +448,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) {
@@ -667,7 +471,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,146 @@
 #include "common.h"
 #include <stdbool.h>
-#include "options.h"
+#include <stddef.h>
 #include <stdint.h>
 enum sc_log_level {
    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,9 +63,14 @@ 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;
-    if (SDL_GetDisplayUsableBounds(0, &rect)) {
+#ifdef SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
 # define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayUsableBounds((i), (r))
 #else
 # define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayBounds((i), (r))
 #endif
    if (GET_DISPLAY_BOUNDS(0, &rect)) {
        LOGW("Could not get display usable bounds: %s", SDL_GetError());
        return false;
    }
@@ -75,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
@@ -89,21 +95,20 @@ 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) {
                 bool within_display_bounds) {
    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 (!within_display_bounds ||
+    if (!get_preferred_display_bounds(&display_size)) {
-            !get_preferred_display_bounds(&display_size)) {
+        // could not get display bounds, do not constraint the size
-        // do not constraint the size
+        window_size.width = current_size.width;
-        window_size = current_size;
+        window_size.height = current_size.height;
    } else {
        window_size.width = MIN(current_size.width, display_size.width);
        window_size.height = MIN(current_size.height, display_size.height);
@@ -131,12 +136,12 @@ 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, true);
+        window_size = get_optimal_size(content_size, content_size);
    } else {
        if (req_width) {
            window_size.width = req_width;
@@ -156,26 +161,15 @@ get_initial_optimal_size(struct sc_size content_size, uint16_t req_width,
    return window_size;
 }
 static inline void
 screen_capture_mouse(struct screen *screen, bool capture) {
    if (SDL_SetRelativeMouseMode(capture)) {
        LOGE("Could not set relative mouse mode to %s: %s",
             capture ? "true" : "false", SDL_GetError());
        return;
    }
    screen->mouse_captured = capture;
 }
 static void
 screen_update_content_rect(struct screen *screen) {
    int dw;
    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;
@@ -207,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);
@@ -231,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
@@ -319,43 +274,27 @@ screen_frame_sink_close(struct sc_frame_sink *sink) {
 static bool
 screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
    struct screen *screen = DOWNCAST(sink);
-    return sc_video_buffer_push(&screen->vb, frame);
+
    bool previous_frame_skipped;
    bool ok = video_buffer_push(&screen->vb, frame, &previous_frame_skipped);
    if (!ok) {
        return false;
    }
-static void
+    if (previous_frame_skipped) {
 sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
                             void *userdata) {
    (void) vb;
    struct screen *screen = userdata;
    // event_failed implies previous_skipped (the previous frame may not have
    // been consumed if the event was not sent)
    assert(!screen->event_failed || previous_skipped);
    bool need_new_event;
    if (previous_skipped) {
        fps_counter_add_skipped_frame(&screen->fps_counter);
        // The EVENT_NEW_FRAME triggered for the previous frame will consume
-        // this new frame instead, 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;
        }
    }
    return true;
 }
 bool
@@ -364,27 +303,16 @@ screen_init(struct screen *screen, const struct screen_params *params) {
    screen->has_frame = false;
    screen->fullscreen = false;
    screen->maximized = false;
    screen->event_failed = false;
    screen->mouse_captured = false;
    screen->mouse_capture_key_pressed = 0;
-    static const struct sc_video_buffer_callbacks cbs = {
+    bool ok = video_buffer_init(&screen->vb);
        .on_new_frame = sc_video_buffer_on_new_frame,
    };
    bool ok = sc_video_buffer_init(&screen->vb, params->buffering_time, &cbs,
                                   screen);
    if (!ok) {
        LOGE("Could not initialize video buffer");
        return false;
    }
    ok = sc_video_buffer_start(&screen->vb);
    if (!ok) {
        goto error_destroy_video_buffer;
    }
    if (!fps_counter_init(&screen->fps_counter)) {
-        goto error_stop_and_join_video_buffer;
+        LOGE("Could not initialize FPS counter");
        goto error_destroy_video_buffer;
    }
    screen->frame_size = params->frame_size;
@@ -392,18 +320,23 @@ 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);
    uint32_t window_flags = SDL_WINDOW_HIDDEN
                          | SDL_WINDOW_RESIZABLE
                          | SDL_WINDOW_ALLOW_HIGHDPI;
    if (params->always_on_top) {
 #ifdef SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
        window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
 #else
        LOGW("The 'always on top' flag is not available "
             "(compile with SDL >= 2.0.5 to enable it)");
 #endif
    }
    if (params->window_borderless) {
        window_flags |= SDL_WINDOW_BORDERLESS;
@@ -461,10 +394,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");
    }
@@ -479,24 +412,10 @@ screen_init(struct screen *screen, const struct screen_params *params) {
    screen->frame = av_frame_alloc();
    if (!screen->frame) {
-        LOG_OOM();
+        LOGC("Could not create screen frame");
        goto error_destroy_texture;
    }
    struct input_manager_params im_params = {
        .controller = params->controller,
        .screen = screen,
        .kp = params->kp,
        .mp = params->mp,
        .control = params->control,
        .forward_all_clicks = params->forward_all_clicks,
        .legacy_paste = params->legacy_paste,
        .clipboard_autosync = params->clipboard_autosync,
        .shortcut_mods = params->shortcut_mods,
    };
    input_manager_init(&screen->im, &im_params);
    // Reset the window size to trigger a SIZE_CHANGED event, to workaround
    // HiDPI issues with some SDL renderers when several displays having
    // different HiDPI scaling are connected
@@ -534,11 +453,8 @@ error_destroy_window:
    SDL_DestroyWindow(screen->window);
 error_destroy_fps_counter:
    fps_counter_destroy(&screen->fps_counter);
 error_stop_and_join_video_buffer:
    sc_video_buffer_stop(&screen->vb);
    sc_video_buffer_join(&screen->vb);
 error_destroy_video_buffer:
-    sc_video_buffer_destroy(&screen->vb);
+    video_buffer_destroy(&screen->vb);
    return false;
 }
@@ -555,13 +471,11 @@ screen_hide_window(struct screen *screen) {
 void
 screen_interrupt(struct screen *screen) {
    sc_video_buffer_stop(&screen->vb);
    fps_counter_interrupt(&screen->fps_counter);
 }
 void
 screen_join(struct screen *screen) {
    sc_video_buffer_join(&screen->vb);
    fps_counter_join(&screen->fps_counter);
 }
@@ -575,25 +489,25 @@ screen_destroy(struct screen *screen) {
    SDL_DestroyRenderer(screen->renderer);
    SDL_DestroyWindow(screen->window);
    fps_counter_destroy(&screen->fps_counter);
-    sc_video_buffer_destroy(&screen->vb);
+    video_buffer_destroy(&screen->vb);
 }
 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
                / old_content_size.height,
    };
-    target_size = get_optimal_size(target_size, new_content_size, true);
+    target_size = get_optimal_size(target_size, new_content_size);
    set_window_size(screen, target_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) {
@@ -624,7 +538,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);
@@ -637,7 +551,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
@@ -645,7 +559,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);
@@ -681,12 +595,12 @@ update_texture(struct screen *screen, const AVFrame *frame) {
 static bool
 screen_update_frame(struct screen *screen) {
    av_frame_unref(screen->frame);
-    sc_video_buffer_consume(&screen->vb, screen->frame);
+    video_buffer_consume(&screen->vb, screen->frame);
    AVFrame *frame = screen->frame;
    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;
    }
@@ -696,6 +610,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;
@@ -719,11 +667,11 @@ 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, false);
+        get_optimal_size(window_size, screen->content_size);
    // Center the window related to the device screen
    assert(optimal_size.width <= window_size.width);
@@ -748,17 +696,12 @@ 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);
 }
 static inline bool
 screen_is_mouse_capture_key(SDL_Keycode key) {
    return key == SDLK_LALT || key == SDLK_LGUI || key == SDLK_RGUI;
 }
 bool
 screen_handle_event(struct screen *screen, SDL_Event *event) {
    switch (event->type) {
@@ -801,74 +744,14 @@ screen_handle_event(struct screen *screen, SDL_Event *event) {
                    apply_pending_resize(screen);
                    screen_render(screen, true);
                    break;
                case SDL_WINDOWEVENT_FOCUS_LOST:
                    if (screen->im.mp->relative_mode) {
                        screen_capture_mouse(screen, false);
                    }
                    break;
            }
            return true;
        case SDL_KEYDOWN:
            if (screen->im.mp->relative_mode) {
                SDL_Keycode key = event->key.keysym.sym;
                if (screen_is_mouse_capture_key(key)) {
                    if (!screen->mouse_capture_key_pressed) {
                        screen->mouse_capture_key_pressed = key;
                        return true;
                    } else {
                        // Another mouse capture key has been pressed, cancel
                        // mouse (un)capture
                        screen->mouse_capture_key_pressed = 0;
                        // Do not return, the event must be forwarded to the
                        // input manager
                    }
                }
            }
            break;
        case SDL_KEYUP:
            if (screen->im.mp->relative_mode) {
                SDL_Keycode key = event->key.keysym.sym;
                SDL_Keycode cap = screen->mouse_capture_key_pressed;
                screen->mouse_capture_key_pressed = 0;
                if (key == cap) {
                    // A mouse capture key has been pressed then released:
                    // toggle the capture mouse mode
                    screen_capture_mouse(screen, !screen->mouse_captured);
                    return true;
                }
                // Do not return, the event must be forwarded to the input
                // manager
            }
            break;
        case SDL_MOUSEWHEEL:
        case SDL_MOUSEMOTION:
        case SDL_MOUSEBUTTONDOWN:
            if (screen->im.mp->relative_mode && !screen->mouse_captured) {
                // Do not forward to input manager, the mouse will be captured
                // on SDL_MOUSEBUTTONUP
                return true;
            }
            break;
        case SDL_FINGERMOTION:
        case SDL_FINGERDOWN:
        case SDL_FINGERUP:
            if (screen->im.mp->relative_mode) {
                // Touch events are not compatible with relative mode
                // (coordinates are not relative)
                return true;
            }
            break;
        case SDL_MOUSEBUTTONUP:
            if (screen->im.mp->relative_mode && !screen->mouse_captured) {
                screen_capture_mouse(screen, true);
            }
            return true;
    }
-    return input_manager_handle_event(&screen->im, 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;
@@ -882,7 +765,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;
@@ -905,7 +788,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
@@ -7,14 +7,9 @@
 #include <SDL2/SDL.h>
 #include <libavformat/avformat.h>
 #include "controller.h"
 #include "coords.h"
 #include "fps_counter.h"
 #include "input_manager.h"
 #include "opengl.h"
 #include "trait/key_processor.h"
 #include "trait/frame_sink.h"
 #include "trait/mouse_processor.h"
 #include "video_buffer.h"
 struct screen {
@@ -24,21 +19,20 @@ struct screen {
    bool open; // track the open/close state to assert correct behavior
 #endif
-    struct input_manager im;
+    struct video_buffer vb;
    struct sc_video_buffer vb;
    struct fps_counter fps_counter;
    SDL_Window *window;
    SDL_Renderer *renderer;
    SDL_Texture *texture;
    struct sc_opengl gl;
-    struct 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;
@@ -49,29 +43,12 @@ struct screen {
    bool maximized;
    bool mipmaps;
    bool event_failed; // in case SDL_PushEvent() returned an error
    bool mouse_captured; // only relevant in relative mouse mode
    // To enable/disable mouse capture, a mouse capture key (LALT, LGUI or
    // RGUI) must be pressed. This variable tracks the pressed capture key.
    SDL_Keycode mouse_capture_key_pressed;
    AVFrame *frame;
 };
 struct screen_params {
    struct controller *controller;
    struct sc_key_processor *kp;
    struct sc_mouse_processor *mp;
    bool control;
    bool forward_all_clicks;
    bool legacy_paste;
    bool clipboard_autosync;
    const struct sc_shortcut_mods *shortcut_mods;
    const char *window_title;
-    struct sc_size frame_size;
+    struct size frame_size;
    bool always_on_top;
    int16_t window_x;
@@ -85,8 +62,6 @@ struct screen_params {
    bool mipmaps;
    bool fullscreen;
    sc_tick buffering_time;
 };
 // initialize screen, create window, renderer and texture (window is hidden)
@@ -113,6 +88,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);
@@ -135,13 +117,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
--- 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;
@@ -41,67 +49,28 @@ struct sc_server_params {
    bool stay_awake;
    bool force_adb_forward;
    bool power_off_on_close;
    bool clipboard_autosync;
    bool tcpip;
    const char *tcpip_dst;
 };
-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
@@ -42,7 +42,7 @@ stream_recv_packet(struct stream *stream, AVPacket *packet) {
    assert(len);
    if (av_new_packet(packet, len)) {
-        LOG_OOM();
+        LOGE("Could not allocate packet");
        return false;
    }
@@ -111,18 +111,18 @@ stream_push_packet(struct stream *stream, AVPacket *packet) {
        if (stream->pending) {
            offset = stream->pending->size;
            if (av_grow_packet(stream->pending, packet->size)) {
-                LOG_OOM();
+                LOGE("Could not grow packet");
                return false;
            }
        } else {
            offset = 0;
            stream->pending = av_packet_alloc();
            if (!stream->pending) {
-                LOG_OOM();
+                LOGE("Could not allocate packet");
                return false;
            }
            if (av_new_packet(stream->pending, packet->size)) {
-                LOG_OOM();
+                LOGE("Could not create packet");
                av_packet_free(&stream->pending);
                return false;
            }
@@ -151,6 +151,7 @@ stream_push_packet(struct stream *stream, AVPacket *packet) {
        if (stream->pending) {
            // the pending packet must be discarded (consumed or error)
            av_packet_unref(stream->pending);
            av_packet_free(&stream->pending);
        }
@@ -200,7 +201,7 @@ run_stream(void *data) {
    stream->codec_ctx = avcodec_alloc_context3(codec);
    if (!stream->codec_ctx) {
-        LOG_OOM();
+        LOGC("Could not allocate codec context");
        goto end;
    }
@@ -221,7 +222,7 @@ run_stream(void *data) {
    AVPacket *packet = av_packet_alloc();
    if (!packet) {
-        LOG_OOM();
+        LOGE("Could not allocate packet");
        goto finally_close_parser;
    }
@@ -243,6 +244,7 @@ run_stream(void *data) {
    LOGD("End of frames");
    if (stream->pending) {
        av_packet_unref(stream->pending);
        av_packet_free(&stream->pending);
    }
@@ -260,7 +262,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;
@@ -284,8 +286,7 @@ bool
 stream_start(struct stream *stream) {
    LOGD("Starting stream thread");
-    bool ok =
+    bool ok = sc_thread_create(&stream->thread, run_stream, "stream", stream);
        sc_thread_create(&stream->thread, run_stream, "scrcpy-stream", stream);
    if (!ok) {
        LOGC("Could not start stream thread");
        return false;
--- 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,81 +0,0 @@
 #include "util/file.h"
 #include <limits.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include "util/log.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)
        {
            LOG_OOM();
            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,180 +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, unsigned flags,
+search_executable(const char *file) {
-                     int *pin, int *pout, int *perr) {
+    char *path = getenv("PATH");
-    bool inherit_stdout = !pout && !(flags & SC_PROCESS_NO_STDOUT);
+    if (!path)
-    bool inherit_stderr = !perr && !(flags & SC_PROCESS_NO_STDERR);
+        return false;
    path = strdup(path);
    if (!path)
        return false;
-    int in[2];
+    bool ret = false;
-    int out[2];
+    size_t file_len = strlen(file);
-    int err[2];
+    char *saveptr;
-    int internal[2]; // communication between parent and children
+    for (char *dir = strtok_r(path, ":", &saveptr); dir;
            dir = strtok_r(NULL, ":", &saveptr)) {
        size_t dir_len = strlen(dir);
        char *fullpath = malloc(dir_len + file_len + 2);
        if (!fullpath)
            continue;
        memcpy(fullpath, dir, dir_len);
        fullpath[dir_len] = '/';
        memcpy(fullpath + dir_len + 1, file, file_len + 1);
-    if (pipe(internal) == -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) {
            perror("read");
            ret = PROCESS_ERROR_GENERIC;
            goto end;
        }
-            close(in[1]);
+    } else if (*pid == 0) {
-        }
+        // child close read side
-        // Do not close stdin in the child process, this makes adb fail on Linux
+        close(fd[0]);
-
+        if (fcntl(fd[1], F_SETFD, FD_CLOEXEC) == 0) {
        if (pout) {
            if (out[1] != STDOUT_FILENO) {
                dup2(out[1], STDOUT_FILENO);
                close(out[1]);
            }
            close(out[0]);
        } else if (!inherit_stdout) {
            // Close stdout in the child process
            close(STDOUT_FILENO);
        }
        if (perr) {
            if (err[1] != STDERR_FILENO) {
                dup2(err[1], STDERR_FILENO);
                close(err[1]);
            }
            close(err[0]);
        } else if (!inherit_stderr) {
            // Close stderr in the child process
            close(STDERR_FILENO);
        }
        close(internal[0]);
        enum sc_process_result err;
        // Somehow SDL masks many signals - undo them for other processes
        // https://github.com/libsdl-org/SDL/blob/release-2.0.18/src/thread/pthread/SDL_systhread.c#L167
        sigset_t mask;
        sigemptyset(&mask);
        sigprocmask(SIG_SETMASK, &mask, NULL);
        if (fcntl(internal[1], F_SETFD, FD_CLOEXEC) == 0) {
            execvp(argv[0], (char *const *)argv);
            if (errno == ENOENT) {
                ret = PROCESS_ERROR_MISSING_BINARY;
            } else {
                ret = PROCESS_ERROR_GENERIC;
            }
            perror("exec");
            err = errno == ENOENT ? SC_PROCESS_ERROR_MISSING_BINARY
                                  : SC_PROCESS_ERROR_GENERIC;
        } else {
            perror("fcntl");
-            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);
@@ -183,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) {
@@ -195,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;
    }
@@ -203,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
    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
 }
-void
+bool
-sc_pipe_close(int pipe) {
+is_regular_file(const char *path) {
-    if (close(pipe)) {
+    struct stat path_stat;
-        perror("close pipe");
+
    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) {
        LOG_OOM();
        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,232 +1,71 @@
 #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
+static int
 static bool
 build_cmd(char *cmd, size_t len, const char *const argv[]) {
    // Windows command-line parsing is WTF:
    // <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 -1;
    }
-    return true;
+    return 0;
 }
-enum sc_process_result
+enum process_result
-sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned flags,
+process_execute(const char *const argv[], HANDLE *handle) {
-                     HANDLE *pin, HANDLE *pout, HANDLE *perr) {
+    STARTUPINFOW si;
    bool inherit_stdout = !pout && !(flags & SC_PROCESS_NO_STDOUT);
    bool inherit_stderr = !perr && !(flags & SC_PROCESS_NO_STDERR);
    // Add 1 per non-NULL pointer
    unsigned handle_count = !!pin || !!pout || !!perr;
    enum sc_process_result ret = SC_PROCESS_ERROR_GENERIC;
    SECURITY_ATTRIBUTES sa;
    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
    sa.lpSecurityDescriptor = NULL;
    sa.bInheritHandle = TRUE;
    HANDLE stdin_read_handle;
    HANDLE stdout_write_handle;
    HANDLE stderr_write_handle;
    if (pin) {
        if (!CreatePipe(&stdin_read_handle, pin, &sa, 0)) {
            perror("pipe");
            return SC_PROCESS_ERROR_GENERIC;
        }
        if (!SetHandleInformation(*pin, HANDLE_FLAG_INHERIT, 0)) {
            LOGE("SetHandleInformation stdin failed");
            goto error_close_stdin;
        }
    }
    if (pout) {
        if (!CreatePipe(pout, &stdout_write_handle, &sa, 0)) {
            perror("pipe");
            goto error_close_stdin;
        }
        if (!SetHandleInformation(*pout, HANDLE_FLAG_INHERIT, 0)) {
            LOGE("SetHandleInformation stdout failed");
            goto error_close_stdout;
        }
    }
    if (perr) {
        if (!CreatePipe(perr, &stderr_write_handle, &sa, 0)) {
            perror("pipe");
            goto error_close_stdout;
        }
        if (!SetHandleInformation(*perr, HANDLE_FLAG_INHERIT, 0)) {
            LOGE("SetHandleInformation stderr failed");
            goto error_close_stderr;
        }
    }
    STARTUPINFOEXW si;
    PROCESS_INFORMATION pi;
    memset(&si, 0, sizeof(si));
-    si.StartupInfo.cb = sizeof(si);
+    si.cb = sizeof(si);
    HANDLE handles[3];
-    si.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
+    char cmd[256];
-    if (inherit_stdout) {
+    if (build_cmd(cmd, sizeof(cmd), argv)) {
-        si.StartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+        *handle = NULL;
-    }
+        return PROCESS_ERROR_GENERIC;
    if (inherit_stderr) {
        si.StartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
    }
-    LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList = NULL;
+    wchar_t *wide = utf8_to_wide_char(cmd);
    if (handle_count) {
        unsigned i = 0;
        if (pin) {
            si.StartupInfo.hStdInput = stdin_read_handle;
            handles[i++] = si.StartupInfo.hStdInput;
        }
        if (pout) {
            assert(!inherit_stdout);
            si.StartupInfo.hStdOutput = stdout_write_handle;
            handles[i++] = si.StartupInfo.hStdOutput;
        }
        if (perr) {
            assert(!inherit_stderr);
            si.StartupInfo.hStdError = stderr_write_handle;
            handles[i++] = si.StartupInfo.hStdError;
        }
        SIZE_T size;
        // Call it once to know the required buffer size
        BOOL ok =
            InitializeProcThreadAttributeList(NULL, 1, 0, &size)
                || GetLastError() == ERROR_INSUFFICIENT_BUFFER;
        if (!ok) {
            goto error_close_stderr;
        }
        lpAttributeList = malloc(size);
        if (!lpAttributeList) {
            LOG_OOM();
            goto error_close_stderr;
        }
        ok = InitializeProcThreadAttributeList(lpAttributeList, 1, 0, &size);
        if (!ok) {
            free(lpAttributeList);
            goto error_close_stderr;
        }
        ok = UpdateProcThreadAttribute(lpAttributeList, 0,
                                       PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
                                       handles, handle_count * sizeof(HANDLE),
                                       NULL, NULL);
        if (!ok) {
            goto error_free_attribute_list;
        }
        si.lpAttributeList = lpAttributeList;
    }
    char *cmd = malloc(CMD_MAX_LEN);
    if (!cmd || !build_cmd(cmd, CMD_MAX_LEN, argv)) {
        LOG_OOM();
        goto error_free_attribute_list;
    }
    wchar_t *wide = sc_str_to_wchars(cmd);
    free(cmd);
    if (!wide) {
-        LOG_OOM();
+        LOGC("Could not allocate wide char string");
-        goto error_free_attribute_list;
+        return PROCESS_ERROR_GENERIC;
    }
-    BOOL bInheritHandles = handle_count > 0 || inherit_stdout || inherit_stderr;
+    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, 0, NULL, NULL, &si,
-    DWORD dwCreationFlags = 0;
+                        &pi)) {
    if (handle_count > 0) {
        dwCreationFlags |= EXTENDED_STARTUPINFO_PRESENT;
    }
    if (!inherit_stdout && !inherit_stderr) {
        // DETACHED_PROCESS to disable stdin, stdout and stderr
        dwCreationFlags |= DETACHED_PROCESS;
    }
    BOOL ok = CreateProcessW(NULL, wide, NULL, NULL, bInheritHandles,
                             dwCreationFlags, NULL, NULL, &si.StartupInfo, &pi);
        free(wide);
-    if (!ok) {
+        *handle = NULL;
-        int err = GetLastError();
+        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
-        LOGE("CreateProcessW() error %d", err);
+            return PROCESS_ERROR_MISSING_BINARY;
        if (err == ERROR_FILE_NOT_FOUND) {
            ret = SC_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);
@@ -235,24 +74,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,55 +0,0 @@
 #ifndef SC_KEY_PROCESSOR_H
 #define SC_KEY_PROCESSOR_H
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
 #include "input_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 a 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.
     *
     * This function is mandatory.
     */
    void
    (*process_key)(struct sc_key_processor *kp,
                   const struct sc_key_event *event, uint64_t ack_to_wait);
    /**
     * Process an input text
     *
     * This function is optional.
     */
    void
    (*process_text)(struct sc_key_processor *kp,
                    const struct sc_text_event *event);
 };
 #endif
--- a/app/src/trait/mouse_processor.h
+++ b/app/src/trait/mouse_processor.h
@@ -1,66 +0,0 @@
 #ifndef SC_MOUSE_PROCESSOR_H
 #define SC_MOUSE_PROCESSOR_H
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
 #include "input_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;
    /**
     * If set, the mouse processor works in relative mode (the absolute
     * position is irrelevant). In particular, it indicates that the mouse
     * pointer must be "captured" by the UI.
     */
    bool relative_mode;
 };
 struct sc_mouse_processor_ops {
    /**
     * Process a mouse motion event
     *
     * This function is mandatory.
     */
    void
    (*process_mouse_motion)(struct sc_mouse_processor *mp,
                            const struct sc_mouse_motion_event *event);
    /**
     * Process a mouse click event
     *
     * This function is mandatory.
     */
    void
    (*process_mouse_click)(struct sc_mouse_processor *mp,
                           const struct sc_mouse_click_event *event);
    /**
     * Process a mouse scroll event
     *
     * This function is optional.
     */
    void
    (*process_mouse_scroll)(struct sc_mouse_processor *mp,
                            const struct sc_mouse_scroll_event *event);
    /**
     * Process a touch event
     *
     * This function is optional.
     */
    void
    (*process_touch)(struct sc_mouse_processor *mp,
                     const struct sc_touch_event *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) {
        LOG_OOM();
        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/intmap.c
+++ b/app/src/util/intmap.c
@@ -1,13 +0,0 @@
 #include "intmap.h"
 const struct sc_intmap_entry *
 sc_intmap_find_entry(const struct sc_intmap_entry entries[], size_t len,
                     int32_t key) {
    for (size_t i = 0; i < len; ++i) {
        const struct sc_intmap_entry *entry = &entries[i];
        if (entry->key == key) {
            return entry;
        }
    }
    return NULL;
 }
--- a/app/src/util/intmap.h
+++ b/app/src/util/intmap.h
@@ -1,24 +0,0 @@
 #ifndef SC_ARRAYMAP_H
 #define SC_ARRAYMAP_H
 #include "common.h"
 #include <stdint.h>
 struct sc_intmap_entry {
    int32_t key;
    int32_t value;
 };
 const struct sc_intmap_entry *
 sc_intmap_find_entry(const struct sc_intmap_entry entries[], size_t len,
                     int32_t key);
 /**
 * MAP is expected to be a static array of sc_intmap_entry, so that
 * ARRAY_LEN(MAP) can be computed statically.
 */
 #define SC_INTMAP_FIND_ENTRY(MAP, KEY) \
    sc_intmap_find_entry(MAP, ARRAY_LEN(MAP), KEY)
 #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) {
        LOG_OOM();
        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.c
+++ b/app/src/util/log.c
@@ -1,53 +0,0 @@
 #include "log.h"
 #include <assert.h>
 static SDL_LogPriority
 log_level_sc_to_sdl(enum sc_log_level level) {
    switch (level) {
        case SC_LOG_LEVEL_VERBOSE:
            return SDL_LOG_PRIORITY_VERBOSE;
        case SC_LOG_LEVEL_DEBUG:
            return SDL_LOG_PRIORITY_DEBUG;
        case SC_LOG_LEVEL_INFO:
            return SDL_LOG_PRIORITY_INFO;
        case SC_LOG_LEVEL_WARN:
            return SDL_LOG_PRIORITY_WARN;
        case SC_LOG_LEVEL_ERROR:
            return SDL_LOG_PRIORITY_ERROR;
        default:
            assert(!"unexpected log level");
            return SDL_LOG_PRIORITY_INFO;
    }
 }
 static enum sc_log_level
 log_level_sdl_to_sc(SDL_LogPriority priority) {
    switch (priority) {
        case SDL_LOG_PRIORITY_VERBOSE:
            return SC_LOG_LEVEL_VERBOSE;
        case SDL_LOG_PRIORITY_DEBUG:
            return SC_LOG_LEVEL_DEBUG;
        case SDL_LOG_PRIORITY_INFO:
            return SC_LOG_LEVEL_INFO;
        case SDL_LOG_PRIORITY_WARN:
            return SC_LOG_LEVEL_WARN;
        case SDL_LOG_PRIORITY_ERROR:
            return SC_LOG_LEVEL_ERROR;
        default:
            assert(!"unexpected log level");
            return SC_LOG_LEVEL_INFO;
    }
 }
 void
 sc_set_log_level(enum sc_log_level level) {
    SDL_LogPriority sdl_log = log_level_sc_to_sdl(level);
    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, sdl_log);
 }
 enum sc_log_level
 sc_get_log_level(void) {
    SDL_LogPriority sdl_log = SDL_LogGetPriority(SDL_LOG_CATEGORY_APPLICATION);
    return log_level_sdl_to_sc(sdl_log);
 }
--- a/app/src/util/log.h
+++ b/app/src/util/log.h
@@ -1,15 +1,8 @@
-#ifndef SC_LOG_H
+#ifndef LOG_H
-#define SC_LOG_H
+#define LOG_H
 #include "common.h"
 #include <SDL2/SDL_log.h>
 #include "options.h"
 #define LOG_STR_IMPL_(x) # x
 #define LOG_STR(x) LOG_STR_IMPL_(x)
 #define LOGV(...) SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGI(...) SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
@@ -17,13 +10,4 @@
 #define LOGE(...) SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGC(...) SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOG_OOM() \
    LOGC("OOM: %s:%d %s()", __FILE__, __LINE__, __func__)
 void
 sc_set_log_level(enum sc_log_level level);
 enum sc_log_level
 sc_get_log_level(void);
 #endif
--- a/app/src/util/net.c
+++ b/app/src/util/net.c
@@ -1,32 +1,121 @@
 #include "net.h"
 #include <assert.h>
 #include <errno.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;
 # define SC_RAW_SOCKET_NONE INVALID_SOCKET
 #else
 # include <sys/types.h>
 # include <sys/socket.h>
 # include <netinet/in.h>
 # include <arpa/inet.h>
 # include <unistd.h>
 # include <fcntl.h>
 # define SOCKET_ERROR -1
  typedef struct sockaddr_in SOCKADDR_IN;
  typedef struct sockaddr SOCKADDR;
  typedef struct in_addr IN_ADDR;
  typedef int sc_raw_socket;
 # define SC_RAW_SOCKET_NONE -1
 #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__
@@ -47,246 +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) {
        LOG_OOM();
        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 inline bool
 sc_raw_socket_close(sc_raw_socket raw_sock) {
 #ifndef _WIN32
    return !close(raw_sock);
 #else
    return !closesocket(raw_sock);
 #endif
 }
 #ifndef HAVE_SOCK_CLOEXEC
 // If SOCK_CLOEXEC does not exist, the flag must be set manually once the
 // socket is created
 static bool
 set_cloexec_flag(sc_raw_socket raw_sock) {
 #ifndef _WIN32
    if (fcntl(raw_sock, F_SETFD, FD_CLOEXEC) == -1) {
        perror("fcntl F_SETFD");
        return false;
    }
 #else
    if (!SetHandleInformation((HANDLE) raw_sock, HANDLE_FLAG_INHERIT, 0)) {
        LOGE("SetHandleInformation socket failed");
        return false;
    }
 #endif
    return true;
 }
 #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) {
 #ifdef HAVE_SOCK_CLOEXEC
    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
 #else
    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (raw_sock != SC_RAW_SOCKET_NONE && !set_cloexec_flag(raw_sock)) {
        sc_raw_socket_close(raw_sock);
        return SC_SOCKET_NONE;
    }
 #endif
    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);
 #ifdef HAVE_SOCK_CLOEXEC
    sc_raw_socket raw_sock =
        accept4(raw_server_socket, (SOCKADDR *) &csin, &sinsize, SOCK_CLOEXEC);
 #else
    sc_raw_socket raw_sock =
        accept(raw_server_socket, (SOCKADDR *) &csin, &sinsize);
    if (raw_sock != SC_RAW_SOCKET_NONE && !set_cloexec_flag(raw_sock)) {
        sc_raw_socket_close(raw_sock);
        return SC_SOCKET_NONE;
    }
 #endif
    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
 }
 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/Show More
+++ b/Show More