Assert screen closed on destroy

The destruction order is important, but tricky, because the screen is open/close by the decoder, but destroyed by scrcpy.c on the main thread. Add assertions to guarantee that the screen is not destroyed before being closed.
Remove video_buffer callbacks
2021-04-12 15:20:54 +02:00 · 2021-04-12 15:20:54 +02:00 · 2021-04-12 15:20:54 +02:00 · 2021-04-12 15:20:54 +02:00 · 2021-04-12 15:20:54 +02:00 · 2021-04-12 15:20:54 +02:00
129 changed files with 2554 additions and 10960 deletions
--- a/BUILD.md
+++ b/BUILD.md
@@ -2,44 +2,11 @@
 Here are the instructions to build _scrcpy_ (client and server).
 You may want to build only the client: the server binary, which will be pushed
 to the Android device, does not depend on your system and architecture. In that
 case, use the [prebuilt server] (so you will not need Java or the Android SDK).
-## Simple
+[prebuilt server]: #prebuilt-server
 If you just want to install the latest release from `master`, follow this
 simplified process.
 First, you need to install the required packages:
 ```bash
 # 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 \
                 libusb-1.0-0 libusb-dev
 ```
 Then clone the repo and execute the installation script
 ([source](install_release.sh)):
 ```bash
 git clone https://github.com/Genymobile/scrcpy
 cd scrcpy
 ./install_release.sh
 ```
 When a new release is out, update the repo and reinstall:
 ```bash
 git pull
 ./install_release.sh
 ```
 To uninstall:
 ```bash
 sudo ninja -Cbuild-auto uninstall
 ```
 ## Branches
@@ -89,15 +56,15 @@ 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 \
+sudo apt install gcc git pkg-config meson ninja-build \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
+                 libavcodec-dev libavformat-dev libavutil-dev \
-                 libusb-dev
+                 libsdl2-dev
 # server build dependencies
-sudo apt install openjdk-11-jdk
+sudo apt install openjdk-8-jdk
 ```
 On old versions (like Ubuntu 16.04), `meson` is too old. In that case, install
@@ -116,7 +83,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
@@ -139,13 +106,13 @@ sudo apt install mingw-w64 mingw-w64-tools
 You also need the JDK to build the server:
 ```bash
-sudo apt install openjdk-11-jdk
+sudo apt install openjdk-8-jdk
 ```
 Then generate the releases:
 ```bash
-./release.sh
+make -f Makefile.CrossWindows
 ```
 It will generate win32 and win64 releases into `dist/`.
@@ -206,12 +173,12 @@ brew install pkg-config meson
 ```
 Additionally, if you want to build the server, install Java 8 from Caskroom, and
-make it available from the `PATH`:
+make it avaliable from the `PATH`:
 ```bash
 brew tap homebrew/cask-versions
-brew install adoptopenjdk/openjdk/adoptopenjdk11
+brew cask install adoptopenjdk/openjdk/adoptopenjdk8
-export JAVA_HOME="$(/usr/libexec/java_home --version 1.11)"
+export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
 export PATH="$JAVA_HOME/bin:$PATH"
 ```
@@ -222,27 +189,8 @@ See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).
 ## Common steps
-**As a non-root user**, clone the project:
+If you want to build the server, install the [Android SDK] (_Android Studio_),
-
+and set `ANDROID_SDK_ROOT` to its directory. For example:
 ```bash
 git clone https://github.com/Genymobile/scrcpy
 cd scrcpy
 ```
 ### Build
 You may want to build only the client: the server binary, which will be pushed
 to the Android device, does not depend on your system and architecture. In that
 case, use the [prebuilt server] (so you will not need Java or the Android SDK).
 [prebuilt server]: #option-2-use-prebuilt-server
 #### Option 1: Build everything from sources
 Install the [Android SDK] (_Android Studio_), and set `ANDROID_SDK_ROOT` to its
 directory. For example:
 [Android SDK]: https://developer.android.com/studio/index.html
@@ -255,11 +203,20 @@ export ANDROID_SDK_ROOT=~/Library/Android/sdk
 set ANDROID_SDK_ROOT=%LOCALAPPDATA%\Android\sdk
 ```
 If you don't want to build the server, use the [prebuilt server].
 Clone the project:
 ```bash
 git clone https://github.com/Genymobile/scrcpy
 cd scrcpy
 ```
 Then, build:
 ```bash
 meson x --buildtype release --strip -Db_lto=true
-ninja -Cx  # DO NOT RUN AS ROOT
+ninja -Cx
 ```
 _Note: `ninja` [must][ninja-user] be run as a non-root user (only `ninja
@@ -268,27 +225,9 @@ install` must be run as root)._
 [ninja-user]: https://github.com/Genymobile/scrcpy/commit/4c49b27e9f6be02b8e63b508b60535426bd0291a
-#### Option 2: Use prebuilt server
+### Run
- - [`scrcpy-server-v1.19`][direct-scrcpy-server]  
+To run without installing:
   _(SHA-256: 876f9322182e6aac6a58db1334f4225855ef3a17eaebc80aab6601d9d1ecb867)_
 [direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.19/scrcpy-server-v1.19
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
 ```bash
 meson x --buildtype release --strip -Db_lto=true \
    -Dprebuilt_server=/path/to/scrcpy-server
 ninja -Cx  # DO NOT RUN AS ROOT
 ```
 The server only works with a matching client version (this server works with the
 `master` branch).
 ### Run without installing:
 ```bash
 ./run x [options]
@@ -303,16 +242,32 @@ After a successful build, you can install _scrcpy_ on the system:
 sudo ninja -Cx install    # without sudo on Windows
 ```
-This installs three files:
+This installs two files:
 - `/usr/local/bin/scrcpy`
 - `/usr/local/share/scrcpy/scrcpy-server`
- - `/usr/local/share/man/man1/scrcpy.1`
+
 Just remove them to "uninstall" the application.
 You can then [run](README.md#run) _scrcpy_.
-### Uninstall
+
 ## Prebuilt server
 - [`scrcpy-server-v1.17`][direct-scrcpy-server]  
   _(SHA-256: 11b5ad2d1bc9b9730fb7254a78efd71a8ff46b1938ff468e47a21b653a1b6725_
 [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:
 ```bash
-sudo ninja -Cx uninstall  # without sudo on Windows
+meson x --buildtype release --strip -Db_lto=true \
    -Dprebuilt_server=/path/to/scrcpy-server
 ninja -Cx
 sudo ninja -Cx install
 ```
 The server only works with a matching client version (this server works with the
 `master` branch).
--- 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).
@@ -211,7 +211,7 @@ There are two [frames][video_buffer] simultaneously in memory:
 - the **rendering** frame, rendered in a texture from the main thread.
 When a new decoded frame is available, the decoder _swaps_ the decoding and
-rendering frame (with proper synchronization). Thus, it immediately starts
+rendering frame (with proper synchronization). Thus, it immediatly starts
 to decode a new frame while the main thread renders the last one.
 If a [recorder] is present (i.e. `--record` is enabled), then it muxes the raw
--- a/FAQ.it.md
+++ b/FAQ.it.md
@@ -1,217 +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
 ### 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.
@@ -41,11 +39,8 @@ Check [stackoverflow][device-unauthorized].
 >     adb: error: failed to get feature set: no devices/emulators found
 Check that you correctly enabled [adb debugging][enable-adb].
 If your device is not detected, you may need some [drivers] (on Windows).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
@@ -116,19 +111,25 @@ In developer options, enable:
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ### Mouse clicks at wrong location
 On MacOS, with HiDPI support and multiple screens, input location are wrongly
 scaled. See [#15].
 [#15]: https://github.com/Genymobile/scrcpy/issues/15
 Open _scrcpy_ directly on the monitor you use it.
 ### 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 +158,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
@@ -256,12 +237,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.17](FAQ.it.md)
 - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.18](FAQ.zh-Hans.md)
--- a/FAQ.zh-Hans.md
+++ b/FAQ.zh-Hans.md
@@ -1,240 +0,0 @@
 只有原版的[FAQ](FAQ.md)会保持更新。
 本文根据[d6aaa5]翻译。
 [d6aaa5]:https://github.com/Genymobile/scrcpy/blob/d6aaa5bf9aa3710660c683b6e3e0ed971ee44af5/FAQ.md
 # 常见问题
 这里是一些常见的问题以及他们的状态。
 ## `adb` 相关问题
 `scrcpy` 执行 `adb` 命令来初始化和设备之间的连接。如果`adb` 执行失败了， scrcpy 就无法工作。
 在这种情况中，将会输出这个错误:
 >     ERROR: "adb push" returned with value 1
 这通常不是 _scrcpy_ 的bug，而是你的环境的问题。
 要找出原因，请执行以下操作：
 ```bash
 adb devices
 ```
 ### 找不到`adb`
 你的`PATH`中需要能访问到`adb`。
 在Windows上，当前目录会包含在`PATH`中，并且`adb.exe`也包含在发行版中，因此它应该是开箱即用（直接解压就可以）的。
 ### 设备未授权
 参见这里 [stackoverflow][device-unauthorized].
 [device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
 ### 未检测到设备
 >     adb: error: failed to get feature set: no devices/emulators found
 确认已经正确启用 [adb debugging][enable-adb].
 如果你的设备没有被检测到，你可能需要一些[驱动][drivers] (在 Windows上).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
 ### 已连接多个设备
 如果连接了多个设备，您将遇到以下错误：
 >     adb: error: failed to get feature set: more than one device/emulator
 必须提供要镜像的设备的标识符：
 ```bash
 scrcpy -s 01234567890abcdef
 ```
 注意，如果你的设备是通过 TCP/IP 连接的， 你将会收到以下消息：
 >     adb: error: more than one device/emulator
 >     ERROR: "adb reverse" returned with value 1
 >     WARN: 'adb reverse' failed, fallback to 'adb forward'
 这是意料之中的 (由于旧版安卓的一个bug, 请参见 [#5])，但是在这种情况下，scrcpy会退回到另一种方法，这种方法应该可以起作用。
 [#5]: https://github.com/Genymobile/scrcpy/issues/5
 ### adb版本之间冲突
 >     adb server version (41) doesn't match this client (39); killing...
 同时使用多个版本的`adb`时会发生此错误。你必须查找使用不同`adb`版本的程序，并在所有地方使用相同版本的`adb`。
 你可以覆盖另一个程序中的`adb`二进制文件，或者通过设置`ADB`环境变量来让 _scrcpy_ 使用特定的`adb`二进制文件。
 ```bash
 set ADB=/path/to/your/adb
 scrcpy
 ```
 ### 设备断开连接
 如果 _scrcpy_ 在警告“设备连接断开”的情况下自动中止，那就意味着`adb`连接已经断开了。
 请尝试使用另一条USB线或者电脑上的另一个USB接口。
 请参看 [#281] 和 [#283]。
 [#281]: https://github.com/Genymobile/scrcpy/issues/281
 [#283]: https://github.com/Genymobile/scrcpy/issues/283
 ## 控制相关问题
 ### 鼠标和键盘不起作用
 在某些设备上，您可能需要启用一个选项以允许 [模拟输入][simulating input]。
 在开发者选项中，打开：
 > **USB调试 (安全设置)**  
 > _允许通过USB调试修改权限或模拟点击_
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ### 特殊字符不起作用
 可输入的文本[被限制为ASCII字符][text-input]。也可以用一些小技巧输入一些[带重音符号的字符][accented-characters]，但是仅此而已。参见[#37]。
 [text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
 [accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
 [#37]: https://github.com/Genymobile/scrcpy/issues/37
 ## 客户端相关问题
 ### 效果很差
 如果你的客户端窗口分辨率比你的设备屏幕小，则可能出现效果差的问题，尤其是在文本上（参见 [#40]）。
 [#40]: https://github.com/Genymobile/scrcpy/issues/40
 为了提升降尺度的质量，如果渲染器是OpenGL并且支持mip映射，就会自动开启三线性过滤。
 在Windows上，你可能希望强制使用OpenGL：
 ```
 scrcpy --render-driver=opengl
 ```
 你可能还需要配置[缩放行为][scaling behavior]：
 > `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
 > Override high DPI scaling behavior > Scaling performed by: _Application_.
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 ### Wayland相关的问题
 在Linux上，SDL默认使用x11。可以通过`SDL_VIDEODRIVER`环境变量来更改[视频驱动][video driver]：
 [video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
 ```bash
 export SDL_VIDEODRIVER=wayland
 scrcpy
 ```
 在一些发行版上 (至少包括 Fedora)， `libdecor` 包必须手动安装。
 参见 [#2554] 和 [#2559]。
 [#2554]: https://github.com/Genymobile/scrcpy/issues/2554
 [#2559]: https://github.com/Genymobile/scrcpy/issues/2559
 ### KWin compositor 崩溃
 在Plasma桌面中，当 _scrcpy_ 运行时，会禁用compositor。
 一种解决方法是， [禁用 "Block compositing"][kwin].
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
 ## 崩溃
 ### 异常
 可能有很多原因。一个常见的原因是您的设备无法按给定清晰度进行编码：
 > ```
 > ERROR: Exception on thread Thread[main,5,main]
 > android.media.MediaCodec$CodecException: Error 0xfffffc0e
 > ...
 > Exit due to uncaughtException in main thread:
 > ERROR: Could not open video stream
 > INFO: Initial texture: 1080x2336
 > ```
 或者
 > ```
 > ERROR: Exception on thread Thread[main,5,main]
 > java.lang.IllegalStateException
 >         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
 > ```
 请尝试使用更低的清晰度：
 ```
 scrcpy -m 1920
 scrcpy -m 1024
 scrcpy -m 800
 ```
 你也可以尝试另一种 [编码器](README.md#encoder)。
 ## Windows命令行
 一些Windows用户不熟悉命令行。以下是如何打开终端并带参数执行`scrcpy`：
 1. 按下 <kbd>Windows</kbd>+<kbd>r</kbd>，打开一个对话框。
 2. 输入 `cmd` 并按 <kbd>Enter</kbd>，这样就打开了一个终端。
 3. 通过输入以下命令，切换到你的 _scrcpy_ 所在的目录 （根据你的实际位置修改路径）:
    ```bat
    cd C:\Users\user\Downloads\scrcpy-win64-xxx
    ```
    然后按 <kbd>Enter</kbd>
 4. 输入你的命令。比如:
    ```bat
    scrcpy --record file.mkv
    ```
 如果你打算总是使用相同的参数，在`scrcpy`目录创建一个文件 `myscrcpy.bat`
 （启用 [显示文件拓展名][show file extensions] 避免混淆），文件中包含你的命令。例如：
 ```bat
 scrcpy --prefer-text --turn-screen-off --stay-awake
 ```
 然后双击刚刚创建的文件。
 你也可以编辑 `scrcpy-console.bat` 或者 `scrcpy-noconsole.vbs`（的副本）来添加参数。
 [show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/
--- a/README.id.md
+++ b/README.id.md
@@ -69,7 +69,10 @@ Anda juga bisa [membangun aplikasi secara manual][BUILD] (jangan khawatir, tidak
 Untuk Windows, untuk kesederhanaan, arsip prebuilt dengan semua dependensi (termasuk `adb`) tersedia :
- - [README](README.md#windows)
+ - [`scrcpy-win64-v1.16.zip`][direct-win64]  
   _(SHA-256: 3f30dc5db1a2f95c2b40a0f5de91ec1642d9f53799250a8c529bc882bc0918f0)_
 [direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.16/scrcpy-win64-v1.16.zip
 Ini juga tersedia di [Chocolatey]:
--- a/README.it.md
+++ b/README.it.md
@@ -1,742 +0,0 @@
 _Apri il [README](README.md) originale e sempre aggiornato._
 # scrcpy (v1.17)
 Questa applicazione fornisce la visualizzazione e il controllo dei dispositivi Android collegati via USB (o [via TCP/IP][article-tcpip]). Non richiede alcun accesso _root_.
 Funziona su _GNU/Linux_, _Windows_ e _macOS_.
 ![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 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 _
 ```
 ### 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
 ### 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
 ```
 #### Renderizzare i fotogrammi scaduti
 Per minimizzare la latenza _scrcpy_ renderizza sempre l'ultimo fotogramma decodificato disponibile in maniera predefinita e tralascia quelli precedenti.
 Per forzare la renderizzazione di tutti i fotogrammi (a costo di una possibile latenza superiore), utilizzare:
 ```bash
 scrcpy --render-expired-frames
 ```
 #### Mostrare i tocchi
 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/` del dispositivo trascina e rilascia un file (non APK) nella finestra di _scrcpy_.
 Non c'è alcuna risposta visiva, un log è stampato nella console.
 La cartella di destinazione può essere cambiata all'avvio:
 ```bash
 scrcpy --push-target=/sdcard/Download/
 ```
 ### 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¹_
 | Premi il tasto `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Click centrale_
 | Premi il tasto `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Click destro²_
 | Premi il tasto `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd>
 | Premi il tasto `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>
 | Chiudi il pannello delle notifiche                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | Copia negli appunti³                          | <kbd>MOD</kbd>+<kbd>c</kbd>
 | Taglia negli appunti³                           | <kbd>MOD</kbd>+<kbd>x</kbd>
 | Sincronizza gli appunti e incolla³           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Inietta il testo degli appunti del computer              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Abilita/Disabilita il contatore FPS (su stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
 | Pizzica per zoomare                               | <kbd>Ctrl</kbd>+_click e trascina_
 _¹Doppio click sui bordi neri per rimuoverli._  
 _²Il tasto destro accende lo schermo se era spento, preme BACK in caso contrario._  
 _³Solo in Android >= 7._
 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,725 +0,0 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._
 # scrcpy (v1.17)
 このアプリケーションはUSB(もしくは[TCP/IP経由][article-tcpip])で接続されたAndroidデバイスの表示と制御を提供します。このアプリケーションは _root_ でのアクセスを必要としません。このアプリケーションは _GNU/Linux_ 、 _Windows_ そして _macOS_ 上で動作します。
 ![screenshot](assets/screenshot-debian-600.jpg)
 以下に焦点を当てています:
 - **軽量** (ネイティブ、デバイス画面表示のみ)
 - **パフォーマンス**　(30~60fps)
 - **クオリティ**　(1920x1080以上)
 - **低遅延**　([35~70ms][lowlatency])
 - **短い起動時間**　(初回画像を1秒以内に表示)
 - **非侵入型**　(デバイスに何もインストールされていない状態になる)
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 ## 必要要件
 AndroidデバイスはAPI21(Android 5.0)以上。
 Androidデバイスで[adbデバッグが有効][enable-adb]であること。
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 一部のAndroidデバイスでは、キーボードとマウスを使用して制御する[追加オプション][control]を有効にする必要がある。
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ## アプリの取得
 <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
 Debian (_testing_ と _sid_) とUbuntu(20.04):
 ```
 apt install scrcpy
 ```
 [Snap]パッケージが利用可能: [`scrcpy`][snap-link]
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
 Fedora用[COPR]パッケージが利用可能: [`scrcpy`][copr-link]
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 Arch Linux用[AUR]パッケージが利用可能: [`scrcpy`][aur-link]
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 [aur-link]: https://aur.archlinux.org/packages/scrcpy/
 Gentoo用[Ebuild]が利用可能: [`scrcpy`][ebuild-link]
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 [自分でビルド][BUILD]も可能（心配しないでください、それほど難しくはありません。）
 ### Windows
 Windowsでは簡単に、（`adb`を含む）すべての依存関係を構築済みのアーカイブを利用可能です。
 - [README](README.md#windows)
 [Chocolatey]でも利用可能です:
 [Chocolatey]: https://chocolatey.org/
 ```bash
 choco install scrcpy
 choco install adb    # まだ入手していない場合
 ```
 [Scoop]でも利用可能です:
 ```bash
 scoop install scrcpy
 scoop install adb    # まだ入手していない場合
 ```
 [Scoop]: https://scoop.sh
 また、[アプリケーションをビルド][BUILD]することも可能です。
 ### macOS
 アプリケーションは[Homebrew]で利用可能です。ただインストールするだけです。
 [Homebrew]: https://brew.sh/
 ```bash
 brew install scrcpy
 ```
 `PATH`から`adb`へのアクセスが必要です。もしまだ持っていない場合:
 ```bash
 # Homebrew >= 2.6.0
 brew install --cask android-platform-tools
 # Homebrew < 2.6.0
 brew cask install android-platform-tools
 ```
 また、[アプリケーションをビルド][BUILD]することも可能です。
 ## 実行
 Androidデバイスを接続し、実行:
 ```bash
 scrcpy
 ```
 次のコマンドでリストされるコマンドライン引数も受け付けます:
 ```bash
 scrcpy --help
 ```
 ## 機能
 ### キャプチャ構成
 #### サイズ削減
 Androidデバイスを低解像度でミラーリングする場合、パフォーマンス向上に便利な場合があります。
 幅と高さをある値(例：1024)に制限するには:
 ```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # 短縮版
 ```
 一方のサイズはデバイスのアスペクト比が維持されるように計算されます。この方法では、1920x1080のデバイスでは1024x576にミラーリングされます。
 #### ビットレート変更
 ビットレートの初期値は8Mbpsです。ビットレートを変更するには(例:2Mbpsに変更):
 ```bash
 scrcpy --bit-rate 2M
 scrcpy -b 2M  # 短縮版
 ```
 #### フレームレート制限
 キャプチャするフレームレートを制限できます:
 ```bash
 scrcpy --max-fps 15
 ```
 この機能はAndroid 10からオフィシャルサポートとなっていますが、以前のバージョンでも動作する可能性があります。
 #### トリミング
 デバイスの画面は、画面の一部のみをミラーリングするようにトリミングできます。
 これは、例えばOculus Goの片方の目をミラーリングする場合に便利です。:
 ```bash
 scrcpy --crop 1224:1440:0:0   # オフセット位置(0,0)で1224x1440
 ```
 もし`--max-size`も指定されている場合、トリミング後にサイズ変更が適用されます。
 #### ビデオの向きをロックする
 ミラーリングの向きをロックするには:
 ```bash
 scrcpy --lock-video-orientation 0   # 自然な向き
 scrcpy --lock-video-orientation 1   # 90°反時計回り
 scrcpy --lock-video-orientation 2   # 180°
 scrcpy --lock-video-orientation 3   # 90°時計回り
 ```
 この設定は録画の向きに影響します。
 [ウィンドウは独立して回転することもできます](#回転)。
 #### エンコーダ
 いくつかのデバイスでは一つ以上のエンコーダを持ちます。それらのいくつかは、問題やクラッシュを引き起こします。別のエンコーダを選択することが可能です:
 ```bash
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```
 利用可能なエンコーダをリストするために、無効なエンコーダ名を渡すことができます。エラー表示で利用可能なエンコーダを提供します。
 ```bash
 scrcpy --encoder _
 ```
 ### 録画
 ミラーリング中に画面の録画をすることが可能です:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 録画中にミラーリングを無効にするには:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # Ctrl+Cで録画を中断する
 ```
 "スキップされたフレーム"は(パフォーマンス上の理由で)リアルタイムで表示されなくても録画されます。
 フレームはデバイス上で _タイムスタンプされる_ ため [パケット遅延のバリエーション] は録画されたファイルに影響を与えません。
 [パケット遅延のバリエーション]: https://en.wikipedia.org/wiki/Packet_delay_variation
 ### 接続
 #### ワイヤレス
 _Scrcpy_ はデバイスとの通信に`adb`を使用します。そして`adb`はTCP/IPを介しデバイスに[接続]することができます:
 1. あなたのコンピュータと同じWi-Fiに接続します。
 2. あなたのIPアドレスを取得します。設定 → 端末情報 → ステータス情報、もしくは、このコマンドを実行します:
    ```bash
    adb shell ip route | awk '{print $9}'
    ```
 3. あなたのデバイスでTCP/IPを介したadbを有効にします: `adb tcpip 5555`
 4. あなたのデバイスの接続を外します。
 5. あなたのデバイスに接続します:
 `adb connect DEVICE_IP:5555` _(`DEVICE_IP`は置き換える)_
 6. 通常通り`scrcpy`を実行します。
 この方法はビットレートと解像度を減らすのにおそらく有用です:
 ```bash
 scrcpy --bit-rate 2M --max-size 800
 scrcpy -b2M -m800  # 短縮版
 ```
 [接続]: https://developer.android.com/studio/command-line/adb.html#wireless
 #### マルチデバイス
 もし`adb devices`でいくつかのデバイスがリストされる場合、 _シリアルナンバー_ を指定する必要があります:
 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # 短縮版
 ```
 デバイスがTCP/IPを介して接続されている場合:
 ```bash
 scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # 短縮版
 ```
 複数のデバイスに対して、複数の _scrcpy_ インスタンスを開始することができます。
 #### デバイス接続での自動起動
 [AutoAdb]を使用可能です:
 ```bash
 autoadb scrcpy -s '{}'
 ```
 [AutoAdb]: https://github.com/rom1v/autoadb
 #### SSHトンネル
 リモートデバイスに接続するため、ローカル`adb`クライアントからリモート`adb`サーバーへ接続することが可能です(同じバージョンの _adb_ プロトコルを使用している場合):
 ```bash
 adb kill-server    # 5037ポートのローカルadbサーバーを終了する
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # オープンしたままにする
 ```
 他の端末から:
 ```bash
 scrcpy
 ```
 リモートポート転送の有効化を回避するためには、代わりに転送接続を強制することができます(`-R`の代わりに`-L`を使用することに注意):
 ```bash
 adb kill-server    # 5037ポートのローカルadbサーバーを終了する
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # オープンしたままにする
 ```
 他の端末から:
 ```bash
 scrcpy --force-adb-forward
 ```
 ワイヤレス接続と同様に、クオリティを下げると便利な場合があります:
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### ウィンドウ構成
 #### タイトル
 ウィンドウのタイトルはデバイスモデルが初期値です。これは変更できます:
 ```bash
 scrcpy --window-title 'My device'
 ```
 #### 位置とサイズ
 ウィンドウの位置とサイズの初期値を指定できます:
 ```bash
 scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 ```
 #### ボーダーレス
 ウィンドウの装飾を無効化するには:
 ```bash
 scrcpy --window-borderless
 ```
 #### 常に画面のトップ
 scrcpyの画面を常にトップにするには:
 ```bash
 scrcpy --always-on-top
 ```
 #### フルスクリーン
 アプリケーションを直接フルスクリーンで開始できます:
 ```bash
 scrcpy --fullscreen
 scrcpy -f  # 短縮版
 ```
 フルスクリーンは、次のコマンドで動的に切り替えることができます <kbd>MOD</kbd>+<kbd>f</kbd>
 #### 回転
 ウィンドウは回転することができます:
 ```bash
 scrcpy --rotation 1
 ```
 設定可能な値:
 - `0`: 回転なし
 - `1`: 90° 反時計回り
 - `2`: 180°
 - `3`: 90° 時計回り
 回転は次のコマンドで動的に変更することができます。 <kbd>MOD</kbd>+<kbd>←</kbd>_(左)_ 、 <kbd>MOD</kbd>+<kbd>→</kbd>_(右)_
 _scrcpy_ は3つの回転を管理することに注意:
 - <kbd>MOD</kbd>+<kbd>r</kbd>はデバイスに縦向きと横向きの切り替えを要求する(現在実行中のアプリで要求している向きをサポートしていない場合、拒否することがある)
 - [`--lock-video-orientation`](#ビデオの向きをロックする)は、ミラーリングする向きを変更する(デバイスからPCへ送信される向き)。録画に影響します。
 - `--rotation` (もしくは<kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)は、ウィンドウのコンテンツのみを回転します。これは表示にのみに影響し、録画には影響しません。
 ### 他のミラーリングオプション
 #### Read-only　リードオンリー
 制御を無効にするには(デバイスと対話する全てのもの:入力キー、マウスイベント、ファイルのドラッグ&ドロップ):
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
 #### ディスプレイ
 いくつか利用可能なディスプレイがある場合、ミラーリングするディスプレイを選択できます:
 ```bash
 scrcpy --display 1
 ```
 ディスプレイIDのリストは次の方法で取得できます:
 ```
 adb shell dumpsys display   # search "mDisplayId=" in the output
 ```
 セカンダリディスプレイは、デバイスが少なくともAndroid 10の場合にコントロール可能です。(それ以外ではリードオンリーでミラーリングされます)
 #### 起動状態にする
 デバイス接続時、少し遅れてからデバイスのスリープを防ぐには:
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
 scrcpyが閉じられた時、初期状態に復元されます。
 #### 画面OFF
 コマンドラインオプションを使用することで、ミラーリングの開始時にデバイスの画面をOFFにすることができます:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
 もしくは、<kbd>MOD</kbd>+<kbd>o</kbd>を押すことでいつでもできます。
 元に戻すには、<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>を押します。
 Androidでは、`POWER`ボタンはいつでも画面を表示します。便宜上、`POWER`がscrcpyを介して(右クリックもしくは<kbd>MOD</kbd>+<kbd>p</kbd>を介して)送信される場合、(ベストエフォートベースで)少し遅れて、強制的に画面を非表示にします。ただし、物理的な`POWER`ボタンを押した場合は、画面は表示されます。
 このオプションはデバイスがスリープしないようにすることにも役立ちます:
 ```bash
 scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
 #### 期限切れフレームをレンダリングする
 初期状態では、待ち時間を最小限にするために、_scrcpy_ は最後にデコードされたフレームをレンダリングし、前のフレームを削除します。
 全フレームのレンダリングを強制するには(待ち時間が長くなる可能性があります):
 ```bash
 scrcpy --render-expired-frames
 ```
 #### タッチを表示
 プレゼンテーションの場合(物理デバイス上で)物理的なタッチを表示すると便利な場合があります。
 Androidはこの機能を _開発者オプション_ で提供します。
 _Scrcpy_　は開始時にこの機能を有効にし、終了時に初期値を復元するオプションを提供します:
 ```bash
 scrcpy --show-touches
 scrcpy -t
 ```
 (デバイス上で指を使った) _物理的な_ タッチのみ表示されることに注意してください。
 #### スクリーンセーバー無効
 初期状態では、scrcpyはコンピュータ上でスクリーンセーバーが実行される事を妨げません。
 これを無効にするには:
 ```bash
 scrcpy --disable-screensaver
 ```
 ### 入力制御
 #### デバイス画面の回転
 <kbd>MOD</kbd>+<kbd>r</kbd>を押すことで、縦向きと横向きを切り替えます。
 フォアグラウンドのアプリケーションが要求された向きをサポートしている場合のみ回転することに注意してください。
 #### コピー-ペースト
 Androidのクリップボードが変更される度に、コンピュータのクリップボードに自動的に同期されます。
 <kbd>Ctrl</kbd>のショートカットは全てデバイスに転送されます。特に:
 - <kbd>Ctrl</kbd>+<kbd>c</kbd> 通常はコピーします
 - <kbd>Ctrl</kbd>+<kbd>x</kbd> 通常はカットします
 - <kbd>Ctrl</kbd>+<kbd>v</kbd> 通常はペーストします(コンピュータとデバイスのクリップボードが同期された後)
 通常は期待通りに動作します。
 しかしながら、実際の動作はアクティブなアプリケーションに依存します。例えば、_Termux_ は代わりに<kbd>Ctrl</kbd>+<kbd>c</kbd>でSIGINTを送信します、そして、_K-9 Mail_ は新しいメッセージを作成します。
 このようなケースでコピー、カットそしてペーストをするには(Android 7以上でのサポートのみですが):
 - <kbd>MOD</kbd>+<kbd>c</kbd> `COPY`を挿入
 - <kbd>MOD</kbd>+<kbd>x</kbd> `CUT`を挿入
 - <kbd>MOD</kbd>+<kbd>v</kbd> `PASTE`を挿入(コンピュータとデバイスのクリップボードが同期された後)
 加えて、<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>はコンピュータのクリップボードテキストにキーイベントのシーケンスとして挿入することを許可します。これはコンポーネントがテキストのペーストを許可しない場合(例えば _Termux_)に有用ですが、非ASCIIコンテンツを壊す可能性があります。
 **警告:** デバイスにコンピュータのクリップボードを(<kbd>Ctrl</kbd>+<kbd>v</kbd>または<kbd>MOD</kbd>+<kbd>v</kbd>を介して)ペーストすることは、デバイスのクリップボードにコンテンツをコピーします。結果としてどのAndoridアプリケーションもそのコンテンツを読み取ることができます。機密性の高いコンテンツ(例えばパスワードなど)をこの方法でペーストすることは避けてください。
 プログラムでデバイスのクリップボードを設定した場合、一部のデバイスは期待どおりに動作しません。`--legacy-paste`オプションは、コンピュータのクリップボードテキストをキーイベントのシーケンスとして挿入するため(<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>と同じ方法)、<kbd>Ctrl</kbd>+<kbd>v</kbd>と<kbd>MOD</kbd>+<kbd>v</kbd>の動作の変更を提供します。
 #### ピンチしてズームする
 "ピンチしてズームする"をシミュレートするには: <kbd>Ctrl</kbd>+_クリック&移動_
 より正確にするには、左クリックボタンを押している間、<kbd>Ctrl</kbd>を押したままにします。左クリックボタンを離すまで、全てのマウスの動きは、(アプリでサポートされている場合)画面の中心を基準として、コンテンツを拡大縮小および回転します。
 具体的には、scrcpyは画面の中央を反転した位置にある"バーチャルフィンガー"から追加のタッチイベントを生成します。
 #### テキストインジェクション環境設定
 テキストをタイプした時に生成される2種類の[イベント][textevents]があります:
 - _key events_　はキーを押したときと離したことを通知します。
 - _text events_　はテキストが入力されたことを通知します。
 初期状態で、文字はキーイベントで挿入されるため、キーボードはゲームで期待通りに動作します(通常はWASDキー)。
 しかし、これは[問題を引き起こす][prefertext]かもしれません。もしこのような問題が発生した場合は、この方法で回避できます:
 ```bash
 scrcpy --prefer-text
 ```
 (しかしこの方法はゲームのキーボードの動作を壊します)
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 #### キーの繰り返し
 初期状態では、キーの押しっぱなしは繰り返しのキーイベントを生成します。これらのイベントが使われない場合でも、この方法は一部のゲームでパフォーマンスの問題を引き起す可能性があります。
 繰り返しのキーイベントの転送を回避するためには:
 ```bash
 scrcpy --no-key-repeat
 ```
 #### 右クリックと真ん中クリック
 初期状態では、右クリックはバックの動作(もしくはパワーオン)を起こし、真ん中クリックではホーム画面へ戻ります。このショートカットを無効にし、代わりにデバイスへクリックを転送するには:
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### ファイルのドロップ
 #### APKのインストール
 APKをインストールするには、(`.apk`で終わる)APKファイルを _scrcpy_ の画面にドラッグ&ドロップします。
 見た目のフィードバックはありません。コンソールにログが出力されます。
 #### デバイスにファイルを送る
 デバイスの`/sdcard/`ディレクトリにファイルを送るには、(APKではない)ファイルを _scrcpy_ の画面にドラッグ&ドロップします。
 見た目のフィードバックはありません。コンソールにログが出力されます。
 転送先ディレクトリを起動時に変更することができます:
 ```bash
 scrcpy --push-target /sdcard/foo/bar/
 ```
 ### 音声転送
 音声は _scrcpy_ では転送されません。[sndcpy]を使用します。
 [issue #14]も参照ください。
 [sndcpy]: https://github.com/rom1v/sndcpy
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## ショートカット
 次のリストでは、<kbd>MOD</kbd>でショートカット変更します。初期状態では、(left)<kbd>Alt</kbd>または(left)<kbd>Super</kbd>です。
 これは`--shortcut-mod`で変更することができます。可能なキーは`lctrl`、`rctrl`、`lalt`、 `ralt`、 `lsuper`そして`rsuper`です。例えば:
 ```bash
 # RCtrlをショートカットとして使用します
 scrcpy --shortcut-mod=rctrl
 # ショートカットにLCtrl+LAltまたはLSuperのいずれかを使用します
 scrcpy --shortcut-mod=lctrl+lalt,lsuper
 ```
 _<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>←</kbd> _(左)_
 | ディスプレイを右に回転                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(右)_
 | ウィンドウサイズを変更して1:1に変更(ピクセルパーフェクト)  | <kbd>MOD</kbd>+<kbd>g</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>
 | `MENU` (画面のアンロック)をクリック            | <kbd>MOD</kbd>+<kbd>m</kbd>
 | `VOLUME_UP`をクリック                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上)_
 | `VOLUME_DOWN`をクリック                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下)_
 | `POWER`をクリック                            | <kbd>MOD</kbd>+<kbd>p</kbd>
 | 電源オン                                     | _右クリック²_
 | デバイス画面をオフにする(ミラーリングしたまま)  | <kbd>MOD</kbd>+<kbd>o</kbd>
 | デバイス画面をオンにする                      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | デバイス画面を回転する                        | <kbd>MOD</kbd>+<kbd>r</kbd>
 | 通知パネルを展開する                          | <kbd>MOD</kbd>+<kbd>n</kbd>
 | 通知パネルを折りたたむ                        | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | クリップボードへのコピー³                     | <kbd>MOD</kbd>+<kbd>c</kbd>
 | クリップボードへのカット³                     | <kbd>MOD</kbd>+<kbd>x</kbd>
 | クリップボードの同期とペースト³                | <kbd>MOD</kbd>+<kbd>v</kbd>
 | コンピュータのクリップボードテキストの挿入      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | FPSカウンタ有効/無効(標準入出力上)             | <kbd>MOD</kbd>+<kbd>i</kbd>
 | ピンチしてズームする                          | <kbd>Ctrl</kbd>+_クリック&移動_
 _¹黒い境界線を削除するため、境界線上でダブルクリック_  
 _²もしスクリーンがオフの場合、右クリックでスクリーンをオンする。それ以外の場合はBackを押します._  
 _³Android 7以上のみ._
 全ての<kbd>Ctrl</kbd>+_キー_ ショートカットはデバイスに転送されます、そのためアクティブなアプリケーションによって処理されます。
 ## カスタムパス
 特定の _adb_ バイナリを使用する場合、そのパスを環境変数`ADB`で構成します:
    ADB=/path/to/adb scrcpy
 `scrcpy-server`ファイルのパスを上書きするには、`SCRCPY_SERVER_PATH`でそのパスを構成します。
 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## なぜ _scrcpy_?
 同僚が私に、[gnirehtet]のように発音できない名前を見つけるように要求しました。
 [`strcpy`]は**str**ingをコピーします。`scrcpy`は**scr**eenをコピーします。
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## ビルド方法は?
 [BUILD]を参照してください。
 [BUILD]: BUILD.md
 ## よくある質問
 [FAQ](FAQ.md)を参照してください。
 ## 開発者
 [開発者のページ]を読んでください。
 [開発者のページ]: DEVELOP.md
 ## ライセンス
    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.
 ## 記事
 - [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.ko.md
+++ b/README.ko.md
@@ -68,7 +68,9 @@ Gentoo에서 ,[Ebuild] 가 가능합니다 : [`scrcpy/`][ebuild-link].
 윈도우 상에서, 간단하게 설치하기 위해 종속성이 있는 사전 구축된 아카이브가 제공됩니다 (`adb` 포함) :
 해당 파일은 Readme원본 링크를 통해서 다운로드가 가능합니다.
- - [README](README.md#windows)
+ - [`scrcpy-win`][direct-win]
 [direct-win]: https://github.com/Genymobile/scrcpy/blob/master/README.md#windows
 [어플을 직접 설치][BUILD] 할 수도 있습니다.
@@ -112,7 +114,7 @@ scrcpy --help
 ### 캡쳐 환경 설정
-### 사이즈 재정의
+###사이즈 재정의
 가끔씩 성능을 향상시키기위해 안드로이드 디바이스를 낮은 해상도에서 미러링하는 것이 유용할 때도 있습니다.
@@ -136,7 +138,7 @@ scrcpy --bit-rate 2M
 scrcpy -b 2M  # 축약 버전
 ```
-### 프레임 비율 제한
+###프레임 비율 제한
 안드로이드 버전 10이상의 디바이스에서는, 다음의 명령어로 캡쳐 화면의 프레임 비율을 제한할 수 있습니다:
--- a/README.md
+++ b/README.md
@@ -1,6 +1,4 @@
-# scrcpy (v1.19)
+# scrcpy (v1.17)
 ![icon](data/icon.png)
 [Read in another language](#translations)
@@ -40,18 +38,6 @@ control it using keyboard and 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>
 ### Summary
 - Linux: `apt install scrcpy`
 - Windows: [download][direct-win64]
 - macOS: `brew install scrcpy`
 Build from sources: [BUILD] ([simplified process][BUILD_simple])
 [BUILD]: BUILD.md
 [BUILD_simple]: BUILD.md#simple
 ### Linux
 On Debian (_testing_ and _sid_ for now) and Ubuntu (20.04):
@@ -81,8 +67,9 @@ For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-You could also [build the app manually][BUILD] ([simplified
+You could also [build the app manually][BUILD] (don't worry, it's not that
-process][BUILD_simple]).
+hard).
 ### Windows
@@ -90,10 +77,10 @@ process][BUILD_simple]).
 For Windows, for simplicity, a prebuilt archive with all the dependencies
 (including `adb`) is available:
- - [`scrcpy-win64-v1.19.zip`][direct-win64]  
+ - [`scrcpy-win64-v1.17.zip`][direct-win64]  
-   _(SHA-256: 383d6483f25ac0092d4bb9fef6c967351ecd50fc248e0c82932db97d6d32f11b)_
+   _(SHA-256: 8b9e57993c707367ed10ebfe0e1ef563c7a29d9af4a355cd8b6a52a317c73eea)_
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.19/scrcpy-win64-v1.19.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-win64-v1.17.zip
 It is also available in [Chocolatey]:
@@ -129,18 +116,13 @@ brew install scrcpy
 You need `adb`, accessible from your `PATH`. If you don't have it yet:
 ```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
 ```
 It's also available in [MacPorts], which sets up adb for you:
 ```bash
 sudo port install scrcpy
 ```
 [MacPorts]: https://www.macports.org/
 You can also [build the app manually][BUILD].
@@ -216,11 +198,10 @@ If `--max-size` is also specified, resizing is applied after cropping.
 To lock the orientation of the mirroring:
 ```bash
-scrcpy --lock-video-orientation     # initial (current) orientation
+scrcpy --lock-video-orientation 0   # natural orientation
-scrcpy --lock-video-orientation=0   # natural orientation
+scrcpy --lock-video-orientation 1   # 90° counterclockwise
-scrcpy --lock-video-orientation=1   # 90° counterclockwise
+scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation 3   # 90° clockwise
 scrcpy --lock-video-orientation=3   # 90° clockwise
 ```
 This affects recording orientation.
@@ -244,9 +225,7 @@ error will give the available encoders:
 scrcpy --encoder _
 ```
-### Capture
+### Recording
 #### Recording
 It is possible to record the screen while mirroring:
@@ -270,77 +249,6 @@ variation] does not impact the recorded file.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 #### v4l2loopback
 On Linux, it is possible to send the video stream to a v4l2 loopback device, so
 that the Android device can be opened like a webcam by any v4l2-capable tool.
 The module `v4l2loopback` must be installed:
 ```bash
 sudo apt install v4l2loopback-dkms
 ```
 To create a v4l2 device:
 ```bash
 sudo modprobe v4l2loopback
 ```
 This will create a new video device in `/dev/videoN`, where `N` is an integer
 (more [options](https://github.com/umlaeute/v4l2loopback#options) are available
 to create several devices or devices with specific IDs).
 To list the enabled devices:
 ```bash
 # requires v4l-utils package
 v4l2-ctl --list-devices
 # simple but might be sufficient
 ls /dev/video*
 ```
 To start scrcpy using a v4l2 sink:
 ```bash
 scrcpy --v4l2-sink=/dev/videoN
 scrcpy --v4l2-sink=/dev/videoN --no-display  # disable mirroring window
 scrcpy --v4l2-sink=/dev/videoN -N            # short version
 ```
 (replace `N` by the device ID, check with `ls /dev/video*`)
 Once enabled, you can open your video stream with a v4l2-capable tool:
 ```bash
 ffplay -i /dev/videoN
 vlc v4l2:///dev/videoN   # VLC might add some buffering delay
 ```
 For example, you could capture the video within [OBS].
 [OBS]: https://obsproject.com/
 #### Buffering
 It is possible to add buffering. This increases latency but reduces jitter (see
 #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
 #### Wireless
@@ -503,7 +411,7 @@ _(left)_ and <kbd>MOD</kbd>+<kbd>→</kbd> _(right)_.
 Note that _scrcpy_ manages 3 different rotations:
 - <kbd>MOD</kbd>+<kbd>r</kbd> requests the device to switch between portrait
-   and landscape (the current running app may refuse, if it does not support the
+   and landscape (the current running app may refuse, if it does support the
   requested orientation).
 - [`--lock-video-orientation`](#lock-video-orientation) changes the mirroring
   orientation (the orientation of the video sent from the device to the
@@ -536,7 +444,7 @@ scrcpy --display 1
 The list of display ids can be retrieved by:
-```bash
+```
 adb shell dumpsys display   # search "mDisplayId=" in the output
 ```
@@ -582,14 +490,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
@@ -681,39 +581,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 USB physical keyboard on Android to provide a
 better input experience (using [USB HID over AOAv2][hid-aoav2]): the virtual
 keyboard is disabled and it works for all characters and IME.
 [hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
 However, it only works if the device is connected by USB, and is currently only
 supported on Linux.
 To enable this mode:
 ```bash
 scrcpy --hid-keyboard
 scrcpy -K  # short version
 ```
 If it fails for some reason (for example because the device is not connected via
 USB), it automatically fallbacks to the default mode (with a log in the
 console). This allows to use the same command line options when connected over
 USB and TCP/IP.
 In this mode, raw key events (scancodes) are sent to the device, independently
 of the host key mapping. Therefore, if your keyboard layout does not match, it
 must be configured on the Android device, in Settings → System → Languages and
 input → [Physical keyboard].
 [Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
 #### Text injection preference
@@ -733,9 +600,6 @@ scrcpy --prefer-text
 (but this will break keyboard behavior in games)
 This option has no effect on HID keyboard (all key events are sent as
 scancodes in this mode).
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
@@ -751,9 +615,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
@@ -777,15 +638,15 @@ There is no visual feedback, a log is printed to the console.
 #### Push file to device
-To push a file to `/sdcard/Download/` on the device, drag & drop a (non-APK)
+To push a file to `/sdcard/` on the device, drag & drop a (non-APK) file to the
-file to the _scrcpy_ window.
+_scrcpy_ window.
 There is no visual feedback, a log is printed to the console.
 The target directory can be changed on start:
 ```bash
-scrcpy --push-target=/sdcard/Movies/
+scrcpy --push-target /sdcard/foo/bar/
 ```
@@ -825,10 +686,10 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
 | Rotate display left                         | <kbd>MOD</kbd>+<kbd>←</kbd> _(left)_
 | Rotate display right                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(right)_
 | Resize window to 1:1 (pixel-perfect)        | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Resize window to remove black borders       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Double-left-click¹_
+ | Resize window to remove black borders       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Double-click¹_
 | Click on `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Middle-click_
 | Click on `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Right-click²_
- | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4th-click³_
+ | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd>
 | Click on `MENU` (unlock screen)             | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Click on `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(up)_
 | Click on `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(down)_
@@ -837,29 +698,18 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
 | Turn device screen off (keep mirroring)     | <kbd>MOD</kbd>+<kbd>o</kbd>
 | Turn device screen on                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Rotate device screen                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5th-click³_
+ | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd>
- | Expand settings panel                       | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Double-5th-click³_
+ | Collapse notification panel                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Collapse panels                             | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copy to clipboard³                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Copy to clipboard⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Cut to clipboard³                           | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Cut to clipboard⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Synchronize clipboards and paste³           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Synchronize clipboards and paste⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Inject computer clipboard text              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Enable/disable FPS counter (on stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
 | Pinch-to-zoom                               | <kbd>Ctrl</kbd>+_click-and-move_
 | 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._  
-_³4th and 5th mouse buttons, if your mouse has them._  
+_³Only on Android >= 7._
 _⁴Only on Android >= 7._
 Shortcuts with repeated keys are executted by releasing and pressing the key a
 second time. For example, to execute "Expand settings panel":
 1. Press and keep pressing <kbd>MOD</kbd>.
 2. Then double-press <kbd>n</kbd>.
 3. Finally, release <kbd>MOD</kbd>.
 All <kbd>Ctrl</kbd>+_key_ shortcuts are forwarded to the device, so they are
 handled by the active application.
@@ -870,14 +720,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
 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_?
@@ -894,6 +742,8 @@ A colleague challenged me to find a name as unpronounceable as [gnirehtet].
 See [BUILD].
 [BUILD]: BUILD.md
 ## Common issues
@@ -937,13 +787,9 @@ Read the [developers page].
 This README is available in other languages:
 - [Indonesian (Indonesia, `id`) - v1.16](README.id.md)
 - [Italiano (Italiano, `it`) - v1.17](README.it.md)
 - [日本語 (Japanese, `jp`) - v1.17](README.jp.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
- [português brasileiro (Brazilian Portuguese, `pt-BR`) - v1.17](README.pt-br.md)
+- [português brasileiro (Brazilian Portuguese, `pt-BR`) - v1.12.1](README.pt-br.md)
- [Español (Spanish, `sp`) - v1.17](README.sp.md)
+- [简体中文 (Simplified Chinese, `zh-Hans`) - v1.16](README.zh-Hans.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.17](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
 - [Turkish (Turkish, `tr`) - v1.18](README.tr.md)
 Only this README file is guaranteed to be up-to-date.
--- a/README.pt-br.md
+++ b/README.pt-br.md
@@ -1,16 +1,16 @@
-_Apenas o [README](README.md) original é garantido estar atualizado._
+_Only the original [README](README.md) is guaranteed to be up-to-date._
-# scrcpy (v1.17)
+# scrcpy (v1.12.1)
-Esta aplicação fornece exibição e controle de dispositivos Android conectados via
+Esta aplicação fornece visualização e controle de dispositivos Android conectados via
-USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso _root_.
+USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso root.
 Funciona em _GNU/Linux_, _Windows_ e _macOS_.
 ![screenshot](assets/screenshot-debian-600.jpg)
 Foco em:
- - **leveza** (nativo, mostra apenas a tela do dispositivo)
+ - **leveza** (Nativo, mostra apenas a tela do dispositivo)
 - **performance** (30~60fps)
 - **qualidade** (1920×1080 ou acima)
 - **baixa latência** ([35~70ms][lowlatency])
@@ -22,41 +22,36 @@ Foco em:
 ## Requisitos
-O dispositivo Android requer pelo menos a API 21 (Android 5.0).
+O Dispositivo Android requer pelo menos a API 21 (Android 5.0).
-Tenha certeza de ter [ativado a depuração adb][enable-adb] no(s) seu(s) dispositivo(s).
+
 Tenha certeza de ter [ativado a depuração USB][enable-adb] no(s) seu(s) dispositivo(s).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-Em alguns dispositivos, você também precisa ativar [uma opção adicional][control] para
+
-controlá-lo usando teclado e mouse.
+Em alguns dispositivos, você também precisará ativar [uma opção adicional][control] para controlá-lo usando o teclado e mouse.
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-## Obter o app
+## Obtendo o 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>
 ### Linux
-No Debian (_testing_ e _sid_ por enquanto) e Ubuntu (20.04):
+No Debian (_em testes_ e _sid_ por enquanto):
 ```
 apt install scrcpy
 ```
-Um pacote [Snap] está disponível: [`scrcpy`][snap-link].
+O pacote [Snap] está disponível: [`scrcpy`][snap-link].
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
 Para Fedora, um pacote [COPR] está disponível: [`scrcpy`][copr-link].
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 Para Arch Linux, um pacote [AUR] está disponível: [`scrcpy`][aur-link].
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
@@ -67,19 +62,21 @@ Para Gentoo, uma [Ebuild] está disponível: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 Você também pode [compilar o app manualmente][BUILD] (não se preocupe, não é tão
 difícil).
 Você também pode [compilar a aplicação manualmente][BUILD] (não se preocupe, não é tão difícil).
 ### Windows
-Para Windows, por simplicidade, um arquivo pré-compilado com todas as dependências
+Para Windows, para simplicidade, um arquivo pré-compilado com todas as dependências
 (incluindo `adb`) está disponível:
- - [README](README.md#windows)
+ - [`scrcpy-win64-v1.12.1.zip`][direct-win64]  
   _(SHA-256: 57d34b6d16cfd9fe169bc37c4df58ebd256d05c1ea3febc63d9cb0a027ab47c9)_
-Também está disponível em [Chocolatey]:
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win64-v1.12.1.zip
 Também disponível em [Chocolatey]:
 [Chocolatey]: https://chocolatey.org/
@@ -97,12 +94,12 @@ scoop install adb    # se você ainda não o tem
 [Scoop]: https://scoop.sh
-Você também pode [compilar o app manualmente][BUILD].
+Você também pode [compilar a aplicação manualmente][BUILD].
 ### macOS
-A aplicação está disponível em [Homebrew]. Apenas instale-a:
+A aplicação está disponível em [Homebrew]. Apenas a instale:
 [Homebrew]: https://brew.sh/
@@ -110,22 +107,18 @@ A aplicação está disponível em [Homebrew]. Apenas instale-a:
 brew install scrcpy
 ```
-Você precisa do `adb`, acessível pelo seu `PATH`. Se você ainda não o tem:
+Você precisa do `adb`, acessível através do seu `PATH`. Se você ainda não o tem:
 ```bash
 # Homebrew >= 2.6.0
 brew install --cask android-platform-tools
 # Homebrew < 2.6.0
 brew cask install android-platform-tools
 ```
-Você também pode [compilar o app manualmente][BUILD].
+Você também pode [compilar a aplicação manualmente][BUILD].
 ## Executar
-Conecte um dispositivo Android e execute:
+Plugue um dispositivo Android e execute:
 ```bash
 scrcpy
@@ -141,87 +134,52 @@ scrcpy --help
 ### Configuração de captura
-#### Reduzir tamanho
+#### Redução de tamanho
 Algumas vezes, é útil espelhar um dispositivo Android em uma resolução menor para
-aumentar a performance.
+aumentar performance.
-Para limitar ambos (largura e altura) para algum valor (ex: 1024):
+Para limitar ambos(largura e altura) para algum valor (ex: 1024):
 ```bash
 scrcpy --max-size 1024
-scrcpy -m 1024  # versão curta
+scrcpy -m 1024  # versão reduzida
 ```
 A outra dimensão é calculada para que a proporção do dispositivo seja preservada.
-Dessa forma, um dispositivo de 1920x1080 será espelhado em 1024x576.
+Dessa forma, um dispositivo em 1920x1080 será espelhado em 1024x576.
-#### Mudar bit-rate
+#### Mudanças no bit-rate
-O bit-rate padrão é 8 Mbps. Para mudar o bit-rate do vídeo (ex: para 2 Mbps):
+O Padrão de bit-rate é 8 mbps. Para mudar o bitrate do vídeo (ex: para 2 Mbps):
 ```bash
 scrcpy --bit-rate 2M
-scrcpy -b 2M  # versão curta
+scrcpy -b 2M  # versão reduzida
 ```
-#### Limitar frame rate
+#### Limitar frame rates
-O frame rate de captura pode ser limitado:
+Em dispositivos com Android >= 10, a captura de frame rate pode ser limitada:
 ```bash
 scrcpy --max-fps 15
 ```
 Isso é oficialmente suportado desde o Android 10, mas pode funcionar em versões anteriores.
 #### Cortar
 A tela do dispositivo pode ser cortada para espelhar apenas uma parte da tela.
-Isso é útil por exemplo, para espelhar apenas um olho do Oculus Go:
+Isso é útil por exemplo, ao espelhar apenas um olho do Oculus Go:
 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 no deslocamento (0,0)
 ```
-Se `--max-size` também for especificado, o redimensionamento é aplicado após o corte.
+Se `--max-size` também for especificado, redimensionar é aplicado após os cortes.
 #### Travar orientação do vídeo
 Para travar a orientação do espelhamento:
 ```bash
 scrcpy --lock-video-orientation 0   # orientação natural
 scrcpy --lock-video-orientation 1   # 90° sentido anti-horário
 scrcpy --lock-video-orientation 2   # 180°
 scrcpy --lock-video-orientation 3   # 90° sentido horário
 ```
 Isso afeta a orientação de gravação.
 A [janela também pode ser rotacionada](#rotação) independentemente.
 #### Encoder
 Alguns dispositivos têm mais de um encoder, e alguns deles podem causar problemas ou
 travar. É possível selecionar um encoder diferente:
 ```bash
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```
 Para listar os encoders disponíveis, você pode passar um nome de encoder inválido, o
 erro dará os encoders disponíveis:
 ```bash
 scrcpy --encoder _
 ```
 ### Gravando
 É possível gravar a tela enquanto ocorre o espelhamento:
@@ -236,84 +194,65 @@ Para desativar o espelhamento durante a gravação:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
-# interrompa a gravação com Ctrl+C
+# interrompe a gravação com Ctrl+C
 # Ctrl+C não encerrar propriamente no Windows, então desconecte o dispositivo
 ```
-"Frames pulados" são gravados, mesmo que não sejam exibidos em tempo real (por
+"Frames pulados" são gravados, mesmo que não sejam mostrado em tempo real (por motivos de performance).
-motivos de performance). Frames têm seu _horário carimbado_ no dispositivo, então [variação de atraso nos
+Frames tem seu _horário_ _carimbado_ no dispositivo, então [Variação de atraso nos pacotes] não impacta na gravação do arquivo.
 pacotes][packet delay variation] não impacta o arquivo gravado.
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
+[Variação de atraso de pacote]: https://en.wikipedia.org/wiki/Packet_delay_variation
 ### Conexão
-#### Sem fio
+#### Wireless/Sem fio
-_Scrcpy_ usa `adb` para se comunicar com o dispositivo, e `adb` pode [conectar-se][connect] a um
+_Scrcpy_ usa `adb` para se comunicar com o dispositivo, e `adb` pode [conectar-se] à um dispositivo via TCP/IP:
 dispositivo via TCP/IP:
 1. Conecte o dispositivo no mesmo Wi-Fi do seu computador.
 2. Pegue o endereço IP do seu dispositivo, em Configurações → Sobre o telefone → Status, ou
   executando este comando:
    ```bash
    adb shell ip route | awk '{print $9}'
    ```
 1. Conecte o dispositivo a mesma rede Wi-Fi do seu computador.
 2. Pegue o endereço de IP do seu dispositivo (Em Configurações → Sobre o Telefone → Status).
 3. Ative o adb via TCP/IP no seu dispositivo: `adb tcpip 5555`.
-4. Desconecte seu dispositivo.
+4. Desplugue seu dispositivo.
-5. Conecte-se ao seu dispositivo: `adb connect DEVICE_IP:5555` _(substitua `DEVICE_IP`)_.
+5. Conecte-se ao seu dispositivo: `adb connect DEVICE_IP:5555` _(substitua o `DEVICE_IP`)_.
 6. Execute `scrcpy` como de costume.
 Pode ser útil diminuir o bit-rate e a resolução:
 ```bash
 scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # versão curta
+scrcpy -b2M -m800  # versão reduzida
 ```
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
+[conectar-se]: https://developer.android.com/studio/command-line/adb.html#wireless
-#### Múltiplos dispositivos
+#### N-dispositivos
-Se vários dispositivos são listados em `adb devices`, você deve especificar o _serial_:
+Se alguns dispositivos estão listados em `adb devices`, você precisa especificar o _serial_:
 ```bash
 scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # versão curta
+scrcpy -s 0123456789abcdef  # versão reduzida
 ```
 Se o dispositivo está conectado via TCP/IP:
 ```bash
 scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # versão curta
+scrcpy -s 192.168.0.1:5555  # versão reduzida
 ```
-Você pode iniciar várias instâncias do _scrcpy_ para vários dispositivos.
+Você pode iniciar algumas instâncias do _scrcpy_ para alguns dispositivos.
-#### Iniciar automaticamente quando dispositivo é conectado
+#### Conexão via SSH
-Você pode usar [AutoAdb]:
+Para conectar-se à um dispositivo remoto, é possível se conectar um cliente local `adb`  à um servidor `adb` remoto (contanto que eles usem a mesma versão do protocolo _adb_):
 ```bash
-autoadb scrcpy -s '{}'
+adb kill-server    # encerra o servidor local na 5037
 ```
 [AutoAdb]: https://github.com/rom1v/autoadb
 #### Túnel SSH
 Para conectar-se a um dispositivo remoto, é possível conectar um cliente `adb` local a
 um servidor `adb` remoto (contanto que eles usem a mesma versão do protocolo
 _adb_):
 ```bash
 adb kill-server    # encerra o servidor adb local em 5037
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# mantenha isso aberto
+# mantém isso aberto
 ```
 De outro terminal:
@@ -322,33 +261,17 @@ De outro terminal:
 scrcpy
 ```
-Para evitar ativar o encaminhamento de porta remota, você pode forçar uma conexão
+Igual para conexões sem fio, pode ser útil reduzir a qualidade:
 de encaminhamento (note o `-L` em vez de `-R`):
 ```bash
 adb kill-server    # encerra o servidor adb local em 5037
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # mantenha isso aberto
 ```
 De outro terminal:
 ```bash
 scrcpy --force-adb-forward
 ```
 Igual a conexões sem fio, pode ser útil reduzir a qualidade:
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
-### Configuração de janela
+### Configurações de Janela
 #### Título
-Por padrão, o título da janela é o modelo do dispositivo. Isso pode ser mudado:
+Por padrão, o título da janela é o modelo do dispositivo. Isto pode ser mudado:
 ```bash
 scrcpy --window-title 'Meu dispositivo'
@@ -364,15 +287,15 @@ scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 #### Sem bordas
-Para desativar decorações de janela:
+Para desativar decorações da janela:
 ```bash
 scrcpy --window-borderless
 ```
-#### Sempre no topo
+#### Sempre visível
-Para manter a janela do scrcpy sempre no topo:
+Para manter a janela do scrcpy sempre visível:
 ```bash
 scrcpy --always-on-top
@@ -384,117 +307,41 @@ A aplicação pode ser iniciada diretamente em tela cheia:
 ```bash
 scrcpy --fullscreen
-scrcpy -f  # versão curta
+scrcpy -f  # versão reduzida
 ```
-Tela cheia pode ser alternada dinamicamente com <kbd>MOD</kbd>+<kbd>f</kbd>.
+Tela cheia pode ser alternada dinamicamente com `Ctrl`+`f`.
 #### Rotação
 A janela pode ser rotacionada:
 ```bash
 scrcpy --rotation 1
 ```
 Valores possíveis são:
 - `0`: sem rotação
 - `1`: 90 graus sentido anti-horário
 - `2`: 180 graus
 - `3`: 90 graus sentido horário
 A rotação também pode ser mudada dinamicamente com <kbd>MOD</kbd>+<kbd>←</kbd>
 _(esquerda)_ e <kbd>MOD</kbd>+<kbd>→</kbd> _(direita)_.
 Note que _scrcpy_ controla 3 rotações diferentes:
 - <kbd>MOD</kbd>+<kbd>r</kbd> requisita ao dispositivo para mudar entre retrato
   e paisagem (a aplicação em execução pode se recusar, se ela não suporta a
   orientação requisitada).
 - [`--lock-video-orientation`](#travar-orientação-do-vídeo) muda a orientação de
   espelhamento (a orientação do vídeo enviado pelo dispositivo para o
   computador). Isso afeta a gravação.
 - `--rotation` (ou <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
   rotaciona apenas o conteúdo da janela. Isso afeta apenas a exibição, não a
   gravação.
 ### Outras opções de espelhamento
 #### Apenas leitura
-Para desativar controles (tudo que possa interagir com o dispositivo: teclas de entrada,
+Para desativar controles (tudo que possa interagir com o dispositivo: teclas de entrada, eventos de mouse, arrastar e soltar arquivos):
 eventos de mouse, arrastar e soltar arquivos):
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
-#### Display
+#### Desligar a tela
-Se vários displays estão disponíveis, é possível selecionar o display para
+É possível desligar a tela do dispositivo durante o início do espelhamento com uma opção de linha de comando:
 espelhar:
 ```bash
 scrcpy --display 1
 ```
 A lista de IDs dos displays pode ser obtida por:
 ```
 adb shell dumpsys display   # busca "mDisplayId=" na saída
 ```
 O display secundário pode apenas ser controlado se o dispositivo roda pelo menos Android
 10 (caso contrário é espelhado como apenas leitura).
 #### Permanecer ativo
 Para evitar que o dispositivo seja suspenso após um delay quando o dispositivo é conectado:
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
 O estado inicial é restaurado quando o scrcpy é fechado.
 #### Desligar tela
 É possível desligar a tela do dispositivo durante o início do espelhamento com uma
 opção de linha de comando:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
-Ou apertando <kbd>MOD</kbd>+<kbd>o</kbd> a qualquer momento.
+Ou apertando `Ctrl`+`o` durante qualquer momento.
-Para ligar novamente, pressione <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
+Para ligar novamente, pressione `POWER` (ou `Ctrl`+`p`).
-No Android, o botão de `POWER` sempre liga a tela. Por conveniência, se
+#### Frames expirados de renderização
 `POWER` é enviado via scrcpy (via clique-direito ou <kbd>MOD</kbd>+<kbd>p</kbd>), ele
 forçará a desligar a tela após um delay pequeno (numa base de melhor esforço).
 O botão `POWER` físico ainda causará a tela ser ligada.
-Também pode ser útil evitar que o dispositivo seja suspenso:
+Por padrão, para minimizar a latência, _scrcpy_ sempre renderiza o último frame decodificado disponível e descarta o anterior.
-```bash
+Para forçar a renderização de todos os frames ( com o custo de aumento de latência), use:
 scrcpy --turn-screen-off --stay-awake
 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
@@ -502,13 +349,11 @@ scrcpy --render-expired-frames
 #### Mostrar toques
-Para apresentações, pode ser útil mostrar toques físicos (no dispositivo
+Para apresentações, pode ser útil mostrar toques físicos(dispositivo físico).
 físico).
-Android fornece esta funcionalidade nas _Opções do desenvolvedor_.
+Android fornece esta funcionalidade nas _Opções do Desenvolvedor_.
-_Scrcpy_ fornece esta opção de ativar esta funcionalidade no início e restaurar o
+_Scrcpy_ fornece esta opção de ativar esta funcionalidade no início e desativar no encerramento:
 valor inicial no encerramento:
 ```bash
 scrcpy --show-touches
@@ -518,137 +363,59 @@ scrcpy -t
 Note que isto mostra apenas toques _físicos_ (com o dedo no dispositivo).
 #### Desativar descanso de tela
 Por padrão, scrcpy não evita que o descanso de tela rode no computador.
 Para desativá-lo:
 ```bash
 scrcpy --disable-screensaver
 ```
 ### Controle de entrada
 #### Rotacionar a tela do dispositivo
-Pressione <kbd>MOD</kbd>+<kbd>r</kbd> para mudar entre os modos retrato e
+Pressione `Ctrl`+`r` para mudar entre os modos Retrato e Paisagem.
 paisagem.
-Note que só será rotacionado se a aplicação em primeiro plano suportar a
+Note que só será rotacionado se a aplicação em primeiro plano tiver suporte para o modo requisitado.
 orientação requisitada.
-#### Copiar-colar
+#### Copiar-Colar
-Sempre que a área de transferência do Android muda, é automaticamente sincronizada com a
+É possível sincronizar áreas de transferência entre computador e o dispositivo,
-área de transferência do computador.
+para ambas direções:
-Qualquer atalho com <kbd>Ctrl</kbd> é encaminhado para o dispositivo. Em particular:
+ - `Ctrl`+`c` copia a área de transferência do dispositivo para a área de trasferência do computador;
- - <kbd>Ctrl</kbd>+<kbd>c</kbd> tipicamente copia
+ - `Ctrl`+`Shift`+`v` copia a área de transferência do computador para a área de transferência do dispositivo;
- - <kbd>Ctrl</kbd>+<kbd>x</kbd> tipicamente recorta
+ - `Ctrl`+`v` _cola_ a área de transferência do computador como uma sequência de eventos de texto (mas
- - <kbd>Ctrl</kbd>+<kbd>v</kbd> tipicamente cola (após a sincronização de área de transferência
+   quebra caracteres não-ASCII).
   computador-para-dispositivo)
-Isso tipicamente funciona como esperado.
+#### Preferências de injeção de texto
-O comportamento de fato depende da aplicação ativa, no entanto. Por exemplo,
+Existe dois tipos de [eventos][textevents] gerados ao digitar um texto:
-_Termux_ envia SIGINT com <kbd>Ctrl</kbd>+<kbd>c</kbd>, e _K-9 Mail_
+ - _eventos de teclas_, sinalizando que a tecla foi pressionada ou solta;
 compõe uma nova mensagem.
 Para copiar, recortar e colar em tais casos (mas apenas suportado no Android >= 7):
 - <kbd>MOD</kbd>+<kbd>c</kbd> injeta `COPY`
 - <kbd>MOD</kbd>+<kbd>x</kbd> injeta `CUT`
 - <kbd>MOD</kbd>+<kbd>v</kbd> injeta `PASTE` (após a sincronização de área de transferência
   computador-para-dispositivo)
 Em adição, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permite injetar o
 texto da área de transferência do computador como uma sequência de eventos de tecla. Isso é útil quando o
 componente não aceita colar texto (por exemplo no _Termux_), mas pode
 quebrar conteúdo não-ASCII.
 **ADVERTÊNCIA:** Colar a área de transferência do computador para o dispositivo (tanto via
 <kbd>Ctrl</kbd>+<kbd>v</kbd> quanto <kbd>MOD</kbd>+<kbd>v</kbd>) copia o conteúdo
 para a área de transferência do dispositivo. Como consequência, qualquer aplicação Android pode ler
 o seu conteúdo. Você deve evitar colar conteúdo sensível (como senhas) dessa
 forma.
 Alguns dispositivos não se comportam como esperado quando a área de transferência é definida
 programaticamente. Uma opção `--legacy-paste` é fornecida para mudar o comportamento
 de <kbd>Ctrl</kbd>+<kbd>v</kbd> e <kbd>MOD</kbd>+<kbd>v</kbd> para que eles
 também injetem o texto da área de transferência do computador como uma sequência de eventos de tecla (da mesma
 forma que <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
 #### Pinçar para dar zoom
 Para simular "pinçar para dar zoom": <kbd>Ctrl</kbd>+_clicar-e-mover_.
 Mais precisamente, segure <kbd>Ctrl</kbd> enquanto pressiona o botão de clique-esquerdo. Até que
 o botão de clique-esquerdo seja liberado, todos os movimentos do mouse ampliar e rotacionam o
 conteúdo (se suportado pelo app) relativo ao centro da tela.
 Concretamente, scrcpy gera eventos adicionais de toque de um "dedo virtual" em
 uma posição invertida em relação ao centro da tela.
 #### Preferência de injeção de texto
 Existem dois tipos de [eventos][textevents] gerados ao digitar um texto:
 - _eventos de tecla_, sinalizando que a tecla foi pressionada ou solta;
 - _eventos de texto_, sinalizando que o texto foi inserido.
-Por padrão, letras são injetadas usando eventos de tecla, assim o teclado comporta-se
+Por padrão, letras são injetadas usando eventos de teclas, assim teclados comportam-se
-como esperado em jogos (normalmente para teclas WASD).
+como esperado em jogos (normalmente para tecladas WASD)
-Mas isso pode [causar problemas][prefertext]. Se você encontrar tal problema, você
+Mas isto pode [causar problemas][prefertext]. Se você encontrar tal problema,
-pode evitá-lo com:
+pode evitá-lo usando:
 ```bash
 scrcpy --prefer-text
 ```
-(mas isso vai quebrar o comportamento do teclado em jogos)
+(mas isto vai quebrar o comportamento do teclado em jogos)
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-#### Repetir tecla
+### Transferência de arquivo
 Por padrão, segurar uma tecla gera eventos de tecla repetidos. Isso pode causar
 problemas de performance em alguns jogos, onde esses eventos são inúteis de qualquer forma.
 Para evitar o encaminhamento eventos de tecla repetidos:
 ```bash
 scrcpy --no-key-repeat
 ```
 #### Clique-direito e clique-do-meio
 Por padrão, clique-direito dispara BACK (ou POWER) e clique-do-meio dispara
 HOME. Para desabilitar esses atalhos e encaminhar os cliques para o dispositivo:
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### Soltar arquivo
 #### Instalar APK
-Para instalar um APK, arraste e solte o arquivo APK (com extensão `.apk`) na janela
+Para instalar um APK, arraste e solte o arquivo APK(com extensão `.apk`) na janela _scrcpy_.
 _scrcpy_.
 Não existe feedback visual, um log é imprimido no console.
-#### Enviar arquivo para dispositivo
+#### Enviar arquivo para o dispositivo
-Para enviar um arquivo para `/sdcard/` no dispositivo, arraste e solte um arquivo (não-APK) para a
+Para enviar um arquivo para o diretório `/sdcard/` no dispositivo, arraste e solte um arquivo não APK para a janela do
-janela do _scrcpy_.
+_scrcpy_.
 Não existe feedback visual, um log é imprimido no console.
@@ -661,73 +428,45 @@ scrcpy --push-target /sdcard/foo/bar/
 ### Encaminhamento de áudio
-Áudio não é encaminhado pelo _scrcpy_. Use [sndcpy].
+Áudio não é encaminhando pelo _scrcpy_. Use [USBaudio] (Apenas linux).
 Também veja [issue #14].
-[sndcpy]: https://github.com/rom1v/sndcpy
+[USBaudio]: https://github.com/rom1v/usbaudio
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## Atalhos
-Na lista a seguir, <kbd>MOD</kbd> é o modificador de atalho. Por padrão, é
+ | Ação                                                          |   Atalho                        |   Atalho (macOS)
-<kbd>Alt</kbd> (esquerdo) ou <kbd>Super</kbd> (esquerdo).
+ | ------------------------------------------------------------- |:------------------------------- |:-----------------------------
-
+ | Alternar para modo de tela cheia                              | `Ctrl`+`f`                      | `Cmd`+`f`
-Ele pode ser mudado usando `--shortcut-mod`. Possíveis teclas são `lctrl`, `rctrl`,
+ | Redimensionar janela para pixel-perfect(Escala 1:1)           | `Ctrl`+`g`                      | `Cmd`+`g`
-`lalt`, `ralt`, `lsuper` e `rsuper`. Por exemplo:
+ | Redimensionar janela para tirar as bordas pretas              | `Ctrl`+`x` \| _Clique-duplo¹_   | `Cmd`+`x`  \| _Clique-duplo¹_
-
+ | Clicar em `HOME`                                              | `Ctrl`+`h` \| _Clique-central_  | `Ctrl`+`h` \| _Clique-central_
-```bash
+ | Clicar em `BACK`                                              | `Ctrl`+`b` \| _Clique-direito²_ | `Cmd`+`b`  \| _Clique-direito²_
-# usar RCtrl para atalhos
+ | Clicar em `APP_SWITCH`                                        | `Ctrl`+`s`                      | `Cmd`+`s`
-scrcpy --shortcut-mod=rctrl
+ | Clicar em `MENU`                                              | `Ctrl`+`m`                      | `Ctrl`+`m`
-
+ | Clicar em `VOLUME_UP`                                         | `Ctrl`+`↑` _(cima)_             | `Cmd`+`↑` _(cima)_
-# usar tanto LCtrl+LAlt quanto LSuper para atalhos
+ | Clicar em `VOLUME_DOWN`                                       | `Ctrl`+`↓` _(baixo)_            | `Cmd`+`↓` _(baixo)_
-scrcpy --shortcut-mod=lctrl+lalt,lsuper
+ | Clicar em `POWER`                                             | `Ctrl`+`p`                      | `Cmd`+`p`
-```
+ | Ligar                                                         | _Clique-direito²_               | _Clique-direito²_
-
+ | Desligar a tela do dispositivo                                | `Ctrl`+`o`                      | `Cmd`+`o`
-_<kbd>[Super]</kbd> é tipicamente a tecla <kbd>Windows</kbd> ou <kbd>Cmd</kbd>._
+ | Rotacionar tela do dispositivo                                | `Ctrl`+`r`                      | `Cmd`+`r`
-
+ | Expandir painel de notificação                                | `Ctrl`+`n`                      | `Cmd`+`n`
-[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
+ | Esconder painel de notificação                                | `Ctrl`+`Shift`+`n`              | `Cmd`+`Shift`+`n`
-
+ | Copiar área de transferência do dispositivo para o computador | `Ctrl`+`c`                      | `Cmd`+`c`
- | Ação                                        |   Atalho
+ | Colar área de transferência do computador para o dispositivo  | `Ctrl`+`v`                      | `Cmd`+`v`
- | ------------------------------------------- |:-----------------------------
+ | Copiar área de transferência do computador para dispositivo   | `Ctrl`+`Shift`+`v`              | `Cmd`+`Shift`+`v`
- | Mudar modo de tela cheia                    | <kbd>MOD</kbd>+<kbd>f</kbd>
+ | Ativar/desativar contador de FPS(Frames por segundo)          | `Ctrl`+`i`                      | `Cmd`+`i`
 | Rotacionar display para esquerda            | <kbd>MOD</kbd>+<kbd>←</kbd> _(esquerda)_
 | Rotacionar display para direita             | <kbd>MOD</kbd>+<kbd>→</kbd> _(direita)_
 | Redimensionar janela para 1:1 (pixel-perfect) | <kbd>MOD</kbd>+<kbd>g</kbd>
 | Redimensionar janela para remover bordas pretas | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Clique-duplo¹_
 | Clicar em `HOME`                            | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Clique-do-meio_
 | Clicar em `BACK`                            | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Clique-direito²_
 | Clicar em `APP_SWITCH`                      | <kbd>MOD</kbd>+<kbd>s</kbd>
 | Clicar em `MENU` (desbloquear tela          | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Clicar em `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>
 | Ligar                                       | _Clique-direito²_
 | Desligar tela do dispositivo (continuar espelhando) | <kbd>MOD</kbd>+<kbd>o</kbd>
 | Ligar tela do dispositivo                   | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Rotacionar tela do dispositivo              | <kbd>MOD</kbd>+<kbd>r</kbd>
 | Expandir painel de notificação              | <kbd>MOD</kbd>+<kbd>n</kbd>
 | Colapsar painel de notificação              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | Copiar para área de transferência³          | <kbd>MOD</kbd>+<kbd>c</kbd>
 | Recortar para área de transferência³        | <kbd>MOD</kbd>+<kbd>x</kbd>
 | Sincronizar áreas de transferência e colar³ | <kbd>MOD</kbd>+<kbd>v</kbd>
 | 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_
 _¹Clique-duplo em bordas pretas para removê-las._  
-_²Clique-direito liga a tela se ela estiver desligada, pressiona BACK caso contrário._
+_²Botão direito liga a tela se ela estiver desligada, clique BACK para o contrário._
 _³Apenas em Android >= 7._
 Todos os atalhos <kbd>Ctrl</kbd>+_tecla_ são encaminhados para o dispositivo, para que eles sejam
 tratados pela aplicação ativa.
 ## Caminhos personalizados
-Para usar um binário _adb_ específico, configure seu caminho na variável de ambiente
+Para usar um binário específico _adb_, configure seu caminho na variável de ambiente `ADB`:
 `ADB`:
    ADB=/caminho/para/adb scrcpy
@@ -739,7 +478,7 @@ Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em
 ## Por quê _scrcpy_?
-Um colega me desafiou a encontrar um nome tão impronunciável quanto [gnirehtet].
+Um colega me desafiou a encontrar um nome impronunciável como [gnirehtet].
 [`strcpy`] copia uma **str**ing; `scrcpy` copia uma **scr**een.
@@ -756,12 +495,12 @@ Veja [BUILD].
 ## Problemas comuns
-Veja o [FAQ](FAQ.md).
+Veja [FAQ](FAQ.md).
 ## Desenvolvedores
-Leia a [página dos desenvolvedores][developers page].
+Leia a  [developers page].
 [developers page]: DEVELOP.md
--- 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,108 +2,115 @@ _Only the original [README](README.md) is guaranteed to be up-to-date._
 只有原版的[README](README.md)会保持最新。
-本文根据[ed130e05]进行翻译。
+本文根据[479d10d]进行翻译。
-[ed130e05]: https://github.com/Genymobile/scrcpy/blob/ed130e05d55615d6014d93f15cfcb92ad62b01d8/README.md
+[479d10d]: https://github.com/Genymobile/scrcpy/commit/479d10dc22b70272187e0963c6ad24d754a669a2#diff-04c6e90faac2675aa89e2176d2eec7d8
 # scrcpy (v1.17)
-本应用程序可以显示并控制通过 USB (或 [TCP/IP][article-tcpip]) 连接的安卓设备，且不需要任何 _root_ 权限。本程序支持 _GNU/Linux_, _Windows_ 和 _macOS_。
+
 # scrcpy (v1.16)
 本应用程序可以通过USB（或 [TCP/IP][article-tcpip] ）连接用于显示或控制安卓设备。这不需要获取 _root_ 权限。
 该应用程序可以在 _GNU/Linux_, _Windows_ 和 _macOS_ 环境下运行。
 [article-tcpip]:https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
 ![screenshot](assets/screenshot-debian-600.jpg)
 它专注于：
- - **轻量** (原生，仅显示设备屏幕)
+ - **轻量** （原生，仅显示设备屏幕）
- - **性能** (30~60fps)
+ - **性能** （30~60fps）
- - **质量** (分辨率可达 1920×1080 或更高)
+ - **质量** （分辨率可达1920x1080或更高）
- - **低延迟** ([35~70ms][lowlatency])
+ - **低延迟** (35-70ms)
- - **快速启动** (最快 1 秒内即可显示第一帧)
+ - **快速启动** （数秒内即能开始显示）
- - **无侵入性** (不会在设备上遗留任何程序)
+ - **无侵入性** （不需要在安卓设备上安装任何程序）
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-## 系统要求
+## 使用要求
-安卓设备最低需要支持 API 21 (Android 5.0)。
+安卓设备系统版本需要在Android 5.0（API 21)或以上。
-确保设备已[开启 adb 调试][enable-adb]。
+确保您在设备上开启了[adb调试]。
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
+[adb调试]: https://developer.android.com/studio/command-line/adb.html#Enabling
-在某些设备上，还需要开启[额外的选项][control]以使用鼠标和键盘进行控制。
+在某些设备上，你还需要开启[额外的选项]以用鼠标和键盘进行控制。
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
+[额外的选项]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-## 获取本程序
+## 获取scrcpy
 <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
-在 Debian (目前仅支持 _testing_ 和 _sid_ 分支) 和Ubuntu (20.04) 上：
+在Debian（目前仅测试版和不稳定版，即 _testing_ 和 _sid_ 版本）和Ubuntu （20.04）上：
 ```
 apt install scrcpy
 ```
-我们也提供 [Snap] 包： [`scrcpy`][snap-link]。
+[Snap]包也是可用的： [`scrcpy`][snap-link].
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
-对 Fedora 我们提供 [COPR] 包： [`scrcpy`][copr-link]。
+对于Fedora用户，我们提供[COPR]包： [`scrcpy`][copr-link].
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
-对 Arch Linux 我们提供 [AUR] 包： [`scrcpy`][aur-link]。
+对于Arch Linux用户，我们提供[AUR]包： [`scrcpy`][aur-link].
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 [aur-link]: https://aur.archlinux.org/packages/scrcpy/
-对 Gentoo 我们提供 [Ebuild] 包：[`scrcpy/`][ebuild-link]。
+对于Gentoo用户，我们提供[Ebuild]包：[`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-您也可以[自行构建][BUILD] (不必担心，这并不困难)。
+您也可以[自行编译][编译](不必担心，这并不困难)。
 ### Windows
-在 Windows 上，简便起见，我们提供包含了所有依赖 (包括 `adb`) 的预编译包。
+在Windows上，简便起见，我们准备了包含所有依赖项（包括adb）的程序包。
- - [README](README.md#windows)
+ - [`scrcpy-win64-v1.16.zip`][direct-win64]  
   _(SHA-256: 3f30dc5db1a2f95c2b40a0f5de91ec1642d9f53799250a8c529bc882bc0918f0)_
-也可以使用 [Chocolatey]：
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.16/scrcpy-win64-v1.16.zip
 您也可以在[Chocolatey]下载：
 [Chocolatey]: https://chocolatey.org/
 ```bash
 choco install scrcpy
-choco install adb    # 如果还没有 adb
+choco install adb    # 如果你没有adb
 ```
-或者 [Scoop]:
+也可以使用 [Scoop]:
 ```bash
 scoop install scrcpy
-scoop install adb    # 如果还没有 adb
+scoop install adb    # 如果你没有adb
 ```
 [Scoop]: https://scoop.sh
-您也可以[自行构建][BUILD]。
+您也可以[自行编译][编译]。
 ### macOS
-本程序已发布到 [Homebrew]。直接安装即可：
+您可以使用[Homebrew]下载scrcpy。直接安装就可以了：
 [Homebrew]: https://brew.sh/
@@ -111,28 +118,24 @@ scoop install adb    # 如果还没有 adb
 brew install scrcpy
 ```
-你还需要在 `PATH` 内有 `adb`。如果还没有：
+您需要 `adb`以使用scrcpy，并且它需要可以通过 `PATH`被访问。如果您没有：
 ```bash
 # Homebrew >= 2.6.0
 brew install --cask android-platform-tools
 # Homebrew < 2.6.0
 brew cask install android-platform-tools
 ```
-您也可以[自行构建][BUILD]。
+您也可以[自行编译][编译]。
-## 运行
+## 运行scrcpy
-连接安卓设备，然后执行：
+用USB链接电脑和安卓设备，并执行：
 ```bash
 scrcpy
 ```
-本程序支持命令行参数，查看参数列表：
+支持带命令行参数执行，查看参数列表：
 ```bash
 scrcpy --help
@@ -140,129 +143,111 @@ scrcpy --help
 ## 功能介绍
-### 捕获设置
+### 画面设置
-#### 降低分辨率
+#### 缩小分辨率
-有时候，可以通过降低镜像的分辨率来提高性能。
+有时候，将设备屏幕镜像分辨率降低可以有效地提升性能。
-要同时限制宽度和高度到某个值 (例如 1024)：
+我们可以将高度和宽度都限制在一定大小内（如 1024）：
 ```bash
 scrcpy --max-size 1024
-scrcpy -m 1024  # 简写
+scrcpy -m 1024  # short version
 ```
-另一边会被按比例缩小以保持设备的显示比例。这样，1920×1080 分辨率的设备会以 1024×576 的分辨率进行镜像。
+较短的一边会被按比例缩小以保持设备的显示比例。
 这样，1920x1080 的设备会以 1024x576 的分辨率显示。
-#### 修改码率
+#### 修改画面比特率
-默认码率是 8Mbps。要改变视频的码率 (例如改为 2Mbps)：
+默认的比特率是8Mbps。如果要改变画面的比特率 (比如说改成2Mbps)：
 ```bash
 scrcpy --bit-rate 2M
-scrcpy -b 2M  # 简写
+scrcpy -b 2M  # short version
 ```
-#### 限制帧率
+#### 限制画面帧率
-要限制捕获的帧率：
+画面的帧率可以通过下面的命令被限制：
 ```bash
 scrcpy --max-fps 15
 ```
-本功能从 Android 10 开始才被官方支持，但在一些旧版本中也能生效。
+这个功能仅在Android 10和以后的版本被Android官方支持，但也有可能在更早的版本可用。
 #### 画面裁剪
-可以对设备屏幕进行裁剪，只镜像屏幕的一部分。
+设备画面可在裁切后进行镜像，以显示部分屏幕。
-例如可以只镜像 Oculus Go 的一只眼睛。
+这项功能可以用于，例如，只显示Oculus Go的一只眼睛。
 ```bash
-scrcpy --crop 1224:1440:0:0   # 以 (0,0) 为原点的 1224x1440 像素
+scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
 ```
-如果同时指定了 `--max-size`，会先进行裁剪，再进行缩放。
+如果`--max-size`在同时被指定，分辨率的改变将在画面裁切后进行。
-#### 锁定屏幕方向
+#### 锁定屏幕朝向
-要锁定镜像画面的方向：
+可以使用如下命令锁定屏幕朝向：
 ```bash
-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 3   # 顺时针旋转 90°
+scrcpy --lock-video-orientation 3   # 90° 顺时针旋转
 ```
-只影响录制的方向。
+该设定影响录制。
 [窗口可以独立旋转](#旋转)。
 #### 编码器
 一些设备内置了多种编码器，但是有的编码器会导致问题或崩溃。可以手动选择其它编码器：
 ```bash
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```
 要列出可用的编码器，可以指定一个不存在的编码器名称，错误信息中会包含所有的编码器：
 ```bash
 scrcpy --encoder _
 ```
 ### 屏幕录制
-可以在镜像的同时录制视频：
+可以在屏幕镜像的同时录制视频：
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
-仅录制，不显示镜像：
+在不开启屏幕镜像的同时录制：
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
-# 按 Ctrl+C 停止录制
+# 按Ctrl+C以停止录制
 ```
-录制时会包含“被跳过的帧”，即使它们由于性能原因没有实时显示。设备会为每一帧打上 _时间戳_ ，所以 [包时延抖动][packet delay variation] 不会影响录制的文件。
+在显示中“被跳过的帧”会被录制，虽然它们由于性能原因没有实时显示。
 在传输中每一帧都有 _时间戳_ ，所以 [包时延变化] 并不影响录制的文件。
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
+[包时延变化]: https://en.wikipedia.org/wiki/Packet_delay_variation
-### 连接
+### 连接方式
 #### 无线
-_Scrcpy_ 使用 `adb` 与设备通信，并且 `adb` 支持通过 TCP/IP [连接]到设备:
+_Scrcpy_ 使用`adb`来与安卓设备连接。同时，`adb`能够通过TCP/IP[连接]到安卓设备:
-1. 将设备和电脑连接至同一 Wi-Fi。
+1. 将您的安卓设备和电脑连接至同一Wi-Fi。
-2. 打开 设置 → 关于手机 → 状态信息，获取设备的 IP 地址，也可以执行以下的命令：
+2. 获取安卓设备的IP地址（在设置-关于手机-状态信息）。
-    ```bash
+3. 打开安卓设备的网络adb功能`adb tcpip 5555`。
-    adb shell ip route | awk '{print $9}'
+4. 将您的设备与电脑断开连接。
-    ```
+5. 连接到您的设备：`adb connect DEVICE_IP:5555` _(用设备IP替换 `DEVICE_IP`)_.
 6. 运行`scrcpy`。
-3. 启用设备的网络 adb 功能 `adb tcpip 5555`。
+降低比特率和分辨率可能有助于性能：
 4. 断开设备的 USB 连接。
 5. 连接到您的设备：`adb connect DEVICE_IP:5555` _(将 `DEVICE_IP` 替换为设备 IP)_.
 6. 正常运行 `scrcpy`。
 可能需要降低码率和分辨率：
 ```bash
 scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # 简写
+scrcpy -b2M -m800  # short version
 ```
 [连接]: https://developer.android.com/studio/command-line/adb.html#wireless
@@ -270,18 +255,18 @@ scrcpy -b2M -m800  # 简写
 #### 多设备
-如果 `adb devices` 列出了多个设备，您必须指定设备的 _序列号_ ：
+如果多个设备在执行`adb devices`后被列出，您必须指定设备的 _序列号_ ：
 ```bash
 scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # 简写
+scrcpy -s 0123456789abcdef  # short version
 ```
-如果设备通过 TCP/IP 连接：
+如果设备是通过TCP/IP方式连接到电脑的：
 ```bash
 scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # 简写
+scrcpy -s 192.168.0.1:5555  # short version
 ```
 您可以同时启动多个 _scrcpy_ 实例以同时显示多个设备的画面。
@@ -296,38 +281,38 @@ autoadb scrcpy -s '{}'
 [AutoAdb]: https://github.com/rom1v/autoadb
-#### SSH 隧道
+#### SSH 连接
-要远程连接到设备，可以将本地的 adb 客户端连接到远程的 adb 服务端 (需要两端的 _adb_ 协议版本相同)：
+本地的 adb 可以远程连接到另一个 adb 服务器（假设两者的adb版本相同），来远程连接到设备：
 ```bash
-adb kill-server    # 关闭本地 5037 端口上的 adb 服务端
+adb kill-server    # 关闭本地5037端口上的adb服务器
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # 保持该窗口开启
 ```
-在另一个终端：
+从另一个终端：
 ```bash
 scrcpy
 ```
-若要不使用远程端口转发，可以强制使用正向连接 (注意 `-L` 和 `-R` 的区别)：
+为了避免启动远程端口转发，你可以强制启动一个转发连接（注意`-L`和`-R`的区别：
 ```bash
-adb kill-server    # 关闭本地 5037 端口上的 adb 服务端
+adb kill-server    # kill the local adb server on 5037
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # 保持该窗口开启
 ```
-在另一个终端:
+从另一个终端:
 ```bash
 scrcpy --force-adb-forward
 ```
-类似无线网络连接，可能需要降低画面质量：
+和无线网络连接类似，下列设置可能对改善性能有帮助：
 ```
 scrcpy -b2M -m800 --max-fps 15
@@ -337,7 +322,7 @@ scrcpy -b2M -m800 --max-fps 15
 #### 标题
-窗口的标题默认为设备型号。可以通过如下命令修改：
+窗口的标题默认为设备型号。您可以通过如下命令修改它：
 ```bash
 scrcpy --window-title 'My device'
@@ -373,14 +358,14 @@ scrcpy --always-on-top
 ```bash
 scrcpy --fullscreen
-scrcpy -f  # 简写
+scrcpy -f  # short version
 ```
-全屏状态可以通过 <kbd>MOD</kbd>+<kbd>f</kbd> 随时切换。
+全屏状态可以通过<kbd>MOD</kbd>+<kbd>f</kbd>实时改变。
 #### 旋转
-可以通过以下命令旋转窗口：
+通过如下命令，窗口可以旋转：
 ```bash
 scrcpy --rotation 1
@@ -388,23 +373,27 @@ scrcpy --rotation 1
 可选的值有：
 - `0`: 无旋转
- - `1`: 逆时针旋转 90°
+ - `1`: 逆时针旋转90°
- - `2`: 旋转 180°
+ - `2`: 旋转180°
- - `3`: 顺时针旋转 90°
+ - `3`: 顺时针旋转90°
-也可以使用 <kbd>MOD</kbd>+<kbd>←</kbd> _(左箭头)_ 和 <kbd>MOD</kbd>+<kbd>→</kbd> _(右箭头)_ 随时更改。
+这同样可以使用<kbd>MOD</kbd>+<kbd>←</kbd>
 _(左)_ 和 <kbd>MOD</kbd>+<kbd>→</kbd> _(右)_ 的快捷键实时更改。
-需要注意的是， _scrcpy_ 有三个不同的方向：
+需要注意的是， _scrcpy_ 控制三个不同的朝向：
- - <kbd>MOD</kbd>+<kbd>r</kbd> 请求设备在竖屏和横屏之间切换 (如果前台应用程序不支持请求的朝向，可能会拒绝该请求)。
+ - <kbd>MOD</kbd>+<kbd>r</kbd> 请求设备在竖屏和横屏之间切换（如果前台应用程序不支持所请求的朝向，可能会拒绝该请求）。
- - [`--lock-video-orientation`](#锁定屏幕方向) 改变镜像的朝向 (设备传输到电脑的画面的朝向)。这会影响录制。
+
- - `--rotation` (或 <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) 只旋转窗口的内容。这只影响显示，不影响录制。
+ - `--lock-video-orientation` 改变镜像的朝向（设备镜像到电脑的画面朝向）。这会影响录制。
 - `--rotation` （或<kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>）
   只旋转窗口的画面。这只影响显示，不影响录制。
 ### 其他镜像设置
 #### 只读
-禁用电脑对设备的控制 (如键盘输入、鼠标事件和文件拖放)：
+关闭电脑对设备的控制（如键盘输入、鼠标移动和文件传输）：
 ```bash
 scrcpy --no-control
@@ -413,49 +402,53 @@ scrcpy -n
 #### 显示屏
-如果设备有多个显示屏，可以选择要镜像的显示屏：
+如果有多个显示屏可用，您可以选择特定显示屏进行镜像：
 ```bash
 scrcpy --display 1
 ```
-可以通过如下命令列出所有显示屏的 id：
+您可以通过如下命令找到显示屏的id：
 ```
-adb shell dumpsys display   # 在输出中搜索 “mDisplayId=”
+adb shell dumpsys display   # 在回显中搜索“mDisplayId=”
 ```
-控制第二显示屏需要设备运行 Android 10 或更高版本 (否则将在只读状态下镜像)。
+第二显示屏可能只能在设备运行Android 10或以上的情况下被控制（它可能会在电脑上显示，但无法通过电脑操作）。
 #### 保持常亮
-阻止设备在连接时休眠：
+防止设备在已连接的状态下休眠：
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
-程序关闭时会恢复设备原来的设置。
+程序关闭后，设备设置会恢复原样。
 #### 关闭设备屏幕
-可以通过以下的命令行参数在关闭设备屏幕的状态下进行镜像：
+在启动屏幕镜像时，可以通过如下命令关闭设备的屏幕：
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
-或者在任何时候按 <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>.
-在Android上，`电源` 按钮始终能把屏幕打开。为了方便，对于在 _scrcpy_ 中发出的 `电源` 事件 (通过鼠标右键或 <kbd>MOD</kbd>+<kbd>p</kbd>)，会 (尽最大的努力) 在短暂的延迟后将屏幕关闭。设备上的 `电源` 按钮仍然能打开设备屏幕。
+在Android上,`电源`按钮始终能把屏幕打开。
-还可以同时阻止设备休眠：
+为了方便，如果按下`电源`按钮的事件是通过 _scrcpy_ 发出的（通过点按鼠标右键或<kbd>MOD</kbd>+<kbd>p</kbd>），它会在短暂的延迟后将屏幕关闭。
 物理的`电源`按钮仍然能打开设备屏幕。
 同时，这项功能还能被用于防止设备休眠：
 ```bash
 scrcpy --turn-screen-off --stay-awake
@@ -463,11 +456,11 @@ scrcpy -Sw
 ```
-#### 渲染过期帧
+#### 渲染超时帧
-默认状态下，为了降低延迟， _scrcpy_ 永远渲染解码成功的最近一帧，并跳过前面任意帧。
+为了降低延迟， _scrcpy_ 默认渲染解码成功的最近一帧，并跳过前面任意帧。
-强制渲染所有帧 (可能导致延迟变高)：
+强制渲染所有帧（可能导致延迟变高）：
 ```bash
 scrcpy --render-expired-frames
@@ -475,9 +468,9 @@ scrcpy --render-expired-frames
 #### 显示触摸
-在演示时，可能会需要显示物理触摸点 (在物理设备上的触摸点)。
+在展示时，有些时候可能会用到显示触摸点这项功能（在设备上显示）。
-Android 在 _开发者选项_ 中提供了这项功能。
+Android在 _开发者设置_ 中提供了这项功能。
 _Scrcpy_ 提供一个选项可以在启动时开启这项功能并在退出时恢复初始设置：
@@ -486,12 +479,12 @@ scrcpy --show-touches
 scrcpy -t
 ```
-请注意这项功能只能显示 _物理_ 触摸 (用手指在屏幕上的触摸)。
+请注意这项功能只能显示 _物理_ 触摸（要用手在屏幕上触摸）。
 #### 关闭屏保
-_Scrcpy_ 默认不会阻止电脑上开启的屏幕保护。
+_Scrcpy_ 不会默认关闭屏幕保护。
 关闭屏幕保护：
@@ -504,58 +497,64 @@ scrcpy --disable-screensaver
 #### 旋转设备屏幕
-使用 <kbd>MOD</kbd>+<kbd>r</kbd> 在竖屏和横屏模式之间切换。
+使用<kbd>MOD</kbd>+<kbd>r</kbd>以在竖屏和横屏模式之间切换。
 需要注意的是，只有在前台应用程序支持所要求的模式时，才会进行切换。
-#### 复制粘贴
+#### 复制黏贴
-每次安卓的剪贴板变化时，其内容都会被自动同步到电脑的剪贴板上。
+每次Android的剪贴板变化的时候，它都会被自动同步到电脑的剪贴板上。
 所有的 <kbd>Ctrl</kbd> 快捷键都会被转发至设备。其中：
- - <kbd>Ctrl</kbd>+<kbd>c</kbd> 通常执行复制
+ - <kbd>Ctrl</kbd>+<kbd>c</kbd> 复制
- - <kbd>Ctrl</kbd>+<kbd>x</kbd> 通常执行剪切
+ - <kbd>Ctrl</kbd>+<kbd>x</kbd> 剪切
- - <kbd>Ctrl</kbd>+<kbd>v</kbd> 通常执行粘贴 (在电脑到设备的剪贴板同步完成之后)
+ - <kbd>Ctrl</kbd>+<kbd>v</kbd> 黏贴 （在电脑到设备的剪贴板同步完成之后）
-大多数时候这些按键都会执行以上的功能。
+这通常如您所期望的那样运作。
-但实际的行为取决于设备上的前台程序。例如，_Termux_ 会在按下 <kbd>Ctrl</kbd>+<kbd>c</kbd> 时发送 SIGINT，又如 _K-9 Mail_ 会新建一封邮件。
+但实际的行为取决于设备上的前台程序。
 例如 _Termux_ 在<kbd>Ctrl</kbd>+<kbd>c</kbd>被按下时发送 SIGINT，
 又如 _K-9 Mail_ 会新建一封新邮件。
-要在这种情况下进行剪切，复制和粘贴 (仅支持 Android >= 7)：
+在这种情况下剪切复制黏贴（仅在Android >= 7时可用）：
- - <kbd>MOD</kbd>+<kbd>c</kbd> 注入 `COPY` (复制)
+ - <kbd>MOD</kbd>+<kbd>c</kbd> 注入 `COPY`（复制）
- - <kbd>MOD</kbd>+<kbd>x</kbd> 注入 `CUT` (剪切)
+ - <kbd>MOD</kbd>+<kbd>x</kbd> 注入 `CUT`（剪切）
- - <kbd>MOD</kbd>+<kbd>v</kbd> 注入 `PASTE` (粘贴) (在电脑到设备的剪贴板同步完成之后)
+ - <kbd>MOD</kbd>+<kbd>v</kbd> 注入 `PASTE`（黏贴）（在电脑到设备的剪贴板同步完成之后）
-另外，<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> 会将电脑的剪贴板内容转换为一串按键事件输入到设备。在应用程序不接受粘贴时 (比如 _Termux_)，这项功能可以派上一定的用场。不过这项功能可能会导致非 ASCII 编码的内容出现错误。
+另外，<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>可以将电脑的剪贴板内容转换为一串按键事件输入到设备。
 在应用程序不接受黏贴时（比如 _Termux_ ），这项功能可以排上一定的用场。
 需要注意的是，这项功能可能会导致非ASCII编码的内容出现错误。
-**警告：** 将电脑剪贴板的内容粘贴至设备 (无论是通过 <kbd>Ctrl</kbd>+<kbd>v</kbd> 还是 <kbd>MOD</kbd>+<kbd>v</kbd>) 都会将内容复制到设备的剪贴板。如此，任何安卓应用程序都能读取到。您应避免将敏感内容 (如密码) 通过这种方式粘贴。
+**警告：** 将电脑剪贴板的内容黏贴至设备（无论是通过<kbd>Ctrl</kbd>+<kbd>v</kbd>还是<kbd>MOD</kbd>+<kbd>v</kbd>）
 都需要将内容保存至设备的剪贴板。如此，任何一个应用程序都可以读取它。
 您应当避免将敏感内容通过这种方式传输（如密码）。
 一些设备不支持通过程序设置剪贴板。通过 `--legacy-paste` 选项可以修改 <kbd>Ctrl</kbd>+<kbd>v</kbd> 和 <kbd>MOD</kbd>+<kbd>v</kbd> 的工作方式，使它们通过按键事件 (同 <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>) 来注入电脑剪贴板内容。
-#### 双指缩放
+#### 捏拉缩放
-模拟“双指缩放”：<kbd>Ctrl</kbd>+_按住并移动鼠标_。
+模拟 “捏拉缩放”：<kbd>Ctrl</kbd>+_按住并移动鼠标_。
-更准确的说，在按住鼠标左键时按住 <kbd>Ctrl</kbd>。直到松开鼠标左键，所有鼠标移动将以屏幕中心为原点，缩放或旋转内容 (如果应用支持)。
+更准确的说，您需要在按住<kbd>Ctrl</kbd>的同时按住并移动鼠标。
 在鼠标左键松开之后，光标的任何操作都会相对于屏幕的中央进行。
-实际上，_scrcpy_ 会在以屏幕中心对称的位置上生成由“虚拟手指”发出的额外触摸事件。
+具体来说， _scrcpy_ 使用“虚拟手指”以在相对于屏幕中央相反的位置产生触摸事件。
 #### 文字注入偏好
 打字的时候，系统会产生两种[事件][textevents]：
- - _按键事件_ ，代表一个按键被按下或松开。
+ - _按键事件_ ，代表一个按键被按下/松开。
- - _文本事件_ ，代表一个字符被输入。
+ - _文本事件_ ，代表一个文本被输入。
-程序默认使用按键事件来输入字母。只有这样，键盘才会在游戏中正常运作 (例如 WASD 键)。
+程序默认使用按键事件来输入字母。只有这样，键盘才会在游戏中正常运作（尤其WASD键）。
-但这也有可能[造成一些问题][prefertext]。如果您遇到了问题，可以通过以下方式避免：
+但这也有可能[造成问题][prefertext]。如果您遇到了这样的问题，您可以通过下列操作避免它：
 ```bash
 scrcpy --prefer-text
 ```
-(这会导致键盘在游戏中工作不正常)
+（这会导致键盘在游戏中工作不正常）
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
@@ -563,7 +562,8 @@ scrcpy --prefer-text
 #### 按键重复
-默认状态下，按住一个按键不放会生成多个重复按键事件。在某些游戏中这可能会导致性能问题。
+当你一直按着一个按键不放时，程序默认产生多个按键事件。
 在某些游戏中这可能会导致性能问题。
 避免转发重复按键事件：
@@ -572,27 +572,18 @@ scrcpy --no-key-repeat
 ```
-#### 右键和中键
+### 文件传输
 默认状态下，右键会触发返回键 (或电源键)，中键会触发 HOME 键。要禁用这些快捷键并把所有点击转发到设备：
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### 文件拖放
 #### 安装APK
-将 APK 文件 (文件名以 `.apk` 结尾) 拖放到 _scrcpy_ 窗口来安装。
+如果您要要安装APK，请拖放APK文件（文件名以`.apk`结尾）到 _scrcpy_ 窗口。
 该操作在屏幕上不会出现任何变化，而会在控制台输出一条日志。
 #### 将文件推送至设备
-要推送文件到设备的 `/sdcard/`，将 (非 APK) 文件拖放至 _scrcpy_ 窗口。
+如果您要推送文件到设备的 `/sdcard/`，请拖放文件至（不能是APK文件）_scrcpy_ 窗口。
 该操作没有可见的响应，只会在控制台输出日志。
@@ -605,7 +596,7 @@ scrcpy --push-target /sdcard/foo/bar/
 ### 音频转发
-_Scrcpy_ 不支持音频。请使用 [sndcpy].
+_scrcpy_ 不支持音频。请使用 [sndcpy].
 另外请阅读 [issue #14]。
@@ -613,90 +604,93 @@ _Scrcpy_ 不支持音频。请使用 [sndcpy].
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
-## 快捷键
+## 热键
-在以下列表中, <kbd>MOD</kbd> 是快捷键的修饰键。
+在下列表格中, <kbd>MOD</kbd> 是热键的修饰键。
-默认是 (左) <kbd>Alt</kbd> 或 (左) <kbd>Super</kbd>。
+默认是（左）<kbd>Alt</kbd>或者（左）<kbd>Super</kbd>。
-您可以使用 `--shortcut-mod` 来修改。可选的按键有 `lctrl`、`rctrl`、`lalt`、`ralt`、`lsuper` 和 `rsuper`。例如：
+您可以使用 `--shortcut-mod`后缀来修改它。可选的按键有`lctrl`、`rctrl`、
 `lalt`、`ralt`、`lsuper`和`rsuper`。如下例：
 ```bash
-# 使用右 Ctrl 键
+# 使用右侧的Ctrl键
 scrcpy --shortcut-mod=rctrl
-# 使用左 Ctrl 键 + 左 Alt 键，或 Super 键
+# 使用左侧的Ctrl键、Alt键或Super键
 scrcpy --shortcut-mod=lctrl+lalt,lsuper
 ```
-_<kbd>[Super]</kbd> 键通常是指 <kbd>Windows</kbd> 或 <kbd>Cmd</kbd> 键。_
+_一般来说，<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>                  |
+ | 点按 `切换应用`                              | <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> _(up)_
- | 点按 `音量-`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下箭头)_       |
+ | 点按 `音量-`                                | <kbd>MOD</kbd>+<kbd>↓</kbd> _(down)_
- | 点按 `电源`                       | <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>                  |
+ | 展开通知面板                                 | <kbd>MOD</kbd>+<kbd>n</kbd>
- | 收起通知面板                      | <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显示（在 stdout)                 | <kbd>MOD</kbd>+<kbd>i</kbd>
- | 捏拉缩放                          | <kbd>Ctrl</kbd>+_按住并移动鼠标_             |
+ | 捏拉缩放                                    | <kbd>Ctrl</kbd>+_点按并移动鼠标_
-_¹双击黑边可以去除黑边_
+_¹双击黑色边界以关闭黑色边界_  
-_²点击鼠标右键将在屏幕熄灭时点亮屏幕，其余情况则视为按下返回键 。_
+_²点击鼠标右键将在屏幕熄灭时点亮屏幕，其余情况则视为按下 返回键 。_  
 _³需要安卓版本 Android >= 7。_
-所有的 <kbd>Ctrl</kbd>+_按键_ 的快捷键都会被转发到设备，所以会由当前应用程序进行处理。
+所有的 <kbd>Ctrl</kbd>+_按键_ 的热键都是被转发到设备进行处理的，所以实际上会由当前应用程序对其做出响应。
 ## 自定义路径
-要使用指定的 _adb_ 二进制文件，可以设置环境变量 `ADB`：
+为了使用您想使用的 _adb_ ，您可以在环境变量
 `ADB`中设置它的路径：
    ADB=/path/to/adb scrcpy
-要覆盖 `scrcpy-server` 的路径，可以设置 `SCRCPY_SERVER_PATH`。
+如果需要覆盖`scrcpy-server`的路径，您可以在
 `SCRCPY_SERVER_PATH`中设置它。
 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## 为什么叫 _scrcpy_ ？
-一个同事让我找出一个和 [gnirehtet] 一样难以发音的名字。
+一个同事让我找出一个和[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
-## 如何构建？
+## 如何编译？
-请查看[BUILD]。
+请查看[编译]。
-[BUILD]: BUILD.md
+[编译]: BUILD.md
 ## 常见问题
-请查看[FAQ](FAQ.md)。
+请查看[FAQ](FAQ.md).
 ## 开发者
--- a/README.zh-Hant.md
+++ b/README.zh-Hant.md
@@ -80,7 +80,10 @@ apt install scrcpy
 為了保持簡單，Windows 用戶可以下載一個包含所有必需軟體 (包含 `adb`) 的壓縮包:
- - [README](README.md#windows)
+- [`scrcpy-win64-v1.15.zip`][direct-win64]  
   _(SHA-256: dd514bb591e63ef4cd52a53c30f1153a28f59722d64690eb07bd017849edcba2)_
 [direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.15/scrcpy-win64-v1.15.zip
 [Chocolatey] 上也可以下載:
--- a/app/meson.build
+++ b/app/meson.build
@@ -2,35 +2,29 @@ src = [
    'src/main.c',
    'src/adb.c',
    'src/cli.c',
    'src/clock.c',
    'src/compat.c',
    'src/control_msg.c',
    'src/controller.c',
    'src/decoder.c',
    'src/device.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/log.c',
    'src/util/net.c',
    'src/util/process.c',
    'src/util/strbuf.c',
    'src/util/str_util.c',
    'src/util/thread.c',
    'src/util/tick.c',
 ]
 if host_machine.system() == 'windows'
@@ -39,19 +33,6 @@ else
    src += [ 'src/sys/unix/process.c' ]
 endif
 v4l2_support = host_machine.system() == 'linux'
 if v4l2_support
    src += [ 'src/v4l2_sink.c' ]
 endif
 aoa_hid_support = host_machine.system() == 'linux'
 if aoa_hid_support
    src += [
        'src/aoa_hid.c',
        'src/hid_keyboard.c',
    ]
 endif
 check_functions = [
    'strdup'
 ]
@@ -68,15 +49,8 @@ if not get_option('crossbuild_windows')
        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'
@@ -150,12 +124,6 @@ conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
 # select the debugger method ('old' for Android < 9, 'new' for Android >= 9)
 conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == 'new')
 # 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')
@@ -167,9 +135,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
@@ -186,18 +151,11 @@ if get_option('buildtype') == 'debug'
        ['test_cli', [
            'tests/test_cli.c',
            'src/cli.c',
            'src/options.c',
            'src/util/strbuf.c',
            'src/util/str_util.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/strbuf.c',
            'src/util/str_util.c',
        ]],
        ['test_device_msg_deserialize', [
@@ -207,13 +165,8 @@ if get_option('buildtype') == 'debug'
        ['test_queue', [
            'tests/test_queue.c',
        ]],
        ['test_strbuf', [
            'tests/test_strbuf.c',
            'src/util/strbuf.c',
        ]],
        ['test_strutil', [
            'tests/test_strutil.c',
            'src/util/strbuf.c',
            'src/util/str_util.c',
        ]],
    ]
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -56,12 +56,6 @@ The list of possible display ids can be listed by "adb shell dumpsys display"
 Default is 0.
 .TP
 .BI "\-\-display\-buffer ms
 Add a buffering delay (in milliseconds) before displaying. This increases latency to compensate for jitter.
 Default is 0 (no buffering).
 .TP
 .BI "\-\-encoder " name
 Use a specific MediaCodec encoder (must be a H.264 encoder).
@@ -82,14 +76,6 @@ Start in fullscreen.
 .B \-h, \-\-help
 Print this help.
 .TP
 .B \-K, \-\-hid\-keyboard
 Simulate a physical keyboard by using HID over AOAv2.
 This provides a better experience for IME users, and allows to generate non-ASCII characters, contrary to the default injection method.
 It may only work over USB, and is currently only supported on Linux.
 .TP
 .B \-\-legacy\-paste
 Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+Shift+v).
@@ -97,12 +83,10 @@ 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 -1 (unlocked), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
-Default is "unlocked".
+Default is -1 (unlocked).
 Passing the option without argument is equivalent to passing "initial".
 .TP
 .BI "\-\-max\-fps " value
@@ -136,10 +120,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.
@@ -151,7 +131,7 @@ but breaks the expected behavior of alpha keys in games (typically WASD).
 .BI "\-\-push\-target " path
 Set the target directory for pushing files to the device by drag & drop. It is passed as\-is to "adb push".
-Default is "/sdcard/Download/".
+Default is "/sdcard/".
 .TP
 .BI "\-r, \-\-record " file
@@ -204,29 +184,15 @@ Enable "show touches" on start, restore the initial value on exit.
 It only shows physical touches (not clicks from scrcpy).
 .TP
-.BI "\-\-v4l2-sink " /dev/videoN
+.B \-v, \-\-version
-Output to v4l2loopback device.
+Print the version of scrcpy.
 It requires to lock the video orientation (see \fB\-\-lock\-video\-orientation\fR).
 .TP
 .BI "\-\-v4l2-buffer " ms
 Add a buffering delay (in milliseconds) before pushing frames. This increases latency to compensate for jitter.
 This option is similar to \fB\-\-display\-buffer\fR, but specific to V4L2 sink.
 Default is 0 (no buffering).
 .TP
 .BI "\-V, \-\-verbosity " value
-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.
 .TP
 .B \-v, \-\-version
 Print the version of scrcpy.
 .TP
 .B \-w, \-\-stay-awake
 Keep the device on while scrcpy is running, when the device is plugged in.
@@ -243,30 +209,30 @@ Set a custom window title.
 .BI "\-\-window\-x " value
 Set the initial window horizontal position.
-Default is "auto".
+Default is "auto".\n
 .TP
 .BI "\-\-window\-y " value
 Set the initial window vertical position.
-Default is "auto".
+Default is "auto".\n
 .TP
 .BI "\-\-window\-width " value
 Set the initial window width.
-Default is 0 (automatic).
+Default is 0 (automatic).\n
 .TP
 .BI "\-\-window\-height " value
 Set the initial window height.
-Default is 0 (automatic).
+Default is 0 (automatic).\n
 .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
@@ -368,10 +334,6 @@ Pinch-to-zoom from the center of the screen
 .B Drag & drop APK file
 Install APK from computer
 .TP
 .B Drag & drop non-APK file
 Push file to device (see \fB\-\-push\-target\fR)
 .SH Environment variables
--- a/app/src/adb.c
+++ b/app/src/adb.c
@@ -81,20 +81,14 @@ show_adb_installation_msg() {
 static void
 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) {
        LOGE("Failed to execute (could not allocate error message)");
        return;
    }
    switch (err) {
        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 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)");
@@ -104,50 +98,32 @@ show_adb_err_msg(enum process_result err, const char *const argv[]) {
            // do nothing
            break;
    }
    free(buf);
 }
 process_t
-adb_execute_redirect(const char *serial, const char *const adb_cmd[],
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
-                     size_t len, pipe_t *pipe_stdin, pipe_t *pipe_stdout,
+    const char *cmd[len + 4];
                     pipe_t *pipe_stderr) {
    int i;
    process_t process;
-
+    cmd[0] = get_adb_command();
    const char **argv = malloc((len + 4) * sizeof(*argv));
    if (!argv) {
        return PROCESS_NONE;
    }
    argv[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;
-    enum process_result r =
+    enum process_result r = process_execute(cmd, &process);
        process_execute_redirect(argv, &process, pipe_stdin, pipe_stdout,
                                 pipe_stderr);
    if (r != PROCESS_SUCCESS) {
-        show_adb_err_msg(r, argv);
+        show_adb_err_msg(r, cmd);
-        process = PROCESS_NONE;
+        return PROCESS_NONE;
    }
    free(argv);
    return process;
 }
 process_t
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
    return adb_execute_redirect(serial, adb_cmd, len, NULL, NULL, NULL);
 }
 process_t
 adb_forward(const char *serial, uint16_t local_port,
            const char *device_socket_name) {
@@ -233,47 +209,3 @@ adb_install(const char *serial, const char *local) {
    return proc;
 }
 static ssize_t
 adb_execute_for_output(const char *serial, const char *const adb_cmd[],
                       size_t adb_cmd_len, char *buf, size_t buf_len,
                       const char *name) {
    pipe_t pipe_stdout;
    process_t proc = adb_execute_redirect(serial, adb_cmd, adb_cmd_len, NULL,
                                          &pipe_stdout, NULL);
    ssize_t r = read_pipe_all(pipe_stdout, buf, buf_len);
    close_pipe(pipe_stdout);
    if (!process_check_success(proc, name, true)) {
        return -1;
    }
    return r;
 }
 static size_t
 truncate_first_line(char *data, size_t len) {
    data[len - 1] = '\0';
    char *eol = strpbrk(data, "\r\n");
    if (eol) {
        *eol = '\0';
        len = eol - data;
    }
    return len;
 }
 char *
 adb_get_serialno(void) {
    char buf[128];
    const char *const adb_cmd[] = {"get-serialno"};
    ssize_t r = adb_execute_for_output(NULL, adb_cmd, ARRAY_LEN(adb_cmd),
                                       buf, sizeof(buf), "get-serialno");
    if (r <= 0) {
        return NULL;
    }
    truncate_first_line(buf, r);
    return strdup(buf);
 }
--- a/app/src/adb.h
+++ b/app/src/adb.h
@@ -11,11 +11,6 @@
 process_t
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
 process_t
 adb_execute_redirect(const char *serial, const char *const adb_cmd[],
                     size_t len, pipe_t *pipe_stdin, pipe_t *pipe_stdout,
                     pipe_t *pipe_stderr);
 process_t
 adb_forward(const char *serial, uint16_t local_port,
            const char *device_socket_name);
@@ -36,8 +31,4 @@ adb_push(const char *serial, const char *local, const char *remote);
 process_t
 adb_install(const char *serial, const char *local);
 // Return the result of "adb get-serialno".
 char *
 adb_get_serialno(void);
 #endif
--- a/app/src/android/input.h
+++ b/app/src/android/input.h
@@ -21,7 +21,7 @@
 #define _ANDROID_INPUT_H
 /**
- * Meta key / modifier state.
+ * Meta key / modifer state.
 */
 enum android_metastate {
    /** No meta keys are pressed. */
--- a/app/src/aoa_hid.c
+++ b/app/src/aoa_hid.c
@@ -1,385 +0,0 @@
 #include "util/log.h"
 #include <assert.h>
 #include <stdio.h>
 #include "aoa_hid.h"
 // See <https://source.android.com/devices/accessories/aoa2#hid-support>.
 #define ACCESSORY_REGISTER_HID 54
 #define ACCESSORY_SET_HID_REPORT_DESC 56
 #define ACCESSORY_SEND_HID_EVENT 57
 #define ACCESSORY_UNREGISTER_HID 55
 #define DEFAULT_TIMEOUT 1000
 static void
 sc_hid_event_log(const struct sc_hid_event *event) {
    // HID Event: [00] FF FF FF FF...
    assert(event->size);
    unsigned buffer_size = event->size * 3 + 1;
    char *buffer = malloc(buffer_size);
    if (!buffer) {
        return;
    }
    for (unsigned i = 0; i < event->size; ++i) {
        snprintf(buffer + i * 3, 4, " %02x", event->buffer[i]);
    }
    LOGV("HID Event: [%d]%s", event->accessory_id, buffer);
    free(buffer);
 }
 void
 sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
                  unsigned char *buffer, uint16_t buffer_size) {
    hid_event->accessory_id = accessory_id;
    hid_event->buffer = buffer;
    hid_event->size = buffer_size;
    hid_event->delay = 0;
 }
 void
 sc_hid_event_destroy(struct sc_hid_event *hid_event) {
    free(hid_event->buffer);
 }
 static inline void
 log_libusb_error(enum libusb_error errcode) {
    LOGW("libusb error: %s", libusb_strerror(errcode));
 }
 static bool
 accept_device(libusb_device *device, const char *serial) {
    // do not log any USB error in this function, it is expected that many USB
    // devices available on the computer have permission restrictions
    struct libusb_device_descriptor desc;
    libusb_get_device_descriptor(device, &desc);
    if (!desc.iSerialNumber) {
        return false;
    }
    libusb_device_handle *handle;
    int result = libusb_open(device, &handle);
    if (result < 0) {
        return false;
    }
    char buffer[128];
    result = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber,
                                                (unsigned char *) buffer,
                                                sizeof(buffer));
    libusb_close(handle);
    if (result < 0) {
        return false;
    }
    buffer[sizeof(buffer) - 1] = '\0'; // just in case
    // accept the device if its serial matches
    return !strcmp(buffer, serial);
 }
 static libusb_device *
 sc_aoa_find_usb_device(const char *serial) {
    if (!serial) {
        return NULL;
    }
    libusb_device **list;
    libusb_device *result = NULL;
    ssize_t count = libusb_get_device_list(NULL, &list);
    if (count < 0) {
        log_libusb_error((enum libusb_error) count);
        return NULL;
    }
    for (size_t i = 0; i < (size_t) count; ++i) {
        libusb_device *device = list[i];
        if (accept_device(device, serial)) {
            result = libusb_ref_device(device);
            break;
        }
    }
    libusb_free_device_list(list, 1);
    return result;
 }
 static int
 sc_aoa_open_usb_handle(libusb_device *device, libusb_device_handle **handle) {
    int result = libusb_open(device, handle);
    if (result < 0) {
        log_libusb_error((enum libusb_error) result);
        return result;
    }
    return 0;
 }
 bool
 sc_aoa_init(struct sc_aoa *aoa, const char *serial) {
    cbuf_init(&aoa->queue);
    if (!sc_mutex_init(&aoa->mutex)) {
        return false;
    }
    if (!sc_cond_init(&aoa->event_cond)) {
        sc_mutex_destroy(&aoa->mutex);
        return false;
    }
    if (libusb_init(&aoa->usb_context) != LIBUSB_SUCCESS) {
        sc_cond_destroy(&aoa->event_cond);
        sc_mutex_destroy(&aoa->mutex);
        return false;
    }
    aoa->usb_device = sc_aoa_find_usb_device(serial);
    if (!aoa->usb_device) {
        LOGW("USB device of serial %s not found", serial);
        libusb_exit(aoa->usb_context);
        sc_mutex_destroy(&aoa->mutex);
        sc_cond_destroy(&aoa->event_cond);
        return false;
    }
    if (sc_aoa_open_usb_handle(aoa->usb_device, &aoa->usb_handle) < 0) {
        LOGW("Open USB handle failed");
        libusb_unref_device(aoa->usb_device);
        libusb_exit(aoa->usb_context);
        sc_cond_destroy(&aoa->event_cond);
        sc_mutex_destroy(&aoa->mutex);
        return false;
    }
    aoa->stopped = false;
    return true;
 }
 void
 sc_aoa_destroy(struct sc_aoa *aoa) {
    // Destroy remaining events
    struct sc_hid_event event;
    while (cbuf_take(&aoa->queue, &event)) {
        sc_hid_event_destroy(&event);
    }
    libusb_close(aoa->usb_handle);
    libusb_unref_device(aoa->usb_device);
    libusb_exit(aoa->usb_context);
    sc_cond_destroy(&aoa->event_cond);
    sc_mutex_destroy(&aoa->mutex);
 }
 static bool
 sc_aoa_register_hid(struct sc_aoa *aoa, uint16_t accessory_id,
                    uint16_t report_desc_size) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_REGISTER_HID;
    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
    // value (arg0): accessory assigned ID for the HID device
    // index (arg1): total length of the HID report descriptor
    uint16_t value = accessory_id;
    uint16_t index = report_desc_size;
    unsigned char *buffer = NULL;
    uint16_t length = 0;
    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
                                         value, index, buffer, length,
                                         DEFAULT_TIMEOUT);
    if (result < 0) {
        log_libusb_error((enum libusb_error) result);
        return false;
    }
    return true;
 }
 static bool
 sc_aoa_set_hid_report_desc(struct sc_aoa *aoa, uint16_t accessory_id,
                           const unsigned char *report_desc,
                           uint16_t report_desc_size) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_SET_HID_REPORT_DESC;
    /**
     * If the HID descriptor is longer than the endpoint zero max packet size,
     * the descriptor will be sent in multiple ACCESSORY_SET_HID_REPORT_DESC
     * commands. The data for the descriptor must be sent sequentially
     * if multiple packets are needed.
     * <https://source.android.com/devices/accessories/aoa2.html#hid-support>
     *
     * libusb handles packet abstraction internally, so we don't need to care
     * about bMaxPacketSize0 here.
     *
     * See <https://libusb.sourceforge.io/api-1.0/libusb_packetoverflow.html>
     */
    // value (arg0): accessory assigned ID for the HID device
    // index (arg1): offset of data (buffer) in descriptor
    uint16_t value = accessory_id;
    uint16_t index = 0;
    // libusb_control_transfer expects a pointer to non-const
    unsigned char *buffer = (unsigned char *) report_desc;
    uint16_t length = report_desc_size;
    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
                                         value, index, buffer, length,
                                         DEFAULT_TIMEOUT);
    if (result < 0) {
        log_libusb_error((enum libusb_error) result);
        return false;
    }
    return true;
 }
 bool
 sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
                 const unsigned char *report_desc, uint16_t report_desc_size) {
    bool ok = sc_aoa_register_hid(aoa, accessory_id, report_desc_size);
    if (!ok) {
        return false;
    }
    ok = sc_aoa_set_hid_report_desc(aoa, accessory_id, report_desc,
                                    report_desc_size);
    if (!ok) {
        if (!sc_aoa_unregister_hid(aoa, accessory_id)) {
            LOGW("Could not unregister HID");
        }
        return false;
    }
    return true;
 }
 static bool
 sc_aoa_send_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_SEND_HID_EVENT;
    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
    // value (arg0): accessory assigned ID for the HID device
    // index (arg1): 0 (unused)
    uint16_t value = event->accessory_id;
    uint16_t index = 0;
    unsigned char *buffer = event->buffer;
    uint16_t length = event->size;
    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
                                         value, index, buffer, length,
                                         DEFAULT_TIMEOUT);
    if (result < 0) {
        log_libusb_error((enum libusb_error) result);
        return false;
    }
    return true;
 }
 bool
 sc_aoa_unregister_hid(struct sc_aoa *aoa, const uint16_t accessory_id) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_UNREGISTER_HID;
    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
    // value (arg0): accessory assigned ID for the HID device
    // index (arg1): 0
    uint16_t value = accessory_id;
    uint16_t index = 0;
    unsigned char *buffer = NULL;
    uint16_t length = 0;
    int result = libusb_control_transfer(aoa->usb_handle, request_type, request,
                                         value, index, buffer, length,
                                         DEFAULT_TIMEOUT);
    if (result < 0) {
        log_libusb_error((enum libusb_error) result);
        return false;
    }
    return true;
 }
 bool
 sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
    if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
        sc_hid_event_log(event);
    }
    sc_mutex_lock(&aoa->mutex);
    bool was_empty = cbuf_is_empty(&aoa->queue);
    bool res = cbuf_push(&aoa->queue, *event);
    if (was_empty) {
        sc_cond_signal(&aoa->event_cond);
    }
    sc_mutex_unlock(&aoa->mutex);
    return res;
 }
 static int
 run_aoa_thread(void *data) {
    struct sc_aoa *aoa = data;
    for (;;) {
        sc_mutex_lock(&aoa->mutex);
        while (!aoa->stopped && cbuf_is_empty(&aoa->queue)) {
            sc_cond_wait(&aoa->event_cond, &aoa->mutex);
        }
        if (aoa->stopped) {
            // Stop immediately, do not process further events
            sc_mutex_unlock(&aoa->mutex);
            break;
        }
        struct sc_hid_event event;
        bool non_empty = cbuf_take(&aoa->queue, &event);
        assert(non_empty);
        (void) non_empty;
        assert(event.delay >= 0);
        if (event.delay) {
            // Wait during the specified delay before injecting the HID event
            sc_tick deadline = sc_tick_now() + event.delay;
            bool timed_out = false;
            while (!aoa->stopped && !timed_out) {
                timed_out = !sc_cond_timedwait(&aoa->event_cond, &aoa->mutex,
                                               deadline);
            }
            if (aoa->stopped) {
                sc_mutex_unlock(&aoa->mutex);
                break;
            }
        }
        sc_mutex_unlock(&aoa->mutex);
        bool ok = sc_aoa_send_hid_event(aoa, &event);
        sc_hid_event_destroy(&event);
        if (!ok) {
            LOGW("Could not send HID event to USB device");
        }
    }
    return 0;
 }
 bool
 sc_aoa_start(struct sc_aoa *aoa) {
    LOGD("Starting AOA thread");
    bool ok = sc_thread_create(&aoa->thread, run_aoa_thread, "aoa_thread", aoa);
    if (!ok) {
        LOGC("Could not start AOA thread");
        return false;
    }
    return true;
 }
 void
 sc_aoa_stop(struct sc_aoa *aoa) {
    sc_mutex_lock(&aoa->mutex);
    aoa->stopped = true;
    sc_cond_signal(&aoa->event_cond);
    sc_mutex_unlock(&aoa->mutex);
 }
 void
 sc_aoa_join(struct sc_aoa *aoa) {
    sc_thread_join(&aoa->thread, NULL);
 }
--- a/app/src/aoa_hid.h
+++ b/app/src/aoa_hid.h
@@ -1,66 +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/cbuf.h"
 #include "util/thread.h"
 #include "util/tick.h"
 struct sc_hid_event {
    uint16_t accessory_id;
    unsigned char *buffer;
    uint16_t size;
    sc_tick delay;
 };
 // Takes ownership of buffer
 void
 sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
                  unsigned char *buffer, uint16_t buffer_size);
 void
 sc_hid_event_destroy(struct sc_hid_event *hid_event);
 struct sc_hid_event_queue CBUF(struct sc_hid_event, 64);
 struct sc_aoa {
    libusb_context *usb_context;
    libusb_device *usb_device;
    libusb_device_handle *usb_handle;
    sc_thread thread;
    sc_mutex mutex;
    sc_cond event_cond;
    bool stopped;
    struct sc_hid_event_queue queue;
 };
 bool
 sc_aoa_init(struct sc_aoa *aoa, const char *serial);
 void
 sc_aoa_destroy(struct sc_aoa *aoa);
 bool
 sc_aoa_start(struct sc_aoa *aoa);
 void
 sc_aoa_stop(struct sc_aoa *aoa);
 void
 sc_aoa_join(struct sc_aoa *aoa);
 bool
 sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
              const unsigned char *report_desc, uint16_t report_desc_size);
 bool
 sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id);
 bool
 sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event);
 #endif
--- a/app/src/cli.c
+++ b/app/src/cli.c
--- a/app/src/cli.h
+++ b/app/src/cli.h
@@ -5,7 +5,7 @@
 #include <stdbool.h>
-#include "options.h"
+#include "scrcpy.h"
 struct scrcpy_cli_args {
    struct scrcpy_options opts;
--- a/app/src/clock.c
+++ b/app/src/clock.c
@@ -1,111 +0,0 @@
 #include "clock.h"
 #include "util/log.h"
 #define SC_CLOCK_NDEBUG // comment to debug
 void
 sc_clock_init(struct sc_clock *clock) {
    clock->count = 0;
    clock->head = 0;
    clock->left_sum.system = 0;
    clock->left_sum.stream = 0;
    clock->right_sum.system = 0;
    clock->right_sum.stream = 0;
 }
 // Estimate the affine function f(stream) = slope * stream + offset
 static void
 sc_clock_estimate(struct sc_clock *clock,
                  double *out_slope, sc_tick *out_offset) {
    assert(clock->count > 1); // two points are necessary
    struct sc_clock_point left_avg = {
        .system = clock->left_sum.system / (clock->count / 2),
        .stream = clock->left_sum.stream / (clock->count / 2),
    };
    struct sc_clock_point right_avg = {
        .system = clock->right_sum.system / ((clock->count + 1) / 2),
        .stream = clock->right_sum.stream / ((clock->count + 1) / 2),
    };
    double slope = (double) (right_avg.system - left_avg.system)
                 / (right_avg.stream - left_avg.stream);
    if (clock->count < SC_CLOCK_RANGE) {
        /* The first frames are typically received and decoded with more delay
         * than the others, causing a wrong slope estimation on start. To
         * compensate, assume an initial slope of 1, then progressively use the
         * estimated slope. */
        slope = (clock->count * slope + (SC_CLOCK_RANGE - clock->count))
              / SC_CLOCK_RANGE;
    }
    struct sc_clock_point global_avg = {
        .system = (clock->left_sum.system + clock->right_sum.system)
                 / clock->count,
        .stream = (clock->left_sum.stream + clock->right_sum.stream)
                 / clock->count,
    };
    sc_tick offset = global_avg.system - (sc_tick) (global_avg.stream * slope);
    *out_slope = slope;
    *out_offset = offset;
 }
 void
 sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
    struct sc_clock_point *point = &clock->points[clock->head];
    if (clock->count == SC_CLOCK_RANGE || clock->count & 1) {
        // One point passes from the right sum to the left sum
        unsigned mid;
        if (clock->count == SC_CLOCK_RANGE) {
            mid = (clock->head + SC_CLOCK_RANGE / 2) % SC_CLOCK_RANGE;
        } else {
            // Only for the first frames
            mid = clock->count / 2;
        }
        struct sc_clock_point *mid_point = &clock->points[mid];
        clock->left_sum.system += mid_point->system;
        clock->left_sum.stream += mid_point->stream;
        clock->right_sum.system -= mid_point->system;
        clock->right_sum.stream -= mid_point->stream;
    }
    if (clock->count == SC_CLOCK_RANGE) {
        // The current point overwrites the previous value in the circular
        // array, update the left sum accordingly
        clock->left_sum.system -= point->system;
        clock->left_sum.stream -= point->stream;
    } else {
        ++clock->count;
    }
    point->system = system;
    point->stream = stream;
    clock->right_sum.system += system;
    clock->right_sum.stream += stream;
    clock->head = (clock->head + 1) % SC_CLOCK_RANGE;
    if (clock->count > 1) {
        // Update estimation
        sc_clock_estimate(clock, &clock->slope, &clock->offset);
 #ifndef SC_CLOCK_NDEBUG
        LOGD("Clock estimation: %g * pts + %" PRItick,
             clock->slope, clock->offset);
 #endif
    }
 }
 sc_tick
 sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream) {
    assert(clock->count > 1); // sc_clock_update() must have been called
    return (sc_tick) (stream * clock->slope) + clock->offset;
 }
--- a/app/src/clock.h
+++ b/app/src/clock.h
@@ -1,70 +0,0 @@
 #ifndef SC_CLOCK_H
 #define SC_CLOCK_H
 #include "common.h"
 #include <assert.h>
 #include "util/tick.h"
 #define SC_CLOCK_RANGE 32
 static_assert(!(SC_CLOCK_RANGE & 1), "SC_CLOCK_RANGE must be even");
 struct sc_clock_point {
    sc_tick system;
    sc_tick stream;
 };
 /**
 * The clock aims to estimate the affine relation between the stream (device)
 * time and the system time:
 *
 *     f(stream) = slope * stream + offset
 *
 * To that end, it stores the SC_CLOCK_RANGE last clock points (the timestamps
 * of a frame expressed both in stream time and system time) in a circular
 * array.
 *
 * To estimate the slope, it splits the last SC_CLOCK_RANGE points into two
 * sets of SC_CLOCK_RANGE/2 points, and computes their centroid ("average
 * point"). The slope of the estimated affine function is that of the line
 * passing through these two points.
 *
 * To estimate the offset, it computes the centroid of all the SC_CLOCK_RANGE
 * points. The resulting affine function passes by this centroid.
 *
 * With a circular array, the rolling sums (and average) are quick to compute.
 * In practice, the estimation is stable and the evolution is smooth.
 */
 struct sc_clock {
    // Circular array
    struct sc_clock_point points[SC_CLOCK_RANGE];
    // Number of points in the array (count <= SC_CLOCK_RANGE)
    unsigned count;
    // Index of the next point to write
    unsigned head;
    // Sum of the first count/2 points
    struct sc_clock_point left_sum;
    // Sum of the last (count+1)/2 points
    struct sc_clock_point right_sum;
    // Estimated slope and offset
    // (computed on sc_clock_update(), used by sc_clock_to_system_time())
    double slope;
    sc_tick offset;
 };
 void
 sc_clock_init(struct sc_clock *clock);
 void
 sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream);
 sc_tick
 sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream);
 #endif
--- a/app/src/compat.h
+++ b/app/src/compat.h
@@ -22,18 +22,6 @@
 # define SCRCPY_LAVF_REQUIRES_REGISTER_ALL
 #endif
 // In ffmpeg/doc/APIchanges:
 // 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
 //   Deprecate AVFormatContext filename field which had limited length, use the
 //   new dynamically allocated url field instead.
 //
 // 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
 //   Add url field to AVFormatContext and add ff_format_set_url helper function.
 #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 7, 100)
 # define SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
 #endif
 #if SDL_VERSION_ATLEAST(2, 0, 5)
 // <https://wiki.libsdl.org/SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH>
 # define SCRCPY_SDL_HAS_HINT_MOUSE_FOCUS_CLICKTHROUGH
@@ -43,11 +31,6 @@
 # define SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
 #endif
 #if SDL_VERSION_ATLEAST(2, 0, 6)
 // <https://github.com/libsdl-org/SDL/commit/d7a318de563125e5bb465b1000d6bc9576fbc6fc>
 # define SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
 #endif
 #if SDL_VERSION_ATLEAST(2, 0, 8)
 // <https://hg.libsdl.org/SDL/rev/dfde5d3f9781>
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@@ -1,7 +1,6 @@
 #include "control_msg.h"
 #include <assert.h>
 #include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
@@ -9,54 +8,8 @@
 #include "util/log.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 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);
@@ -114,9 +67,6 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
            buffer_write32be(&buf[17],
                             (uint32_t) msg->inject_scroll_event.vscroll);
            return 21;
        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
            buf[1] = msg->inject_keycode.action;
            return 2;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
            buf[1] = !!msg->set_clipboard.paste;
            size_t len = write_string(msg->set_clipboard.text,
@@ -127,9 +77,9 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
            buf[1] = msg->set_screen_power_mode.mode;
            return 2;
        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
+        case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
            // no additional data
@@ -140,94 +90,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
 #ifndef __WIN32
 # define PRIu64_ PRIu64
 #else
 # define PRIu64_ "I64u"  // Windows...
 #endif
                LOG_CMSG("touch [id=%" PRIu64_ "] %-4s position=%" PRIi32 ",%"
                             PRIi32 " pressure=%g buttons=%06lx",
                         id,
                         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,
                     msg->inject_scroll_event.position.point.x,
                     msg->inject_scroll_event.position.point.y,
                     msg->inject_scroll_event.hscroll,
                     msg->inject_scroll_event.vscroll);
            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_SET_CLIPBOARD:
            LOG_CMSG("clipboard %s \"%s\"",
                     msg->set_clipboard.paste ? "paste" : "copy",
                     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_GET_CLIPBOARD:
            LOG_CMSG("get clipboard");
            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
@@ -17,8 +17,8 @@
 // type: 1 byte; paste flag: 1 byte; length: 4 bytes
 #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,
@@ -27,8 +27,7 @@ enum control_msg_type {
    CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
    CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
    CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
-    CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+    CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
    CONTROL_MSG_TYPE_COLLAPSE_PANELS,
    CONTROL_MSG_TYPE_GET_CLIPBOARD,
    CONTROL_MSG_TYPE_SET_CLIPBOARD,
    CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
@@ -57,18 +56,14 @@ struct control_msg {
            enum android_motionevent_action action;
            enum android_motionevent_buttons buttons;
            uint64_t pointer_id;
-            struct sc_position position;
+            struct position position;
            float pressure;
        } inject_touch_event;
        struct {
-            struct sc_position position;
+            struct position position;
            int32_t hscroll;
            int32_t vscroll;
        } inject_scroll_event;
        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 {
            char *text; // owned, to be freed by free()
            bool paste;
@@ -84,9 +79,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,7 +5,7 @@
 #include "util/log.h"
 bool
-controller_init(struct controller *controller, sc_socket control_socket) {
+controller_init(struct controller *controller, socket_t control_socket) {
    cbuf_init(&controller->queue);
    bool ok = receiver_init(&controller->receiver, control_socket);
@@ -47,11 +47,7 @@ controller_destroy(struct controller *controller) {
 bool
 controller_push_msg(struct controller *controller,
-                    const struct control_msg *msg) {
+                      const struct control_msg *msg) {
    if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
        control_msg_log(msg);
    }
    sc_mutex_lock(&controller->mutex);
    bool was_empty = cbuf_is_empty(&controller->queue);
    bool res = cbuf_push(&controller->queue, *msg);
@@ -63,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;
 }
--- a/app/src/controller.h
+++ b/app/src/controller.h
@@ -14,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;
@@ -24,7 +24,7 @@ struct controller {
 };
 bool
-controller_init(struct controller *controller, sc_socket control_socket);
+controller_init(struct controller *controller, socket_t control_socket);
 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"
@@ -65,7 +64,6 @@ decoder_open(struct decoder *decoder, const AVCodec *codec) {
        av_frame_free(&decoder->frame);
        avcodec_close(decoder->codec_ctx);
        avcodec_free_context(&decoder->codec_ctx);
        return false;
    }
    return true;
@@ -100,8 +98,8 @@ decoder_push(struct decoder *decoder, const AVPacket *packet) {
        return true;
    }
-    int ret = avcodec_send_packet(decoder->codec_ctx, packet);
+    int ret;
-    if (ret < 0 && ret != AVERROR(EAGAIN)) {
+    if ((ret = avcodec_send_packet(decoder->codec_ctx, packet)) < 0) {
        LOGE("Could not send video packet: %d", ret);
        return false;
    }
@@ -112,8 +110,6 @@ decoder_push(struct decoder *decoder, const AVPacket *packet) {
        // A frame lost should not make the whole pipeline fail. The error, if
        // any, is already logged.
        (void) ok;
        av_frame_unref(decoder->frame);
    } else if (ret != AVERROR(EAGAIN)) {
        LOGE("Could not receive video frame: %d", ret);
        return false;
@@ -141,8 +137,6 @@ decoder_packet_sink_push(struct sc_packet_sink *sink, const AVPacket *packet) {
 void
 decoder_init(struct decoder *decoder) {
    decoder->sink_count = 0;
    static const struct sc_packet_sink_ops ops = {
        .open = decoder_packet_sink_open,
        .close = decoder_packet_sink_close,
--- a/app/src/decoder.h
+++ b/app/src/decoder.h
@@ -8,7 +8,7 @@
 #include <stdbool.h>
 #include <libavformat/avformat.h>
-#define DECODER_MAX_SINKS 2
+#define DECODER_MAX_SINKS 1
 struct decoder {
    struct sc_packet_sink packet_sink; // packet sink trait
--- a/app/src/device.c
+++ b/app/src/device.c
@@ -0,0 +1,23 @@
 #include "device.h"
 #include "util/log.h"
 bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size) {
    unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
    int r = net_recv_all(device_socket, buf, sizeof(buf));
    if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
        LOGE("Could not retrieve device information");
        return false;
    }
    // in case the client sends garbage
    buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
    // strcpy is safe here, since name contains at least
    // DEVICE_NAME_FIELD_LENGTH bytes and strlen(buf) < DEVICE_NAME_FIELD_LENGTH
    strcpy(device_name, (char *) buf);
    size->width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
            | buf[DEVICE_NAME_FIELD_LENGTH + 1];
    size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
    return true;
 }
--- a/app/src/device.h
+++ b/app/src/device.h
@@ -0,0 +1,17 @@
 #ifndef DEVICE_H
 #define DEVICE_H
 #include "common.h"
 #include <stdbool.h>
 #include "coords.h"
 #include "util/net.h"
 #define DEVICE_NAME_FIELD_LENGTH 64
 // name must be at least DEVICE_NAME_FIELD_LENGTH bytes
 bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size);
 #endif
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@@ -1,20 +1,9 @@
-#include "keyboard_inject.h"
+#include "event_converter.h"
 #include <assert.h>
 #include <SDL2/SDL_events.h>
 #include "android/input.h"
 #include "control_msg.h"
 #include "controller.h"
 #include "util/log.h"
 /** Downcast key processor to sc_keyboard_inject */
 #define DOWNCAST(KP) \
    container_of(KP, struct sc_keyboard_inject, key_processor)
 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false
-static bool
+
 bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
    switch (from) {
        MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
@@ -23,7 +12,67 @@ convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
    }
 }
-static bool
+static enum android_metastate
 autocomplete_metastate(enum android_metastate metastate) {
    // fill dependant flags
    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
        metastate |= AMETA_SHIFT_ON;
    }
    if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
        metastate |= AMETA_CTRL_ON;
    }
    if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
        metastate |= AMETA_ALT_ON;
    }
    if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
        metastate |= AMETA_META_ON;
    }
    return metastate;
 }
 enum android_metastate
 convert_meta_state(SDL_Keymod mod) {
    enum android_metastate metastate = 0;
    if (mod & KMOD_LSHIFT) {
        metastate |= AMETA_SHIFT_LEFT_ON;
    }
    if (mod & KMOD_RSHIFT) {
        metastate |= AMETA_SHIFT_RIGHT_ON;
    }
    if (mod & KMOD_LCTRL) {
        metastate |= AMETA_CTRL_LEFT_ON;
    }
    if (mod & KMOD_RCTRL) {
        metastate |= AMETA_CTRL_RIGHT_ON;
    }
    if (mod & KMOD_LALT) {
        metastate |= AMETA_ALT_LEFT_ON;
    }
    if (mod & KMOD_RALT) {
        metastate |= AMETA_ALT_RIGHT_ON;
    }
    if (mod & KMOD_LGUI) { // Windows key
        metastate |= AMETA_META_LEFT_ON;
    }
    if (mod & KMOD_RGUI) { // Windows key
        metastate |= AMETA_META_RIGHT_ON;
    }
    if (mod & KMOD_NUM) {
        metastate |= AMETA_NUM_LOCK_ON;
    }
    if (mod & KMOD_CAPS) {
        metastate |= AMETA_CAPS_LOCK_ON;
    }
    if (mod & KMOD_MODE) { // Alt Gr
        // no mapping?
    }
    // fill the dependent fields
    return autocomplete_metastate(metastate);
 }
 bool
 convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
                bool prefer_text) {
    switch (from) {
@@ -105,150 +154,42 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
    }
 }
-static enum android_metastate
+enum android_motionevent_buttons
-autocomplete_metastate(enum android_metastate metastate) {
+convert_mouse_buttons(uint32_t state) {
-    // fill dependent flags
+    enum android_motionevent_buttons buttons = 0;
-    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
+    if (state & SDL_BUTTON_LMASK) {
-        metastate |= AMETA_SHIFT_ON;
+        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
    }
-    if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
+    if (state & SDL_BUTTON_RMASK) {
-        metastate |= AMETA_CTRL_ON;
+        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
    }
-    if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
+    if (state & SDL_BUTTON_MMASK) {
-        metastate |= AMETA_ALT_ON;
+        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
    }
-    if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
+    if (state & SDL_BUTTON_X1MASK) {
-        metastate |= AMETA_META_ON;
+        buttons |= AMOTION_EVENT_BUTTON_BACK;
    }
-
+    if (state & SDL_BUTTON_X2MASK) {
-    return metastate;
+        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
    }
    return buttons;
 }
-static enum android_metastate
+bool
-convert_meta_state(SDL_Keymod mod) {
+convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
-    enum android_metastate metastate = 0;
+    switch (from) {
-    if (mod & KMOD_LSHIFT) {
+        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
-        metastate |= AMETA_SHIFT_LEFT_ON;
+        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
-    }
+        FAIL;
    if (mod & KMOD_RSHIFT) {
        metastate |= AMETA_SHIFT_RIGHT_ON;
    }
    if (mod & KMOD_LCTRL) {
        metastate |= AMETA_CTRL_LEFT_ON;
    }
    if (mod & KMOD_RCTRL) {
        metastate |= AMETA_CTRL_RIGHT_ON;
    }
    if (mod & KMOD_LALT) {
        metastate |= AMETA_ALT_LEFT_ON;
    }
    if (mod & KMOD_RALT) {
        metastate |= AMETA_ALT_RIGHT_ON;
    }
    if (mod & KMOD_LGUI) { // Windows key
        metastate |= AMETA_META_LEFT_ON;
    }
    if (mod & KMOD_RGUI) { // Windows key
        metastate |= AMETA_META_RIGHT_ON;
    }
    if (mod & KMOD_NUM) {
        metastate |= AMETA_NUM_LOCK_ON;
    }
    if (mod & KMOD_CAPS) {
        metastate |= AMETA_CAPS_LOCK_ON;
    }
    if (mod & KMOD_MODE) { // Alt Gr
        // no mapping?
    }
    // fill the dependent fields
    return autocomplete_metastate(metastate);
 }
 static bool
 convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
                  bool prefer_text, uint32_t repeat) {
    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
        return false;
    }
    uint16_t mod = from->keysym.mod;
    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod,
                         prefer_text)) {
        return false;
    }
    to->inject_keycode.repeat = repeat;
    to->inject_keycode.metastate = convert_meta_state(mod);
    return true;
 }
 static void
 sc_key_processor_process_key(struct sc_key_processor *kp,
                             const SDL_KeyboardEvent *event) {
    struct sc_keyboard_inject *ki = DOWNCAST(kp);
    if (event->repeat) {
        if (!ki->forward_key_repeat) {
            return;
        }
        ++ki->repeat;
    } else {
        ki->repeat = 0;
    }
    struct control_msg msg;
    if (convert_input_key(event, &msg, ki->prefer_text, ki->repeat)) {
        if (!controller_push_msg(ki->controller, &msg)) {
            LOGW("Could not request 'inject keycode'");
        }
    }
 }
-static void
+bool
-sc_key_processor_process_text(struct sc_key_processor *kp,
+convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
-                              const SDL_TextInputEvent *event) {
+    switch (from) {
-    struct sc_keyboard_inject *ki = DOWNCAST(kp);
+        MAP(SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE);
-
+        MAP(SDL_FINGERDOWN,   AMOTION_EVENT_ACTION_DOWN);
-    if (!ki->prefer_text) {
+        MAP(SDL_FINGERUP,     AMOTION_EVENT_ACTION_UP);
-        char c = event->text[0];
+        FAIL;
        if (isalpha(c) || c == ' ') {
            assert(event->text[1] == '\0');
            // letters and space are handled as raw key event
            return;
        }
    }
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
    msg.inject_text.text = strdup(event->text);
    if (!msg.inject_text.text) {
        LOGW("Could not strdup input text");
        return;
    }
    if (!controller_push_msg(ki->controller, &msg)) {
        free(msg.inject_text.text);
        LOGW("Could not request 'inject text'");
    }
 }
 void
 sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
                        struct controller *controller,
                        const struct scrcpy_options *options) {
    ki->controller = controller;
    ki->prefer_text = options->prefer_text;
    ki->forward_key_repeat = options->forward_key_repeat;
    ki->repeat = 0;
    static const struct sc_key_processor_ops ops = {
        .process_key = sc_key_processor_process_key,
        .process_text = sc_key_processor_process_text,
    };
    ki->key_processor.ops = &ops;
 }
--- a/app/src/event_converter.h
+++ b/app/src/event_converter.h
@@ -0,0 +1,30 @@
 #ifndef CONVERT_H
 #define CONVERT_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL_events.h>
 #include "control_msg.h"
 bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to);
 enum android_metastate
 convert_meta_state(SDL_Keymod mod);
 bool
 convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
                bool prefer_text);
 enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state);
 bool
 convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to);
 bool
 convert_touch_action(SDL_EventType from, enum android_motionevent_action *to);
 #endif
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@@ -6,7 +6,7 @@
 #include "adb.h"
 #include "util/log.h"
-#define DEFAULT_PUSH_TARGET "/sdcard/Download/"
+#define DEFAULT_PUSH_TARGET "/sdcard/"
 static void
 file_handler_request_destroy(struct file_handler_request *req) {
--- 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);
@@ -147,10 +150,6 @@ fps_counter_interrupt(struct fps_counter *counter) {
 void
 fps_counter_join(struct fps_counter *counter) {
    if (counter->thread_started) {
        // interrupted must be set by the thread calling join(), so no need to
        // lock for the assertion
        assert(counter->interrupted);
        sc_thread_join(&counter->thread, NULL);
    }
 }
@@ -162,7 +161,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 +174,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,88 +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) {
        return false;
    }
    fb->tmp_frame = av_frame_alloc();
    if (!fb->tmp_frame) {
        av_frame_free(&fb->pending_frame);
        return false;
    }
    bool ok = sc_mutex_init(&fb->mutex);
    if (!ok) {
        av_frame_free(&fb->pending_frame);
        av_frame_free(&fb->tmp_frame);
        return false;
    }
    // there is initially no frame, so consider it has already been consumed
    fb->pending_frame_consumed = true;
    return true;
 }
 void
 sc_frame_buffer_destroy(struct sc_frame_buffer *fb) {
    sc_mutex_destroy(&fb->mutex);
    av_frame_free(&fb->pending_frame);
    av_frame_free(&fb->tmp_frame);
 }
 static inline void
 swap_frames(AVFrame **lhs, AVFrame **rhs) {
    AVFrame *tmp = *lhs;
    *lhs = *rhs;
    *rhs = tmp;
 }
 bool
 sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
                  bool *previous_frame_skipped) {
    sc_mutex_lock(&fb->mutex);
    // Use a temporary frame to preserve pending_frame in case of error.
    // tmp_frame is an empty frame, no need to call av_frame_unref() beforehand.
    int r = av_frame_ref(fb->tmp_frame, frame);
    if (r) {
        LOGE("Could not ref frame: %d", r);
        return false;
    }
    // Now that av_frame_ref() succeeded, we can replace the previous
    // pending_frame
    swap_frames(&fb->pending_frame, &fb->tmp_frame);
    av_frame_unref(fb->tmp_frame);
    if (previous_frame_skipped) {
        *previous_frame_skipped = !fb->pending_frame_consumed;
    }
    fb->pending_frame_consumed = false;
    sc_mutex_unlock(&fb->mutex);
    return true;
 }
 void
 sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst) {
    sc_mutex_lock(&fb->mutex);
    assert(!fb->pending_frame_consumed);
    fb->pending_frame_consumed = true;
    av_frame_move_ref(dst, fb->pending_frame);
    // av_frame_move_ref() resets its source frame, so no need to call
    // av_frame_unref()
    sc_mutex_unlock(&fb->mutex);
 }
--- 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,363 +0,0 @@
 #include "hid_keyboard.h"
 #include <assert.h>
 #include <SDL2/SDL_events.h>
 #include "util/log.h"
 /** Downcast key processor to hid_keyboard */
 #define DOWNCAST(KP) container_of(KP, struct sc_hid_keyboard, key_processor)
 #define HID_KEYBOARD_ACCESSORY_ID 1
 #define HID_MODIFIER_NONE 0x00
 #define HID_MODIFIER_LEFT_CONTROL (1 << 0)
 #define HID_MODIFIER_LEFT_SHIFT (1 << 1)
 #define HID_MODIFIER_LEFT_ALT (1 << 2)
 #define HID_MODIFIER_LEFT_GUI (1 << 3)
 #define HID_MODIFIER_RIGHT_CONTROL (1 << 4)
 #define HID_MODIFIER_RIGHT_SHIFT (1 << 5)
 #define HID_MODIFIER_RIGHT_ALT (1 << 6)
 #define HID_MODIFIER_RIGHT_GUI (1 << 7)
 #define HID_KEYBOARD_INDEX_MODIFIER 0
 #define HID_KEYBOARD_INDEX_KEYS 2
 // USB HID protocol says 6 keys in an event is the requirement for BIOS
 // keyboard support, though OS could support more keys via modifying the report
 // desc. 6 should be enough for scrcpy.
 #define HID_KEYBOARD_MAX_KEYS 6
 #define HID_KEYBOARD_EVENT_SIZE (2 + HID_KEYBOARD_MAX_KEYS)
 #define HID_RESERVED 0x00
 #define HID_ERROR_ROLL_OVER 0x01
 /**
 * For HID over AOAv2, only report descriptor is needed.
 *
 * The specification is available here:
 * <https://www.usb.org/sites/default/files/hid1_11.pdf>
 *
 * In particular, read:
 *  - 6.2.2 Report Descriptor
 *  - Appendix B.1 Protocol 1 (Keyboard)
 *  - Appendix C: Keyboard Implementation
 *
 * Normally a basic HID keyboard uses 8 bytes:
 *     Modifier Reserved Key Key Key Key Key Key
 *
 * You can dump your device's report descriptor with:
 *
 *     sudo usbhid-dump -m vid:pid -e descriptor
 *
 * (change vid:pid' to your device's vendor ID and product ID).
 */
 static const unsigned char keyboard_report_desc[]  = {
    // Usage Page (Generic Desktop)
    0x05, 0x01,
    // Usage (Keyboard)
    0x09, 0x06,
    // Collection (Application)
    0xA1, 0x01,
    // Usage Page (Key Codes)
    0x05, 0x07,
    // Usage Minimum (224)
    0x19, 0xE0,
     // Usage Maximum (231)
    0x29, 0xE7,
    // Logical Minimum (0)
    0x15, 0x00,
    // Logical Maximum (1)
    0x25, 0x01,
    // Report Size (1)
    0x75, 0x01,
    // Report Count (8)
    0x95, 0x08,
    // Input (Data, Variable, Absolute): Modifier byte
    0x81, 0x02,
    // Report Size (8)
    0x75, 0x08,
    // Report Count (1)
    0x95, 0x01,
    // Input (Constant): Reserved byte
    0x81, 0x01,
    // Usage Page (LEDs)
    0x05, 0x08,
    // Usage Minimum (1)
    0x19, 0x01,
    // Usage Maximum (5)
    0x29, 0x05,
    // Report Size (1)
    0x75, 0x01,
    // Report Count (5)
    0x95, 0x05,
    // Output (Data, Variable, Absolute): LED report
    0x91, 0x02,
    // Report Size (3)
    0x75, 0x03,
    // Report Count (1)
    0x95, 0x01,
    // Output (Constant): LED report padding
    0x91, 0x01,
    // Usage Page (Key Codes)
    0x05, 0x07,
    // Usage Minimum (0)
    0x19, 0x00,
    // Usage Maximum (101)
    0x29, SC_HID_KEYBOARD_KEYS - 1,
    // Logical Minimum (0)
    0x15, 0x00,
    // Logical Maximum(101)
    0x25, SC_HID_KEYBOARD_KEYS - 1,
    // Report Size (8)
    0x75, 0x08,
    // Report Count (6)
    0x95, HID_KEYBOARD_MAX_KEYS,
    // Input (Data, Array): Keys
    0x81, 0x00,
    // End Collection
    0xC0
 };
 static unsigned char
 sdl_keymod_to_hid_modifiers(SDL_Keymod mod) {
    unsigned char modifiers = HID_MODIFIER_NONE;
    if (mod & KMOD_LCTRL) {
        modifiers |= HID_MODIFIER_LEFT_CONTROL;
    }
    if (mod & KMOD_LSHIFT) {
        modifiers |= HID_MODIFIER_LEFT_SHIFT;
    }
    if (mod & KMOD_LALT) {
        modifiers |= HID_MODIFIER_LEFT_ALT;
    }
    if (mod & KMOD_LGUI) {
        modifiers |= HID_MODIFIER_LEFT_GUI;
    }
    if (mod & KMOD_RCTRL) {
        modifiers |= HID_MODIFIER_RIGHT_CONTROL;
    }
    if (mod & KMOD_RSHIFT) {
        modifiers |= HID_MODIFIER_RIGHT_SHIFT;
    }
    if (mod & KMOD_RALT) {
        modifiers |= HID_MODIFIER_RIGHT_ALT;
    }
    if (mod & KMOD_RGUI) {
        modifiers |= HID_MODIFIER_RIGHT_GUI;
    }
    return modifiers;
 }
 static bool
 sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) {
    unsigned char *buffer = malloc(HID_KEYBOARD_EVENT_SIZE);
    if (!buffer) {
        return false;
    }
    buffer[HID_KEYBOARD_INDEX_MODIFIER] = HID_MODIFIER_NONE;
    buffer[1] = HID_RESERVED;
    memset(&buffer[HID_KEYBOARD_INDEX_KEYS], 0, HID_KEYBOARD_MAX_KEYS);
    sc_hid_event_init(hid_event, HID_KEYBOARD_ACCESSORY_ID, buffer,
                      HID_KEYBOARD_EVENT_SIZE);
    return true;
 }
 static inline bool
 scancode_is_modifier(SDL_Scancode scancode) {
    return scancode >= SDL_SCANCODE_LCTRL && scancode <= SDL_SCANCODE_RGUI;
 }
 static bool
 convert_hid_keyboard_event(struct sc_hid_keyboard *kb,
                           struct sc_hid_event *hid_event,
                           const SDL_KeyboardEvent *event) {
    SDL_Scancode scancode = event->keysym.scancode;
    assert(scancode >= 0);
    // SDL also generates events when only modifiers are pressed, we cannot
    // ignore them totally, for example press 'a' first then press 'Control',
    // if we ignore 'Control' event, only 'a' is sent.
    if (scancode >= SC_HID_KEYBOARD_KEYS && !scancode_is_modifier(scancode)) {
        // Scancode to ignore
        return false;
    }
    if (!sc_hid_keyboard_event_init(hid_event)) {
        LOGW("Could not initialize HID keyboard event");
        return false;
    }
    unsigned char modifiers = sdl_keymod_to_hid_modifiers(event->keysym.mod);
    if (scancode < SC_HID_KEYBOARD_KEYS) {
        // Pressed is true and released is false
        kb->keys[scancode] = (event->type == SDL_KEYDOWN);
        LOGV("keys[%02x] = %s", scancode,
             kb->keys[scancode] ? "true" : "false");
    }
    hid_event->buffer[HID_KEYBOARD_INDEX_MODIFIER] = modifiers;
    unsigned char *keys_buffer = &hid_event->buffer[HID_KEYBOARD_INDEX_KEYS];
    // Re-calculate pressed keys every time
    int keys_pressed_count = 0;
    for (int i = 0; i < SC_HID_KEYBOARD_KEYS; ++i) {
        if (kb->keys[i]) {
            // USB HID protocol says that if keys exceeds report count, a
            // phantom state should be reported
            if (keys_pressed_count >= HID_KEYBOARD_MAX_KEYS) {
                // Pantom state:
                //  - Modifiers
                //  - Reserved
                //  - ErrorRollOver * HID_MAX_KEYS
                memset(keys_buffer, HID_ERROR_ROLL_OVER, HID_KEYBOARD_MAX_KEYS);
                goto end;
            }
            keys_buffer[keys_pressed_count] = i;
            ++keys_pressed_count;
        }
    }
 end:
    LOGV("hid keyboard: key %-4s scancode=%02x (%u) mod=%02x",
         event->type == SDL_KEYDOWN ? "down" : "up", event->keysym.scancode,
         event->keysym.scancode, modifiers);
    return true;
 }
 static bool
 push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) {
    bool capslock = sdl_mod & KMOD_CAPS;
    bool numlock = sdl_mod & KMOD_NUM;
    if (!capslock && !numlock) {
        // Nothing to do
        return true;
    }
    struct sc_hid_event hid_event;
    if (!sc_hid_keyboard_event_init(&hid_event)) {
        LOGW("Could not initialize HID keyboard event");
        return false;
    }
 #define SC_SCANCODE_CAPSLOCK SDL_SCANCODE_CAPSLOCK
 #define SC_SCANCODE_NUMLOCK SDL_SCANCODE_NUMLOCKCLEAR
    unsigned i = 0;
    if (capslock) {
        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;
        ++i;
    }
    if (numlock) {
        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_NUMLOCK;
        ++i;
    }
    if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
        sc_hid_event_destroy(&hid_event);
        LOGW("Could request HID event");
        return false;
    }
    LOGD("HID keyboard state synchronized");
    return true;
 }
 static void
 sc_key_processor_process_key(struct sc_key_processor *kp,
                             const SDL_KeyboardEvent *event) {
    if (event->repeat) {
        // In USB HID protocol, key repeat is handled by the host (Android), so
        // just ignore key repeat here.
        return;
    }
    struct sc_hid_keyboard *kb = DOWNCAST(kp);
    struct sc_hid_event hid_event;
    // Not all keys are supported, just ignore unsupported keys
    if (convert_hid_keyboard_event(kb, &hid_event, event)) {
        if (!kb->mod_lock_synchronized) {
            // Inject CAPSLOCK and/or NUMLOCK if necessary to synchronize
            // keyboard state
            if (push_mod_lock_state(kb, event->keysym.mod)) {
                kb->mod_lock_synchronized = true;
            }
        }
        SDL_Keycode keycode = event->keysym.sym;
        bool down = event->type == SDL_KEYDOWN;
        bool ctrl = event->keysym.mod & KMOD_CTRL;
        bool shift = event->keysym.mod & KMOD_SHIFT;
        if (ctrl && !shift && keycode == SDLK_v && down) {
            // Ctrl+v is pressed, so clipboard synchronization has been
            // requested. Wait a bit so that the clipboard is set before
            // injecting Ctrl+v via HID, otherwise it would paste the old
            // clipboard content.
            hid_event.delay = SC_TICK_FROM_MS(2);
        }
        if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
            sc_hid_event_destroy(&hid_event);
            LOGW("Could request HID event");
        }
    }
 }
 static void
 sc_key_processor_process_text(struct sc_key_processor *kp,
                              const SDL_TextInputEvent *event) {
    (void) kp;
    (void) event;
    // Never forward text input via HID (all the keys are injected separately)
 }
 bool
 sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa) {
    kb->aoa = aoa;
    bool ok = sc_aoa_setup_hid(aoa, HID_KEYBOARD_ACCESSORY_ID,
                               keyboard_report_desc,
                               ARRAY_LEN(keyboard_report_desc));
    if (!ok) {
        LOGW("Register HID keyboard failed");
        return false;
    }
    // Reset all states
    memset(kb->keys, false, SC_HID_KEYBOARD_KEYS);
    kb->mod_lock_synchronized = false;
    static const struct sc_key_processor_ops ops = {
        .process_key = sc_key_processor_process_key,
        .process_text = sc_key_processor_process_text,
    };
    kb->key_processor.ops = &ops;
    return true;
 }
 void
 sc_hid_keyboard_destroy(struct sc_hid_keyboard *kb) {
    // Unregister HID keyboard so the soft keyboard shows again on Android
    bool ok = sc_aoa_unregister_hid(kb->aoa, HID_KEYBOARD_ACCESSORY_ID);
    if (!ok) {
        LOGW("Could not unregister HID keyboard");
    }
 }
--- a/app/src/hid_keyboard.h
+++ b/app/src/hid_keyboard.h
@@ -1,44 +0,0 @@
 #ifndef SC_HID_KEYBOARD_H
 #define SC_HID_KEYBOARD_H
 #include "common.h"
 #include <stdbool.h>
 #include "aoa_hid.h"
 #include "trait/key_processor.h"
 // See "SDL2/SDL_scancode.h".
 // Maybe SDL_Keycode is used by most people, but SDL_Scancode is taken from USB
 // HID protocol.
 // 0x65 is Application, typically AT-101 Keyboard ends here.
 #define SC_HID_KEYBOARD_KEYS 0x66
 /**
 * HID keyboard events are sequence-based, every time keyboard state changes
 * it sends an array of currently pressed keys, the host is responsible for
 * compare events and determine which key becomes pressed and which key becomes
 * released. In order to convert SDL_KeyboardEvent to HID events, we first use
 * an array of keys to save each keys' state. And when a SDL_KeyboardEvent was
 * emitted, we updated our state, and then we use a loop to generate HID
 * events. The sequence of array elements is unimportant and when too much keys
 * pressed at the same time (more than report count), we should generate
 * phantom state. Don't forget that modifiers should be updated too, even for
 * phantom state.
 */
 struct sc_hid_keyboard {
    struct sc_key_processor key_processor; // key processor trait
    struct sc_aoa *aoa;
    bool keys[SC_HID_KEYBOARD_KEYS];
    bool mod_lock_synchronized;
 };
 bool
 sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa);
 void
 sc_hid_keyboard_destroy(struct sc_hid_keyboard *kb);
 #endif
--- a/app/src/icon.c
+++ b/app/src/icon.c
@@ -1,282 +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/log.h"
 #include "util/process.h"
 #include "util/str_util.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 = utf8_from_wide_char(icon_path_env);
 #else
        char *icon_path = strdup(icon_path_env);
 #endif
        if (!icon_path) {
            LOGE("Could not allocate memory");
            return NULL;
        }
        LOGD("Using SCRCPY_ICON_PATH: %s", icon_path);
        return icon_path;
    }
 #ifndef PORTABLE
    LOGD("Using icon: " SCRCPY_DEFAULT_ICON_PATH);
    char *icon_path = strdup(SCRCPY_DEFAULT_ICON_PATH);
    if (!icon_path) {
        LOGE("Could not allocate memory");
        return NULL;
    }
 #else
    char *icon_path = get_local_file_path(SCRCPY_PORTABLE_ICON_FILENAME);
    if (!icon_path) {
        LOGE("Could not get icon path");
        return NULL;
    }
    LOGD("Using icon (portable): %s", icon_path);
 #endif
    return icon_path;
 }
 static AVFrame *
 decode_image(const char *path) {
    AVFrame *result = NULL;
    AVFormatContext *ctx = avformat_alloc_context();
    if (!ctx) {
        LOGE("Could not allocate image decoder context");
        return NULL;
    }
    if (avformat_open_input(&ctx, path, NULL, NULL) < 0) {
        LOGE("Could not open image codec: %s", path);
        goto free_ctx;
    }
    if (avformat_find_stream_info(ctx, NULL) < 0) {
        LOGE("Could not find image stream info");
        goto close_input;
    }
    int stream = av_find_best_stream(ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    if (stream < 0 ) {
        LOGE("Could not find best image stream");
        goto close_input;
    }
    AVCodecParameters *params = ctx->streams[stream]->codecpar;
    AVCodec *codec = avcodec_find_decoder(params->codec_id);
    if (!codec) {
        LOGE("Could not find image decoder");
        goto close_input;
    }
    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
        LOGE("Could not allocate codec context");
        goto close_input;
    }
    if (avcodec_parameters_to_context(codec_ctx, params) < 0) {
        LOGE("Could not fill codec context");
        goto free_codec_ctx;
    }
    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
        LOGE("Could not open image codec");
        goto free_codec_ctx;
    }
    AVFrame *frame = av_frame_alloc();
    if (!frame) {
        LOGE("Could not allocate frame");
        goto close_codec;
    }
    AVPacket *packet = av_packet_alloc();
    if (!packet) {
        LOGE("Could not allocate packet");
        av_frame_free(&frame);
        goto close_codec;
    }
    if (av_read_frame(ctx, packet) < 0) {
        LOGE("Could not read frame");
        av_packet_free(&packet);
        av_frame_free(&frame);
        goto close_codec;
    }
    int ret;
    if ((ret = avcodec_send_packet(codec_ctx, packet)) < 0) {
        LOGE("Could not send icon packet: %d", ret);
        av_packet_free(&packet);
        av_frame_free(&frame);
        goto close_codec;
    }
    if ((ret = avcodec_receive_frame(codec_ctx, frame)) != 0) {
        LOGE("Could not receive icon frame: %d", ret);
        av_packet_free(&packet);
        av_frame_free(&frame);
        goto close_codec;
    }
    av_packet_free(&packet);
    result = frame;
 close_codec:
    avcodec_close(codec_ctx);
 free_codec_ctx:
    avcodec_free_context(&codec_ctx);
 close_input:
    avformat_close_input(&ctx);
 free_ctx:
    avformat_free_context(ctx);
    return result;
 }
 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;
        case AV_PIX_FMT_BGR444BE: return SDL_PIXELFORMAT_BGR444;
        case AV_PIX_FMT_PAL8: return SDL_PIXELFORMAT_INDEX8;
        default: return SDL_PIXELFORMAT_UNKNOWN;
    }
 }
 static SDL_Surface *
 load_from_path(const char *path) {
    AVFrame *frame = decode_image(path);
    if (!frame) {
        return NULL;
    }
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
    if (!desc) {
        LOGE("Could not get icon format descriptor");
        goto error;
    }
    bool is_packed = !(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
    if (!is_packed) {
        LOGE("Could not load non-packed icon");
        goto error;
    }
    SDL_PixelFormatEnum format = to_sdl_pixel_format(frame->format);
    if (format == SDL_PIXELFORMAT_UNKNOWN) {
        LOGE("Unsupported icon pixel format: %s (%d)", desc->name,
                                                       frame->format);
        goto error;
    }
    int bits_per_pixel = av_get_bits_per_pixel(desc);
    SDL_Surface *surface =
        SDL_CreateRGBSurfaceWithFormatFrom(frame->data[0],
                                           frame->width, frame->height,
                                           bits_per_pixel,
                                           frame->linesize[0],
                                           format);
    if (!surface) {
        LOGE("Could not create icon surface");
        goto error;
    }
    if (frame->format == AV_PIX_FMT_PAL8) {
        // Initialize the SDL palette
        uint8_t *data = frame->data[1];
        SDL_Color colors[256];
        for (int i = 0; i < 256; ++i) {
            SDL_Color *color = &colors[i];
            // The palette is transported in AVFrame.data[1], is 1024 bytes
            // long (256 4-byte entries) and is formatted the same as in
            // AV_PIX_FMT_RGB32 described above (i.e., it is also
            // endian-specific).
            // <https://ffmpeg.org/doxygen/4.1/pixfmt_8h.html#a9a8e335cf3be472042bc9f0cf80cd4c5>
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
            color->a = data[i * 4];
            color->r = data[i * 4 + 1];
            color->g = data[i * 4 + 2];
            color->b = data[i * 4 + 3];
 #else
            color->a = data[i * 4 + 3];
            color->r = data[i * 4 + 2];
            color->g = data[i * 4 + 1];
            color->b = data[i * 4];
 #endif
        }
        SDL_Palette *palette = surface->format->palette;
        assert(palette);
        int ret = SDL_SetPaletteColors(palette, colors, 0, 256);
        if (ret) {
            LOGE("Could not set palette colors");
            SDL_FreeSurface(surface);
            goto error;
        }
    }
    surface->userdata = frame; // frame owns the data
    return surface;
 error:
    av_frame_free(&frame);
    return NULL;
 }
 SDL_Surface *
 scrcpy_icon_load() {
    char *icon_path = get_icon_path();
    if (!icon_path) {
        return NULL;
    }
    SDL_Surface *icon = load_from_path(icon_path);
    free(icon_path);
    return icon;
 }
 void
 scrcpy_icon_destroy(SDL_Surface *icon) {
    AVFrame *frame = icon->userdata;
    assert(frame);
    av_frame_free(&frame);
    SDL_FreeSurface(icon);
 }
--- a/app/src/icon.h
+++ b/app/src/icon.h
@@ -1,16 +0,0 @@
 #ifndef ICON_H
 #define ICON_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL.h>
 #include <libavformat/avformat.h>
 SDL_Surface *
 scrcpy_icon_load(void);
 void
 scrcpy_icon_destroy(SDL_Surface *icon);
 #endif
--- a/app/src/icon.xpm
+++ b/app/src/icon.xpm
@@ -0,0 +1,53 @@
 /* XPM */
 static char * icon_xpm[] = {
 "48 48 2 1",
 " 	c None",
 ".	c #96C13E",
 "              ..                ..              ",
 "              ...              ...              ",
 "               ...   ......   ...               ",
 "                ................                ",
 "                 ..............                 ",
 "                ................                ",
 "               ..................               ",
 "              ....................              ",
 "             .....  ........  .....             ",
 "             .....  ........  .....             ",
 "             ......................             ",
 "            ........................            ",
 "            ........................            ",
 "            ........................            ",
 "                                                ",
 "                                                ",
 "     ....   ........................   ....     ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "     ....   ........................   ....     ",
 "            ........................            ",
 "             ......................             ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                 ....      ....                 "};
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@@ -3,6 +3,7 @@
 #include <assert.h>
 #include <SDL2/SDL_keycode.h>
 #include "event_converter.h"
 #include "util/log.h"
 static const int ACTION_DOWN = 1;
@@ -51,19 +52,12 @@ is_shortcut_mod(struct input_manager *im, uint16_t sdl_mod) {
 }
 void
-input_manager_init(struct input_manager *im, struct controller *controller,
+input_manager_init(struct input_manager *im,
-                   struct screen *screen, struct sc_key_processor *kp,
+                   const struct scrcpy_options *options)
-                   struct sc_mouse_processor *mp,
+{
                   const struct scrcpy_options *options) {
    assert(!options->control || (kp && kp->ops));
    assert(!options->control || (mp && mp->ops));
    im->controller = controller;
    im->screen = screen;
    im->kp = kp;
    im->mp = mp;
    im->control = options->control;
    im->forward_key_repeat = options->forward_key_repeat;
    im->prefer_text = options->prefer_text;
    im->forward_all_clicks = options->forward_all_clicks;
    im->legacy_paste = options->legacy_paste;
@@ -78,10 +72,6 @@ input_manager_init(struct input_manager *im, struct controller *controller,
    im->sdl_shortcut_mods.count = shortcut_mods->count;
    im->vfinger_down = false;
    im->last_keycode = SDLK_UNKNOWN;
    im->last_mod = 0;
    im->key_repeat = 0;
 }
 static void
@@ -156,25 +146,13 @@ action_cut(struct controller *controller, int actions) {
 }
 // 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, int actions) {
+press_back_or_turn_screen_on(struct controller *controller) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
-    if (actions & ACTION_DOWN) {
+    if (!controller_push_msg(controller, &msg)) {
-        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_DOWN;
+        LOGW("Could not request 'press back or turn screen on'");
        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'");
        }
    }
 }
@@ -189,19 +167,9 @@ expand_notification_panel(struct controller *controller) {
 }
 static void
-expand_settings_panel(struct controller *controller) {
+collapse_notification_panel(struct controller *controller) {
    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
+    msg.type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL;
    if (!controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'expand settings panel'");
    }
 }
 static void
 collapse_panels(struct controller *controller) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_COLLAPSE_PANELS;
    if (!controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'collapse notification panel'");
@@ -325,14 +293,32 @@ input_manager_process_text_input(struct input_manager *im,
        // A shortcut must never generate text events
        return;
    }
    if (!im->prefer_text) {
        char c = event->text[0];
        if (isalpha(c) || c == ' ') {
            assert(event->text[1] == '\0');
            // letters and space are handled as raw key event
            return;
        }
    }
-    im->kp->ops->process_text(im->kp, event);
+    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
    msg.inject_text.text = strdup(event->text);
    if (!msg.inject_text.text) {
        LOGW("Could not strdup input text");
        return;
    }
    if (!controller_push_msg(im->controller, &msg)) {
        free(msg.inject_text.text);
        LOGW("Could not request 'inject text'");
    }
 }
 static bool
 simulate_virtual_finger(struct input_manager *im,
                        enum android_motionevent_action action,
-                        struct sc_point point) {
+                        struct point point) {
    bool up = action == AMOTION_EVENT_ACTION_UP;
    struct control_msg msg;
@@ -352,40 +338,50 @@ 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) {
    // control: indicates the state of the command-line option --no-control
    bool control = im->control;
    bool smod = is_shortcut_mod(im, event->keysym.mod);
    struct controller *controller = im->controller;
    SDL_Keycode keycode = event->keysym.sym;
    uint16_t mod = event->keysym.mod;
    bool down = event->type == SDL_KEYDOWN;
    bool ctrl = event->keysym.mod & KMOD_CTRL;
    bool shift = event->keysym.mod & KMOD_SHIFT;
    bool repeat = event->repeat;
    bool smod = is_shortcut_mod(im, mod);
    if (down && !repeat) {
        if (keycode == im->last_keycode && mod == im->last_mod) {
            ++im->key_repeat;
        } else {
            im->key_repeat = 0;
            im->last_keycode = keycode;
            im->last_mod = mod;
        }
    }
    // The shortcut modifier is pressed
    if (smod) {
        int action = down ? ACTION_DOWN : ACTION_UP;
@@ -484,17 +480,15 @@ input_manager_process_key(struct input_manager *im,
                return;
            case SDLK_i:
                if (!shift && !repeat && down) {
-                    switch_fps_counter_state(&im->screen->fps_counter);
+                    switch_fps_counter_state(im->fps_counter);
                }
                return;
            case SDLK_n:
                if (control && !repeat && down) {
                    if (shift) {
-                        collapse_panels(controller);
+                        collapse_notification_panel(controller);
                    } else if (im->key_repeat == 0) {
                        expand_notification_panel(controller);
                    } else {
-                        expand_settings_panel(controller);
+                        expand_notification_panel(controller);
                    }
                }
                return;
@@ -512,6 +506,15 @@ input_manager_process_key(struct input_manager *im,
        return;
    }
    if (event->repeat) {
        if (!im->forward_key_repeat) {
            return;
        }
        ++im->repeat;
    } else {
        im->repeat = 0;
    }
    if (ctrl && !shift && keycode == SDLK_v && down && !repeat) {
        if (im->legacy_paste) {
            // inject the text as input events
@@ -523,40 +526,113 @@ input_manager_process_key(struct input_manager *im,
        set_device_clipboard(controller, false);
    }
-    im->kp->ops->process_key(im->kp, event);
+    struct control_msg msg;
    if (convert_input_key(event, &msg, im->prefer_text, im->repeat)) {
        if (!controller_push_msg(controller, &msg)) {
            LOGW("Could not request 'inject keycode'");
        }
    }
 }
 static bool
 convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
                     struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
    to->inject_touch_event.position.screen_size = screen->frame_size;
    to->inject_touch_event.position.point =
        screen_convert_window_to_frame_coords(screen, from->x, from->y);
    to->inject_touch_event.pressure = 1.f;
    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
    return true;
 }
 static void
 input_manager_process_mouse_motion(struct input_manager *im,
                                   const SDL_MouseMotionEvent *event) {
-    uint32_t mask = SDL_BUTTON_LMASK;
+    if (!event->state) {
-    if (im->forward_all_clicks) {
+        // do not send motion events when no button is pressed
        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;
    }
-    im->mp->ops->process_mouse_motion(im->mp, event);
+    if (!controller_push_msg(im->controller, &msg)) {
        LOGW("Could not request 'inject mouse motion event'");
    }
    if (im->vfinger_down) {
-        struct sc_point mouse =
+        struct point mouse = msg.inject_touch_event.position.point;
-            screen_convert_window_to_frame_coords(im->screen, event->x,
+        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
                                                  event->y);
        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
        simulate_virtual_finger(im, AMOTION_EVENT_ACTION_MOVE, vfinger);
    }
 }
 static bool
 convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
              struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
    if (!convert_touch_action(from->type, &to->inject_touch_event.action)) {
        return false;
    }
    to->inject_touch_event.pointer_id = from->fingerId;
    to->inject_touch_event.position.screen_size = screen->frame_size;
    int dw;
    int dh;
    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
    // SDL touch event coordinates are normalized in the range [0; 1]
    int32_t x = from->x * dw;
    int32_t y = from->y * dh;
    to->inject_touch_event.position.point =
        screen_convert_drawable_to_frame_coords(screen, x, y);
    to->inject_touch_event.pressure = from->pressure;
    to->inject_touch_event.buttons = 0;
    return true;
 }
 static void
 input_manager_process_touch(struct input_manager *im,
                            const SDL_TouchFingerEvent *event) {
-    im->mp->ops->process_touch(im->mp, event);
+    struct control_msg msg;
    if (convert_touch(event, im->screen, &msg)) {
        if (!controller_push_msg(im->controller, &msg)) {
            LOGW("Could not request 'inject touch event'");
        }
    }
 }
 static bool
 convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
                     struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
        return false;
    }
    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
    to->inject_touch_event.position.screen_size = screen->frame_size;
    to->inject_touch_event.position.point =
        screen_convert_window_to_frame_coords(screen, from->x, from->y);
    to->inject_touch_event.pressure =
        from->type == SDL_MOUSEBUTTONDOWN ? 1.f : 0.f;
    to->inject_touch_event.buttons =
        convert_mouse_buttons(SDL_BUTTON(from->button));
    return true;
 }
 static void
@@ -570,27 +646,13 @@ input_manager_process_mouse_button(struct input_manager *im,
    }
    bool down = event->type == SDL_MOUSEBUTTONDOWN;
-    if (!im->forward_all_clicks) {
+    if (!im->forward_all_clicks && down) {
        int action = down ? ACTION_DOWN : ACTION_UP;
        if (control && event->button == SDL_BUTTON_X1) {
            action_app_switch(im->controller, action);
            return;
        }
        if (control && event->button == SDL_BUTTON_X2 && down) {
            if (event->clicks < 2) {
                expand_notification_panel(im->controller);
            } else {
                expand_settings_panel(im->controller);
            }
            return;
        }
        if (control && event->button == SDL_BUTTON_RIGHT) {
-            press_back_or_turn_screen_on(im->controller, action);
+            press_back_or_turn_screen_on(im->controller);
            return;
        }
        if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, action);
+            action_home(im->controller, ACTION_DOWN | ACTION_UP);
            return;
        }
@@ -603,9 +665,7 @@ input_manager_process_mouse_button(struct input_manager *im,
            bool outside = x < r->x || x >= r->x + r->w
                        || y < r->y || y >= r->y + r->h;
            if (outside) {
-                if (down) {
+                screen_resize_to_fit(im->screen);
                    screen_resize_to_fit(im->screen);
                }
                return;
            }
        }
@@ -616,7 +676,15 @@ input_manager_process_mouse_button(struct input_manager *im,
        return;
    }
-    im->mp->ops->process_mouse_button(im->mp, event);
+    struct control_msg msg;
    if (!convert_mouse_button(event, im->screen, &msg)) {
        return;
    }
    if (!controller_push_msg(im->controller, &msg)) {
        LOGW("Could not request 'inject mouse button event'");
        return;
    }
    // Pinch-to-zoom simulation.
    //
@@ -630,10 +698,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;
@@ -644,10 +710,39 @@ input_manager_process_mouse_button(struct input_manager *im,
    }
 }
 static bool
 convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
                    struct control_msg *to) {
    // mouse_x and mouse_y are expressed in pixels relative to the window
    int mouse_x;
    int mouse_y;
    SDL_GetMouseState(&mouse_x, &mouse_y);
    struct position position = {
        .screen_size = screen->frame_size,
        .point = screen_convert_window_to_frame_coords(screen,
                                                       mouse_x, mouse_y),
    };
    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
    to->inject_scroll_event.position = position;
    to->inject_scroll_event.hscroll = from->x;
    to->inject_scroll_event.vscroll = from->y;
    return true;
 }
 static void
 input_manager_process_mouse_wheel(struct input_manager *im,
                                  const SDL_MouseWheelEvent *event) {
-    im->mp->ops->process_mouse_wheel(im->mp, event);
+    struct control_msg msg;
    if (convert_mouse_wheel(event, im->screen, &msg)) {
        if (!controller_push_msg(im->controller, &msg)) {
            LOGW("Could not request 'inject mouse wheel event'");
        }
    }
 }
 bool
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@@ -9,19 +9,21 @@
 #include "controller.h"
 #include "fps_counter.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "screen.h"
 #include "trait/key_processor.h"
 #include "trait/mouse_processor.h"
 struct input_manager {
    struct controller *controller;
    struct fps_counter *fps_counter;
    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;
@@ -31,19 +33,10 @@ struct input_manager {
    } sdl_shortcut_mods;
    bool vfinger_down;
    // Tracks the number of identical consecutive shortcut key down events.
    // Not to be confused with event->repeat, which counts the number of
    // system-generated repeated key presses.
    unsigned key_repeat;
    SDL_Keycode last_keycode;
    uint16_t last_mod;
 };
 void
-input_manager_init(struct input_manager *im, struct controller *controller,
+input_manager_init(struct input_manager *im,
                   struct screen *screen, struct sc_key_processor *kp,
                   struct sc_mouse_processor *mp,
                   const struct scrcpy_options *options);
 bool
--- a/app/src/keyboard_inject.h
+++ b/app/src/keyboard_inject.h
@@ -1,30 +0,0 @@
 #ifndef SC_KEYBOARD_INJECT_H
 #define SC_KEYBOARD_INJECT_H
 #include "common.h"
 #include <stdbool.h>
 #include "controller.h"
 #include "options.h"
 #include "trait/key_processor.h"
 struct sc_keyboard_inject {
    struct sc_key_processor key_processor; // key processor trait
    struct controller *controller;
    // SDL reports repeated events as a boolean, but Android expects the actual
    // number of repetitions. This variable keeps track of the count.
    unsigned repeat;
    bool prefer_text;
    bool forward_key_repeat;
 };
 void
 sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
                        struct controller *controller,
                        const struct scrcpy_options *options);
 #endif
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -1,18 +1,15 @@
 #include "scrcpy.h"
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
 #include <unistd.h>
 #include <libavformat/avformat.h>
 #ifdef HAVE_V4L2
 # include <libavdevice/avdevice.h>
 #endif
 #define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
 #include <SDL2/SDL.h>
 #include "cli.h"
 #include "options.h"
 #include "scrcpy.h"
 #include "util/log.h"
 static void
@@ -31,13 +28,26 @@ print_version(void) {
    fprintf(stderr, " - libavutil %d.%d.%d\n", LIBAVUTIL_VERSION_MAJOR,
                                               LIBAVUTIL_VERSION_MINOR,
                                               LIBAVUTIL_VERSION_MICRO);
 #ifdef HAVE_V4L2
    fprintf(stderr, " - libavdevice %d.%d.%d\n", LIBAVDEVICE_VERSION_MAJOR,
                                                 LIBAVDEVICE_VERSION_MINOR,
                                                 LIBAVDEVICE_VERSION_MICRO);
 #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__
@@ -48,7 +58,7 @@ main(int argc, char *argv[]) {
 #endif
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
@@ -61,7 +71,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]);
@@ -79,12 +90,6 @@ main(int argc, char *argv[]) {
    av_register_all();
 #endif
 #ifdef HAVE_V4L2
    if (args.opts.v4l2_device) {
        avdevice_register_all();
    }
 #endif
    if (avformat_network_init()) {
        return 1;
    }
--- a/app/src/mouse_inject.c
+++ b/app/src/mouse_inject.c
@@ -1,211 +0,0 @@
 #include "mouse_inject.h"
 #include <assert.h>
 #include <SDL2/SDL_events.h>
 #include "android/input.h"
 #include "control_msg.h"
 #include "controller.h"
 #include "util/log.h"
 /** Downcast mouse processor to sc_mouse_inject */
 #define DOWNCAST(MP) container_of(MP, struct sc_mouse_inject, mouse_processor)
 static enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state) {
    enum android_motionevent_buttons buttons = 0;
    if (state & SDL_BUTTON_LMASK) {
        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
    }
    if (state & SDL_BUTTON_RMASK) {
        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
    }
    if (state & SDL_BUTTON_MMASK) {
        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
    }
    if (state & SDL_BUTTON_X1MASK) {
        buttons |= AMOTION_EVENT_BUTTON_BACK;
    }
    if (state & SDL_BUTTON_X2MASK) {
        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
    }
    return buttons;
 }
 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false
 static bool
 convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
    switch (from) {
        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
        FAIL;
    }
 }
 static bool
 convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
    switch (from) {
        MAP(SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE);
        MAP(SDL_FINGERDOWN,   AMOTION_EVENT_ACTION_DOWN);
        MAP(SDL_FINGERUP,     AMOTION_EVENT_ACTION_UP);
        FAIL;
    }
 }
 static bool
 convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
                     struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
    to->inject_touch_event.position.screen_size = screen->frame_size;
    to->inject_touch_event.position.point =
        screen_convert_window_to_frame_coords(screen, from->x, from->y);
    to->inject_touch_event.pressure = 1.f;
    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
    return true;
 }
 static bool
 convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
              struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
    if (!convert_touch_action(from->type, &to->inject_touch_event.action)) {
        return false;
    }
    to->inject_touch_event.pointer_id = from->fingerId;
    to->inject_touch_event.position.screen_size = screen->frame_size;
    int dw;
    int dh;
    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
    // SDL touch event coordinates are normalized in the range [0; 1]
    int32_t x = from->x * dw;
    int32_t y = from->y * dh;
    to->inject_touch_event.position.point =
        screen_convert_drawable_to_frame_coords(screen, x, y);
    to->inject_touch_event.pressure = from->pressure;
    to->inject_touch_event.buttons = 0;
    return true;
 }
 static bool
 convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
                     struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
        return false;
    }
    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
    to->inject_touch_event.position.screen_size = screen->frame_size;
    to->inject_touch_event.position.point =
        screen_convert_window_to_frame_coords(screen, from->x, from->y);
    to->inject_touch_event.pressure =
        from->type == SDL_MOUSEBUTTONDOWN ? 1.f : 0.f;
    to->inject_touch_event.buttons =
        convert_mouse_buttons(SDL_BUTTON(from->button));
    return true;
 }
 static bool
 convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
                    struct control_msg *to) {
    // mouse_x and mouse_y are expressed in pixels relative to the window
    int mouse_x;
    int mouse_y;
    SDL_GetMouseState(&mouse_x, &mouse_y);
    struct sc_position position = {
        .screen_size = screen->frame_size,
        .point = screen_convert_window_to_frame_coords(screen,
                                                       mouse_x, mouse_y),
    };
    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
    to->inject_scroll_event.position = position;
    to->inject_scroll_event.hscroll = from->x;
    to->inject_scroll_event.vscroll = from->y;
    return true;
 }
 static void
 sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
                                        const SDL_MouseMotionEvent *event) {
    struct sc_mouse_inject *mi = DOWNCAST(mp);
    struct control_msg msg;
    if (!convert_mouse_motion(event, mi->screen, &msg)) {
        return;
    }
    if (!controller_push_msg(mi->controller, &msg)) {
        LOGW("Could not request 'inject mouse motion event'");
    }
 }
 static void
 sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
                                 const SDL_TouchFingerEvent *event) {
    struct sc_mouse_inject *mi = DOWNCAST(mp);
    struct control_msg msg;
    if (convert_touch(event, mi->screen, &msg)) {
        if (!controller_push_msg(mi->controller, &msg)) {
            LOGW("Could not request 'inject touch event'");
        }
    }
 }
 static void
 sc_mouse_processor_process_mouse_button(struct sc_mouse_processor *mp,
                                        const SDL_MouseButtonEvent *event) {
    struct sc_mouse_inject *mi = DOWNCAST(mp);
    struct control_msg msg;
    if (convert_mouse_button(event, mi->screen, &msg)) {
        if (!controller_push_msg(mi->controller, &msg)) {
            LOGW("Could not request 'inject mouse button event'");
        }
    }
 }
 static void
 sc_mouse_processor_process_mouse_wheel(struct sc_mouse_processor *mp,
                                       const SDL_MouseWheelEvent *event) {
    struct sc_mouse_inject *mi = DOWNCAST(mp);
    struct control_msg msg;
    if (convert_mouse_wheel(event, mi->screen, &msg)) {
        if (!controller_push_msg(mi->controller, &msg)) {
            LOGW("Could not request 'inject mouse wheel event'");
        }
    }
 }
 void
 sc_mouse_inject_init(struct sc_mouse_inject *mi, struct controller *controller,
                     struct screen *screen) {
    mi->controller = controller;
    mi->screen = screen;
    static const struct sc_mouse_processor_ops ops = {
        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
        .process_touch = sc_mouse_processor_process_touch,
        .process_mouse_button = sc_mouse_processor_process_mouse_button,
        .process_mouse_wheel = sc_mouse_processor_process_mouse_wheel,
    };
    mi->mouse_processor.ops = &ops;
 }
--- a/app/src/mouse_inject.h
+++ b/app/src/mouse_inject.h
@@ -1,23 +0,0 @@
 #ifndef SC_MOUSE_INJECT_H
 #define SC_MOUSE_INJECT_H
 #include "common.h"
 #include <stdbool.h>
 #include "controller.h"
 #include "screen.h"
 #include "trait/mouse_processor.h"
 struct sc_mouse_inject {
    struct sc_mouse_processor mouse_processor; // mouse processor trait
    struct controller *controller;
    struct screen *screen;
 };
 void
 sc_mouse_inject_init(struct sc_mouse_inject *mi, struct controller *controller,
                     struct screen *screen);
 #endif
--- a/app/src/options.c
+++ b/app/src/options.c
@@ -1,54 +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,
    },
    .shortcut_mods = {
        .data = {SC_MOD_LALT, SC_MOD_LSUPER},
        .count = 2,
    },
    .max_size = 0,
    .bit_rate = DEFAULT_BIT_RATE,
    .max_fps = 0,
    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
    .rotation = 0,
    .window_x = SC_WINDOW_POSITION_UNDEFINED,
    .window_y = SC_WINDOW_POSITION_UNDEFINED,
    .window_width = 0,
    .window_height = 0,
    .display_id = 0,
    .display_buffer = 0,
    .v4l2_buffer = 0,
    .show_touches = false,
    .fullscreen = false,
    .always_on_top = false,
    .control = true,
    .display = true,
    .turn_screen_off = false,
    .prefer_text = false,
    .window_borderless = false,
    .mipmaps = true,
    .stay_awake = false,
    .force_adb_forward = false,
    .disable_screensaver = false,
    .forward_key_repeat = true,
    .forward_all_clicks = false,
    .legacy_paste = false,
    .power_off_on_close = false,
 };
--- a/app/src/options.h
+++ b/app/src/options.h
@@ -1,113 +0,0 @@
 #ifndef SCRCPY_OPTIONS_H
 #define SCRCPY_OPTIONS_H
 #include "common.h"
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include "util/tick.h"
 enum sc_log_level {
    SC_LOG_LEVEL_VERBOSE,
    SC_LOG_LEVEL_DEBUG,
    SC_LOG_LEVEL_INFO,
    SC_LOG_LEVEL_WARN,
    SC_LOG_LEVEL_ERROR,
 };
 enum sc_record_format {
    SC_RECORD_FORMAT_AUTO,
    SC_RECORD_FORMAT_MP4,
    SC_RECORD_FORMAT_MKV,
 };
 enum sc_lock_video_orientation {
    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
    // lock the current orientation when scrcpy starts
    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
    SC_LOCK_VIDEO_ORIENTATION_1,
    SC_LOCK_VIDEO_ORIENTATION_2,
    SC_LOCK_VIDEO_ORIENTATION_3,
 };
 enum sc_keyboard_input_mode {
    SC_KEYBOARD_INPUT_MODE_INJECT,
    SC_KEYBOARD_INPUT_MODE_HID,
 };
 #define SC_MAX_SHORTCUT_MODS 8
 enum sc_shortcut_mod {
    SC_MOD_LCTRL = 1 << 0,
    SC_MOD_RCTRL = 1 << 1,
    SC_MOD_LALT = 1 << 2,
    SC_MOD_RALT = 1 << 3,
    SC_MOD_LSUPER = 1 << 4,
    SC_MOD_RSUPER = 1 << 5,
 };
 struct sc_shortcut_mods {
    unsigned data[SC_MAX_SHORTCUT_MODS];
    unsigned count;
 };
 struct sc_port_range {
    uint16_t first;
    uint16_t last;
 };
 #define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
 struct scrcpy_options {
    const char *serial;
    const char *crop;
    const char *record_filename;
    const char *window_title;
    const char *push_target;
    const char *render_driver;
    const char *codec_options;
    const char *encoder_name;
 #ifdef HAVE_V4L2
    const char *v4l2_device;
 #endif
    enum sc_log_level log_level;
    enum sc_record_format record_format;
    enum sc_keyboard_input_mode keyboard_input_mode;
    struct sc_port_range port_range;
    struct sc_shortcut_mods shortcut_mods;
    uint16_t max_size;
    uint32_t bit_rate;
    uint16_t max_fps;
    enum sc_lock_video_orientation lock_video_orientation;
    uint8_t rotation;
    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    uint16_t window_width;
    uint16_t window_height;
    uint32_t display_id;
    sc_tick display_buffer;
    sc_tick v4l2_buffer;
    bool show_touches;
    bool fullscreen;
    bool always_on_top;
    bool control;
    bool display;
    bool turn_screen_off;
    bool prefer_text;
    bool window_borderless;
    bool mipmaps;
    bool stay_awake;
    bool force_adb_forward;
    bool disable_screensaver;
    bool forward_key_repeat;
    bool forward_all_clicks;
    bool legacy_paste;
    bool power_off_on_close;
 };
 extern const struct scrcpy_options scrcpy_options_default;
 #endif
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@@ -7,7 +7,7 @@
 #include "util/log.h"
 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket) {
+receiver_init(struct receiver *receiver, socket_t control_socket) {
    bool ok = sc_mutex_init(&receiver->mutex);
    if (!ok) {
        return false;
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@@ -11,13 +11,13 @@
 // 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;
 };
 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket);
+receiver_init(struct receiver *receiver, socket_t control_socket);
 void
 receiver_destroy(struct receiver *receiver);
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@@ -1,12 +1,9 @@
 #include "recorder.h"
 #include <assert.h>
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
 #include "util/log.h"
 #include "util/str_util.h"
 /** Downcast packet_sink to recorder */
 #define DOWNCAST(SINK) container_of(SINK, struct recorder, packet_sink)
@@ -25,8 +22,8 @@ find_muxer(const char *name) {
 #else
        oformat = av_oformat_next(oformat);
 #endif
-        // until null or containing the requested name
+        // until null or with name "mp4"
-    } while (oformat && !strlist_contains(oformat->name, ',', name));
+    } while (oformat && strcmp(oformat->name, name));
    return oformat;
 }
@@ -37,14 +34,11 @@ record_packet_new(const AVPacket *packet) {
        return NULL;
    }
-    rec->packet = av_packet_alloc();
+    // av_packet_ref() does not initialize all fields in old FFmpeg versions
-    if (!rec->packet) {
+    // See <https://github.com/Genymobile/scrcpy/issues/707>
-        free(rec);
+    av_init_packet(&rec->packet);
        return NULL;
    }
-    if (av_packet_ref(rec->packet, packet)) {
+    if (av_packet_ref(&rec->packet, packet)) {
        av_packet_free(&rec->packet);
        free(rec);
        return NULL;
    }
@@ -53,15 +47,15 @@ record_packet_new(const AVPacket *packet) {
 static void
 record_packet_delete(struct record_packet *rec) {
-    av_packet_free(&rec->packet);
+    av_packet_unref(&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);
    }
 }
@@ -137,20 +131,20 @@ 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) {
                // assign an arbitrary duration to the last packet
-                last->packet->duration = 100000;
+                last->packet.duration = 100000;
-                bool ok = recorder_write(recorder, last->packet);
+                bool ok = recorder_write(recorder, &last->packet);
                if (!ok) {
                    // failing to write the last frame is not very serious, no
                    // future frame may depend on it, so the resulting file
@@ -163,7 +157,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);
@@ -177,14 +171,13 @@ run_recorder(void *data) {
        }
        // config packets have no PTS, we must ignore them
-        if (rec->packet->pts != AV_NOPTS_VALUE
+        if (rec->packet.pts != AV_NOPTS_VALUE
-            && previous->packet->pts != AV_NOPTS_VALUE) {
+            && previous->packet.pts != AV_NOPTS_VALUE) {
            // we now know the duration of the previous packet
-            previous->packet->duration =
+            previous->packet.duration = rec->packet.pts - previous->packet.pts;
                rec->packet->pts - previous->packet->pts;
        }
-        bool ok = recorder_write(recorder, previous->packet);
+        bool ok = recorder_write(recorder, &previous->packet);
        record_packet_delete(previous);
        if (!ok) {
            LOGE("Could not record packet");
@@ -215,8 +208,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");
@@ -226,36 +218,18 @@ run_recorder(void *data) {
 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);
    recorder->stopped = false;
    recorder->failed = false;
    recorder->header_written = false;
    recorder->previous = NULL;
    const char *format_name = recorder_get_format_name(recorder->format);
    assert(format_name);
    const AVOutputFormat *format = find_muxer(format_name);
    if (!format) {
        LOGE("Could not find muxer");
-        goto error_cond_destroy;
+        return false;
    }
    recorder->ctx = avformat_alloc_context();
    if (!recorder->ctx) {
        LOGE("Could not allocate output context");
-        goto error_cond_destroy;
+        return false;
    }
    // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
@@ -269,7 +243,8 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
    if (!ostream) {
-        goto error_avformat_free_context;
+        avformat_free_context(recorder->ctx);
        return false;
    }
    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
@@ -283,31 +258,22 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    if (ret < 0) {
        LOGE("Failed to open output file: %s", recorder->filename);
        // ostream will be cleaned up during context cleaning
-        goto error_avformat_free_context;
+        avformat_free_context(recorder->ctx);
        return false;
    }
    LOGD("Starting recorder thread");
-    ok = sc_thread_create(&recorder->thread, run_recorder, "recorder",
+    bool ok = sc_thread_create(&recorder->thread, run_recorder, "recorder",
                               recorder);
    if (!ok) {
        LOGC("Could not start recorder thread");
-        goto error_avio_close;
+        avformat_free_context(recorder->ctx);
        return false;
    }
    LOGI("Recording started to %s file: %s", format_name, recorder->filename);
    return true;
 error_avio_close:
    avio_close(recorder->ctx->pb);
 error_avformat_free_context:
    avformat_free_context(recorder->ctx);
 error_cond_destroy:
    sc_cond_destroy(&recorder->queue_cond);
 error_mutex_destroy:
    sc_mutex_destroy(&recorder->mutex);
    return false;
 }
 static void
@@ -321,8 +287,6 @@ recorder_close(struct recorder *recorder) {
    avio_close(recorder->ctx->pb);
    avformat_free_context(recorder->ctx);
    sc_cond_destroy(&recorder->queue_cond);
    sc_mutex_destroy(&recorder->mutex);
 }
 static bool
@@ -343,7 +307,7 @@ recorder_push(struct recorder *recorder, const AVPacket *packet) {
        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,15 +336,35 @@ bool
 recorder_init(struct recorder *recorder,
              const char *filename,
              enum sc_record_format format,
-              struct sc_size declared_frame_size) {
+              struct size declared_frame_size) {
    recorder->filename = strdup(filename);
    if (!recorder->filename) {
        LOGE("Could not strdup filename");
        return false;
    }
    bool ok = sc_mutex_init(&recorder->mutex);
    if (!ok) {
        LOGC("Could not create mutex");
        free(recorder->filename);
        return false;
    }
    ok = sc_cond_init(&recorder->queue_cond);
    if (!ok) {
        LOGC("Could not create cond");
        sc_mutex_destroy(&recorder->mutex);
        free(recorder->filename);
        return false;
    }
    queue_init(&recorder->queue);
    recorder->stopped = false;
    recorder->failed = false;
    recorder->format = format;
    recorder->declared_frame_size = declared_frame_size;
    recorder->header_written = false;
    recorder->previous = NULL;
    static const struct sc_packet_sink_ops ops = {
        .open = recorder_packet_sink_open,
@@ -395,5 +379,7 @@ recorder_init(struct recorder *recorder,
 void
 recorder_destroy(struct recorder *recorder) {
    sc_cond_destroy(&recorder->queue_cond);
    sc_mutex_destroy(&recorder->mutex);
    free(recorder->filename);
 }
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@@ -7,17 +7,17 @@
 #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"
 struct record_packet {
-    AVPacket *packet;
+    AVPacket 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
@@ -15,72 +15,77 @@
 #include "controller.h"
 #include "decoder.h"
 #include "device.h"
 #include "events.h"
 #include "file_handler.h"
 #include "fps_counter.h"
 #include "input_manager.h"
 #ifdef HAVE_AOA_HID
 # include "hid_keyboard.h"
 #endif
 #include "keyboard_inject.h"
 #include "mouse_inject.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
 #include "stream.h"
 #include "tiny_xpm.h"
 #include "util/log.h"
 #include "util/net.h"
 #ifdef HAVE_V4L2
 # include "v4l2_sink.h"
 #endif
-struct scrcpy {
+static struct server server;
-    struct server server;
+static struct screen screen;
-    struct screen screen;
+static struct fps_counter fps_counter;
-    struct stream stream;
+static struct stream stream;
-    struct decoder decoder;
+static struct decoder decoder;
-    struct recorder recorder;
+static struct recorder recorder;
-#ifdef HAVE_V4L2
+static struct controller controller;
-    struct sc_v4l2_sink v4l2_sink;
+static struct file_handler file_handler;
-#endif
+
-    struct controller controller;
+static struct input_manager input_manager = {
-    struct file_handler file_handler;
+    .controller = &controller,
-#ifdef HAVE_AOA_HID
+    .fps_counter = &fps_counter,
-    struct sc_aoa aoa;
+    .screen = &screen,
-#endif
+    .repeat = 0,
-    union {
+
-        struct sc_keyboard_inject keyboard_inject;
+    // initialized later
-#ifdef HAVE_AOA_HID
+    .prefer_text = false,
-        struct sc_hid_keyboard keyboard_hid;
+    .sdl_shortcut_mods = {
-#endif
+        .data = {0},
-    };
+        .count = 0,
-    struct sc_mouse_inject mouse_inject;
+    },
    struct input_manager input_manager;
 };
 static inline void
 push_event(uint32_t type, const char *name) {
    SDL_Event event;
    event.type = type;
    int ret = SDL_PushEvent(&event);
    if (ret < 0) {
        LOGE("Could not post %s event: %s", name, SDL_GetError());
        // What could we do?
    }
 }
 #define PUSH_EVENT(TYPE) push_event(TYPE, # TYPE)
 #ifdef _WIN32
 BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
    if (ctrl_type == CTRL_C_EVENT) {
-        PUSH_EVENT(SDL_QUIT);
+        SDL_Event event;
        event.type = SDL_QUIT;
        SDL_PushEvent(&event);
        return TRUE;
    }
    return FALSE;
 }
 #endif // _WIN32
-static void
+// init SDL and set appropriate hints
-sdl_set_hints(const char *render_driver) {
+static bool
 sdl_init_and_configure(bool display, const char *render_driver,
                       bool disable_screensaver) {
    uint32_t flags = display ? SDL_INIT_VIDEO : SDL_INIT_EVENTS;
    if (SDL_Init(flags)) {
        LOGC("Could not initialize SDL: %s", SDL_GetError());
        return false;
    }
    atexit(SDL_Quit);
 #ifdef _WIN32
    // Clean up properly on Ctrl+C on Windows
    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
    if (!ok) {
        LOGW("Could not set Ctrl+C handler");
    }
 #endif // _WIN32
    if (!display) {
        return true;
    }
    if (render_driver && !SDL_SetHint(SDL_HINT_RENDER_DRIVER, render_driver)) {
        LOGW("Could not set render driver");
@@ -98,15 +103,6 @@ sdl_set_hints(const char *render_driver) {
    }
 #endif
 #ifdef SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
    // Disable synthetic mouse events from touch events
    // Touch events with id SDL_TOUCH_MOUSEID are ignored anyway, but it is
    // better not to generate them in the first place.
    if (!SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0")) {
        LOGW("Could not disable synthetic mouse events");
    }
 #endif
 #ifdef SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
    // Disable compositor bypassing on X11
    if (!SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0")) {
@@ -118,21 +114,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");
@@ -141,8 +122,34 @@ sdl_configure(bool display, bool disable_screensaver) {
        LOGD("Screensaver enabled");
        SDL_EnableScreenSaver();
    }
    return true;
 }
 #if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
 // On Windows and MacOS, resizing blocks the event loop, so resizing events are
 // not triggered. As a workaround, handle them in an event handler.
 //
 // <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
 // <https://stackoverflow.com/a/40693139/1987178>
 static int
 event_watcher(void *data, SDL_Event *event) {
    (void) data;
    if (event->type == SDL_WINDOWEVENT
            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
        // In practice, it seems to always be called from the same thread in
        // that specific case. Anyway, it's just a workaround.
        screen_render(&screen, true);
    }
    return 0;
 }
 #endif
 static bool
 is_apk(const char *file) {
    const char *ext = strrchr(file, '.');
@@ -156,8 +163,7 @@ enum event_result {
 };
 static enum event_result
-handle_event(struct scrcpy *s, const struct scrcpy_options *options,
+handle_event(SDL_Event *event, const struct scrcpy_options *options) {
             SDL_Event *event) {
    switch (event->type) {
        case EVENT_STREAM_STOPPED:
            LOGD("Video stream stopped");
@@ -182,17 +188,17 @@ handle_event(struct scrcpy *s, const struct scrcpy_options *options,
            } else {
                action = ACTION_PUSH_FILE;
            }
-            file_handler_request(&s->file_handler, action, file);
+            file_handler_request(&file_handler, action, file);
-            goto end;
+            break;
        }
    }
-    bool consumed = screen_handle_event(&s->screen, event);
+    bool consumed = screen_handle_event(&screen, event);
    if (consumed) {
        goto end;
    }
-    consumed = input_manager_handle_event(&s->input_manager, event);
+    consumed = input_manager_handle_event(&input_manager, event);
    (void) consumed;
 end:
@@ -200,10 +206,15 @@ end:
 }
 static bool
-event_loop(struct scrcpy *s, const struct scrcpy_options *options) {
+event_loop(const struct scrcpy_options *options) {
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
    if (options->display) {
        SDL_AddEventWatch(event_watcher, NULL);
    }
 #endif
    SDL_Event event;
    while (SDL_WaitEvent(&event)) {
-        enum event_result result = handle_event(s, options, &event);
+        enum event_result result = handle_event(&event, options);
        switch (result) {
            case EVENT_RESULT_STOPPED_BY_USER:
                return true;
@@ -241,62 +252,37 @@ 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) {
        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);
 }
 static void
 stream_on_eos(struct stream *stream, void *userdata) {
    (void) stream;
    (void) userdata;
    PUSH_EVENT(EVENT_STREAM_STOPPED);
 }
 bool
-scrcpy(struct scrcpy_options *options) {
+scrcpy(const struct scrcpy_options *options) {
-    static struct scrcpy scrcpy;
+    if (!server_init(&server)) {
    struct scrcpy *s = &scrcpy;
    // Minimal SDL initialization
    if (SDL_Init(SDL_INIT_EVENTS)) {
        LOGC("Could not initialize SDL: %s", SDL_GetError());
        return false;
    }
    atexit(SDL_Quit);
    if (!server_init(&s->server)) {
        return false;
    }
    bool ret = false;
    bool server_started = false;
    bool fps_counter_initialized = false;
    bool file_handler_initialized = false;
    bool recorder_initialized = false;
 #ifdef HAVE_V4L2
    bool v4l2_sink_initialized = false;
 #endif
    bool stream_started = false;
 #ifdef HAVE_AOA_HID
    bool aoa_hid_initialized = false;
 #endif
    bool controller_initialized = false;
    bool controller_started = false;
    bool screen_initialized = false;
    bool record = !!options->record_filename;
    struct server_params params = {
        .serial = options->serial,
        .log_level = options->log_level,
        .crop = options->crop,
        .port_range = options->port_range,
@@ -313,104 +299,93 @@ scrcpy(struct scrcpy_options *options) {
        .force_adb_forward = options->force_adb_forward,
        .power_off_on_close = options->power_off_on_close,
    };
-    if (!server_start(&s->server, &params)) {
+    if (!server_start(&server, options->serial, &params)) {
        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);
+    if (!server_connect_to(&server)) {
    struct server_info info;
    if (!server_connect_to(&s->server, &info)) {
        goto end;
    }
-    if (options->display && options->control) {
+    char device_name[DEVICE_NAME_FIELD_LENGTH];
-        if (!file_handler_init(&s->file_handler, s->server.serial,
+    struct size frame_size;
-                               options->push_target)) {
+
-            goto end;
+    // screenrecord does not send frames when the screen content does not
-        }
+    // change therefore, we transmit the screen size before the video stream,
-        file_handler_initialized = true;
+    // to be able to init the window immediately
    if (!device_read_info(server.video_socket, device_name, &frame_size)) {
        goto end;
    }
    struct decoder *dec = NULL;
-    bool needs_decoder = options->display;
+    if (options->display) {
-#ifdef HAVE_V4L2
+        if (!fps_counter_init(&fps_counter)) {
-    needs_decoder |= !!options->v4l2_device;
+            goto end;
-#endif
+        }
-    if (needs_decoder) {
+        fps_counter_initialized = true;
-        decoder_init(&s->decoder);
+
-        dec = &s->decoder;
+        if (options->control) {
            if (!file_handler_init(&file_handler, server.serial,
                                   options->push_target)) {
                goto end;
            }
            file_handler_initialized = true;
        }
        decoder_init(&decoder);
        dec = &decoder;
    }
    struct recorder *rec = NULL;
-    if (options->record_filename) {
+    if (record) {
-        if (!recorder_init(&s->recorder,
+        if (!recorder_init(&recorder,
                           options->record_filename,
                           options->record_format,
-                           info.frame_size)) {
+                           frame_size)) {
            goto end;
        }
-        rec = &s->recorder;
+        rec = &recorder;
        recorder_initialized = true;
    }
    av_log_set_callback(av_log_callback);
-    static const struct stream_callbacks stream_cbs = {
+    stream_init(&stream, server.video_socket);
        .on_eos = stream_on_eos,
    };
    stream_init(&s->stream, s->server.video_socket, &stream_cbs, NULL);
    if (dec) {
-        stream_add_sink(&s->stream, &dec->packet_sink);
+        stream_add_sink(&stream, &dec->packet_sink);
    }
    if (rec) {
-        stream_add_sink(&s->stream, &rec->packet_sink);
+        stream_add_sink(&stream, &rec->packet_sink);
    }
    if (options->control) {
        if (!controller_init(&s->controller, s->server.control_socket)) {
            goto end;
        }
        controller_initialized = true;
        if (!controller_start(&s->controller)) {
            goto end;
        }
        controller_started = true;
        if (options->turn_screen_off) {
            struct control_msg msg;
            msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
            msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF;
            if (!controller_push_msg(&s->controller, &msg)) {
                LOGW("Could not request 'set screen power mode'");
            }
        }
    }
    if (options->display) {
        if (options->control) {
            if (!controller_init(&controller, server.control_socket)) {
                goto end;
            }
            controller_initialized = true;
            if (!controller_start(&controller)) {
                goto end;
            }
            controller_started = true;
        }
        const char *window_title =
-            options->window_title ? options->window_title : info.device_name;
+            options->window_title ? options->window_title : device_name;
        struct screen_params screen_params = {
            .window_title = window_title,
-            .frame_size = info.frame_size,
+            .frame_size = frame_size,
            .always_on_top = options->always_on_top,
            .window_x = options->window_x,
            .window_y = options->window_y,
@@ -419,184 +394,94 @@ scrcpy(struct scrcpy_options *options) {
            .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)) {
+        if (!screen_init(&screen, &fps_counter, &screen_params)) {
            goto end;
        }
        screen_initialized = true;
-        decoder_add_sink(&s->decoder, &s->screen.frame_sink);
+        decoder_add_sink(&decoder, &screen.frame_sink);
    }
-#ifdef HAVE_V4L2
+        if (options->turn_screen_off) {
-    if (options->v4l2_device) {
+            struct control_msg msg;
-        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device,
+            msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
-                               info.frame_size, options->v4l2_buffer)) {
+            msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF;
-            goto end;
+
            if (!controller_push_msg(&controller, &msg)) {
                LOGW("Could not request 'set screen power mode'");
            }
        }
-        decoder_add_sink(&s->decoder, &s->v4l2_sink.frame_sink);
+        if (options->fullscreen) {
-
+            screen_switch_fullscreen(&screen);
-        v4l2_sink_initialized = true;
+        }
    }
 #endif
    // now we consumed the header values, the socket receives the video stream
    // start the stream
-    if (!stream_start(&s->stream)) {
+    if (!stream_start(&stream)) {
        goto end;
    }
    stream_started = true;
-    struct sc_key_processor *kp = NULL;
+    input_manager_init(&input_manager, options);
    struct sc_mouse_processor *mp = NULL;
-    if (options->control) {
+    ret = event_loop(options);
        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID) {
 #ifdef HAVE_AOA_HID
            bool aoa_hid_ok = false;
            char *serialno = NULL;
            const char *serial = options->serial;
            if (!serial) {
                serialno = adb_get_serialno();
                if (!serialno) {
                    LOGE("Could not get device serial");
                    goto aoa_hid_end;
                }
                serial = serialno;
                LOGI("Device serial: %s", serial);
            }
            bool ok = sc_aoa_init(&s->aoa, serial);
            free(serialno);
            if (!ok) {
                goto aoa_hid_end;
            }
            if (!sc_hid_keyboard_init(&s->keyboard_hid, &s->aoa)) {
                sc_aoa_destroy(&s->aoa);
                goto aoa_hid_end;
            }
            if (!sc_aoa_start(&s->aoa)) {
                sc_hid_keyboard_destroy(&s->keyboard_hid);
                sc_aoa_destroy(&s->aoa);
                goto aoa_hid_end;
            }
            aoa_hid_ok = true;
            kp = &s->keyboard_hid.key_processor;
            aoa_hid_initialized = true;
 aoa_hid_end:
            if (!aoa_hid_ok) {
                LOGE("Failed to enable HID over AOA, "
                     "fallback to default keyboard injection method "
                     "(-K/--hid-keyboard ignored)");
                options->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT;
            }
 #else
            LOGE("HID over AOA is not supported on this platform, "
                 "fallback to default keyboard injection method "
                 "(-K/--hid-keyboard ignored)");
            options->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT;
 #endif
        }
        // keyboard_input_mode may have been reset if HID mode failed
        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_INJECT) {
            sc_keyboard_inject_init(&s->keyboard_inject, &s->controller,
                                    options);
            kp = &s->keyboard_inject.key_processor;
        }
        sc_mouse_inject_init(&s->mouse_inject, &s->controller, &s->screen);
        mp = &s->mouse_inject.mouse_processor;
    }
    input_manager_init(&s->input_manager, &s->controller, &s->screen, kp, mp,
                       options);
    ret = event_loop(s, options);
    LOGD("quit...");
    // Close the window immediately on closing, because screen_destroy() may
    // only be called once the stream thread is joined (it may take time)
    screen_hide_window(&s->screen);
 end:
    // The stream is not stopped explicitly, because it will stop by itself on
    // end-of-stream
 #ifdef HAVE_AOA_HID
    if (aoa_hid_initialized) {
        sc_hid_keyboard_destroy(&s->keyboard_hid);
        sc_aoa_stop(&s->aoa);
    }
 #endif
    if (controller_started) {
-        controller_stop(&s->controller);
+        controller_stop(&controller);
    }
    if (file_handler_initialized) {
-        file_handler_stop(&s->file_handler);
+        file_handler_stop(&file_handler);
    }
-    if (screen_initialized) {
+    if (fps_counter_initialized) {
-        screen_interrupt(&s->screen);
+        fps_counter_interrupt(&fps_counter);
    }
    if (server_started) {
        // shutdown the sockets and kill the server
-        server_stop(&s->server);
+        server_stop(&server);
    }
    // now that the sockets are shutdown, the stream and controller are
    // interrupted, we can join them
    if (stream_started) {
-        stream_join(&s->stream);
+        stream_join(&stream);
    }
 #ifdef HAVE_V4L2
    if (v4l2_sink_initialized) {
        sc_v4l2_sink_destroy(&s->v4l2_sink);
    }
 #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) {
-        screen_join(&s->screen);
+        screen_destroy(&screen);
        screen_destroy(&s->screen);
    }
    if (controller_started) {
-        controller_join(&s->controller);
+        controller_join(&controller);
    }
    if (controller_initialized) {
-        controller_destroy(&s->controller);
+        controller_destroy(&controller);
    }
    if (recorder_initialized) {
-        recorder_destroy(&s->recorder);
+        recorder_destroy(&recorder);
    }
    if (file_handler_initialized) {
-        file_handler_join(&s->file_handler);
+        file_handler_join(&file_handler);
-        file_handler_destroy(&s->file_handler);
+        file_handler_destroy(&file_handler);
    }
-    server_destroy(&s->server);
+    if (fps_counter_initialized) {
        fps_counter_join(&fps_counter);
        fps_counter_destroy(&fps_counter);
    }
    server_destroy(&server);
    return ret;
 }
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@@ -4,9 +4,134 @@
 #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,
 };
 #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;
    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;
    int8_t 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, \
    .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 = -1, \
    .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,34 +28,22 @@ 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
 get_window_position(const struct screen *screen) {
    int x;
    int y;
    SDL_GetWindowPosition(screen->window, &x, &y);
    struct sc_point point;
    point.x = x;
    point.y = y;
    return point;
 }
 // set the window size to be applied when fullscreen is disabled
 static void
-set_window_size(struct screen *screen, struct sc_size new_size) {
+set_window_size(struct screen *screen, struct size new_size) {
    assert(!screen->fullscreen);
    assert(!screen->maximized);
    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
@@ -62,7 +51,7 @@ set_window_size(struct screen *screen, struct sc_size new_size) {
 // get the preferred display bounds (i.e. the screen bounds with some margins)
 static bool
-get_preferred_display_bounds(struct sc_size *bounds) {
+get_preferred_display_bounds(struct size *bounds) {
    SDL_Rect rect;
 #ifdef SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
 # define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayUsableBounds((i), (r))
@@ -80,7 +69,7 @@ get_preferred_display_bounds(struct sc_size *bounds) {
 }
 static bool
-is_optimal_size(struct sc_size current_size, struct sc_size content_size) {
+is_optimal_size(struct size current_size, struct size content_size) {
    // The size is optimal if we can recompute one dimension of the current
    // size from the other
    return current_size.height == current_size.width * content_size.height
@@ -94,16 +83,16 @@ is_optimal_size(struct sc_size current_size, struct sc_size content_size) {
 //    crops the black borders)
 //  - it keeps the aspect ratio
 //  - it scales down to make it fit in the display_size
-static struct sc_size
+static struct size
-get_optimal_size(struct sc_size current_size, struct sc_size content_size) {
+get_optimal_size(struct size current_size, struct size content_size) {
    if (content_size.width == 0 || content_size.height == 0) {
        // avoid division by 0
        return current_size;
    }
-    struct sc_size window_size;
+    struct size window_size;
-    struct sc_size display_size;
+    struct size display_size;
    if (!get_preferred_display_bounds(&display_size)) {
        // could not get display bounds, do not constraint the size
        window_size.width = current_size.width;
@@ -133,12 +122,19 @@ get_optimal_size(struct sc_size current_size, struct sc_size content_size) {
    return window_size;
 }
 // same as get_optimal_size(), but read the current size from the window
 static inline struct size
 get_optimal_window_size(const struct screen *screen, struct size content_size) {
    struct size window_size = get_window_size(screen);
    return get_optimal_size(window_size, content_size);
 }
 // initially, there is no current size, so use the frame size as current size
 // req_width and req_height, if not 0, are the sizes requested by the user
-static inline struct sc_size
+static inline struct size
-get_initial_optimal_size(struct sc_size content_size, uint16_t req_width,
+get_initial_optimal_size(struct size content_size, uint16_t req_width,
                         uint16_t req_height) {
-    struct sc_size window_size;
+    struct size window_size;
    if (!req_width && !req_height) {
        window_size = get_optimal_size(content_size, content_size);
    } else {
@@ -166,9 +162,9 @@ screen_update_content_rect(struct screen *screen) {
    int dh;
    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
-    struct sc_size content_size = screen->content_size;
+    struct size content_size = screen->content_size;
    // The drawable size is the window size * the HiDPI scale
-    struct sc_size drawable_size = {dw, dh};
+    struct size drawable_size = {dw, dh};
    SDL_Rect *rect = &screen->rect;
@@ -200,7 +196,7 @@ screen_update_content_rect(struct screen *screen) {
 static inline SDL_Texture *
 create_texture(struct screen *screen) {
    SDL_Renderer *renderer = screen->renderer;
-    struct sc_size size = screen->frame_size;
+    struct size size = screen->frame_size;
    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
                                             SDL_TEXTUREACCESS_STREAMING,
                                             size.width, size.height);
@@ -224,29 +220,6 @@ create_texture(struct screen *screen) {
    return texture;
 }
 #if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
 // On Windows and MacOS, resizing blocks the event loop, so resizing events are
 // not triggered. As a workaround, handle them in an event handler.
 //
 // <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
 // <https://stackoverflow.com/a/40693139/1987178>
 static int
 event_watcher(void *data, SDL_Event *event) {
    struct screen *screen = data;
    if (event->type == SDL_WINDOWEVENT
            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
        // In practice, it seems to always be called from the same thread in
        // that specific case. Anyway, it's just a workaround.
        screen_render(screen, true);
    }
    return 0;
 }
 #endif
 static bool
 screen_frame_sink_open(struct sc_frame_sink *sink) {
    struct screen *screen = DOWNCAST(sink);
@@ -273,87 +246,57 @@ 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);
 }
-static void
+    bool previous_frame_skipped;
-sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
+    bool ok = video_buffer_push(&screen->vb, frame, &previous_frame_skipped);
-                             void *userdata) {
+    if (!ok) {
-    (void) vb;
+        return false;
    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
        need_new_event = screen->event_failed;
    } else {
        need_new_event = true;
    }
-    if (need_new_event) {
+    if (previous_frame_skipped) {
        fps_counter_add_skipped_frame(screen->fps_counter);
        // The EVENT_NEW_FRAME triggered for the previous frame will consume
        // this new frame instead
    } else {
        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
-screen_init(struct screen *screen, const struct screen_params *params) {
+screen_init(struct screen *screen, struct fps_counter *fps_counter,
            const struct screen_params *params) {
    screen->fps_counter = fps_counter;
    screen->resize_pending = false;
    screen->has_frame = false;
    screen->fullscreen = false;
    screen->maximized = false;
    screen->event_failed = false;
-    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) {
        LOGE("Could not start video_buffer");
        goto error_destroy_video_buffer;
    }
    if (!fps_counter_init(&screen->fps_counter)) {
        LOGE("Could not initialize FPS counter");
        goto error_stop_and_join_video_buffer;
    }
    screen->frame_size = params->frame_size;
    screen->rotation = params->rotation;
    if (screen->rotation) {
        LOGI("Initial display rotation set to %u", screen->rotation);
    }
-    struct sc_size content_size =
+    struct size content_size =
        get_rotated_size(screen->frame_size, screen->rotation);
    screen->content_size = content_size;
-    struct sc_size window_size =
+    struct size window_size = get_initial_optimal_size(content_size,
-        get_initial_optimal_size(content_size,params->window_width,
+                                                       params->window_width,
-                                 params->window_height);
+                                                       params->window_height);
    uint32_t window_flags = SDL_WINDOW_HIDDEN
                          | SDL_WINDOW_RESIZABLE
                          | SDL_WINDOW_ALLOW_HIGHDPI;
@@ -378,14 +321,16 @@ screen_init(struct screen *screen, const struct screen_params *params) {
                                      window_flags);
    if (!screen->window) {
        LOGC("Could not create window: %s", SDL_GetError());
-        goto error_destroy_fps_counter;
+        return false;
    }
    screen->renderer = SDL_CreateRenderer(screen->window, -1,
                                          SDL_RENDERER_ACCELERATED);
    if (!screen->renderer) {
        LOGC("Could not create renderer: %s", SDL_GetError());
-        goto error_destroy_window;
+        SDL_DestroyWindow(screen->window);
        video_buffer_destroy(&screen->vb);
        return false;
    }
    SDL_RendererInfo renderer_info;
@@ -421,10 +366,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");
    }
@@ -434,13 +379,20 @@ screen_init(struct screen *screen, const struct screen_params *params) {
    screen->texture = create_texture(screen);
    if (!screen->texture) {
        LOGC("Could not create texture: %s", SDL_GetError());
-        goto error_destroy_renderer;
+        SDL_DestroyRenderer(screen->renderer);
        SDL_DestroyWindow(screen->window);
        video_buffer_destroy(&screen->vb);
        return false;
    }
    screen->frame = av_frame_alloc();
    if (!screen->frame) {
        LOGC("Could not create screen frame");
-        goto error_destroy_texture;
+        SDL_DestroyTexture(screen->texture);
        SDL_DestroyRenderer(screen->renderer);
        SDL_DestroyWindow(screen->window);
        video_buffer_destroy(&screen->vb);
        return false;
    }
    // Reset the window size to trigger a SIZE_CHANGED event, to workaround
@@ -450,14 +402,6 @@ screen_init(struct screen *screen, const struct screen_params *params) {
    screen_update_content_rect(screen);
    if (params->fullscreen) {
        screen_switch_fullscreen(screen);
    }
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
    SDL_AddEventWatch(event_watcher, screen);
 #endif
    static const struct sc_frame_sink_ops ops = {
        .open = screen_frame_sink_open,
        .close = screen_frame_sink_close,
@@ -471,46 +415,13 @@ screen_init(struct screen *screen, const struct screen_params *params) {
 #endif
    return true;
 error_destroy_texture:
    SDL_DestroyTexture(screen->texture);
 error_destroy_renderer:
    SDL_DestroyRenderer(screen->renderer);
 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);
    return false;
 }
-static void
+void
 screen_show_window(struct screen *screen) {
    SDL_ShowWindow(screen->window);
 }
 void
 screen_hide_window(struct screen *screen) {
    SDL_HideWindow(screen->window);
 }
 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);
 }
 void
 screen_destroy(struct screen *screen) {
 #ifndef NDEBUG
@@ -520,15 +431,14 @@ screen_destroy(struct screen *screen) {
    SDL_DestroyTexture(screen->texture);
    SDL_DestroyRenderer(screen->renderer);
    SDL_DestroyWindow(screen->window);
-    fps_counter_destroy(&screen->fps_counter);
+    video_buffer_destroy(&screen->vb);
    sc_video_buffer_destroy(&screen->vb);
 }
 static void
-resize_for_content(struct screen *screen, struct 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
@@ -539,7 +449,7 @@ resize_for_content(struct screen *screen, struct sc_size old_content_size,
 }
 static void
-set_content_size(struct screen *screen, struct sc_size new_content_size) {
+set_content_size(struct screen *screen, struct size new_content_size) {
    if (!screen->fullscreen && !screen->maximized) {
        resize_for_content(screen, screen->content_size, new_content_size);
    } else if (!screen->resize_pending) {
@@ -570,7 +480,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);
@@ -583,7 +493,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
@@ -591,7 +501,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);
@@ -627,12 +537,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);
+    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;
    }
@@ -699,20 +609,9 @@ screen_resize_to_fit(struct screen *screen) {
        return;
    }
-    struct sc_point point = get_window_position(screen);
+    struct size optimal_size =
-    struct sc_size window_size = get_window_size(screen);
+        get_optimal_window_size(screen, screen->content_size);
    struct sc_size optimal_size =
        get_optimal_size(window_size, screen->content_size);
    // Center the window related to the device screen
    assert(optimal_size.width <= window_size.width);
    assert(optimal_size.height <= window_size.height);
    uint32_t new_x = point.x + (window_size.width - optimal_size.width) / 2;
    uint32_t new_y = point.y + (window_size.height - optimal_size.height) / 2;
    SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
    SDL_SetWindowPosition(screen->window, new_x, new_y);
    LOGD("Resized to optimal size: %ux%u", optimal_size.width,
                                           optimal_size.height);
 }
@@ -728,7 +627,7 @@ screen_resize_to_pixel_perfect(struct screen *screen) {
        screen->maximized = false;
    }
-    struct sc_size content_size = screen->content_size;
+    struct size content_size = screen->content_size;
    SDL_SetWindowSize(screen->window, content_size.width, content_size.height);
    LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
                                            content_size.height);
@@ -774,7 +673,6 @@ screen_handle_event(struct screen *screen, SDL_Event *event) {
                    }
                    screen->maximized = false;
                    apply_pending_resize(screen);
                    screen_render(screen, true);
                    break;
            }
            return true;
@@ -783,7 +681,7 @@ screen_handle_event(struct screen *screen, SDL_Event *event) {
    return false;
 }
-struct sc_point
+struct point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                        int32_t x, int32_t y) {
    unsigned rotation = screen->rotation;
@@ -797,7 +695,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;
@@ -820,7 +718,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
@@ -8,11 +8,12 @@
 #include <libavformat/avformat.h>
 #include "coords.h"
 #include "fps_counter.h"
 #include "opengl.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
 struct video_buffer;
 struct screen {
    struct sc_frame_sink frame_sink; // frame sink trait
@@ -20,20 +21,20 @@ struct screen {
    bool open; // track the open/close state to assert correct behavior
 #endif
-    struct sc_video_buffer vb;
+    struct video_buffer vb;
-    struct fps_counter fps_counter;
+    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;
@@ -44,14 +45,12 @@ struct screen {
    bool maximized;
    bool mipmaps;
    bool event_failed; // in case SDL_PushEvent() returned an error
    AVFrame *frame;
 };
 struct screen_params {
    const char *window_title;
-    struct sc_size frame_size;
+    struct size frame_size;
    bool always_on_top;
    int16_t window_x;
@@ -63,36 +62,21 @@ struct screen_params {
    uint8_t rotation;
    bool mipmaps;
    bool fullscreen;
    sc_tick buffering_time;
 };
 // initialize screen, create window, renderer and texture (window is hidden)
 bool
-screen_init(struct screen *screen, const struct screen_params *params);
+screen_init(struct screen *screen, struct fps_counter *fps_counter,
            const struct screen_params *params);
-// request to interrupt any inner thread
+// show the window
 // must be called before screen_join()
 void
-screen_interrupt(struct screen *screen);
+screen_show_window(struct screen *screen);
 // join any inner thread
 void
 screen_join(struct screen *screen);
 // destroy window, renderer and texture (if any)
 void
 screen_destroy(struct screen *screen);
 // hide the window
 //
 // It is used to hide the window immediately on closing without waiting for
 // screen_destroy()
 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
@@ -122,13 +106,13 @@ screen_handle_event(struct screen *screen, SDL_Event *event);
 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels
-struct sc_point
+struct point
 screen_convert_window_to_frame_coords(struct screen *screen,
                                      int32_t x, int32_t y);
 // convert point from drawable coordinates to frame coordinates
 // x and y are expressed in pixels
-struct sc_point
+struct point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                        int32_t x, int32_t y);
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -3,6 +3,7 @@
 #include <assert.h>
 #include <errno.h>
 #include <inttypes.h>
 #include <libgen.h>
 #include <stdio.h>
 #include <SDL2/SDL_timer.h>
 #include <SDL2/SDL_platform.h>
@@ -47,18 +48,41 @@ get_server_path(void) {
        LOGE("Could not allocate memory");
        return NULL;
    }
    // the absolute path is hardcoded
    return server_path;
 #else
-    char *server_path = get_local_file_path(SERVER_FILENAME);
+
-    if (!server_path) {
+    // use scrcpy-server in the same directory as the executable
-        LOGE("Could not get local file path, "
+    char *executable_path = get_executable_path();
    if (!executable_path) {
        LOGE("Could not get executable path, "
             "using " SERVER_FILENAME " from current directory");
-        return strdup(SERVER_FILENAME);
+        // not found, use current directory
        return SERVER_FILENAME;
    }
    char *dir = dirname(executable_path);
    size_t dirlen = strlen(dir);
    // sizeof(SERVER_FILENAME) gives statically the size including the null byte
    size_t len = dirlen + 1 + sizeof(SERVER_FILENAME);
    char *server_path = malloc(len);
    if (!server_path) {
        LOGE("Could not alloc server path string, "
             "using " SERVER_FILENAME " from current directory");
        free(executable_path);
        return SERVER_FILENAME;
    }
-    LOGD("Using server (portable): %s", server_path);
+    memcpy(server_path, dir, dirlen);
-#endif
+    server_path[dirlen] = PATH_SEPARATOR;
    memcpy(&server_path[dirlen + 1], SERVER_FILENAME, sizeof(SERVER_FILENAME));
    // the final null byte has been copied with SERVER_FILENAME
    free(executable_path);
    LOGD("Using server (portable): %s", server_path);
    return server_path;
 #endif
 }
 static bool
@@ -109,7 +133,7 @@ disable_tunnel(struct server *server) {
    return disable_tunnel_reverse(server->serial);
 }
-static sc_socket
+static socket_t
 listen_on_port(uint16_t port) {
 #define IPV4_LOCALHOST 0x7F000001
    return net_listen(IPV4_LOCALHOST, port, 1);
@@ -132,7 +156,7 @@ enable_tunnel_reverse_any_port(struct server *server,
        // need to try to connect until the server socket is listening on the
        // device.
        server->server_socket = listen_on_port(port);
-        if (server->server_socket != SC_INVALID_SOCKET) {
+        if (server->server_socket != INVALID_SOCKET) {
            // success
            server->local_port = port;
            return true;
@@ -211,8 +235,6 @@ enable_tunnel_any_port(struct server *server, struct sc_port_range port_range,
 static const char *
 log_level_to_server_string(enum sc_log_level level) {
    switch (level) {
        case SC_LOG_LEVEL_VERBOSE:
            return "verbose";
        case SC_LOG_LEVEL_DEBUG:
            return "debug";
        case SC_LOG_LEVEL_INFO:
@@ -237,8 +259,7 @@ execute_server(struct server *server, const struct server_params *params) {
    sprintf(max_size_string, "%"PRIu16, params->max_size);
    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
    sprintf(max_fps_string, "%"PRIu16, params->max_fps);
-    sprintf(lock_video_orientation_string, "%"PRIi8,
+    sprintf(lock_video_orientation_string, "%"PRIi8, params->lock_video_orientation);
            params->lock_video_orientation);
    sprintf(display_id_string, "%"PRIu32, params->display_id);
    const char *const cmd[] = {
        "shell",
@@ -248,8 +269,7 @@ execute_server(struct server *server, const struct server_params *params) {
 # define SERVER_DEBUGGER_PORT "5005"
 # ifdef SERVER_DEBUGGER_METHOD_NEW
        /* Android 9 and above */
-        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,"
+        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,server=y,address="
        "server=y,address="
 # else
        /* Android 8 and below */
        "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
@@ -286,14 +306,14 @@ execute_server(struct server *server, const struct server_params *params) {
    //     Port: 5005
    // Then click on "Debug"
 #endif
-    return adb_execute(server->serial, cmd, ARRAY_LEN(cmd));
+    return adb_execute(server->serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
 }
-static sc_socket
+static socket_t
 connect_and_read_byte(uint16_t port) {
-    sc_socket socket = net_connect(IPV4_LOCALHOST, port);
+    socket_t socket = net_connect(IPV4_LOCALHOST, port);
-    if (socket == SC_INVALID_SOCKET) {
+    if (socket == INVALID_SOCKET) {
-        return SC_INVALID_SOCKET;
+        return INVALID_SOCKET;
    }
    char byte;
@@ -302,17 +322,17 @@ connect_and_read_byte(uint16_t port) {
    if (net_recv(socket, &byte, 1) != 1) {
        // the server is not listening yet behind the adb tunnel
        net_close(socket);
-        return SC_INVALID_SOCKET;
+        return INVALID_SOCKET;
    }
    return socket;
 }
-static sc_socket
+static socket_t
 connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
    do {
        LOGD("Remaining connection attempts: %d", (int) attempts);
-        sc_socket socket = connect_and_read_byte(port);
+        socket_t socket = connect_and_read_byte(port);
-        if (socket != SC_INVALID_SOCKET) {
+        if (socket != INVALID_SOCKET) {
            // it worked!
            return socket;
        }
@@ -320,13 +340,24 @@ connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
            SDL_Delay(delay);
        }
    } while (--attempts > 0);
-    return SC_INVALID_SOCKET;
+    return INVALID_SOCKET;
 }
 static void
 close_socket(socket_t socket) {
    assert(socket != INVALID_SOCKET);
    net_shutdown(socket, SHUT_RDWR);
    if (!net_close(socket)) {
        LOGW("Could not close socket");
    }
 }
 bool
 server_init(struct server *server) {
    server->serial = NULL;
    server->process = PROCESS_NONE;
    atomic_flag_clear_explicit(&server->server_socket_closed,
                               memory_order_relaxed);
    bool ok = sc_mutex_init(&server->mutex);
    if (!ok) {
@@ -341,9 +372,9 @@ server_init(struct server *server) {
    server->process_terminated = false;
-    server->server_socket = SC_INVALID_SOCKET;
+    server->server_socket = INVALID_SOCKET;
-    server->video_socket = SC_INVALID_SOCKET;
+    server->video_socket = INVALID_SOCKET;
-    server->control_socket = SC_INVALID_SOCKET;
+    server->control_socket = INVALID_SOCKET;
    server->local_port = 0;
@@ -365,38 +396,39 @@ run_wait_server(void *data) {
    // no need for synchronization, server_socket is initialized before this
    // thread was created
-    if (server->server_socket != SC_INVALID_SOCKET) {
+    if (server->server_socket != INVALID_SOCKET
-        // Unblock any accept()
+            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
-        net_interrupt(server->server_socket);
+        // On Linux, accept() is unblocked by shutdown(), but on Windows, it is
        // unblocked by closesocket(). Therefore, call both (close_socket()).
        close_socket(server->server_socket);
    }
    LOGD("Server terminated");
    return 0;
 }
 bool
-server_start(struct server *server, const struct server_params *params) {
+server_start(struct server *server, const char *serial,
-    if (params->serial) {
+             const struct server_params *params) {
-        server->serial = strdup(params->serial);
+    if (serial) {
        server->serial = strdup(serial);
        if (!server->serial) {
            return false;
        }
    }
-    if (!push_server(params->serial)) {
+    if (!push_server(serial)) {
-        /* server->serial will be freed on server_destroy() */
+        goto error1;
        return false;
    }
    if (!enable_tunnel_any_port(server, params->port_range,
                                params->force_adb_forward)) {
-        return false;
+        goto error1;
    }
    // server will connect to our server socket
    server->process = execute_server(server, params);
    if (server->process == PROCESS_NONE) {
-        goto error;
+        goto error2;
    }
    // If the server process dies before connecting to the server socket, then
@@ -410,73 +442,61 @@ server_start(struct server *server, const struct server_params *params) {
    if (!ok) {
        process_terminate(server->process);
        process_wait(server->process, true); // ignore exit code
-        goto error;
+        goto error2;
    }
    server->tunnel_enabled = true;
    return true;
-error:
+error2:
-    // The server socket (if any) will be closed on server_destroy()
+    if (!server->tunnel_forward) {
-
+        bool was_closed =
            atomic_flag_test_and_set(&server->server_socket_closed);
        // the thread is not started, the flag could not be already set
        assert(!was_closed);
        (void) was_closed;
        close_socket(server->server_socket);
    }
    disable_tunnel(server);
-
+error1:
    free(server->serial);
    return false;
 }
 static bool
 device_read_info(sc_socket device_socket, struct server_info *info) {
    unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
    ssize_t r = net_recv_all(device_socket, buf, sizeof(buf));
    if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
        LOGE("Could not retrieve device information");
        return false;
    }
    // in case the client sends garbage
    buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
    memcpy(info->device_name, (char *) buf, sizeof(info->device_name));
    info->frame_size.width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
                           | buf[DEVICE_NAME_FIELD_LENGTH + 1];
    info->frame_size.height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
                            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
    return true;
 }
 bool
-server_connect_to(struct server *server, struct server_info *info) {
+server_connect_to(struct server *server) {
    if (!server->tunnel_forward) {
        server->video_socket = net_accept(server->server_socket);
-        if (server->video_socket == SC_INVALID_SOCKET) {
+        if (server->video_socket == INVALID_SOCKET) {
            return false;
        }
        server->control_socket = net_accept(server->server_socket);
-        if (server->control_socket == SC_INVALID_SOCKET) {
+        if (server->control_socket == INVALID_SOCKET) {
            // the video_socket will be cleaned up on destroy
            return false;
        }
        // we don't need the server socket anymore
-        if (!net_close(server->server_socket)) {
+        if (!atomic_flag_test_and_set(&server->server_socket_closed)) {
-            LOGW("Could not close server socket on connect");
+            // close it from here
            close_socket(server->server_socket);
            // otherwise, it is closed by run_wait_server()
        }
        // Do not attempt to close it again on server_destroy()
        server->server_socket = SC_INVALID_SOCKET;
    } else {
        uint32_t attempts = 100;
        uint32_t delay = 100; // ms
        server->video_socket =
            connect_to_server(server->local_port, attempts, delay);
-        if (server->video_socket == SC_INVALID_SOCKET) {
+        if (server->video_socket == INVALID_SOCKET) {
            return false;
        }
        // we know that the device is listening, we don't need several attempts
        server->control_socket =
            net_connect(IPV4_LOCALHOST, server->local_port);
-        if (server->control_socket == SC_INVALID_SOCKET) {
+        if (server->control_socket == INVALID_SOCKET) {
            return false;
        }
    }
@@ -485,26 +505,20 @@ server_connect_to(struct server *server, struct server_info *info) {
    disable_tunnel(server); // ignore failure
    server->tunnel_enabled = false;
-    // The sockets will be closed on stop if device_read_info() fails
+    return true;
    return device_read_info(server->video_socket, info);
 }
 void
 server_stop(struct server *server) {
-    if (server->server_socket != SC_INVALID_SOCKET) {
+    if (server->server_socket != INVALID_SOCKET
-        if (!net_interrupt(server->server_socket)) {
+            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
-            LOGW("Could not interrupt server socket");
+        close_socket(server->server_socket);
        }
    }
-    if (server->video_socket != SC_INVALID_SOCKET) {
+    if (server->video_socket != INVALID_SOCKET) {
-        if (!net_interrupt(server->video_socket)) {
+        close_socket(server->video_socket);
            LOGW("Could not interrupt video socket");
        }
    }
-    if (server->control_socket != SC_INVALID_SOCKET) {
+    if (server->control_socket != INVALID_SOCKET) {
-        if (!net_interrupt(server->control_socket)) {
+        close_socket(server->control_socket);
            LOGW("Could not interrupt control socket");
        }
    }
    assert(server->process != PROCESS_NONE);
@@ -518,10 +532,10 @@ server_stop(struct server *server) {
    sc_mutex_lock(&server->mutex);
    bool signaled = false;
    if (!server->process_terminated) {
-#define WATCHDOG_DELAY SC_TICK_FROM_SEC(1)
+#define WATCHDOG_DELAY_MS 1000
        signaled = sc_cond_timedwait(&server->process_terminated_cond,
                                     &server->mutex,
-                                     sc_tick_now() + WATCHDOG_DELAY);
+                                     WATCHDOG_DELAY_MS);
    }
    sc_mutex_unlock(&server->mutex);
@@ -541,21 +555,6 @@ server_stop(struct server *server) {
 void
 server_destroy(struct server *server) {
    if (server->server_socket != SC_INVALID_SOCKET) {
        if (!net_close(server->server_socket)) {
            LOGW("Could not close server socket");
        }
    }
    if (server->video_socket != SC_INVALID_SOCKET) {
        if (!net_close(server->video_socket)) {
            LOGW("Could not close video socket");
        }
    }
    if (server->control_socket != SC_INVALID_SOCKET) {
        if (!net_close(server->control_socket)) {
            LOGW("Could not close control socket");
        }
    }
    free(server->serial);
    sc_cond_destroy(&server->process_terminated_cond);
    sc_mutex_destroy(&server->mutex);
--- a/app/src/server.h
+++ b/app/src/server.h
@@ -8,37 +8,30 @@
 #include <stdint.h>
 #include "adb.h"
-#include "coords.h"
+#include "scrcpy.h"
 #include "options.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/thread.h"
 #define DEVICE_NAME_FIELD_LENGTH 64
 struct server_info {
    char device_name[DEVICE_NAME_FIELD_LENGTH];
    struct sc_size frame_size;
 };
 struct server {
    char *serial;
    process_t process;
    sc_thread wait_server_thread;
    atomic_flag server_socket_closed;
    sc_mutex mutex;
    sc_cond process_terminated_cond;
    bool process_terminated;
-    sc_socket server_socket; // only used if !tunnel_forward
+    socket_t server_socket; // only used if !tunnel_forward
-    sc_socket video_socket;
+    socket_t video_socket;
-    sc_socket control_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 server_params {
    const char *serial;
    enum sc_log_level log_level;
    const char *crop;
    const char *codec_options;
@@ -62,11 +55,12 @@ server_init(struct server *server);
 // push, enable tunnel et start the server
 bool
-server_start(struct server *server, const struct server_params *params);
+server_start(struct server *server, const char *serial,
             const struct server_params *params);
 // block until the communication with the server is established
 bool
-server_connect_to(struct server *server, struct server_info *info);
+server_connect_to(struct server *server);
 // disconnect and kill the server process
 void
--- a/app/src/stream.c
+++ b/app/src/stream.c
@@ -3,6 +3,7 @@
 #include <assert.h>
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
 #include <SDL2/SDL_events.h>
 #include <unistd.h>
 #include "decoder.h"
@@ -57,6 +58,13 @@ stream_recv_packet(struct stream *stream, AVPacket *packet) {
    return true;
 }
 static void
 notify_stopped(void) {
    SDL_Event stop_event;
    stop_event.type = EVENT_STREAM_STOPPED;
    SDL_PushEvent(&stop_event);
 }
 static bool
 push_packet_to_sinks(struct stream *stream, const AVPacket *packet) {
    for (unsigned i = 0; i < stream->sink_count; ++i) {
@@ -104,38 +112,33 @@ static bool
 stream_push_packet(struct stream *stream, AVPacket *packet) {
    bool is_config = packet->pts == AV_NOPTS_VALUE;
-    // A config packet must not be decoded immediately (it contains no
+    // A config packet must not be decoded immetiately (it contains no
    // frame); instead, it must be concatenated with the future data packet.
-    if (stream->pending || is_config) {
+    if (stream->has_pending || is_config) {
        size_t offset;
-        if (stream->pending) {
+        if (stream->has_pending) {
-            offset = stream->pending->size;
+            offset = stream->pending.size;
-            if (av_grow_packet(stream->pending, packet->size)) {
+            if (av_grow_packet(&stream->pending, packet->size)) {
                LOGE("Could not grow packet");
                return false;
            }
        } else {
            offset = 0;
-            stream->pending = av_packet_alloc();
+            if (av_new_packet(&stream->pending, packet->size)) {
            if (!stream->pending) {
                LOGE("Could not allocate packet");
                return false;
            }
            if (av_new_packet(stream->pending, packet->size)) {
                LOGE("Could not create packet");
                av_packet_free(&stream->pending);
                return false;
            }
            stream->has_pending = true;
        }
-        memcpy(stream->pending->data + offset, packet->data, packet->size);
+        memcpy(stream->pending.data + offset, packet->data, packet->size);
        if (!is_config) {
            // prepare the concat packet to send to the decoder
-            stream->pending->pts = packet->pts;
+            stream->pending.pts = packet->pts;
-            stream->pending->dts = packet->dts;
+            stream->pending.dts = packet->dts;
-            stream->pending->flags = packet->flags;
+            stream->pending.flags = packet->flags;
-            packet = stream->pending;
+            packet = &stream->pending;
        }
    }
@@ -149,9 +152,10 @@ stream_push_packet(struct stream *stream, AVPacket *packet) {
        // data packet
        bool ok = stream_parse(stream, packet);
-        if (stream->pending) {
+        if (stream->has_pending) {
            // the pending packet must be discarded (consumed or error)
-            av_packet_free(&stream->pending);
+            stream->has_pending = false;
            av_packet_unref(&stream->pending);
        }
        if (!ok) {
@@ -219,21 +223,16 @@ run_stream(void *data) {
    // It's more complicated, but this allows to reduce the latency by 1 frame!
    stream->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
    AVPacket *packet = av_packet_alloc();
    if (!packet) {
        LOGE("Could not allocate packet");
        goto finally_close_parser;
    }
    for (;;) {
-        bool ok = stream_recv_packet(stream, packet);
+        AVPacket packet;
        bool ok = stream_recv_packet(stream, &packet);
        if (!ok) {
            // end of stream
            break;
        }
-        ok = stream_push_packet(stream, packet);
+        ok = stream_push_packet(stream, &packet);
-        av_packet_unref(packet);
+        av_packet_unref(&packet);
        if (!ok) {
            // cannot process packet (error already logged)
            break;
@@ -242,34 +241,25 @@ run_stream(void *data) {
    LOGD("End of frames");
-    if (stream->pending) {
+    if (stream->has_pending) {
-        av_packet_free(&stream->pending);
+        av_packet_unref(&stream->pending);
    }
    av_packet_free(&packet);
 finally_close_parser:
    av_parser_close(stream->parser);
 finally_close_sinks:
    stream_close_sinks(stream);
 finally_free_codec_ctx:
    avcodec_free_context(&stream->codec_ctx);
 end:
-    stream->cbs->on_eos(stream, stream->cbs_userdata);
+    notify_stopped();
    return 0;
 }
 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;
+    stream->has_pending = false;
    stream->sink_count = 0;
    assert(cbs && cbs->on_eos);
    stream->cbs = cbs;
    stream->cbs_userdata = cbs_userdata;
 }
 void
--- a/app/src/stream.h
+++ b/app/src/stream.h
@@ -6,6 +6,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <libavformat/avformat.h>
 #include <SDL2/SDL_atomic.h>
 #include "trait/packet_sink.h"
 #include "util/net.h"
@@ -14,7 +15,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];
@@ -24,19 +25,12 @@ struct stream {
    AVCodecParserContext *parser;
    // successive packets may need to be concatenated, until a non-config
    // packet is available
-    AVPacket *pending;
+    bool has_pending;
-
+    AVPacket pending;
    const struct stream_callbacks *cbs;
    void *cbs_userdata;
 };
 struct stream_callbacks {
    void (*on_eos)(struct stream *stream, void *userdata);
 };
 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
 stream_add_sink(struct stream *stream, struct sc_packet_sink *sink);
--- a/app/src/sys/unix/process.c
+++ b/app/src/sys/unix/process.c
@@ -1,6 +1,5 @@
 #include "util/process.h"
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
@@ -51,151 +50,65 @@ search_executable(const char *file) {
 }
 enum process_result
-process_execute_redirect(const char *const argv[], pid_t *pid, int *pipe_stdin,
+process_execute(const char *const argv[], pid_t *pid) {
-                     int *pipe_stdout, int *pipe_stderr) {
+    int fd[2];
    int in[2];
    int out[2];
    int err[2];
    int internal[2]; // communication between parent and children
-    if (pipe(internal) == -1) {
+    if (pipe(fd) == -1) {
        perror("pipe");
        return PROCESS_ERROR_GENERIC;
    }
-    if (pipe_stdin) {
+
-        if (pipe(in) == -1) {
+    enum process_result ret = PROCESS_SUCCESS;
            perror("pipe");
            close(internal[0]);
            close(internal[1]);
            return PROCESS_ERROR_GENERIC;
        }
    }
    if (pipe_stdout) {
        if (pipe(out) == -1) {
            perror("pipe");
            // clean up
            if (pipe_stdin) {
                close(in[0]);
                close(in[1]);
            }
            close(internal[0]);
            close(internal[1]);
            return PROCESS_ERROR_GENERIC;
        }
    }
    if (pipe_stderr) {
        if (pipe(err) == -1) {
            perror("pipe");
            // clean up
            if (pipe_stdout) {
                close(out[0]);
                close(out[1]);
            }
            if (pipe_stdin) {
                close(in[0]);
                close(in[1]);
            }
            close(internal[0]);
            close(internal[1]);
            return PROCESS_ERROR_GENERIC;
        }
    }
    *pid = fork();
    if (*pid == -1) {
        perror("fork");
-        // clean up
+        ret = PROCESS_ERROR_GENERIC;
-        if (pipe_stderr) {
+        goto end;
            close(err[0]);
            close(err[1]);
        }
        if (pipe_stdout) {
            close(out[0]);
            close(out[1]);
        }
        if (pipe_stdin) {
            close(in[0]);
            close(in[1]);
        }
        close(internal[0]);
        close(internal[1]);
        return PROCESS_ERROR_GENERIC;
    }
-    if (*pid == 0) {
+    if (*pid > 0) {
-        if (pipe_stdin) {
+        // parent close write side
-            if (in[0] != STDIN_FILENO) {
+        close(fd[1]);
-                dup2(in[0], STDIN_FILENO);
+        fd[1] = -1;
-                close(in[0]);
+        // wait for EOF or receive errno from child
-            }
+        if (read(fd[0], &ret, sizeof(ret)) == -1) {
-            close(in[1]);
+            perror("read");
            ret = PROCESS_ERROR_GENERIC;
            goto end;
        }
-        if (pipe_stdout) {
+    } else if (*pid == 0) {
-            if (out[1] != STDOUT_FILENO) {
+        // child close read side
-                dup2(out[1], STDOUT_FILENO);
+        close(fd[0]);
-                close(out[1]);
+        if (fcntl(fd[1], F_SETFD, FD_CLOEXEC) == 0) {
            execvp(argv[0], (char *const *)argv);
            if (errno == ENOENT) {
                ret = PROCESS_ERROR_MISSING_BINARY;
            } else {
                ret = PROCESS_ERROR_GENERIC;
            }
            close(out[0]);
        }
        if (pipe_stderr) {
            if (err[1] != STDERR_FILENO) {
                dup2(err[1], STDERR_FILENO);
                close(err[1]);
            }
            close(err[0]);
        }
        close(internal[0]);
        enum process_result err;
        if (fcntl(internal[1], F_SETFD, FD_CLOEXEC) == 0) {
            execvp(argv[0], (char *const *) argv);
            perror("exec");
            err = errno == ENOENT ? PROCESS_ERROR_MISSING_BINARY
                                  : PROCESS_ERROR_GENERIC;
        } else {
            perror("fcntl");
-            err = 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 process_result res = PROCESS_SUCCESS;
    // wait for EOF or receive err from child
    if (read(internal[0], &res, sizeof(res)) == -1) {
        perror("read");
        res = PROCESS_ERROR_GENERIC;
    }
-
+    if (fd[1] != -1) {
-    close(internal[0]);
+        close(fd[1]);
    if (pipe_stdin) {
        close(in[0]);
        *pipe_stdin = in[1];
    }
-    if (pipe_stdout) {
+    return ret;
        *pipe_stdout = out[0];
        close(out[1]);
    }
    if (pipe_stderr) {
        *pipe_stderr = err[0];
        close(err[1]);
    }
    return res;
 }
 enum process_result
 process_execute(const char *const argv[], pid_t *pid) {
    return process_execute_redirect(argv, pid, NULL, NULL, NULL);
 }
 bool
@@ -262,15 +175,3 @@ is_regular_file(const char *path) {
    }
    return S_ISREG(path_stat.st_mode);
 }
 ssize_t
 read_pipe(int pipe, char *data, size_t len) {
    return read(pipe, data, len);
 }
 void
 close_pipe(int pipe) {
    if (close(pipe)) {
        perror("close pipe");
    }
 }
--- a/app/src/sys/win/process.c
+++ b/app/src/sys/win/process.c
@@ -6,9 +6,7 @@
 #include "util/log.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>
@@ -17,135 +15,43 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
    size_t ret = xstrjoin(cmd, argv, ' ', len);
    if (ret >= len) {
        LOGE("Command too long (%" PRIsizet " chars)", len - 1);
-        return false;
+        return -1;
    }
-    return true;
+    return 0;
 }
 enum process_result
 process_execute_redirect(const char *const argv[], HANDLE *handle,
                         HANDLE *pipe_stdin, HANDLE *pipe_stdout,
                         HANDLE *pipe_stderr) {
    enum process_result ret = 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 (pipe_stdin) {
        if (!CreatePipe(&stdin_read_handle, pipe_stdin, &sa, 0)) {
            perror("pipe");
            return PROCESS_ERROR_GENERIC;
        }
        if (!SetHandleInformation(*pipe_stdin, HANDLE_FLAG_INHERIT, 0)) {
            LOGE("SetHandleInformation stdin failed");
            goto error_close_stdin;
        }
    }
    if (pipe_stdout) {
        if (!CreatePipe(pipe_stdout, &stdout_write_handle, &sa, 0)) {
            perror("pipe");
            goto error_close_stdin;
        }
        if (!SetHandleInformation(*pipe_stdout, HANDLE_FLAG_INHERIT, 0)) {
            LOGE("SetHandleInformation stdout failed");
            goto error_close_stdout;
        }
    }
    if (pipe_stderr) {
        if (!CreatePipe(pipe_stderr, &stderr_write_handle, &sa, 0)) {
            perror("pipe");
            goto error_close_stdout;
        }
        if (!SetHandleInformation(*pipe_stderr, HANDLE_FLAG_INHERIT, 0)) {
            LOGE("SetHandleInformation stderr failed");
            goto error_close_stderr;
        }
    }
    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);
    if (pipe_stdin || pipe_stdout || pipe_stderr) {
        si.dwFlags = STARTF_USESTDHANDLES;
        if (pipe_stdin) {
            si.hStdInput = stdin_read_handle;
        }
        if (pipe_stdout) {
            si.hStdOutput = stdout_write_handle;
        }
        if (pipe_stderr) {
            si.hStdError = stderr_write_handle;
        }
    }
    char *cmd = malloc(CMD_MAX_LEN);
    if (!cmd || !build_cmd(cmd, CMD_MAX_LEN, argv)) {
        *handle = NULL;
        goto error_close_stderr;
    }
    wchar_t *wide = utf8_to_wide_char(cmd);
    free(cmd);
    if (!wide) {
        LOGC("Could not allocate wide char string");
        goto error_close_stderr;
    }
    if (!CreateProcessW(NULL, wide, NULL, NULL, TRUE, 0, NULL, NULL, &si,
                        &pi)) {
        free(wide);
        *handle = NULL;
        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
            ret = PROCESS_ERROR_MISSING_BINARY;
        }
        goto error_close_stderr;
    }
    // These handles are used by the child process, close them for this process
    if (pipe_stdin) {
        CloseHandle(stdin_read_handle);
    }
    if (pipe_stdout) {
        CloseHandle(stdout_write_handle);
    }
    if (pipe_stderr) {
        CloseHandle(stderr_write_handle);
    }
    free(wide);
    *handle = pi.hProcess;
    return PROCESS_SUCCESS;
 error_close_stderr:
    if (pipe_stderr) {
        CloseHandle(*pipe_stderr);
        CloseHandle(stderr_write_handle);
    }
 error_close_stdout:
    if (pipe_stdout) {
        CloseHandle(*pipe_stdout);
        CloseHandle(stdout_write_handle);
    }
 error_close_stdin:
    if (pipe_stdin) {
        CloseHandle(*pipe_stdin);
        CloseHandle(stdin_read_handle);
    }
    return ret;
 }
 enum process_result
 process_execute(const char *const argv[], HANDLE *handle) {
-    return process_execute_redirect(argv, handle, NULL, NULL, NULL);
+    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);
    char cmd[256];
    if (build_cmd(cmd, sizeof(cmd), argv)) {
        *handle = NULL;
        return PROCESS_ERROR_GENERIC;
    }
    wchar_t *wide = utf8_to_wide_char(cmd);
    if (!wide) {
        LOGC("Could not allocate wide char string");
        return PROCESS_ERROR_GENERIC;
    }
    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, 0, NULL, NULL, &si,
                        &pi)) {
        free(wide);
        *handle = NULL;
        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
            return PROCESS_ERROR_MISSING_BINARY;
        }
        return PROCESS_ERROR_GENERIC;
    }
    free(wide);
    *handle = pi.hProcess;
    return PROCESS_SUCCESS;
 }
 bool
@@ -207,19 +113,3 @@ is_regular_file(const char *path) {
    }
    return S_ISREG(path_stat.st_mode);
 }
 ssize_t
 read_pipe(HANDLE pipe, char *data, size_t len) {
    DWORD r;
    if (!ReadFile(pipe, data, len, &r, NULL)) {
        return -1;
    }
    return r;
 }
 void
 close_pipe(HANDLE pipe) {
    if (!CloseHandle(pipe)) {
        LOGW("Cannot close pipe");
    }
 }
--- 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,13 +1,11 @@
-#ifndef SC_FRAME_SINK_H
+#ifndef SC_FRAME_SINK
-#define SC_FRAME_SINK_H
+#define SC_FRAME_SINK
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
 typedef struct AVFrame AVFrame;
 /**
 * Frame sink trait.
 *
--- a/app/src/trait/key_processor.h
+++ b/app/src/trait/key_processor.h
@@ -1,29 +0,0 @@
 #ifndef SC_KEY_PROCESSOR_H
 #define SC_KEY_PROCESSOR_H
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
 #include <SDL2/SDL_events.h>
 /**
 * Key processor trait.
 *
 * Component able to process and inject keys should implement this trait.
 */
 struct sc_key_processor {
    const struct sc_key_processor_ops *ops;
 };
 struct sc_key_processor_ops {
    void
    (*process_key)(struct sc_key_processor *kp, const SDL_KeyboardEvent *event);
    void
    (*process_text)(struct sc_key_processor *kp,
                    const SDL_TextInputEvent *event);
 };
 #endif
--- a/app/src/trait/mouse_processor.h
+++ b/app/src/trait/mouse_processor.h
@@ -1,39 +0,0 @@
 #ifndef SC_MOUSE_PROCESSOR_H
 #define SC_MOUSE_PROCESSOR_H
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
 #include <SDL2/SDL_events.h>
 /**
 * Mouse processor trait.
 *
 * Component able to process and inject mouse events should implement this
 * trait.
 */
 struct sc_mouse_processor {
    const struct sc_mouse_processor_ops *ops;
 };
 struct sc_mouse_processor_ops {
    void
    (*process_mouse_motion)(struct sc_mouse_processor *mp,
                            const SDL_MouseMotionEvent *event);
    void
    (*process_touch)(struct sc_mouse_processor *mp,
                     const SDL_TouchFingerEvent *event);
    void
    (*process_mouse_button)(struct sc_mouse_processor *mp,
                            const SDL_MouseButtonEvent *event);
    void
    (*process_mouse_wheel)(struct sc_mouse_processor *mp,
                           const SDL_MouseWheelEvent *event);
 };
 #endif
--- a/app/src/trait/packet_sink.h
+++ b/app/src/trait/packet_sink.h
@@ -1,13 +1,11 @@
-#ifndef SC_PACKET_SINK_H
+#ifndef SC_PACKET_SINK
-#define SC_PACKET_SINK_H
+#define SC_PACKET_SINK
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
-
+#include <libavcodec/avcodec.h>
 typedef struct AVCodec AVCodec;
 typedef struct AVPacket AVPacket;
 /**
 * Packet sink trait.
--- 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,12 +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 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__)
@@ -14,10 +10,4 @@
 #define LOGE(...) SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGC(...) SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 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,6 +1,5 @@
 #include "net.h"
 #include <assert.h>
 #include <stdio.h>
 #include <SDL2/SDL_platform.h>
@@ -8,7 +7,6 @@
 #ifdef __WINDOWS__
  typedef int socklen_t;
  typedef SOCKET sc_raw_socket;
 #else
 # include <sys/types.h>
 # include <sys/socket.h>
@@ -19,9 +17,105 @@
  typedef struct sockaddr_in SOCKADDR_IN;
  typedef struct sockaddr SOCKADDR;
  typedef struct in_addr IN_ADDR;
  typedef int sc_raw_socket;
 #endif
 socket_t
 net_connect(uint32_t addr, uint16_t port) {
    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == INVALID_SOCKET) {
        perror("socket");
        return INVALID_SOCKET;
    }
    SOCKADDR_IN sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = htonl(addr);
    sin.sin_port = htons(port);
    if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
        perror("connect");
        net_close(sock);
        return INVALID_SOCKET;
    }
    return sock;
 }
 socket_t
 net_listen(uint32_t addr, uint16_t port, int backlog) {
    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == INVALID_SOCKET) {
        perror("socket");
        return INVALID_SOCKET;
    }
    int reuse = 1;
    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
                   sizeof(reuse)) == -1) {
        perror("setsockopt(SO_REUSEADDR)");
    }
    SOCKADDR_IN sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = htonl(addr); // htonl() harmless on INADDR_ANY
    sin.sin_port = htons(port);
    if (bind(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
        perror("bind");
        net_close(sock);
        return INVALID_SOCKET;
    }
    if (listen(sock, backlog) == SOCKET_ERROR) {
        perror("listen");
        net_close(sock);
        return INVALID_SOCKET;
    }
    return sock;
 }
 socket_t
 net_accept(socket_t server_socket) {
    SOCKADDR_IN csin;
    socklen_t sinsize = sizeof(csin);
    return accept(server_socket, (SOCKADDR *) &csin, &sinsize);
 }
 ssize_t
 net_recv(socket_t socket, void *buf, size_t len) {
    return recv(socket, buf, len, 0);
 }
 ssize_t
 net_recv_all(socket_t socket, void *buf, size_t len) {
    return recv(socket, buf, len, MSG_WAITALL);
 }
 ssize_t
 net_send(socket_t socket, const void *buf, size_t len) {
    return send(socket, buf, len, 0);
 }
 ssize_t
 net_send_all(socket_t socket, const void *buf, size_t len) {
    ssize_t w = 0;
    while (len > 0) {
        w = send(socket, buf, len, 0);
        if (w == -1) {
            return -1;
        }
        len -= w;
        buf = (char *) buf + w;
    }
    return w;
 }
 bool
 net_shutdown(socket_t socket, int how) {
    return !shutdown(socket, how);
 }
 bool
 net_init(void) {
 #ifdef __WINDOWS__
@@ -42,189 +136,11 @@ net_cleanup(void) {
 #endif
 }
 static inline sc_socket
 wrap(sc_raw_socket sock) {
 #ifdef __WINDOWS__
    if (sock == INVALID_SOCKET) {
        return SC_INVALID_SOCKET;
    }
    struct sc_socket_windows *socket = malloc(sizeof(*socket));
    if (!socket) {
        closesocket(sock);
        return SC_INVALID_SOCKET;
    }
    socket->socket = sock;
    socket->closed = (atomic_flag) ATOMIC_FLAG_INIT;
    return socket;
 #else
    return sock;
 #endif
 }
 static inline sc_raw_socket
 unwrap(sc_socket socket) {
 #ifdef __WINDOWS__
    if (socket == SC_INVALID_SOCKET) {
        return INVALID_SOCKET;
    }
    return socket->socket;
 #else
    return socket;
 #endif
 }
 static void
 net_perror(const char *s) {
 #ifdef _WIN32
    int error = WSAGetLastError();
    char *wsa_message;
    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
            NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
            (char *) &wsa_message, 0, NULL);
    // no explicit '\n', wsa_message already contains a trailing '\n'
    fprintf(stderr, "%s: [%d] %s", s, error, wsa_message);
    LocalFree(wsa_message);
 #else
    perror(s);
 #endif
 }
 sc_socket
 net_connect(uint32_t addr, uint16_t port) {
    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
    sc_socket sock = wrap(raw_sock);
    if (sock == SC_INVALID_SOCKET) {
        net_perror("socket");
        return SC_INVALID_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");
        net_close(sock);
        return SC_INVALID_SOCKET;
    }
    return sock;
 }
 sc_socket
 net_listen(uint32_t addr, uint16_t port, int backlog) {
    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
    sc_socket sock = wrap(raw_sock);
    if (sock == SC_INVALID_SOCKET) {
        net_perror("socket");
        return SC_INVALID_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");
        net_close(sock);
        return SC_INVALID_SOCKET;
    }
    if (listen(raw_sock, backlog) == SOCKET_ERROR) {
        net_perror("listen");
        net_close(sock);
        return SC_INVALID_SOCKET;
    }
    return sock;
 }
 sc_socket
 net_accept(sc_socket server_socket) {
    sc_raw_socket raw_server_socket = unwrap(server_socket);
    SOCKADDR_IN csin;
    socklen_t sinsize = sizeof(csin);
    sc_raw_socket raw_sock =
        accept(raw_server_socket, (SOCKADDR *) &csin, &sinsize);
    return wrap(raw_sock);
 }
 ssize_t
 net_recv(sc_socket socket, void *buf, size_t len) {
    sc_raw_socket raw_sock = unwrap(socket);
    return recv(raw_sock, buf, len, 0);
 }
 ssize_t
 net_recv_all(sc_socket socket, void *buf, size_t len) {
    sc_raw_socket raw_sock = unwrap(socket);
    return recv(raw_sock, buf, len, MSG_WAITALL);
 }
 ssize_t
 net_send(sc_socket socket, const void *buf, size_t len) {
    sc_raw_socket raw_sock = unwrap(socket);
    return send(raw_sock, buf, len, 0);
 }
 ssize_t
 net_send_all(sc_socket socket, const void *buf, size_t len) {
    size_t copied = 0;
    while (len > 0) {
        ssize_t w = net_send(socket, buf, len);
        if (w == -1) {
            return copied ? (ssize_t) copied : -1;
        }
        len -= w;
        buf = (char *) buf + w;
        copied += w;
    }
    return copied;
 }
 bool
-net_interrupt(sc_socket socket) {
+net_close(socket_t socket) {
    assert(socket != SC_INVALID_SOCKET);
    sc_raw_socket raw_sock = unwrap(socket);
 #ifdef __WINDOWS__
-    if (!atomic_flag_test_and_set(&socket->closed)) {
+    return !closesocket(socket);
        return !closesocket(raw_sock);
    }
    return true;
 #else
-    return !shutdown(raw_sock, SHUT_RDWR);
+    return !close(socket);
 #endif
 }
 #include <errno.h>
 bool
 net_close(sc_socket socket) {
    sc_raw_socket raw_sock = unwrap(socket);
 #ifdef __WINDOWS__
    bool ret = true;
    if (!atomic_flag_test_and_set(&socket->closed)) {
        ret = !closesocket(raw_sock);
    }
    free(socket);
    return ret;
 #else
    return !close(raw_sock);
 #endif
 }
--- a/app/src/util/net.h
+++ b/app/src/util/net.h
@@ -8,20 +8,15 @@
 #include <SDL2/SDL_platform.h>
 #ifdef __WINDOWS__
 # include <winsock2.h>
-# include <stdatomic.h>
+  #define SHUT_RD SD_RECEIVE
-# define SC_INVALID_SOCKET 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_INVALID_SOCKET -1
+# define INVALID_SOCKET -1
-  typedef int sc_socket;
+  typedef int socket_t;
 #endif
 bool
@@ -30,36 +25,33 @@ net_init(void);
 void
 net_cleanup(void);
-sc_socket
+socket_t
 net_connect(uint32_t addr, uint16_t port);
-sc_socket
+socket_t
 net_listen(uint32_t addr, uint16_t port, int backlog);
-sc_socket
+socket_t
-net_accept(sc_socket server_socket);
+net_accept(socket_t 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);
 #endif
--- a/app/src/util/process.c
+++ b/app/src/util/process.c
@@ -1,6 +1,5 @@
 #include "process.h"
 #include <libgen.h>
 #include "log.h"
 bool
@@ -20,59 +19,3 @@ process_check_success(process_t proc, const char *name, bool close) {
    }
    return true;
 }
 char *
 get_local_file_path(const char *name) {
    char *executable_path = 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, PATH_SEPARATOR);
    if (!p) {
        LOGE("Unexpected executable path: \"%s\" (it should contain a '%c')",
             executable_path, PATH_SEPARATOR);
        free(executable_path);
        return NULL;
    }
    *p = '\0'; // modify executable_path in place
    char *dir = executable_path;
    size_t dirlen = strlen(dir);
    size_t namelen = strlen(name);
    size_t len = dirlen + namelen + 2; // +2: '/' and '\0'
    char *file_path = malloc(len);
    if (!file_path) {
        LOGE("Could not alloc path");
        free(executable_path);
        return NULL;
    }
    memcpy(file_path, dir, dirlen);
    file_path[dirlen] = PATH_SEPARATOR;
    // namelen + 1 to copy the final '\0'
    memcpy(&file_path[dirlen + 1], name, namelen + 1);
    free(executable_path);
    return file_path;
 }
 ssize_t
 read_pipe_all(pipe_t pipe, char *data, size_t len) {
    size_t copied = 0;
    while (len > 0) {
        ssize_t r = read_pipe(pipe, data, len);
        if (r <= 0) {
            return copied ? (ssize_t) copied : r;
        }
        len -= r;
        data += r;
        copied += r;
    }
    return copied;
 }
--- a/app/src/util/process.h
+++ b/app/src/util/process.h
@@ -18,7 +18,6 @@
 # define NO_EXIT_CODE -1u // max value as unsigned
  typedef HANDLE process_t;
  typedef DWORD exit_code_t;
  typedef HANDLE pipe_t;
 #else
@@ -30,7 +29,6 @@
 # define NO_EXIT_CODE -1
  typedef pid_t process_t;
  typedef int exit_code_t;
  typedef int pipe_t;
 #endif
@@ -44,14 +42,6 @@ enum process_result {
 enum process_result
 process_execute(const char *const argv[], process_t *process);
 enum process_result
 process_execute_redirect(const char *const argv[], process_t *process,
                         pipe_t *pipe_stdin, pipe_t *pipe_stdout,
                         pipe_t *pipe_stderr);
 bool
 process_terminate(process_t pid);
 // kill the process
 bool
 process_terminate(process_t pid);
@@ -84,22 +74,8 @@ search_executable(const char *file);
 char *
 get_executable_path(void);
 // Return the absolute path of a file in the same directory as he executable.
 // May be NULL on error. To be freed by free().
 char *
 get_local_file_path(const char *name);
 // returns true if the file exists and is not a directory
 bool
 is_regular_file(const char *path);
 ssize_t
 read_pipe(pipe_t pipe, char *data, size_t len);
 ssize_t
 read_pipe_all(pipe_t pipe, char *data, size_t len);
 void
 close_pipe(pipe_t pipe);
 #endif
--- a/app/src/util/queue.h
+++ b/app/src/util/queue.h
@@ -1,6 +1,6 @@
 // generic intrusive FIFO queue
-#ifndef SC_QUEUE_H
+#ifndef QUEUE_H
-#define SC_QUEUE_H
+#define QUEUE_H
 #include "common.h"
@@ -10,15 +10,15 @@
 // To define a queue type of "struct foo":
 //    struct queue_foo QUEUE(struct foo);
-#define SC_QUEUE(TYPE) { \
+#define QUEUE(TYPE) { \
    TYPE *first; \
    TYPE *last; \
 }
-#define sc_queue_init(PQ) \
+#define queue_init(PQ) \
    (void) ((PQ)->first = (PQ)->last = NULL)
-#define sc_queue_is_empty(PQ) \
+#define queue_is_empty(PQ) \
    !(PQ)->first
 // NEXTFIELD is the field in the ITEM type used for intrusive linked-list
@@ -30,30 +30,30 @@
 //    };
 //
 //    // define the type "struct my_queue"
-//    struct my_queue SC_QUEUE(struct foo);
+//    struct my_queue QUEUE(struct foo);
 //
 //    struct my_queue queue;
-//    sc_queue_init(&queue);
+//    queue_init(&queue);
 //
 //    struct foo v1 = { .value = 42 };
 //    struct foo v2 = { .value = 27 };
 //
-//    sc_queue_push(&queue, next, v1);
+//    queue_push(&queue, next, v1);
-//    sc_queue_push(&queue, next, v2);
+//    queue_push(&queue, next, v2);
 //
 //    struct foo *foo;
-//    sc_queue_take(&queue, next, &foo);
+//    queue_take(&queue, next, &foo);
 //    assert(foo->value == 42);
-//    sc_queue_take(&queue, next, &foo);
+//    queue_take(&queue, next, &foo);
 //    assert(foo->value == 27);
-//    assert(sc_queue_is_empty(&queue));
+//    assert(queue_is_empty(&queue));
 //
 // push a new item into the queue
-#define sc_queue_push(PQ, NEXTFIELD, ITEM) \
+#define queue_push(PQ, NEXTFIELD, ITEM) \
    (void) ({ \
        (ITEM)->NEXTFIELD = NULL; \
-        if (sc_queue_is_empty(PQ)) { \
+        if (queue_is_empty(PQ)) { \
            (PQ)->first = (PQ)->last = (ITEM); \
        } else { \
            (PQ)->last->NEXTFIELD = (ITEM); \
@@ -65,9 +65,9 @@
 // the result is stored in *(PITEM)
 // (without typeof(), we could not store a local variable having the correct
 // type so that we can "return" it)
-#define sc_queue_take(PQ, NEXTFIELD, PITEM) \
+#define queue_take(PQ, NEXTFIELD, PITEM) \
    (void) ({ \
-        assert(!sc_queue_is_empty(PQ)); \
+        assert(!queue_is_empty(PQ)); \
        *(PITEM) = (PQ)->first; \
        (PQ)->first = (PQ)->first->NEXTFIELD; \
    })
--- a/app/src/util/str_util.c
+++ b/app/src/util/str_util.c
@@ -1,11 +1,9 @@
 #include "str_util.h"
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "util/strbuf.h"
 #ifdef _WIN32
 # include <windows.h>
@@ -142,24 +140,6 @@ parse_integer_with_suffix(const char *s, long *out) {
    return true;
 }
 bool
 strlist_contains(const char *list, char sep, const char *s) {
    char *p;
    do {
        p = strchr(list, sep);
        size_t token_len = p ? (size_t) (p - list) : strlen(list);
        if (!strncmp(list, s, token_len)) {
            return true;
        }
        if (p) {
            list = p + 1;
        }
    } while (p);
    return false;
 }
 size_t
 utf8_truncation_index(const char *utf8, size_t max_len) {
    size_t len = strlen(utf8);
@@ -211,81 +191,3 @@ utf8_from_wide_char(const wchar_t *ws) {
 }
 #endif
 char *wrap_lines(const char *input, unsigned columns, unsigned indent) {
    assert(indent < columns);
    struct sc_strbuf buf;
    // The output string should not be a lot longer than the input string (just
    // a few '\n' added), so this initial capacity should almost always avoid
    // internal realloc() in string buffer
    size_t cap = strlen(input) * 3 / 2;
    if (!sc_strbuf_init(&buf, cap)) {
        return false;
    }
 #define APPEND(S,N) if (!sc_strbuf_append(&buf, S, N)) goto error
 #define APPEND_CHAR(C) if (!sc_strbuf_append_char(&buf, C)) goto error
 #define APPEND_N(C,N) if (!sc_strbuf_append_n(&buf, C, N)) goto error
 #define APPEND_INDENT() if (indent) APPEND_N(' ', indent)
    APPEND_INDENT();
    // The last separator encountered, it must be inserted only conditionnaly,
    // depending on the next token
    char pending = 0;
    // col tracks the current column in the current line
    size_t col = indent;
    while (*input) {
        size_t sep_idx = strcspn(input, "\n ");
        size_t new_col = col + sep_idx;
        if (pending == ' ') {
            // The pending space counts
            ++new_col;
        }
        bool wrap = new_col > columns;
        char sep = input[sep_idx];
        if (sep == ' ')
            sep = ' ';
        if (wrap) {
            APPEND_CHAR('\n');
            APPEND_INDENT();
            col = indent;
        } else if (pending) {
            APPEND_CHAR(pending);
            ++col;
            if (pending == '\n')
            {
                APPEND_INDENT();
                col = indent;
            }
        }
        if (sep_idx) {
            APPEND(input, sep_idx);
            col += sep_idx;
        }
        pending = sep;
        input += sep_idx;
        if (*input != '\0') {
            // Skip the separator
            ++input;
        }
    }
    if (pending)
        APPEND_CHAR(pending);
    return buf.s;
 error:
    free(buf.s);
    return NULL;
 }
--- a/app/src/util/str_util.h
+++ b/app/src/util/str_util.h
@@ -16,7 +16,7 @@ size_t
 xstrncpy(char *dest, const char *src, size_t n);
 // join tokens by sep into dst
-// returns the number of chars actually written (max n-1) if no truncation
+// returns the number of chars actually written (max n-1) if no trucation
 // occurred, or n if truncated
 size_t
 xstrjoin(char *dst, const char *const tokens[], char sep, size_t n);
@@ -43,11 +43,6 @@ parse_integers(const char *s, const char sep, size_t max_items, long *out);
 bool
 parse_integer_with_suffix(const char *s, long *out);
 // search s in the list separated by sep
 // for example, strlist_contains("a,bc,def", ',', "bc") returns true
 bool
 strlist_contains(const char *list, char sep, const char *s);
 // return the index to truncate a UTF-8 string at a valid position
 size_t
 utf8_truncation_index(const char *utf8, size_t max_len);
@@ -62,8 +57,4 @@ char *
 utf8_from_wide_char(const wchar_t *s);
 #endif
 // Wrap input lines at words boundaries (spaces) so that they fit in 'columns'
 // columns, left-indented by 'indent' spaces
 char *wrap_lines(const char *input, unsigned columns, unsigned indent);
 #endif
--- a/app/src/util/strbuf.c
+++ b/app/src/util/strbuf.c
@@ -1,87 +0,0 @@
 #include "strbuf.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 bool
 sc_strbuf_init(struct sc_strbuf *buf, size_t init_cap) {
    buf->s = malloc(init_cap + 1); // +1 for '\0'
    if (!buf->s) {
        return false;
    }
    buf->len = 0;
    buf->cap = init_cap;
    return true;
 }
 static bool
 sc_strbuf_reserve(struct sc_strbuf *buf, size_t len) {
    if (buf->len + len > buf->cap) {
        size_t new_cap = buf->cap * 3 / 2 + len;
        char *s = realloc(buf->s, new_cap + 1); // +1 for '\0'
        if (!s) {
            // Leave the old buf->s
            return false;
        }
        buf->s = s;
        buf->cap = new_cap;
    }
    return true;
 }
 bool
 sc_strbuf_append(struct sc_strbuf *buf, const char *s, size_t len) {
    assert(s);
    assert(*s);
    assert(strlen(s) >= len);
    if (!sc_strbuf_reserve(buf, len)) {
        return false;
    }
    memcpy(&buf->s[buf->len], s, len);
    buf->len += len;
    buf->s[buf->len] = '\0';
    return true;
 }
 bool
 sc_strbuf_append_char(struct sc_strbuf *buf, const char c) {
    if (!sc_strbuf_reserve(buf, 1)) {
        return false;
    }
    buf->s[buf->len] = c;
    buf->len ++;
    buf->s[buf->len] = '\0';
    return true;
 }
 bool
 sc_strbuf_append_n(struct sc_strbuf *buf, const char c, size_t n) {
    if (!sc_strbuf_reserve(buf, n)) {
        return false;
    }
    memset(&buf->s[buf->len], c, n);
    buf->len += n;
    buf->s[buf->len] = '\0';
    return true;
 }
 void
 sc_strbuf_shrink(struct sc_strbuf *buf) {
    assert(buf->len <= buf->cap);
    if (buf->len != buf->cap) {
        char *s = realloc(buf->s, buf->len + 1); // +1 for '\0'
        assert(s); // decreasing the size may not fail
        buf->s = s;
        buf->cap = buf->len;
    }
 }
--- a/app/src/util/strbuf.h
+++ b/app/src/util/strbuf.h
@@ -1,40 +0,0 @@
 #ifndef SC_STRBUF_H
 #define SC_STRBUF_H
 #include <stdbool.h>
 #include <stddef.h>
 #include <string.h>
 struct sc_strbuf {
    char *s;
    size_t len;
    size_t cap;
 };
 // buf->s must be manually freed by the caller
 bool
 sc_strbuf_init(struct sc_strbuf *buf, size_t init_cap);
 bool
 sc_strbuf_append(struct sc_strbuf *buf, const char *s, size_t len);
 bool
 sc_strbuf_append_char(struct sc_strbuf *buf, const char c);
 bool
 sc_strbuf_append_n(struct sc_strbuf *buf, const char c, size_t n);
 static inline bool
 sc_strbuf_append_str(struct sc_strbuf *buf, const char *s) {
    return sc_strbuf_append(buf, s, strlen(s));
 }
 // Append static string (i.e. the string size is known at compile time, for
 // example a string literal)
 #define sc_strbuf_append_staticstr(BUF, S) \
    sc_strbuf_append(BUF, S, sizeof(S) - 1)
 void
 sc_strbuf_shrink(struct sc_strbuf *buf);
 #endif
--- a/app/src/util/thread.c
+++ b/app/src/util/thread.c
@@ -31,7 +31,7 @@ sc_mutex_init(sc_mutex *mutex) {
    mutex->mutex = sdl_mutex;
 #ifndef NDEBUG
-    atomic_init(&mutex->locker, 0);
+    mutex->locker = 0;
 #endif
    return true;
 }
@@ -52,8 +52,7 @@ sc_mutex_lock(sc_mutex *mutex) {
        abort();
    }
-    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
+    mutex->locker = sc_thread_get_id();
                          memory_order_relaxed);
 #else
    (void) r;
 #endif
@@ -63,7 +62,7 @@ void
 sc_mutex_unlock(sc_mutex *mutex) {
 #ifndef NDEBUG
    assert(sc_mutex_held(mutex));
-    atomic_store_explicit(&mutex->locker, 0, memory_order_relaxed);
+    mutex->locker = 0;
 #endif
    int r = SDL_UnlockMutex(mutex->mutex);
 #ifndef NDEBUG
@@ -84,9 +83,7 @@ sc_thread_get_id(void) {
 #ifndef NDEBUG
 bool
 sc_mutex_held(struct sc_mutex *mutex) {
-    sc_thread_id locker_id =
+    return mutex->locker == sc_thread_get_id();
        atomic_load_explicit(&mutex->locker, memory_order_relaxed);
    return locker_id == sc_thread_get_id();
 }
 #endif
@@ -115,21 +112,14 @@ sc_cond_wait(sc_cond *cond, sc_mutex *mutex) {
        abort();
    }
-    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
+    mutex->locker = sc_thread_get_id();
                          memory_order_relaxed);
 #else
    (void) r;
 #endif
 }
 bool
-sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline) {
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms) {
    sc_tick now = sc_tick_now();
    if (deadline <= now) {
        return false; // timeout
    }
    uint32_t ms = SC_TICK_TO_MS(deadline - now);
    int r = SDL_CondWaitTimeout(cond->cond, mutex->mutex, ms);
 #ifndef NDEBUG
    if (r < 0) {
@@ -137,8 +127,7 @@ sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline) {
        abort();
    }
-    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
+    mutex->locker = sc_thread_get_id();
                          memory_order_relaxed);
 #endif
    assert(r == 0 || r == SDL_MUTEX_TIMEDOUT);
    return r == 0;
--- a/app/src/util/thread.h
+++ b/app/src/util/thread.h
@@ -3,10 +3,8 @@
 #include "common.h"
 #include <stdatomic.h>
 #include <stdbool.h>
-
+#include <stdint.h>
 #include "tick.h"
 /* Forward declarations */
 typedef struct SDL_Thread SDL_Thread;
@@ -14,8 +12,7 @@ typedef struct SDL_mutex SDL_mutex;
 typedef struct SDL_cond SDL_cond;
 typedef int sc_thread_fn(void *);
-typedef unsigned sc_thread_id;
+typedef unsigned int sc_thread_id;
 typedef atomic_uint sc_atomic_thread_id;
 typedef struct sc_thread {
    SDL_Thread *thread;
@@ -24,7 +21,7 @@ typedef struct sc_thread {
 typedef struct sc_mutex {
    SDL_mutex *mutex;
 #ifndef NDEBUG
-    sc_atomic_thread_id locker;
+    sc_thread_id locker;
 #endif
 } sc_mutex;
@@ -73,7 +70,7 @@ sc_cond_wait(sc_cond *cond, sc_mutex *mutex);
 // return true on signaled, false on timeout
 bool
-sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline);
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms);
 void
 sc_cond_signal(sc_cond *cond);
--- a/app/src/util/tick.c
+++ b/app/src/util/tick.c
@@ -1,16 +0,0 @@
 #include "tick.h"
 #include <SDL2/SDL_timer.h>
 sc_tick
 sc_tick_now(void) {
    // SDL_GetTicks() resolution is in milliseconds, but sc_tick are expressed
    // in microseconds to store PTS without precision loss.
    //
    // As an alternative, SDL_GetPerformanceCounter() and
    // SDL_GetPerformanceFrequency() could be used, but:
    //  - the conversions (avoiding overflow) are expansive, since the
    //    frequency is not known at compile time;
    //  - in practice, we don't need more precision for now.
    return (sc_tick) SDL_GetTicks() * 1000;
 }
--- a/app/src/util/tick.h
+++ b/app/src/util/tick.h
@@ -1,23 +0,0 @@
 #ifndef SC_TICK_H
 #define SC_TICK_H
 #include "common.h"
 #include <stdint.h>
 typedef int64_t sc_tick;
 #define PRItick PRIi64
 #define SC_TICK_FREQ 1000000 // microsecond
 // To be adapted if SC_TICK_FREQ changes
 #define SC_TICK_TO_US(tick) (tick)
 #define SC_TICK_TO_MS(tick) ((tick) / 1000)
 #define SC_TICK_TO_SEC(tick) ((tick) / 1000000)
 #define SC_TICK_FROM_US(us) (us)
 #define SC_TICK_FROM_MS(ms) ((ms) * 1000)
 #define SC_TICK_FROM_SEC(sec) ((sec) * 1000000)
 sc_tick
 sc_tick_now(void);
 #endif
--- a/app/src/v4l2_sink.c
+++ b/app/src/v4l2_sink.c
@@ -1,386 +0,0 @@
 #include "v4l2_sink.h"
 #include "util/log.h"
 #include "util/str_util.h"
 /** Downcast frame_sink to sc_v4l2_sink */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_v4l2_sink, frame_sink)
 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
 static const AVOutputFormat *
 find_muxer(const char *name) {
 #ifdef SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
    void *opaque = NULL;
 #endif
    const AVOutputFormat *oformat = NULL;
    do {
 #ifdef SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
        oformat = av_muxer_iterate(&opaque);
 #else
        oformat = av_oformat_next(oformat);
 #endif
        // until null or containing the requested name
    } while (oformat && !strlist_contains(oformat->name, ',', name));
    return oformat;
 }
 static bool
 write_header(struct sc_v4l2_sink *vs, const AVPacket *packet) {
    AVStream *ostream = vs->format_ctx->streams[0];
    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
    if (!extradata) {
        LOGC("Could not allocate extradata");
        return false;
    }
    // copy the first packet to the extra data
    memcpy(extradata, packet->data, packet->size);
    ostream->codecpar->extradata = extradata;
    ostream->codecpar->extradata_size = packet->size;
    int ret = avformat_write_header(vs->format_ctx, NULL);
    if (ret < 0) {
        LOGE("Failed to write header to %s", vs->device_name);
        return false;
    }
    return true;
 }
 static void
 rescale_packet(struct sc_v4l2_sink *vs, AVPacket *packet) {
    AVStream *ostream = vs->format_ctx->streams[0];
    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
 }
 static bool
 write_packet(struct sc_v4l2_sink *vs, AVPacket *packet) {
    if (!vs->header_written) {
        bool ok = write_header(vs, packet);
        if (!ok) {
            return false;
        }
        vs->header_written = true;
        return true;
    }
    rescale_packet(vs, packet);
    bool ok = av_write_frame(vs->format_ctx, packet) >= 0;
    // Failing to write the last frame is not very serious, no future frame may
    // depend on it, so the resulting file will still be valid
    (void) ok;
    return true;
 }
 static bool
 encode_and_write_frame(struct sc_v4l2_sink *vs, const AVFrame *frame) {
    int ret = avcodec_send_frame(vs->encoder_ctx, frame);
    if (ret < 0 && ret != AVERROR(EAGAIN)) {
        LOGE("Could not send v4l2 video frame: %d", ret);
        return false;
    }
    AVPacket *packet = vs->packet;
    ret = avcodec_receive_packet(vs->encoder_ctx, packet);
    if (ret == 0) {
        // A packet was received
        bool ok = write_packet(vs, packet);
        av_packet_unref(packet);
        if (!ok) {
            LOGW("Could not send packet to v4l2 sink");
            return false;
        }
    } else if (ret != AVERROR(EAGAIN)) {
        LOGE("Could not receive v4l2 video packet: %d", ret);
        return false;
    }
    return true;
 }
 static int
 run_v4l2_sink(void *data) {
    struct sc_v4l2_sink *vs = data;
    for (;;) {
        sc_mutex_lock(&vs->mutex);
        while (!vs->stopped && !vs->has_frame) {
            sc_cond_wait(&vs->cond, &vs->mutex);
        }
        if (vs->stopped) {
            sc_mutex_unlock(&vs->mutex);
            break;
        }
        vs->has_frame = false;
        sc_mutex_unlock(&vs->mutex);
        sc_video_buffer_consume(&vs->vb, vs->frame);
        bool ok = encode_and_write_frame(vs, vs->frame);
        av_frame_unref(vs->frame);
        if (!ok) {
            LOGE("Could not send frame to v4l2 sink");
            break;
        }
    }
    LOGD("V4l2 thread ended");
    return 0;
 }
 static void
 sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
                             void *userdata) {
    (void) vb;
    struct sc_v4l2_sink *vs = userdata;
    if (!previous_skipped) {
        sc_mutex_lock(&vs->mutex);
        vs->has_frame = true;
        sc_cond_signal(&vs->cond);
        sc_mutex_unlock(&vs->mutex);
    }
 }
 static bool
 sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
    static const struct sc_video_buffer_callbacks cbs = {
        .on_new_frame = sc_video_buffer_on_new_frame,
    };
    bool ok = sc_video_buffer_init(&vs->vb, vs->buffering_time, &cbs, vs);
    if (!ok) {
        LOGE("Could not initialize video buffer");
        return false;
    }
    ok = sc_video_buffer_start(&vs->vb);
    if (!ok) {
        LOGE("Could not start video buffer");
        goto error_video_buffer_destroy;
    }
    ok = sc_mutex_init(&vs->mutex);
    if (!ok) {
        LOGC("Could not create mutex");
        goto error_video_buffer_stop_and_join;
    }
    ok = sc_cond_init(&vs->cond);
    if (!ok) {
        LOGC("Could not create cond");
        goto error_mutex_destroy;
    }
    const AVOutputFormat *format = find_muxer("v4l2");
    if (!format) {
        // Alternative name
        format = find_muxer("video4linux2");
    }
    if (!format) {
        LOGE("Could not find v4l2 muxer");
        goto error_cond_destroy;
    }
    const AVCodec *encoder = avcodec_find_encoder(AV_CODEC_ID_RAWVIDEO);
    if (!encoder) {
        LOGE("Raw video encoder not found");
        return false;
    }
    vs->format_ctx = avformat_alloc_context();
    if (!vs->format_ctx) {
        LOGE("Could not allocate v4l2 output context");
        return false;
    }
    // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
    // returns (on purpose) a pointer-to-const, but AVFormatContext.oformat
    // still expects a pointer-to-non-const (it has not be updated accordingly)
    // <https://github.com/FFmpeg/FFmpeg/commit/0694d8702421e7aff1340038559c438b61bb30dd>
    vs->format_ctx->oformat = (AVOutputFormat *) format;
 #ifdef SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
    vs->format_ctx->url = strdup(vs->device_name);
    if (!vs->format_ctx->url) {
        LOGE("Could not strdup v4l2 device name");
        goto error_avformat_free_context;
        return false;
    }
 #else
    strncpy(vs->format_ctx->filename, vs->device_name,
            sizeof(vs->format_ctx->filename));
 #endif
    AVStream *ostream = avformat_new_stream(vs->format_ctx, encoder);
    if (!ostream) {
        LOGE("Could not allocate new v4l2 stream");
        goto error_avformat_free_context;
        return false;
    }
    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
    ostream->codecpar->codec_id = encoder->id;
    ostream->codecpar->format = AV_PIX_FMT_YUV420P;
    ostream->codecpar->width = vs->frame_size.width;
    ostream->codecpar->height = vs->frame_size.height;
    int ret = avio_open(&vs->format_ctx->pb, vs->device_name, AVIO_FLAG_WRITE);
    if (ret < 0) {
        LOGE("Failed to open output device: %s", vs->device_name);
        // ostream will be cleaned up during context cleaning
        goto error_avformat_free_context;
    }
    vs->encoder_ctx = avcodec_alloc_context3(encoder);
    if (!vs->encoder_ctx) {
        LOGC("Could not allocate codec context for v4l2");
        goto error_avio_close;
    }
    vs->encoder_ctx->width = vs->frame_size.width;
    vs->encoder_ctx->height = vs->frame_size.height;
    vs->encoder_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
    vs->encoder_ctx->time_base.num = 1;
    vs->encoder_ctx->time_base.den = 1;
    if (avcodec_open2(vs->encoder_ctx, encoder, NULL) < 0) {
        LOGE("Could not open codec for v4l2");
        goto error_avcodec_free_context;
    }
    vs->frame = av_frame_alloc();
    if (!vs->frame) {
        LOGE("Could not create v4l2 frame");
        goto error_avcodec_close;
    }
    vs->packet = av_packet_alloc();
    if (!vs->packet) {
        LOGE("Could not allocate packet");
        goto error_av_frame_free;
    }
    vs->has_frame = false;
    vs->header_written = false;
    vs->stopped = false;
    LOGD("Starting v4l2 thread");
    ok = sc_thread_create(&vs->thread, run_v4l2_sink, "v4l2", vs);
    if (!ok) {
        LOGC("Could not start v4l2 thread");
        goto error_av_packet_free;
    }
    LOGI("v4l2 sink started to device: %s", vs->device_name);
    return true;
 error_av_packet_free:
    av_packet_free(&vs->packet);
 error_av_frame_free:
    av_frame_free(&vs->frame);
 error_avcodec_close:
    avcodec_close(vs->encoder_ctx);
 error_avcodec_free_context:
    avcodec_free_context(&vs->encoder_ctx);
 error_avio_close:
    avio_close(vs->format_ctx->pb);
 error_avformat_free_context:
    avformat_free_context(vs->format_ctx);
 error_cond_destroy:
    sc_cond_destroy(&vs->cond);
 error_mutex_destroy:
    sc_mutex_destroy(&vs->mutex);
 error_video_buffer_stop_and_join:
    sc_video_buffer_stop(&vs->vb);
    sc_video_buffer_join(&vs->vb);
 error_video_buffer_destroy:
    sc_video_buffer_destroy(&vs->vb);
    return false;
 }
 static void
 sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
    sc_mutex_lock(&vs->mutex);
    vs->stopped = true;
    sc_cond_signal(&vs->cond);
    sc_mutex_unlock(&vs->mutex);
    sc_video_buffer_stop(&vs->vb);
    sc_thread_join(&vs->thread, NULL);
    sc_video_buffer_join(&vs->vb);
    av_packet_free(&vs->packet);
    av_frame_free(&vs->frame);
    avcodec_close(vs->encoder_ctx);
    avcodec_free_context(&vs->encoder_ctx);
    avio_close(vs->format_ctx->pb);
    avformat_free_context(vs->format_ctx);
    sc_cond_destroy(&vs->cond);
    sc_mutex_destroy(&vs->mutex);
    sc_video_buffer_destroy(&vs->vb);
 }
 static bool
 sc_v4l2_sink_push(struct sc_v4l2_sink *vs, const AVFrame *frame) {
    return sc_video_buffer_push(&vs->vb, frame);
 }
 static bool
 sc_v4l2_frame_sink_open(struct sc_frame_sink *sink) {
    struct sc_v4l2_sink *vs = DOWNCAST(sink);
    return sc_v4l2_sink_open(vs);
 }
 static void
 sc_v4l2_frame_sink_close(struct sc_frame_sink *sink) {
    struct sc_v4l2_sink *vs = DOWNCAST(sink);
    sc_v4l2_sink_close(vs);
 }
 static bool
 sc_v4l2_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
    struct sc_v4l2_sink *vs = DOWNCAST(sink);
    return sc_v4l2_sink_push(vs, frame);
 }
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
                  struct sc_size frame_size, sc_tick buffering_time) {
    vs->device_name = strdup(device_name);
    if (!vs->device_name) {
        LOGE("Could not strdup v4l2 device name");
        return false;
    }
    vs->frame_size = frame_size;
    vs->buffering_time = buffering_time;
    static const struct sc_frame_sink_ops ops = {
        .open = sc_v4l2_frame_sink_open,
        .close = sc_v4l2_frame_sink_close,
        .push = sc_v4l2_frame_sink_push,
    };
    vs->frame_sink.ops = &ops;
    return true;
 }
 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs) {
    free(vs->device_name);
 }
--- a/app/src/v4l2_sink.h
+++ b/app/src/v4l2_sink.h
@@ -1,42 +0,0 @@
 #ifndef SC_V4L2_SINK_H
 #define SC_V4L2_SINK_H
 #include "common.h"
 #include "coords.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
 #include "util/tick.h"
 #include <libavformat/avformat.h>
 struct sc_v4l2_sink {
    struct sc_frame_sink frame_sink; // frame sink trait
    struct sc_video_buffer vb;
    AVFormatContext *format_ctx;
    AVCodecContext *encoder_ctx;
    char *device_name;
    struct sc_size frame_size;
    sc_tick buffering_time;
    sc_thread thread;
    sc_mutex mutex;
    sc_cond cond;
    bool has_frame;
    bool stopped;
    bool header_written;
    AVFrame *frame;
    AVPacket *packet;
 };
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
                  struct sc_size frame_size, sc_tick buffering_time);
 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);
 #endif
--- a/app/src/video_buffer.c
+++ b/app/src/video_buffer.c
@@ -1,255 +1,88 @@
 #include "video_buffer.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <libavutil/avutil.h>
 #include <libavformat/avformat.h>
 #include "util/log.h"
-#define SC_BUFFERING_NDEBUG // comment to debug
+bool
-
+video_buffer_init(struct video_buffer *vb) {
-static struct sc_video_buffer_frame *
+    vb->pending_frame = av_frame_alloc();
-sc_video_buffer_frame_new(const AVFrame *frame) {
+    if (!vb->pending_frame) {
-    struct sc_video_buffer_frame *vb_frame = malloc(sizeof(*vb_frame));
+        return false;
    if (!vb_frame) {
        return NULL;
    }
-    vb_frame->frame = av_frame_alloc();
+    vb->tmp_frame = av_frame_alloc();
-    if (!vb_frame->frame) {
+    if (!vb->tmp_frame) {
-        free(vb_frame);
+        av_frame_free(&vb->pending_frame);
-        return NULL;
+        return false;
    }
-    if (av_frame_ref(vb_frame->frame, frame)) {
+    bool ok = sc_mutex_init(&vb->mutex);
        av_frame_free(&vb_frame->frame);
        free(vb_frame);
        return NULL;
    }
    return vb_frame;
 }
 static void
 sc_video_buffer_frame_delete(struct sc_video_buffer_frame *vb_frame) {
    av_frame_unref(vb_frame->frame);
    av_frame_free(&vb_frame->frame);
    free(vb_frame);
 }
 static bool
 sc_video_buffer_offer(struct sc_video_buffer *vb, const AVFrame *frame) {
    bool previous_skipped;
    bool ok = sc_frame_buffer_push(&vb->fb, frame, &previous_skipped);
    if (!ok) {
        av_frame_free(&vb->pending_frame);
        av_frame_free(&vb->tmp_frame);
        return false;
    }
-    vb->cbs->on_new_frame(vb, previous_skipped, vb->cbs_userdata);
+    // there is initially no frame, so consider it has already been consumed
    vb->pending_frame_consumed = true;
    return true;
 }
-static int
+void
-run_buffering(void *data) {
+video_buffer_destroy(struct video_buffer *vb) {
-    struct sc_video_buffer *vb = data;
+    sc_mutex_destroy(&vb->mutex);
    av_frame_free(&vb->pending_frame);
    av_frame_free(&vb->tmp_frame);
 }
-    assert(vb->buffering_time > 0);
+static inline void
-
+swap_frames(AVFrame **lhs, AVFrame **rhs) {
-    for (;;) {
+    AVFrame *tmp = *lhs;
-        sc_mutex_lock(&vb->b.mutex);
+    *lhs = *rhs;
-
+    *rhs = tmp;
        while (!vb->b.stopped && sc_queue_is_empty(&vb->b.queue)) {
            sc_cond_wait(&vb->b.queue_cond, &vb->b.mutex);
        }
        if (vb->b.stopped) {
            sc_mutex_unlock(&vb->b.mutex);
            goto stopped;
        }
        struct sc_video_buffer_frame *vb_frame;
        sc_queue_take(&vb->b.queue, next, &vb_frame);
        sc_tick max_deadline = sc_tick_now() + vb->buffering_time;
        // PTS (written by the server) are expressed in microseconds
        sc_tick pts = SC_TICK_TO_US(vb_frame->frame->pts);
        bool timed_out = false;
        while (!vb->b.stopped && !timed_out) {
            sc_tick deadline = sc_clock_to_system_time(&vb->b.clock, pts)
                             + vb->buffering_time;
            if (deadline > max_deadline) {
                deadline = max_deadline;
            }
            timed_out =
                !sc_cond_timedwait(&vb->b.wait_cond, &vb->b.mutex, deadline);
        }
        if (vb->b.stopped) {
            sc_video_buffer_frame_delete(vb_frame);
            sc_mutex_unlock(&vb->b.mutex);
            goto stopped;
        }
        sc_mutex_unlock(&vb->b.mutex);
 #ifndef SC_BUFFERING_NDEBUG
        LOGD("Buffering: %" PRItick ";%" PRItick ";%" PRItick,
             pts, vb_frame->push_date, sc_tick_now());
 #endif
        sc_video_buffer_offer(vb, vb_frame->frame);
        sc_video_buffer_frame_delete(vb_frame);
    }
 stopped:
    // Flush queue
    while (!sc_queue_is_empty(&vb->b.queue)) {
        struct sc_video_buffer_frame *vb_frame;
        sc_queue_take(&vb->b.queue, next, &vb_frame);
        sc_video_buffer_frame_delete(vb_frame);
    }
    LOGD("Buffering thread ended");
    return 0;
 }
 bool
-sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
+video_buffer_push(struct video_buffer *vb, const AVFrame *frame,
-                     const struct sc_video_buffer_callbacks *cbs,
+                  bool *previous_frame_skipped) {
-                     void *cbs_userdata) {
+    sc_mutex_lock(&vb->mutex);
-    bool ok = sc_frame_buffer_init(&vb->fb);
+
-    if (!ok) {
+    // 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(vb->tmp_frame, frame);
    if (r) {
        LOGE("Could not ref frame: %d", r);
        return false;
    }
-    assert(buffering_time >= 0);
+    // Now that av_frame_ref() succeeded, we can replace the previous
-    if (buffering_time) {
+    // pending_frame
-        ok = sc_mutex_init(&vb->b.mutex);
+    swap_frames(&vb->pending_frame, &vb->tmp_frame);
-        if (!ok) {
+    av_frame_unref(vb->tmp_frame);
            LOGC("Could not create mutex");
            sc_frame_buffer_destroy(&vb->fb);
            return false;
        }
-        ok = sc_cond_init(&vb->b.queue_cond);
+    if (previous_frame_skipped) {
-        if (!ok) {
+        *previous_frame_skipped = !vb->pending_frame_consumed;
            LOGC("Could not create cond");
            sc_mutex_destroy(&vb->b.mutex);
            sc_frame_buffer_destroy(&vb->fb);
            return false;
        }
        ok = sc_cond_init(&vb->b.wait_cond);
        if (!ok) {
            LOGC("Could not create wait cond");
            sc_cond_destroy(&vb->b.queue_cond);
            sc_mutex_destroy(&vb->b.mutex);
            sc_frame_buffer_destroy(&vb->fb);
            return false;
        }
        sc_clock_init(&vb->b.clock);
        sc_queue_init(&vb->b.queue);
    }
    vb->pending_frame_consumed = false;
-    assert(cbs);
+    sc_mutex_unlock(&vb->mutex);
    assert(cbs->on_new_frame);
    vb->buffering_time = buffering_time;
    vb->cbs = cbs;
    vb->cbs_userdata = cbs_userdata;
    return true;
 }
 bool
 sc_video_buffer_start(struct sc_video_buffer *vb) {
    if (vb->buffering_time) {
        bool ok =
            sc_thread_create(&vb->b.thread, run_buffering, "buffering", vb);
        if (!ok) {
            LOGE("Could not start buffering thread");
            return false;
        }
    }
    return true;
 }
 void
-sc_video_buffer_stop(struct sc_video_buffer *vb) {
+video_buffer_consume(struct video_buffer *vb, AVFrame *dst) {
-    if (vb->buffering_time) {
+    sc_mutex_lock(&vb->mutex);
-        sc_mutex_lock(&vb->b.mutex);
+    assert(!vb->pending_frame_consumed);
-        vb->b.stopped = true;
+    vb->pending_frame_consumed = true;
-        sc_cond_signal(&vb->b.queue_cond);
+
-        sc_cond_signal(&vb->b.wait_cond);
+    av_frame_move_ref(dst, vb->pending_frame);
-        sc_mutex_unlock(&vb->b.mutex);
+    // av_frame_move_ref() resets its source frame, so no need to call
-    }
+    // av_frame_unref()
-}
+
-
+    sc_mutex_unlock(&vb->mutex);
 void
 sc_video_buffer_join(struct sc_video_buffer *vb) {
    if (vb->buffering_time) {
        sc_thread_join(&vb->b.thread, NULL);
    }
 }
 void
 sc_video_buffer_destroy(struct sc_video_buffer *vb) {
    sc_frame_buffer_destroy(&vb->fb);
    if (vb->buffering_time) {
        sc_cond_destroy(&vb->b.wait_cond);
        sc_cond_destroy(&vb->b.queue_cond);
        sc_mutex_destroy(&vb->b.mutex);
    }
 }
 bool
 sc_video_buffer_push(struct sc_video_buffer *vb, const AVFrame *frame) {
    if (!vb->buffering_time) {
        // No buffering
        return sc_video_buffer_offer(vb, frame);
    }
    sc_mutex_lock(&vb->b.mutex);
    sc_tick pts = SC_TICK_FROM_US(frame->pts);
    sc_clock_update(&vb->b.clock, sc_tick_now(), pts);
    sc_cond_signal(&vb->b.wait_cond);
    if (vb->b.clock.count == 1) {
        sc_mutex_unlock(&vb->b.mutex);
        // First frame, offer it immediately, for two reasons:
        //  - not to delay the opening of the scrcpy window
        //  - the buffering estimation needs at least two clock points, so it
        //  could not handle the first frame
        return sc_video_buffer_offer(vb, frame);
    }
    struct sc_video_buffer_frame *vb_frame = sc_video_buffer_frame_new(frame);
    if (!vb_frame) {
        sc_mutex_unlock(&vb->b.mutex);
        LOGE("Could not allocate frame");
        return false;
    }
 #ifndef SC_BUFFERING_NDEBUG
    vb_frame->push_date = sc_tick_now();
 #endif
    sc_queue_push(&vb->b.queue, next, vb_frame);
    sc_cond_signal(&vb->b.queue_cond);
    sc_mutex_unlock(&vb->b.mutex);
    return true;
 }
 void
 sc_video_buffer_consume(struct sc_video_buffer *vb, AVFrame *dst) {
    sc_frame_buffer_consume(&vb->fb, dst);
 }
--- a/app/src/video_buffer.h
+++ b/app/src/video_buffer.h
@@ -1,76 +1,50 @@
-#ifndef SC_VIDEO_BUFFER_H
+#ifndef VIDEO_BUFFER_H
-#define SC_VIDEO_BUFFER_H
+#define VIDEO_BUFFER_H
 #include "common.h"
 #include <stdbool.h>
-#include "clock.h"
+#include "fps_counter.h"
 #include "frame_buffer.h"
 #include "util/queue.h"
 #include "util/thread.h"
 #include "util/tick.h"
 // forward declarations
 typedef struct AVFrame AVFrame;
-struct sc_video_buffer_frame {
+/**
-    AVFrame *frame;
+ * A video buffer holds 1 pending frame, which is the last frame received from
-    struct sc_video_buffer_frame *next;
+ * the producer (typically, the decoder).
-#ifndef NDEBUG
+ *
-    sc_tick push_date;
+ * If a pending frame has not been consumed when the producer pushes a new
-#endif
+ * frame, then it is lost. The intent is to always provide access to the very
-};
+ * last frame to minimize latency.
 *
 * The producer and the consumer typically do not live in the same thread.
 * That's the reason why the callback on_frame_available() does not provide the
 * frame as parameter: the consumer might post an event to its own thread to
 * retrieve the pending frame from there, and that frame may have changed since
 * the callback if producer pushed a new one in between.
 */
-struct sc_video_buffer_frame_queue SC_QUEUE(struct sc_video_buffer_frame);
+struct video_buffer {
    AVFrame *pending_frame;
    AVFrame *tmp_frame; // To preserve the pending frame on error
-struct sc_video_buffer {
+    sc_mutex mutex;
    struct sc_frame_buffer fb;
-    sc_tick buffering_time;
+    bool pending_frame_consumed;
    // only if buffering_time > 0
    struct {
        sc_thread thread;
        sc_mutex mutex;
        sc_cond queue_cond;
        sc_cond wait_cond;
        struct sc_clock clock;
        struct sc_video_buffer_frame_queue queue;
        bool stopped;
    } b; // buffering
    const struct sc_video_buffer_callbacks *cbs;
    void *cbs_userdata;
 };
 struct sc_video_buffer_callbacks {
    void (*on_new_frame)(struct sc_video_buffer *vb, bool previous_skipped,
                         void *userdata);
 };
 bool
-sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
+video_buffer_init(struct video_buffer *vb);
-                     const struct sc_video_buffer_callbacks *cbs,
+
-                     void *cbs_userdata);
+void
 video_buffer_destroy(struct video_buffer *vb);
 bool
-sc_video_buffer_start(struct sc_video_buffer *vb);
+video_buffer_push(struct video_buffer *vb, const AVFrame *frame, bool *skipped);
 void
-sc_video_buffer_stop(struct sc_video_buffer *vb);
+video_buffer_consume(struct video_buffer *vb, AVFrame *dst);
 void
 sc_video_buffer_join(struct sc_video_buffer *vb);
 void
 sc_video_buffer_destroy(struct sc_video_buffer *vb);
 bool
 sc_video_buffer_push(struct sc_video_buffer *vb, const AVFrame *frame);
 void
 sc_video_buffer_consume(struct sc_video_buffer *vb, AVFrame *dst);
 #endif
--- a/app/tests/test_cli.c
+++ b/app/tests/test_cli.c
@@ -4,11 +4,11 @@
 #include <string.h>
 #include "cli.h"
-#include "options.h"
+#include "scrcpy.h"
 static void test_flag_version(void) {
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
@@ -23,7 +23,7 @@ static void test_flag_version(void) {
 static void test_flag_help(void) {
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
@@ -38,7 +38,7 @@ static void test_flag_help(void) {
 static void test_options(void) {
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
@@ -51,7 +51,7 @@ static void test_options(void) {
        "--fullscreen",
        "--max-fps", "30",
        "--max-size", "1024",
-        "--lock-video-orientation=2", // optional arguments require '='
+        "--lock-video-orientation", "2",
        // "--no-control" is not compatible with "--turn-screen-off"
        // "--no-display" is not compatible with "--fulscreen"
        "--port", "1234:1236",
@@ -100,7 +100,7 @@ static void test_options(void) {
 static void test_options2(void) {
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
--- a/app/tests/test_clock.c
+++ b/app/tests/test_clock.c
@@ -1,79 +0,0 @@
 #include "common.h"
 #include <assert.h>
 #include "clock.h"
 void test_small_rolling_sum(void) {
    struct sc_clock clock;
    sc_clock_init(&clock);
    assert(clock.count == 0);
    assert(clock.left_sum.system == 0);
    assert(clock.left_sum.stream == 0);
    assert(clock.right_sum.system == 0);
    assert(clock.right_sum.stream == 0);
    sc_clock_update(&clock, 2, 3);
    assert(clock.count == 1);
    assert(clock.left_sum.system == 0);
    assert(clock.left_sum.stream == 0);
    assert(clock.right_sum.system == 2);
    assert(clock.right_sum.stream == 3);
    sc_clock_update(&clock, 10, 20);
    assert(clock.count == 2);
    assert(clock.left_sum.system == 2);
    assert(clock.left_sum.stream == 3);
    assert(clock.right_sum.system == 10);
    assert(clock.right_sum.stream == 20);
    sc_clock_update(&clock, 40, 80);
    assert(clock.count == 3);
    assert(clock.left_sum.system == 2);
    assert(clock.left_sum.stream == 3);
    assert(clock.right_sum.system == 50);
    assert(clock.right_sum.stream == 100);
    sc_clock_update(&clock, 400, 800);
    assert(clock.count == 4);
    assert(clock.left_sum.system == 12);
    assert(clock.left_sum.stream == 23);
    assert(clock.right_sum.system == 440);
    assert(clock.right_sum.stream == 880);
 }
 void test_large_rolling_sum(void) {
    const unsigned half_range = SC_CLOCK_RANGE / 2;
    struct sc_clock clock1;
    sc_clock_init(&clock1);
    for (unsigned i = 0; i < 5 * half_range; ++i) {
        sc_clock_update(&clock1, i, 2 * i + 1);
    }
    struct sc_clock clock2;
    sc_clock_init(&clock2);
    for (unsigned i = 3 * half_range; i < 5 * half_range; ++i) {
        sc_clock_update(&clock2, i, 2 * i + 1);
    }
    assert(clock1.count == SC_CLOCK_RANGE);
    assert(clock2.count == SC_CLOCK_RANGE);
    // The values before the last SC_CLOCK_RANGE points in clock1 should have
    // no impact
    assert(clock1.left_sum.system == clock2.left_sum.system);
    assert(clock1.left_sum.stream == clock2.left_sum.stream);
    assert(clock1.right_sum.system == clock2.right_sum.system);
    assert(clock1.right_sum.stream == clock2.right_sum.stream);
 }
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;
    test_small_rolling_sum();
    test_large_rolling_sum();
    return 0;
 };
--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@@ -146,18 +146,14 @@ static void test_serialize_inject_scroll_event(void) {
 static void test_serialize_back_or_screen_on(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
        .back_or_screen_on = {
            .action = AKEY_EVENT_ACTION_UP,
        },
    };
    unsigned char buf[CONTROL_MSG_MAX_SIZE];
    size_t size = control_msg_serialize(&msg, buf);
-    assert(size == 2);
+    assert(size == 1);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
        0x01, // AKEY_EVENT_ACTION_UP
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
@@ -177,9 +173,9 @@ static void test_serialize_expand_notification_panel(void) {
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
-static void test_serialize_expand_settings_panel(void) {
+static void test_serialize_collapse_notification_panel(void) {
    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+        .type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
    };
    unsigned char buf[CONTROL_MSG_MAX_SIZE];
@@ -187,22 +183,7 @@ static void test_serialize_expand_settings_panel(void) {
    assert(size == 1);
    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+        CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
 static void test_serialize_collapse_panels(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_COLLAPSE_PANELS,
    };
    unsigned char buf[CONTROL_MSG_MAX_SIZE];
    size_t size = control_msg_serialize(&msg, buf);
    assert(size == 1);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_COLLAPSE_PANELS,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
@@ -289,8 +270,7 @@ int main(int argc, char *argv[]) {
    test_serialize_inject_scroll_event();
    test_serialize_back_or_screen_on();
    test_serialize_expand_notification_panel();
-    test_serialize_expand_settings_panel();
+    test_serialize_collapse_notification_panel();
    test_serialize_collapse_panels();
    test_serialize_get_clipboard();
    test_serialize_set_clipboard();
    test_serialize_set_screen_power_mode();
--- a/app/tests/test_queue.c
+++ b/app/tests/test_queue.c
@@ -10,28 +10,28 @@ struct foo {
 };
 static void test_queue(void) {
-    struct my_queue SC_QUEUE(struct foo) queue;
+    struct my_queue QUEUE(struct foo) queue;
-    sc_queue_init(&queue);
+    queue_init(&queue);
-    assert(sc_queue_is_empty(&queue));
+    assert(queue_is_empty(&queue));
    struct foo v1 = { .value = 42 };
    struct foo v2 = { .value = 27 };
-    sc_queue_push(&queue, next, &v1);
+    queue_push(&queue, next, &v1);
-    sc_queue_push(&queue, next, &v2);
+    queue_push(&queue, next, &v2);
    struct foo *foo;
-    assert(!sc_queue_is_empty(&queue));
+    assert(!queue_is_empty(&queue));
-    sc_queue_take(&queue, next, &foo);
+    queue_take(&queue, next, &foo);
    assert(foo->value == 42);
-    assert(!sc_queue_is_empty(&queue));
+    assert(!queue_is_empty(&queue));
-    sc_queue_take(&queue, next, &foo);
+    queue_take(&queue, next, &foo);
    assert(foo->value == 27);
-    assert(sc_queue_is_empty(&queue));
+    assert(queue_is_empty(&queue));
 }
 int main(int argc, char *argv[]) {
--- a/app/tests/test_strbuf.c
+++ b/app/tests/test_strbuf.c
@@ -1,47 +0,0 @@
 #include "common.h"
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
 #include "util/strbuf.h"
 static void test_strbuf_simple(void) {
    struct sc_strbuf buf;
    bool ok = sc_strbuf_init(&buf, 10);
    assert(ok);
    ok = sc_strbuf_append_staticstr(&buf, "Hello");
    assert(ok);
    ok = sc_strbuf_append_char(&buf, ' ');
    assert(ok);
    ok = sc_strbuf_append_staticstr(&buf, "world");
    assert(ok);
    ok = sc_strbuf_append_staticstr(&buf, "!\n");
    assert(ok);
    ok = sc_strbuf_append_staticstr(&buf, "This is a test");
    assert(ok);
    ok = sc_strbuf_append_n(&buf, '.', 3);
    assert(ok);
    assert(!strcmp(buf.s, "Hello world!\nThis is a test..."));
    sc_strbuf_shrink(&buf);
    assert(buf.len == buf.cap);
    assert(!strcmp(buf.s, "Hello world!\nThis is a test..."));
    free(buf.s);
 }
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;
    test_strbuf_simple();
    return 0;
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Romain Vimont	6093235a96	Assert screen closed on destroy The destruction order is important, but tricky, because the screen is open/close by the decoder, but destroyed by scrcpy.c on the main thread. Add assertions to guarantee that the screen is not destroyed before being closed.	2021-04-12 15:20:54 +02:00
Romain Vimont	9307cb3c96	Remove video_buffer callbacks Now that screen is both the owner and the listener of the video buffer, execute the code directly without callbacks.	2021-04-12 15:20:54 +02:00
Romain Vimont	350d9bfbfb	Move video_buffer to screen The video buffer is now an internal detail of the screen component. Since the screen is plugged to the decoder via the frame sink trait, the decoder does not access to the video buffer anymore.	2021-04-12 15:20:54 +02:00
Romain Vimont	082083b83e	Make decoder push frames to sinks Now that screen implements the packet sink trait, make decoder push packets to the sinks without depending on the concrete sink types.	2021-04-12 15:20:54 +02:00
Romain Vimont	58c2619a6d	Expose screen as frame sink Make screen implement the frame sink trait. This will allow the decoder to push frames without depending on the concrete sink type.	2021-04-12 15:20:54 +02:00
Romain Vimont	6ba6ec40e3	Add frame sink trait This trait will allow to abstract the concrete sink types from the frame producer (decoder.c).	2021-04-12 15:20:54 +02:00
Romain Vimont	070525de06	Make stream push packets to sinks Now that decoder and recorder implement the packet sink trait, make stream push packets to the sinks without depending on the concrete sink types.	2021-04-12 15:20:54 +02:00
Romain Vimont	3fb0594fe8	Expose decoder as packet sink Make decoder implement the packet sink trait. This will allow the stream to push packets without depending on the concrete sink type.	2021-04-12 15:20:54 +02:00
Romain Vimont	d470943505	Reorder decoder functions This will make further commits more readable.	2021-04-12 15:20:54 +02:00
Romain Vimont	1be76c5113	Expose recorder as packet sink Make recorder implement the packet sink trait. This will allow the stream to push packets without depending on the concrete sink type.	2021-04-12 15:20:54 +02:00
Romain Vimont	6ff4e5c926	Privatize recorder threading The fact that the recorder uses a separate thread is an internal detail, so the functions _start(), _stop() and _join() should not be exposed. Instead, start the thread on _open() and _stop()+_join() on close(). This paves the way to expose the recorder as a packet sink trait.	2021-04-12 15:20:54 +02:00
Romain Vimont	b2e9270e53	Reorder recorder functions This will make further commits more readable.	2021-04-12 15:20:54 +02:00
Romain Vimont	f3879fc92d	Add packet sink trait This trait will allow to abstract the concrete sink types from the packet producer (stream.c).	2021-04-12 15:20:54 +02:00
Romain Vimont	042ace4b4e	Add container_of() macro This will allow to get the parent of an embedded struct.	2021-04-11 15:01:05 +02:00
Romain Vimont	f43d66d5d6	Make video_buffer more generic The video buffer took ownership of the producer frame (so that it could swap frames quickly). In order to support multiple sinks plugged to the decoder, the decoded frame must not be consumed by the display video buffer. Therefore, move the producer and consumer frames out of the video buffer, and use FFmpeg AVFrame refcounting to share ownership while avoiding copies.	2021-04-11 15:01:05 +02:00
Romain Vimont	e1b2824730	Remove compat with old FFmpeg codec params API The new API has been introduced in 2016 in libavformat 57.xx, it's very old. This will avoid to maintain two code paths for codec parameters.	2021-04-11 15:01:05 +02:00
Romain Vimont	19b518bf24	Remove compat with old FFmpeg decoding API The new API has been introduced in 2016 in libavcodec 57.xx, it's very old. This will avoid to maintain two code paths for decoding.	2021-04-11 15:01:05 +02:00
Romain Vimont	3ffea72fa6	Remove option --render-expired-frames This flag forced the decoder to wait for the previous frame to be consumed by the display. It was initially implemented as a compilation flag for testing, not intended to be exposed at runtime. But to remove ifdefs and to allow users to test this flag easily, it had finally been exposed by commit `ebccb9f6cc`. In practice, it turned out to be useless: it had no practical impact, and it did not solve or mitigate any performance issues causing frame skipping. But that added some complexity to the codebase: it required an additional condition variable, and made video buffer calls possibly blocking, which in turn required code to interrupt it on exit. To prepare support for multiple sinks plugged to the decoder (display and v4l2 for example), the blocking call used for pacing the decoder output becomes unacceptable, so just remove this useless "feature".	2021-04-11 15:01:05 +02:00
Romain Vimont	a34bd5c43b	Write trailer from recorder thread The recorder thread wrote the whole content except the trailer, which was odd.	2021-04-11 15:01:05 +02:00