Compensate slope on start

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.
Add buffering debugging tools
2021-07-14 00:39:35 +02:00 · 2021-07-14 00:39:35 +02:00 · 2021-07-14 00:39:35 +02:00 · 2021-07-14 00:39:35 +02:00 · 2021-07-14 00:39:35 +02:00 · 2021-07-14 00:39:35 +02:00
54 changed files with 500 additions and 3339 deletions
--- a/BUILD.md
+++ b/BUILD.md
@@ -88,12 +88,11 @@ Install the required packages from your package manager.
 ```bash
 # runtime dependencies
-sudo apt install ffmpeg libsdl2-2.0-0 adb libusb-1.0-0
+sudo apt install ffmpeg libsdl2-2.0-0 adb
 # client build dependencies
 sudo apt install gcc git pkg-config meson ninja-build libsdl2-dev \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev\
+                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev
                 libusb-dev
 # server build dependencies
 sudo apt install openjdk-11-jdk
@@ -115,7 +114,7 @@ pip3 install meson
 sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
 # client build dependencies
-sudo dnf install SDL2-devel ffms2-devel libusb-devel meson gcc make
+sudo dnf install SDL2-devel ffms2-devel meson gcc make
 # server build dependencies
 sudo dnf install java-devel
@@ -160,8 +159,7 @@ install the required packages:
 ```bash
 # runtime dependencies
 pacman -S mingw-w64-x86_64-SDL2 \
-          mingw-w64-x86_64-ffmpeg \
+          mingw-w64-x86_64-ffmpeg
          mingw-w64-x86_64-libusb
 # client build dependencies
 pacman -S mingw-w64-x86_64-make \
@@ -175,8 +173,7 @@ For a 32 bits version, replace `x86_64` by `i686`:
 ```bash
 # runtime dependencies
 pacman -S mingw-w64-i686-SDL2 \
-          mingw-w64-i686-ffmpeg \
+          mingw-w64-i686-ffmpeg
          mingw-w64-i686-libusb
 # client build dependencies
 pacman -S mingw-w64-i686-make \
@@ -200,7 +197,7 @@ Install the packages with [Homebrew]:
 ```bash
 # runtime dependencies
-brew install sdl2 ffmpeg libusb
+brew install sdl2 ffmpeg
 # client build dependencies
 brew install pkg-config meson
@@ -271,10 +268,10 @@ install` must be run as root)._
 #### Option 2: Use prebuilt server
- - [`scrcpy-server-v1.19`][direct-scrcpy-server]  
+ - [`scrcpy-server-v1.18`][direct-scrcpy-server]  
-   _(SHA-256: 876f9322182e6aac6a58db1334f4225855ef3a17eaebc80aab6601d9d1ecb867)_
+   _(SHA-256: 641c5c6beda9399dfae72d116f5ff43b5ed1059d871c9ebc3f47610fd33c51a3)_
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.19/scrcpy-server-v1.19
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-server-v1.18
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/DEVELOP.md
+++ b/DEVELOP.md
@@ -76,7 +76,7 @@ The server uses 3 threads:
 - the **main** thread, encoding and streaming the video to the client;
 - the **controller** thread, listening for _control messages_ (typically,
   keyboard and mouse events) from the client;
- - the **receiver** thread (managed by the controller), sending _device messages_
+ - the **receiver** thread (managed by the controller), sending _device messges_
   to the clients (currently, it is only used to send the device clipboard
   content).
--- a/FAQ.it.md
+++ b/FAQ.it.md
@@ -140,24 +140,6 @@ Potresti anche dover configurare il [comportamento di ridimensionamento][scaling
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 ### Problema con Wayland
 Per impostazione predefinita, SDL utilizza x11 su Linux. Il [video driver] può essere cambiato attraversio la variabile d'ambiente `SDL_VIDEODRIVER`:
 [video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
 ```bash
 export SDL_VIDEODRIVER=wayland
 scrcpy
 ```
 Su alcune distribuzioni (almeno Fedora), il pacchetto `libdecor` deve essere installato manualmente.
 Vedi le issues [#2554] e [#2559].
 [#2554]: https://github.com/Genymobile/scrcpy/issues/2554
 [#2559]: https://github.com/Genymobile/scrcpy/issues/2559
 ### Crash del compositore KWin
--- a/FAQ.md
+++ b/FAQ.md
@@ -153,26 +153,6 @@ You may also need to configure the [scaling behavior]:
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 ### Issue with Wayland
 By default, SDL uses x11 on Linux. The [video driver] can be changed via the
 `SDL_VIDEODRIVER` environment variable:
 [video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
 ```bash
 export SDL_VIDEODRIVER=wayland
 scrcpy
 ```
 On some distributions (at least Fedora), the package `libdecor` must be
 installed manually.
 See issues [#2554] and [#2559].
 [#2554]: https://github.com/Genymobile/scrcpy/issues/2554
 [#2559]: https://github.com/Genymobile/scrcpy/issues/2559
 ### KWin compositor crashes
@@ -258,6 +238,5 @@ to add some arguments.
 This FAQ is available in other languages:
- - [Italiano (Italiano, `it`) - v1.19](FAQ.it.md)
+ - [Italiano (Italiano, `it`) - v1.17](FAQ.it.md)
 - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.18](FAQ.zh-Hans.md)
--- a/FAQ.zh-Hans.md
+++ b/FAQ.zh-Hans.md
@@ -1,240 +0,0 @@
 只有原版的[FAQ](FAQ.md)会保持更新。
 本文根据[d6aaa5]翻译。
 [d6aaa5]:https://github.com/Genymobile/scrcpy/blob/d6aaa5bf9aa3710660c683b6e3e0ed971ee44af5/FAQ.md
 # 常见问题
 这里是一些常见的问题以及他们的状态。
 ## `adb` 相关问题
 `scrcpy` 执行 `adb` 命令来初始化和设备之间的连接。如果`adb` 执行失败了， scrcpy 就无法工作。
 在这种情况中，将会输出这个错误:
 >     ERROR: "adb push" returned with value 1
 这通常不是 _scrcpy_ 的bug，而是你的环境的问题。
 要找出原因，请执行以下操作：
 ```bash
 adb devices
 ```
 ### 找不到`adb`
 你的`PATH`中需要能访问到`adb`。
 在Windows上，当前目录会包含在`PATH`中，并且`adb.exe`也包含在发行版中，因此它应该是开箱即用（直接解压就可以）的。
 ### 设备未授权
 参见这里 [stackoverflow][device-unauthorized].
 [device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
 ### 未检测到设备
 >     adb: error: failed to get feature set: no devices/emulators found
 确认已经正确启用 [adb debugging][enable-adb].
 如果你的设备没有被检测到，你可能需要一些[驱动][drivers] (在 Windows上).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
 ### 已连接多个设备
 如果连接了多个设备，您将遇到以下错误：
 >     adb: error: failed to get feature set: more than one device/emulator
 必须提供要镜像的设备的标识符：
 ```bash
 scrcpy -s 01234567890abcdef
 ```
 注意，如果你的设备是通过 TCP/IP 连接的， 你将会收到以下消息：
 >     adb: error: more than one device/emulator
 >     ERROR: "adb reverse" returned with value 1
 >     WARN: 'adb reverse' failed, fallback to 'adb forward'
 这是意料之中的 (由于旧版安卓的一个bug, 请参见 [#5])，但是在这种情况下，scrcpy会退回到另一种方法，这种方法应该可以起作用。
 [#5]: https://github.com/Genymobile/scrcpy/issues/5
 ### adb版本之间冲突
 >     adb server version (41) doesn't match this client (39); killing...
 同时使用多个版本的`adb`时会发生此错误。你必须查找使用不同`adb`版本的程序，并在所有地方使用相同版本的`adb`。
 你可以覆盖另一个程序中的`adb`二进制文件，或者通过设置`ADB`环境变量来让 _scrcpy_ 使用特定的`adb`二进制文件。
 ```bash
 set ADB=/path/to/your/adb
 scrcpy
 ```
 ### 设备断开连接
 如果 _scrcpy_ 在警告“设备连接断开”的情况下自动中止，那就意味着`adb`连接已经断开了。
 请尝试使用另一条USB线或者电脑上的另一个USB接口。
 请参看 [#281] 和 [#283]。
 [#281]: https://github.com/Genymobile/scrcpy/issues/281
 [#283]: https://github.com/Genymobile/scrcpy/issues/283
 ## 控制相关问题
 ### 鼠标和键盘不起作用
 在某些设备上，您可能需要启用一个选项以允许 [模拟输入][simulating input]。
 在开发者选项中，打开：
 > **USB调试 (安全设置)**  
 > _允许通过USB调试修改权限或模拟点击_
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ### 特殊字符不起作用
 可输入的文本[被限制为ASCII字符][text-input]。也可以用一些小技巧输入一些[带重音符号的字符][accented-characters]，但是仅此而已。参见[#37]。
 [text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
 [accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
 [#37]: https://github.com/Genymobile/scrcpy/issues/37
 ## 客户端相关问题
 ### 效果很差
 如果你的客户端窗口分辨率比你的设备屏幕小，则可能出现效果差的问题，尤其是在文本上（参见 [#40]）。
 [#40]: https://github.com/Genymobile/scrcpy/issues/40
 为了提升降尺度的质量，如果渲染器是OpenGL并且支持mip映射，就会自动开启三线性过滤。
 在Windows上，你可能希望强制使用OpenGL：
 ```
 scrcpy --render-driver=opengl
 ```
 你可能还需要配置[缩放行为][scaling behavior]：
 > `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
 > Override high DPI scaling behavior > Scaling performed by: _Application_.
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 ### Wayland相关的问题
 在Linux上，SDL默认使用x11。可以通过`SDL_VIDEODRIVER`环境变量来更改[视频驱动][video driver]：
 [video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
 ```bash
 export SDL_VIDEODRIVER=wayland
 scrcpy
 ```
 在一些发行版上 (至少包括 Fedora)， `libdecor` 包必须手动安装。
 参见 [#2554] 和 [#2559]。
 [#2554]: https://github.com/Genymobile/scrcpy/issues/2554
 [#2559]: https://github.com/Genymobile/scrcpy/issues/2559
 ### KWin compositor 崩溃
 在Plasma桌面中，当 _scrcpy_ 运行时，会禁用compositor。
 一种解决方法是， [禁用 "Block compositing"][kwin].
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
 ## 崩溃
 ### 异常
 可能有很多原因。一个常见的原因是您的设备无法按给定清晰度进行编码：
 > ```
 > ERROR: Exception on thread Thread[main,5,main]
 > android.media.MediaCodec$CodecException: Error 0xfffffc0e
 > ...
 > Exit due to uncaughtException in main thread:
 > ERROR: Could not open video stream
 > INFO: Initial texture: 1080x2336
 > ```
 或者
 > ```
 > ERROR: Exception on thread Thread[main,5,main]
 > java.lang.IllegalStateException
 >         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
 > ```
 请尝试使用更低的清晰度：
 ```
 scrcpy -m 1920
 scrcpy -m 1024
 scrcpy -m 800
 ```
 你也可以尝试另一种 [编码器](README.md#encoder)。
 ## Windows命令行
 一些Windows用户不熟悉命令行。以下是如何打开终端并带参数执行`scrcpy`：
 1. 按下 <kbd>Windows</kbd>+<kbd>r</kbd>，打开一个对话框。
 2. 输入 `cmd` 并按 <kbd>Enter</kbd>，这样就打开了一个终端。
 3. 通过输入以下命令，切换到你的 _scrcpy_ 所在的目录 （根据你的实际位置修改路径）:
    ```bat
    cd C:\Users\user\Downloads\scrcpy-win64-xxx
    ```
    然后按 <kbd>Enter</kbd>
 4. 输入你的命令。比如:
    ```bat
    scrcpy --record file.mkv
    ```
 如果你打算总是使用相同的参数，在`scrcpy`目录创建一个文件 `myscrcpy.bat`
 （启用 [显示文件拓展名][show file extensions] 避免混淆），文件中包含你的命令。例如：
 ```bat
 scrcpy --prefer-text --turn-screen-off --stay-awake
 ```
 然后双击刚刚创建的文件。
 你也可以编辑 `scrcpy-console.bat` 或者 `scrcpy-noconsole.vbs`（的副本）来添加参数。
 [show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/
--- a/README.it.md
+++ b/README.it.md
@@ -1,6 +1,6 @@
 _Apri il [README](README.md) originale e sempre aggiornato._
-# scrcpy (v1.19)
+# scrcpy (v1.17)
 Questa applicazione fornisce la visualizzazione e il controllo dei dispositivi Android collegati via USB (o [via TCP/IP][article-tcpip]). Non richiede alcun accesso _root_.
 Funziona su _GNU/Linux_, _Windows_ e _macOS_.
@@ -205,11 +205,10 @@ Se anche `--max-size` è specificata, il ridimensionamento è applicato dopo il
 Per bloccare l'orientamento della trasmissione:
 ```bash
-scrcpy --lock-video-orientation     # orientamento iniziale (corrente)
+scrcpy --lock-video-orientation 0   # orientamento naturale
-scrcpy --lock-video-orientation=0   # orientamento naturale
+scrcpy --lock-video-orientation 1   # 90° antiorario
-scrcpy --lock-video-orientation=1   # 90° antiorario
+scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation 3   # 90° orario
 scrcpy --lock-video-orientation=3   # 90° orario
 ```
 Questo influisce sull'orientamento della registrazione.
@@ -232,9 +231,7 @@ Per elencare i codificatori disponibili puoi immettere un nome di codificatore n
 scrcpy --encoder _
 ```
-### Cattura
+### Registrazione
 #### Registrazione
 È possibile registrare lo schermo durante la trasmissione:
@@ -256,75 +253,6 @@ I "fotogrammi saltati" sono registrati nonostante non siano mostrati in tempo re
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 #### v4l2loopback
 Su Linux è possibile inviare il flusso video ad un dispositivo v4l2 loopback, cosicchè un dispositivo Android possa essere aperto come una webcam da qualsiasi strumento compatibile con v4l2.
 Il modulo `v4l2loopback` deve essere installato:
 ```bash
 sudo apt install v4l2loopback-dkms
 ```
 Per creare un dispositvo v4l2:
 ```bash
 sudo modprobe v4l2loopback
 ```
 Questo creerà un nuovo dispositivo video in `/dev/videoN` dove `N` è un intero (più [opzioni](https://github.com/umlaeute/v4l2loopback#options) sono disponibili per crere più dispositivi o dispositivi con ID specifici).
 Per elencare i dispositvi attivati:
 ```bash
 # necessita del pacchetto v4l-utils
 v4l2-ctl --list-devices
 # semplice ma potrebbe essere sufficiente
 ls /dev/video*
 ```
 Per avviare scrcpy utilizzando un v4l2 sink:
 ```bash
 scrcpy --v4l2-sink=/dev/videoN
 scrcpy --v4l2-sink=/dev/videoN --no-display  # disabilita la finestra di trasmissione
 scrcpy --v4l2-sink=/dev/videoN -N            # versione corta
 ```
 (sostituisci `N` con l'ID del dispositivo, controlla con `ls /dev/video*`)
 Una volta abilitato, puoi aprire il tuo flusso video con uno strumento compatibile con v4l2:
 ```bash
 ffplay -i /dev/videoN
 vlc v4l2:///dev/videoN   # VLC potrebbe aggiungere del ritardo per il buffer
 ```
 Per esempio potresti catturare il video in [OBS].
 [OBS]: https://obsproject.com/
 #### Buffering
 È possibile aggiungere del buffer. Questo aumenta la latenza ma riduce il jitter (vedi [#2464]).
 [#2464]: https://github.com/Genymobile/scrcpy/issues/2464
 L'opzione è disponibile per il buffer della visualizzazione:
 ```bash
 scrcpy --display-buffer=50  # aggiungi 50 ms di buffer per la visualizzazione
 ```
 e per il V4L2 sink:
 ```bash
 scrcpy --v4l2-buffer=500    #  aggiungi 50 ms di buffer per il v4l2 sink
 ```
 ### Connessione
 #### Wireless
@@ -551,6 +479,15 @@ scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
 #### Renderizzare i fotogrammi scaduti
 Per minimizzare la latenza _scrcpy_ renderizza sempre l'ultimo fotogramma decodificato disponibile in maniera predefinita e tralascia quelli precedenti.
 Per forzare la renderizzazione di tutti i fotogrammi (a costo di una possibile latenza superiore), utilizzare:
 ```bash
 scrcpy --render-expired-frames
 ```
 #### Mostrare i tocchi
@@ -670,14 +607,14 @@ Non c'è alcuna risposta visiva, un log è stampato nella console.
 #### Trasferimento di file verso il dispositivo
-Per trasferire un file in `/sdcard/Download` del dispositivo trascina e rilascia un file (non APK) nella finestra di _scrcpy_.
+Per trasferire un file in `/sdcard/` del dispositivo trascina e rilascia un file (non APK) nella finestra di _scrcpy_.
 Non c'è alcuna risposta visiva, un log è stampato nella console.
 La cartella di destinazione può essere cambiata all'avvio:
 ```bash
-scrcpy --push-target=/sdcard/Movies/
+scrcpy --push-target=/sdcard/Download/
 ```
@@ -716,10 +653,10 @@ _<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
 | Rotazione schermo a sinistra                         | <kbd>MOD</kbd>+<kbd>←</kbd> _(sinistra)_
 | Rotazione schermo a destra                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(destra)_
 | Ridimensiona finestra a 1:1 (pixel-perfect)        | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Ridimensiona la finestra per rimuovere i bordi neri       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doppio click sinistro¹_
+ | Ridimensiona la finestra per rimuovere i bordi neri       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doppio click¹_
 | Premi il tasto `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Click centrale_
 | Premi il tasto `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Click destro²_
- | Premi il tasto `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4° click³_
+ | Premi il tasto `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd>
 | Premi il tasto `MENU` (sblocca lo schermo)             | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Premi il tasto `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(su)_
 | Premi il tasto `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(giù)_
@@ -728,26 +665,18 @@ _<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
 | Spegni lo schermo del dispositivo (continua a trasmettere)     | <kbd>MOD</kbd>+<kbd>o</kbd>
 | Accendi lo schermo del dispositivo                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Ruota lo schermo del dispositivo                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Espandi il pannello delle notifiche                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5° click³_
+ | Espandi il pannello delle notifiche                   | <kbd>MOD</kbd>+<kbd>n</kbd>
- | Espandi il pannello delle impostazioni                   | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Doppio 5° click³_
+ | Chiudi il pannello delle notifiche                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Chiudi pannelli                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copia negli appunti³                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Copia negli appunti⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Taglia negli appunti³                           | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Taglia negli appunti⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Sincronizza gli appunti e incolla³           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Sincronizza gli appunti e incolla⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Inietta il testo degli appunti del computer              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Abilita/Disabilita il contatore FPS (su stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
 | Pizzica per zoomare                               | <kbd>Ctrl</kbd>+_click e trascina_
 _¹Doppio click sui bordi neri per rimuoverli._  
 _²Il tasto destro accende lo schermo se era spento, preme BACK in caso contrario._  
-_³4° e 5° pulsante del mouse, se il tuo mouse ne dispone._  
+_³Solo in Android >= 7._
 _⁴Solo in Android >= 7._
 Le scorciatoie con pulsanti ripetuti sono eseguite rilasciando e premendo il pulsante una seconda volta. Per esempio, per eseguire "Espandi il pannello delle impostazioni":
 1. Premi e tieni premuto <kbd>MOD</kbd>.
 2. Poi premi due volte <kbd>n</kbd>.
 3. Infine rilascia <kbd>MOD</kbd>.
 Tutte le scorciatoie <kbd>Ctrl</kbd>+_tasto_ sono inoltrate al dispositivo, così sono gestite dall'applicazione attiva.
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# scrcpy (v1.19)
+# scrcpy (v1.18)
 [Read in another language](#translations)
@@ -88,10 +88,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.18.zip`][direct-win64]  
-   _(SHA-256: 383d6483f25ac0092d4bb9fef6c967351ecd50fc248e0c82932db97d6d32f11b)_
+   _(SHA-256: 37212f5087fe6f3e258f1d44fa5c02207496b30e1d7ec442cbcf8358910a5c63)_
-[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.18/scrcpy-win64-v1.18.zip
 It is also available in [Chocolatey]:
@@ -207,29 +207,6 @@ scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
 If `--max-size` is also specified, resizing is applied after cropping.
 #### USB HID over AOAv2
 Scrcpy can simulate a USB physical keyboard on Android to provide better input
 experience, you need to connect your device via USB, not wireless.
 However, due to some limitation of libusb and WinUSB driver, you cannot use HID
 over AOAv2 on Windows.
 Currently a USB serial number is needed to use HID over AOAv2.
 ```bash
 scrcpy --serial XXXXXXXXXXXXXXXX # don't use HID
 scrcpy --serial XXXXXXXXXXXXXXXX --input-mode inject # don't use HID
 scrcpy --serial XXXXXXXXXXXXXXXX --input-mode hid # try HID and exit if failed
 ```
 Serial number can be found by `adb get-serialno`.
 If you are a non-QWERTY keyboard user and using HID mode, please remember to set
 correct physical keyboard layout manually in Android settings, because scrcpy
 just forwards scancodes to Android device and Android system is responsible for
 converting scancodes to correct keycode on Android device (your system does this
 on your PC).
 #### Lock video orientation
@@ -341,15 +318,13 @@ vlc v4l2:///dev/videoN   # VLC might add some buffering delay
 For example, you could capture the video within [OBS].
-[OBS]: https://obsproject.com/
+[OBS]: https://obsproject.com/fr
 #### Buffering
 It is possible to add buffering. This increases latency but reduces jitter (see
-[#2464]).
+#2464).
 [#2464]: https://github.com/Genymobile/scrcpy/issues/2464
 The option is available for display buffering:
@@ -911,13 +886,12 @@ Read the [developers page].
 This README is available in other languages:
 - [Indonesian (Indonesia, `id`) - v1.16](README.id.md)
- [Italiano (Italiano, `it`) - v1.19](README.it.md)
+- [Italiano (Italiano, `it`) - v1.17](README.it.md)
 - [日本語 (Japanese, `jp`) - v1.17](README.jp.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
- [Português Brasileiro (Brazilian Portuguese, `pt-BR`) - v1.19](README.pt-br.md)
+- [português brasileiro (Brazilian Portuguese, `pt-BR`) - v1.17](README.pt-br.md)
 - [Español (Spanish, `sp`) - v1.17](README.sp.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.17](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
 - [Turkish (Turkish, `tr`) - v1.18](README.tr.md)
 Only this README file is guaranteed to be up-to-date.
--- a/README.pt-br.md
+++ b/README.pt-br.md
@@ -1,6 +1,6 @@
 _Apenas o [README](README.md) original é garantido estar atualizado._
-# scrcpy (v1.19)
+# scrcpy (v1.17)
 Esta aplicação fornece exibição e controle de dispositivos Android conectados via
 USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso _root_.
@@ -38,18 +38,6 @@ controlá-lo usando teclado e mouse.
 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
 ### Sumário
 - Linux: `apt install scrcpy`
 - Windows: [baixar][direct-win64]
 - macOS: `brew install scrcpy`
  Compilar pelos arquivos fontes: [BUILD] ([processo simplificado][BUILD_simple])
 [BUILD]: BUILD.md
 [BUILD_simple]: BUILD.md#simple
 ### Linux
 No Debian (_testing_ e _sid_ por enquanto) e Ubuntu (20.04):
@@ -79,7 +67,9 @@ Para Gentoo, uma [Ebuild] está disponível: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-Você também pode [compilar o app manualmente][BUILD] ([processo simplificado][BUILD_simple]).
+Você também pode [compilar o app manualmente][BUILD] (não se preocupe, não é tão
 difícil).
 ### Windows
@@ -123,18 +113,13 @@ brew install scrcpy
 Você precisa do `adb`, acessível pelo seu `PATH`. Se você ainda não o tem:
 ```bash
-brew install android-platform-tools
+# Homebrew >= 2.6.0
 brew install --cask android-platform-tools
 # Homebrew < 2.6.0
 brew cask install android-platform-tools
 ```
 Está também disponivel em [MacPorts], que prepara o adb para você:
 ```bash
 sudo port install scrcpy
 ```
 [MacPorts]: https://www.macports.org/
 Você também pode [compilar o app manualmente][BUILD].
@@ -210,11 +195,10 @@ Se `--max-size` também for especificado, o redimensionamento é aplicado após
 Para travar a orientação do espelhamento:
 ```bash
-scrcpy --lock-video-orientation     # orientação inicial (Atual)
+scrcpy --lock-video-orientation 0   # orientação natural
-scrcpy --lock-video-orientation=0   # orientação natural
+scrcpy --lock-video-orientation 1   # 90° sentido anti-horário
-scrcpy --lock-video-orientation=1   # 90° sentido anti-horário
+scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation 3   # 90° sentido horário
 scrcpy --lock-video-orientation=3   # 90° sentido horário
 ```
 Isso afeta a orientação de gravação.
@@ -238,9 +222,7 @@ erro dará os encoders disponíveis:
 scrcpy --encoder _
 ```
-### Captura
+### Gravando
 #### Gravando
 É possível gravar a tela enquanto ocorre o espelhamento:
@@ -264,79 +246,6 @@ pacotes][packet delay variation] não impacta o arquivo gravado.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 #### v4l2loopback
 Em Linux, é possível enviar a transmissão do video para um disposiivo v4l2 loopback, assim
 o dispositivo Android pode ser aberto como uma webcam por qualquer ferramneta capaz de v4l2
 The module `v4l2loopback` must be installed:
 ```bash
 sudo apt install v4l2loopback-dkms
 ```
 Para criar um dispositivo v4l2:
 ```bash
 sudo modprobe v4l2loopback
 ```
 Isso criara um novo dispositivo de vídeo em `/dev/videoN`, onde `N` é uma integer
 (mais [opções](https://github.com/umlaeute/v4l2loopback#options) estão disponiveis
 para criar varios dispositivos ou dispositivos com IDs específicas).
 Para listar os dispositivos disponíveis:
 ```bash
 # requer o pacote v4l-utils
 v4l2-ctl --list-devices
 # simples, mas pode ser suficiente
 ls /dev/video*
 ```
 Para iniciar o scrcpy usando o coletor v4l2 (sink):
 ```bash
 scrcpy --v4l2-sink=/dev/videoN
 scrcpy --v4l2-sink=/dev/videoN --no-display  # desativa a janela espelhada
 scrcpy --v4l2-sink=/dev/videoN -N            # versão curta
 ```
 (troque `N` pelo ID do dipositivo, verifique com `ls /dev/video*`)
 Uma vez ativado, você pode abrir suas trasmissões de videos com uma ferramenta capaz de v4l2:
 ```bash
 ffplay -i /dev/videoN
 vlc v4l2:///dev/videoN   # VLC pode adicionar um pouco de atraso de buffering
 ```
 Por exemplo, você pode capturar o video dentro do [OBS].
 [OBS]: https://obsproject.com/
 #### Buffering
 É possivel adicionar buffering. Isso aumenta a latência, mas reduz a tenção (jitter) (veja
 [#2464]).
 [#2464]: https://github.com/Genymobile/scrcpy/issues/2464
 A opção éta disponivel para buffering de exibição:
 ```bash
 scrcpy --display-buffer=50  # adiciona 50 ms de buffering para a exibição
 ```
 e coletor V4L2:
 ```bash
 scrcpy --v4l2-buffer=500    # adiciona 500 ms de buffering para coletor V4L2
 ```
 ,
 ### Conexão
 #### Sem fio
@@ -579,6 +488,18 @@ scrcpy -Sw
 ```
 #### Renderizar frames expirados
 Por padrão, para minimizar a latência, _scrcpy_ sempre renderiza o último frame decodificado
 disponível, e descarta o anterior.
 Para forçar a renderização de todos os frames (com o custo de um possível aumento de
 latência), use:
 ```bash
 scrcpy --render-expired-frames
 ```
 #### Mostrar toques
 Para apresentações, pode ser útil mostrar toques físicos (no dispositivo
@@ -726,7 +647,7 @@ Não existe feedback visual, um log é imprimido no console.
 #### Enviar arquivo para dispositivo
-Para enviar um arquivo para `/sdcard/Download/` no dispositivo, arraste e solte um arquivo (não-APK) para a
+Para enviar um arquivo para `/sdcard/` no dispositivo, arraste e solte um arquivo (não-APK) para a
 janela do _scrcpy_.
 Não existe feedback visual, um log é imprimido no console.
@@ -773,12 +694,12 @@ _<kbd>[Super]</kbd> é tipicamente a tecla <kbd>Windows</kbd> ou <kbd>Cmd</kbd>.
 | Mudar modo de tela cheia                    | <kbd>MOD</kbd>+<kbd>f</kbd>
 | Rotacionar display para esquerda            | <kbd>MOD</kbd>+<kbd>←</kbd> _(esquerda)_
 | Rotacionar display para direita             | <kbd>MOD</kbd>+<kbd>→</kbd> _(direita)_
- | Redimensionar janela para 1:1 (pixel-perfeito) | <kbd>MOD</kbd>+<kbd>g</kbd>
+ | Redimensionar janela para 1:1 (pixel-perfect) | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Redimensionar janela para remover bordas pretas | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Clique-duplo-esquerdo¹_
+ | Redimensionar janela para remover bordas pretas | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Clique-duplo¹_
 | Clicar em `HOME`                            | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Clique-do-meio_
 | Clicar em `BACK`                            | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Clique-direito²_
- | Clicar em `APP_SWITCH`                      | <kbd>MOD</kbd>+<kbd>s</kbd> \| _Clique-do-4.°³_
+ | Clicar em `APP_SWITCH`                      | <kbd>MOD</kbd>+<kbd>s</kbd>
- | Clicar em `MENU` (desbloquear tela)         | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | Clicar em `MENU` (desbloquear tela          | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Clicar em `VOLUME_UP`                       | <kbd>MOD</kbd>+<kbd>↑</kbd> _(cima)_
 | Clicar em `VOLUME_DOWN`                     | <kbd>MOD</kbd>+<kbd>↓</kbd> _(baixo)_
 | Clicar em `POWER`                           | <kbd>MOD</kbd>+<kbd>p</kbd>
@@ -786,27 +707,18 @@ _<kbd>[Super]</kbd> é tipicamente a tecla <kbd>Windows</kbd> ou <kbd>Cmd</kbd>.
 | Desligar tela do dispositivo (continuar espelhando) | <kbd>MOD</kbd>+<kbd>o</kbd>
 | Ligar tela do dispositivo                   | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Rotacionar tela do dispositivo              | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Expandir painel de notificação              | <kbd>MOD</kbd>+<kbd>n</kbd> \| _Clique-do-5.°³_
+ | Expandir painel de notificação              | <kbd>MOD</kbd>+<kbd>n</kbd>
- | Expandir painel de configurção              | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Clique-duplo-do-5.°³_
+ | Colapsar painel de notificação              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Colapsar paineis                            | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copiar para área de transferência³          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Copiar para área de transferência⁴          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Recortar para área de transferência³        | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Recortar para área de transferência⁴        | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Sincronizar áreas de transferência e colar³ | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Sincronizar áreas de transferência e colar⁴ | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Injetar texto da área de transferência do computador | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Ativar/desativar contador de FPS (em stdout) | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Pinçar para dar zoom                        | <kbd>Ctrl</kbd>+_Clicar-e-mover_
+ | Pinçar para dar zoom                        | <kbd>Ctrl</kbd>+_clicar-e-mover_
-_¹Clique-duplo-esquerdo na borda preta para remove-la._  
+_¹Clique-duplo em bordas pretas para removê-las._  
-_²Clique-direito liga a tela caso esteja desligada, pressione BACK caso contrário._  
+_²Clique-direito liga a tela se ela estiver desligada, pressiona BACK caso contrário._
-_³4.° and 5.° botões do mouse, caso o mouse possua._  
+_³Apenas em Android >= 7._
 _⁴Apenas em Android >= 7._
 Atalhos com teclas reptidas são executados soltando e precionando a tecla
 uma segunda vez. Por exemplo, para executar "Expandir painel de Configurção":
 1. Mantenha pressionado <kbd>MOD</kbd>.
 2. Depois click duas vezes <kbd>n</kbd>.
 3. Finalmente, solte <kbd>MOD</kbd>.
 Todos os atalhos <kbd>Ctrl</kbd>+_tecla_ são encaminhados para o dispositivo, para que eles sejam
 tratados pela aplicação ativa.
@@ -817,9 +729,7 @@ tratados pela aplicação ativa.
 Para usar um binário _adb_ específico, configure seu caminho na variável de ambiente
 `ADB`:
-```bash
+    ADB=/caminho/para/adb scrcpy
 ADB=/caminho/para/adb scrcpy
 ```
 Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em
 `SCRCPY_SERVER_PATH`.
@@ -841,6 +751,8 @@ Um colega me desafiou a encontrar um nome tão impronunciável quanto [gnirehtet
 Veja [BUILD].
 [BUILD]: BUILD.md
 ## Problemas comuns
--- a/README.tr.md
+++ b/README.tr.md
@@ -1,824 +0,0 @@
 # scrcpy (v1.18)
 Bu uygulama Android cihazların USB (ya da [TCP/IP][article-tcpip]) üzerinden
 görüntülenmesini ve kontrol edilmesini sağlar. _root_ erişimine ihtiyaç duymaz.
 _GNU/Linux_, _Windows_ ve _macOS_ sistemlerinde çalışabilir.
 ![screenshot](assets/screenshot-debian-600.jpg)
 Öne çıkan özellikler:
 - **hafiflik** (doğal, sadece cihazın ekranını gösterir)
 - **performans** (30~60fps)
 - **kalite** (1920×1080 ya da üzeri)
 - **düşük gecikme süresi** ([35~70ms][lowlatency])
 - **düşük başlangıç süresi** (~1 saniye ilk kareyi gösterme süresi)
 - **müdaheleci olmama** (cihazda kurulu yazılım kalmaz)
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 ## Gereksinimler
 Android cihaz en düşük API 21 (Android 5.0) olmalıdır.
 [Adb hata ayıklamasının][enable-adb] cihazınızda aktif olduğundan emin olun.
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 Bazı cihazlarda klavye ve fare ile kontrol için [ilave bir seçenek][control] daha
 etkinleştirmeniz gerekebilir.
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ## Uygulamayı indirin
 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
 ### Özet
 - Linux: `apt install scrcpy`
 - Windows: [indir][direct-win64]
 - macOS: `brew install scrcpy`
 Kaynak kodu derle: [BUILD] ([basitleştirilmiş süreç][build_simple])
 [build]: BUILD.md
 [build_simple]: BUILD.md#simple
 ### Linux
 Debian (şimdilik _testing_ ve _sid_) ve Ubuntu (20.04) için:
 ```
 apt install scrcpy
 ```
 [Snap] paketi: [`scrcpy`][snap-link].
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
 Fedora için, [COPR] paketi: [`scrcpy`][copr-link].
 [copr]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 Arch Linux için, [AUR] paketi: [`scrcpy`][aur-link].
 [aur]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 [aur-link]: https://aur.archlinux.org/packages/scrcpy/
 Gentoo için, [Ebuild] mevcut: [`scrcpy/`][ebuild-link].
 [ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 Ayrıca [uygulamayı el ile de derleyebilirsiniz][build] ([basitleştirilmiş süreç][build_simple]).
 ### Windows
 Windows için (`adb` dahil) tüm gereksinimleri ile derlenmiş bir arşiv mevcut:
 - [README](README.md#windows)
 [Chocolatey] ile kurulum:
 [chocolatey]: https://chocolatey.org/
 ```bash
 choco install scrcpy
 choco install adb    # if you don't have it yet
 ```
 [Scoop] ile kurulum:
 ```bash
 scoop install scrcpy
 scoop install adb    # if you don't have it yet
 ```
 [scoop]: https://scoop.sh
 Ayrıca [uygulamayı el ile de derleyebilirsiniz][build].
 ### macOS
 Uygulama [Homebrew] içerisinde mevcut. Sadece kurun:
 [homebrew]: https://brew.sh/
 ```bash
 brew install scrcpy
 ```
 `adb`, `PATH` içerisinden erişilebilir olmalıdır. Eğer değilse:
 ```bash
 brew install android-platform-tools
 ```
 [MacPorts] kullanılarak adb ve uygulamanın birlikte kurulumu yapılabilir:
 ```bash
 sudo port install scrcpy
 ```
 [macports]: https://www.macports.org/
 Ayrıca [uygulamayı el ile de derleyebilirsiniz][build].
 ## Çalıştırma
 Android cihazınızı bağlayın ve aşağıdaki komutu çalıştırın:
 ```bash
 scrcpy
 ```
 Komut satırı argümanları aşağıdaki komut ile listelenebilir:
 ```bash
 scrcpy --help
 ```
 ## Özellikler
 ### Ekran yakalama ayarları
 #### Boyut azaltma
 Bazen, Android cihaz ekranını daha düşük seviyede göstermek performansı artırabilir.
 Hem genişliği hem de yüksekliği bir değere sabitlemek için (ör. 1024):
 ```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # kısa versiyon
 ```
 Diğer boyut en-boy oranı korunacak şekilde hesaplanır.
 Bu şekilde ekran boyutu 1920x1080 olan bir cihaz 1024x576 olarak görünür.
 #### Bit-oranı değiştirme
 Varsayılan bit-oranı 8 Mbps'dir. Değiştirmek için (ör. 2 Mbps):
 ```bash
 scrcpy --bit-rate 2M
 scrcpy -b 2M  # kısa versiyon
 ```
 #### Çerçeve oranı sınırlama
 Ekran yakalama için maksimum çerçeve oranı için sınır koyulabilir:
 ```bash
 scrcpy --max-fps 15
 ```
 Bu özellik Android 10 ve sonrası sürümlerde resmi olarak desteklenmektedir,
 ancak daha önceki sürümlerde çalışmayabilir.
 #### Kesme
 Cihaz ekranının sadece bir kısmı görünecek şekilde kesilebilir.
 Bu özellik Oculus Go'nun bir gözünü yakalamak gibi durumlarda kullanışlı olur:
 ```bash
 scrcpy --crop 1224:1440:0:0   # (0,0) noktasından 1224x1440
 ```
 Eğer `--max-size` belirtilmişse yeniden boyutlandırma kesme işleminden sonra yapılır.
 #### Video yönünü kilitleme
 Videonun yönünü kilitlemek için:
 ```bash
 scrcpy --lock-video-orientation     # başlangıç yönü
 scrcpy --lock-video-orientation=0   # doğal yön
 scrcpy --lock-video-orientation=1   # 90° saatin tersi yönü
 scrcpy --lock-video-orientation=2   # 180°
 scrcpy --lock-video-orientation=3   # 90° saat yönü
 ```
 Bu özellik kaydetme yönünü de etkiler.
 [Pencere ayrı olarak döndürülmüş](#rotation) olabilir.
 #### Kodlayıcı
 Bazı cihazlar birden fazla kodlayıcıya sahiptir, ve bunların bazıları programın
 kapanmasına sebep olabilir. Bu durumda farklı bir kodlayıcı seçilebilir:
 ```bash
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```
 Mevcut kodlayıcıları listelemek için geçerli olmayan bir kodlayıcı ismi girebilirsiniz,
 hata mesajı mevcut kodlayıcıları listeleyecektir:
 ```bash
 scrcpy --encoder _
 ```
 ### Yakalama
 #### Kaydetme
 Ekran yakalama sırasında kaydedilebilir:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 Yakalama olmadan kayıt için:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # Ctrl+C ile kayıt kesilebilir
 ```
 "Atlanan kareler" gerçek zamanlı olarak gösterilmese (performans sebeplerinden ötürü) dahi kaydedilir.
 Kareler cihazda _zamandamgası_ ile saklanır, bu sayede [paket gecikme varyasyonu]
 kayıt edilen dosyayı etkilemez.
 [paket gecikme varyasyonu]: https://en.wikipedia.org/wiki/Packet_delay_variation
 #### v4l2loopback
 Linux'ta video akışı bir v4l2 loopback cihazına gönderilebilir. Bu sayede Android
 cihaz bir web kamerası gibi davranabilir.
 Bu işlem için `v4l2loopback` modülü kurulu olmalıdır:
 ```bash
 sudo apt install v4l2loopback-dkms
 ```
 v4l2 cihazı oluşturmak için:
 ```bash
 sudo modprobe v4l2loopback
 ```
 Bu komut `/dev/videoN` adresinde `N` yerine bir tamsayı koyarak yeni bir video
 cihazı oluşturacaktır.
 (birden fazla cihaz oluşturmak veya spesifik ID'ye sahip cihazlar için
 diğer [seçenekleri](https://github.com/umlaeute/v4l2loopback#options) inceleyebilirsiniz.)
 Aktif cihazları listelemek için:
 ```bash
 # v4l-utils paketi ile
 v4l2-ctl --list-devices
 # daha basit ama yeterli olabilecek şekilde
 ls /dev/video*
 ```
 v4l2 kullanarak scrpy kullanmaya başlamak için:
 ```bash
 scrcpy --v4l2-sink=/dev/videoN
 scrcpy --v4l2-sink=/dev/videoN --no-display  # ayna penceresini kapatarak
 scrcpy --v4l2-sink=/dev/videoN -N            # kısa versiyon
 ```
 (`N` harfini oluşturulan cihaz ID numarası ile değiştirin. `ls /dev/video*` cihaz ID'lerini görebilirsiniz.)
 Aktifleştirildikten sonra video akışını herhangi bir v4l2 özellikli araçla açabilirsiniz:
 ```bash
 ffplay -i /dev/videoN
 vlc v4l2:///dev/videoN   # VLC kullanırken yükleme gecikmesi olabilir
 ```
 Örneğin, [OBS] ile video akışını kullanabilirsiniz.
 [obs]: https://obsproject.com/
 ### Bağlantı
 #### Kablosuz
 _Scrcpy_ cihazla iletişim kurmak için `adb`'yi kullanır, Ve `adb`
 bir cihaza TCP/IP kullanarak [bağlanabilir].
 1. Cihazınızı bilgisayarınızla aynı Wi-Fi ağına bağlayın.
 2. Cihazınızın IP adresini bulun. Ayarlar → Telefon Hakkında → Durum sekmesinden veya
   aşağıdaki komutu çalıştırarak öğrenebilirsiniz:
   ```bash
   adb shell ip route | awk '{print $9}'
   ```
 3. Cihazınızda TCP/IP üzerinden adb kullanımını etkinleştirin: `adb tcpip 5555`.
 4. Cihazınızı bilgisayarınızdan sökün.
 5. Cihazınıza bağlanın: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` değerini değiştirin)_.
 6. `scrcpy` komutunu normal olarak çalıştırın.
 Bit-oranını ve büyüklüğü azaltmak yararlı olabilir:
 ```bash
 scrcpy --bit-rate 2M --max-size 800
 scrcpy -b2M -m800  # kısa version
 ```
 [bağlanabilir]: https://developer.android.com/studio/command-line/adb.html#wireless
 #### Birden fazla cihaz
 Eğer `adb devices` komutu birden fazla cihaz listeliyorsa _serial_ değerini belirtmeniz gerekir:
 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # kısa versiyon
 ```
 Eğer cihaz TCP/IP üzerinden bağlanmışsa:
 ```bash
 scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # kısa version
 ```
 Birden fazla cihaz için birden fazla _scrcpy_ uygulaması çalıştırabilirsiniz.
 #### Cihaz bağlantısı ile otomatik başlatma
 [AutoAdb] ile yapılabilir:
 ```bash
 autoadb scrcpy -s '{}'
 ```
 [autoadb]: https://github.com/rom1v/autoadb
 #### SSH Tünel
 Uzaktaki bir cihaza erişmek için lokal `adb` istemcisi, uzaktaki bir `adb` sunucusuna
 (aynı _adb_ sürümünü kullanmak şartı ile) bağlanabilir :
 ```bash
 adb kill-server    # 5037 portunda çalışan lokal adb sunucusunu kapat
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # bunu açık tutun
 ```
 Başka bir terminalde:
 ```bash
 scrcpy
 ```
 Uzaktan port yönlendirme ileri yönlü bağlantı kullanabilirsiniz
 (`-R` yerine `-L` olduğuna dikkat edin):
 ```bash
 adb kill-server    # 5037 portunda çalışan lokal adb sunucusunu kapat
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # bunu açık tutun
 ```
 Başka bir terminalde:
 ```bash
 scrcpy --force-adb-forward
 ```
 Kablosuz bağlantı gibi burada da kalite düşürmek faydalı olabilir:
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### Pencere ayarları
 #### İsim
 Cihaz modeli varsayılan pencere ismidir. Değiştirmek için:
 ```bash
 scrcpy --window-title 'Benim cihazım'
 ```
 #### Konum ve
 Pencerenin başlangıç konumu ve boyutu belirtilebilir:
 ```bash
 scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 ```
 #### Kenarlıklar
 Pencere dekorasyonunu kapatmak için:
 ```bash
 scrcpy --window-borderless
 ```
 #### Her zaman üstte
 Scrcpy penceresini her zaman üstte tutmak için:
 ```bash
 scrcpy --always-on-top
 ```
 #### Tam ekran
 Uygulamayı tam ekran başlatmak için:
 ```bash
 scrcpy --fullscreen
 scrcpy -f  # kısa versiyon
 ```
 Tam ekran <kbd>MOD</kbd>+<kbd>f</kbd> ile dinamik olarak değiştirilebilir.
 #### Döndürme
 Pencere döndürülebilir:
 ```bash
 scrcpy --rotation 1
 ```
 Seçilebilecek değerler:
 - `0`: döndürme yok
 - `1`: 90 derece saat yönünün tersi
 - `2`: 180 derece
 - `3`: 90 derece saat yönü
 Döndürme <kbd>MOD</kbd>+<kbd>←</kbd>_(sol)_ ve
 <kbd>MOD</kbd>+<kbd>→</kbd> _(sağ)_ ile dinamik olarak değiştirilebilir.
 _scrcpy_'de 3 farklı döndürme olduğuna dikkat edin:
 - <kbd>MOD</kbd>+<kbd>r</kbd> cihazın yatay veya dikey modda çalışmasını sağlar.
  (çalışan uygulama istenilen oryantasyonda çalışmayı desteklemiyorsa döndürme
  işlemini reddedebilir.)
 - [`--lock-video-orientation`](#lock-video-orientation) görüntü yakalama oryantasyonunu
  (cihazdan bilgisayara gelen video akışının oryantasyonu) değiştirir. Bu kayıt işlemini
  etkiler.
 - `--rotation` (or <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
  pencere içeriğini dönderir. Bu sadece canlı görüntüyü etkiler, kayıt işlemini etkilemez.
 ### Diğer ekran yakalama seçenekleri
 #### Yazma korumalı
 Kontrolleri devre dışı bırakmak için (cihazla etkileşime geçebilecek her şey: klavye ve
 fare girdileri, dosya sürükleyip bırakma):
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
 #### Ekran
 Eğer cihazın birden fazla ekranı varsa hangi ekranın kullanılacağını seçebilirsiniz:
 ```bash
 scrcpy --display 1
 ```
 Kullanılabilecek ekranları listelemek için:
 ```bash
 adb shell dumpsys display   # çıktı içerisinde "mDisplayId=" terimini arayın
 ```
 İkinci ekran ancak cihaz Android sürümü 10 veya üzeri olmalıdır (değilse yazma korumalı
 olarak görüntülenir).
 #### Uyanık kalma
 Cihazın uyku moduna girmesini engellemek için:
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
 scrcpy kapandığında cihaz başlangıç durumuna geri döner.
 #### Ekranı kapatma
 Ekran yakalama sırasında cihazın ekranı kapatılabilir:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
 Ya da <kbd>MOD</kbd>+<kbd>o</kbd> kısayolunu kullanabilirsiniz.
 Tekrar açmak için ise <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd> tuşlarına basın.
 Android'de, `GÜÇ` tuşu her zaman ekranı açar. Eğer `GÜÇ` sinyali scrcpy ile
 gönderilsiyse (sağ tık veya <kbd>MOD</kbd>+<kbd>p</kbd>), ekran kısa bir gecikme
 ile kapanacaktır. Fiziksel `GÜÇ` tuşuna basmak hala ekranın açılmasına sebep olacaktır.
 Bu cihazın uykuya geçmesini engellemek için kullanılabilir:
 ```bash
 scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
 #### Dokunuşları gösterme
 Sunumlar sırasında fiziksel dokunuşları (fiziksel cihazdaki) göstermek
 faydalı olabilir.
 Android'de bu özellik _Geliştici seçenekleri_ içerisinde bulunur.
 _Scrcpy_ bu özelliği çalışırken etkinleştirebilir ve kapanırken eski
 haline geri getirebilir:
 ```bash
 scrcpy --show-touches
 scrcpy -t
 ```
 Bu opsiyon sadece _fiziksel_ dokunuşları (cihaz ekranındaki) gösterir.
 #### Ekran koruyucuyu devre dışı bırakma
 Scrcpy varsayılan ayarlarında ekran koruyucuyu devre dışı bırakmaz.
 Bırakmak için:
 ```bash
 scrcpy --disable-screensaver
 ```
 ### Girdi kontrolü
 #### Cihaz ekranını dönderme
 <kbd>MOD</kbd>+<kbd>r</kbd> tuşları ile yatay ve dikey modlar arasında
 geçiş yapabilirsiniz.
 Bu kısayol ancak çalışan uygulama desteklediği takdirde ekranı döndürecektir.
 #### Kopyala yapıştır
 Ne zaman Android cihazdaki pano değişse bilgisayardaki pano otomatik olarak
 senkronize edilir.
 Tüm <kbd>Ctrl</kbd> kısayolları cihaza iletilir:
 - <kbd>Ctrl</kbd>+<kbd>c</kbd> genelde kopyalar
 - <kbd>Ctrl</kbd>+<kbd>x</kbd> genelde keser
 - <kbd>Ctrl</kbd>+<kbd>v</kbd> genelde yapıştırır (bilgisayar ve cihaz arasındaki
  pano senkronizasyonundan sonra)
 Bu kısayollar genelde beklediğiniz gibi çalışır.
 Ancak kısayolun gerçekten yaptığı eylemi açık olan uygulama belirler.
 Örneğin, _Termux_ <kbd>Ctrl</kbd>+<kbd>c</kbd> ile kopyalama yerine
 SIGINT sinyali gönderir, _K-9 Mail_ ise yeni mesaj oluşturur.
 Bu tip durumlarda kopyalama, kesme ve yapıştırma için (Android versiyon 7 ve
 üstü):
 - <kbd>MOD</kbd>+<kbd>c</kbd> `KOPYALA`
 - <kbd>MOD</kbd>+<kbd>x</kbd> `KES`
 - <kbd>MOD</kbd>+<kbd>v</kbd> `YAPIŞTIR` (bilgisayar ve cihaz arasındaki
  pano senkronizasyonundan sonra)
 Bunlara ek olarak, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> tuşları
 bilgisayar pano içeriğini tuş basma eylemleri şeklinde gönderir. Bu metin
 yapıştırmayı desteklemeyen (_Termux_ gibi) uygulamar için kullanışlıdır,
 ancak ASCII olmayan içerikleri bozabilir.
 **UYARI:** Bilgisayar pano içeriğini cihaza yapıştırmak
 (<kbd>Ctrl</kbd>+<kbd>v</kbd> ya da <kbd>MOD</kbd>+<kbd>v</kbd> tuşları ile)
 içeriği cihaz panosuna kopyalar. Sonuç olarak, herhangi bir Android uygulaması
 içeriğe erişebilir. Hassas içerikler (parolalar gibi) için bu özelliği kullanmaktan
 kaçının.
 Bazı cihazlar pano değişikleri konusunda beklenilen şekilde çalışmayabilir.
 Bu durumlarda `--legacy-paste` argümanı kullanılabilir. Bu sayede
 <kbd>Ctrl</kbd>+<kbd>v</kbd> ve <kbd>MOD</kbd>+<kbd>v</kbd> tuşları da
 pano içeriğini tuş basma eylemleri şeklinde gönderir
 (<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> ile aynı şekilde).
 #### İki parmak ile yakınlaştırma
 "İki parmak ile yakınlaştırma" için: <kbd>Ctrl</kbd>+_tıkla-ve-sürükle_.
 Daha açıklayıcı şekilde, <kbd>Ctrl</kbd> tuşuna sol-tık ile birlikte basılı
 tutun. Sol-tık serbest bırakılıncaya kadar yapılan tüm fare hareketleri
 ekran içeriğini ekranın merkezini baz alarak dönderir, büyütür veya küçültür
 (eğer uygulama destekliyorsa).
 Scrcpy ekranın merkezinde bir "sanal parmak" varmış gibi davranır.
 #### Metin gönderme tercihi
 Metin girilirken ili çeşit [eylem][textevents] gerçekleştirilir:
 - _tuş eylemleri_, bir tuşa basıldığı sinyalini verir;
 - _metin eylemleri_, bir metin girildiği sinyalini verir.
 Varsayılan olarak, harfler tuş eylemleri kullanılarak gönderilir. Bu sayede
 klavye oyunlarda beklenilene uygun olarak çalışır (Genelde WASD tuşları).
 Ancak bu [bazı problemlere][prefertext] yol açabilir. Eğer bu problemler ile
 karşılaşırsanız metin eylemlerini tercih edebilirsiniz:
 ```bash
 scrcpy --prefer-text
 ```
 (Ama bu oyunlardaki klavye davranışlarını bozacaktır)
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 #### Tuş tekrarı
 Varsayılan olarak, bir tuşa basılı tutmak tuş eylemini tekrarlar. Bu durum
 bazı oyunlarda problemlere yol açabilir.
 Tuş eylemlerinin tekrarını kapatmak için:
 ```bash
 scrcpy --no-key-repeat
 ```
 #### Sağ-tık ve Orta-tık
 Varsayılan olarak, sağ-tık GERİ (ya da GÜÇ açma) eylemlerini, orta-tık ise
 ANA EKRAN eylemini tetikler. Bu kısayolları devre dışı bırakmak için:
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### Dosya bırakma
 #### APK kurulumu
 APK kurmak için, bilgisayarınızdaki APK dosyasını (`.apk` ile biten) _scrcpy_
 penceresine sürükleyip bırakın.
 Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır.
 #### Dosyayı cihaza gönderme
 Bir dosyayı cihazdaki `/sdcard/Download/` dizinine atmak için, (APK olmayan)
 bir dosyayı _scrcpy_ penceresine sürükleyip bırakın.
 Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır.
 Hedef dizin uygulama başlatılırken değiştirilebilir:
 ```bash
 scrcpy --push-target=/sdcard/Movies/
 ```
 ### Ses iletimi
 _Scrcpy_ ses iletimi yapmaz. Yerine [sndcpy] kullanabilirsiniz.
 Ayrıca bakınız [issue #14].
 [sndcpy]: https://github.com/rom1v/sndcpy
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## Kısayollar
 Aşağıdaki listede, <kbd>MOD</kbd> kısayol tamamlayıcısıdır. Varsayılan olarak
 (sol) <kbd>Alt</kbd> veya (sol) <kbd>Super</kbd> tuşudur.
 Bu tuş `--shortcut-mod` argümanı kullanılarak `lctrl`, `rctrl`,
 `lalt`, `ralt`, `lsuper` ve `rsuper` tuşlarından biri ile değiştirilebilir.
 Örneğin:
 ```bash
 # Sağ Ctrl kullanmak için
 scrcpy --shortcut-mod=rctrl
 # Sol Ctrl, Sol Alt veya Sol Super tuşlarından birini kullanmak için
 scrcpy --shortcut-mod=lctrl+lalt,lsuper
 ```
 _<kbd>[Super]</kbd> tuşu genelde <kbd>Windows</kbd> veya <kbd>Cmd</kbd> tuşudur._
 [super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
 | Action                                           | Shortcut                                                  |
 | ------------------------------------------------ | :-------------------------------------------------------- |
 | Tam ekran modunu değiştirme                      | <kbd>MOD</kbd>+<kbd>f</kbd>                               |
 | Ekranı sola çevirme                              | <kbd>MOD</kbd>+<kbd>←</kbd> _(sol)_                       |
 | Ekranı sağa çevirme                              | <kbd>MOD</kbd>+<kbd>→</kbd> _(sağ)_                       |
 | Pencereyi 1:1 oranına çevirme (pixel-perfect)    | <kbd>MOD</kbd>+<kbd>g</kbd>                               |
 | Penceredeki siyah kenarlıkları kaldırma          | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Çift-sol-tık¹_            |
 | `ANA EKRAN` tuşu                                 | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Orta-tık_                 |
 | `GERİ` tuşu                                      | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Sağ-tık²_                 |
 | `UYGULAMA_DEĞİŞTİR` tuşu                         | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4.tık³_                   |
 | `MENÜ` tuşu (ekran kilidini açma)                | <kbd>MOD</kbd>+<kbd>m</kbd>                               |
 | `SES_AÇ` tuşu                                    | <kbd>MOD</kbd>+<kbd>↑</kbd> _(yukarı)_                    |
 | `SES_KIS` tuşu                                   | <kbd>MOD</kbd>+<kbd>↓</kbd> _(aşağı)_                     |
 | `GÜÇ` tuşu                                       | <kbd>MOD</kbd>+<kbd>p</kbd>                               |
 | Gücü açma                                        | _Sağ-tık²_                                                |
 | Cihaz ekranını kapatma (ekran yakalama durmadan) | <kbd>MOD</kbd>+<kbd>o</kbd>                               |
 | Cihaz ekranını açma                              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>              |
 | Cihaz ekranını dönderme                          | <kbd>MOD</kbd>+<kbd>r</kbd>                               |
 | Bildirim panelini genişletme                     | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5.tık³_                   |
 | Ayarlar panelini genişletme                      | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Çift-5.tık³_ |
 | Panelleri kapatma                                | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>              |
 | Panoya kopyalama⁴                                | <kbd>MOD</kbd>+<kbd>c</kbd>                               |
 | Panoya kesme⁴                                    | <kbd>MOD</kbd>+<kbd>x</kbd>                               |
 | Panoları senkronize ederek yapıştırma⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>                               |
 | Bilgisayar panosundaki metini girme              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>              |
 | FPS sayacını açma/kapatma (terminalde)           | <kbd>MOD</kbd>+<kbd>i</kbd>                               |
 | İki parmakla yakınlaştırma                       | <kbd>Ctrl</kbd>+_tıkla-ve-sürükle_                        |
 _¹Siyah kenarlıkları silmek için üzerine çift tıklayın._  
 _²Sağ-tık ekran kapalıysa açar, değilse GERİ sinyali gönderir._  
 _³4. ve 5. fare tuşları (eğer varsa)._  
 _⁴Sadece Android 7 ve üzeri versiyonlarda._
 Tekrarlı tuşu olan kısayollar tuş bırakılıp tekrar basılarak tekrar çalıştırılır.
 Örneğin, "Ayarlar panelini genişletmek" için:
 1.  <kbd>MOD</kbd> tuşuna basın ve basılı tutun.
 2.  <kbd>n</kbd> tuşuna iki defa basın.
 3.  <kbd>MOD</kbd> tuşuna basmayı bırakın.
 Tüm <kbd>Ctrl</kbd>+_tuş_ kısayolları cihaza gönderilir. Bu sayede istenilen komut
 uygulama tarafından çalıştırılır.
 ## Özel dizinler
 Varsayılandan farklı bir _adb_ programı çalıştırmak için `ADB` ortam değişkenini
 ayarlayın:
 ```bash
 ADB=/path/to/adb scrcpy
 ```
 `scrcpy-server` programının dizinini değiştirmek için `SCRCPY_SERVER_PATH`
 değişkenini ayarlayın.
 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## Neden _scrcpy_?
 Bir meslektaşım [gnirehtet] gibi söylenmesi zor bir isim bulmam için bana meydan okudu.
 [`strcpy`] **str**ing kopyalıyor; `scrcpy` **scr**een kopyalıyor.
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## Nasıl derlenir?
 Bakınız [BUILD].
 ## Yaygın problemler
 Bakınız [FAQ](FAQ.md).
 ## Geliştiriciler
 [Geliştiriciler sayfası]nı okuyun.
 [geliştiriciler sayfası]: DEVELOP.md
 ## Lisans
    Copyright (C) 2018 Genymobile
    Copyright (C) 2018-2021 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## Makaleler
 - [Introducing scrcpy][article-intro]
 - [Scrcpy now works wirelessly][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/app/meson.build
+++ b/app/meson.build
@@ -8,12 +8,11 @@ src = [
    'src/controller.c',
    'src/decoder.c',
    'src/device_msg.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/receiver.c',
    'src/recorder.c',
@@ -42,14 +41,6 @@ if v4l2_support
    src += [ 'src/v4l2_sink.c' ]
 endif
 aoa_hid_support = host_machine.system() == 'linux'
 if aoa_hid_support
    src += [
        'src/aoa_hid.c',
        'src/hid_keyboard.c',
    ]
 endif
 check_functions = [
    'strdup'
 ]
@@ -70,11 +61,8 @@ if not get_option('crossbuild_windows')
        dependencies += dependency('libavdevice')
    endif
    if aoa_hid_support
        dependencies += dependency('libusb-1.0')
    endif
 else
    # cross-compile mingw32 build (from Linux to Windows)
    prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
    sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
@@ -151,9 +139,6 @@ conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == '
 # enable V4L2 support (linux only)
 conf.set('HAVE_V4L2', v4l2_support)
 # enable HID over AOA support (linux only)
 conf.set('HAVE_AOA_HID', aoa_hid_support)
 configure_file(configuration: conf, output: 'config.h')
 src_dir = include_directories('src')
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -82,24 +82,6 @@ Start in fullscreen.
 .B \-h, \-\-help
 Print this help.
 .TP
 .B \-K, \-\-keyboard\-hid
 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 \-i, \-\-input\-mode mode
 Select input mode for keyboard events.
 Possible values are "hid" and "inject".
 "hid" uses Android's USB HID over AOAv2 feature to simulate physical keyboard's events, which provides better experience for IME users if supported by you device.
 "inject" is the legacy scrcpy way by injecting keycode events on Android, works on most devices and is the default.
 .TP
 .B \-\-legacy\-paste
 Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+Shift+v).
@@ -108,7 +90,7 @@ This is a workaround for some devices not behaving as expected when setting the
 .TP
 .BI "\-\-lock\-video\-orientation[=value]
-Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees rotation counterclockwise.
+Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
 Default is "unlocked".
@@ -221,8 +203,6 @@ Add a buffering delay (in milliseconds) before pushing frames. This increases la
 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").
--- a/app/src/adb.c
+++ b/app/src/adb.c
@@ -109,9 +109,7 @@ show_adb_err_msg(enum process_result err, const char *const argv[]) {
 }
 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,
                     pipe_t *pipe_stderr) {
    int i;
    process_t process;
@@ -131,9 +129,7 @@ adb_execute_redirect(const char *serial, const char *const adb_cmd[],
    memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
    argv[len + i] = NULL;
-    enum process_result r =
+    enum process_result r = process_execute(argv, &process);
        process_execute_redirect(argv, &process, pipe_stdin, pipe_stdout,
                                 pipe_stderr);
    if (r != PROCESS_SUCCESS) {
        show_adb_err_msg(r, argv);
        process = PROCESS_NONE;
@@ -143,11 +139,6 @@ adb_execute_redirect(const char *serial, const char *const adb_cmd[],
    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 +224,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/aoa_hid.c
+++ b/app/src/aoa_hid.c
@@ -1,357 +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
 hid_event_log(const struct 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->from_accessory_id, buffer);
    free(buffer);
 }
 static void
 hid_event_destroy(struct hid_event *event) {
    free(event->buffer);
 }
 static 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 *
 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
 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
 aoa_init(struct 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 = 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 (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
 aoa_destroy(struct aoa *aoa) {
    // Destroy remaining events
    struct hid_event event;
    while (cbuf_take(&aoa->queue, &event)) {
        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
 aoa_register_hid(struct 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
 aoa_set_hid_report_desc(struct 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
 aoa_setup_hid(struct aoa *aoa, uint16_t accessory_id,
              const unsigned char *report_desc, uint16_t report_desc_size) {
    bool ok = aoa_register_hid(aoa, accessory_id, report_desc_size);
    if (!ok) {
        return false;
    }
    ok = aoa_set_hid_report_desc(aoa, accessory_id, report_desc,
                                 report_desc_size);
    if (!ok) {
        if (!aoa_unregister_hid(aoa, accessory_id)) {
            LOGW("Could not unregister HID");
        }
        return false;
    }
    return true;
 }
 static bool
 aoa_send_hid_event(struct aoa *aoa, const struct 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->from_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
 aoa_unregister_hid(struct 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
 aoa_push_hid_event(struct aoa *aoa, const struct hid_event *event) {
    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 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 hid_event event;
        bool non_empty = cbuf_take(&aoa->queue, &event);
        assert(non_empty);
        (void) non_empty;
        sc_mutex_unlock(&aoa->mutex);
        bool ok = aoa_send_hid_event(aoa, &event);
        hid_event_destroy(&event);
        if (!ok) {
            LOGW("Could not send HID event to USB device");
        }
    }
    return 0;
 }
 bool
 aoa_start(struct 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
 aoa_stop(struct aoa *aoa) {
    sc_mutex_lock(&aoa->mutex);
    aoa->stopped = true;
    sc_cond_signal(&aoa->event_cond);
    sc_mutex_unlock(&aoa->mutex);
 }
 void
 aoa_join(struct aoa *aoa) {
    sc_thread_join(&aoa->thread, NULL);
 }
--- a/app/src/aoa_hid.h
+++ b/app/src/aoa_hid.h
@@ -1,57 +0,0 @@
 #ifndef AOA_HID_H
 #define AOA_HID_H
 #include <stdint.h>
 #include <stdbool.h>
 #include <libusb-1.0/libusb.h>
 #include "scrcpy.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
 struct hid_event {
    uint16_t from_accessory_id;
    unsigned char *buffer;
    uint16_t size;
 };
 struct hid_event_queue CBUF(struct hid_event, 64);
 struct 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 hid_event_queue queue;
 };
 bool
 aoa_init(struct aoa *aoa, const char *serial);
 void
 aoa_destroy(struct aoa *aoa);
 bool
 aoa_start(struct aoa *aoa);
 void
 aoa_stop(struct aoa *aoa);
 void
 aoa_join(struct aoa *aoa);
 bool
 aoa_setup_hid(struct aoa *aoa, uint16_t accessory_id,
              const unsigned char *report_desc, uint16_t report_desc_size);
 bool
 aoa_unregister_hid(struct aoa *aoa, uint16_t accessory_id);
 bool
 aoa_push_hid_event(struct aoa *aoa, const struct hid_event *event);
 #endif
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -76,14 +76,6 @@ scrcpy_print_usage(const char *arg0) {
        "    -f, --fullscreen\n"
        "        Start in fullscreen.\n"
        "\n"
        "    -K, --keyboard-hid\n"
        "        Simulate a physical keyboard by using HID over AOAv2.\n"
        "        It provides a better experience for IME users, and allows to\n"
        "        generate non-ASCII characters, contrary to the default\n"
        "        injection method.\n"
        "        It may only work over USB, and is currently only supported\n"
        "        on Linux.\n"
        "\n"
        "    -h, --help\n"
        "        Print this help.\n"
        "\n"
@@ -418,7 +410,7 @@ parse_max_fps(const char *s, uint16_t *max_fps) {
 static bool
 parse_buffering_time(const char *s, sc_tick *tick) {
    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 0x7FFFFFFF,
+    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFFFFFF,
                                "buffering time");
    if (!ok) {
        return false;
@@ -746,7 +738,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
                                                  OPT_FORWARD_ALL_CLICKS},
        {"fullscreen",             no_argument,       NULL, 'f'},
        {"help",                   no_argument,       NULL, 'h'},
        {"keyboard-hid",           no_argument,       NULL, 'K'},
        {"legacy-paste",           no_argument,       NULL, OPT_LEGACY_PASTE},
        {"lock-video-orientation", optional_argument, NULL,
                                                  OPT_LOCK_VIDEO_ORIENTATION},
@@ -793,7 +784,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
    optind = 0; // reset to start from the first argument in tests
    int c;
-    while ((c = getopt_long(argc, argv, "b:c:fF:hKm:nNp:r:s:StTvV:w",
+    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTvV:w",
                            long_options, NULL)) != -1) {
        switch (c) {
            case 'b':
@@ -826,9 +817,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case 'h':
                args->help = true;
                break;
            case 'K':
                opts->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_HID;
                break;
            case OPT_MAX_FPS:
                if (!parse_max_fps(optarg, &opts->max_fps)) {
                    return false;
@@ -995,11 +983,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
             "See --lock-video-orientation.");
        opts->lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_INITIAL;
    }
    if (opts->v4l2_buffer && !opts->v4l2_device) {
        LOGE("V4L2 buffer value without V4L2 sink\n");
        return false;
    }
 #else
    if (!opts->display && !opts->record_filename) {
        LOGE("-N/--no-display requires screen recording (-r/--record)");
--- a/app/src/controller.c
+++ b/app/src/controller.c
@@ -70,7 +70,7 @@ process_msg(struct controller *controller,
    if (!length) {
        return false;
    }
-    ssize_t w = net_send_all(controller->control_socket, serialized_msg, length);
+    int w = net_send_all(controller->control_socket, serialized_msg, length);
    return (size_t) w == length;
 }
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@@ -1,6 +1,5 @@
 #include "decoder.h"
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include "events.h"
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@@ -1,20 +1,9 @@
-#include "keyboard_inject.h"
+#include "event_converter.h"
 #include <assert.h>
 #include <SDL2/SDL_events.h>
 #include "android/input.h"
 #include "control_msg.h"
 #include "controller.h"
 #include "util/log.h"
 /** Downcast key processor to sc_keyboard_inject */
 #define DOWNCAST(KP) \
    container_of(KP, struct sc_keyboard_inject, key_processor)
 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false
-static bool
+
 bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
    switch (from) {
        MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
@@ -23,7 +12,67 @@ convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
    }
 }
-static bool
+static enum android_metastate
 autocomplete_metastate(enum android_metastate metastate) {
    // fill dependent flags
    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
        metastate |= AMETA_SHIFT_ON;
    }
    if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
        metastate |= AMETA_CTRL_ON;
    }
    if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
        metastate |= AMETA_ALT_ON;
    }
    if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
        metastate |= AMETA_META_ON;
    }
    return metastate;
 }
 enum android_metastate
 convert_meta_state(SDL_Keymod mod) {
    enum android_metastate metastate = 0;
    if (mod & KMOD_LSHIFT) {
        metastate |= AMETA_SHIFT_LEFT_ON;
    }
    if (mod & KMOD_RSHIFT) {
        metastate |= AMETA_SHIFT_RIGHT_ON;
    }
    if (mod & KMOD_LCTRL) {
        metastate |= AMETA_CTRL_LEFT_ON;
    }
    if (mod & KMOD_RCTRL) {
        metastate |= AMETA_CTRL_RIGHT_ON;
    }
    if (mod & KMOD_LALT) {
        metastate |= AMETA_ALT_LEFT_ON;
    }
    if (mod & KMOD_RALT) {
        metastate |= AMETA_ALT_RIGHT_ON;
    }
    if (mod & KMOD_LGUI) { // Windows key
        metastate |= AMETA_META_LEFT_ON;
    }
    if (mod & KMOD_RGUI) { // Windows key
        metastate |= AMETA_META_RIGHT_ON;
    }
    if (mod & KMOD_NUM) {
        metastate |= AMETA_NUM_LOCK_ON;
    }
    if (mod & KMOD_CAPS) {
        metastate |= AMETA_CAPS_LOCK_ON;
    }
    if (mod & KMOD_MODE) { // Alt Gr
        // no mapping?
    }
    // fill the dependent fields
    return autocomplete_metastate(metastate);
 }
 bool
 convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
                bool prefer_text) {
    switch (from) {
@@ -105,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/hid_keyboard.c
+++ b/app/src/hid_keyboard.c
@@ -1,356 +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 hid_keyboard, key_processor)
 #define HID_KEYBOARD_ACCESSORY_ID 1
 #define HID_KEYBOARD_MODIFIER_NONE 0x00
 #define HID_KEYBOARD_MODIFIER_LEFT_CONTROL (1 << 0)
 #define HID_KEYBOARD_MODIFIER_LEFT_SHIFT (1 << 1)
 #define HID_KEYBOARD_MODIFIER_LEFT_ALT (1 << 2)
 #define HID_KEYBOARD_MODIFIER_LEFT_GUI (1 << 3)
 #define HID_KEYBOARD_MODIFIER_RIGHT_CONTROL (1 << 4)
 #define HID_KEYBOARD_MODIFIER_RIGHT_SHIFT (1 << 5)
 #define HID_KEYBOARD_MODIFIER_RIGHT_ALT (1 << 6)
 #define HID_KEYBOARD_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_KEYBOARD_RESERVED 0x00
 #define HID_KEYBOARD_ERROR_ROLL_OVER 0x01
 #define SC_SCANCODE_CAPSLOCK 57
 #define SC_SCANCODE_NUMLOCK 83
 /**
 * 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, HID_KEYBOARD_KEYS - 1,
    // Logical Minimum (0)
    0x15, 0x00,
    // Logical Maximum(101)
    0x25, 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 *
 create_hid_keyboard_event(void) {
    unsigned char *buffer = malloc(HID_KEYBOARD_EVENT_SIZE);
    if (!buffer) {
        return NULL;
    }
    buffer[HID_KEYBOARD_INDEX_MODIFIER] = HID_KEYBOARD_MODIFIER_NONE;
    buffer[1] = HID_KEYBOARD_RESERVED;
    memset(&buffer[HID_KEYBOARD_INDEX_KEYS], 0, HID_KEYBOARD_MAX_KEYS);
    return buffer;
 }
 static unsigned char
 sdl_keymod_to_hid_modifiers(SDL_Keymod mod) {
    unsigned char modifiers = HID_KEYBOARD_MODIFIER_NONE;
    if (mod & KMOD_LCTRL) {
        modifiers |= HID_KEYBOARD_MODIFIER_LEFT_CONTROL;
    }
    if (mod & KMOD_LSHIFT) {
        modifiers |= HID_KEYBOARD_MODIFIER_LEFT_SHIFT;
    }
    if (mod & KMOD_LALT) {
        modifiers |= HID_KEYBOARD_MODIFIER_LEFT_ALT;
    }
    if (mod & KMOD_LGUI) {
        modifiers |= HID_KEYBOARD_MODIFIER_LEFT_GUI;
    }
    if (mod & KMOD_RCTRL) {
        modifiers |= HID_KEYBOARD_MODIFIER_RIGHT_CONTROL;
    }
    if (mod & KMOD_RSHIFT) {
        modifiers |= HID_KEYBOARD_MODIFIER_RIGHT_SHIFT;
    }
    if (mod & KMOD_RALT) {
        modifiers |= HID_KEYBOARD_MODIFIER_RIGHT_ALT;
    }
    if (mod & KMOD_RGUI) {
        modifiers |= HID_KEYBOARD_MODIFIER_RIGHT_GUI;
    }
    return modifiers;
 }
 static bool
 send_mod_lock_state(struct hid_keyboard *kb, unsigned lock_mod) {
    assert(!(lock_mod & ~SC_MOD_MASK));
    if (!lock_mod) {
        // Nothing to do
        return true;
    }
    struct hid_event hid_event;
    hid_event.from_accessory_id = HID_KEYBOARD_ACCESSORY_ID;
    hid_event.buffer = create_hid_keyboard_event();
    if (!hid_event.buffer) {
        return false;
    }
    hid_event.size = HID_KEYBOARD_EVENT_SIZE;
    unsigned i = 0;
    if (lock_mod & SC_MOD_CAPSLOCK) {
        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;
        ++i;
    }
    if (lock_mod & SC_MOD_NUMLOCK) {
        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_NUMLOCK;
        ++i;
    }
 //    for (int i = 0; i < HID_KEYBOARD_EVENT_SIZE; ++i)
 //        printf("%02x ", hid_event->buffer[i]);
 //    printf("\n");
    if (!aoa_push_hid_event(kb->aoa, &hid_event)) {
        LOGW("Could request HID event");
    }
    return true;
 }
 static bool
 convert_hid_keyboard_event(struct hid_keyboard *kb, struct hid_event *hid_event,
                           const SDL_KeyboardEvent *event) {
    hid_event->buffer = create_hid_keyboard_event();
    if (!hid_event->buffer) {
        return false;
    }
    hid_event->size = HID_KEYBOARD_EVENT_SIZE;
    unsigned char modifiers = sdl_keymod_to_hid_modifiers(event->keysym.mod);
    SDL_Scancode scancode = event->keysym.scancode;
    assert(scancode >= 0);
    if (scancode < 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;
    // Re-calculate pressed keys every time
    int keys_pressed_count = 0;
    for (int i = 0; i < 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_KEYBOARD_MAX_KEYS
                memset(&hid_event->buffer[HID_KEYBOARD_INDEX_KEYS],
                       HID_KEYBOARD_ERROR_ROLL_OVER, HID_KEYBOARD_MAX_KEYS);
                return true;
            }
            hid_event->buffer[HID_KEYBOARD_INDEX_KEYS + keys_pressed_count] = i;
            ++keys_pressed_count;
        }
    }
    return true;
 }
 static inline bool
 scancode_is_modifier(SDL_Scancode scancode) {
    return scancode >= SDL_SCANCODE_LCTRL && scancode <= SDL_SCANCODE_RGUI;
 }
 static bool
 hid_keyboard_convert_event(struct hid_keyboard *kb, struct hid_event *hid_event,
                           const SDL_KeyboardEvent *event) {
    LOGV(
        "Type: %s, Repeat: %s, Modifiers: %02x, Key: %02x",
        event->type == SDL_KEYDOWN ? "down" : "up",
        event->repeat != 0 ? "true" : "false",
        sdl_keymod_to_hid_modifiers(event->keysym.mod),
        event->keysym.scancode
    );
    hid_event->from_accessory_id = HID_KEYBOARD_ACCESSORY_ID;
    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 < HID_KEYBOARD_KEYS || scancode_is_modifier(scancode)) {
        return convert_hid_keyboard_event(kb, hid_event, event);
    }
    return false;
 }
 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 hid_keyboard *kb = DOWNCAST(kp);
    struct hid_event hid_event;
    // Not all keys are supported, just ignore unsupported keys
    if (hid_keyboard_convert_event(kb, &hid_event, event)) {
        if (!aoa_push_hid_event(kb->aoa, &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
 hid_keyboard_init(struct hid_keyboard *kb, struct aoa *aoa, unsigned lock_mod) {
    kb->aoa = aoa;
    // FIXME In practice, sending CAPS_LOCK immediately after fails with a Pipe
    // error but we must know immediately if this fails or not
    bool ok = aoa_setup_hid(aoa, HID_KEYBOARD_ACCESSORY_ID,
                            keyboard_report_desc,
                            ARRAY_LEN(keyboard_report_desc));
    if (!ok) {
        LOGW("Register HID for keyboard failed");
        return false;
    }
    // Reset all states
    memset(kb->keys, false, HID_KEYBOARD_KEYS);
    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;
    // FIXME to avoid pipe error
    usleep(100000);
    send_mod_lock_state(kb, lock_mod);
    return true;
 }
 void
 hid_keyboard_destroy(struct hid_keyboard *kb) {
    // Unregister HID keyboard so the soft keyboard shows again on Android
    bool ok = aoa_unregister_hid(kb->aoa, HID_KEYBOARD_ACCESSORY_ID);
    if (!ok) {
        LOGW("Could not unregister HID");
    }
 }
--- a/app/src/hid_keyboard.h
+++ b/app/src/hid_keyboard.h
@@ -1,48 +0,0 @@
 #ifndef HID_KEYBOARD_H
 #define HID_KEYBOARD_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL.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 HID_KEYBOARD_KEYS 0x66
 #define SC_MOD_MASK 0x3
 #define SC_MOD_CAPSLOCK 0x1
 #define SC_MOD_NUMLOCK 0x2
 /**
 * 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 hid_keyboard {
    struct sc_key_processor key_processor; // key processor trait
    struct aoa *aoa;
    bool keys[HID_KEYBOARD_KEYS];
 };
 bool
 hid_keyboard_init(struct hid_keyboard *kb, struct aoa *aoa, unsigned lock_mod);
 void
 hid_keyboard_destroy(struct hid_keyboard *kb);
 #endif
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@@ -3,6 +3,7 @@
 #include <assert.h>
 #include <SDL2/SDL_keycode.h>
 #include "event_converter.h"
 #include "util/log.h"
 static const int ACTION_DOWN = 1;
@@ -52,18 +53,15 @@ is_shortcut_mod(struct input_manager *im, uint16_t sdl_mod) {
 void
 input_manager_init(struct input_manager *im, struct controller *controller,
-                   struct screen *screen, struct sc_key_processor *kp,
+                   struct screen *screen,
                   struct sc_mouse_processor *mp,
                   const struct scrcpy_options *options) {
    assert(!options->control || (kp && kp->ops));
    assert(!options->control || (mp && mp->ops));
    im->controller = controller;
    im->screen = screen;
-    im->kp = kp;
+    im->repeat = 0;
    im->mp = mp;
    im->control = options->control;
    im->forward_key_repeat = options->forward_key_repeat;
    im->prefer_text = options->prefer_text;
    im->forward_all_clicks = options->forward_all_clicks;
    im->legacy_paste = options->legacy_paste;
@@ -325,8 +323,26 @@ 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
@@ -359,6 +375,27 @@ inverse_point(struct point point, struct size size) {
    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) {
@@ -376,8 +413,6 @@ input_manager_process_key(struct input_manager *im,
    bool smod = is_shortcut_mod(im, mod);
    LOGD("=== %x", (int) mod);
    if (down && !repeat) {
        if (keycode == im->last_keycode && mod == im->last_mod) {
            ++im->key_repeat;
@@ -514,6 +549,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
@@ -525,7 +569,27 @@ 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
@@ -543,22 +607,79 @@ input_manager_process_mouse_motion(struct input_manager *im,
        // simulated from touch events, so it's a duplicate
        return;
    }
    struct control_msg msg;
    if (!convert_mouse_motion(event, im->screen, &msg)) {
        return;
    }
-    im->mp->ops->process_mouse_motion(im->mp, event);
+    if (!controller_push_msg(im->controller, &msg)) {
        LOGW("Could not request 'inject mouse motion event'");
    }
    if (im->vfinger_down) {
-        struct point mouse =
+        struct point mouse = msg.inject_touch_event.position.point;
            screen_convert_window_to_frame_coords(im->screen, event->x,
                                                  event->y);
        struct 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
@@ -618,7 +739,15 @@ input_manager_process_mouse_button(struct input_manager *im,
        return;
    }
-    im->mp->ops->process_mouse_button(im->mp, event);
+    struct control_msg msg;
    if (!convert_mouse_button(event, im->screen, &msg)) {
        return;
    }
    if (!controller_push_msg(im->controller, &msg)) {
        LOGW("Could not request 'inject mouse button event'");
        return;
    }
    // Pinch-to-zoom simulation.
    //
@@ -632,9 +761,7 @@ input_manager_process_mouse_button(struct input_manager *im,
 #define CTRL_PRESSED (SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL))
    if ((down && !im->vfinger_down && CTRL_PRESSED)
            || (!down && im->vfinger_down)) {
-        struct point mouse =
+        struct point mouse = msg.inject_touch_event.position.point;
            screen_convert_window_to_frame_coords(im->screen, event->x,
                                                              event->y);
        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
        enum android_motionevent_action action = down
                                               ? AMOTION_EVENT_ACTION_DOWN
@@ -646,10 +773,39 @@ input_manager_process_mouse_button(struct input_manager *im,
    }
 }
 static bool
 convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
                    struct control_msg *to) {
    // mouse_x and mouse_y are expressed in pixels relative to the window
    int mouse_x;
    int mouse_y;
    SDL_GetMouseState(&mouse_x, &mouse_y);
    struct position position = {
        .screen_size = screen->frame_size,
        .point = screen_convert_window_to_frame_coords(screen,
                                                       mouse_x, mouse_y),
    };
    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
    to->inject_scroll_event.position = position;
    to->inject_scroll_event.hscroll = from->x;
    to->inject_scroll_event.vscroll = from->y;
    return true;
 }
 static void
 input_manager_process_mouse_wheel(struct input_manager *im,
                                  const SDL_MouseWheelEvent *event) {
-    im->mp->ops->process_mouse_wheel(im->mp, event);
+    struct control_msg msg;
    if (convert_mouse_wheel(event, im->screen, &msg)) {
        if (!controller_push_msg(im->controller, &msg)) {
            LOGW("Could not request 'inject mouse wheel event'");
        }
    }
 }
 bool
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@@ -11,17 +11,18 @@
 #include "fps_counter.h"
 #include "scrcpy.h"
 #include "screen.h"
 #include "trait/key_processor.h"
 #include "trait/mouse_processor.h"
 struct input_manager {
    struct controller *controller;
    struct screen *screen;
-    struct sc_key_processor *kp;
+    // SDL reports repeated events as a boolean, but Android expects the actual
-    struct sc_mouse_processor *mp;
+    // number of repetitions. This variable keeps track of the count.
    unsigned repeat;
    bool control;
    bool forward_key_repeat;
    bool prefer_text;
    bool forward_all_clicks;
    bool legacy_paste;
@@ -42,9 +43,7 @@ struct input_manager {
 void
 input_manager_init(struct input_manager *im, struct controller *controller,
-                   struct screen *screen, struct sc_key_processor *kp,
+                   struct screen *screen, const struct scrcpy_options *options);
                   struct sc_mouse_processor *mp,
                   const struct scrcpy_options *options);
 bool
 input_manager_handle_event(struct input_manager *im, SDL_Event *event);
--- a/app/src/keyboard_inject.h
+++ b/app/src/keyboard_inject.h
@@ -1,30 +0,0 @@
 #ifndef SC_KEYBOARD_INJECT_H
 #define SC_KEYBOARD_INJECT_H
 #include "common.h"
 #include <stdbool.h>
 #include "controller.h"
 #include "scrcpy.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/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 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,24 +0,0 @@
 #ifndef SC_MOUSE_INJECT_H
 #define SC_MOUSE_INJECT_H
 #include "common.h"
 #include <stdbool.h>
 #include "controller.h"
 #include "scrcpy.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/recorder.c
+++ b/app/src/recorder.c
@@ -1,8 +1,6 @@
 #include "recorder.h"
 #include <assert.h>
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
 #include "util/log.h"
@@ -215,8 +213,7 @@ run_recorder(void *data) {
        LOGE("Recording failed to %s", recorder->filename);
    } else {
        const char *format_name = recorder_get_format_name(recorder->format);
-        LOGI("Recording complete to %s file: %s", format_name,
+        LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
                                                  recorder->filename);
    }
    LOGD("Recorder thread ended");
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -18,11 +18,6 @@
 #include "events.h"
 #include "file_handler.h"
 #include "input_manager.h"
 #ifdef HAVE_AOA_HID
 # include "hid_keyboard.h"
 #endif
 #include "keyboard_inject.h"
 #include "mouse_inject.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
@@ -45,16 +40,6 @@ struct scrcpy {
 #endif
    struct controller controller;
    struct file_handler file_handler;
 #ifdef HAVE_AOA_HID
    struct aoa aoa;
 #endif
    union {
        struct sc_keyboard_inject keyboard_inject;
 #ifdef HAVE_AOA_HID
        struct hid_keyboard keyboard_hid;
 #endif
    };
    struct sc_mouse_inject mouse_inject;
    struct input_manager input_manager;
 };
@@ -254,20 +239,8 @@ stream_on_eos(struct stream *stream, void *userdata) {
    SDL_PushEvent(&stop_event);
 }
 static unsigned
 to_sc_mod(SDL_Keymod sdl_mod) {
    unsigned mod = 0;
    if (sdl_mod & KMOD_CAPS) {
        mod |= SC_MOD_CAPSLOCK;
    }
    if (sdl_mod & KMOD_NUM) {
        mod |= SC_MOD_NUMLOCK;
    }
    return mod;
 }
 bool
-scrcpy(struct scrcpy_options *options) {
+scrcpy(const struct scrcpy_options *options) {
    static struct scrcpy scrcpy;
    struct scrcpy *s = &scrcpy;
@@ -284,9 +257,6 @@ scrcpy(struct scrcpy_options *options) {
    bool v4l2_sink_initialized = false;
 #endif
    bool stream_started = false;
 #ifdef HAVE_AOA_HID
    bool aoa_hid_initialized = false;
 #endif
    bool controller_initialized = false;
    bool controller_started = false;
    bool screen_initialized = false;
@@ -360,7 +330,7 @@ scrcpy(struct scrcpy_options *options) {
    av_log_set_callback(av_log_callback);
-    static const struct stream_callbacks stream_cbs = {
+    const struct stream_callbacks stream_cbs = {
        .on_eos = stream_on_eos,
    };
    stream_init(&s->stream, s->server.video_socket, &stream_cbs, NULL);
@@ -442,80 +412,7 @@ scrcpy(struct scrcpy_options *options) {
    }
    stream_started = true;
-    struct sc_key_processor *kp = NULL;
+    input_manager_init(&s->input_manager, &s->controller, &s->screen, options);
    struct sc_mouse_processor *mp = NULL;
    if (options->control) {
        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID) {
 #ifdef HAVE_AOA_HID
            bool aoa_hid_ok = false;
            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 = aoa_init(&s->aoa, serial);
            free(serialno);
            if (!ok) {
                goto aoa_hid_end;
            }
            if (!aoa_start(&s->aoa)) {
                aoa_destroy(&s->aoa);
                goto aoa_hid_end;
            }
            // FIXME: SDL_GetModState() always returns 0 here :/
            unsigned mod = to_sc_mod(SDL_GetModState());
            if (!hid_keyboard_init(&s->keyboard_hid, &s->aoa, mod)) {
                aoa_join(&s->aoa);
                aoa_stop(&s->aoa);
                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/--keyboard-hid 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/--keyboard-hid 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...");
@@ -527,12 +424,6 @@ aoa_hid_end:
 end:
    // The stream is not stopped explicitly, because it will stop by itself on
    // end-of-stream
 #ifdef HAVE_AOA_HID
    if (aoa_hid_initialized) {
        hid_keyboard_destroy(&s->keyboard_hid);
        aoa_stop(&s->aoa);
    }
 #endif
    if (controller_started) {
        controller_stop(&s->controller);
    }
@@ -560,13 +451,6 @@ end:
    }
 #endif
 #ifdef HAVE_AOA_HID
    if (aoa_hid_initialized) {
        aoa_join(&s->aoa);
        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) {
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@@ -33,11 +33,6 @@ enum sc_lock_video_orientation {
    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 {
@@ -73,7 +68,6 @@ struct scrcpy_options {
    const char *v4l2_device;
    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;
@@ -118,7 +112,6 @@ struct scrcpy_options {
    .v4l2_device = NULL, \
    .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, \
@@ -158,6 +151,6 @@ struct scrcpy_options {
 }
 bool
-scrcpy(struct scrcpy_options *options);
+scrcpy(const struct scrcpy_options *options);
 #endif
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -60,20 +60,7 @@ get_server_path(void) {
        // not found, use current directory
        return strdup(SERVER_FILENAME);
    }
-
+    char *dir = dirname(executable_path);
    // 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 strdup(SERVER_FILENAME);
    }
    *p = '\0'; // modify executable_path in place
    char *dir = executable_path;
    size_t dirlen = strlen(dir);
    // sizeof(SERVER_FILENAME) gives statically the size including the null byte
@@ -274,8 +261,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",
@@ -285,8 +271,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="
@@ -483,7 +468,7 @@ error:
 static bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size) {
    unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
-    ssize_t r = net_recv_all(device_socket, buf, sizeof(buf));
+    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;
--- 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
@@ -23,129 +23,38 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
 }
 enum process_result
-process_execute_redirect(const char *const argv[], HANDLE *handle,
+process_execute(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;
+        return PROCESS_ERROR_GENERIC;
    }
    wchar_t *wide = utf8_to_wide_char(cmd);
    free(cmd);
    if (!wide) {
        LOGC("Could not allocate wide char string");
-        goto error_close_stderr;
+        return PROCESS_ERROR_GENERIC;
    }
-    if (!CreateProcessW(NULL, wide, NULL, NULL, TRUE, 0, NULL, NULL, &si,
+    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, 0, NULL, NULL, &si,
                        &pi)) {
        free(wide);
        *handle = NULL;
        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
-            ret = PROCESS_ERROR_MISSING_BINARY;
+            return PROCESS_ERROR_MISSING_BINARY;
        }
-        goto error_close_stderr;
+        return PROCESS_ERROR_GENERIC;
    }
    // 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);
 }
 bool
@@ -207,19 +116,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/trait/frame_sink.h
+++ b/app/src/trait/frame_sink.h
@@ -1,5 +1,5 @@
-#ifndef SC_FRAME_SINK_H
+#ifndef SC_FRAME_SINK
-#define SC_FRAME_SINK_H
+#define SC_FRAME_SINK
 #include "common.h"
--- a/app/src/trait/key_processor.h
+++ b/app/src/trait/key_processor.h
@@ -1,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,5 +1,5 @@
-#ifndef SC_PACKET_SINK_H
+#ifndef SC_PACKET_SINK
-#define SC_PACKET_SINK_H
+#define SC_PACKET_SINK
 #include "common.h"
--- a/app/src/util/net.c
+++ b/app/src/util/net.c
@@ -19,27 +19,11 @@
  typedef struct in_addr IN_ADDR;
 #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
 }
 socket_t
 net_connect(uint32_t addr, uint16_t port) {
    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == INVALID_SOCKET) {
-        net_perror("socket");
+        perror("socket");
        return INVALID_SOCKET;
    }
@@ -49,7 +33,7 @@ net_connect(uint32_t addr, uint16_t port) {
    sin.sin_port = htons(port);
    if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
-        net_perror("connect");
+        perror("connect");
        net_close(sock);
        return INVALID_SOCKET;
    }
@@ -61,14 +45,14 @@ 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) {
-        net_perror("socket");
+        perror("socket");
        return INVALID_SOCKET;
    }
    int reuse = 1;
    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
                   sizeof(reuse)) == -1) {
-        net_perror("setsockopt(SO_REUSEADDR)");
+        perror("setsockopt(SO_REUSEADDR)");
    }
    SOCKADDR_IN sin;
@@ -77,13 +61,13 @@ net_listen(uint32_t addr, uint16_t port, int backlog) {
    sin.sin_port = htons(port);
    if (bind(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
-        net_perror("bind");
+        perror("bind");
        net_close(sock);
        return INVALID_SOCKET;
    }
    if (listen(sock, backlog) == SOCKET_ERROR) {
-        net_perror("listen");
+        perror("listen");
        net_close(sock);
        return INVALID_SOCKET;
    }
@@ -115,17 +99,16 @@ net_send(socket_t socket, const void *buf, size_t len) {
 ssize_t
 net_send_all(socket_t socket, const void *buf, size_t len) {
-    size_t copied = 0;
+    ssize_t w = 0;
    while (len > 0) {
-        ssize_t w = send(socket, buf, len, 0);
+        w = send(socket, buf, len, 0);
        if (w == -1) {
-            return copied ? (ssize_t) copied : -1;
+            return -1;
        }
        len -= w;
        buf = (char *) buf + w;
        copied += w;
    }
-    return copied;
+    return w;
 }
 bool
--- a/app/src/util/process.c
+++ b/app/src/util/process.c
@@ -19,18 +19,3 @@ process_check_success(process_t proc, const char *name, bool close) {
    }
    return true;
 }
 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);
@@ -88,13 +78,4 @@ get_executable_path(void);
 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/tick.c
+++ b/app/src/util/tick.c
@@ -5,11 +5,11 @@
 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.
+    // in microseconds to avoid loosing precision on PTS.
    //
-    // As an alternative, SDL_GetPerformanceCounter() and
+    // SDL_GetPerformanceCounter()/SDL_GetPerformanceFrequency() could be used,
-    // SDL_GetPerformanceFrequency() could be used, but:
+    // but:
-    //  - the conversions (avoiding overflow) are expansive, since the
+    //  - the conversions (to avoid overflow) are not zero-cost, 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/v4l2_sink.c
+++ b/app/src/v4l2_sink.c
@@ -183,11 +183,8 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
        goto error_mutex_destroy;
    }
-    const AVOutputFormat *format = find_muxer("v4l2");
+    // FIXME
-    if (!format) {
+    const AVOutputFormat *format = find_muxer("video4linux2,v4l2");
        // Alternative name
        format = find_muxer("video4linux2");
    }
    if (!format) {
        LOGE("Could not find v4l2 muxer");
        goto error_cond_destroy;
--- a/app/src/video_buffer.h
+++ b/app/src/video_buffer.h
@@ -29,7 +29,7 @@ struct sc_video_buffer {
    sc_tick buffering_time;
-    // only if buffering_time > 0
+    // only if buffering_ms > 0
    struct {
        sc_thread thread;
        sc_mutex mutex;
--- a/cross_win32.txt
+++ b/cross_win32.txt
@@ -17,4 +17,4 @@ endian = 'little'
 [properties]
 prebuilt_ffmpeg_shared = 'ffmpeg-4.3.1-win32-shared'
 prebuilt_ffmpeg_dev = 'ffmpeg-4.3.1-win32-dev'
-prebuilt_sdl2 = 'SDL2-2.0.16/i686-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.14/i686-w64-mingw32'
--- a/cross_win64.txt
+++ b/cross_win64.txt
@@ -17,4 +17,4 @@ endian = 'little'
 [properties]
 prebuilt_ffmpeg_shared = 'ffmpeg-4.3.1-win64-shared'
 prebuilt_ffmpeg_dev = 'ffmpeg-4.3.1-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.16/x86_64-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.14/x86_64-w64-mingw32'
--- a/install_release.sh
+++ b/install_release.sh
@@ -2,8 +2,8 @@
 set -e
 BUILDDIR=build-auto
-PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.19/scrcpy-server-v1.19
+PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-server-v1.18
-PREBUILT_SERVER_SHA256=876f9322182e6aac6a58db1334f4225855ef3a17eaebc80aab6601d9d1ecb867
+PREBUILT_SERVER_SHA256=641c5c6beda9399dfae72d116f5ff43b5ed1059d871c9ebc3f47610fd33c51a3
 echo "[scrcpy] Downloading prebuilt server..."
 wget "$PREBUILT_SERVER_URL" -O scrcpy-server
--- a/meson.build
+++ b/meson.build
@@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '1.19',
+        version: '1.18',
        meson_version: '>= 0.48',
        default_options: [
            'c_std=c11',
--- a/prebuilt-deps/Makefile
+++ b/prebuilt-deps/Makefile
@@ -30,11 +30,11 @@ prepare-ffmpeg-dev-win64:
 		ffmpeg-4.3.1-win64-dev
 prepare-sdl2:
-	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.16-mingw.tar.gz \
+	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.14-mingw.tar.gz \
-		2bfe48628aa9635c12eac7d421907e291525de1d0b04b3bca4a5bd6e6c881a6f \
+		405eaff3eb18f2e08fe669ef9e63bc9a8710b7d343756f238619761e9b60407d \
-		SDL2-2.0.16
+		SDL2-2.0.14
 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r31.0.3-windows.zip \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r31.0.2-windows.zip \
-		0f4b8fdd26af2c3733539d6eebb3c2ed499ea1d4bb1f4e0ecc2d6016961a6e24 \
+		d560cb8ded83ae04763b94632673481f14843a5969256569623cfeac82db4ba5 \
 		platform-tools
--- a/release.mk
+++ b/release.mk
@@ -102,7 +102,7 @@ dist-win32: build-server build-win32
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.16/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.14/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 dist-win64: build-server build-win64
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
@@ -118,7 +118,7 @@ dist-win64: build-server build-win64
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.16/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.14/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 zip-win32: dist-win32
 	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 30
-        versionCode 11900
+        versionCode 11800
-        versionName "1.19"
+        versionName "1.18"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
--- a/server/build_without_gradle.sh
+++ b/server/build_without_gradle.sh
@@ -12,7 +12,7 @@
 set -e
 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.19
+SCRCPY_VERSION_NAME=1.18
 PLATFORM=${ANDROID_PLATFORM:-30}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-30.0.0}
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@@ -241,7 +241,7 @@ public class Controller {
        MotionEvent event = MotionEvent
                .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEFAULT_DEVICE_ID, 0,
-                        InputDevice.SOURCE_MOUSE, 0);
+                        InputDevice.SOURCE_TOUCHSCREEN, 0);
        return device.injectEvent(event);
    }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@@ -56,13 +56,17 @@ public class ScreenEncoder implements Device.RotationListener {
    public void streamScreen(Device device, FileDescriptor fd) throws IOException {
        Workarounds.prepareMainLooper();
        if (Build.BRAND.equalsIgnoreCase("meizu")) {
            // <https://github.com/Genymobile/scrcpy/issues/240>
            // <https://github.com/Genymobile/scrcpy/issues/2656>
            Workarounds.fillAppInfo();
        }
-        internalStreamScreen(device, fd);
+        try {
            internalStreamScreen(device, fd);
        } catch (NullPointerException e) {
            // Retry with workarounds enabled:
            // <https://github.com/Genymobile/scrcpy/issues/365>
            // <https://github.com/Genymobile/scrcpy/issues/940>
            Ln.d("Applying workarounds to avoid NullPointerException");
            Workarounds.fillAppInfo();
            internalStreamScreen(device, fd);
        }
    }
    private void internalStreamScreen(Device device, FileDescriptor fd) throws IOException {
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
@@ -11,7 +11,6 @@ public class StatusBarManager {
    private final IInterface manager;
    private Method expandNotificationsPanelMethod;
    private boolean expandNotificationPanelMethodCustomVersion;
    private Method expandSettingsPanelMethod;
    private boolean expandSettingsPanelMethodNewVersion = true;
    private Method collapsePanelsMethod;
@@ -22,13 +21,7 @@ public class StatusBarManager {
    private Method getExpandNotificationsPanelMethod() throws NoSuchMethodException {
        if (expandNotificationsPanelMethod == null) {
-            try {
+            expandNotificationsPanelMethod = manager.getClass().getMethod("expandNotificationsPanel");
                expandNotificationsPanelMethod = manager.getClass().getMethod("expandNotificationsPanel");
            } catch (NoSuchMethodException e) {
                // Custom version for custom vendor ROM: <https://github.com/Genymobile/scrcpy/issues/2551>
                expandNotificationsPanelMethod = manager.getClass().getMethod("expandNotificationsPanel", int.class);
                expandNotificationPanelMethodCustomVersion = true;
            }
        }
        return expandNotificationsPanelMethod;
    }
@@ -57,11 +50,7 @@ public class StatusBarManager {
    public void expandNotificationsPanel() {
        try {
            Method method = getExpandNotificationsPanelMethod();
-            if (expandNotificationPanelMethodCustomVersion) {
+            method.invoke(manager);
                method.invoke(manager, 0);
            } else {
                method.invoke(manager);
            }
        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
        }
Author	SHA1	Message	Date
Romain Vimont	b454af6808	Compensate slope on start 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.	2021-07-14 00:39:35 +02:00
Romain Vimont	2b0399a615	Add buffering debugging tools Output buffering and clock logs by disabling a compilation flag.	2021-07-14 00:39:35 +02:00
Romain Vimont	fb6863068c	Add clock tests The clock rolling sum is not trivial. Test it.	2021-07-14 00:39:35 +02:00
Romain Vimont	5cbcd10356	Add buffering command line options Add --display-buffer and --v4l2-buffer options to configure buffering time.	2021-07-14 00:39:35 +02:00
Romain Vimont	ecf417fc49	Implement buffering To minimize latency (at the cost of jitter), scrcpy always displays a frame as soon as it available, without waiting. However, when recording (--record), it still writes the captured timestamps to the output file, so that the recorded file can be played correctly without jitter. Some real-time use cases might benefit from adding a small latency to compensate for jitter too. For example, few tens of seconds of latency for live-streaming are not important, but jitter is noticeable. Therefore, implement a buffering mechanism (disabled by default) to add a configurable latency delay. PR #2417 <https://github.com/Genymobile/scrcpy/issues/2417>	2021-07-14 00:39:35 +02:00
Romain Vimont	85bc66ad05	Notify new frames via callbacks Currently, a frame is available to the consumer as soon as it is pushed by the producer (which can detect if the previous frame is skipped). Notify the new frames (and frame skipped) via callbacks instead. This paves the way to add (optional) buffering, which will introduce a delay between the time when the frame is produced and the time it is available to be consumed.	2021-07-14 00:39:35 +02:00
Romain Vimont	ed2ac27596	Extract current video_buffer to frame_buffer The current video buffer only stores one pending frame. In order to add a new buffering feature, move this part to a separate "frame buffer". Keep the video_buffer, which currently delegates all its calls to the frame_buffer.	2021-07-14 00:39:35 +02:00
Romain Vimont	70a1b46e13	Rename video_buffer to sc_video_buffer Add a scrcpy-specific prefix.	2021-07-14 00:39:35 +02:00
Romain Vimont	c1eeaa080a	Relax v4l2_sink lock constraints To fix a data race, commit `5caeab5f6d` called video_buffer_push() and video_buffer_consume() under the v4l2_sink lock. Instead, use the previous_skipped indication (initialized with video buffer locked) to lock only for protecting the has_frame flag. This enables the possibility for the video_buffer to notify new frames via callbacks without lock inversion issues.	2021-07-14 00:39:35 +02:00
Romain Vimont	7ae18c3601	Replace delay by deadline in timedwait() The function sc_cond_timedwait() accepted a parameter representing the max duration to wait, because it internally uses SDL_CondWaitTimeout(). Instead, accept a deadline, to be consistent with pthread_cond_timedwait().	2021-07-14 00:39:35 +02:00
Romain Vimont	1ffabc6fcd	Wrap tick API This avoids to use the SDL timer API directly, and will allow to handle generic ticks (possibly negative).	2021-07-14 00:39:35 +02:00