wip

The serial is necessary to find the correct Android device for AOA.

If it is not explicitly provided by the user via -s, then execute "adb
getserialno" to retrieve it.

BUILD.md

@@ -88,11 +88,12 @@ Install the required packages from your package manager.
 
 ```bash
 # runtime dependencies
-sudo apt install ffmpeg libsdl2-2.0-0 adb
+sudo apt install ffmpeg libsdl2-2.0-0 adb libusb-1.0-0
 
 # client build dependencies
 sudo apt install gcc git pkg-config meson ninja-build libsdl2-dev \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev
+                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev\
+                 libusb-dev
 
 # server build dependencies
 sudo apt install openjdk-11-jdk
@@ -114,7 +115,7 @@ pip3 install meson
 sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
 
 # client build dependencies
-sudo dnf install SDL2-devel ffms2-devel meson gcc make
+sudo dnf install SDL2-devel ffms2-devel libusb-devel meson gcc make
 
 # server build dependencies
 sudo dnf install java-devel
@@ -159,7 +160,8 @@ 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 \
@@ -173,7 +175,8 @@ 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 \
@@ -197,7 +200,7 @@ Install the packages with [Homebrew]:
 
 ```bash
 # runtime dependencies
-brew install sdl2 ffmpeg
+brew install sdl2 ffmpeg libusb
 
 # client build dependencies
 brew install pkg-config meson
@@ -268,10 +271,10 @@ install` must be run as root)._
 
 #### Option 2: Use prebuilt server
 
- - [`scrcpy-server-v1.18`][direct-scrcpy-server]  
-   _(SHA-256: 641c5c6beda9399dfae72d116f5ff43b5ed1059d871c9ebc3f47610fd33c51a3)_
+ - [`scrcpy-server-v1.19`][direct-scrcpy-server]  
+   _(SHA-256: 876f9322182e6aac6a58db1334f4225855ef3a17eaebc80aab6601d9d1ecb867)_
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-server-v1.18
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.19/scrcpy-server-v1.19
 
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:

DEVELOP.md

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

FAQ.md

@@ -153,6 +153,26 @@ You may also need to configure the [scaling behavior]:
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 
 
+### Issue with Wayland
+
+By default, SDL uses x11 on Linux. The [video driver] can be changed via the
+`SDL_VIDEODRIVER` environment variable:
+
+[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
+
+```bash
+export SDL_VIDEODRIVER=wayland
+scrcpy
+```
+
+On some distributions (at least Fedora), the package `libdecor` must be
+installed manually.
+
+See issues [#2554] and [#2559].
+
+[#2554]: https://github.com/Genymobile/scrcpy/issues/2554
+[#2559]: https://github.com/Genymobile/scrcpy/issues/2559
+
 
 ### KWin compositor crashes
 
@@ -240,3 +260,4 @@ This FAQ is available in other languages:
 
  - [Italiano (Italiano, `it`) - v1.17](FAQ.it.md)
  - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md)
+ - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.18](FAQ.zh-Hans.md)

FAQ.zh-Hans.md

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

README.md

@@ -1,4 +1,4 @@
-# scrcpy (v1.18)
+# scrcpy (v1.19)
 
 [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.18.zip`][direct-win64]  
-   _(SHA-256: 37212f5087fe6f3e258f1d44fa5c02207496b30e1d7ec442cbcf8358910a5c63)_
+ - [`scrcpy-win64-v1.19.zip`][direct-win64]  
+   _(SHA-256: 383d6483f25ac0092d4bb9fef6c967351ecd50fc248e0c82932db97d6d32f11b)_
 
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-win64-v1.18.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.19/scrcpy-win64-v1.19.zip
 
 It is also available in [Chocolatey]:
 
@@ -207,6 +207,29 @@ 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
 
@@ -318,7 +341,25 @@ vlc v4l2:///dev/videoN   # VLC might add some buffering delay
 
 For example, you could capture the video within [OBS].
 
-[OBS]: https://obsproject.com/fr
+[OBS]: https://obsproject.com/
+
+
+#### Buffering
+
+It is possible to add buffering. This increases latency but reduces jitter (see
+#2464).
+
+The option is available for display buffering:
+
+```bash
+scrcpy --display-buffer=50  # add 50 ms buffering for display
+```
+
+and V4L2 sink:
+
+```bash
+scrcpy --v4l2-buffer=500    # add 500 ms buffering for v4l2 sink
+```
 
 
 ### Connection
@@ -875,5 +916,6 @@ This README is available in other languages:
 - [Español (Spanish, `sp`) - v1.17](README.sp.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.17](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
+- [Turkish (Turkish, `tr`) - v1.18](README.tr.md)
 
 Only this README file is guaranteed to be up-to-date.

README.tr.md

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

app/meson.build

@@ -2,15 +2,18 @@ src = [
     'src/main.c',
     'src/adb.c',
     'src/cli.c',
+    'src/clock.c',
     'src/compat.c',
     'src/control_msg.c',
     'src/controller.c',
     'src/decoder.c',
     'src/device_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',
@@ -25,6 +28,7 @@ src = [
     'src/util/process.c',
     'src/util/str_util.c',
     'src/util/thread.c',
+    'src/util/tick.c',
 ]
 
 if host_machine.system() == 'windows'
@@ -38,6 +42,14 @@ if v4l2_support
     src += [ 'src/v4l2_sink.c' ]
 endif
 
+aoa_hid_support = host_machine.system() == 'linux'
+if aoa_hid_support
+    src += [
+        'src/aoa_hid.c',
+        'src/hid_keyboard.c',
+    ]
+endif
+
 check_functions = [
     'strdup'
 ]
@@ -58,8 +70,11 @@ if not get_option('crossbuild_windows')
         dependencies += dependency('libavdevice')
     endif
 
-else
+    if aoa_hid_support
+        dependencies += dependency('libusb-1.0')
+    endif
 
+else
     # cross-compile mingw32 build (from Linux to Windows)
     prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
     sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
@@ -136,6 +151,9 @@ conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == '
 # enable V4L2 support (linux only)
 conf.set('HAVE_V4L2', v4l2_support)
 
+# enable HID over AOA support (linux only)
+conf.set('HAVE_AOA_HID', aoa_hid_support)
+
 configure_file(configuration: conf, output: 'config.h')
 
 src_dir = include_directories('src')
@@ -165,6 +183,10 @@ if get_option('buildtype') == 'debug'
             'src/cli.c',
             'src/util/str_util.c',
         ]],
+        ['test_clock', [
+            'tests/test_clock.c',
+            'src/clock.c',
+        ]],
         ['test_control_msg_serialize', [
             'tests/test_control_msg_serialize.c',
             'src/control_msg.c',

app/scrcpy.1

@@ -56,6 +56,12 @@ The list of possible display ids can be listed by "adb shell dumpsys display"
 
 Default is 0.
 
+.TP
+.BI "\-\-display\-buffer ms
+Add a buffering delay (in milliseconds) before displaying. This increases latency to compensate for jitter.
+
+Default is 0 (no buffering).
+
 .TP
 .BI "\-\-encoder " name
 Use a specific MediaCodec encoder (must be a H.264 encoder).
@@ -76,6 +82,24 @@ 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).
@@ -83,8 +107,8 @@ Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+S
 This is a workaround for some devices not behaving as expected when setting the device clipboard programmatically.
 
 .TP
-.BI "\-\-lock\-video\-orientation " [value]
-Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
+.BI "\-\-lock\-video\-orientation[=value]
+Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees rotation counterclockwise.
 
 Default is "unlocked".
 
@@ -189,7 +213,15 @@ It only shows physical touches (not clicks from scrcpy).
 .BI "\-\-v4l2-sink " /dev/videoN
 Output to v4l2loopback device.
 
-It requires to lock the video orientation (see --lock-video-orientation).
+It requires to lock the video orientation (see \fB\-\-lock\-video\-orientation\fR).
+
+.TP
+.BI "\-\-v4l2-buffer " ms
+Add a buffering delay (in milliseconds) before pushing frames. This increases latency to compensate for jitter.
+
+This option is similar to \fB\-\-display\-buffer\fR, but specific to V4L2 sink.
+
+Default is 0 (no buffering).
 
 .TP
 .BI "\-V, \-\-verbosity " value
@@ -240,7 +272,7 @@ Default is 0 (automatic).
 .SH SHORTCUTS
 
 In the following list, MOD is the shortcut modifier. By default, it's (left)
-Alt or (left) Super, but it can be configured by \-\-shortcut-mod (see above).
+Alt or (left) Super, but it can be configured by \fB\-\-shortcut\-mod\fR (see above).
 
 .TP
 .B MOD+f

app/src/adb.c

@@ -109,7 +109,9 @@ show_adb_err_msg(enum process_result err, const char *const argv[]) {
 }
 
 process_t
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
+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) {
     int i;
     process_t process;
 
@@ -129,7 +131,9 @@ adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
 
     memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
     argv[len + i] = NULL;
-    enum process_result r = process_execute(argv, &process);
+    enum process_result r =
+        process_execute_redirect(argv, &process, pipe_stdin, pipe_stdout,
+                                 pipe_stderr);
     if (r != PROCESS_SUCCESS) {
         show_adb_err_msg(r, argv);
         process = PROCESS_NONE;
@@ -139,6 +143,11 @@ adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
     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) {
@@ -224,3 +233,47 @@ 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);
+}

app/src/adb.h

@@ -11,6 +11,11 @@
 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);
@@ -31,4 +36,8 @@ 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

app/src/aoa_hid.c

@@ -0,0 +1,363 @@
+#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 (ssize_t i = 0; i < 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 inline bool
+process_hid_event(struct aoa *aoa, const struct hid_event *event) {
+    return aoa_send_hid_event(aoa, event);
+}
+
+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);
+
+        LOGD("======= aoa_thread process event");
+        bool ok = process_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);
+}

app/src/aoa_hid.h

@@ -0,0 +1,57 @@
+#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

app/src/cli.c

@@ -55,6 +55,12 @@ scrcpy_print_usage(const char *arg0) {
         "\n"
         "        Default is 0.\n"
         "\n"
+        "    --display-buffer ms\n"
+        "        Add a buffering delay (in milliseconds) before displaying.\n"
+        "        This increases latency to compensate for jitter.\n"
+        "\n"
+        "        Default is 0 (no buffering).\n"
+        "\n"
         "    --encoder name\n"
         "        Use a specific MediaCodec encoder (must be a H.264 encoder).\n"
         "\n"
@@ -70,6 +76,14 @@ 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"
@@ -79,7 +93,7 @@ scrcpy_print_usage(const char *arg0) {
         "        This is a workaround for some devices not behaving as\n"
         "        expected when setting the device clipboard programmatically.\n"
         "\n"
-        "    --lock-video-orientation [value]\n"
+        "    --lock-video-orientation[=value]\n"
         "        Lock video orientation to value.\n"
         "        Possible values are \"unlocked\", \"initial\" (locked to the\n"
         "        initial orientation), 0, 1, 2 and 3.\n"
@@ -182,6 +196,15 @@ scrcpy_print_usage(const char *arg0) {
         "        It requires to lock the video orientation (see\n"
         "        --lock-video-orientation).\n"
         "\n"
+        "    --v4l2-buffer ms\n"
+        "        Add a buffering delay (in milliseconds) before pushing\n"
+        "        frames. This increases latency to compensate for jitter.\n"
+        "\n"
+        "        This option is similar to --display-buffer, but specific to\n"
+        "        V4L2 sink.\n"
+        "\n"
+        "        Default is 0 (no buffering).\n"
+        "\n"
 #endif
         "    -V, --verbosity value\n"
         "        Set the log level (verbose, debug, info, warn or error).\n"
@@ -392,6 +415,19 @@ parse_max_fps(const char *s, uint16_t *max_fps) {
     return true;
 }
 
+static bool
+parse_buffering_time(const char *s, sc_tick *tick) {
+    long value;
+    bool ok = parse_integer_arg(s, &value, false, 0, 0x7FFFFFFF,
+                                "buffering time");
+    if (!ok) {
+        return false;
+    }
+
+    *tick = SC_TICK_FROM_MS(value);
+    return true;
+}
+
 static bool
 parse_lock_video_orientation(const char *s,
                              enum sc_lock_video_orientation *lock_mode) {
@@ -689,6 +725,8 @@ guess_record_format(const char *filename) {
 #define OPT_ENCODER_NAME           1025
 #define OPT_POWER_OFF_ON_CLOSE     1026
 #define OPT_V4L2_SINK              1027
+#define OPT_DISPLAY_BUFFER         1028
+#define OPT_V4L2_BUFFER            1029
 
 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@@ -700,6 +738,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         {"disable-screensaver",    no_argument,       NULL,
                                                   OPT_DISABLE_SCREENSAVER},
         {"display",                required_argument, NULL, OPT_DISPLAY_ID},
+        {"display-buffer",         required_argument, NULL, OPT_DISPLAY_BUFFER},
         {"encoder",                required_argument, NULL, OPT_ENCODER_NAME},
         {"force-adb-forward",      no_argument,       NULL,
                                                   OPT_FORCE_ADB_FORWARD},
@@ -707,6 +746,7 @@ 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},
@@ -732,6 +772,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         {"turn-screen-off",        no_argument,       NULL, 'S'},
 #ifdef HAVE_V4L2
         {"v4l2-sink",              required_argument, NULL, OPT_V4L2_SINK},
+        {"v4l2-buffer",            required_argument, NULL, OPT_V4L2_BUFFER},
 #endif
         {"verbosity",              required_argument, NULL, 'V'},
         {"version",                no_argument,       NULL, 'v'},
@@ -752,7 +793,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:hm:nNp:r:s:StTvV:w",
+    while ((c = getopt_long(argc, argv, "b:c:fF:hKm:nNp:r:s:StTvV:w",
                             long_options, NULL)) != -1) {
         switch (c) {
             case 'b':
@@ -785,6 +826,9 @@ 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;
@@ -917,10 +961,20 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
             case OPT_POWER_OFF_ON_CLOSE:
                 opts->power_off_on_close = true;
                 break;
+            case OPT_DISPLAY_BUFFER:
+                if (!parse_buffering_time(optarg, &opts->display_buffer)) {
+                    return false;
+                }
+                break;
 #ifdef HAVE_V4L2
             case OPT_V4L2_SINK:
                 opts->v4l2_device = optarg;
                 break;
+            case OPT_V4L2_BUFFER:
+                if (!parse_buffering_time(optarg, &opts->v4l2_buffer)) {
+                    return false;
+                }
+                break;
 #endif
             default:
                 // getopt prints the error message on stderr
@@ -941,6 +995,11 @@ 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)");

app/src/clock.c

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

app/src/clock.h

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

app/src/controller.c

@@ -70,7 +70,7 @@ process_msg(struct controller *controller,
     if (!length) {
         return false;
     }
-    int w = net_send_all(controller->control_socket, serialized_msg, length);
+    ssize_t w = net_send_all(controller->control_socket, serialized_msg, length);
     return (size_t) w == length;
 }
 

app/src/decoder.c

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

app/src/event_converter.h

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

app/src/fps_counter.c

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

app/src/fps_counter.h

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

app/src/frame_buffer.c

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

app/src/frame_buffer.h

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

app/src/hid_keyboard.c

@@ -0,0 +1,341 @@
+#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
+
+/**
+ * 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
+gen(struct hid_keyboard *kb, 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;
+    hid_event->buffer[HID_KEYBOARD_INDEX_KEYS] = 57; //CAPSLOCK
+    for (int i = 0; i < HID_KEYBOARD_EVENT_SIZE; ++i)
+        printf("%02x ", hid_event->buffer[i]);
+    printf("\n");
+    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 *kh = DOWNCAST(kp);
+
+    struct hid_event hid_event;
+    // Not all keys are supported, just ignore unsupported keys
+    if (hid_keyboard_convert_event(kh, &hid_event, event)) {
+        if (!aoa_push_hid_event(kh->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 problem: aoa_setup_hid is executed from this thread, but events
+    // are sent from the aoa thread. Is this thread-safe?
+    // In practice, sending CAPS_LOCK immediately after fails with a Pipe error
+    // but we must know immediately if this fails or not
+    // TODO test with a simple mutex to confirm
+    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;
+
+    if (lock_mod & SC_MOD_CAPS_LOCK) {
+        struct hid_event event;
+        gen(kb, &event); // FIXME error handling
+        if (!aoa_push_hid_event(kb->aoa, &event)) {
+            LOGW("Could request HID event");
+        }
+    }
+    if (lock_mod & SC_MOD_NUM_LOCK) {
+        // TODO
+    }
+
+    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");
+    }
+}

app/src/hid_keyboard.h

@@ -0,0 +1,47 @@
+#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_CAPS_LOCK 0x1
+#define SC_MOD_NUM_LOCK 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

app/src/input_manager.c

@@ -3,7 +3,6 @@
 #include <assert.h>
 #include <SDL2/SDL_keycode.h>
 
-#include "event_converter.h"
 #include "util/log.h"
 
 static const int ACTION_DOWN = 1;
@@ -53,15 +52,18 @@ is_shortcut_mod(struct input_manager *im, uint16_t sdl_mod) {
 
 void
 input_manager_init(struct input_manager *im, struct controller *controller,
-                   struct screen *screen,
+                   struct screen *screen, struct sc_key_processor *kp,
+                   struct sc_mouse_processor *mp,
                    const struct scrcpy_options *options) {
+    assert(!options->control || (kp && kp->ops));
+    assert(!options->control || (mp && mp->ops));
+
     im->controller = controller;
     im->screen = screen;
-    im->repeat = 0;
+    im->kp = kp;
+    im->mp = mp;
 
     im->control = options->control;
-    im->forward_key_repeat = options->forward_key_repeat;
-    im->prefer_text = options->prefer_text;
     im->forward_all_clicks = options->forward_all_clicks;
     im->legacy_paste = options->legacy_paste;
 
@@ -323,26 +325,8 @@ input_manager_process_text_input(struct input_manager *im,
         // A shortcut must never generate text events
         return;
     }
-    if (!im->prefer_text) {
-        char c = event->text[0];
-        if (isalpha(c) || c == ' ') {
-            assert(event->text[1] == '\0');
-            // letters and space are handled as raw key event
-            return;
-        }
-    }
 
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = strdup(event->text);
-    if (!msg.inject_text.text) {
-        LOGW("Could not strdup input text");
-        return;
-    }
-    if (!controller_push_msg(im->controller, &msg)) {
-        free(msg.inject_text.text);
-        LOGW("Could not request 'inject text'");
-    }
+    im->kp->ops->process_text(im->kp, event);
 }
 
 static bool
@@ -375,27 +359,6 @@ 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) {
@@ -413,6 +376,8 @@ 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;
@@ -549,15 +514,6 @@ input_manager_process_key(struct input_manager *im,
         return;
     }
 
-    if (event->repeat) {
-        if (!im->forward_key_repeat) {
-            return;
-        }
-        ++im->repeat;
-    } else {
-        im->repeat = 0;
-    }
-
     if (ctrl && !shift && keycode == SDLK_v && down && !repeat) {
         if (im->legacy_paste) {
             // inject the text as input events
@@ -569,27 +525,7 @@ input_manager_process_key(struct input_manager *im,
         set_device_clipboard(controller, false);
     }
 
-    struct control_msg msg;
-    if (convert_input_key(event, &msg, im->prefer_text, im->repeat)) {
-        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'inject keycode'");
-        }
-    }
-}
-
-static bool
-convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
-                     struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
-        screen_convert_window_to_frame_coords(screen, from->x, from->y);
-    to->inject_touch_event.pressure = 1.f;
-    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
-
-    return true;
+    im->kp->ops->process_key(im->kp, event);
 }
 
 static void
@@ -607,79 +543,22 @@ input_manager_process_mouse_motion(struct input_manager *im,
         // simulated from touch events, so it's a duplicate
         return;
     }
-    struct control_msg msg;
-    if (!convert_mouse_motion(event, im->screen, &msg)) {
-        return;
-    }
 
-    if (!controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request 'inject mouse motion event'");
-    }
+    im->mp->ops->process_mouse_motion(im->mp, event);
 
     if (im->vfinger_down) {
-        struct point mouse = msg.inject_touch_event.position.point;
+        struct point mouse =
+            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) {
-    struct control_msg msg;
-    if (convert_touch(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject touch event'");
-        }
-    }
-}
-
-static bool
-convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
-                     struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-
-    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
-        return false;
-    }
-
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
-        screen_convert_window_to_frame_coords(screen, from->x, from->y);
-    to->inject_touch_event.pressure =
-        from->type == SDL_MOUSEBUTTONDOWN ? 1.f : 0.f;
-    to->inject_touch_event.buttons =
-        convert_mouse_buttons(SDL_BUTTON(from->button));
-
-    return true;
+    im->mp->ops->process_touch(im->mp, event);
 }
 
 static void
@@ -739,15 +618,7 @@ input_manager_process_mouse_button(struct input_manager *im,
         return;
     }
 
-    struct control_msg msg;
-    if (!convert_mouse_button(event, im->screen, &msg)) {
-        return;
-    }
-
-    if (!controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request 'inject mouse button event'");
-        return;
-    }
+    im->mp->ops->process_mouse_button(im->mp, event);
 
     // Pinch-to-zoom simulation.
     //
@@ -761,7 +632,9 @@ input_manager_process_mouse_button(struct input_manager *im,
 #define CTRL_PRESSED (SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL))
     if ((down && !im->vfinger_down && CTRL_PRESSED)
             || (!down && im->vfinger_down)) {
-        struct point mouse = msg.inject_touch_event.position.point;
+        struct point mouse =
+            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
@@ -773,39 +646,10 @@ input_manager_process_mouse_button(struct input_manager *im,
     }
 }
 
-static bool
-convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
-                    struct control_msg *to) {
-
-    // mouse_x and mouse_y are expressed in pixels relative to the window
-    int mouse_x;
-    int mouse_y;
-    SDL_GetMouseState(&mouse_x, &mouse_y);
-
-    struct position position = {
-        .screen_size = screen->frame_size,
-        .point = screen_convert_window_to_frame_coords(screen,
-                                                       mouse_x, mouse_y),
-    };
-
-    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
-
-    to->inject_scroll_event.position = position;
-    to->inject_scroll_event.hscroll = from->x;
-    to->inject_scroll_event.vscroll = from->y;
-
-    return true;
-}
-
 static void
 input_manager_process_mouse_wheel(struct input_manager *im,
                                   const SDL_MouseWheelEvent *event) {
-    struct control_msg msg;
-    if (convert_mouse_wheel(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject mouse wheel event'");
-        }
-    }
+    im->mp->ops->process_mouse_wheel(im->mp, event);
 }
 
 bool

app/src/input_manager.h

@@ -11,18 +11,17 @@
 #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;
 
-    // SDL reports repeated events as a boolean, but Android expects the actual
-    // number of repetitions. This variable keeps track of the count.
-    unsigned repeat;
+    struct sc_key_processor *kp;
+    struct sc_mouse_processor *mp;
 
     bool control;
-    bool forward_key_repeat;
-    bool prefer_text;
     bool forward_all_clicks;
     bool legacy_paste;
 
@@ -43,7 +42,9 @@ struct input_manager {
 
 void
 input_manager_init(struct input_manager *im, struct controller *controller,
-                   struct screen *screen, const struct scrcpy_options *options);
+                   struct screen *screen, struct sc_key_processor *kp,
+                   struct sc_mouse_processor *mp,
+                   const struct scrcpy_options *options);
 
 bool
 input_manager_handle_event(struct input_manager *im, SDL_Event *event);

app/src/keyboard_inject.c

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

app/src/keyboard_inject.h

@@ -0,0 +1,30 @@
+#ifndef SC_KEYBOARD_INJECT_H
+#define SC_KEYBOARD_INJECT_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "controller.h"
+#include "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

app/src/mouse_inject.c

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

app/src/mouse_inject.h

@@ -0,0 +1,24 @@
+#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

app/src/recorder.c

@@ -1,6 +1,8 @@
 #include "recorder.h"
 
 #include <assert.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
 #include <libavutil/time.h>
 
 #include "util/log.h"
@@ -51,16 +53,15 @@ record_packet_new(const AVPacket *packet) {
 
 static void
 record_packet_delete(struct record_packet *rec) {
-    av_packet_unref(rec->packet);
     av_packet_free(&rec->packet);
     free(rec);
 }
 
 static void
 recorder_queue_clear(struct recorder_queue *queue) {
-    while (!queue_is_empty(queue)) {
+    while (!sc_queue_is_empty(queue)) {
         struct record_packet *rec;
-        queue_take(queue, next, &rec);
+        sc_queue_take(queue, next, &rec);
         record_packet_delete(rec);
     }
 }
@@ -136,14 +137,14 @@ run_recorder(void *data) {
     for (;;) {
         sc_mutex_lock(&recorder->mutex);
 
-        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
+        while (!recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
             sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
         }
 
         // if stopped is set, continue to process the remaining events (to
         // finish the recording) before actually stopping
 
-        if (recorder->stopped && queue_is_empty(&recorder->queue)) {
+        if (recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
             sc_mutex_unlock(&recorder->mutex);
             struct record_packet *last = recorder->previous;
             if (last) {
@@ -162,7 +163,7 @@ run_recorder(void *data) {
         }
 
         struct record_packet *rec;
-        queue_take(&recorder->queue, next, &rec);
+        sc_queue_take(&recorder->queue, next, &rec);
 
         sc_mutex_unlock(&recorder->mutex);
 
@@ -214,7 +215,8 @@ run_recorder(void *data) {
         LOGE("Recording failed to %s", recorder->filename);
     } else {
         const char *format_name = recorder_get_format_name(recorder->format);
-        LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
+        LOGI("Recording complete to %s file: %s", format_name,
+                                                  recorder->filename);
     }
 
     LOGD("Recorder thread ended");
@@ -236,7 +238,7 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
         goto error_mutex_destroy;
     }
 
-    queue_init(&recorder->queue);
+    sc_queue_init(&recorder->queue);
     recorder->stopped = false;
     recorder->failed = false;
     recorder->header_written = false;
@@ -341,7 +343,7 @@ recorder_push(struct recorder *recorder, const AVPacket *packet) {
         return false;
     }
 
-    queue_push(&recorder->queue, next, rec);
+    sc_queue_push(&recorder->queue, next, rec);
     sc_cond_signal(&recorder->queue_cond);
 
     sc_mutex_unlock(&recorder->mutex);

app/src/recorder.h

@@ -17,7 +17,7 @@ struct record_packet {
     struct record_packet *next;
 };
 
-struct recorder_queue QUEUE(struct record_packet);
+struct recorder_queue SC_QUEUE(struct record_packet);
 
 struct recorder {
     struct sc_packet_sink packet_sink; // packet sink trait

app/src/scrcpy.c

@@ -18,6 +18,11 @@
 #include "events.h"
 #include "file_handler.h"
 #include "input_manager.h"
+#ifdef HAVE_AOA_HID
+# include "hid_keyboard.h"
+#endif
+#include "keyboard_inject.h"
+#include "mouse_inject.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
@@ -40,6 +45,16 @@ 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;
 };
 
@@ -240,7 +255,7 @@ stream_on_eos(struct stream *stream, void *userdata) {
 }
 
 bool
-scrcpy(const struct scrcpy_options *options) {
+scrcpy(struct scrcpy_options *options) {
     static struct scrcpy scrcpy;
     struct scrcpy *s = &scrcpy;
 
@@ -257,6 +272,9 @@ scrcpy(const struct scrcpy_options *options) {
     bool v4l2_sink_initialized = false;
 #endif
     bool stream_started = false;
+#ifdef HAVE_AOA_HID
+    bool aoa_hid_initialized = false;
+#endif
     bool controller_initialized = false;
     bool controller_started = false;
     bool screen_initialized = false;
@@ -330,7 +348,7 @@ scrcpy(const struct scrcpy_options *options) {
 
     av_log_set_callback(av_log_callback);
 
-    const struct stream_callbacks stream_cbs = {
+    static const struct stream_callbacks stream_cbs = {
         .on_eos = stream_on_eos,
     };
     stream_init(&s->stream, s->server.video_socket, &stream_cbs, NULL);
@@ -381,6 +399,7 @@ scrcpy(const struct scrcpy_options *options) {
             .rotation = options->rotation,
             .mipmaps = options->mipmaps,
             .fullscreen = options->fullscreen,
+            .buffering_time = options->display_buffer,
         };
 
         if (!screen_init(&s->screen, &screen_params)) {
@@ -393,7 +412,8 @@ scrcpy(const struct scrcpy_options *options) {
 
 #ifdef HAVE_V4L2
     if (options->v4l2_device) {
-        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device, frame_size)) {
+        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device, frame_size,
+                               options->v4l2_buffer)) {
             goto end;
         }
 
@@ -410,7 +430,79 @@ scrcpy(const struct scrcpy_options *options) {
     }
     stream_started = true;
 
-    input_manager_init(&s->input_manager, &s->controller, &s->screen, options);
+    struct sc_key_processor *kp = NULL;
+    struct sc_mouse_processor *mp = NULL;
+
+    if (options->control) {
+        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID) {
+#ifdef HAVE_AOA_HID
+            bool aoa_hid_ok = false;
+
+            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;
+            }
+
+            unsigned mod = SC_MOD_CAPS_LOCK;
+            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...");
@@ -422,6 +514,12 @@ scrcpy(const struct scrcpy_options *options) {
 end:
     // The stream is not stopped explicitly, because it will stop by itself on
     // end-of-stream
+#ifdef HAVE_AOA_HID
+    if (aoa_hid_initialized) {
+        hid_keyboard_destroy(&s->keyboard_hid);
+        aoa_stop(&s->aoa);
+    }
+#endif
     if (controller_started) {
         controller_stop(&s->controller);
     }
@@ -449,6 +547,13 @@ 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) {

app/src/scrcpy.h

@@ -7,6 +7,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "util/tick.h"
+
 enum sc_log_level {
     SC_LOG_LEVEL_VERBOSE,
     SC_LOG_LEVEL_DEBUG,
@@ -31,6 +33,11 @@ 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 {
@@ -66,6 +73,7 @@ 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;
@@ -78,6 +86,8 @@ struct scrcpy_options {
     uint16_t window_width;
     uint16_t window_height;
     uint32_t display_id;
+    sc_tick display_buffer;
+    sc_tick v4l2_buffer;
     bool show_touches;
     bool fullscreen;
     bool always_on_top;
@@ -108,6 +118,7 @@ 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, \
@@ -126,6 +137,8 @@ struct scrcpy_options {
     .window_width = 0, \
     .window_height = 0, \
     .display_id = 0, \
+    .display_buffer = 0, \
+    .v4l2_buffer = 0, \
     .show_touches = false, \
     .fullscreen = false, \
     .always_on_top = false, \
@@ -145,6 +158,6 @@ struct scrcpy_options {
 }
 
 bool
-scrcpy(const struct scrcpy_options *options);
+scrcpy(struct scrcpy_options *options);
 
 #endif

app/src/screen.c

@@ -274,14 +274,16 @@ screen_frame_sink_close(struct sc_frame_sink *sink) {
 static bool
 screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
     struct screen *screen = DOWNCAST(sink);
+    return sc_video_buffer_push(&screen->vb, frame);
+}
 
-    bool previous_frame_skipped;
-    bool ok = video_buffer_push(&screen->vb, frame, &previous_frame_skipped);
-    if (!ok) {
-        return false;
-    }
+static void
+sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
+                             void *userdata) {
+    (void) vb;
+    struct screen *screen = userdata;
 
-    if (previous_frame_skipped) {
+    if (previous_skipped) {
         fps_counter_add_skipped_frame(&screen->fps_counter);
         // The EVENT_NEW_FRAME triggered for the previous frame will consume
         // this new frame instead
@@ -293,8 +295,6 @@ screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
         // Post the event on the UI thread
         SDL_PushEvent(&new_frame_event);
     }
-
-    return true;
 }
 
 bool
@@ -304,15 +304,26 @@ screen_init(struct screen *screen, const struct screen_params *params) {
     screen->fullscreen = false;
     screen->maximized = false;
 
-    bool ok = video_buffer_init(&screen->vb);
+    static const struct sc_video_buffer_callbacks cbs = {
+        .on_new_frame = sc_video_buffer_on_new_frame,
+    };
+
+    bool ok = sc_video_buffer_init(&screen->vb, params->buffering_time, &cbs,
+                                   screen);
     if (!ok) {
         LOGE("Could not initialize video buffer");
         return false;
     }
 
+    ok = sc_video_buffer_start(&screen->vb);
+    if (!ok) {
+        LOGE("Could not start video_buffer");
+        goto error_destroy_video_buffer;
+    }
+
     if (!fps_counter_init(&screen->fps_counter)) {
         LOGE("Could not initialize FPS counter");
-        goto error_destroy_video_buffer;
+        goto error_stop_and_join_video_buffer;
     }
 
     screen->frame_size = params->frame_size;
@@ -453,8 +464,11 @@ error_destroy_window:
     SDL_DestroyWindow(screen->window);
 error_destroy_fps_counter:
     fps_counter_destroy(&screen->fps_counter);
+error_stop_and_join_video_buffer:
+    sc_video_buffer_stop(&screen->vb);
+    sc_video_buffer_join(&screen->vb);
 error_destroy_video_buffer:
-    video_buffer_destroy(&screen->vb);
+    sc_video_buffer_destroy(&screen->vb);
 
     return false;
 }
@@ -471,11 +485,13 @@ screen_hide_window(struct screen *screen) {
 
 void
 screen_interrupt(struct screen *screen) {
+    sc_video_buffer_stop(&screen->vb);
     fps_counter_interrupt(&screen->fps_counter);
 }
 
 void
 screen_join(struct screen *screen) {
+    sc_video_buffer_join(&screen->vb);
     fps_counter_join(&screen->fps_counter);
 }
 
@@ -489,7 +505,7 @@ screen_destroy(struct screen *screen) {
     SDL_DestroyRenderer(screen->renderer);
     SDL_DestroyWindow(screen->window);
     fps_counter_destroy(&screen->fps_counter);
-    video_buffer_destroy(&screen->vb);
+    sc_video_buffer_destroy(&screen->vb);
 }
 
 static void
@@ -595,7 +611,7 @@ update_texture(struct screen *screen, const AVFrame *frame) {
 static bool
 screen_update_frame(struct screen *screen) {
     av_frame_unref(screen->frame);
-    video_buffer_consume(&screen->vb, screen->frame);
+    sc_video_buffer_consume(&screen->vb, screen->frame);
     AVFrame *frame = screen->frame;
 
     fps_counter_add_rendered_frame(&screen->fps_counter);

app/src/screen.h

@@ -8,6 +8,7 @@
 #include <libavformat/avformat.h>
 
 #include "coords.h"
+#include "fps_counter.h"
 #include "opengl.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
@@ -19,7 +20,7 @@ struct screen {
     bool open; // track the open/close state to assert correct behavior
 #endif
 
-    struct video_buffer vb;
+    struct sc_video_buffer vb;
     struct fps_counter fps_counter;
 
     SDL_Window *window;
@@ -62,6 +63,8 @@ struct screen_params {
     bool mipmaps;
 
     bool fullscreen;
+
+    sc_tick buffering_time;
 };
 
 // initialize screen, create window, renderer and texture (window is hidden)

app/src/server.c

@@ -60,7 +60,20 @@ 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
@@ -261,7 +274,8 @@ execute_server(struct server *server, const struct server_params *params) {
     sprintf(max_size_string, "%"PRIu16, params->max_size);
     sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
     sprintf(max_fps_string, "%"PRIu16, params->max_fps);
-    sprintf(lock_video_orientation_string, "%"PRIi8, params->lock_video_orientation);
+    sprintf(lock_video_orientation_string, "%"PRIi8,
+            params->lock_video_orientation);
     sprintf(display_id_string, "%"PRIu32, params->display_id);
     const char *const cmd[] = {
         "shell",
@@ -271,7 +285,8 @@ 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,server=y,address="
+        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,"
+        "server=y,address="
 # else
         /* Android 8 and below */
         "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
@@ -468,7 +483,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];
-    int r = net_recv_all(device_socket, buf, sizeof(buf));
+    ssize_t r = net_recv_all(device_socket, buf, sizeof(buf));
     if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
         LOGE("Could not retrieve device information");
         return false;
@@ -554,10 +569,10 @@ server_stop(struct server *server) {
     sc_mutex_lock(&server->mutex);
     bool signaled = false;
     if (!server->process_terminated) {
-#define WATCHDOG_DELAY_MS 1000
+#define WATCHDOG_DELAY SC_TICK_FROM_SEC(1)
         signaled = sc_cond_timedwait(&server->process_terminated_cond,
                                      &server->mutex,
-                                     WATCHDOG_DELAY_MS);
+                                     sc_tick_now() + WATCHDOG_DELAY);
     }
     sc_mutex_unlock(&server->mutex);
 

app/src/stream.c

@@ -151,7 +151,6 @@ stream_push_packet(struct stream *stream, AVPacket *packet) {
 
         if (stream->pending) {
             // the pending packet must be discarded (consumed or error)
-            av_packet_unref(stream->pending);
             av_packet_free(&stream->pending);
         }
 
@@ -244,7 +243,6 @@ run_stream(void *data) {
     LOGD("End of frames");
 
     if (stream->pending) {
-        av_packet_unref(stream->pending);
         av_packet_free(&stream->pending);
     }
 

app/src/sys/unix/process.c

@@ -1,5 +1,6 @@
 #include "util/process.h"
 
+#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
@@ -50,65 +51,151 @@ search_executable(const char *file) {
 }
 
 enum process_result
-process_execute(const char *const argv[], pid_t *pid) {
-    int fd[2];
+process_execute_redirect(const char *const argv[], pid_t *pid, int *pipe_stdin,
+                     int *pipe_stdout, int *pipe_stderr) {
+    int in[2];
+    int out[2];
+    int err[2];
+    int internal[2]; // communication between parent and children
 
-    if (pipe(fd) == -1) {
+    if (pipe(internal) == -1) {
         perror("pipe");
         return PROCESS_ERROR_GENERIC;
     }
-
-    enum process_result ret = PROCESS_SUCCESS;
+    if (pipe_stdin) {
+        if (pipe(in) == -1) {
+            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");
-        ret = PROCESS_ERROR_GENERIC;
-        goto end;
+        // clean up
+        if (pipe_stderr) {
+            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) {
-        // parent close write side
-        close(fd[1]);
-        fd[1] = -1;
-        // wait for EOF or receive errno from child
-        if (read(fd[0], &ret, sizeof(ret)) == -1) {
-            perror("read");
-            ret = PROCESS_ERROR_GENERIC;
-            goto end;
-        }
-    } else if (*pid == 0) {
-        // child close read side
-        close(fd[0]);
-        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;
+    if (*pid == 0) {
+        if (pipe_stdin) {
+            if (in[0] != STDIN_FILENO) {
+                dup2(in[0], STDIN_FILENO);
+                close(in[0]);
             }
+            close(in[1]);
+        }
+        if (pipe_stdout) {
+            if (out[1] != STDOUT_FILENO) {
+                dup2(out[1], STDOUT_FILENO);
+                close(out[1]);
+            }
+            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");
-            ret = PROCESS_ERROR_GENERIC;
+            err = PROCESS_ERROR_GENERIC;
         }
-        // send ret to the parent
-        if (write(fd[1], &ret, sizeof(ret)) == -1) {
+        // send err to the parent
+        if (write(internal[1], &err, sizeof(err)) == -1) {
             perror("write");
         }
-        // close write side before exiting
-        close(fd[1]);
+        close(internal[1]);
         _exit(1);
     }
 
-end:
-    if (fd[0] != -1) {
-        close(fd[0]);
+    // parent
+    assert(*pid > 0);
+
+    close(internal[1]);
+
+    enum 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(fd[1]);
+
+    close(internal[0]);
+
+    if (pipe_stdin) {
+        close(in[0]);
+        *pipe_stdin = in[1];
     }
-    return ret;
+    if (pipe_stdout) {
+        *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
@@ -175,3 +262,15 @@ 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");
+    }
+}

app/src/sys/win/process.c

@@ -23,38 +23,129 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
 }
 
 enum process_result
-process_execute(const char *const argv[], HANDLE *handle) {
+process_execute_redirect(const char *const argv[], HANDLE *handle,
+                         HANDLE *pipe_stdin, HANDLE *pipe_stdout,
+                         HANDLE *pipe_stderr) {
+    enum process_result ret = PROCESS_ERROR_GENERIC;
+
+    SECURITY_ATTRIBUTES sa;
+    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+    sa.lpSecurityDescriptor = NULL;
+    sa.bInheritHandle = TRUE;
+
+    HANDLE stdin_read_handle;
+    HANDLE stdout_write_handle;
+    HANDLE stderr_write_handle;
+    if (pipe_stdin) {
+        if (!CreatePipe(&stdin_read_handle, pipe_stdin, &sa, 0)) {
+            perror("pipe");
+            return PROCESS_ERROR_GENERIC;
+        }
+        if (!SetHandleInformation(*pipe_stdin, HANDLE_FLAG_INHERIT, 0)) {
+            LOGE("SetHandleInformation stdin failed");
+            goto error_close_stdin;
+        }
+    }
+    if (pipe_stdout) {
+        if (!CreatePipe(pipe_stdout, &stdout_write_handle, &sa, 0)) {
+            perror("pipe");
+            goto error_close_stdin;
+        }
+        if (!SetHandleInformation(*pipe_stdout, HANDLE_FLAG_INHERIT, 0)) {
+            LOGE("SetHandleInformation stdout failed");
+            goto error_close_stdout;
+        }
+    }
+    if (pipe_stderr) {
+        if (!CreatePipe(pipe_stderr, &stderr_write_handle, &sa, 0)) {
+            perror("pipe");
+            goto error_close_stdout;
+        }
+        if (!SetHandleInformation(*pipe_stderr, HANDLE_FLAG_INHERIT, 0)) {
+            LOGE("SetHandleInformation stderr failed");
+            goto error_close_stderr;
+        }
+    }
+
     STARTUPINFOW si;
     PROCESS_INFORMATION pi;
     memset(&si, 0, sizeof(si));
     si.cb = sizeof(si);
+    if (pipe_stdin || pipe_stdout || pipe_stderr) {
+        si.dwFlags = STARTF_USESTDHANDLES;
+        if (pipe_stdin) {
+            si.hStdInput = stdin_read_handle;
+        }
+        if (pipe_stdout) {
+            si.hStdOutput = stdout_write_handle;
+        }
+        if (pipe_stderr) {
+            si.hStdError = stderr_write_handle;
+        }
+    }
 
     char *cmd = malloc(CMD_MAX_LEN);
     if (!cmd || !build_cmd(cmd, CMD_MAX_LEN, argv)) {
         *handle = NULL;
-        return PROCESS_ERROR_GENERIC;
+        goto error_close_stderr;
     }
 
     wchar_t *wide = utf8_to_wide_char(cmd);
     free(cmd);
     if (!wide) {
         LOGC("Could not allocate wide char string");
-        return PROCESS_ERROR_GENERIC;
+        goto error_close_stderr;
     }
 
-    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, 0, NULL, NULL, &si,
+    if (!CreateProcessW(NULL, wide, NULL, NULL, TRUE, 0, NULL, NULL, &si,
                         &pi)) {
         free(wide);
         *handle = NULL;
+
         if (GetLastError() == ERROR_FILE_NOT_FOUND) {
-            return PROCESS_ERROR_MISSING_BINARY;
+            ret = PROCESS_ERROR_MISSING_BINARY;
         }
-        return PROCESS_ERROR_GENERIC;
+        goto error_close_stderr;
+    }
+
+    // These handles are used by the child process, close them for this process
+    if (pipe_stdin) {
+        CloseHandle(stdin_read_handle);
+    }
+    if (pipe_stdout) {
+        CloseHandle(stdout_write_handle);
+    }
+    if (pipe_stderr) {
+        CloseHandle(stderr_write_handle);
     }
 
     free(wide);
     *handle = pi.hProcess;
+
     return PROCESS_SUCCESS;
+
+error_close_stderr:
+    if (pipe_stderr) {
+        CloseHandle(*pipe_stderr);
+        CloseHandle(stderr_write_handle);
+    }
+error_close_stdout:
+    if (pipe_stdout) {
+        CloseHandle(*pipe_stdout);
+        CloseHandle(stdout_write_handle);
+    }
+error_close_stdin:
+    if (pipe_stdin) {
+        CloseHandle(*pipe_stdin);
+        CloseHandle(stdin_read_handle);
+    }
+
+    return ret;
+}
+
+enum process_result
+process_execute(const char *const argv[], HANDLE *handle) {
+    return process_execute_redirect(argv, handle, NULL, NULL, NULL);
 }
 
 bool
@@ -116,3 +207,19 @@ 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");
+    }
+}

app/src/trait/frame_sink.h

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

app/src/trait/key_processor.h

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

app/src/trait/mouse_processor.h

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

app/src/trait/packet_sink.h

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

app/src/util/net.c

@@ -19,11 +19,27 @@
   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) {
-        perror("socket");
+        net_perror("socket");
         return INVALID_SOCKET;
     }
 
@@ -33,7 +49,7 @@ net_connect(uint32_t addr, uint16_t port) {
     sin.sin_port = htons(port);
 
     if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
-        perror("connect");
+        net_perror("connect");
         net_close(sock);
         return INVALID_SOCKET;
     }
@@ -45,14 +61,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) {
-        perror("socket");
+        net_perror("socket");
         return INVALID_SOCKET;
     }
 
     int reuse = 1;
     if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
                    sizeof(reuse)) == -1) {
-        perror("setsockopt(SO_REUSEADDR)");
+        net_perror("setsockopt(SO_REUSEADDR)");
     }
 
     SOCKADDR_IN sin;
@@ -61,13 +77,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) {
-        perror("bind");
+        net_perror("bind");
         net_close(sock);
         return INVALID_SOCKET;
     }
 
     if (listen(sock, backlog) == SOCKET_ERROR) {
-        perror("listen");
+        net_perror("listen");
         net_close(sock);
         return INVALID_SOCKET;
     }
@@ -99,16 +115,17 @@ 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) {
-    ssize_t w = 0;
+    size_t copied = 0;
     while (len > 0) {
-        w = send(socket, buf, len, 0);
+        ssize_t w = send(socket, buf, len, 0);
         if (w == -1) {
-            return -1;
+            return copied ? (ssize_t) copied : -1;
         }
         len -= w;
         buf = (char *) buf + w;
+        copied += w;
     }
-    return w;
+    return copied;
 }
 
 bool

app/src/util/process.c

@@ -19,3 +19,18 @@ 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;
+}

app/src/util/process.h

@@ -18,6 +18,7 @@
 # define NO_EXIT_CODE -1u // max value as unsigned
   typedef HANDLE process_t;
   typedef DWORD exit_code_t;
+  typedef HANDLE pipe_t;
 
 #else
 
@@ -29,6 +30,7 @@
 # define NO_EXIT_CODE -1
   typedef pid_t process_t;
   typedef int exit_code_t;
+  typedef int pipe_t;
 
 #endif
 
@@ -42,6 +44,14 @@ 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);
@@ -78,4 +88,13 @@ 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

app/src/util/queue.h

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

app/src/util/thread.c

@@ -123,7 +123,13 @@ sc_cond_wait(sc_cond *cond, sc_mutex *mutex) {
 }
 
 bool
-sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms) {
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline) {
+    sc_tick now = sc_tick_now();
+    if (deadline <= now) {
+        return false; // timeout
+    }
+
+    uint32_t ms = SC_TICK_TO_MS(deadline - now);
     int r = SDL_CondWaitTimeout(cond->cond, mutex->mutex, ms);
 #ifndef NDEBUG
     if (r < 0) {

app/src/util/thread.h

@@ -5,7 +5,8 @@
 
 #include <stdatomic.h>
 #include <stdbool.h>
-#include <stdint.h>
+
+#include "tick.h"
 
 /* Forward declarations */
 typedef struct SDL_Thread SDL_Thread;
@@ -72,7 +73,7 @@ sc_cond_wait(sc_cond *cond, sc_mutex *mutex);
 
 // return true on signaled, false on timeout
 bool
-sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms);
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline);
 
 void
 sc_cond_signal(sc_cond *cond);

app/src/util/tick.c

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

app/src/util/tick.h

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

app/src/v4l2_sink.c

@@ -121,11 +121,11 @@ run_v4l2_sink(void *data) {
             break;
         }
 
-        video_buffer_consume(&vs->vb, vs->frame);
         vs->has_frame = false;
-
         sc_mutex_unlock(&vs->mutex);
 
+        sc_video_buffer_consume(&vs->vb, vs->frame);
+
         bool ok = encode_and_write_frame(vs, vs->frame);
         av_frame_unref(vs->frame);
         if (!ok) {
@@ -139,17 +139,42 @@ run_v4l2_sink(void *data) {
     return 0;
 }
 
+static void
+sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
+                             void *userdata) {
+    (void) vb;
+    struct sc_v4l2_sink *vs = userdata;
+
+    if (!previous_skipped) {
+        sc_mutex_lock(&vs->mutex);
+        vs->has_frame = true;
+        sc_cond_signal(&vs->cond);
+        sc_mutex_unlock(&vs->mutex);
+    }
+}
+
 static bool
 sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
-    bool ok = video_buffer_init(&vs->vb);
+    static const struct sc_video_buffer_callbacks cbs = {
+        .on_new_frame = sc_video_buffer_on_new_frame,
+    };
+
+    bool ok = sc_video_buffer_init(&vs->vb, vs->buffering_time, &cbs, vs);
     if (!ok) {
+        LOGE("Could not initialize video buffer");
         return false;
     }
 
+    ok = sc_video_buffer_start(&vs->vb);
+    if (!ok) {
+        LOGE("Could not start video buffer");
+        goto error_video_buffer_destroy;
+    }
+
     ok = sc_mutex_init(&vs->mutex);
     if (!ok) {
         LOGC("Could not create mutex");
-        goto error_video_buffer_destroy;
+        goto error_video_buffer_stop_and_join;
     }
 
     ok = sc_cond_init(&vs->cond);
@@ -274,8 +299,11 @@ error_cond_destroy:
     sc_cond_destroy(&vs->cond);
 error_mutex_destroy:
     sc_mutex_destroy(&vs->mutex);
+error_video_buffer_stop_and_join:
+    sc_video_buffer_stop(&vs->vb);
+    sc_video_buffer_join(&vs->vb);
 error_video_buffer_destroy:
-    video_buffer_destroy(&vs->vb);
+    sc_video_buffer_destroy(&vs->vb);
 
     return false;
 }
@@ -287,7 +315,10 @@ sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
     sc_cond_signal(&vs->cond);
     sc_mutex_unlock(&vs->mutex);
 
+    sc_video_buffer_stop(&vs->vb);
+
     sc_thread_join(&vs->thread, NULL);
+    sc_video_buffer_join(&vs->vb);
 
     av_packet_free(&vs->packet);
     av_frame_free(&vs->frame);
@@ -297,24 +328,12 @@ sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
     avformat_free_context(vs->format_ctx);
     sc_cond_destroy(&vs->cond);
     sc_mutex_destroy(&vs->mutex);
-    video_buffer_destroy(&vs->vb);
+    sc_video_buffer_destroy(&vs->vb);
 }
 
 static bool
 sc_v4l2_sink_push(struct sc_v4l2_sink *vs, const AVFrame *frame) {
-    sc_mutex_lock(&vs->mutex);
-
-    bool ok = video_buffer_push(&vs->vb, frame, NULL);
-    if (!ok) {
-        return false;
-    }
-
-    vs->has_frame = true;
-    sc_cond_signal(&vs->cond);
-
-    sc_mutex_unlock(&vs->mutex);
-
-    return true;
+    return sc_video_buffer_push(&vs->vb, frame);
 }
 
 static bool
@@ -337,7 +356,7 @@ sc_v4l2_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
 
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct size frame_size) {
+                  struct size frame_size, sc_tick buffering_time) {
     vs->device_name = strdup(device_name);
     if (!vs->device_name) {
         LOGE("Could not strdup v4l2 device name");
@@ -345,6 +364,7 @@ sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
     }
 
     vs->frame_size = frame_size;
+    vs->buffering_time = buffering_time;
 
     static const struct sc_frame_sink_ops ops = {
         .open = sc_v4l2_frame_sink_open,

app/src/v4l2_sink.h

@@ -6,18 +6,20 @@
 #include "coords.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
+#include "util/tick.h"
 
 #include <libavformat/avformat.h>
 
 struct sc_v4l2_sink {
     struct sc_frame_sink frame_sink; // frame sink trait
 
-    struct video_buffer vb;
+    struct sc_video_buffer vb;
     AVFormatContext *format_ctx;
     AVCodecContext *encoder_ctx;
 
     char *device_name;
     struct size frame_size;
+    sc_tick buffering_time;
 
     sc_thread thread;
     sc_mutex mutex;
@@ -32,7 +34,7 @@ struct sc_v4l2_sink {
 
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct size frame_size);
+                  struct size frame_size, sc_tick buffering_time);
 
 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);

app/src/video_buffer.c

@@ -1,88 +1,255 @@
 #include "video_buffer.h"
 
 #include <assert.h>
+#include <stdlib.h>
+
 #include <libavutil/avutil.h>
 #include <libavformat/avformat.h>
 
 #include "util/log.h"
 
-bool
-video_buffer_init(struct video_buffer *vb) {
-    vb->pending_frame = av_frame_alloc();
-    if (!vb->pending_frame) {
-        return false;
+#define SC_BUFFERING_NDEBUG // comment to debug
+
+static struct sc_video_buffer_frame *
+sc_video_buffer_frame_new(const AVFrame *frame) {
+    struct sc_video_buffer_frame *vb_frame = malloc(sizeof(*vb_frame));
+    if (!vb_frame) {
+        return NULL;
     }
 
-    vb->tmp_frame = av_frame_alloc();
-    if (!vb->tmp_frame) {
-        av_frame_free(&vb->pending_frame);
-        return false;
+    vb_frame->frame = av_frame_alloc();
+    if (!vb_frame->frame) {
+        free(vb_frame);
+        return NULL;
     }
 
-    bool ok = sc_mutex_init(&vb->mutex);
+    if (av_frame_ref(vb_frame->frame, frame)) {
+        av_frame_free(&vb_frame->frame);
+        free(vb_frame);
+        return NULL;
+    }
+
+    return vb_frame;
+}
+
+static void
+sc_video_buffer_frame_delete(struct sc_video_buffer_frame *vb_frame) {
+    av_frame_unref(vb_frame->frame);
+    av_frame_free(&vb_frame->frame);
+    free(vb_frame);
+}
+
+static bool
+sc_video_buffer_offer(struct sc_video_buffer *vb, const AVFrame *frame) {
+    bool previous_skipped;
+    bool ok = sc_frame_buffer_push(&vb->fb, frame, &previous_skipped);
     if (!ok) {
-        av_frame_free(&vb->pending_frame);
-        av_frame_free(&vb->tmp_frame);
         return false;
     }
 
-    // there is initially no frame, so consider it has already been consumed
-    vb->pending_frame_consumed = true;
-
+    vb->cbs->on_new_frame(vb, previous_skipped, vb->cbs_userdata);
     return true;
 }
 
-void
-video_buffer_destroy(struct video_buffer *vb) {
-    sc_mutex_destroy(&vb->mutex);
-    av_frame_free(&vb->pending_frame);
-    av_frame_free(&vb->tmp_frame);
-}
+static int
+run_buffering(void *data) {
+    struct sc_video_buffer *vb = data;
 
-static inline void
-swap_frames(AVFrame **lhs, AVFrame **rhs) {
-    AVFrame *tmp = *lhs;
-    *lhs = *rhs;
-    *rhs = tmp;
+    assert(vb->buffering_time > 0);
+
+    for (;;) {
+        sc_mutex_lock(&vb->b.mutex);
+
+        while (!vb->b.stopped && sc_queue_is_empty(&vb->b.queue)) {
+            sc_cond_wait(&vb->b.queue_cond, &vb->b.mutex);
+        }
+
+        if (vb->b.stopped) {
+            sc_mutex_unlock(&vb->b.mutex);
+            goto stopped;
+        }
+
+        struct sc_video_buffer_frame *vb_frame;
+        sc_queue_take(&vb->b.queue, next, &vb_frame);
+
+        sc_tick max_deadline = sc_tick_now() + vb->buffering_time;
+        // PTS (written by the server) are expressed in microseconds
+        sc_tick pts = SC_TICK_TO_US(vb_frame->frame->pts);
+
+        bool timed_out = false;
+        while (!vb->b.stopped && !timed_out) {
+            sc_tick deadline = sc_clock_to_system_time(&vb->b.clock, pts)
+                             + vb->buffering_time;
+            if (deadline > max_deadline) {
+                deadline = max_deadline;
+            }
+
+            timed_out =
+                !sc_cond_timedwait(&vb->b.wait_cond, &vb->b.mutex, deadline);
+        }
+
+        if (vb->b.stopped) {
+            sc_video_buffer_frame_delete(vb_frame);
+            sc_mutex_unlock(&vb->b.mutex);
+            goto stopped;
+        }
+
+        sc_mutex_unlock(&vb->b.mutex);
+
+#ifndef SC_BUFFERING_NDEBUG
+        LOGD("Buffering: %" PRItick ";%" PRItick ";%" PRItick,
+             pts, vb_frame->push_date, sc_tick_now());
+#endif
+
+        sc_video_buffer_offer(vb, vb_frame->frame);
+
+        sc_video_buffer_frame_delete(vb_frame);
+    }
+
+stopped:
+    // Flush queue
+    while (!sc_queue_is_empty(&vb->b.queue)) {
+        struct sc_video_buffer_frame *vb_frame;
+        sc_queue_take(&vb->b.queue, next, &vb_frame);
+        sc_video_buffer_frame_delete(vb_frame);
+    }
+
+    LOGD("Buffering thread ended");
+
+    return 0;
 }
 
 bool
-video_buffer_push(struct video_buffer *vb, const AVFrame *frame,
-                  bool *previous_frame_skipped) {
-    sc_mutex_lock(&vb->mutex);
-
-    // Use a temporary frame to preserve pending_frame in case of error.
-    // tmp_frame is an empty frame, no need to call av_frame_unref() beforehand.
-    int r = av_frame_ref(vb->tmp_frame, frame);
-    if (r) {
-        LOGE("Could not ref frame: %d", r);
+sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
+                     const struct sc_video_buffer_callbacks *cbs,
+                     void *cbs_userdata) {
+    bool ok = sc_frame_buffer_init(&vb->fb);
+    if (!ok) {
         return false;
     }
 
-    // Now that av_frame_ref() succeeded, we can replace the previous
-    // pending_frame
-    swap_frames(&vb->pending_frame, &vb->tmp_frame);
-    av_frame_unref(vb->tmp_frame);
+    assert(buffering_time >= 0);
+    if (buffering_time) {
+        ok = sc_mutex_init(&vb->b.mutex);
+        if (!ok) {
+            LOGC("Could not create mutex");
+            sc_frame_buffer_destroy(&vb->fb);
+            return false;
+        }
 
-    if (previous_frame_skipped) {
-        *previous_frame_skipped = !vb->pending_frame_consumed;
+        ok = sc_cond_init(&vb->b.queue_cond);
+        if (!ok) {
+            LOGC("Could not create cond");
+            sc_mutex_destroy(&vb->b.mutex);
+            sc_frame_buffer_destroy(&vb->fb);
+            return false;
+        }
+
+        ok = sc_cond_init(&vb->b.wait_cond);
+        if (!ok) {
+            LOGC("Could not create wait cond");
+            sc_cond_destroy(&vb->b.queue_cond);
+            sc_mutex_destroy(&vb->b.mutex);
+            sc_frame_buffer_destroy(&vb->fb);
+            return false;
+        }
+
+        sc_clock_init(&vb->b.clock);
+        sc_queue_init(&vb->b.queue);
     }
-    vb->pending_frame_consumed = false;
 
-    sc_mutex_unlock(&vb->mutex);
+    assert(cbs);
+    assert(cbs->on_new_frame);
+
+    vb->buffering_time = buffering_time;
+    vb->cbs = cbs;
+    vb->cbs_userdata = cbs_userdata;
+    return true;
+}
+
+bool
+sc_video_buffer_start(struct sc_video_buffer *vb) {
+    if (vb->buffering_time) {
+        bool ok =
+            sc_thread_create(&vb->b.thread, run_buffering, "buffering", vb);
+        if (!ok) {
+            LOGE("Could not start buffering thread");
+            return false;
+        }
+    }
 
     return true;
 }
 
 void
-video_buffer_consume(struct video_buffer *vb, AVFrame *dst) {
-    sc_mutex_lock(&vb->mutex);
-    assert(!vb->pending_frame_consumed);
-    vb->pending_frame_consumed = true;
-
-    av_frame_move_ref(dst, vb->pending_frame);
-    // av_frame_move_ref() resets its source frame, so no need to call
-    // av_frame_unref()
-
-    sc_mutex_unlock(&vb->mutex);
+sc_video_buffer_stop(struct sc_video_buffer *vb) {
+    if (vb->buffering_time) {
+        sc_mutex_lock(&vb->b.mutex);
+        vb->b.stopped = true;
+        sc_cond_signal(&vb->b.queue_cond);
+        sc_cond_signal(&vb->b.wait_cond);
+        sc_mutex_unlock(&vb->b.mutex);
+    }
+}
+
+void
+sc_video_buffer_join(struct sc_video_buffer *vb) {
+    if (vb->buffering_time) {
+        sc_thread_join(&vb->b.thread, NULL);
+    }
+}
+
+void
+sc_video_buffer_destroy(struct sc_video_buffer *vb) {
+    sc_frame_buffer_destroy(&vb->fb);
+    if (vb->buffering_time) {
+        sc_cond_destroy(&vb->b.wait_cond);
+        sc_cond_destroy(&vb->b.queue_cond);
+        sc_mutex_destroy(&vb->b.mutex);
+    }
+}
+
+bool
+sc_video_buffer_push(struct sc_video_buffer *vb, const AVFrame *frame) {
+    if (!vb->buffering_time) {
+        // No buffering
+        return sc_video_buffer_offer(vb, frame);
+    }
+
+    sc_mutex_lock(&vb->b.mutex);
+
+    sc_tick pts = SC_TICK_FROM_US(frame->pts);
+    sc_clock_update(&vb->b.clock, sc_tick_now(), pts);
+    sc_cond_signal(&vb->b.wait_cond);
+
+    if (vb->b.clock.count == 1) {
+        sc_mutex_unlock(&vb->b.mutex);
+        // First frame, offer it immediately, for two reasons:
+        //  - not to delay the opening of the scrcpy window
+        //  - the buffering estimation needs at least two clock points, so it
+        //  could not handle the first frame
+        return sc_video_buffer_offer(vb, frame);
+    }
+
+    struct sc_video_buffer_frame *vb_frame = sc_video_buffer_frame_new(frame);
+    if (!vb_frame) {
+        sc_mutex_unlock(&vb->b.mutex);
+        LOGE("Could not allocate frame");
+        return false;
+    }
+
+#ifndef SC_BUFFERING_NDEBUG
+    vb_frame->push_date = sc_tick_now();
+#endif
+    sc_queue_push(&vb->b.queue, next, vb_frame);
+    sc_cond_signal(&vb->b.queue_cond);
+
+    sc_mutex_unlock(&vb->b.mutex);
+
+    return true;
+}
+
+void
+sc_video_buffer_consume(struct sc_video_buffer *vb, AVFrame *dst) {
+    sc_frame_buffer_consume(&vb->fb, dst);
 }

app/src/video_buffer.h

@@ -1,50 +1,76 @@
-#ifndef VIDEO_BUFFER_H
-#define VIDEO_BUFFER_H
+#ifndef SC_VIDEO_BUFFER_H
+#define SC_VIDEO_BUFFER_H
 
 #include "common.h"
 
 #include <stdbool.h>
 
-#include "fps_counter.h"
+#include "clock.h"
+#include "frame_buffer.h"
+#include "util/queue.h"
 #include "util/thread.h"
+#include "util/tick.h"
 
 // forward declarations
 typedef struct AVFrame AVFrame;
 
-/**
- * A video buffer holds 1 pending frame, which is the last frame received from
- * the producer (typically, the decoder).
- *
- * If a pending frame has not been consumed when the producer pushes a new
- * frame, then it is lost. The intent is to always provide access to the very
- * last frame to minimize latency.
- *
- * The producer and the consumer typically do not live in the same thread.
- * That's the reason why the callback on_frame_available() does not provide the
- * frame as parameter: the consumer might post an event to its own thread to
- * retrieve the pending frame from there, and that frame may have changed since
- * the callback if producer pushed a new one in between.
- */
+struct sc_video_buffer_frame {
+    AVFrame *frame;
+    struct sc_video_buffer_frame *next;
+#ifndef NDEBUG
+    sc_tick push_date;
+#endif
+};
 
-struct video_buffer {
-    AVFrame *pending_frame;
-    AVFrame *tmp_frame; // To preserve the pending frame on error
+struct sc_video_buffer_frame_queue SC_QUEUE(struct sc_video_buffer_frame);
 
-    sc_mutex mutex;
+struct sc_video_buffer {
+    struct sc_frame_buffer fb;
 
-    bool pending_frame_consumed;
+    sc_tick buffering_time;
+
+    // only if buffering_time > 0
+    struct {
+        sc_thread thread;
+        sc_mutex mutex;
+        sc_cond queue_cond;
+        sc_cond wait_cond;
+
+        struct sc_clock clock;
+        struct sc_video_buffer_frame_queue queue;
+        bool stopped;
+    } b; // buffering
+
+    const struct sc_video_buffer_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+struct sc_video_buffer_callbacks {
+    void (*on_new_frame)(struct sc_video_buffer *vb, bool previous_skipped,
+                         void *userdata);
 };
 
 bool
-video_buffer_init(struct video_buffer *vb);
-
-void
-video_buffer_destroy(struct video_buffer *vb);
+sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
+                     const struct sc_video_buffer_callbacks *cbs,
+                     void *cbs_userdata);
 
 bool
-video_buffer_push(struct video_buffer *vb, const AVFrame *frame, bool *skipped);
+sc_video_buffer_start(struct sc_video_buffer *vb);
 
 void
-video_buffer_consume(struct video_buffer *vb, AVFrame *dst);
+sc_video_buffer_stop(struct sc_video_buffer *vb);
+
+void
+sc_video_buffer_join(struct sc_video_buffer *vb);
+
+void
+sc_video_buffer_destroy(struct sc_video_buffer *vb);
+
+bool
+sc_video_buffer_push(struct sc_video_buffer *vb, const AVFrame *frame);
+
+void
+sc_video_buffer_consume(struct sc_video_buffer *vb, AVFrame *dst);
 
 #endif

app/tests/test_clock.c

@@ -0,0 +1,79 @@
+#include "common.h"
+
+#include <assert.h>
+
+#include "clock.h"
+
+void test_small_rolling_sum(void) {
+    struct sc_clock clock;
+    sc_clock_init(&clock);
+
+    assert(clock.count == 0);
+    assert(clock.left_sum.system == 0);
+    assert(clock.left_sum.stream == 0);
+    assert(clock.right_sum.system == 0);
+    assert(clock.right_sum.stream == 0);
+
+    sc_clock_update(&clock, 2, 3);
+    assert(clock.count == 1);
+    assert(clock.left_sum.system == 0);
+    assert(clock.left_sum.stream == 0);
+    assert(clock.right_sum.system == 2);
+    assert(clock.right_sum.stream == 3);
+
+    sc_clock_update(&clock, 10, 20);
+    assert(clock.count == 2);
+    assert(clock.left_sum.system == 2);
+    assert(clock.left_sum.stream == 3);
+    assert(clock.right_sum.system == 10);
+    assert(clock.right_sum.stream == 20);
+
+    sc_clock_update(&clock, 40, 80);
+    assert(clock.count == 3);
+    assert(clock.left_sum.system == 2);
+    assert(clock.left_sum.stream == 3);
+    assert(clock.right_sum.system == 50);
+    assert(clock.right_sum.stream == 100);
+
+    sc_clock_update(&clock, 400, 800);
+    assert(clock.count == 4);
+    assert(clock.left_sum.system == 12);
+    assert(clock.left_sum.stream == 23);
+    assert(clock.right_sum.system == 440);
+    assert(clock.right_sum.stream == 880);
+}
+
+void test_large_rolling_sum(void) {
+    const unsigned half_range = SC_CLOCK_RANGE / 2;
+
+    struct sc_clock clock1;
+    sc_clock_init(&clock1);
+    for (unsigned i = 0; i < 5 * half_range; ++i) {
+        sc_clock_update(&clock1, i, 2 * i + 1);
+    }
+
+    struct sc_clock clock2;
+    sc_clock_init(&clock2);
+    for (unsigned i = 3 * half_range; i < 5 * half_range; ++i) {
+        sc_clock_update(&clock2, i, 2 * i + 1);
+    }
+
+    assert(clock1.count == SC_CLOCK_RANGE);
+    assert(clock2.count == SC_CLOCK_RANGE);
+
+    // The values before the last SC_CLOCK_RANGE points in clock1 should have
+    // no impact
+    assert(clock1.left_sum.system == clock2.left_sum.system);
+    assert(clock1.left_sum.stream == clock2.left_sum.stream);
+    assert(clock1.right_sum.system == clock2.right_sum.system);
+    assert(clock1.right_sum.stream == clock2.right_sum.stream);
+}
+
+int main(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_small_rolling_sum();
+    test_large_rolling_sum();
+    return 0;
+};

app/tests/test_queue.c

@@ -10,28 +10,28 @@ struct foo {
 };
 
 static void test_queue(void) {
-    struct my_queue QUEUE(struct foo) queue;
-    queue_init(&queue);
+    struct my_queue SC_QUEUE(struct foo) queue;
+    sc_queue_init(&queue);
 
-    assert(queue_is_empty(&queue));
+    assert(sc_queue_is_empty(&queue));
 
     struct foo v1 = { .value = 42 };
     struct foo v2 = { .value = 27 };
 
-    queue_push(&queue, next, &v1);
-    queue_push(&queue, next, &v2);
+    sc_queue_push(&queue, next, &v1);
+    sc_queue_push(&queue, next, &v2);
 
     struct foo *foo;
 
-    assert(!queue_is_empty(&queue));
-    queue_take(&queue, next, &foo);
+    assert(!sc_queue_is_empty(&queue));
+    sc_queue_take(&queue, next, &foo);
     assert(foo->value == 42);
 
-    assert(!queue_is_empty(&queue));
-    queue_take(&queue, next, &foo);
+    assert(!sc_queue_is_empty(&queue));
+    sc_queue_take(&queue, next, &foo);
     assert(foo->value == 27);
 
-    assert(queue_is_empty(&queue));
+    assert(sc_queue_is_empty(&queue));
 }
 
 int main(int argc, char *argv[]) {

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.14/i686-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.16/i686-w64-mingw32'

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.14/x86_64-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.16/x86_64-w64-mingw32'

install_release.sh

@@ -2,8 +2,8 @@
 set -e
 
 BUILDDIR=build-auto
-PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-server-v1.18
-PREBUILT_SERVER_SHA256=641c5c6beda9399dfae72d116f5ff43b5ed1059d871c9ebc3f47610fd33c51a3
+PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.19/scrcpy-server-v1.19
+PREBUILT_SERVER_SHA256=876f9322182e6aac6a58db1334f4225855ef3a17eaebc80aab6601d9d1ecb867
 
 echo "[scrcpy] Downloading prebuilt server..."
 wget "$PREBUILT_SERVER_URL" -O scrcpy-server

meson.build

@@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '1.18',
+        version: '1.19',
         meson_version: '>= 0.48',
         default_options: [
             'c_std=c11',

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.14-mingw.tar.gz \
-		405eaff3eb18f2e08fe669ef9e63bc9a8710b7d343756f238619761e9b60407d \
-		SDL2-2.0.14
+	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.16-mingw.tar.gz \
+		2bfe48628aa9635c12eac7d421907e291525de1d0b04b3bca4a5bd6e6c881a6f \
+		SDL2-2.0.16
 
 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r31.0.2-windows.zip \
-		d560cb8ded83ae04763b94632673481f14843a5969256569623cfeac82db4ba5 \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r31.0.3-windows.zip \
+		0f4b8fdd26af2c3733539d6eebb3c2ed499ea1d4bb1f4e0ecc2d6016961a6e24 \
 		platform-tools

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.14/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.16/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.14/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.16/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 
 zip-win32: dist-win32
 	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \

server/build.gradle

@@ -6,8 +6,8 @@ android {
         applicationId "com.genymobile.scrcpy"
         minSdkVersion 21
         targetSdkVersion 30
-        versionCode 11800
-        versionName "1.18"
+        versionCode 11900
+        versionName "1.19"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
     }
     buildTypes {

server/build_without_gradle.sh

@@ -12,7 +12,7 @@
 set -e
 
 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.18
+SCRCPY_VERSION_NAME=1.19
 
 PLATFORM=${ANDROID_PLATFORM:-30}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-30.0.0}

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_TOUCHSCREEN, 0);
+                        InputDevice.SOURCE_MOUSE, 0);
         return device.injectEvent(event);
     }
 

server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java

@@ -56,17 +56,13 @@ public class ScreenEncoder implements Device.RotationListener {
 
     public void streamScreen(Device device, FileDescriptor fd) throws IOException {
         Workarounds.prepareMainLooper();
-
-        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");
+        if (Build.BRAND.equalsIgnoreCase("meizu")) {
+            // <https://github.com/Genymobile/scrcpy/issues/240>
+            // <https://github.com/Genymobile/scrcpy/issues/2656>
             Workarounds.fillAppInfo();
-            internalStreamScreen(device, fd);
         }
+
+        internalStreamScreen(device, fd);
     }
 
     private void internalStreamScreen(Device device, FileDescriptor fd) throws IOException {

server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java

@@ -11,6 +11,7 @@ public class StatusBarManager {
 
     private final IInterface manager;
     private Method expandNotificationsPanelMethod;
+    private boolean expandNotificationPanelMethodCustomVersion;
     private Method expandSettingsPanelMethod;
     private boolean expandSettingsPanelMethodNewVersion = true;
     private Method collapsePanelsMethod;
@@ -21,7 +22,13 @@ public class StatusBarManager {
 
     private Method getExpandNotificationsPanelMethod() throws NoSuchMethodException {
         if (expandNotificationsPanelMethod == null) {
-            expandNotificationsPanelMethod = manager.getClass().getMethod("expandNotificationsPanel");
+            try {
+                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;
     }
@@ -50,7 +57,11 @@ public class StatusBarManager {
     public void expandNotificationsPanel() {
         try {
             Method method = getExpandNotificationsPanelMethod();
-            method.invoke(manager);
+            if (expandNotificationPanelMethodCustomVersion) {
+                method.invoke(manager, 0);
+            } else {
+                method.invoke(manager);
+            }
         } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             Ln.e("Could not invoke method", e);
         }