Apply workaround on "honor" devices

This makes audio work on those devices. Fixes #4015 <https://github.com/Genymobile/scrcpy/issues/4015>
Use system context as base context
2023-06-17 00:25:10 +02:00 · 2023-06-17 00:25:10 +02:00 · 2023-06-17 00:25:10 +02:00
164 changed files with 3094 additions and 7205 deletions
--- a/.gitignore
+++ b/.gitignore
@ -7,4 +7,3 @@ build/
 .gradle/
 /x/
 local.properties
-/scrcpy-server
--- a/FAQ.md
+++ b/FAQ.md
@ -133,9 +133,9 @@ Try with another USB cable or plug it into another USB port. See [#281] and
 [#283]: https://github.com/Genymobile/scrcpy/issues/283


-## OTG issues on Windows
+## HID/OTG issues on Windows

-On Windows, if `scrcpy --otg` (or `--keyboard=aoa`/`--mouse=aoa`) results in:
+On Windows, if `scrcpy --otg` (or `--hid-keyboard`/`--hid-mouse`) results in:

 >     ERROR: Could not find any USB device

@ -159,8 +159,6 @@ In developer options, enable:
 > **USB debugging (Security settings)**  
 > _Allow granting permissions and simulating input via USB debugging_

-Rebooting the device is necessary once this option is set.
-
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323


@ -170,13 +168,12 @@ The default text injection method is [limited to ASCII characters][text-input].
 A trick allows to also inject some [accented characters][accented-characters],
 but that's all. See [#37].

-To avoid the problem, [change the keyboard mode to simulate a physical
-keyboard][hid].
+Since scrcpy v1.20, it is possible to simulate a [physical keyboard][hid] (HID).

 [text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
 [accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
 [#37]: https://github.com/Genymobile/scrcpy/issues/37
-[hid]: doc/keyboard.md#physical-keyboard-simulation
+[hid]: README.md#physical-keyboard-simulation-hid


 ## Client issues
@ -223,7 +220,7 @@ java.lang.IllegalStateException
        at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
 ```

-then try with another [encoder](doc/video.md#encoder).
+then try with another [encoder](doc/video.md#codec).


 ## Translations
@ -232,4 +229,4 @@ Translations of this FAQ in other languages are available in the [wiki].

 [wiki]: https://github.com/Genymobile/scrcpy/wiki

-Only this FAQ file is guaranteed to be up-to-date.
+Only this README file is guaranteed to be up-to-date.
--- a/README.md
+++ b/README.md
@ -1,11 +1,11 @@
-# scrcpy (v2.3.1)
+# scrcpy (v2.0)

 <img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />

 _pronounced "**scr**een **c**o**py**"_

 This application mirrors Android devices (video and audio) connected via
-USB or [over TCP/IP](doc/connection.md#tcpip-wireless), and allows to control the
+USB or [over TCP/IP](doc/device.md#tcpip-wireless), and allows to control the
 device with the keyboard and the mouse of the computer. It does not require any
 _root_ access. It works on _Linux_, _Windows_ and _macOS_.

@ -25,25 +25,21 @@ It focuses on:
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646

 Its features include:
- - [audio forwarding](doc/audio.md) (Android 11+)
+ - [audio forwarding](doc/audio.md) (Android >= 11)
 - [recording](doc/recording.md)
 - mirroring with [Android device screen off](doc/device.md#turn-screen-off)
 - [copy-paste](doc/control.md#copy-paste) in both directions
 - [configurable quality](doc/video.md)
- - [camera mirroring](doc/camera.md) (Android 12+)
- - [mirroring as a webcam (V4L2)](doc/v4l2.md) (Linux-only)
- - physical [keyboard][hid-keyboard] and [mouse][hid-mouse] simulation (HID)
- - [OTG mode](doc/otg.md)
+ - Android device [as a webcam (V4L2)](doc/v4l2.md) (Linux-only)
+ - [physical keyboard/mouse simulation (HID)](doc/hid-otg.md)
+ - [OTG mode](doc/hid-otg.md#otg)
 - and more…

-[hid-keyboard]: doc/keyboard.md#physical-keyboard-simulation
-[hid-mouse]: doc/mouse.md#physical-mouse-simulation
-
 ## Prerequisites

 The Android device requires at least API 21 (Android 5.0).

-[Audio forwarding](doc/audio.md) is supported for API >= 30 (Android 11+).
+[Audio forwarding](doc/audio.md) is supported from API 30 (Android 11).

 Make sure you [enabled USB debugging][enable-adb] on your device(s).

@ -51,13 +47,10 @@ Make sure you [enabled USB debugging][enable-adb] on your device(s).

 On some devices, you also need to enable [an additional option][control] `USB
 debugging (Security Settings)` (this is an item different from `USB debugging`)
-to control it using a keyboard and mouse. Rebooting the device is necessary once
-this option is set.
+to control it using a keyboard and mouse.

 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323

-Note that USB debugging is not required to run scrcpy in [OTG mode](doc/otg.md).
-

 ## Get the app

@ -71,18 +64,14 @@ Note that USB debugging is not required to run scrcpy in [OTG mode](doc/otg.md).
 The application provides a lot of features and configuration options. They are
 documented in the following pages:

- - [Connection](doc/connection.md)
+ - [Device](doc/device.md)
 - [Video](doc/video.md)
 - [Audio](doc/audio.md)
 - [Control](doc/control.md)
- - [Keyboard](doc/keyboard.md)
- - [Mouse](doc/mouse.md)
- - [Device](doc/device.md)
 - [Window](doc/window.md)
 - [Recording](doc/recording.md)
 - [Tunnels](doc/tunnels.md)
- - [OTG](doc/otg.md)
- - [Camera](doc/camera.md)
+ - [HID/OTG](doc/hid-otg.md)
 - [Video4Linux](doc/v4l2.md)
 - [Shortcuts](doc/shortcuts.md)

@ -124,10 +113,7 @@ For general questions or discussions, you can also use:
 I'm [@rom1v](https://github.com/rom1v), the author and maintainer of _scrcpy_.

 If you appreciate this application, you can [support my open source
-work][donate]:
- - [GitHub Sponsors](https://github.com/sponsors/rom1v)
- - [Liberapay](https://liberapay.com/rom1v/)
- - [PayPal](https://paypal.me/rom2v)
+work][donate].

 [donate]: https://blog.rom1v.com/about/#support-my-open-source-work

--- a/app/data/bash-completion/scrcpy
+++ b/app/data/bash-completion/scrcpy
@ -10,37 +10,26 @@ _scrcpy() {
        --audio-source=
        --audio-output-buffer=
        -b --video-bit-rate=
-        --camera-ar=
-        --camera-id=
-        --camera-facing=
-        --camera-fps=
-        --camera-high-speed
-        --camera-size=
        --crop=
        -d --select-usb
        --disable-screensaver
+        --display=
        --display-buffer=
-        --display-id=
-        --display-orientation=
        -e --select-tcpip
        -f --fullscreen
        --force-adb-forward
        --forward-all-clicks
        -h --help
-        -K
-        --keyboard=
        --kill-adb-on-close
+        -K --hid-keyboard
        --legacy-paste
-        --list-camera-sizes
-        --list-cameras
        --list-displays
        --list-encoders
        --lock-video-orientation
        --lock-video-orientation=
        -m --max-size=
-        -M
+        -M --hid-mouse
        --max-fps=
-        --mouse=
        -n --no-control
        -N --no-playback
        --no-audio
@ -53,11 +42,8 @@ _scrcpy() {
        --no-power-on
        --no-video
        --no-video-playback
-        --orientation=
        --otg
        -p --port=
-        --pause-on-exit
-        --pause-on-exit=
        --power-off-on-close
        --prefer-text
        --print-fps
@ -65,7 +51,6 @@ _scrcpy() {
        -r --record=
        --raw-key-events
        --record-format=
-        --record-orientation=
        --render-driver=
        --require-audio
        --rotation=
@ -85,7 +70,6 @@ _scrcpy() {
        --video-codec=
        --video-codec-options=
        --video-encoder=
-        --video-source=
        -w --stay-awake
        --window-borderless
        --window-title=
@ -102,43 +86,15 @@ _scrcpy() {
            return
            ;;
        --audio-codec)
-            COMPREPLY=($(compgen -W 'opus aac flac raw' -- "$cur"))
-            return
-            ;;
-        --video-source)
-            COMPREPLY=($(compgen -W 'display camera' -- "$cur"))
+            COMPREPLY=($(compgen -W 'opus aac raw' -- "$cur"))
            return
            ;;
        --audio-source)
            COMPREPLY=($(compgen -W 'output mic' -- "$cur"))
            return
            ;;
-        --camera-facing)
-            COMPREPLY=($(compgen -W 'front back external' -- "$cur"))
-            return
-            ;;
-        --keyboard)
-            COMPREPLY=($(compgen -W 'disabled sdk uhid aoa' -- "$cur"))
-            return
-            ;;
-        --mouse)
-            COMPREPLY=($(compgen -W 'disabled sdk uhid aoa' -- "$cur"))
-            return
-            ;;
-        --orientation|--display-orientation)
-            COMPREPLY=($(compgen -W '0 90 180 270 flip0 flip90 flip180 flip270' -- "$cur"))
-            return
-            ;;
-        --record-orientation)
-            COMPREPLY=($(compgen -W '0 90 180 270' -- "$cur"))
-            return
-            ;;
        --lock-video-orientation)
-            COMPREPLY=($(compgen -W 'unlocked initial 0 90 180 270' -- "$cur"))
-            return
-            ;;
-        --pause-on-exit)
-            COMPREPLY=($(compgen -W 'true false if-error' -- "$cur"))
+            COMPREPLY=($(compgen -W 'unlocked initial 0 1 2 3' -- "$cur"))
            return
            ;;
        -r|--record)
@ -146,13 +102,17 @@ _scrcpy() {
            return
            ;;
        --record-format)
-            COMPREPLY=($(compgen -W 'mp4 mkv m4a mka opus aac flac wav' -- "$cur"))
+            COMPREPLY=($(compgen -W 'mkv mp4' -- "$cur"))
            return
            ;;
        --render-driver)
            COMPREPLY=($(compgen -W 'direct3d opengl opengles2 opengles metal software' -- "$cur"))
            return
            ;;
+        --rotation)
+            COMPREPLY=($(compgen -W '0 1 2 3' -- "$cur"))
+            return
+            ;;
        --shortcut-mod)
            # Only auto-complete a single key
            COMPREPLY=($(compgen -W 'lctrl rctrl lalt ralt lsuper rsuper' -- "$cur"))
@ -173,12 +133,8 @@ _scrcpy() {
        |--audio-codec-options \
        |--audio-encoder \
        |--audio-output-buffer \
-        |--camera-ar \
-        |--camera-id \
-        |--camera-fps \
-        |--camera-size \
        |--crop \
-        |--display-id \
+        |--display \
        |--display-buffer \
        |--max-fps \
        |-m|--max-size \
--- a/app/data/scrcpy-console.bat
+++ b/app/data/scrcpy-console.bat
@ -1,2 +1,4 @@
@echo off
-scrcpy.exe --pause-on-exit=if-error %*
+scrcpy.exe %*
+:: if the exit code is >= 1, then pause
+if errorlevel 1 pause
--- a/app/data/scrcpy-console.desktop
+++ b/app/data/scrcpy-console.desktop
@ -5,7 +5,7 @@ Comment=Display and control your Android device
 # For some users, the PATH or ADB environment variables are set from the shell
 # startup file, like .bashrc or .zshrc… Run an interactive shell to get
 # environment correctly initialized.
-Exec=/bin/sh -c "\\$SHELL -i -c 'scrcpy --pause-on-exit=if-error'"
+Exec=/bin/bash --norc --noprofile -i -c "\"\\$SHELL\" -i -c scrcpy || read -p 'Press Enter to quit...'"
 Icon=scrcpy
 Terminal=true
 Type=Application
--- a/app/data/scrcpy.desktop
+++ b/app/data/scrcpy.desktop
@ -5,7 +5,7 @@ Comment=Display and control your Android device
 # For some users, the PATH or ADB environment variables are set from the shell
 # startup file, like .bashrc or .zshrc… Run an interactive shell to get
 # environment correctly initialized.
-Exec=/bin/sh -c "\\$SHELL -i -c scrcpy"
+Exec=/bin/sh -c "\"\\$SHELL\" -i -c scrcpy"
 Icon=scrcpy
 Terminal=false
 Type=Application
--- a/app/data/zsh-completion/_scrcpy
+++ b/app/data/zsh-completion/_scrcpy
@ -11,42 +11,31 @@ arguments=(
    '--always-on-top[Make scrcpy window always on top \(above other windows\)]'
    '--audio-bit-rate=[Encode the audio at the given bit-rate]'
    '--audio-buffer=[Configure the audio buffering delay (in milliseconds)]'
-    '--audio-codec=[Select the audio codec]:codec:(opus aac flac raw)'
+    '--audio-codec=[Select the audio codec]:codec:(opus aac raw)'
    '--audio-codec-options=[Set a list of comma-separated key\:type=value options for the device audio encoder]'
    '--audio-encoder=[Use a specific MediaCodec audio encoder]'
    '--audio-source=[Select the audio source]:source:(output mic)'
    '--audio-output-buffer=[Configure the size of the SDL audio output buffer (in milliseconds)]'
    {-b,--video-bit-rate=}'[Encode the video at the given bit-rate]'
-    '--camera-ar=[Select the camera size by its aspect ratio]'
-    '--camera-high-speed=[Enable high-speed camera capture mode]'
-    '--camera-id=[Specify the camera id to mirror]'
-    '--camera-facing=[Select the device camera by its facing direction]:facing:(front back external)'
-    '--camera-fps=[Specify the camera capture frame rate]'
-    '--camera-size=[Specify an explicit camera capture size]'
    '--crop=[\[width\:height\:x\:y\] Crop the device screen on the server]'
    {-d,--select-usb}'[Use USB device]'
    '--disable-screensaver[Disable screensaver while scrcpy is running]'
+    '--display=[Specify the display id to mirror]'
    '--display-buffer=[Add a buffering delay \(in milliseconds\) before displaying]'
-    '--display-id=[Specify the display id to mirror]'
-    '--display-orientation=[Set the initial display orientation]:orientation values:(0 90 180 270 flip0 flip90 flip180 flip270)'
    {-e,--select-tcpip}'[Use TCP/IP device]'
    {-f,--fullscreen}'[Start in fullscreen]'
    '--force-adb-forward[Do not attempt to use \"adb reverse\" to connect to the device]'
    '--forward-all-clicks[Forward clicks to device]'
    {-h,--help}'[Print the help]'
-    '-K[Use UHID keyboard (same as --keyboard=uhid)]'
-    '--keyboard[Set the keyboard input mode]:mode:(disabled sdk uhid aoa)'
    '--kill-adb-on-close[Kill adb when scrcpy terminates]'
+    {-K,--hid-keyboard}'[Simulate a physical keyboard by using HID over AOAv2]'
    '--legacy-paste[Inject computer clipboard text as a sequence of key events on Ctrl+v]'
-    '--list-camera-sizes[List the valid camera capture sizes]'
-    '--list-cameras[List cameras available on the device]'
    '--list-displays[List displays available on the device]'
    '--list-encoders[List video and audio encoders available on the device]'
-    '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 90 180 270)'
+    '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 1 2 3)'
    {-m,--max-size=}'[Limit both the width and height of the video to value]'
-    '-M[Use UHID mouse (same as --mouse=uhid)]'
+    {-M,--hid-mouse}'[Simulate a physical mouse by using HID over AOAv2]'
    '--max-fps=[Limit the frame rate of screen capture]'
-    '--mouse[Set the mouse input mode]:mode:(disabled sdk uhid aoa)'
    {-n,--no-control}'[Disable device control \(mirror the device in read only\)]'
    {-N,--no-playback}'[Disable video and audio playback]'
    '--no-audio[Disable audio forwarding]'
@ -59,20 +48,18 @@ arguments=(
    '--no-power-on[Do not power on the device on start]'
    '--no-video[Disable video forwarding]'
    '--no-video-playback[Disable video playback]'
-    '--orientation=[Set the video orientation]:orientation values:(0 90 180 270 flip0 flip90 flip180 flip270)'
    '--otg[Run in OTG mode \(simulating physical keyboard and mouse\)]'
    {-p,--port=}'[\[port\[\:port\]\] Set the TCP port \(range\) used by the client to listen]'
-    '--pause-on-exit=[Make scrcpy pause before exiting]:mode:(true false if-error)'
    '--power-off-on-close[Turn the device screen off when closing scrcpy]'
    '--prefer-text[Inject alpha characters and space as text events instead of key events]'
    '--print-fps[Start FPS counter, to print frame logs to the console]'
    '--push-target=[Set the target directory for pushing files to the device by drag and drop]'
    {-r,--record=}'[Record screen to file]:record file:_files'
    '--raw-key-events[Inject key events for all input keys, and ignore text events]'
-    '--record-format=[Force recording format]:format:(mp4 mkv m4a mka opus aac flac wav)'
-    '--record-orientation=[Set the record orientation]:orientation values:(0 90 180 270)'
+    '--record-format=[Force recording format]:format:(mp4 mkv)'
    '--render-driver=[Request SDL to use the given render driver]:driver name:(direct3d opengl opengles2 opengles metal software)'
    '--require-audio=[Make scrcpy fail if audio is enabled but does not work]'
+    '--rotation=[Set the initial display rotation]:rotation values:(0 1 2 3)'
    {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]:serial:($("${ADB-adb}" devices | awk '\''$2 == "device" {print $1}'\''))'
    {-S,--turn-screen-off}'[Turn the device screen off immediately]'
    '--shortcut-mod=[\[key1,key2+key3,...\] Specify the modifiers to use for scrcpy shortcuts]:shortcut mod:(lctrl rctrl lalt ralt lsuper rsuper)'
@ -88,7 +75,6 @@ arguments=(
    '--video-codec=[Select the video codec]:codec:(h264 h265 av1)'
    '--video-codec-options=[Set a list of comma-separated key\:type=value options for the device video encoder]'
    '--video-encoder=[Use a specific MediaCodec video encoder]'
-    '--video-source=[Select the video source]:source:(display camera)'
    {-w,--stay-awake}'[Keep the device on while scrcpy is running, when the device is plugged in]'
    '--window-borderless[Disable window decorations \(display borderless window\)]'
    '--window-title=[Set a custom window title]'
--- a/app/meson.build
+++ b/app/meson.build
@ -20,8 +20,8 @@ src = [
    'src/fps_counter.c',
    'src/frame_buffer.c',
    'src/input_manager.c',
-    'src/keyboard_sdk.c',
-    'src/mouse_sdk.c',
+    'src/keyboard_inject.c',
+    'src/mouse_inject.c',
    'src/opengl.c',
    'src/options.c',
    'src/packet_merger.c',
@ -31,16 +31,11 @@ src = [
    'src/screen.c',
    'src/server.c',
    'src/version.c',
-    'src/hid/hid_keyboard.c',
-    'src/hid/hid_mouse.c',
    'src/trait/frame_source.c',
    'src/trait/packet_source.c',
-    'src/uhid/keyboard_uhid.c',
-    'src/uhid/mouse_uhid.c',
-    'src/uhid/uhid_output.c',
    'src/util/acksync.c',
-    'src/util/audiobuf.c',
    'src/util/average.c',
+    'src/util/bytebuf.c',
    'src/util/file.c',
    'src/util/intmap.c',
    'src/util/intr.c',
@ -93,8 +88,8 @@ usb_support = get_option('usb')
 if usb_support
    src += [
        'src/usb/aoa_hid.c',
-        'src/usb/keyboard_aoa.c',
-        'src/usb/mouse_aoa.c',
+        'src/usb/hid_keyboard.c',
+        'src/usb/hid_mouse.c',
        'src/usb/scrcpy_otg.c',
        'src/usb/screen_otg.c',
        'src/usb/usb.c',
@ -103,24 +98,77 @@ endif

 cc = meson.get_compiler('c')

-dependencies = [
-    dependency('libavformat', version: '>= 57.33'),
-    dependency('libavcodec', version: '>= 57.37'),
-    dependency('libavutil'),
-    dependency('libswresample'),
-    dependency('sdl2', version: '>= 2.0.5'),
-]
+crossbuild_windows = meson.is_cross_build() and host_machine.system() == 'windows'

-if v4l2_support
-    dependencies += dependency('libavdevice')
-endif
+if not crossbuild_windows
+
+    # native build
+    dependencies = [
+        dependency('libavformat', version: '>= 57.33'),
+        dependency('libavcodec', version: '>= 57.37'),
+        dependency('libavutil'),
+        dependency('libswresample'),
+        dependency('sdl2', version: '>= 2.0.5'),
+    ]
+
+    if v4l2_support
+        dependencies += dependency('libavdevice')
+    endif
+
+    if usb_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/data/' + prebuilt_sdl2 + '/bin'
+    sdl2_lib_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_sdl2 + '/lib'
+    sdl2_include_dir = 'prebuilt-deps/data/' + prebuilt_sdl2 + '/include'
+
+    sdl2 = declare_dependency(
+        dependencies: [
+            cc.find_library('SDL2', dirs: sdl2_bin_dir),
+            cc.find_library('SDL2main', dirs: sdl2_lib_dir),
+        ],
+        include_directories: include_directories(sdl2_include_dir)
+    )
+
+    prebuilt_ffmpeg = meson.get_cross_property('prebuilt_ffmpeg')
+    ffmpeg_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_ffmpeg + '/bin'
+    ffmpeg_include_dir = 'prebuilt-deps/data/' + prebuilt_ffmpeg + '/include'
+
+    ffmpeg = declare_dependency(
+        dependencies: [
+            cc.find_library('avcodec-60', dirs: ffmpeg_bin_dir),
+            cc.find_library('avformat-60', dirs: ffmpeg_bin_dir),
+            cc.find_library('avutil-58', dirs: ffmpeg_bin_dir),
+            cc.find_library('swresample-4', dirs: ffmpeg_bin_dir),
+        ],
+        include_directories: include_directories(ffmpeg_include_dir)
+    )
+
+    prebuilt_libusb = meson.get_cross_property('prebuilt_libusb')
+    libusb_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_libusb + '/bin'
+    libusb_include_dir = 'prebuilt-deps/data/' + prebuilt_libusb + '/include'
+
+    libusb = declare_dependency(
+        dependencies: [
+            cc.find_library('msys-usb-1.0', dirs: libusb_bin_dir),
+        ],
+        include_directories: include_directories(libusb_include_dir)
+    )
+
+    dependencies = [
+        ffmpeg,
+        sdl2,
+        libusb,
+        cc.find_library('mingw32')
+    ]

-if usb_support
-    dependencies += dependency('libusb-1.0')
 endif

 if host_machine.system() == 'windows'
-    dependencies += cc.find_library('mingw32')
    dependencies += cc.find_library('ws2_32')
 endif

@ -217,10 +265,9 @@ if get_option('buildtype') == 'debug'
        ['test_binary', [
            'tests/test_binary.c',
        ]],
-        ['test_audiobuf', [
-            'tests/test_audiobuf.c',
-            'src/util/audiobuf.c',
-            'src/util/memory.c',
+        ['test_bytebuf', [
+            'tests/test_bytebuf.c',
+            'src/util/bytebuf.c',
        ]],
        ['test_cli', [
            'tests/test_cli.c',
@ -242,10 +289,6 @@ if get_option('buildtype') == 'debug'
            'tests/test_device_msg_deserialize.c',
            'src/device_msg.c',
        ]],
-        ['test_orientation', [
-            'tests/test_orientation.c',
-            'src/options.c',
-        ]],
        ['test_strbuf', [
            'tests/test_strbuf.c',
            'src/util/strbuf.c',
--- a/app/prebuilt-deps/prepare-adb.sh
+++ b/app/prebuilt-deps/prepare-adb.sh
@ -6,10 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"

-DEP_DIR=platform-tools-34.0.5
+DEP_DIR=platform-tools-34.0.1

-FILENAME=platform-tools_r34.0.5-windows.zip
-SHA256SUM=3f8320152704377de150418a3c4c9d07d16d80a6c0d0d8f7289c22c499e33571
+FILENAME=platform-tools_r34.0.1-windows.zip
+SHA256SUM=5dd9c2be744c224fa3a7cbe30ba02d2cb378c763bd0f797a7e47e9f3156a5daa

 if [[ -d "$DEP_DIR" ]]
 then
--- a/app/prebuilt-deps/prepare-ffmpeg.sh
+++ b/app/prebuilt-deps/prepare-ffmpeg.sh
@ -6,11 +6,11 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"

-VERSION=6.1-scrcpy-3
+VERSION=6.0-scrcpy-4
 DEP_DIR="ffmpeg-$VERSION"

 FILENAME="$DEP_DIR".7z
-SHA256SUM=b646d18a3d543a4e4c46881568213499f22e4454a464e1552f03f2ac9cc3a05a
+SHA256SUM=39274b321491ce83e76cab5d24e7cbe3f402d3ccf382f739b13be5651c146b60

 if [[ -d "$DEP_DIR" ]]
 then
--- a/app/prebuilt-deps/prepare-libusb.sh
+++ b/app/prebuilt-deps/prepare-libusb.sh
@ -6,10 +6,9 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"

-VERSION=1.0.26
-DEP_DIR="libusb-$VERSION"
+DEP_DIR=libusb-1.0.26

-FILENAME="libusb-$VERSION-binaries.7z"
+FILENAME=libusb-1.0.26-binaries.7z
 SHA256SUM=9c242696342dbde9cdc47239391f71833939bf9f7aa2bbb28cdaabe890465ec5

 if [[ -d "$DEP_DIR" ]]
@ -18,20 +17,17 @@ then
    exit 0
 fi

-get_file "https://github.com/libusb/libusb/releases/download/v$VERSION/$FILENAME" \
-    "$FILENAME" "$SHA256SUM"
+get_file "https://github.com/libusb/libusb/releases/download/v1.0.26/$FILENAME" "$FILENAME" "$SHA256SUM"

 mkdir "$DEP_DIR"
 cd "$DEP_DIR"

 7z x "../$FILENAME" \
-    "libusb-$VERSION-binaries/libusb-MinGW-Win32/" \
-    "libusb-$VERSION-binaries/libusb-MinGW-x64/"
+    libusb-1.0.26-binaries/libusb-MinGW-Win32/bin/msys-usb-1.0.dll \
+    libusb-1.0.26-binaries/libusb-MinGW-Win32/include/ \
+    libusb-1.0.26-binaries/libusb-MinGW-x64/bin/msys-usb-1.0.dll \
+    libusb-1.0.26-binaries/libusb-MinGW-x64/include/

-mv "libusb-$VERSION-binaries/libusb-MinGW-Win32" .
-mv "libusb-$VERSION-binaries/libusb-MinGW-x64" .
-rm -rf "libusb-$VERSION-binaries"
-
-# Rename the dll to get the same library name on all platforms
-mv libusb-MinGW-Win32/bin/msys-usb-1.0.dll libusb-MinGW-Win32/bin/libusb-1.0.dll
-mv libusb-MinGW-x64/bin/msys-usb-1.0.dll libusb-MinGW-x64/bin/libusb-1.0.dll
+mv libusb-1.0.26-binaries/libusb-MinGW-Win32 .
+mv libusb-1.0.26-binaries/libusb-MinGW-x64 .
+rm -rf libusb-1.0.26-binaries
--- a/app/prebuilt-deps/prepare-sdl.sh
+++ b/app/prebuilt-deps/prepare-sdl.sh
@ -6,11 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"

-VERSION=2.28.5
-DEP_DIR="SDL2-$VERSION"
+DEP_DIR=SDL2-2.26.4

-FILENAME="SDL2-devel-$VERSION-mingw.tar.gz"
-SHA256SUM=3c0c655c2ebf67cad48fead72761d1601740ded30808952c3274ba223d226c21
+FILENAME=SDL2-devel-2.26.4-mingw.tar.gz
+SHA256SUM=fe899c8642caac2f180b1ee6f786857ddcaa0adc1fa82474312b09dd47d74712

 if [[ -d "$DEP_DIR" ]]
 then
@ -18,8 +17,7 @@ then
    exit 0
 fi

-get_file "https://github.com/libsdl-org/SDL/releases/download/release-$VERSION/$FILENAME" \
-    "$FILENAME" "$SHA256SUM"
+get_file "https://libsdl.org/release/$FILENAME" "$FILENAME" "$SHA256SUM"

 mkdir "$DEP_DIR"
 cd "$DEP_DIR"
--- a/app/scrcpy-windows.rc
+++ b/app/scrcpy-windows.rc
@ -13,7 +13,7 @@ BEGIN
      VALUE "LegalCopyright", "Romain Vimont, Genymobile"
      VALUE "OriginalFilename", "scrcpy.exe"
      VALUE "ProductName", "scrcpy"
-      VALUE "ProductVersion", "2.3.1"
+      VALUE "ProductVersion", "2.0"
    END
  END
  BLOCK "VarFileInfo"
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -21,12 +21,12 @@ Make scrcpy window always on top (above other windows).

 .TP
 .BI "\-\-audio\-bit\-rate " value
-Encode the audio at the given bit rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
+Encode the audio at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).

 Default is 128K (128000).

 .TP
-.BI "\-\-audio\-buffer " ms
+.BI "\-\-audio\-buffer ms
 Configure the audio buffering delay (in milliseconds).

 Lower values decrease the latency, but increase the likelyhood of buffer underrun (causing audio glitches).
@ -35,7 +35,7 @@ Default is 50.

 .TP
 .BI "\-\-audio\-codec " name
-Select an audio codec (opus, aac, flac or raw).
+Select an audio codec (opus, aac or raw).

 Default is opus.

@ -45,15 +45,15 @@ Set a list of comma-separated key:type=value options for the device audio encode

 The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.

-The list of possible codec options is available in the Android documentation:
-
-<https://d.android.com/reference/android/media/MediaFormat>
+The list of possible codec options is available in the Android documentation
+.UR https://d.android.com/reference/android/media/MediaFormat
+.UE .

 .TP
 .BI "\-\-audio\-encoder " name
 Use a specific MediaCodec audio encoder (depending on the codec provided by \fB\-\-audio\-codec\fR).

-The available encoders can be listed by \fB\-\-list\-encoders\fR.
+The available encoders can be listed by \-\-list\-encoders.

 .TP
 .BI "\-\-audio\-source " source
@ -62,7 +62,7 @@ Select the audio source (output or mic).
 Default is output.

 .TP
-.BI "\-\-audio\-output\-buffer " ms
+.BI "\-\-audio\-output\-buffer ms
 Configure the size of the SDL audio output buffer (in milliseconds).

 If you get "robotic" audio playback, you should test with a higher value (10). Do not change this setting otherwise.
@ -71,44 +71,10 @@ Default is 5.

 .TP
 .BI "\-b, \-\-video\-bit\-rate " value
-Encode the video at the given bit rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
+Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).

 Default is 8M (8000000).

-.TP
-.BI "\-\-camera\-ar " ar
-Select the camera size by its aspect ratio (+/- 10%).
-
-Possible values are "sensor" (use the camera sensor aspect ratio), "\fInum\fR:\fIden\fR" (e.g. "4:3") and "\fIvalue\fR" (e.g. "1.6").
-
-.TP
-.B \-\-camera\-high\-speed
-Enable high-speed camera capture mode.
-
-This mode is restricted to specific resolutions and frame rates, listed by \fB\-\-list\-camera\-sizes\fR.
-
-.TP
-.BI "\-\-camera\-id " id
-Specify the device camera id to mirror.
-
-The available camera ids can be listed by \fB\-\-list\-cameras\fR.
-
-.TP
-.BI "\-\-camera\-facing " facing
-Select the device camera by its facing direction.
-
-Possible values are "front", "back" and "external".
-
-.TP
-.BI "\-\-camera\-fps " fps
-Specify the camera capture frame rate.
-
-If not specified, Android's default frame rate (30 fps) is used.
-
-.TP
-.BI "\-\-camera\-size " width\fRx\fIheight
-Specify an explicit camera capture size.
-
 .TP
 .BI "\-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
 Crop the device screen on the server.
@ -124,31 +90,23 @@ Use USB device (if there is exactly one, like adb -d).
 Also see \fB\-e\fR (\fB\-\-select\-tcpip\fR).

 .TP
-.BI "\-\-disable\-screensaver"
+.BI "\-\-disable-screensaver"
 Disable screensaver while scrcpy is running.

 .TP
-.BI "\-\-display\-buffer " ms
+.BI "\-\-display " id
+Specify the device display id to mirror.
+
+The available display ids can be listed by \-\-list\-displays.
+
+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 "\-\-display\-id " id
-Specify the device display id to mirror.
-
-The available display ids can be listed by \fB\-\-list\-displays\fR.
-
-Default is 0.
-
-.TP
-.BI "\-\-display\-orientation " value
-Set the initial display orientation.
-
-Possible values are 0, 90, 180, 270, flip0, flip90, flip180 and flip270. The number represents the clockwise rotation in degrees; the "flip" keyword applies a horizontal flip before the rotation.
-
-Default is 0.
-
 .TP
 .B \-e, \-\-select\-tcpip
 Use TCP/IP device (if there is exactly one, like adb -e).
@ -172,31 +130,24 @@ By default, right-click triggers BACK (or POWER on) and middle-click triggers HO
 Print this help.

 .TP
-.B \-K
-Same as \fB\-\-keyboard=uhid\fR.
+.B \-\-kill\-adb\-on\-close
+Kill adb when scrcpy terminates.

 .TP
-.BI "\-\-keyboard " mode
-Select how to send keyboard inputs to the device.
+.B \-K, \-\-hid\-keyboard
+Simulate a physical keyboard by using HID over AOAv2.

-Possible values are "disabled", "sdk", "uhid" and "aoa":
+This provides a better experience for IME users, and allows to generate non-ASCII characters, contrary to the default injection method.

- - "disabled" does not send keyboard inputs to the device.
- - "sdk" uses the Android system API to deliver keyboard events to applications.
- - "uhid" simulates a physical HID keyboard using the Linux HID kernel module on the device.
- - "aoa" simulates a physical HID keyboard using the AOAv2 protocol. It may only work over USB.
+It may only work over USB.

-For "uhid" and "aoa", the keyboard layout must be configured (once and for all) on the device, via Settings -> System -> Languages and input -> Physical keyboard. This settings page can be started directly using the shortcut MOD+k (except in OTG mode), or by executing:
+The keyboard layout must be configured (once and for all) on the device, via Settings -> System -> Languages and input -> Physical keyboard. This settings page can be started directly:

    adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS

-This option is only available when the HID keyboard is enabled (or a physical keyboard is connected).
+However, the option is only available when the HID keyboard is enabled (or a physical keyboard is connected).

-Also see \fB\-\-mouse\fR.
-
-.TP
-.B \-\-kill\-adb\-on\-close
-Kill adb when scrcpy terminates.
+Also see \fB\-\-hid\-mouse\fR.

 .TP
 .B \-\-legacy\-paste
@ -204,14 +155,6 @@ 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
-.B \-\-list\-camera\-sizes
-List the valid camera capture sizes.
-
-.TP
-.B \-\-list\-cameras
-List cameras available on the device.
-
 .TP
 .B \-\-list\-encoders
 List video and audio encoders available on the device.
@ -222,9 +165,7 @@ List displays available on the device.

 .TP
 \fB\-\-lock\-video\-orientation\fR[=\fIvalue\fR]
-Lock capture video orientation to \fIvalue\fR.
-
-Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 90, 180, and 270. The values represent the clockwise rotation from the natural device orientation, in degrees.
+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".

@ -237,38 +178,28 @@ Limit both the width and height of the video to \fIvalue\fR. The other dimension
 Default is 0 (unlimited).

 .TP
-.B \-M
-Same as \fB\-\-mouse=uhid\fR.
+.B \-M, \-\-hid\-mouse
+Simulate a physical mouse by using HID over AOAv2.
+
+In this mode, the computer mouse is captured to control the device directly (relative mouse mode).
+
+LAlt, LSuper or RSuper toggle the capture mode, to give control of the mouse back to the computer.
+
+It may only work over USB.
+
+Also see \fB\-\-hid\-keyboard\fR.

 .TP
 .BI "\-\-max\-fps " value
 Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).

-.TP
-.BI "\-\-mouse " mode
-Select how to send mouse inputs to the device.
-
-Possible values are "disabled", "sdk", "uhid" and "aoa":
-
- - "disabled" does not send mouse inputs to the device.
- - "sdk" uses the Android system API to deliver mouse events to applications.
- - "uhid" simulates a physical HID mouse using the Linux HID kernel module on the device.
- - "aoa" simulates a physical mouse using the AOAv2 protocol. It may only work over USB.
-
-In "uhid" and "aoa" modes, the computer mouse is captured to control the device directly (relative mouse mode).
-
-LAlt, LSuper or RSuper toggle the capture mode, to give control of the mouse back to the computer.
-
-Also see \fB\-\-keyboard\fR.
-
-
 .TP
 .B \-n, \-\-no\-control
 Disable device control (mirror the device in read\-only).

 .TP
 .B \-N, \-\-no\-playback
-Disable video and audio playback on the computer (equivalent to \fB\-\-no\-video\-playback \-\-no\-audio\-playback\fR).
+Disable video and audio playback on the computer (equivalent to --no-video-playback --no-audio-playback).

 .TP
 .B \-\-no\-audio
@ -316,10 +247,6 @@ Disable video forwarding.
 .B \-\-no\-video\-playback
 Disable video playback on the computer.

-.TP
-.BI "\-\-orientation " value
-Same as --display-orientation=value --record-orientation=value.
-
 .TP
 .B \-\-otg
 Run in OTG mode: simulate physical keyboard and mouse, as if the computer keyboard and mouse were plugged directly to the device via an OTG cable.
@ -340,16 +267,6 @@ Set the TCP port (range) used by the client to listen.

 Default is 27183:27199.

-.TP
-\fB\-\-pause\-on\-exit\fR[=\fImode\fR]
-Configure pause on exit. Possible values are "true" (always pause on exit), "false" (never pause on exit) and "if-error" (pause only if an error occured).
-
-This is useful to prevent the terminal window from automatically closing, so that error messages can be read.
-
-Default is "false".
-
-Passing the option without argument is equivalent to passing "true".
-
 .TP
 .B \-\-power\-off\-on\-close
 Turn the device screen off when closing scrcpy.
@ -378,7 +295,7 @@ Record screen to

 The format is determined by the
 .B \-\-record\-format
-option if set, or by the file extension.
+option if set, or by the file extension (.mp4 or .mkv).

 .TP
 .B \-\-raw\-key\-events
@ -386,15 +303,7 @@ Inject key events for all input keys, and ignore text events.

 .TP
 .BI "\-\-record\-format " format
-Force recording format (mp4, mkv, m4a, mka, opus, aac, flac or wav).
-
-.TP
-.BI "\-\-record\-orientation " value
-Set the record orientation.
-
-Possible values are 0, 90, 180 and 270. The number represents the clockwise rotation in degrees.
-
-Default is 0.
+Force recording format (either mp4 or mkv).

 .TP
 .BI "\-\-render\-driver " name
@ -402,12 +311,17 @@ Request SDL to use the given render driver (this is just a hint).

 Supported names are currently "direct3d", "opengl", "opengles2", "opengles", "metal" and "software".

-<https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER>
+.UR https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER
+.UE

 .TP
 .B \-\-require\-audio
 By default, scrcpy mirrors only the video if audio capture fails on the device. This option makes scrcpy fail if audio is enabled but does not work.

+.TP
+.BI "\-\-rotation " value
+Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each increment adds a 90 degrees rotation counterclockwise.
+
 .TP
 .BI "\-s, \-\-serial " number
 The device serial number. Mandatory only if several devices are connected to adb.
@ -446,13 +360,13 @@ Set the maximum mirroring time, in seconds.

 .TP
 .BI "\-\-tunnel\-host " ip
-Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables \fB\-\-force\-adb\-forward\fR.
+Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.

 Default is localhost.

 .TP
 .BI "\-\-tunnel\-port " port
-Set the TCP port of the adb tunnel to reach the scrcpy server. This option automatically enables \fB\-\-force\-adb\-forward\fR.
+Set the TCP port of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.

 Default is 0 (not forced): the local port used for establishing the tunnel will be used.

@ -492,23 +406,15 @@ Set a list of comma-separated key:type=value options for the device video encode

 The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.

-The list of possible codec options is available in the Android documentation:
-
-<https://d.android.com/reference/android/media/MediaFormat>
+The list of possible codec options is available in the Android documentation
+.UR https://d.android.com/reference/android/media/MediaFormat
+.UE .

 .TP
 .BI "\-\-video\-encoder " name
 Use a specific MediaCodec video encoder (depending on the codec provided by \fB\-\-video\-codec\fR).

-The available encoders can be listed by \fB\-\-list\-encoders\fR.
-
-.TP
-.BI "\-\-video\-source " source
-Select the video source (display or camera).
-
-Camera mirroring requires Android 12+.
-
-Default is display.
+The available encoders can be listed by \-\-list\-encoders.

 .TP
 .B \-w, \-\-stay-awake
@ -569,14 +475,6 @@ Rotate display left
 .B MOD+Right
 Rotate display right

-.TP
-.B MOD+Shift+Left, MOD+Shift+Right
-Flip display horizontally
-
-.TP
-.B MOD+Shift+Up, MOD+Shift+Down
-Flip display vertically
-
 .TP
 .B MOD+g
 Resize window to 1:1 (pixel\-perfect)
@ -653,21 +551,13 @@ Copy computer clipboard to device, then paste (inject PASTE keycode, Android >=
 .B MOD+Shift+v
 Inject computer clipboard text as a sequence of key events

-.TP
-.B MOD+k
-Open keyboard settings on the device (for HID keyboard only)
-
 .TP
 .B MOD+i
 Enable/disable FPS counter (print frames/second in logs)

 .TP
 .B Ctrl+click-and-move
-Pinch-to-zoom and rotate from the center of the screen
-
-.TP
-.B Shift+click-and-move
-Tilt (slide vertically with two fingers)
+Pinch-to-zoom from the center of the screen

 .TP
 .B Drag & drop APK file
@ -686,7 +576,7 @@ Path to adb.

 .TP
 .B ANDROID_SERIAL
-Device serial to use if no selector (\fB-s\fR, \fB-d\fR, \fB-e\fR or \fB\-\-tcpip=\fIaddr\fR) is specified.
+Device serial to use if no selector (-s, -d, -e or --tcpip=<addr>) is specified.

 .TP
 .B SCRCPY_ICON_PATH
@ -709,14 +599,23 @@ for the Debian Project (and may be used by others).


 .SH "REPORTING BUGS"
-Report bugs to <https://github.com/Genymobile/scrcpy/issues>.
+Report bugs to
+.UR https://github.com/Genymobile/scrcpy/issues
+.UE .

 .SH COPYRIGHT
-Copyright \(co 2018 Genymobile <https://www.genymobile.com>
+Copyright \(co 2018 Genymobile
+.UR https://www.genymobile.com
+Genymobile
+.UE

-Copyright \(co 2018\-2023 Romain Vimont <rom@rom1v.com>
+Copyright \(co 2018\-2023
+.MT rom@rom1v.com
+Romain Vimont
+.ME

 Licensed under the Apache License, Version 2.0.

 .SH WWW
-<https://github.com/Genymobile/scrcpy>
+.UR https://github.com/Genymobile/scrcpy
+.UE
--- a/app/src/adb/adb.c
+++ b/app/src/adb/adb.c
@ -70,7 +70,7 @@ argv_to_string(const char *const *argv, char *buf, size_t bufsize) {
 }

 static void
-show_adb_installation_msg(void) {
+show_adb_installation_msg() {
 #ifndef __WINDOWS__
    static const struct {
        const char *binary;
@ -218,16 +218,8 @@ sc_adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
               const char *device_socket_name, unsigned flags) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
-
-    int r = snprintf(local, sizeof(local), "tcp:%" PRIu16, local_port);
-    assert(r >= 0 && (size_t) r < sizeof(local));
-
-    r = snprintf(remote, sizeof(remote), "localabstract:%s",
-                 device_socket_name);
-    if (r < 0 || (size_t) r >= sizeof(remote)) {
-        LOGE("Could not write socket name");
-        return false;
-    }
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);

    assert(serial);
    const char *const argv[] =
@ -241,9 +233,7 @@ bool
 sc_adb_forward_remove(struct sc_intr *intr, const char *serial,
                      uint16_t local_port, unsigned flags) {
    char local[4 + 5 + 1]; // tcp:PORT
-    int r = snprintf(local, sizeof(local), "tcp:%" PRIu16, local_port);
-    assert(r >= 0 && (size_t) r < sizeof(local));
-    (void) r;
+    sprintf(local, "tcp:%" PRIu16, local_port);

    assert(serial);
    const char *const argv[] =
@ -259,16 +249,8 @@ sc_adb_reverse(struct sc_intr *intr, const char *serial,
               unsigned flags) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
-    int r = snprintf(local, sizeof(local), "tcp:%" PRIu16, local_port);
-    assert(r >= 0 && (size_t) r < sizeof(local));
-
-    r = snprintf(remote, sizeof(remote), "localabstract:%s",
-                 device_socket_name);
-    if (r < 0 || (size_t) r >= sizeof(remote)) {
-        LOGE("Could not write socket name");
-        return false;
-    }
-
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "reverse", remote, local);
@ -281,12 +263,7 @@ bool
 sc_adb_reverse_remove(struct sc_intr *intr, const char *serial,
                      const char *device_socket_name, unsigned flags) {
    char remote[108 + 14 + 1]; // localabstract:NAME
-    int r = snprintf(remote, sizeof(remote), "localabstract:%s",
-                     device_socket_name);
-    if (r < 0 || (size_t) r >= sizeof(remote)) {
-        LOGE("Device socket name too long");
-        return false;
-    }
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);

    assert(serial);
    const char *const argv[] =
@ -356,9 +333,7 @@ bool
 sc_adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
             unsigned flags) {
    char port_string[5 + 1];
-    int r = snprintf(port_string, sizeof(port_string), "%" PRIu16, port);
-    assert(r >= 0 && (size_t) r < sizeof(port_string));
-    (void) r;
+    sprintf(port_string, "%" PRIu16, port);

    assert(serial);
    const char *const argv[] =
@ -458,7 +433,6 @@ sc_adb_list_devices(struct sc_intr *intr, unsigned flags,
        // in the buffer in a single pass
        LOGW("Result of \"adb devices -l\" does not fit in 64Kb. "
             "Please report an issue.");
-        free(buf);
        return false;
    }

@ -654,8 +628,8 @@ sc_adb_select_device(struct sc_intr *intr,
        return false;
    }

-    LOGI("ADB device found:");
-    sc_adb_devices_log(SC_LOG_LEVEL_INFO, vec.data, vec.size);
+    LOGD("ADB device found:");
+    sc_adb_devices_log(SC_LOG_LEVEL_DEBUG, vec.data, vec.size);

    // Move devics into out_device (do not destroy device)
    sc_adb_device_move(out_device, device);
--- a/app/src/adb/adb_parser.c
+++ b/app/src/adb/adb_parser.c
@ -7,7 +7,7 @@
 #include "util/log.h"
 #include "util/str.h"

-static bool
+bool
 sc_adb_parse_device(char *line, struct sc_adb_device *device) {
    // One device line looks like:
    // "0123456789abcdef	device usb:2-1 product:MyProduct model:MyModel "
--- a/app/src/audio_player.c
+++ b/app/src/audio_player.c
@ -66,7 +66,8 @@ static void SDLCALL
 sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
    struct sc_audio_player *ap = userdata;

-    // This callback is called with the lock used by SDL_LockAudioDevice()
+    // This callback is called with the lock used by SDL_AudioDeviceLock(), so
+    // the audiobuf is protected

    assert(len_int > 0);
    size_t len = len_int;
@ -76,12 +77,12 @@ sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
    LOGD("[Audio] SDL callback requests %" PRIu32 " samples", count);
 #endif

-    bool played = atomic_load_explicit(&ap->played, memory_order_relaxed);
-    if (!played) {
-        uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
-        // Wait until the buffer is filled up to at least target_buffering
-        // before playing
-        if (buffered_samples < ap->target_buffering) {
+    uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
+    if (!ap->played) {
+        // Part of the buffering is handled by inserting initial silence. The
+        // remaining (margin) last samples will be handled by compensation.
+        uint32_t margin = 30 * ap->sample_rate / 1000; // 30ms
+        if (buffered_samples + margin < ap->target_buffering) {
            LOGV("[Audio] Inserting initial buffering silence: %" PRIu32
                 " samples", count);
            // Delay playback starting to reach the target buffering. Fill the
@ -92,7 +93,10 @@ sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
        }
    }

-    uint32_t read = sc_audiobuf_read(&ap->buf, stream, count);
+    uint32_t read = MIN(buffered_samples, count);
+    if (read) {
+        sc_audiobuf_read(&ap->buf, stream, read);
+    }

    if (read < count) {
        uint32_t silence = count - read;
@ -105,16 +109,13 @@ sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
             silence);
        memset(stream + TO_BYTES(read), 0, TO_BYTES(silence));

-        bool received = atomic_load_explicit(&ap->received,
-                                             memory_order_relaxed);
-        if (received) {
+        if (ap->received) {
            // Inserting additional samples immediately increases buffering
-            atomic_fetch_add_explicit(&ap->underflow, silence,
-                                      memory_order_relaxed);
+            ap->underflow += silence;
        }
    }

-    atomic_store_explicit(&ap->played, true, memory_order_relaxed);
+    ap->played = true;
 }

 static uint8_t *
@ -161,168 +162,155 @@ sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,

    // swr_convert() returns the number of samples which would have been
    // written if the buffer was big enough.
-    uint32_t samples = MIN(ret, dst_nb_samples);
+    uint32_t samples_written = MIN(ret, dst_nb_samples);
 #ifndef SC_AUDIO_PLAYER_NDEBUG
-    LOGD("[Audio] %" PRIu32 " samples written to buffer", samples);
+    LOGD("[Audio] %" PRIu32 " samples written to buffer", samples_written);
 #endif

-    uint32_t cap = sc_audiobuf_capacity(&ap->buf);
-    if (samples > cap) {
-        // Very very unlikely: a single resampled frame should never
-        // exceed the audio buffer size (or something is very wrong).
-        // Ignore the first bytes in swr_buf to avoid memory corruption anyway.
-        swr_buf += TO_BYTES(samples - cap);
-        samples = cap;
+    // Since this function is the only writer, the current available space is
+    // at least the previous available space. In practice, it should almost
+    // always be possible to write without lock.
+    bool lockless_write = samples_written <= ap->previous_can_write;
+    if (lockless_write) {
+        sc_audiobuf_prepare_write(&ap->buf, swr_buf, samples_written);
    }

-    uint32_t skipped_samples = 0;
+    SDL_LockAudioDevice(ap->device);

-    uint32_t written = sc_audiobuf_write(&ap->buf, swr_buf, samples);
-    if (written < samples) {
-        uint32_t remaining = samples - written;
+    uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);

-        // All samples that could be written without locking have been written,
-        // now we need to lock to drop/consume old samples
-        SDL_LockAudioDevice(ap->device);
+    if (lockless_write) {
+        sc_audiobuf_commit_write(&ap->buf, samples_written);
+    } else {
+        uint32_t can_write = sc_audiobuf_can_write(&ap->buf);
+        if (samples_written > can_write) {
+            // Entering this branch is very unlikely, the audio buffer is
+            // allocated with a size sufficient to store 1 second more than the
+            // target buffering. If this happens, though, we have to skip old
+            // samples.
+            uint32_t cap = sc_audiobuf_capacity(&ap->buf);
+            if (samples_written > cap) {
+                // Very very unlikely: a single resampled frame should never
+                // exceed the audio buffer size (or something is very wrong).
+                // Ignore the first bytes in swr_buf
+                swr_buf += TO_BYTES(samples_written - cap);
+                // This change in samples_written will impact the
+                // instant_compensation below
+                samples_written = cap;
+            }

-        // Retry with the lock
-        written += sc_audiobuf_write(&ap->buf,
-                                     swr_buf + TO_BYTES(written),
-                                     remaining);
-        if (written < samples) {
-            remaining = samples - written;
-            // Still insufficient, drop old samples to make space
-            skipped_samples = sc_audiobuf_read(&ap->buf, NULL, remaining);
-            assert(skipped_samples == remaining);
+            assert(samples_written >= can_write);
+            if (samples_written > can_write) {
+                uint32_t skip_samples = samples_written - can_write;
+                assert(buffered_samples >= skip_samples);
+                sc_audiobuf_skip(&ap->buf, skip_samples);
+                buffered_samples -= skip_samples;
+                if (ap->played) {
+                    // Dropping input samples instantly decreases buffering
+                    ap->avg_buffering.avg -= skip_samples;
+                }
+            }

-            // Now there is enough space
-            uint32_t w = sc_audiobuf_write(&ap->buf,
-                                           swr_buf + TO_BYTES(written),
-                                           remaining);
-            assert(w == remaining);
-            (void) w;
+            // It should remain exactly the expected size to write the new
+            // samples.
+            assert(sc_audiobuf_can_write(&ap->buf) == samples_written);
        }

-        SDL_UnlockAudioDevice(ap->device);
+        sc_audiobuf_write(&ap->buf, swr_buf, samples_written);
    }

-    uint32_t underflow = 0;
-    uint32_t max_buffered_samples;
-    bool played = atomic_load_explicit(&ap->played, memory_order_relaxed);
-    if (played) {
-        underflow = atomic_exchange_explicit(&ap->underflow, 0,
-                                             memory_order_relaxed);
+    buffered_samples += samples_written;
+    assert(buffered_samples == sc_audiobuf_can_read(&ap->buf));

-        max_buffered_samples = ap->target_buffering
-                               + 12 * ap->output_buffer
-                               + ap->target_buffering / 10;
+    // Read with lock held, to be used after unlocking
+    bool played = ap->played;
+    uint32_t underflow = ap->underflow;
+
+    if (played) {
+        uint32_t max_buffered_samples = ap->target_buffering
+                                      + 12 * ap->output_buffer
+                                      + ap->target_buffering / 10;
+        if (buffered_samples > max_buffered_samples) {
+            uint32_t skip_samples = buffered_samples - max_buffered_samples;
+            sc_audiobuf_skip(&ap->buf, skip_samples);
+            LOGD("[Audio] Buffering threshold exceeded, skipping %" PRIu32
+                 " samples", skip_samples);
+        }
+
+        // reset (the current value was copied to a local variable)
+        ap->underflow = 0;
    } else {
        // SDL playback not started yet, do not accumulate more than
        // max_initial_buffering samples, this would cause unnecessary delay
        // (and glitches to compensate) on start.
-        max_buffered_samples = ap->target_buffering + 2 * ap->output_buffer;
+        uint32_t max_initial_buffering = ap->target_buffering
+                                       + 2 * ap->output_buffer;
+        if (buffered_samples > max_initial_buffering) {
+            uint32_t skip_samples = buffered_samples - max_initial_buffering;
+            sc_audiobuf_skip(&ap->buf, skip_samples);
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+            LOGD("[Audio] Playback not started, skipping %" PRIu32 " samples",
+                 skip_samples);
+#endif
+        }
    }

-    uint32_t can_read = sc_audiobuf_can_read(&ap->buf);
-    if (can_read > max_buffered_samples) {
-        uint32_t skip_samples = 0;
+    ap->previous_can_write = sc_audiobuf_can_write(&ap->buf);
+    ap->received = true;

-        SDL_LockAudioDevice(ap->device);
-        can_read = sc_audiobuf_can_read(&ap->buf);
-        if (can_read > max_buffered_samples) {
-            skip_samples = can_read - max_buffered_samples;
-            uint32_t r = sc_audiobuf_read(&ap->buf, NULL, skip_samples);
-            assert(r == skip_samples);
-            (void) r;
-            skipped_samples += skip_samples;
-        }
-        SDL_UnlockAudioDevice(ap->device);
+    SDL_UnlockAudioDevice(ap->device);
+
+    if (played) {
+        // Number of samples added (or removed, if negative) for compensation
+        int32_t instant_compensation =
+            (int32_t) samples_written - frame->nb_samples;
+        int32_t inserted_silence = (int32_t) underflow;
+
+        // The compensation must apply instantly, it must not be smoothed
+        ap->avg_buffering.avg += instant_compensation + inserted_silence;
+
+
+        // However, the buffering level must be smoothed
+        sc_average_push(&ap->avg_buffering, buffered_samples);

-        if (skip_samples) {
-            if (played) {
-                LOGD("[Audio] Buffering threshold exceeded, skipping %" PRIu32
-                     " samples", skip_samples);
 #ifndef SC_AUDIO_PLAYER_NDEBUG
-            } else {
-                LOGD("[Audio] Playback not started, skipping %" PRIu32
-                     " samples", skip_samples);
+        LOGD("[Audio] buffered_samples=%" PRIu32 " avg_buffering=%f",
+             buffered_samples, sc_average_get(&ap->avg_buffering));
 #endif
+
+        ap->samples_since_resync += samples_written;
+        if (ap->samples_since_resync >= ap->sample_rate) {
+            // Recompute compensation every second
+            ap->samples_since_resync = 0;
+
+            float avg = sc_average_get(&ap->avg_buffering);
+            int diff = ap->target_buffering - avg;
+            if (abs(diff) < (int) ap->sample_rate / 1000) {
+                // Do not compensate for less than 1ms, the error is just noise
+                diff = 0;
+            } else if (diff < 0 && buffered_samples < ap->target_buffering) {
+                // Do not accelerate if the instant buffering level is below
+                // the average, this would increase underflow
+                diff = 0;
            }
-        }
-    }
+            // Compensate the diff over 4 seconds (but will be recomputed after
+            // 1 second)
+            int distance = 4 * ap->sample_rate;
+            // Limit compensation rate to 2%
+            int abs_max_diff = distance / 50;
+            diff = CLAMP(diff, -abs_max_diff, abs_max_diff);
+            LOGV("[Audio] Buffering: target=%" PRIu32 " avg=%f cur=%" PRIu32
+                 " compensation=%d", ap->target_buffering, avg,
+                 buffered_samples, diff);

-    atomic_store_explicit(&ap->received, true, memory_order_relaxed);
-    if (!played) {
-        // Nothing more to do
-        return true;
-    }
-
-    // Number of samples added (or removed, if negative) for compensation
-    int32_t instant_compensation = (int32_t) written - frame->nb_samples;
-    // Inserting silence instantly increases buffering
-    int32_t inserted_silence = (int32_t) underflow;
-    // Dropping input samples instantly decreases buffering
-    int32_t dropped = (int32_t) skipped_samples;
-
-    // The compensation must apply instantly, it must not be smoothed
-    ap->avg_buffering.avg += instant_compensation + inserted_silence - dropped;
-    if (ap->avg_buffering.avg < 0) {
-        // Since dropping samples instantly reduces buffering, the difference
-        // is applied immediately to the average value, assuming that the delay
-        // between the producer and the consumer will be caught up.
-        //
-        // However, when this assumption is not valid, the average buffering
-        // may decrease indefinitely. Prevent it to become negative to limit
-        // the consequences.
-        ap->avg_buffering.avg = 0;
-    }
-
-    // However, the buffering level must be smoothed
-    sc_average_push(&ap->avg_buffering, can_read);
-
-#ifndef SC_AUDIO_PLAYER_NDEBUG
-    LOGD("[Audio] can_read=%" PRIu32 " avg_buffering=%f",
-         can_read, sc_average_get(&ap->avg_buffering));
-#endif
-
-    ap->samples_since_resync += written;
-    if (ap->samples_since_resync >= ap->sample_rate) {
-        // Recompute compensation every second
-        ap->samples_since_resync = 0;
-
-        float avg = sc_average_get(&ap->avg_buffering);
-        int diff = ap->target_buffering - avg;
-
-        // Enable compensation when the difference exceeds +/- 4ms.
-        // Disable compensation when the difference is lower than +/- 1ms.
-        int threshold = ap->compensation != 0
-                      ? ap->sample_rate     / 1000  /* 1ms */
-                      : ap->sample_rate * 4 / 1000; /* 4ms */
-
-        if (abs(diff) < threshold) {
-            // Do not compensate for small values, the error is just noise
-            diff = 0;
-        } else if (diff < 0 && can_read < ap->target_buffering) {
-            // Do not accelerate if the instant buffering level is below the
-            // target, this would increase underflow
-            diff = 0;
-        }
-        // Compensate the diff over 4 seconds (but will be recomputed after 1
-        // second)
-        int distance = 4 * ap->sample_rate;
-        // Limit compensation rate to 2%
-        int abs_max_diff = distance / 50;
-        diff = CLAMP(diff, -abs_max_diff, abs_max_diff);
-        LOGV("[Audio] Buffering: target=%" PRIu32 " avg=%f cur=%" PRIu32
-             " compensation=%d", ap->target_buffering, avg, can_read, diff);
-
-        if (diff != ap->compensation) {
-            int ret = swr_set_compensation(swr_ctx, diff, distance);
-            if (ret < 0) {
-                LOGW("Resampling compensation failed: %d", ret);
-                // not fatal
-            } else {
-                ap->compensation = diff;
+            if (diff != ap->compensation) {
+                int ret = swr_set_compensation(swr_ctx, diff, distance);
+                if (ret < 0) {
+                    LOGW("Resampling compensation failed: %d", ret);
+                    // not fatal
+                } else {
+                    ap->compensation = diff;
+                }
            }
        }
    }
@ -409,7 +397,7 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
    // producer and the consumer. It's too big on purpose, to guarantee that
    // the producer and the consumer will be able to access it in parallel
    // without locking.
-    uint32_t audiobuf_samples = ap->target_buffering + ap->sample_rate;
+    size_t audiobuf_samples = ap->target_buffering + ap->sample_rate;

    size_t sample_size = ap->nb_channels * ap->out_bytes_per_sample;
    bool ok = sc_audiobuf_init(&ap->buf, sample_size, audiobuf_samples);
@ -425,15 +413,16 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
    }
    ap->swr_buf_alloc_size = initial_swr_buf_size;

+    ap->previous_can_write = sc_audiobuf_can_write(&ap->buf);
+
    // Samples are produced and consumed by blocks, so the buffering must be
    // smoothed to get a relatively stable value.
-    sc_average_init(&ap->avg_buffering, 128);
+    sc_average_init(&ap->avg_buffering, 32);
    ap->samples_since_resync = 0;

    ap->received = false;
-    atomic_init(&ap->played, false);
-    atomic_init(&ap->received, false);
-    atomic_init(&ap->underflow, 0);
+    ap->played = false;
+    ap->underflow = 0;
    ap->compensation = 0;

    // The thread calling open() is the thread calling push(), which fills the
--- a/app/src/audio_player.h
+++ b/app/src/audio_player.h
@ -3,18 +3,17 @@

 #include "common.h"

-#include <stdatomic.h>
 #include <stdbool.h>
+#include "trait/frame_sink.h"
+#include <util/audiobuf.h>
+#include <util/average.h>
+#include <util/thread.h>
+#include <util/tick.h>
+
 #include <libavformat/avformat.h>
 #include <libswresample/swresample.h>
 #include <SDL2/SDL.h>

-#include "trait/frame_sink.h"
-#include "util/audiobuf.h"
-#include "util/average.h"
-#include "util/thread.h"
-#include "util/tick.h"
-
 struct sc_audio_player {
    struct sc_frame_sink frame_sink;

@ -33,9 +32,13 @@ struct sc_audio_player {
    uint16_t output_buffer;

    // Audio buffer to communicate between the receiver and the SDL audio
-    // callback
+    // callback (protected by SDL_AudioDeviceLock())
    struct sc_audiobuf buf;

+    // The previous empty space in the buffer (only used by the receiver
+    // thread)
+    uint32_t previous_can_write;
+
    // Resampler (only used from the receiver thread)
    struct SwrContext *swr_ctx;

@ -44,7 +47,7 @@ struct sc_audio_player {
    // The number of channels is the same for input and output
    unsigned nb_channels;
    // The number of bytes per sample for a single channel
-    size_t out_bytes_per_sample;
+    unsigned out_bytes_per_sample;

    // Target buffer for resampling (only used by the receiver thread)
    uint8_t *swr_buf;
@ -58,16 +61,19 @@ struct sc_audio_player {
    uint32_t samples_since_resync;

    // Number of silence samples inserted since the last received packet
-    atomic_uint_least32_t underflow;
+    // (protected by SDL_AudioDeviceLock())
+    uint32_t underflow;

    // Current applied compensation value (only used by the receiver thread)
    int compensation;

-    // Set to true the first time a sample is received
-    atomic_bool received;
+    // Set to true the first time a sample is received (protected by
+    // SDL_AudioDeviceLock())
+    bool received;

-    // Set to true the first time the SDL callback is called
-    atomic_bool played;
+    // Set to true the first time the SDL callback is called (protected by
+    // SDL_AudioDeviceLock())
+    bool played;

    const struct sc_audio_player_callbacks *cbs;
    void *cbs_userdata;
--- a/app/src/cli.c
+++ b/app/src/cli.c
--- a/app/src/cli.h
+++ b/app/src/cli.h
@ -7,17 +7,10 @@

 #include "options.h"

-enum sc_pause_on_exit {
-    SC_PAUSE_ON_EXIT_TRUE,
-    SC_PAUSE_ON_EXIT_FALSE,
-    SC_PAUSE_ON_EXIT_IF_ERROR,
-};
-
 struct scrcpy_cli_args {
    struct scrcpy_options opts;
    bool help;
    bool version;
-    enum sc_pause_on_exit pause_on_exit;
 };

 void
--- a/app/src/compat.h
+++ b/app/src/compat.h
@ -3,9 +3,7 @@

 #include "config.h"

-#include <libavcodec/version.h>
 #include <libavformat/version.h>
-#include <libavutil/version.h>
 #include <SDL2/SDL_version.h>

 #ifndef __WIN32
@ -52,15 +50,6 @@
 # define SCRCPY_LAVU_HAS_CHLAYOUT
 #endif

-// In ffmpeg/doc/APIchanges:
-// 2023-10-06 - 5432d2aacad - lavc 60.15.100 - avformat.h
-//   Deprecate AVFormatContext.{nb_,}side_data, av_stream_add_side_data(),
-//   av_stream_new_side_data(), and av_stream_get_side_data(). Side data fields
-//   from AVFormatContext.codecpar should be used from now on.
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(60, 15, 100)
-# define SCRCPY_LAVC_HAS_CODECPAR_CODEC_SIDEDATA
-#endif
-
 #if SDL_VERSION_ATLEAST(2, 0, 6)
 // <https://github.com/libsdl-org/SDL/commit/d7a318de563125e5bb465b1000d6bc9576fbc6fc>
 # define SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@ -87,7 +87,7 @@ write_position(uint8_t *buf, const struct sc_position *position) {

 // write length (4 bytes) + string (non null-terminated)
 static size_t
-write_string(const char *utf8, size_t max_len, uint8_t *buf) {
+write_string(const char *utf8, size_t max_len, unsigned char *buf) {
    size_t len = sc_str_utf8_truncation_index(utf8, max_len);
    sc_write32be(buf, len);
    memcpy(&buf[4], utf8, len);
@ -95,7 +95,7 @@ write_string(const char *utf8, size_t max_len, uint8_t *buf) {
 }

 size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
+sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
    buf[0] = msg->type;
    switch (msg->type) {
        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
@ -146,22 +146,10 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
        case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
            buf[1] = msg->set_screen_power_mode.mode;
            return 2;
-        case SC_CONTROL_MSG_TYPE_UHID_CREATE:
-            sc_write16be(&buf[1], msg->uhid_create.id);
-            sc_write16be(&buf[3], msg->uhid_create.report_desc_size);
-            memcpy(&buf[5], msg->uhid_create.report_desc,
-                            msg->uhid_create.report_desc_size);
-            return 5 + msg->uhid_create.report_desc_size;
-        case SC_CONTROL_MSG_TYPE_UHID_INPUT:
-            sc_write16be(&buf[1], msg->uhid_input.id);
-            sc_write16be(&buf[3], msg->uhid_input.size);
-            memcpy(&buf[5], msg->uhid_input.data, msg->uhid_input.size);
-            return 5 + msg->uhid_input.size;
        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
-        case SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
            // no additional data
            return 1;
        default:
@ -254,26 +242,6 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
            LOG_CMSG("rotate device");
            break;
-        case SC_CONTROL_MSG_TYPE_UHID_CREATE:
-            LOG_CMSG("UHID create [%" PRIu16 "] report_desc_size=%" PRIu16,
-                     msg->uhid_create.id, msg->uhid_create.report_desc_size);
-            break;
-        case SC_CONTROL_MSG_TYPE_UHID_INPUT: {
-            char *hex = sc_str_to_hex_string(msg->uhid_input.data,
-                                             msg->uhid_input.size);
-            if (hex) {
-                LOG_CMSG("UHID input [%" PRIu16 "] %s",
-                         msg->uhid_input.id, hex);
-                free(hex);
-            } else {
-                LOG_CMSG("UHID input [%" PRIu16 "] size=%" PRIu16,
-                         msg->uhid_input.id, msg->uhid_input.size);
-            }
-            break;
-        }
-        case SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
-            LOG_CMSG("open hard keyboard settings");
-            break;
        default:
            LOG_CMSG("unknown type: %u", (unsigned) msg->type);
            break;
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@ -10,7 +10,6 @@
 #include "android/input.h"
 #include "android/keycodes.h"
 #include "coords.h"
-#include "hid/hid_event.h"

 #define SC_CONTROL_MSG_MAX_SIZE (1 << 18) // 256k

@ -38,9 +37,6 @@ enum sc_control_msg_type {
    SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
    SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
    SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
-    SC_CONTROL_MSG_TYPE_UHID_CREATE,
-    SC_CONTROL_MSG_TYPE_UHID_INPUT,
-    SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS,
 };

 enum sc_screen_power_mode {
@ -96,23 +92,13 @@ struct sc_control_msg {
        struct {
            enum sc_screen_power_mode mode;
        } set_screen_power_mode;
-        struct {
-            uint16_t id;
-            uint16_t report_desc_size;
-            const uint8_t *report_desc; // pointer to static data
-        } uhid_create;
-        struct {
-            uint16_t id;
-            uint16_t size;
-            uint8_t data[SC_HID_MAX_SIZE];
-        } uhid_input;
    };
 };

 // buf size must be at least CONTROL_MSG_MAX_SIZE
 // return the number of bytes written
 size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf);
+sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf);

 void
 sc_control_msg_log(const struct sc_control_msg *msg);
--- a/app/src/controller.c
+++ b/app/src/controller.c
@ -7,7 +7,8 @@
 #define SC_CONTROL_MSG_QUEUE_MAX 64

 bool
-sc_controller_init(struct sc_controller *controller, sc_socket control_socket) {
+sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
+                   struct sc_acksync *acksync) {
    sc_vecdeque_init(&controller->queue);

    bool ok = sc_vecdeque_reserve(&controller->queue, SC_CONTROL_MSG_QUEUE_MAX);
@ -15,7 +16,7 @@ sc_controller_init(struct sc_controller *controller, sc_socket control_socket) {
        return false;
    }

-    ok = sc_receiver_init(&controller->receiver, control_socket);
+    ok = sc_receiver_init(&controller->receiver, control_socket, acksync);
    if (!ok) {
        sc_vecdeque_destroy(&controller->queue);
        return false;
@ -42,14 +43,6 @@ sc_controller_init(struct sc_controller *controller, sc_socket control_socket) {
    return true;
 }

-void
-sc_controller_configure(struct sc_controller *controller,
-                        struct sc_acksync *acksync,
-                        struct sc_uhid_devices *uhid_devices) {
-    controller->receiver.acksync = acksync;
-    controller->receiver.uhid_devices = uhid_devices;
-}
-
 void
 sc_controller_destroy(struct sc_controller *controller) {
    sc_cond_destroy(&controller->msg_cond);
@ -91,7 +84,7 @@ sc_controller_push_msg(struct sc_controller *controller,
 static bool
 process_msg(struct sc_controller *controller,
            const struct sc_control_msg *msg) {
-    static uint8_t serialized_msg[SC_CONTROL_MSG_MAX_SIZE];
+    static unsigned char serialized_msg[SC_CONTROL_MSG_MAX_SIZE];
    size_t length = sc_control_msg_serialize(msg, serialized_msg);
    if (!length) {
        return false;
--- a/app/src/controller.h
+++ b/app/src/controller.h
@ -25,12 +25,8 @@ struct sc_controller {
 };

 bool
-sc_controller_init(struct sc_controller *controller, sc_socket control_socket);
-
-void
-sc_controller_configure(struct sc_controller *controller,
-                        struct sc_acksync *acksync,
-                        struct sc_uhid_devices *uhid_devices);
+sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
+                   struct sc_acksync *acksync);

 void
 sc_controller_destroy(struct sc_controller *controller);
--- a/app/src/demuxer.c
+++ b/app/src/demuxer.c
@ -25,8 +25,7 @@ sc_demuxer_to_avcodec_id(uint32_t codec_id) {
 #define SC_CODEC_ID_H265 UINT32_C(0x68323635) // "h265" in ASCII
 #define SC_CODEC_ID_AV1 UINT32_C(0x00617631) // "av1" in ASCII
 #define SC_CODEC_ID_OPUS UINT32_C(0x6f707573) // "opus" in ASCII
-#define SC_CODEC_ID_AAC UINT32_C(0x00616163) // "aac" in ASCII
-#define SC_CODEC_ID_FLAC UINT32_C(0x666c6163) // "flac" in ASCII
+#define SC_CODEC_ID_AAC UINT32_C(0x00616163) // "aac in ASCII"
 #define SC_CODEC_ID_RAW UINT32_C(0x00726177) // "raw" in ASCII
    switch (codec_id) {
        case SC_CODEC_ID_H264:
@ -44,8 +43,6 @@ sc_demuxer_to_avcodec_id(uint32_t codec_id) {
            return AV_CODEC_ID_OPUS;
        case SC_CODEC_ID_AAC:
            return AV_CODEC_ID_AAC;
-        case SC_CODEC_ID_FLAC:
-            return AV_CODEC_ID_FLAC;
        case SC_CODEC_ID_RAW:
            return AV_CODEC_ID_PCM_S16LE;
        default:
@ -210,11 +207,6 @@ run_demuxer(void *data) {
        codec_ctx->channels = 2;
 #endif
        codec_ctx->sample_rate = 48000;
-
-        if (raw_codec_id == SC_CODEC_ID_FLAC) {
-            // The sample_fmt is not set by the FLAC decoder
-            codec_ctx->sample_fmt = AV_SAMPLE_FMT_S16;
-        }
    }

    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
@ -227,9 +219,8 @@ run_demuxer(void *data) {
    }

    // Config packets must be merged with the next non-config packet only for
-    // H.26x
-    bool must_merge_config_packet = raw_codec_id == SC_CODEC_ID_H264
-                                 || raw_codec_id == SC_CODEC_ID_H265;
+    // video streams
+    bool must_merge_config_packet = codec->type == AVMEDIA_TYPE_VIDEO;

    struct sc_packet_merger merger;

--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@ -8,22 +8,19 @@
 #include "util/log.h"

 ssize_t
-sc_device_msg_deserialize(const uint8_t *buf, size_t len,
-                          struct sc_device_msg *msg) {
-    if (!len) {
-        return 0; // no message
+device_msg_deserialize(const unsigned char *buf, size_t len,
+                       struct device_msg *msg) {
+    if (len < 5) {
+        // at least type + empty string length
+        return 0; // not available
    }

    msg->type = buf[0];
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
-            if (len < 5) {
-                // at least type + empty string length
-                return 0; // no complete message
-            }
            size_t clipboard_len = sc_read32be(&buf[1]);
            if (clipboard_len > len - 5) {
-                return 0; // no complete message
+                return 0; // not available
            }
            char *text = malloc(clipboard_len + 1);
            if (!text) {
@ -39,38 +36,10 @@ sc_device_msg_deserialize(const uint8_t *buf, size_t len,
            return 5 + clipboard_len;
        }
        case DEVICE_MSG_TYPE_ACK_CLIPBOARD: {
-            if (len < 9) {
-                return 0; // no complete message
-            }
            uint64_t sequence = sc_read64be(&buf[1]);
            msg->ack_clipboard.sequence = sequence;
            return 9;
        }
-        case DEVICE_MSG_TYPE_UHID_OUTPUT: {
-            if (len < 5) {
-                // at least id + size
-                return 0; // not available
-            }
-            uint16_t id = sc_read16be(&buf[1]);
-            size_t size = sc_read16be(&buf[3]);
-            if (size < len - 5) {
-                return 0; // not available
-            }
-            uint8_t *data = malloc(size);
-            if (!data) {
-                LOG_OOM();
-                return -1;
-            }
-            if (size) {
-                memcpy(data, &buf[5], size);
-            }
-
-            msg->uhid_output.id = id;
-            msg->uhid_output.size = size;
-            msg->uhid_output.data = data;
-
-            return 5 + size;
-        }
        default:
            LOGW("Unknown device message type: %d", (int) msg->type);
            return -1; // error, we cannot recover
@ -78,16 +47,8 @@ sc_device_msg_deserialize(const uint8_t *buf, size_t len,
 }

 void
-sc_device_msg_destroy(struct sc_device_msg *msg) {
-    switch (msg->type) {
-        case DEVICE_MSG_TYPE_CLIPBOARD:
-            free(msg->clipboard.text);
-            break;
-        case DEVICE_MSG_TYPE_UHID_OUTPUT:
-            free(msg->uhid_output.data);
-            break;
-        default:
-            // nothing to do
-            break;
+device_msg_destroy(struct device_msg *msg) {
+    if (msg->type == DEVICE_MSG_TYPE_CLIPBOARD) {
+        free(msg->clipboard.text);
    }
 }
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@ -11,14 +11,13 @@
 // type: 1 byte; length: 4 bytes
 #define DEVICE_MSG_TEXT_MAX_LENGTH (DEVICE_MSG_MAX_SIZE - 5)

-enum sc_device_msg_type {
+enum device_msg_type {
    DEVICE_MSG_TYPE_CLIPBOARD,
    DEVICE_MSG_TYPE_ACK_CLIPBOARD,
-    DEVICE_MSG_TYPE_UHID_OUTPUT,
 };

-struct sc_device_msg {
-    enum sc_device_msg_type type;
+struct device_msg {
+    enum device_msg_type type;
    union {
        struct {
            char *text; // owned, to be freed by free()
@ -26,20 +25,15 @@ struct sc_device_msg {
        struct {
            uint64_t sequence;
        } ack_clipboard;
-        struct {
-            uint16_t id;
-            uint16_t size;
-            uint8_t *data; // owned, to be freed by free()
-        } uhid_output;
    };
 };

 // return the number of bytes consumed (0 for no msg available, -1 on error)
 ssize_t
-sc_device_msg_deserialize(const uint8_t *buf, size_t len,
-                          struct sc_device_msg *msg);
+device_msg_deserialize(const unsigned char *buf, size_t len,
+                       struct device_msg *msg);

 void
-sc_device_msg_destroy(struct sc_device_msg *msg);
+device_msg_destroy(struct device_msg *msg);

 #endif
--- a/app/src/display.c
+++ b/app/src/display.c
@ -53,13 +53,13 @@ sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps) {
                display->mipmaps = true;
            } else {
                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required)");
+                     "(OpenGL 3.0+ or ES 2.0+ required");
            }
        } else {
            LOGI("Trilinear filtering disabled");
        }
    } else if (mipmaps) {
-        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
+        LOGD("Trilinear filtering disabled (not an OpenGL renderer");
    }

    display->pending.flags = 0;
@ -234,7 +234,7 @@ sc_display_update_texture(struct sc_display *display, const AVFrame *frame) {

 enum sc_display_result
 sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
-                  enum sc_orientation orientation) {
+                  unsigned rotation) {
    SDL_RenderClear(display->renderer);

    if (display->pending.flags) {
@ -247,33 +247,33 @@ sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
    SDL_Renderer *renderer = display->renderer;
    SDL_Texture *texture = display->texture;

-    if (orientation == SC_ORIENTATION_0) {
+    if (rotation == 0) {
        int ret = SDL_RenderCopy(renderer, texture, NULL, geometry);
        if (ret) {
            LOGE("Could not render texture: %s", SDL_GetError());
            return SC_DISPLAY_RESULT_ERROR;
        }
    } else {
-        unsigned cw_rotation = sc_orientation_get_rotation(orientation);
+        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
+        // counterclockwise (to be consistent with --lock-video-orientation)
+        int cw_rotation = (4 - rotation) % 4;
        double angle = 90 * cw_rotation;

        const SDL_Rect *dstrect = NULL;
        SDL_Rect rect;
-        if (sc_orientation_is_swap(orientation)) {
+        if (rotation & 1) {
            rect.x = geometry->x + (geometry->w - geometry->h) / 2;
            rect.y = geometry->y + (geometry->h - geometry->w) / 2;
            rect.w = geometry->h;
            rect.h = geometry->w;
            dstrect = &rect;
        } else {
+            assert(rotation == 2);
            dstrect = geometry;
        }

-        SDL_RendererFlip flip = sc_orientation_is_mirror(orientation)
-                              ? SDL_FLIP_HORIZONTAL : 0;
-
        int ret = SDL_RenderCopyEx(renderer, texture, NULL, dstrect, angle,
-                                   NULL, flip);
+                                   NULL, 0);
        if (ret) {
            LOGE("Could not render texture: %s", SDL_GetError());
            return SC_DISPLAY_RESULT_ERROR;
--- a/app/src/display.h
+++ b/app/src/display.h
@ -9,7 +9,6 @@

 #include "coords.h"
 #include "opengl.h"
-#include "options.h"

 #ifdef __APPLE__
 # define SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
@ -55,6 +54,6 @@ sc_display_update_texture(struct sc_display *display, const AVFrame *frame);

 enum sc_display_result
 sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
-                  enum sc_orientation orientation);
+                  unsigned rotation);

 #endif
--- a/app/src/hid/hid_event.h
+++ b/app/src/hid/hid_event.h
@ -1,15 +0,0 @@
-#ifndef SC_HID_EVENT_H
-#define SC_HID_EVENT_H
-
-#include "common.h"
-
-#include <stdint.h>
-
-#define SC_HID_MAX_SIZE 8
-
-struct sc_hid_event {
-    uint8_t data[SC_HID_MAX_SIZE];
-    uint8_t size;
-};
-
-#endif
--- a/app/src/hid/hid_mouse.c
+++ b/app/src/hid/hid_mouse.c
@ -1,192 +0,0 @@
-#include "hid_mouse.h"
-
-// 1 byte for buttons + padding, 1 byte for X position, 1 byte for Y position,
-// 1 byte for wheel motion
-#define HID_MOUSE_EVENT_SIZE 4
-
-/**
- * Mouse descriptor from the specification:
- * <https://www.usb.org/sites/default/files/hid1_11.pdf>
- *
- * Appendix E (p71): §E.10 Report Descriptor (Mouse)
- *
- * The usage tags (like Wheel) are listed in "HID Usage Tables":
- * <https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf>
- * §4 Generic Desktop Page (0x01) (p26)
- */
-const uint8_t SC_HID_MOUSE_REPORT_DESC[] = {
-    // Usage Page (Generic Desktop)
-    0x05, 0x01,
-    // Usage (Mouse)
-    0x09, 0x02,
-
-    // Collection (Application)
-    0xA1, 0x01,
-
-    // Usage (Pointer)
-    0x09, 0x01,
-
-    // Collection (Physical)
-    0xA1, 0x00,
-
-    // Usage Page (Buttons)
-    0x05, 0x09,
-
-    // Usage Minimum (1)
-    0x19, 0x01,
-     // Usage Maximum (5)
-    0x29, 0x05,
-    // Logical Minimum (0)
-    0x15, 0x00,
-    // Logical Maximum (1)
-    0x25, 0x01,
-    // Report Count (5)
-    0x95, 0x05,
-    // Report Size (1)
-    0x75, 0x01,
-    // Input (Data, Variable, Absolute): 5 buttons bits
-    0x81, 0x02,
-
-    // Report Count (1)
-    0x95, 0x01,
-    // Report Size (3)
-    0x75, 0x03,
-    // Input (Constant): 3 bits padding
-    0x81, 0x01,
-
-    // Usage Page (Generic Desktop)
-    0x05, 0x01,
-    // Usage (X)
-    0x09, 0x30,
-    // Usage (Y)
-    0x09, 0x31,
-    // Usage (Wheel)
-    0x09, 0x38,
-    // Local Minimum (-127)
-    0x15, 0x81,
-    // Local Maximum (127)
-    0x25, 0x7F,
-    // Report Size (8)
-    0x75, 0x08,
-    // Report Count (3)
-    0x95, 0x03,
-    // Input (Data, Variable, Relative): 3 position bytes (X, Y, Wheel)
-    0x81, 0x06,
-
-    // End Collection
-    0xC0,
-
-    // End Collection
-    0xC0,
-};
-
-const size_t SC_HID_MOUSE_REPORT_DESC_LEN =
-    sizeof(SC_HID_MOUSE_REPORT_DESC);
-
-/**
- * A mouse HID event is 4 bytes long:
- *
- *  - byte 0: buttons state
- *  - byte 1: relative x motion (signed byte from -127 to 127)
- *  - byte 2: relative y motion (signed byte from -127 to 127)
- *  - byte 3: wheel motion (-1, 0 or 1)
- *
- *                   7 6 5 4 3 2 1 0
- *                  +---------------+
- *         byte 0:  |0 0 0 . . . . .| buttons state
- *                  +---------------+
- *                         ^ ^ ^ ^ ^
- *                         | | | | `- left button
- *                         | | | `--- right button
- *                         | | `----- middle button
- *                         | `------- button 4
- *                         `--------- button 5
- *
- *                  +---------------+
- *         byte 1:  |. . . . . . . .| relative x motion
- *                  +---------------+
- *         byte 2:  |. . . . . . . .| relative y motion
- *                  +---------------+
- *         byte 3:  |. . . . . . . .| wheel motion
- *                  +---------------+
- *
- * As an example, here is the report for a motion of (x=5, y=-4) with left
- * button pressed:
- *
- *                  +---------------+
- *                  |0 0 0 0 0 0 0 1| left button pressed
- *                  +---------------+
- *                  |0 0 0 0 0 1 0 1| horizontal motion (x = 5)
- *                  +---------------+
- *                  |1 1 1 1 1 1 0 0| relative y motion (y = -4)
- *                  +---------------+
- *                  |0 0 0 0 0 0 0 0| wheel motion
- *                  +---------------+
- */
-
-static void
-sc_hid_mouse_event_init(struct sc_hid_event *hid_event) {
-    hid_event->size = HID_MOUSE_EVENT_SIZE;
-    // Leave hid_event->data uninitialized, it will be fully initialized by
-    // callers
-}
-
-static uint8_t
-sc_hid_buttons_from_buttons_state(uint8_t buttons_state) {
-    uint8_t c = 0;
-    if (buttons_state & SC_MOUSE_BUTTON_LEFT) {
-        c |= 1 << 0;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_RIGHT) {
-        c |= 1 << 1;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_MIDDLE) {
-        c |= 1 << 2;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_X1) {
-        c |= 1 << 3;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_X2) {
-        c |= 1 << 4;
-    }
-    return c;
-}
-
-void
-sc_hid_mouse_event_from_motion(struct sc_hid_event *hid_event,
-                               const struct sc_mouse_motion_event *event) {
-    sc_hid_mouse_event_init(hid_event);
-
-    uint8_t *data = hid_event->data;
-    data[0] = sc_hid_buttons_from_buttons_state(event->buttons_state);
-    data[1] = CLAMP(event->xrel, -127, 127);
-    data[2] = CLAMP(event->yrel, -127, 127);
-    data[3] = 0; // wheel coordinates only used for scrolling
-}
-
-void
-sc_hid_mouse_event_from_click(struct sc_hid_event *hid_event,
-                              const struct sc_mouse_click_event *event) {
-    sc_hid_mouse_event_init(hid_event);
-
-    uint8_t *data = hid_event->data;
-    data[0] = sc_hid_buttons_from_buttons_state(event->buttons_state);
-    data[1] = 0; // no x motion
-    data[2] = 0; // no y motion
-    data[3] = 0; // wheel coordinates only used for scrolling
-}
-
-void
-sc_hid_mouse_event_from_scroll(struct sc_hid_event *hid_event,
-                               const struct sc_mouse_scroll_event *event) {
-    sc_hid_mouse_event_init(hid_event);
-
-    uint8_t *data = hid_event->data;
-    data[0] = 0; // buttons state irrelevant (and unknown)
-    data[1] = 0; // no x motion
-    data[2] = 0; // no y motion
-    // In practice, vscroll is always -1, 0 or 1, but in theory other values
-    // are possible
-    data[3] = CLAMP(event->vscroll, -127, 127);
-    // Horizontal scrolling ignored
-}
--- a/app/src/hid/hid_mouse.h
+++ b/app/src/hid/hid_mouse.h
@ -1,26 +0,0 @@
-#ifndef SC_HID_MOUSE_H
-#define SC_HID_MOUSE_H
-
-#endif
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "hid/hid_event.h"
-#include "input_events.h"
-
-extern const uint8_t SC_HID_MOUSE_REPORT_DESC[];
-extern const size_t SC_HID_MOUSE_REPORT_DESC_LEN;
-
-void
-sc_hid_mouse_event_from_motion(struct sc_hid_event *hid_event,
-                               const struct sc_mouse_motion_event *event);
-
-void
-sc_hid_mouse_event_from_click(struct sc_hid_event *hid_event,
-                              const struct sc_mouse_click_event *event);
-
-void
-sc_hid_mouse_event_from_scroll(struct sc_hid_event *hid_event,
-                               const struct sc_mouse_scroll_event *event);
--- a/app/src/icon.c
+++ b/app/src/icon.c
@ -271,7 +271,7 @@ error:
 }

 SDL_Surface *
-scrcpy_icon_load(void) {
+scrcpy_icon_load() {
    char *icon_path = get_icon_path();
    if (!icon_path) {
        return NULL;
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -52,11 +52,8 @@ is_shortcut_mod(struct sc_input_manager *im, uint16_t sdl_mod) {
 void
 sc_input_manager_init(struct sc_input_manager *im,
                      const struct sc_input_manager_params *params) {
-    // A key/mouse processor may not be present if there is no controller
-    assert((!params->kp && !params->mp) || params->controller);
-    // A processor must have ops initialized
-    assert(!params->kp || params->kp->ops);
-    assert(!params->mp || params->mp->ops);
+    assert(!params->controller || (params->kp && params->kp->ops));
+    assert(!params->controller || (params->mp && params->mp->ops));

    im->controller = params->controller;
    im->fp = params->fp;
@ -79,8 +76,6 @@ sc_input_manager_init(struct sc_input_manager *im,
    im->sdl_shortcut_mods.count = shortcut_mods->count;

    im->vfinger_down = false;
-    im->vfinger_invert_x = false;
-    im->vfinger_invert_y = false;

    im->last_keycode = SDLK_UNKNOWN;
    im->last_mod = 0;
@ -90,10 +85,8 @@ sc_input_manager_init(struct sc_input_manager *im,
 }

 static void
-send_keycode(struct sc_input_manager *im, enum android_keycode keycode,
+send_keycode(struct sc_controller *controller, enum android_keycode keycode,
             enum sc_action action, const char *name) {
-    assert(im->controller && im->kp);
-
    // send DOWN event
    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
@ -104,109 +97,100 @@ send_keycode(struct sc_input_manager *im, enum android_keycode keycode,
    msg.inject_keycode.metastate = 0;
    msg.inject_keycode.repeat = 0;

-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'inject %s'", name);
    }
 }

 static inline void
-action_home(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_HOME, action, "HOME");
+action_home(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_HOME, action, "HOME");
 }

 static inline void
-action_back(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_BACK, action, "BACK");
+action_back(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_BACK, action, "BACK");
 }

 static inline void
-action_app_switch(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_APP_SWITCH, action, "APP_SWITCH");
+action_app_switch(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_APP_SWITCH, action, "APP_SWITCH");
 }

 static inline void
-action_power(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_POWER, action, "POWER");
+action_power(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_POWER, action, "POWER");
 }

 static inline void
-action_volume_up(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_VOLUME_UP, action, "VOLUME_UP");
+action_volume_up(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_VOLUME_UP, action, "VOLUME_UP");
 }

 static inline void
-action_volume_down(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_VOLUME_DOWN, action, "VOLUME_DOWN");
+action_volume_down(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_VOLUME_DOWN, action, "VOLUME_DOWN");
 }

 static inline void
-action_menu(struct sc_input_manager *im, enum sc_action action) {
-    send_keycode(im, AKEYCODE_MENU, action, "MENU");
+action_menu(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_MENU, action, "MENU");
 }

 // turn the screen on if it was off, press BACK otherwise
 // If the screen is off, it is turned on only on ACTION_DOWN
 static void
-press_back_or_turn_screen_on(struct sc_input_manager *im,
+press_back_or_turn_screen_on(struct sc_controller *controller,
                             enum sc_action action) {
-    assert(im->controller && im->kp);
-
    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
    msg.back_or_screen_on.action = action == SC_ACTION_DOWN
                                 ? AKEY_EVENT_ACTION_DOWN
                                 : AKEY_EVENT_ACTION_UP;

-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'press back or turn screen on'");
    }
 }

 static void
-expand_notification_panel(struct sc_input_manager *im) {
-    assert(im->controller);
-
+expand_notification_panel(struct sc_controller *controller) {
    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;

-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'expand notification panel'");
    }
 }

 static void
-expand_settings_panel(struct sc_input_manager *im) {
-    assert(im->controller);
-
+expand_settings_panel(struct sc_controller *controller) {
    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;

-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'expand settings panel'");
    }
 }

 static void
-collapse_panels(struct sc_input_manager *im) {
-    assert(im->controller);
-
+collapse_panels(struct sc_controller *controller) {
    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS;

-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'collapse notification panel'");
    }
 }

 static bool
-get_device_clipboard(struct sc_input_manager *im, enum sc_copy_key copy_key) {
-    assert(im->controller && im->kp);
-
+get_device_clipboard(struct sc_controller *controller,
+                     enum sc_copy_key copy_key) {
    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD;
    msg.get_clipboard.copy_key = copy_key;

-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'get device clipboard'");
        return false;
    }
@ -215,10 +199,8 @@ get_device_clipboard(struct sc_input_manager *im, enum sc_copy_key copy_key) {
 }

 static bool
-set_device_clipboard(struct sc_input_manager *im, bool paste,
+set_device_clipboard(struct sc_controller *controller, bool paste,
                     uint64_t sequence) {
-    assert(im->controller && im->kp);
-
    char *text = SDL_GetClipboardText();
    if (!text) {
        LOGW("Could not get clipboard text: %s", SDL_GetError());
@ -238,7 +220,7 @@ set_device_clipboard(struct sc_input_manager *im, bool paste,
    msg.set_clipboard.text = text_dup;
    msg.set_clipboard.paste = paste;

-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
        free(text_dup);
        LOGW("Could not request 'set device clipboard'");
        return false;
@ -248,23 +230,19 @@ set_device_clipboard(struct sc_input_manager *im, bool paste,
 }

 static void
-set_screen_power_mode(struct sc_input_manager *im,
+set_screen_power_mode(struct sc_controller *controller,
                      enum sc_screen_power_mode mode) {
-    assert(im->controller);
-
    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
    msg.set_screen_power_mode.mode = mode;

-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'set screen power mode'");
    }
 }

 static void
-switch_fps_counter_state(struct sc_input_manager *im) {
-    struct sc_fps_counter *fps_counter = &im->screen->fps_counter;
-
+switch_fps_counter_state(struct sc_fps_counter *fps_counter) {
    // the started state can only be written from the current thread, so there
    // is no ToCToU issue
    if (sc_fps_counter_is_started(fps_counter)) {
@ -276,9 +254,7 @@ switch_fps_counter_state(struct sc_input_manager *im) {
 }

 static void
-clipboard_paste(struct sc_input_manager *im) {
-    assert(im->controller && im->kp);
-
+clipboard_paste(struct sc_controller *controller) {
    char *text = SDL_GetClipboardText();
    if (!text) {
        LOGW("Could not get clipboard text: %s", SDL_GetError());
@ -300,43 +276,32 @@ clipboard_paste(struct sc_input_manager *im) {
    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
    msg.inject_text.text = text_dup;
-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
        free(text_dup);
        LOGW("Could not request 'paste clipboard'");
    }
 }

 static void
-rotate_device(struct sc_input_manager *im) {
-    assert(im->controller);
-
+rotate_device(struct sc_controller *controller) {
    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE;

-    if (!sc_controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
        LOGW("Could not request device rotation");
    }
 }

 static void
-open_hard_keyboard_settings(struct sc_input_manager *im) {
-    assert(im->controller);
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS;
-
-    if (!sc_controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request opening hard keyboard settings");
-    }
+rotate_client_left(struct sc_screen *screen) {
+    unsigned new_rotation = (screen->rotation + 1) % 4;
+    sc_screen_set_rotation(screen, new_rotation);
 }

 static void
-apply_orientation_transform(struct sc_input_manager *im,
-                            enum sc_orientation transform) {
-    struct sc_screen *screen = im->screen;
-    enum sc_orientation new_orientation =
-        sc_orientation_apply(screen->orientation, transform);
-    sc_screen_set_orientation(screen, new_orientation);
+rotate_client_right(struct sc_screen *screen) {
+    unsigned new_rotation = (screen->rotation + 3) % 4;
+    sc_screen_set_rotation(screen, new_rotation);
 }

 static void
@ -386,14 +351,9 @@ simulate_virtual_finger(struct sc_input_manager *im,
 }

 static struct sc_point
-inverse_point(struct sc_point point, struct sc_size size,
-              bool invert_x, bool invert_y) {
-    if (invert_x) {
-        point.x = size.width - point.x;
-    }
-    if (invert_y) {
-        point.y = size.height - point.y;
-    }
+inverse_point(struct sc_point point, struct sc_size size) {
+    point.x = size.width - point.x;
+    point.y = size.height - point.y;
    return point;
 }

@ -401,7 +361,7 @@ static void
 sc_input_manager_process_key(struct sc_input_manager *im,
                             const SDL_KeyboardEvent *event) {
    // controller is NULL if --no-control is requested
-    bool control = im->controller;
+    struct sc_controller *controller = im->controller;

    SDL_Keycode keycode = event->keysym.sym;
    uint16_t mod = event->keysym.mod;
@ -427,102 +387,81 @@ sc_input_manager_process_key(struct sc_input_manager *im,
        enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
        switch (keycode) {
            case SDLK_h:
-                if (im->kp && !shift && !repeat) {
-                    action_home(im, action);
+                if (controller && !shift && !repeat) {
+                    action_home(controller, action);
                }
                return;
            case SDLK_b: // fall-through
            case SDLK_BACKSPACE:
-                if (im->kp && !shift && !repeat) {
-                    action_back(im, action);
+                if (controller && !shift && !repeat) {
+                    action_back(controller, action);
                }
                return;
            case SDLK_s:
-                if (im->kp && !shift && !repeat) {
-                    action_app_switch(im, action);
+                if (controller && !shift && !repeat) {
+                    action_app_switch(controller, action);
                }
                return;
            case SDLK_m:
-                if (im->kp && !shift && !repeat) {
-                    action_menu(im, action);
+                if (controller && !shift && !repeat) {
+                    action_menu(controller, action);
                }
                return;
            case SDLK_p:
-                if (im->kp && !shift && !repeat) {
-                    action_power(im, action);
+                if (controller && !shift && !repeat) {
+                    action_power(controller, action);
                }
                return;
            case SDLK_o:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                    enum sc_screen_power_mode mode = shift
                                                   ? SC_SCREEN_POWER_MODE_NORMAL
                                                   : SC_SCREEN_POWER_MODE_OFF;
-                    set_screen_power_mode(im, mode);
+                    set_screen_power_mode(controller, mode);
                }
                return;
            case SDLK_DOWN:
-                if (shift) {
-                    if (!repeat & down) {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_FLIP_180);
-                    }
-                } else if (im->kp) {
+                if (controller && !shift) {
                    // forward repeated events
-                    action_volume_down(im, action);
+                    action_volume_down(controller, action);
                }
                return;
            case SDLK_UP:
-                if (shift) {
-                    if (!repeat & down) {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_FLIP_180);
-                    }
-                } else if (im->kp) {
+                if (controller && !shift) {
                    // forward repeated events
-                    action_volume_up(im, action);
+                    action_volume_up(controller, action);
                }
                return;
            case SDLK_LEFT:
-                if (!repeat && down) {
-                    if (shift) {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_FLIP_0);
-                    } else {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_270);
-                    }
+                if (!shift && !repeat && down) {
+                    rotate_client_left(im->screen);
                }
                return;
            case SDLK_RIGHT:
-                if (!repeat && down) {
-                    if (shift) {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_FLIP_0);
-                    } else {
-                        apply_orientation_transform(im,
-                                                    SC_ORIENTATION_90);
-                    }
+                if (!shift && !repeat && down) {
+                    rotate_client_right(im->screen);
                }
                return;
            case SDLK_c:
-                if (im->kp && !shift && !repeat && down) {
-                    get_device_clipboard(im, SC_COPY_KEY_COPY);
+                if (controller && !shift && !repeat && down) {
+                    get_device_clipboard(controller, SC_COPY_KEY_COPY);
                }
                return;
            case SDLK_x:
-                if (im->kp && !shift && !repeat && down) {
-                    get_device_clipboard(im, SC_COPY_KEY_CUT);
+                if (controller && !shift && !repeat && down) {
+                    get_device_clipboard(controller, SC_COPY_KEY_CUT);
                }
                return;
            case SDLK_v:
-                if (im->kp && !repeat && down) {
+                if (controller && !repeat && down) {
                    if (shift || im->legacy_paste) {
                        // inject the text as input events
-                        clipboard_paste(im);
+                        clipboard_paste(controller);
                    } else {
                        // store the text in the device clipboard and paste,
                        // without requesting an acknowledgment
-                        set_device_clipboard(im, true, SC_SEQUENCE_INVALID);
+                        set_device_clipboard(controller, true,
+                                             SC_SEQUENCE_INVALID);
                    }
                }
                return;
@ -543,30 +482,23 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                return;
            case SDLK_i:
                if (!shift && !repeat && down) {
-                    switch_fps_counter_state(im);
+                    switch_fps_counter_state(&im->screen->fps_counter);
                }
                return;
            case SDLK_n:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                    if (shift) {
-                        collapse_panels(im);
+                        collapse_panels(controller);
                    } else if (im->key_repeat == 0) {
-                        expand_notification_panel(im);
+                        expand_notification_panel(controller);
                    } else {
-                        expand_settings_panel(im);
+                        expand_settings_panel(controller);
                    }
                }
                return;
            case SDLK_r:
-                if (control && !shift && !repeat && down) {
-                    rotate_device(im);
-                }
-                return;
-            case SDLK_k:
-                if (control && !shift && !repeat && down
-                        && im->kp && im->kp->hid) {
-                    // Only if the current keyboard is hid
-                    open_hard_keyboard_settings(im);
+                if (controller && !shift && !repeat && down) {
+                    rotate_device(controller);
                }
                return;
        }
@ -574,7 +506,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
        return;
    }

-    if (!im->kp) {
+    if (!controller) {
        return;
    }

@ -583,7 +515,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
    if (im->clipboard_autosync && is_ctrl_v) {
        if (im->legacy_paste) {
            // inject the text as input events
-            clipboard_paste(im);
+            clipboard_paste(controller);
            return;
        }

@ -593,7 +525,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,

        // Synchronize the computer clipboard to the device clipboard before
        // sending Ctrl+v, to allow seamless copy-paste.
-        bool ok = set_device_clipboard(im, false, sequence);
+        bool ok = set_device_clipboard(controller, false, sequence);
        if (!ok) {
            LOGW("Clipboard could not be synchronized, Ctrl+v not injected");
            return;
@ -655,9 +587,7 @@ sc_input_manager_process_mouse_motion(struct sc_input_manager *im,
        struct sc_point mouse =
           sc_screen_convert_window_to_frame_coords(im->screen, event->x,
                                                    event->y);
-        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size,
-                                                im->vfinger_invert_x,
-                                                im->vfinger_invert_y);
+        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
        simulate_virtual_finger(im, AMOTION_EVENT_ACTION_MOVE, vfinger);
    }
 }
@ -695,7 +625,7 @@ sc_input_manager_process_touch(struct sc_input_manager *im,
 static void
 sc_input_manager_process_mouse_button(struct sc_input_manager *im,
                                      const SDL_MouseButtonEvent *event) {
-    bool control = im->controller;
+    struct sc_controller *controller = im->controller;

    if (event->which == SDL_TOUCH_MOUSEID) {
        // simulated from touch events, so it's a duplicate
@ -704,27 +634,27 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,

    bool down = event->type == SDL_MOUSEBUTTONDOWN;
    if (!im->forward_all_clicks) {
-        if (control) {
+        if (controller) {
            enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;

-            if (im->kp && event->button == SDL_BUTTON_X1) {
-                action_app_switch(im, action);
+            if (event->button == SDL_BUTTON_X1) {
+                action_app_switch(controller, action);
                return;
            }
            if (event->button == SDL_BUTTON_X2 && down) {
                if (event->clicks < 2) {
-                    expand_notification_panel(im);
+                    expand_notification_panel(controller);
                } else {
-                    expand_settings_panel(im);
+                    expand_settings_panel(controller);
                }
                return;
            }
-            if (im->kp && event->button == SDL_BUTTON_RIGHT) {
-                press_back_or_turn_screen_on(im, action);
+            if (event->button == SDL_BUTTON_RIGHT) {
+                press_back_or_turn_screen_on(controller, action);
                return;
            }
-            if (im->kp && event->button == SDL_BUTTON_MIDDLE) {
-                action_home(im, action);
+            if (event->button == SDL_BUTTON_MIDDLE) {
+                action_home(controller, action);
                return;
            }
        }
@ -747,7 +677,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
        // otherwise, send the click event to the device
    }

-    if (!im->mp) {
+    if (!controller) {
        return;
    }

@ -778,7 +708,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
        return;
    }

-    // Pinch-to-zoom, rotate and tilt simulation.
+    // Pinch-to-zoom simulation.
    //
    // If Ctrl is hold when the left-click button is pressed, then
    // pinch-to-zoom mode is enabled: on every mouse event until the left-click
@ -787,29 +717,14 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
    //
    // In other words, the center of the rotation/scaling is the center of the
    // screen.
-    //
-    // To simulate a tilt gesture (a vertical slide with two fingers), Shift
-    // can be used instead of Ctrl. The "virtual finger" has a position
-    // inverted with respect to the vertical axis of symmetry in the middle of
-    // the screen.
-    const SDL_Keymod keymod = SDL_GetModState();
-    const bool ctrl_pressed = keymod & KMOD_CTRL;
-    const bool shift_pressed = keymod & KMOD_SHIFT;
+#define CTRL_PRESSED (SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL))
    if (event->button == SDL_BUTTON_LEFT &&
-            ((down && !im->vfinger_down &&
-              ((ctrl_pressed && !shift_pressed) ||
-               (!ctrl_pressed && shift_pressed))) ||
+            ((down && !im->vfinger_down && CTRL_PRESSED) ||
             (!down && im->vfinger_down))) {
        struct sc_point mouse =
            sc_screen_convert_window_to_frame_coords(im->screen, event->x,
                                                                 event->y);
-        if (down) {
-            im->vfinger_invert_x = ctrl_pressed || shift_pressed;
-            im->vfinger_invert_y = ctrl_pressed;
-        }
-        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size,
-                                                im->vfinger_invert_x,
-                                                im->vfinger_invert_y);
+        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
        enum android_motionevent_action action = down
                                               ? AMOTION_EVENT_ACTION_DOWN
                                               : AMOTION_EVENT_ACTION_UP;
@ -887,7 +802,7 @@ sc_input_manager_handle_event(struct sc_input_manager *im,
    bool control = im->controller;
    switch (event->type) {
        case SDL_TEXTINPUT:
-            if (!im->kp) {
+            if (!control) {
                break;
            }
            sc_input_manager_process_text_input(im, &event->text);
@ -899,13 +814,13 @@ sc_input_manager_handle_event(struct sc_input_manager *im,
            sc_input_manager_process_key(im, &event->key);
            break;
        case SDL_MOUSEMOTION:
-            if (!im->mp) {
+            if (!control) {
                break;
            }
            sc_input_manager_process_mouse_motion(im, &event->motion);
            break;
        case SDL_MOUSEWHEEL:
-            if (!im->mp) {
+            if (!control) {
                break;
            }
            sc_input_manager_process_mouse_wheel(im, &event->wheel);
@ -919,7 +834,7 @@ sc_input_manager_handle_event(struct sc_input_manager *im,
        case SDL_FINGERMOTION:
        case SDL_FINGERDOWN:
        case SDL_FINGERUP:
-            if (!im->mp) {
+            if (!control) {
                break;
            }
            sc_input_manager_process_touch(im, &event->tfinger);
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@ -32,8 +32,6 @@ struct sc_input_manager {
    } sdl_shortcut_mods;

    bool vfinger_down;
-    bool vfinger_invert_x;
-    bool vfinger_invert_y;

    // Tracks the number of identical consecutive shortcut key down events.
    // Not to be confused with event->repeat, which counts the number of
--- a/app/src/keyboard_inject.c
+++ b/app/src/keyboard_inject.c
@ -1,4 +1,4 @@
-#include "keyboard_sdk.h"
+#include "keyboard_inject.h"

 #include <assert.h>

@ -9,8 +9,8 @@
 #include "util/intmap.h"
 #include "util/log.h"

-/** Downcast key processor to sc_keyboard_sdk */
-#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_sdk, key_processor)
+/** Downcast key processor to sc_keyboard_inject */
+#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_inject, key_processor)

 static enum android_keyevent_action
 convert_keycode_action(enum sc_action action) {
@ -271,20 +271,20 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
    // is set before injecting Ctrl+v.
    (void) ack_to_wait;

-    struct sc_keyboard_sdk *kb = DOWNCAST(kp);
+    struct sc_keyboard_inject *ki = DOWNCAST(kp);

    if (event->repeat) {
-        if (!kb->forward_key_repeat) {
+        if (!ki->forward_key_repeat) {
            return;
        }
-        ++kb->repeat;
+        ++ki->repeat;
    } else {
-        kb->repeat = 0;
+        ki->repeat = 0;
    }

    struct sc_control_msg msg;
-    if (convert_input_key(event, &msg, kb->key_inject_mode, kb->repeat)) {
-        if (!sc_controller_push_msg(kb->controller, &msg)) {
+    if (convert_input_key(event, &msg, ki->key_inject_mode, ki->repeat)) {
+        if (!sc_controller_push_msg(ki->controller, &msg)) {
            LOGW("Could not request 'inject keycode'");
        }
    }
@ -293,14 +293,14 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
 static void
 sc_key_processor_process_text(struct sc_key_processor *kp,
                              const struct sc_text_event *event) {
-    struct sc_keyboard_sdk *kb = DOWNCAST(kp);
+    struct sc_keyboard_inject *ki = DOWNCAST(kp);

-    if (kb->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
+    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
        // Never inject text events
        return;
    }

-    if (kb->key_inject_mode == SC_KEY_INJECT_MODE_MIXED) {
+    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_MIXED) {
        char c = event->text[0];
        if (isalpha(c) || c == ' ') {
            assert(event->text[1] == '\0');
@ -316,22 +316,22 @@ sc_key_processor_process_text(struct sc_key_processor *kp,
        LOGW("Could not strdup input text");
        return;
    }
-    if (!sc_controller_push_msg(kb->controller, &msg)) {
+    if (!sc_controller_push_msg(ki->controller, &msg)) {
        free(msg.inject_text.text);
        LOGW("Could not request 'inject text'");
    }
 }

 void
-sc_keyboard_sdk_init(struct sc_keyboard_sdk *kb,
-                     struct sc_controller *controller,
-                     enum sc_key_inject_mode key_inject_mode,
-                     bool forward_key_repeat) {
-    kb->controller = controller;
-    kb->key_inject_mode = key_inject_mode;
-    kb->forward_key_repeat = forward_key_repeat;
+sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
+                        struct sc_controller *controller,
+                        enum sc_key_inject_mode key_inject_mode,
+                        bool forward_key_repeat) {
+    ki->controller = controller;
+    ki->key_inject_mode = key_inject_mode;
+    ki->forward_key_repeat = forward_key_repeat;

-    kb->repeat = 0;
+    ki->repeat = 0;

    static const struct sc_key_processor_ops ops = {
        .process_key = sc_key_processor_process_key,
@ -339,7 +339,6 @@ sc_keyboard_sdk_init(struct sc_keyboard_sdk *kb,
    };

    // Key injection and clipboard synchronization are serialized
-    kb->key_processor.async_paste = false;
-    kb->key_processor.hid = false;
-    kb->key_processor.ops = &ops;
+    ki->key_processor.async_paste = false;
+    ki->key_processor.ops = &ops;
 }
--- a/app/src/keyboard_inject.h
+++ b/app/src/keyboard_inject.h
@ -1,5 +1,5 @@
-#ifndef SC_KEYBOARD_SDK_H
-#define SC_KEYBOARD_SDK_H
+#ifndef SC_KEYBOARD_INJECT_H
+#define SC_KEYBOARD_INJECT_H

 #include "common.h"

@ -9,7 +9,7 @@
 #include "options.h"
 #include "trait/key_processor.h"

-struct sc_keyboard_sdk {
+struct sc_keyboard_inject {
    struct sc_key_processor key_processor; // key processor trait

    struct sc_controller *controller;
@ -23,9 +23,9 @@ struct sc_keyboard_sdk {
 };

 void
-sc_keyboard_sdk_init(struct sc_keyboard_sdk *kb,
-                     struct sc_controller *controller,
-                     enum sc_key_inject_mode key_inject_mode,
-                     bool forward_key_repeat);
+sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
+                        struct sc_controller *controller,
+                        enum sc_key_inject_mode key_inject_mode,
+                        bool forward_key_repeat);

 #endif
--- a/app/src/main.c
+++ b/app/src/main.c
@ -23,7 +23,7 @@
 #include "util/str.h"
 #endif

-static int
+int
 main_scrcpy(int argc, char *argv[]) {
 #ifdef _WIN32
    // disable buffering, we want logs immediately
@ -39,32 +39,26 @@ main_scrcpy(int argc, char *argv[]) {
        .opts = scrcpy_options_default,
        .help = false,
        .version = false,
-        .pause_on_exit = SC_PAUSE_ON_EXIT_FALSE,
    };

 #ifndef NDEBUG
    args.opts.log_level = SC_LOG_LEVEL_DEBUG;
 #endif

-    enum scrcpy_exit_code ret;
-
    if (!scrcpy_parse_args(&args, argc, argv)) {
-        ret = SCRCPY_EXIT_FAILURE;
-        goto end;
+        return SCRCPY_EXIT_FAILURE;
    }

    sc_set_log_level(args.opts.log_level);

    if (args.help) {
        scrcpy_print_usage(argv[0]);
-        ret = SCRCPY_EXIT_SUCCESS;
-        goto end;
+        return SCRCPY_EXIT_SUCCESS;
    }

    if (args.version) {
        scrcpy_print_version();
-        ret = SCRCPY_EXIT_SUCCESS;
-        goto end;
+        return SCRCPY_EXIT_SUCCESS;
    }

 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
@ -78,26 +72,18 @@ main_scrcpy(int argc, char *argv[]) {
 #endif

    if (!net_init()) {
-        ret = SCRCPY_EXIT_FAILURE;
-        goto end;
+        return SCRCPY_EXIT_FAILURE;
    }

    sc_log_configure();

 #ifdef HAVE_USB
-    ret = args.opts.otg ? scrcpy_otg(&args.opts) : scrcpy(&args.opts);
+    enum scrcpy_exit_code ret = args.opts.otg ? scrcpy_otg(&args.opts)
+                                              : scrcpy(&args.opts);
 #else
-    ret = scrcpy(&args.opts);
+    enum scrcpy_exit_code ret = scrcpy(&args.opts);
 #endif

-end:
-    if (args.pause_on_exit == SC_PAUSE_ON_EXIT_TRUE ||
-            (args.pause_on_exit == SC_PAUSE_ON_EXIT_IF_ERROR &&
-                ret != SCRCPY_EXIT_SUCCESS)) {
-        printf("Press Enter to continue...\n");
-        getchar();
-    }
-
    return ret;
 }

--- a/app/src/mouse_inject.c
+++ b/app/src/mouse_inject.c
@ -1,4 +1,4 @@
-#include "mouse_sdk.h"
+#include "mouse_inject.h"

 #include <assert.h>

@ -9,8 +9,8 @@
 #include "util/intmap.h"
 #include "util/log.h"

-/** Downcast mouse processor to sc_mouse_sdk */
-#define DOWNCAST(MP) container_of(MP, struct sc_mouse_sdk, mouse_processor)
+/** 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) {
@ -63,7 +63,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
        return;
    }

-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);

    struct sc_control_msg msg = {
        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
@ -76,7 +76,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
        },
    };

-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
        LOGW("Could not request 'inject mouse motion event'");
    }
 }
@ -84,7 +84,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
 static void
 sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
                                    const struct sc_mouse_click_event *event) {
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);

    struct sc_control_msg msg = {
        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
@ -98,7 +98,7 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
        },
    };

-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
        LOGW("Could not request 'inject mouse click event'");
    }
 }
@ -106,7 +106,7 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
 static void
 sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
                                   const struct sc_mouse_scroll_event *event) {
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);

    struct sc_control_msg msg = {
        .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
@ -118,7 +118,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
        },
    };

-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
        LOGW("Could not request 'inject mouse scroll event'");
    }
 }
@ -126,7 +126,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
 static void
 sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
                                 const struct sc_touch_event *event) {
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);

    struct sc_control_msg msg = {
        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
@ -139,14 +139,15 @@ sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
        },
    };

-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
        LOGW("Could not request 'inject touch event'");
    }
 }

 void
-sc_mouse_sdk_init(struct sc_mouse_sdk *m, struct sc_controller *controller) {
-    m->controller = controller;
+sc_mouse_inject_init(struct sc_mouse_inject *mi,
+                     struct sc_controller *controller) {
+    mi->controller = controller;

    static const struct sc_mouse_processor_ops ops = {
        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
@ -155,7 +156,7 @@ sc_mouse_sdk_init(struct sc_mouse_sdk *m, struct sc_controller *controller) {
        .process_touch = sc_mouse_processor_process_touch,
    };

-    m->mouse_processor.ops = &ops;
+    mi->mouse_processor.ops = &ops;

-    m->mouse_processor.relative_mode = false;
+    mi->mouse_processor.relative_mode = false;
 }
--- a/app/src/mouse_inject.h
+++ b/app/src/mouse_inject.h
@ -1,5 +1,5 @@
-#ifndef SC_MOUSE_SDK_H
-#define SC_MOUSE_SDK_H
+#ifndef SC_MOUSE_INJECT_H
+#define SC_MOUSE_INJECT_H

 #include "common.h"

@ -9,13 +9,14 @@
 #include "screen.h"
 #include "trait/mouse_processor.h"

-struct sc_mouse_sdk {
+struct sc_mouse_inject {
    struct sc_mouse_processor mouse_processor; // mouse processor trait

    struct sc_controller *controller;
 };

 void
-sc_mouse_sdk_init(struct sc_mouse_sdk *m, struct sc_controller *controller);
+sc_mouse_inject_init(struct sc_mouse_inject *mi,
+                     struct sc_controller *controller);

 #endif
--- a/app/src/options.c
+++ b/app/src/options.c
@ -11,19 +11,13 @@ const struct scrcpy_options scrcpy_options_default = {
    .audio_codec_options = NULL,
    .video_encoder = NULL,
    .audio_encoder = NULL,
-    .camera_id = NULL,
-    .camera_size = NULL,
-    .camera_ar = NULL,
-    .camera_fps = 0,
    .log_level = SC_LOG_LEVEL_INFO,
    .video_codec = SC_CODEC_H264,
    .audio_codec = SC_CODEC_OPUS,
-    .video_source = SC_VIDEO_SOURCE_DISPLAY,
-    .audio_source = SC_AUDIO_SOURCE_AUTO,
+    .audio_source = SC_AUDIO_SOURCE_OUTPUT,
    .record_format = SC_RECORD_FORMAT_AUTO,
-    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_AUTO,
-    .mouse_input_mode = SC_MOUSE_INPUT_MODE_AUTO,
-    .camera_facing = SC_CAMERA_FACING_ANY,
+    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
+    .mouse_input_mode = SC_MOUSE_INPUT_MODE_INJECT,
    .port_range = {
        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
        .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
@ -39,15 +33,14 @@ const struct scrcpy_options scrcpy_options_default = {
    .audio_bit_rate = 0,
    .max_fps = 0,
    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
-    .display_orientation = SC_ORIENTATION_0,
-    .record_orientation = SC_ORIENTATION_0,
+    .rotation = 0,
    .window_x = SC_WINDOW_POSITION_UNDEFINED,
    .window_y = SC_WINDOW_POSITION_UNDEFINED,
    .window_width = 0,
    .window_height = 0,
    .display_id = 0,
    .display_buffer = 0,
-    .audio_buffer = -1, // depends on the audio format,
+    .audio_buffer = SC_TICK_FROM_MS(50),
    .audio_output_buffer = SC_TICK_FROM_MS(5),
    .time_limit = 0,
 #ifdef HAVE_V4L2
@ -86,43 +79,7 @@ const struct scrcpy_options scrcpy_options_default = {
    .video = true,
    .audio = true,
    .require_audio = false,
+    .list_encoders = false,
+    .list_displays = false,
    .kill_adb_on_close = false,
-    .camera_high_speed = false,
-    .list = 0,
 };
-
-enum sc_orientation
-sc_orientation_apply(enum sc_orientation src, enum sc_orientation transform) {
-    assert(!(src & ~7));
-    assert(!(transform & ~7));
-
-    unsigned transform_hflip = transform & 4;
-    unsigned transform_rotation = transform & 3;
-    unsigned src_hflip = src & 4;
-    unsigned src_rotation = src & 3;
-    unsigned src_swap = src & 1;
-    if (src_swap && transform_hflip) {
-        // If the src is rotated by 90 or 270 degrees, applying a flipped
-        // transformation requires an additional 180 degrees rotation to
-        // compensate for the inversion of the order of multiplication:
-        //
-        //     hflip1 × rotate1 × hflip2 × rotate2
-        //     `--------------'   `--------------'
-        //           src             transform
-        //
-        // In the final result, we want all the hflips then all the rotations,
-        // so we must move hflip2 to the left:
-        //
-        //     hflip1 × hflip2 × rotate1' × rotate2
-        //
-        // with rotate1' = | rotate1           if src is 0° or 180°
-        //                 | rotate1 + 180°    if src is 90° or 270°
-
-        src_rotation += 2;
-    }
-
-    unsigned result_hflip = src_hflip ^ transform_hflip;
-    unsigned result_rotation = (transform_rotation + src_rotation) % 4;
-    enum sc_orientation result = result_hflip | result_rotation;
-    return result;
-}
--- a/app/src/options.h
+++ b/app/src/options.h
@ -3,7 +3,6 @@

 #include "common.h"

-#include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@ -26,8 +25,6 @@ enum sc_record_format {
    SC_RECORD_FORMAT_MKA,
    SC_RECORD_FORMAT_OPUS,
    SC_RECORD_FORMAT_AAC,
-    SC_RECORD_FORMAT_FLAC,
-    SC_RECORD_FORMAT_WAV,
 };

 static inline bool
@ -35,9 +32,7 @@ sc_record_format_is_audio_only(enum sc_record_format fmt) {
    return fmt == SC_RECORD_FORMAT_M4A
        || fmt == SC_RECORD_FORMAT_MKA
        || fmt == SC_RECORD_FORMAT_OPUS
-        || fmt == SC_RECORD_FORMAT_AAC
-        || fmt == SC_RECORD_FORMAT_FLAC
-        || fmt == SC_RECORD_FORMAT_WAV;
+        || fmt == SC_RECORD_FORMAT_AAC;
 }

 enum sc_codec {
@ -46,113 +41,32 @@ enum sc_codec {
    SC_CODEC_AV1,
    SC_CODEC_OPUS,
    SC_CODEC_AAC,
-    SC_CODEC_FLAC,
    SC_CODEC_RAW,
 };

-enum sc_video_source {
-    SC_VIDEO_SOURCE_DISPLAY,
-    SC_VIDEO_SOURCE_CAMERA,
-};
-
 enum sc_audio_source {
-    SC_AUDIO_SOURCE_AUTO, // OUTPUT for video DISPLAY, MIC for video CAMERA
    SC_AUDIO_SOURCE_OUTPUT,
    SC_AUDIO_SOURCE_MIC,
 };

-enum sc_camera_facing {
-    SC_CAMERA_FACING_ANY,
-    SC_CAMERA_FACING_FRONT,
-    SC_CAMERA_FACING_BACK,
-    SC_CAMERA_FACING_EXTERNAL,
-};
-
-                              // ,----- hflip (applied before the rotation)
-                              // | ,--- 180°
-                              // | | ,- 90° clockwise
-                              // | | |
-enum sc_orientation {         // v v v
-    SC_ORIENTATION_0,         // 0 0 0
-    SC_ORIENTATION_90,        // 0 0 1
-    SC_ORIENTATION_180,       // 0 1 0
-    SC_ORIENTATION_270,       // 0 1 1
-    SC_ORIENTATION_FLIP_0,    // 1 0 0
-    SC_ORIENTATION_FLIP_90,   // 1 0 1
-    SC_ORIENTATION_FLIP_180,  // 1 1 0
-    SC_ORIENTATION_FLIP_270,  // 1 1 1
-};
-
-static inline bool
-sc_orientation_is_mirror(enum sc_orientation orientation) {
-    assert(!(orientation & ~7));
-    return orientation & 4;
-}
-
-// Does the orientation swap width and height?
-static inline bool
-sc_orientation_is_swap(enum sc_orientation orientation) {
-    assert(!(orientation & ~7));
-    return orientation & 1;
-}
-
-static inline enum sc_orientation
-sc_orientation_get_rotation(enum sc_orientation orientation) {
-    assert(!(orientation & ~7));
-    return orientation & 3;
-}
-
-enum sc_orientation
-sc_orientation_apply(enum sc_orientation src, enum sc_orientation transform);
-
-static inline const char *
-sc_orientation_get_name(enum sc_orientation orientation) {
-    switch (orientation) {
-        case SC_ORIENTATION_0:
-            return "0";
-        case SC_ORIENTATION_90:
-            return "90";
-        case SC_ORIENTATION_180:
-            return "180";
-        case SC_ORIENTATION_270:
-            return "270";
-        case SC_ORIENTATION_FLIP_0:
-            return "flip0";
-        case SC_ORIENTATION_FLIP_90:
-            return "flip90";
-        case SC_ORIENTATION_FLIP_180:
-            return "flip180";
-        case SC_ORIENTATION_FLIP_270:
-            return "flip270";
-        default:
-            return "(unknown)";
-    }
-}
-
 enum sc_lock_video_orientation {
    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
    // lock the current orientation when scrcpy starts
    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
-    SC_LOCK_VIDEO_ORIENTATION_90 = 3,
-    SC_LOCK_VIDEO_ORIENTATION_180 = 2,
-    SC_LOCK_VIDEO_ORIENTATION_270 = 1,
+    SC_LOCK_VIDEO_ORIENTATION_1,
+    SC_LOCK_VIDEO_ORIENTATION_2,
+    SC_LOCK_VIDEO_ORIENTATION_3,
 };

 enum sc_keyboard_input_mode {
-    SC_KEYBOARD_INPUT_MODE_AUTO,
-    SC_KEYBOARD_INPUT_MODE_DISABLED,
-    SC_KEYBOARD_INPUT_MODE_SDK,
-    SC_KEYBOARD_INPUT_MODE_UHID,
-    SC_KEYBOARD_INPUT_MODE_AOA,
+    SC_KEYBOARD_INPUT_MODE_INJECT,
+    SC_KEYBOARD_INPUT_MODE_HID,
 };

 enum sc_mouse_input_mode {
-    SC_MOUSE_INPUT_MODE_AUTO,
-    SC_MOUSE_INPUT_MODE_DISABLED,
-    SC_MOUSE_INPUT_MODE_SDK,
-    SC_MOUSE_INPUT_MODE_UHID,
-    SC_MOUSE_INPUT_MODE_AOA,
+    SC_MOUSE_INPUT_MODE_INJECT,
+    SC_MOUSE_INPUT_MODE_HID,
 };

 enum sc_key_inject_mode {
@ -203,19 +117,13 @@ struct scrcpy_options {
    const char *audio_codec_options;
    const char *video_encoder;
    const char *audio_encoder;
-    const char *camera_id;
-    const char *camera_size;
-    const char *camera_ar;
-    uint16_t camera_fps;
    enum sc_log_level log_level;
    enum sc_codec video_codec;
    enum sc_codec audio_codec;
-    enum sc_video_source video_source;
    enum sc_audio_source audio_source;
    enum sc_record_format record_format;
    enum sc_keyboard_input_mode keyboard_input_mode;
    enum sc_mouse_input_mode mouse_input_mode;
-    enum sc_camera_facing camera_facing;
    struct sc_port_range port_range;
    uint32_t tunnel_host;
    uint16_t tunnel_port;
@ -225,8 +133,7 @@ struct scrcpy_options {
    uint32_t audio_bit_rate;
    uint16_t max_fps;
    enum sc_lock_video_orientation lock_video_orientation;
-    enum sc_orientation display_orientation;
-    enum sc_orientation record_orientation;
+    uint8_t rotation;
    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    uint16_t window_width;
@ -272,13 +179,9 @@ struct scrcpy_options {
    bool video;
    bool audio;
    bool require_audio;
+    bool list_encoders;
+    bool list_displays;
    bool kill_adb_on_close;
-    bool camera_high_speed;
-#define SC_OPTION_LIST_ENCODERS 0x1
-#define SC_OPTION_LIST_DISPLAYS 0x2
-#define SC_OPTION_LIST_CAMERAS 0x4
-#define SC_OPTION_LIST_CAMERA_SIZES 0x8
-    uint8_t list;
 };

 extern const struct scrcpy_options scrcpy_options_default;
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@ -1,24 +1,21 @@
 #include "receiver.h"

 #include <assert.h>
-#include <inttypes.h>
-#include <stdint.h>
 #include <SDL2/SDL_clipboard.h>

 #include "device_msg.h"
 #include "util/log.h"
-#include "util/str.h"

 bool
-sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket) {
+sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
+              struct sc_acksync *acksync) {
    bool ok = sc_mutex_init(&receiver->mutex);
    if (!ok) {
        return false;
    }

    receiver->control_socket = control_socket;
-    receiver->acksync = NULL;
-    receiver->uhid_devices = NULL;
+    receiver->acksync = acksync;

    return true;
 }
@ -29,7 +26,7 @@ sc_receiver_destroy(struct sc_receiver *receiver) {
 }

 static void
-process_msg(struct sc_receiver *receiver, struct sc_device_msg *msg) {
+process_msg(struct sc_receiver *receiver, struct device_msg *msg) {
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
            char *current = SDL_GetClipboardText();
@ -45,65 +42,20 @@ process_msg(struct sc_receiver *receiver, struct sc_device_msg *msg) {
            break;
        }
        case DEVICE_MSG_TYPE_ACK_CLIPBOARD:
+            assert(receiver->acksync);
            LOGD("Ack device clipboard sequence=%" PRIu64_,
                 msg->ack_clipboard.sequence);
-
-            // This is a programming error to receive this message if there is
-            // no ACK synchronization mechanism
-            assert(receiver->acksync);
-
-            // Also check at runtime (do not trust the server)
-            if (!receiver->acksync) {
-                LOGE("Received unexpected ack");
-                return;
-            }
-
            sc_acksync_ack(receiver->acksync, msg->ack_clipboard.sequence);
            break;
-        case DEVICE_MSG_TYPE_UHID_OUTPUT:
-            if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
-                char *hex = sc_str_to_hex_string(msg->uhid_output.data,
-                                                 msg->uhid_output.size);
-                if (hex) {
-                    LOGV("UHID output [%" PRIu16 "] %s",
-                         msg->uhid_output.id, hex);
-                    free(hex);
-                } else {
-                    LOGV("UHID output [%" PRIu16 "] size=%" PRIu16,
-                         msg->uhid_output.id, msg->uhid_output.size);
-                }
-            }
-
-            // This is a programming error to receive this message if there is
-            // no uhid_devices instance
-            assert(receiver->uhid_devices);
-
-            // Also check at runtime (do not trust the server)
-            if (!receiver->uhid_devices) {
-                LOGE("Received unexpected HID output message");
-                return;
-            }
-
-            struct sc_uhid_receiver *uhid_receiver =
-                sc_uhid_devices_get_receiver(receiver->uhid_devices,
-                                             msg->uhid_output.id);
-            if (uhid_receiver) {
-                uhid_receiver->ops->process_output(uhid_receiver,
-                                                   msg->uhid_output.data,
-                                                   msg->uhid_output.size);
-            } else {
-                LOGW("No UHID receiver for id %" PRIu16, msg->uhid_output.id);
-            }
-            break;
    }
 }

 static ssize_t
-process_msgs(struct sc_receiver *receiver, const uint8_t *buf, size_t len) {
+process_msgs(struct sc_receiver *receiver, const unsigned char *buf, size_t len) {
    size_t head = 0;
    for (;;) {
-        struct sc_device_msg msg;
-        ssize_t r = sc_device_msg_deserialize(&buf[head], len - head, &msg);
+        struct device_msg msg;
+        ssize_t r = device_msg_deserialize(&buf[head], len - head, &msg);
        if (r == -1) {
            return -1;
        }
@ -112,7 +64,7 @@ process_msgs(struct sc_receiver *receiver, const uint8_t *buf, size_t len) {
        }

        process_msg(receiver, &msg);
-        sc_device_msg_destroy(&msg);
+        device_msg_destroy(&msg);

        head += r;
        assert(head <= len);
@ -126,7 +78,7 @@ static int
 run_receiver(void *data) {
    struct sc_receiver *receiver = data;

-    static uint8_t buf[DEVICE_MSG_MAX_SIZE];
+    static unsigned char buf[DEVICE_MSG_MAX_SIZE];
    size_t head = 0;

    for (;;) {
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@ -5,7 +5,6 @@

 #include <stdbool.h>

-#include "uhid/uhid_output.h"
 #include "util/acksync.h"
 #include "util/net.h"
 #include "util/thread.h"
@ -18,11 +17,11 @@ struct sc_receiver {
    sc_mutex mutex;

    struct sc_acksync *acksync;
-    struct sc_uhid_devices *uhid_devices;
 };

 bool
-sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket);
+sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
+                 struct sc_acksync *acksync);

 void
 sc_receiver_destroy(struct sc_receiver *receiver);
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@ -4,7 +4,6 @@
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
-#include <libavutil/display.h>

 #include "util/log.h"
 #include "util/str.h"
@ -70,10 +69,6 @@ sc_recorder_get_format_name(enum sc_record_format format) {
            return "matroska";
        case SC_RECORD_FORMAT_OPUS:
            return "opus";
-        case SC_RECORD_FORMAT_FLAC:
-            return "flac";
-        case SC_RECORD_FORMAT_WAV:
-            return "wav";
        default:
            return NULL;
    }
@ -106,7 +101,7 @@ sc_recorder_write_stream(struct sc_recorder *recorder,
    AVStream *stream = recorder->ctx->streams[st->index];
    sc_recorder_rescale_packet(stream, packet);
    if (st->last_pts != AV_NOPTS_VALUE && packet->pts <= st->last_pts) {
-        LOGD("Fixing PTS non monotonically increasing in stream %d "
+        LOGW("Fixing PTS non monotonically increasing in stream %d "
             "(%" PRIi64 " >= %" PRIi64 ")",
             st->index, st->last_pts, packet->pts);
        packet->pts = ++st->last_pts;
@ -171,14 +166,13 @@ sc_recorder_close_output_file(struct sc_recorder *recorder) {
 }

 static inline bool
-sc_recorder_must_wait_for_config_packets(struct sc_recorder *recorder) {
+sc_recorder_has_empty_queues(struct sc_recorder *recorder) {
    if (recorder->video && sc_vecdeque_is_empty(&recorder->video_queue)) {
        // The video queue is empty
        return true;
    }

-    if (recorder->audio && recorder->audio_expects_config_packet
-            && sc_vecdeque_is_empty(&recorder->audio_queue)) {
+    if (recorder->audio && sc_vecdeque_is_empty(&recorder->audio_queue)) {
        // The audio queue is empty (when audio is enabled)
        return true;
    }
@ -194,7 +188,7 @@ sc_recorder_process_header(struct sc_recorder *recorder) {
    while (!recorder->stopped &&
              ((recorder->video && !recorder->video_init)
            || (recorder->audio && !recorder->audio_init)
-            || sc_recorder_must_wait_for_config_packets(recorder))) {
+            || sc_recorder_has_empty_queues(recorder))) {
        sc_cond_wait(&recorder->cond, &recorder->mutex);
    }

@ -213,8 +207,7 @@ sc_recorder_process_header(struct sc_recorder *recorder) {
    }

    AVPacket *audio_pkt = NULL;
-    if (recorder->audio_expects_config_packet &&
-            !sc_vecdeque_is_empty(&recorder->audio_queue)) {
+    if (!sc_vecdeque_is_empty(&recorder->audio_queue)) {
        assert(recorder->audio);
        audio_pkt = sc_vecdeque_pop(&recorder->audio_queue);
    }
@ -494,42 +487,6 @@ run_recorder(void *data) {
    return 0;
 }

-static bool
-sc_recorder_set_orientation(AVStream *stream, enum sc_orientation orientation) {
-    assert(!sc_orientation_is_mirror(orientation));
-
-    uint8_t *raw_data;
-#ifdef SCRCPY_LAVC_HAS_CODECPAR_CODEC_SIDEDATA
-    AVPacketSideData *sd =
-        av_packet_side_data_new(&stream->codecpar->coded_side_data,
-                                &stream->codecpar->nb_coded_side_data,
-                                AV_PKT_DATA_DISPLAYMATRIX,
-                                sizeof(int32_t) * 9, 0);
-    if (!sd) {
-        LOG_OOM();
-        return false;
-    }
-
-    raw_data = sd->data;
-#else
-    raw_data = av_stream_new_side_data(stream, AV_PKT_DATA_DISPLAYMATRIX,
-                                      sizeof(int32_t) * 9);
-    if (!raw_data) {
-        LOG_OOM();
-        return false;
-    }
-#endif
-
-    int32_t *matrix = (int32_t *) raw_data;
-
-    unsigned rotation = orientation;
-    unsigned angle = rotation * 90;
-
-    av_display_rotation_set(matrix, angle);
-
-    return true;
-}
-
 static bool
 sc_recorder_video_packet_sink_open(struct sc_packet_sink *sink,
                                   AVCodecContext *ctx) {
@ -557,16 +514,6 @@ sc_recorder_video_packet_sink_open(struct sc_packet_sink *sink,

    recorder->video_stream.index = stream->index;

-    if (recorder->orientation != SC_ORIENTATION_0) {
-        if (!sc_recorder_set_orientation(stream, recorder->orientation)) {
-            sc_mutex_unlock(&recorder->mutex);
-            return false;
-        }
-
-        LOGI("Record orientation set to %s",
-             sc_orientation_get_name(recorder->orientation));
-    }
-
    recorder->video_init = true;
    sc_cond_signal(&recorder->cond);
    sc_mutex_unlock(&recorder->mutex);
@ -648,10 +595,6 @@ sc_recorder_audio_packet_sink_open(struct sc_packet_sink *sink,

    recorder->audio_stream.index = stream->index;

-    // A config packet is provided for all supported formats except raw audio
-    recorder->audio_expects_config_packet =
-        ctx->codec_id != AV_CODEC_ID_PCM_S16LE;
-
    recorder->audio_init = true;
    sc_cond_signal(&recorder->cond);
    sc_mutex_unlock(&recorder->mutex);
@ -736,10 +679,7 @@ sc_recorder_stream_init(struct sc_recorder_stream *stream) {
 bool
 sc_recorder_init(struct sc_recorder *recorder, const char *filename,
                 enum sc_record_format format, bool video, bool audio,
-                 enum sc_orientation orientation,
                 const struct sc_recorder_callbacks *cbs, void *cbs_userdata) {
-    assert(!sc_orientation_is_mirror(orientation));
-
    recorder->filename = strdup(filename);
    if (!recorder->filename) {
        LOG_OOM();
@ -760,8 +700,6 @@ sc_recorder_init(struct sc_recorder *recorder, const char *filename,
    recorder->video = video;
    recorder->audio = audio;

-    recorder->orientation = orientation;
-
    sc_vecdeque_init(&recorder->video_queue);
    sc_vecdeque_init(&recorder->audio_queue);
    recorder->stopped = false;
@ -769,8 +707,6 @@ sc_recorder_init(struct sc_recorder *recorder, const char *filename,
    recorder->video_init = false;
    recorder->audio_init = false;

-    recorder->audio_expects_config_packet = false;
-
    sc_recorder_stream_init(&recorder->video_stream);
    sc_recorder_stream_init(&recorder->audio_stream);

--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@ -34,8 +34,6 @@ struct sc_recorder {
    bool audio;
    bool video;

-    enum sc_orientation orientation;
-
    char *filename;
    enum sc_record_format format;
    AVFormatContext *ctx;
@ -52,8 +50,6 @@ struct sc_recorder {
    bool video_init;
    bool audio_init;

-    bool audio_expects_config_packet;
-
    struct sc_recorder_stream video_stream;
    struct sc_recorder_stream audio_stream;

@ -69,7 +65,6 @@ struct sc_recorder_callbacks {
 bool
 sc_recorder_init(struct sc_recorder *recorder, const char *filename,
                 enum sc_record_format format, bool video, bool audio,
-                 enum sc_orientation orientation,
                 const struct sc_recorder_callbacks *cbs, void *cbs_userdata);

 bool
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -20,17 +20,15 @@
 #include "demuxer.h"
 #include "events.h"
 #include "file_pusher.h"
-#include "keyboard_sdk.h"
-#include "mouse_sdk.h"
+#include "keyboard_inject.h"
+#include "mouse_inject.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
-#include "uhid/keyboard_uhid.h"
-#include "uhid/mouse_uhid.h"
 #ifdef HAVE_USB
 # include "usb/aoa_hid.h"
-# include "usb/keyboard_aoa.h"
-# include "usb/mouse_aoa.h"
+# include "usb/hid_keyboard.h"
+# include "usb/hid_mouse.h"
 # include "usb/usb.h"
 #endif
 #include "util/acksync.h"
@ -63,20 +61,17 @@ struct scrcpy {
    struct sc_aoa aoa;
    // sequence/ack helper to synchronize clipboard and Ctrl+v via HID
    struct sc_acksync acksync;
-    struct sc_uhid_devices uhid_devices;
 #endif
    union {
-        struct sc_keyboard_sdk keyboard_sdk;
-        struct sc_keyboard_uhid keyboard_uhid;
+        struct sc_keyboard_inject keyboard_inject;
 #ifdef HAVE_USB
-        struct sc_keyboard_aoa keyboard_aoa;
+        struct sc_hid_keyboard keyboard_hid;
 #endif
    };
    union {
-        struct sc_mouse_sdk mouse_sdk;
-        struct sc_mouse_uhid mouse_uhid;
+        struct sc_mouse_inject mouse_inject;
 #ifdef HAVE_USB
-        struct sc_mouse_aoa mouse_aoa;
+        struct sc_hid_mouse mouse_hid;
 #endif
    };
    struct sc_timeout timeout;
@ -95,7 +90,7 @@ push_event(uint32_t type, const char *name) {
 #define PUSH_EVENT(TYPE) push_event(TYPE, # TYPE)

 #ifdef _WIN32
-static BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
+BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
    if (ctrl_type == CTRL_C_EVENT) {
        PUSH_EVENT(SDL_QUIT);
        return TRUE;
@ -257,9 +252,7 @@ sc_audio_demuxer_on_ended(struct sc_demuxer *demuxer,

    // Contrary to the video demuxer, keep mirroring if only the audio fails
    // (unless --require-audio is set).
-    if (status == SC_DEMUXER_STATUS_EOS) {
-        PUSH_EVENT(SC_EVENT_DEVICE_DISCONNECTED);
-    } else if (status == SC_DEMUXER_STATUS_ERROR
+    if (status == SC_DEMUXER_STATUS_ERROR
            || (status == SC_DEMUXER_STATUS_DISABLED
                && options->require_audio)) {
        PUSH_EVENT(SC_EVENT_DEMUXER_ERROR);
@ -302,7 +295,7 @@ sc_timeout_on_timeout(struct sc_timeout *timeout, void *userdata) {

 // Generate a scrcpy id to differentiate multiple running scrcpy instances
 static uint32_t
-scrcpy_generate_scid(void) {
+scrcpy_generate_scid() {
    struct sc_rand rand;
    sc_rand_init(&rand);
    // Only use 31 bits to avoid issues with signed values on the Java-side
@ -335,8 +328,8 @@ scrcpy(struct scrcpy_options *options) {
    bool audio_demuxer_started = false;
 #ifdef HAVE_USB
    bool aoa_hid_initialized = false;
-    bool keyboard_aoa_initialized = false;
-    bool mouse_aoa_initialized = false;
+    bool hid_keyboard_initialized = false;
+    bool hid_mouse_initialized = false;
 #endif
    bool controller_initialized = false;
    bool controller_started = false;
@ -345,7 +338,6 @@ scrcpy(struct scrcpy_options *options) {
    bool timeout_started = false;

    struct sc_acksync *acksync = NULL;
-    struct sc_uhid_devices *uhid_devices = NULL;

    uint32_t scid = scrcpy_generate_scid();

@ -357,9 +349,7 @@ scrcpy(struct scrcpy_options *options) {
        .log_level = options->log_level,
        .video_codec = options->video_codec,
        .audio_codec = options->audio_codec,
-        .video_source = options->video_source,
        .audio_source = options->audio_source,
-        .camera_facing = options->camera_facing,
        .crop = options->crop,
        .port_range = options->port_range,
        .tunnel_host = options->tunnel_host,
@ -379,10 +369,6 @@ scrcpy(struct scrcpy_options *options) {
        .audio_codec_options = options->audio_codec_options,
        .video_encoder = options->video_encoder,
        .audio_encoder = options->audio_encoder,
-        .camera_id = options->camera_id,
-        .camera_size = options->camera_size,
-        .camera_ar = options->camera_ar,
-        .camera_fps = options->camera_fps,
        .force_adb_forward = options->force_adb_forward,
        .power_off_on_close = options->power_off_on_close,
        .clipboard_autosync = options->clipboard_autosync,
@ -391,9 +377,9 @@ scrcpy(struct scrcpy_options *options) {
        .tcpip_dst = options->tcpip_dst,
        .cleanup = options->cleanup,
        .power_on = options->power_on,
+        .list_encoders = options->list_encoders,
+        .list_displays = options->list_displays,
        .kill_adb_on_close = options->kill_adb_on_close,
-        .camera_high_speed = options->camera_high_speed,
-        .list = options->list,
    };

    static const struct sc_server_callbacks cbs = {
@ -411,7 +397,7 @@ scrcpy(struct scrcpy_options *options) {

    server_started = true;

-    if (options->list) {
+    if (options->list_encoders || options->list_displays) {
        bool ok = await_for_server(NULL);
        ret = ok ? SCRCPY_EXIT_SUCCESS : SCRCPY_EXIT_FAILURE;
        goto end;
@ -423,22 +409,9 @@ scrcpy(struct scrcpy_options *options) {

    if (options->video_playback) {
        sdl_set_hints(options->render_driver);
-    }
-
-    if (options->video_playback ||
-            (options->control && options->clipboard_autosync)) {
-        // Initialize the video subsystem even if --no-video or
-        // --no-video-playback is passed so that clipboard synchronization
-        // still works.
-        // <https://github.com/Genymobile/scrcpy/issues/4418>
        if (SDL_Init(SDL_INIT_VIDEO)) {
-            // If it fails, it is an error only if video playback is enabled
-            if (options->video_playback) {
-                LOGE("Could not initialize SDL video: %s", SDL_GetError());
-                goto end;
-            } else {
-                LOGW("Could not initialize SDL video: %s", SDL_GetError());
-            }
+            LOGE("Could not initialize SDL video: %s", SDL_GetError());
+            goto end;
        }
    }

@ -475,7 +448,9 @@ scrcpy(struct scrcpy_options *options) {

    struct sc_file_pusher *fp = NULL;

-    if (options->video_playback && options->control) {
+    // control implies video playback
+    assert(!options->control || options->video_playback);
+    if (options->control) {
        if (!sc_file_pusher_init(&s->file_pusher, serial,
                                 options->push_target)) {
            goto end;
@ -522,8 +497,7 @@ scrcpy(struct scrcpy_options *options) {
        };
        if (!sc_recorder_init(&s->recorder, options->record_filename,
                              options->record_format, options->video,
-                              options->audio, options->record_orientation,
-                              &recorder_cbs, NULL)) {
+                              options->audio, &recorder_cbs, NULL)) {
            goto end;
        }
        recorder_initialized = true;
@ -548,19 +522,12 @@ scrcpy(struct scrcpy_options *options) {
    struct sc_mouse_processor *mp = NULL;

    if (options->control) {
-        if (!sc_controller_init(&s->controller, s->server.control_socket)) {
-            goto end;
-        }
-        controller_initialized = true;
-
-        controller = &s->controller;
-
 #ifdef HAVE_USB
-        bool use_keyboard_aoa =
-            options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_AOA;
-        bool use_mouse_aoa =
-            options->mouse_input_mode == SC_MOUSE_INPUT_MODE_AOA;
-        if (use_keyboard_aoa || use_mouse_aoa) {
+        bool use_hid_keyboard =
+            options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID;
+        bool use_hid_mouse =
+            options->mouse_input_mode == SC_MOUSE_INPUT_MODE_HID;
+        if (use_hid_keyboard || use_hid_mouse) {
            bool ok = sc_acksync_init(&s->acksync);
            if (!ok) {
                goto end;
@ -570,7 +537,7 @@ scrcpy(struct scrcpy_options *options) {
            if (!ok) {
                LOGE("Failed to initialize USB");
                sc_acksync_destroy(&s->acksync);
-                goto end;
+                goto aoa_hid_end;
            }

            assert(serial);
@ -578,7 +545,7 @@ scrcpy(struct scrcpy_options *options) {
            ok = sc_usb_select_device(&s->usb, serial, &usb_device);
            if (!ok) {
                sc_usb_destroy(&s->usb);
-                goto end;
+                goto aoa_hid_end;
            }

            LOGI("USB device: %s (%04" PRIx16 ":%04" PRIx16 ") %s %s",
@ -591,7 +558,7 @@ scrcpy(struct scrcpy_options *options) {
                LOGE("Failed to connect to USB device %s", serial);
                sc_usb_destroy(&s->usb);
                sc_acksync_destroy(&s->acksync);
-                goto end;
+                goto aoa_hid_end;
            }

            ok = sc_aoa_init(&s->aoa, &s->usb, &s->acksync);
@ -600,80 +567,95 @@ scrcpy(struct scrcpy_options *options) {
                sc_usb_disconnect(&s->usb);
                sc_usb_destroy(&s->usb);
                sc_acksync_destroy(&s->acksync);
-                goto end;
+                goto aoa_hid_end;
            }

-            if (use_keyboard_aoa) {
-                if (sc_keyboard_aoa_init(&s->keyboard_aoa, &s->aoa)) {
-                    keyboard_aoa_initialized = true;
-                    kp = &s->keyboard_aoa.key_processor;
+            if (use_hid_keyboard) {
+                if (sc_hid_keyboard_init(&s->keyboard_hid, &s->aoa)) {
+                    hid_keyboard_initialized = true;
+                    kp = &s->keyboard_hid.key_processor;
                } else {
                    LOGE("Could not initialize HID keyboard");
                }
            }

-            if (use_mouse_aoa) {
-                if (sc_mouse_aoa_init(&s->mouse_aoa, &s->aoa)) {
-                    mouse_aoa_initialized = true;
-                    mp = &s->mouse_aoa.mouse_processor;
+            if (use_hid_mouse) {
+                if (sc_hid_mouse_init(&s->mouse_hid, &s->aoa)) {
+                    hid_mouse_initialized = true;
+                    mp = &s->mouse_hid.mouse_processor;
                } else {
                    LOGE("Could not initialized HID mouse");
                }
            }

-            bool need_aoa = keyboard_aoa_initialized || mouse_aoa_initialized;
+            bool need_aoa = hid_keyboard_initialized || hid_mouse_initialized;

            if (!need_aoa || !sc_aoa_start(&s->aoa)) {
                sc_acksync_destroy(&s->acksync);
                sc_usb_disconnect(&s->usb);
                sc_usb_destroy(&s->usb);
                sc_aoa_destroy(&s->aoa);
-                goto end;
+                goto aoa_hid_end;
            }

            acksync = &s->acksync;

            aoa_hid_initialized = true;
+
+aoa_hid_end:
+            if (!aoa_hid_initialized) {
+                if (hid_keyboard_initialized) {
+                    sc_hid_keyboard_destroy(&s->keyboard_hid);
+                    hid_keyboard_initialized = false;
+                }
+                if (hid_mouse_initialized) {
+                    sc_hid_mouse_destroy(&s->mouse_hid);
+                    hid_mouse_initialized = false;
+                }
+            }
+
+            if (use_hid_keyboard && !hid_keyboard_initialized) {
+                LOGE("Fallback to default keyboard injection method "
+                     "(-K/--hid-keyboard ignored)");
+                options->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT;
+            }
+
+            if (use_hid_mouse && !hid_mouse_initialized) {
+                LOGE("Fallback to default mouse injection method "
+                     "(-M/--hid-mouse ignored)");
+                options->mouse_input_mode = SC_MOUSE_INPUT_MODE_INJECT;
+            }
        }
 #else
-        assert(options->keyboard_input_mode != SC_KEYBOARD_INPUT_MODE_AOA);
-        assert(options->mouse_input_mode != SC_MOUSE_INPUT_MODE_AOA);
+        assert(options->keyboard_input_mode != SC_KEYBOARD_INPUT_MODE_HID);
+        assert(options->mouse_input_mode != SC_MOUSE_INPUT_MODE_HID);
 #endif

-        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_SDK) {
-            sc_keyboard_sdk_init(&s->keyboard_sdk, &s->controller,
-                                 options->key_inject_mode,
-                                 options->forward_key_repeat);
-            kp = &s->keyboard_sdk.key_processor;
-        } else if (options->keyboard_input_mode
-                == SC_KEYBOARD_INPUT_MODE_UHID) {
-            sc_uhid_devices_init(&s->uhid_devices);
-            bool ok = sc_keyboard_uhid_init(&s->keyboard_uhid, &s->controller,
-                                            &s->uhid_devices);
-            if (!ok) {
-                goto end;
-            }
-            uhid_devices = &s->uhid_devices;
-            kp = &s->keyboard_uhid.key_processor;
+        // 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->key_inject_mode,
+                                    options->forward_key_repeat);
+            kp = &s->keyboard_inject.key_processor;
        }

-        if (options->mouse_input_mode == SC_MOUSE_INPUT_MODE_SDK) {
-            sc_mouse_sdk_init(&s->mouse_sdk, &s->controller);
-            mp = &s->mouse_sdk.mouse_processor;
-        } else if (options->mouse_input_mode == SC_MOUSE_INPUT_MODE_UHID) {
-            bool ok = sc_mouse_uhid_init(&s->mouse_uhid, &s->controller);
-            if (!ok) {
-                goto end;
-            }
-            mp = &s->mouse_uhid.mouse_processor;
+        // mouse_input_mode may have been reset if HID mode failed
+        if (options->mouse_input_mode == SC_MOUSE_INPUT_MODE_INJECT) {
+            sc_mouse_inject_init(&s->mouse_inject, &s->controller);
+            mp = &s->mouse_inject.mouse_processor;
        }

-        sc_controller_configure(&s->controller, acksync, uhid_devices);
+        if (!sc_controller_init(&s->controller, s->server.control_socket,
+                                acksync)) {
+            goto end;
+        }
+        controller_initialized = true;

        if (!sc_controller_start(&s->controller)) {
            goto end;
        }
        controller_started = true;
+        controller = &s->controller;
    }

    // There is a controller if and only if control is enabled
@ -699,7 +681,7 @@ scrcpy(struct scrcpy_options *options) {
            .window_width = options->window_width,
            .window_height = options->window_height,
            .window_borderless = options->window_borderless,
-            .orientation = options->display_orientation,
+            .rotation = options->rotation,
            .mipmaps = options->mipmaps,
            .fullscreen = options->fullscreen,
            .start_fps_counter = options->start_fps_counter,
@ -813,11 +795,11 @@ end:
    // end-of-stream
 #ifdef HAVE_USB
    if (aoa_hid_initialized) {
-        if (keyboard_aoa_initialized) {
-            sc_keyboard_aoa_destroy(&s->keyboard_aoa);
+        if (hid_keyboard_initialized) {
+            sc_hid_keyboard_destroy(&s->keyboard_hid);
        }
-        if (mouse_aoa_initialized) {
-            sc_mouse_aoa_destroy(&s->mouse_aoa);
+        if (hid_mouse_initialized) {
+            sc_hid_mouse_destroy(&s->mouse_hid);
        }
        sc_aoa_stop(&s->aoa);
        sc_usb_stop(&s->usb);
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -14,16 +14,16 @@
 #define DOWNCAST(SINK) container_of(SINK, struct sc_screen, frame_sink)

 static inline struct sc_size
-get_oriented_size(struct sc_size size, enum sc_orientation orientation) {
-    struct sc_size oriented_size;
-    if (sc_orientation_is_swap(orientation)) {
-        oriented_size.width = size.height;
-        oriented_size.height = size.width;
+get_rotated_size(struct sc_size size, int rotation) {
+    struct sc_size rotated_size;
+    if (rotation & 1) {
+        rotated_size.width = size.height;
+        rotated_size.height = size.width;
    } else {
-        oriented_size.width = size.width;
-        oriented_size.height = size.height;
+        rotated_size.width = size.width;
+        rotated_size.height = size.height;
    }
-    return oriented_size;
+    return rotated_size;
 }

 // get the window size in a struct sc_size
@ -251,7 +251,7 @@ sc_screen_render(struct sc_screen *screen, bool update_content_rect) {
    }

    enum sc_display_result res =
-        sc_display_render(&screen->display, &screen->rect, screen->orientation);
+        sc_display_render(&screen->display, &screen->rect, screen->rotation);
    (void) res; // any error already logged
 }

@ -379,10 +379,9 @@ sc_screen_init(struct sc_screen *screen,
        goto error_destroy_frame_buffer;
    }

-    screen->orientation = params->orientation;
-    if (screen->orientation != SC_ORIENTATION_0) {
-        LOGI("Initial display orientation set to %s",
-             sc_orientation_get_name(screen->orientation));
+    screen->rotation = params->rotation;
+    if (screen->rotation) {
+        LOGI("Initial display rotation set to %u", screen->rotation);
    }

    uint32_t window_flags = SDL_WINDOW_HIDDEN
@ -489,7 +488,6 @@ sc_screen_show_initial_window(struct sc_screen *screen) {
    }

    SDL_ShowWindow(screen->window);
-    sc_screen_update_content_rect(screen);
 }

 void
@ -560,19 +558,19 @@ apply_pending_resize(struct sc_screen *screen) {
 }

 void
-sc_screen_set_orientation(struct sc_screen *screen,
-                          enum sc_orientation orientation) {
-    if (orientation == screen->orientation) {
+sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation) {
+    assert(rotation < 4);
+    if (rotation == screen->rotation) {
        return;
    }

    struct sc_size new_content_size =
-        get_oriented_size(screen->frame_size, orientation);
+        get_rotated_size(screen->frame_size, rotation);

    set_content_size(screen, new_content_size);

-    screen->orientation = orientation;
-    LOGI("Display orientation set to %s", sc_orientation_get_name(orientation));
+    screen->rotation = rotation;
+    LOGI("Display rotation set to %u", rotation);

    sc_screen_render(screen, true);
 }
@ -585,7 +583,7 @@ sc_screen_init_size(struct sc_screen *screen) {
    // The requested size is passed via screen->frame_size

    struct sc_size content_size =
-        get_oriented_size(screen->frame_size, screen->orientation);
+        get_rotated_size(screen->frame_size, screen->rotation);
    screen->content_size = content_size;

    enum sc_display_result res =
@ -605,7 +603,7 @@ prepare_for_frame(struct sc_screen *screen, struct sc_size new_frame_size) {
    screen->frame_size = new_frame_size;

    struct sc_size new_content_size =
-        get_oriented_size(new_frame_size, screen->orientation);
+        get_rotated_size(new_frame_size, screen->rotation);
    set_content_size(screen, new_content_size);

    sc_screen_update_content_rect(screen);
@ -844,54 +842,37 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
 struct sc_point
 sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen,
                                           int32_t x, int32_t y) {
-    enum sc_orientation orientation = screen->orientation;
+    unsigned rotation = screen->rotation;
+    assert(rotation < 4);

    int32_t w = screen->content_size.width;
    int32_t h = screen->content_size.height;

-    // screen->rect must be initialized to avoid a division by zero
-    assert(screen->rect.w && screen->rect.h);

    x = (int64_t) (x - screen->rect.x) * w / screen->rect.w;
    y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;

+    // rotate
    struct sc_point result;
-    switch (orientation) {
-        case SC_ORIENTATION_0:
+    switch (rotation) {
+        case 0:
            result.x = x;
            result.y = y;
            break;
-        case SC_ORIENTATION_90:
-            result.x = y;
-            result.y = w - x;
-            break;
-        case SC_ORIENTATION_180:
-            result.x = w - x;
-            result.y = h - y;
-            break;
-        case SC_ORIENTATION_270:
+        case 1:
            result.x = h - y;
            result.y = x;
            break;
-        case SC_ORIENTATION_FLIP_0:
+        case 2:
            result.x = w - x;
-            result.y = y;
-            break;
-        case SC_ORIENTATION_FLIP_90:
-            result.x = h - y;
-            result.y = w - x;
-            break;
-        case SC_ORIENTATION_FLIP_180:
-            result.x = x;
            result.y = h - y;
            break;
        default:
-            assert(orientation == SC_ORIENTATION_FLIP_270);
+            assert(rotation == 3);
            result.x = y;
-            result.y = x;
+            result.y = w - x;
            break;
    }
-
    return result;
 }

--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -14,7 +14,6 @@
 #include "frame_buffer.h"
 #include "input_manager.h"
 #include "opengl.h"
-#include "options.h"
 #include "trait/key_processor.h"
 #include "trait/frame_sink.h"
 #include "trait/mouse_processor.h"
@ -50,8 +49,8 @@ struct sc_screen {
    // fullscreen (meaningful only when resize_pending is true)
    struct sc_size windowed_content_size;

-    // client orientation
-    enum sc_orientation orientation;
+    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
+    unsigned rotation;
    // rectangle of the content (excluding black borders)
    struct SDL_Rect rect;
    bool has_frame;
@ -87,7 +86,7 @@ struct sc_screen_params {

    bool window_borderless;

-    enum sc_orientation orientation;
+    uint8_t rotation;
    bool mipmaps;

    bool fullscreen;
@ -130,10 +129,9 @@ sc_screen_resize_to_fit(struct sc_screen *screen);
 void
 sc_screen_resize_to_pixel_perfect(struct sc_screen *screen);

-// set the display orientation
+// set the display rotation (0, 1, 2 or 3, x90 degrees counterclockwise)
 void
-sc_screen_set_orientation(struct sc_screen *screen,
-                          enum sc_orientation orientation);
+sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation);

 // react to SDL events
 // If this function returns false, scrcpy must exit with an error.
--- a/app/src/server.c
+++ b/app/src/server.c
@ -76,8 +76,6 @@ sc_server_params_destroy(struct sc_server_params *params) {
    free((char *) params->video_encoder);
    free((char *) params->audio_encoder);
    free((char *) params->tcpip_dst);
-    free((char *) params->camera_id);
-    free((char *) params->camera_ar);
 }

 static bool
@ -88,15 +86,14 @@ sc_server_params_copy(struct sc_server_params *dst,
    // The params reference user-allocated memory, so we must copy them to
    // handle them from another thread

-#define COPY(FIELD) do { \
+#define COPY(FIELD) \
    dst->FIELD = NULL; \
    if (src->FIELD) { \
        dst->FIELD = strdup(src->FIELD); \
        if (!dst->FIELD) { \
            goto error; \
        } \
-    } \
-} while(0)
+    }

    COPY(req_serial);
    COPY(crop);
@ -105,8 +102,6 @@ sc_server_params_copy(struct sc_server_params *dst,
    COPY(video_encoder);
    COPY(audio_encoder);
    COPY(tcpip_dst);
-    COPY(camera_id);
-    COPY(camera_ar);
 #undef COPY

    return true;
@ -178,8 +173,6 @@ sc_server_get_codec_name(enum sc_codec codec) {
            return "opus";
        case SC_CODEC_AAC:
            return "aac";
-        case SC_CODEC_FLAC:
-            return "flac";
        case SC_CODEC_RAW:
            return "raw";
        default:
@ -187,20 +180,6 @@ sc_server_get_codec_name(enum sc_codec codec) {
    }
 }

-static const char *
-sc_server_get_camera_facing_name(enum sc_camera_facing camera_facing) {
-    switch (camera_facing) {
-        case SC_CAMERA_FACING_FRONT:
-            return "front";
-        case SC_CAMERA_FACING_BACK:
-            return "back";
-        case SC_CAMERA_FACING_EXTERNAL:
-            return "external";
-        default:
-            return NULL;
-    }
-}
-
 static sc_pid
 execute_server(struct sc_server *server,
               const struct sc_server_params *params) {
@ -236,13 +215,13 @@ execute_server(struct sc_server *server,
    cmd[count++] = SCRCPY_VERSION;

    unsigned dyn_idx = count; // from there, the strings are allocated
-#define ADD_PARAM(fmt, ...) do { \
+#define ADD_PARAM(fmt, ...) { \
        char *p; \
        if (asprintf(&p, fmt, ## __VA_ARGS__) == -1) { \
            goto end; \
        } \
        cmd[count++] = p; \
-    } while(0)
+    }

    ADD_PARAM("scid=%08x", params->scid);
    ADD_PARAM("log_level=%s", log_level_to_server_string(params->log_level));
@ -267,11 +246,8 @@ execute_server(struct sc_server *server,
        ADD_PARAM("audio_codec=%s",
            sc_server_get_codec_name(params->audio_codec));
    }
-    if (params->video_source != SC_VIDEO_SOURCE_DISPLAY) {
-        assert(params->video_source == SC_VIDEO_SOURCE_CAMERA);
-        ADD_PARAM("video_source=camera");
-    }
-    if (params->audio_source == SC_AUDIO_SOURCE_MIC) {
+    if (params->audio_source != SC_AUDIO_SOURCE_OUTPUT) {
+        assert(params->audio_source == SC_AUDIO_SOURCE_MIC);
        ADD_PARAM("audio_source=mic");
    }
    if (params->max_size) {
@ -297,25 +273,6 @@ execute_server(struct sc_server *server,
    if (params->display_id) {
        ADD_PARAM("display_id=%" PRIu32, params->display_id);
    }
-    if (params->camera_id) {
-        ADD_PARAM("camera_id=%s", params->camera_id);
-    }
-    if (params->camera_size) {
-        ADD_PARAM("camera_size=%s", params->camera_size);
-    }
-    if (params->camera_facing != SC_CAMERA_FACING_ANY) {
-        ADD_PARAM("camera_facing=%s",
-            sc_server_get_camera_facing_name(params->camera_facing));
-    }
-    if (params->camera_ar) {
-        ADD_PARAM("camera_ar=%s", params->camera_ar);
-    }
-    if (params->camera_fps) {
-        ADD_PARAM("camera_fps=%" PRIu16, params->camera_fps);
-    }
-    if (params->camera_high_speed) {
-        ADD_PARAM("camera_high_speed=true");
-    }
    if (params->show_touches) {
        ADD_PARAM("show_touches=true");
    }
@ -353,18 +310,12 @@ execute_server(struct sc_server *server,
        // By default, power_on is true
        ADD_PARAM("power_on=false");
    }
-    if (params->list & SC_OPTION_LIST_ENCODERS) {
+    if (params->list_encoders) {
        ADD_PARAM("list_encoders=true");
    }
-    if (params->list & SC_OPTION_LIST_DISPLAYS) {
+    if (params->list_displays) {
        ADD_PARAM("list_displays=true");
    }
-    if (params->list & SC_OPTION_LIST_CAMERAS) {
-        ADD_PARAM("list_cameras=true");
-    }
-    if (params->list & SC_OPTION_LIST_CAMERA_SIZES) {
-        ADD_PARAM("list_camera_sizes=true");
-    }

 #undef ADD_PARAM

@ -498,7 +449,7 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
 static bool
 device_read_info(struct sc_intr *intr, sc_socket device_socket,
                 struct sc_server_info *info) {
-    uint8_t buf[SC_DEVICE_NAME_FIELD_LENGTH];
+    unsigned char buf[SC_DEVICE_NAME_FIELD_LENGTH];
    ssize_t r = net_recv_all_intr(intr, device_socket, buf, sizeof(buf));
    if (r < SC_DEVICE_NAME_FIELD_LENGTH) {
        LOGE("Could not retrieve device information");
@ -582,8 +533,8 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
                if (audio_socket == SC_SOCKET_NONE) {
                    goto fail;
                }
-                bool ok = net_connect_intr(&server->intr, audio_socket,
-                                           tunnel_host, tunnel_port);
+                bool ok = net_connect_intr(&server->intr, audio_socket, tunnel_host,
+                                           tunnel_port);
                if (!ok) {
                    goto fail;
                }
@ -944,7 +895,7 @@ run_server(void *data) {

    // If --list-* is passed, then the server just prints the requested data
    // then exits.
-    if (params->list) {
+    if (params->list_encoders || params->list_displays) {
        sc_pid pid = execute_server(server, params);
        if (pid == SC_PROCESS_NONE) {
            goto error_connection_failed;
--- a/app/src/server.h
+++ b/app/src/server.h
@ -26,18 +26,12 @@ struct sc_server_params {
    enum sc_log_level log_level;
    enum sc_codec video_codec;
    enum sc_codec audio_codec;
-    enum sc_video_source video_source;
    enum sc_audio_source audio_source;
-    enum sc_camera_facing camera_facing;
    const char *crop;
    const char *video_codec_options;
    const char *audio_codec_options;
    const char *video_encoder;
    const char *audio_encoder;
-    const char *camera_id;
-    const char *camera_size;
-    const char *camera_ar;
-    uint16_t camera_fps;
    struct sc_port_range port_range;
    uint32_t tunnel_host;
    uint16_t tunnel_port;
@ -62,9 +56,9 @@ struct sc_server_params {
    bool select_tcpip;
    bool cleanup;
    bool power_on;
+    bool list_encoders;
+    bool list_displays;
    bool kill_adb_on_close;
-    bool camera_high_speed;
-    uint8_t list;
 };

 struct sc_server {
--- a/app/src/trait/key_processor.h
+++ b/app/src/trait/key_processor.h
@ -23,13 +23,6 @@ struct sc_key_processor {
     */
    bool async_paste;

-    /**
-     * Set by the implementation to indicate that the keyboard is HID. In
-     * practice, it is used to react on a shortcut to open the hard keyboard
-     * settings only if the keyboard is HID.
-     */
-    bool hid;
-
    const struct sc_key_processor_ops *ops;
 };

--- a/app/src/uhid/keyboard_uhid.c
+++ b/app/src/uhid/keyboard_uhid.c
@ -1,162 +0,0 @@
-#include "keyboard_uhid.h"
-
-#include "util/log.h"
-
-/** Downcast key processor to keyboard_uhid */
-#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_uhid, key_processor)
-
-/** Downcast uhid_receiver to keyboard_uhid */
-#define DOWNCAST_RECEIVER(UR) \
-    container_of(UR, struct sc_keyboard_uhid, uhid_receiver)
-
-#define UHID_KEYBOARD_ID 1
-
-static void
-sc_keyboard_uhid_send_input(struct sc_keyboard_uhid *kb,
-                            const struct sc_hid_event *event) {
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_UHID_INPUT;
-    msg.uhid_input.id = UHID_KEYBOARD_ID;
-
-    assert(event->size <= SC_HID_MAX_SIZE);
-    memcpy(msg.uhid_input.data, event->data, event->size);
-    msg.uhid_input.size = event->size;
-
-    if (!sc_controller_push_msg(kb->controller, &msg)) {
-        LOGE("Could not send UHID_INPUT message (key)");
-    }
-}
-
-static void
-sc_keyboard_uhid_synchronize_mod(struct sc_keyboard_uhid *kb) {
-    SDL_Keymod sdl_mod = SDL_GetModState();
-    uint16_t mod = sc_mods_state_from_sdl(sdl_mod) & (SC_MOD_CAPS | SC_MOD_NUM);
-
-    uint16_t device_mod =
-        atomic_load_explicit(&kb->device_mod, memory_order_relaxed);
-    uint16_t diff = mod ^ device_mod;
-
-    if (diff) {
-        // Inherently racy (the HID output reports arrive asynchronously in
-        // response to key presses), but will re-synchronize on next key press
-        // or HID output anyway
-        atomic_store_explicit(&kb->device_mod, mod, memory_order_relaxed);
-
-        struct sc_hid_event hid_event;
-        sc_hid_keyboard_event_from_mods(&hid_event, diff);
-
-        LOGV("HID keyboard state synchronized");
-
-        sc_keyboard_uhid_send_input(kb, &hid_event);
-    }
-}
-
-static void
-sc_key_processor_process_key(struct sc_key_processor *kp,
-                             const struct sc_key_event *event,
-                             uint64_t ack_to_wait) {
-    (void) ack_to_wait;
-
-    if (event->repeat) {
-        // In USB HID protocol, key repeat is handled by the host (Android), so
-        // just ignore key repeat here.
-        return;
-    }
-
-    struct sc_keyboard_uhid *kb = DOWNCAST(kp);
-
-    struct sc_hid_event hid_event;
-
-    // Not all keys are supported, just ignore unsupported keys
-    if (sc_hid_keyboard_event_from_key(&kb->hid, &hid_event, event)) {
-        if (event->scancode == SC_SCANCODE_CAPSLOCK) {
-            atomic_fetch_xor_explicit(&kb->device_mod, SC_MOD_CAPS,
-                                      memory_order_relaxed);
-        } else if (event->scancode == SC_SCANCODE_NUMLOCK) {
-            atomic_fetch_xor_explicit(&kb->device_mod, SC_MOD_NUM,
-                                      memory_order_relaxed);
-        } else {
-            // Synchronize modifiers (only if the scancode itself does not
-            // change the modifiers)
-            sc_keyboard_uhid_synchronize_mod(kb);
-        }
-        sc_keyboard_uhid_send_input(kb, &hid_event);
-    }
-}
-
-static unsigned
-sc_keyboard_uhid_to_sc_mod(uint8_t hid_led) {
-    // <https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf>
-    // (chapter 11: LED page)
-    unsigned mod = 0;
-    if (hid_led & 0x01) {
-        mod |= SC_MOD_NUM;
-    }
-    if (hid_led & 0x02) {
-        mod |= SC_MOD_CAPS;
-    }
-    return mod;
-}
-
-static void
-sc_uhid_receiver_process_output(struct sc_uhid_receiver *receiver,
-                                const uint8_t *data, size_t len) {
-    // Called from the thread receiving device messages
-
-    assert(len);
-
-    // Also check at runtime (do not trust the server)
-    if (!len) {
-        LOGE("Unexpected empty HID output message");
-        return;
-    }
-
-    struct sc_keyboard_uhid *kb = DOWNCAST_RECEIVER(receiver);
-
-    uint8_t hid_led = data[0];
-    uint16_t device_mod = sc_keyboard_uhid_to_sc_mod(hid_led);
-    atomic_store_explicit(&kb->device_mod, device_mod, memory_order_relaxed);
-}
-
-bool
-sc_keyboard_uhid_init(struct sc_keyboard_uhid *kb,
-                      struct sc_controller *controller,
-                      struct sc_uhid_devices *uhid_devices) {
-    sc_hid_keyboard_init(&kb->hid);
-
-    kb->controller = controller;
-    atomic_init(&kb->device_mod, 0);
-
-    static const struct sc_key_processor_ops ops = {
-        .process_key = sc_key_processor_process_key,
-        // Never forward text input via HID (all the keys are injected
-        // separately)
-        .process_text = NULL,
-    };
-
-    // Clipboard synchronization is requested over the same control socket, so
-    // there is no need for a specific synchronization mechanism
-    kb->key_processor.async_paste = false;
-    kb->key_processor.hid = true;
-    kb->key_processor.ops = &ops;
-
-    static const struct sc_uhid_receiver_ops uhid_receiver_ops = {
-        .process_output = sc_uhid_receiver_process_output,
-    };
-
-    kb->uhid_receiver.id = UHID_KEYBOARD_ID;
-    kb->uhid_receiver.ops = &uhid_receiver_ops;
-    sc_uhid_devices_add_receiver(uhid_devices, &kb->uhid_receiver);
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_UHID_CREATE;
-    msg.uhid_create.id = UHID_KEYBOARD_ID;
-    msg.uhid_create.report_desc = SC_HID_KEYBOARD_REPORT_DESC;
-    msg.uhid_create.report_desc_size = SC_HID_KEYBOARD_REPORT_DESC_LEN;
-    if (!sc_controller_push_msg(controller, &msg)) {
-        LOGE("Could not send UHID_CREATE message (keyboard)");
-        return false;
-    }
-
-    return true;
-}
--- a/app/src/uhid/keyboard_uhid.h
+++ b/app/src/uhid/keyboard_uhid.h
@ -1,27 +0,0 @@
-#ifndef SC_KEYBOARD_UHID_H
-#define SC_KEYBOARD_UHID_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "controller.h"
-#include "hid/hid_keyboard.h"
-#include "uhid/uhid_output.h"
-#include "trait/key_processor.h"
-
-struct sc_keyboard_uhid {
-    struct sc_key_processor key_processor; // key processor trait
-    struct sc_uhid_receiver uhid_receiver;
-
-    struct sc_hid_keyboard hid;
-    struct sc_controller *controller;
-    atomic_uint_least16_t device_mod;
-};
-
-bool
-sc_keyboard_uhid_init(struct sc_keyboard_uhid *kb,
-                      struct sc_controller *controller,
-                      struct sc_uhid_devices *uhid_devices);
-
-#endif
--- a/app/src/uhid/mouse_uhid.c
+++ b/app/src/uhid/mouse_uhid.c
@ -1,89 +0,0 @@
-#include "mouse_uhid.h"
-
-#include "hid/hid_mouse.h"
-#include "input_events.h"
-#include "util/log.h"
-
-/** Downcast mouse processor to mouse_uhid */
-#define DOWNCAST(MP) container_of(MP, struct sc_mouse_uhid, mouse_processor)
-
-#define UHID_MOUSE_ID 2
-
-static void
-sc_mouse_uhid_send_input(struct sc_mouse_uhid *mouse,
-                         const struct sc_hid_event *event, const char *name) {
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_UHID_INPUT;
-    msg.uhid_input.id = UHID_MOUSE_ID;
-
-    assert(event->size <= SC_HID_MAX_SIZE);
-    memcpy(msg.uhid_input.data, event->data, event->size);
-    msg.uhid_input.size = event->size;
-
-    if (!sc_controller_push_msg(mouse->controller, &msg)) {
-        LOGE("Could not send UHID_INPUT message (%s)", name);
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_motion_event *event) {
-    struct sc_mouse_uhid *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_motion(&hid_event, event);
-
-    sc_mouse_uhid_send_input(mouse, &hid_event, "mouse motion");
-}
-
-static void
-sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
-                                   const struct sc_mouse_click_event *event) {
-    struct sc_mouse_uhid *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_click(&hid_event, event);
-
-    sc_mouse_uhid_send_input(mouse, &hid_event, "mouse click");
-}
-
-static void
-sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_scroll_event *event) {
-    struct sc_mouse_uhid *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_scroll(&hid_event, event);
-
-    sc_mouse_uhid_send_input(mouse, &hid_event, "mouse scroll");
-}
-
-bool
-sc_mouse_uhid_init(struct sc_mouse_uhid *mouse,
-                   struct sc_controller *controller) {
-    mouse->controller = controller;
-
-    static const struct sc_mouse_processor_ops ops = {
-        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
-        .process_mouse_click = sc_mouse_processor_process_mouse_click,
-        .process_mouse_scroll = sc_mouse_processor_process_mouse_scroll,
-        // Touch events not supported (coordinates are not relative)
-        .process_touch = NULL,
-    };
-
-    mouse->mouse_processor.ops = &ops;
-
-    mouse->mouse_processor.relative_mode = true;
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_UHID_CREATE;
-    msg.uhid_create.id = UHID_MOUSE_ID;
-    msg.uhid_create.report_desc = SC_HID_MOUSE_REPORT_DESC;
-    msg.uhid_create.report_desc_size = SC_HID_MOUSE_REPORT_DESC_LEN;
-    if (!sc_controller_push_msg(controller, &msg)) {
-        LOGE("Could not send UHID_CREATE message (mouse)");
-        return false;
-    }
-
-    return true;
-}
--- a/app/src/uhid/mouse_uhid.h
+++ b/app/src/uhid/mouse_uhid.h
@ -1,19 +0,0 @@
-#ifndef SC_MOUSE_UHID_H
-#define SC_MOUSE_UHID_H
-
-#include <stdbool.h>
-
-#include "controller.h"
-#include "trait/mouse_processor.h"
-
-struct sc_mouse_uhid {
-    struct sc_mouse_processor mouse_processor; // mouse processor trait
-
-    struct sc_controller *controller;
-};
-
-bool
-sc_mouse_uhid_init(struct sc_mouse_uhid *mouse,
-                   struct sc_controller *controller);
-
-#endif
--- a/app/src/uhid/uhid_output.c
+++ b/app/src/uhid/uhid_output.c
@ -1,25 +0,0 @@
-#include "uhid_output.h"
-
-#include <assert.h>
-
-void
-sc_uhid_devices_init(struct sc_uhid_devices *devices) {
-    devices->count = 0;
-}
-
-void
-sc_uhid_devices_add_receiver(struct sc_uhid_devices *devices,
-                             struct sc_uhid_receiver *receiver) {
-    assert(devices->count < SC_UHID_MAX_RECEIVERS);
-    devices->receivers[devices->count++] = receiver;
-}
-
-struct sc_uhid_receiver *
-sc_uhid_devices_get_receiver(struct sc_uhid_devices *devices, uint16_t id) {
-    for (size_t i = 0; i < devices->count; ++i) {
-        if (devices->receivers[i]->id == id) {
-            return devices->receivers[i];
-        }
-    }
-    return NULL;
-}
--- a/app/src/uhid/uhid_output.h
+++ b/app/src/uhid/uhid_output.h
@ -1,45 +0,0 @@
-#ifndef SC_UHID_OUTPUT_H
-#define SC_UHID_OUTPUT_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-
-/**
- * The communication with UHID devices is bidirectional.
- *
- * This component manages the registration of receivers to handle UHID output
- * messages (sent from the device to the computer).
- */
-
-struct sc_uhid_receiver {
-    uint16_t id;
-
-    const struct sc_uhid_receiver_ops *ops;
-};
-
-struct sc_uhid_receiver_ops {
-    void
-    (*process_output)(struct sc_uhid_receiver *receiver,
-                      const uint8_t *data, size_t len);
-};
-
-#define SC_UHID_MAX_RECEIVERS 1
-
-struct sc_uhid_devices {
-    struct sc_uhid_receiver *receivers[SC_UHID_MAX_RECEIVERS];
-    unsigned count;
-};
-
-void
-sc_uhid_devices_init(struct sc_uhid_devices *devices);
-
-void
-sc_uhid_devices_add_receiver(struct sc_uhid_devices *devices,
-                             struct sc_uhid_receiver *receiver);
-
-struct sc_uhid_receiver *
-sc_uhid_devices_get_receiver(struct sc_uhid_devices *devices, uint16_t id);
-
-#endif
--- a/app/src/usb/aoa_hid.c
+++ b/app/src/usb/aoa_hid.c
@ -5,7 +5,6 @@

 #include "aoa_hid.h"
 #include "util/log.h"
-#include "util/str.h"

 // See <https://source.android.com/devices/accessories/aoa2#hid-support>.
 #define ACCESSORY_REGISTER_HID 54
@ -15,18 +14,37 @@

 #define DEFAULT_TIMEOUT 1000

-#define SC_AOA_EVENT_QUEUE_MAX 64
+#define SC_HID_EVENT_QUEUE_MAX 64

 static void
-sc_hid_event_log(uint16_t accessory_id, const struct sc_hid_event *event) {
+sc_hid_event_log(const struct sc_hid_event *event) {
    // HID Event: [00] FF FF FF FF...
    assert(event->size);
-    char *hex = sc_str_to_hex_string(event->data, event->size);
-    if (!hex) {
+    unsigned buffer_size = event->size * 3 + 1;
+    char *buffer = malloc(buffer_size);
+    if (!buffer) {
+        LOG_OOM();
        return;
    }
-    LOGV("HID Event: [%d] %s", accessory_id, hex);
-    free(hex);
+    for (unsigned i = 0; i < event->size; ++i) {
+        snprintf(buffer + i * 3, 4, " %02x", event->buffer[i]);
+    }
+    LOGV("HID Event: [%d]%s", event->accessory_id, buffer);
+    free(buffer);
+}
+
+void
+sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
+                  unsigned char *buffer, uint16_t buffer_size) {
+    hid_event->accessory_id = accessory_id;
+    hid_event->buffer = buffer;
+    hid_event->size = buffer_size;
+    hid_event->ack_to_wait = SC_SEQUENCE_INVALID;
+}
+
+void
+sc_hid_event_destroy(struct sc_hid_event *hid_event) {
+    free(hid_event->buffer);
 }

 bool
@ -34,7 +52,7 @@ sc_aoa_init(struct sc_aoa *aoa, struct sc_usb *usb,
            struct sc_acksync *acksync) {
    sc_vecdeque_init(&aoa->queue);

-    if (!sc_vecdeque_reserve(&aoa->queue, SC_AOA_EVENT_QUEUE_MAX)) {
+    if (!sc_vecdeque_reserve(&aoa->queue, SC_HID_EVENT_QUEUE_MAX)) {
        return false;
    }

@ -58,7 +76,12 @@ sc_aoa_init(struct sc_aoa *aoa, struct sc_usb *usb,

 void
 sc_aoa_destroy(struct sc_aoa *aoa) {
-    sc_vecdeque_destroy(&aoa->queue);
+    // Destroy remaining events
+    while (!sc_vecdeque_is_empty(&aoa->queue)) {
+        struct sc_hid_event *event = sc_vecdeque_popref(&aoa->queue);
+        assert(event);
+        sc_hid_event_destroy(event);
+    }

    sc_cond_destroy(&aoa->event_cond);
    sc_mutex_destroy(&aoa->mutex);
@ -74,10 +97,10 @@ sc_aoa_register_hid(struct sc_aoa *aoa, uint16_t accessory_id,
    // index (arg1): total length of the HID report descriptor
    uint16_t value = accessory_id;
    uint16_t index = report_desc_size;
-    unsigned char *data = NULL;
+    unsigned char *buffer = NULL;
    uint16_t length = 0;
    int result = libusb_control_transfer(aoa->usb->handle, request_type,
-                                         request, value, index, data, length,
+                                         request, value, index, buffer, length,
                                         DEFAULT_TIMEOUT);
    if (result < 0) {
        LOGE("REGISTER_HID: libusb error: %s", libusb_strerror(result));
@ -90,7 +113,7 @@ sc_aoa_register_hid(struct sc_aoa *aoa, uint16_t accessory_id,

 static bool
 sc_aoa_set_hid_report_desc(struct sc_aoa *aoa, uint16_t accessory_id,
-                           const uint8_t *report_desc,
+                           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;
@ -107,14 +130,14 @@ sc_aoa_set_hid_report_desc(struct sc_aoa *aoa, uint16_t accessory_id,
     * 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 in descriptor
+    // 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 *data = (unsigned char *) report_desc;
+    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, data, length,
+                                         request, value, index, buffer, length,
                                         DEFAULT_TIMEOUT);
    if (result < 0) {
        LOGE("SET_HID_REPORT_DESC: libusb error: %s", libusb_strerror(result));
@ -127,7 +150,7 @@ sc_aoa_set_hid_report_desc(struct sc_aoa *aoa, uint16_t accessory_id,

 bool
 sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
-                 const uint8_t *report_desc, uint16_t report_desc_size) {
+                 const unsigned char *report_desc, uint16_t report_desc_size) {
    bool ok = sc_aoa_register_hid(aoa, accessory_id, report_desc_size);
    if (!ok) {
        return false;
@ -146,19 +169,18 @@ sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
 }

 static bool
-sc_aoa_send_hid_event(struct sc_aoa *aoa, uint16_t accessory_id,
-                      const struct sc_hid_event *event) {
+sc_aoa_send_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_SEND_HID_EVENT;
    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
    // value (arg0): accessory assigned ID for the HID device
    // index (arg1): 0 (unused)
-    uint16_t value = accessory_id;
+    uint16_t value = event->accessory_id;
    uint16_t index = 0;
-    unsigned char *data = (uint8_t *) event->data; // discard const
+    unsigned char *buffer = event->buffer;
    uint16_t length = event->size;
    int result = libusb_control_transfer(aoa->usb->handle, request_type,
-                                         request, value, index, data, length,
+                                         request, value, index, buffer, length,
                                         DEFAULT_TIMEOUT);
    if (result < 0) {
        LOGE("SEND_HID_EVENT: libusb error: %s", libusb_strerror(result));
@ -170,7 +192,7 @@ sc_aoa_send_hid_event(struct sc_aoa *aoa, uint16_t accessory_id,
 }

 bool
-sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id) {
+sc_aoa_unregister_hid(struct sc_aoa *aoa, const uint16_t accessory_id) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_UNREGISTER_HID;
    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
@ -178,10 +200,10 @@ sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id) {
    // index (arg1): 0
    uint16_t value = accessory_id;
    uint16_t index = 0;
-    unsigned char *data = NULL;
+    unsigned char *buffer = NULL;
    uint16_t length = 0;
    int result = libusb_control_transfer(aoa->usb->handle, request_type,
-                                         request, value, index, data, length,
+                                         request, value, index, buffer, length,
                                         DEFAULT_TIMEOUT);
    if (result < 0) {
        LOGE("UNREGISTER_HID: libusb error: %s", libusb_strerror(result));
@ -193,25 +215,16 @@ sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id) {
 }

 bool
-sc_aoa_push_hid_event_with_ack_to_wait(struct sc_aoa *aoa,
-                                       uint16_t accessory_id,
-                                       const struct sc_hid_event *event,
-                                       uint64_t ack_to_wait) {
+sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
    if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
-        sc_hid_event_log(accessory_id, event);
+        sc_hid_event_log(event);
    }

    sc_mutex_lock(&aoa->mutex);
    bool full = sc_vecdeque_is_full(&aoa->queue);
    if (!full) {
        bool was_empty = sc_vecdeque_is_empty(&aoa->queue);
-
-        struct sc_aoa_event *aoa_event =
-            sc_vecdeque_push_hole_noresize(&aoa->queue);
-        aoa_event->hid = *event;
-        aoa_event->accessory_id = accessory_id;
-        aoa_event->ack_to_wait = ack_to_wait;
-
+        sc_vecdeque_push_noresize(&aoa->queue, *event);
        if (was_empty) {
            sc_cond_signal(&aoa->event_cond);
        }
@ -239,7 +252,7 @@ run_aoa_thread(void *data) {
        }

        assert(!sc_vecdeque_is_empty(&aoa->queue));
-        struct sc_aoa_event event = sc_vecdeque_pop(&aoa->queue);
+        struct sc_hid_event event = sc_vecdeque_pop(&aoa->queue);
        uint64_t ack_to_wait = event.ack_to_wait;
        sc_mutex_unlock(&aoa->mutex);

@ -258,14 +271,17 @@ run_aoa_thread(void *data) {

            if (result == SC_ACKSYNC_WAIT_TIMEOUT) {
                LOGW("Ack not received after 500ms, discarding HID event");
+                sc_hid_event_destroy(&event);
                continue;
            } else if (result == SC_ACKSYNC_WAIT_INTR) {
                // stopped
+                sc_hid_event_destroy(&event);
                break;
            }
        }

-        bool ok = sc_aoa_send_hid_event(aoa, event.accessory_id, &event.hid);
+        bool ok = sc_aoa_send_hid_event(aoa, &event);
+        sc_hid_event_destroy(&event);
        if (!ok) {
            LOGW("Could not send HID event to USB device");
        }
--- a/app/src/usb/aoa_hid.h
+++ b/app/src/usb/aoa_hid.h
@ -6,22 +6,28 @@

 #include <libusb-1.0/libusb.h>

-#include "hid/hid_event.h"
 #include "usb.h"
 #include "util/acksync.h"
 #include "util/thread.h"
 #include "util/tick.h"
 #include "util/vecdeque.h"

-#define SC_HID_MAX_SIZE 8
-
-struct sc_aoa_event {
-    struct sc_hid_event hid;
+struct sc_hid_event {
    uint16_t accessory_id;
+    unsigned char *buffer;
+    uint16_t size;
    uint64_t ack_to_wait;
 };

-struct sc_aoa_event_queue SC_VECDEQUE(struct sc_aoa_event);
+// Takes ownership of buffer
+void
+sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
+                  unsigned char *buffer, uint16_t buffer_size);
+
+void
+sc_hid_event_destroy(struct sc_hid_event *hid_event);
+
+struct sc_hid_event_queue SC_VECDEQUE(struct sc_hid_event);

 struct sc_aoa {
    struct sc_usb *usb;
@ -29,7 +35,7 @@ struct sc_aoa {
    sc_mutex mutex;
    sc_cond event_cond;
    bool stopped;
-    struct sc_aoa_event_queue queue;
+    struct sc_hid_event_queue queue;

    struct sc_acksync *acksync;
 };
@ -51,22 +57,12 @@ sc_aoa_join(struct sc_aoa *aoa);

 bool
 sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
-              const uint8_t *report_desc, uint16_t report_desc_size);
+              const unsigned char *report_desc, uint16_t report_desc_size);

 bool
 sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id);

 bool
-sc_aoa_push_hid_event_with_ack_to_wait(struct sc_aoa *aoa,
-                                       uint16_t accessory_id,
-                                       const struct sc_hid_event *event,
-                                       uint64_t ack_to_wait);
-
-static inline bool
-sc_aoa_push_hid_event(struct sc_aoa *aoa, uint16_t accessory_id,
-                      const struct sc_hid_event *event) {
-    return sc_aoa_push_hid_event_with_ack_to_wait(aoa, accessory_id, event,
-                                                  SC_SEQUENCE_INVALID);
-}
+sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event);

 #endif
--- a/app/src/usb/hid_keyboard.c
+++ b/app/src/usb/hid_keyboard.c
@ -1,34 +1,39 @@
 #include "hid_keyboard.h"

-#include <string.h>
+#include <assert.h>

+#include "input_events.h"
 #include "util/log.h"

-#define SC_HID_MOD_NONE 0x00
-#define SC_HID_MOD_LEFT_CONTROL (1 << 0)
-#define SC_HID_MOD_LEFT_SHIFT (1 << 1)
-#define SC_HID_MOD_LEFT_ALT (1 << 2)
-#define SC_HID_MOD_LEFT_GUI (1 << 3)
-#define SC_HID_MOD_RIGHT_CONTROL (1 << 4)
-#define SC_HID_MOD_RIGHT_SHIFT (1 << 5)
-#define SC_HID_MOD_RIGHT_ALT (1 << 6)
-#define SC_HID_MOD_RIGHT_GUI (1 << 7)
+/** Downcast key processor to hid_keyboard */
+#define DOWNCAST(KP) container_of(KP, struct sc_hid_keyboard, key_processor)

-#define SC_HID_KEYBOARD_INDEX_MODS 0
-#define SC_HID_KEYBOARD_INDEX_KEYS 2
+#define HID_KEYBOARD_ACCESSORY_ID 1
+
+#define HID_MODIFIER_NONE 0x00
+#define HID_MODIFIER_LEFT_CONTROL (1 << 0)
+#define HID_MODIFIER_LEFT_SHIFT (1 << 1)
+#define HID_MODIFIER_LEFT_ALT (1 << 2)
+#define HID_MODIFIER_LEFT_GUI (1 << 3)
+#define HID_MODIFIER_RIGHT_CONTROL (1 << 4)
+#define HID_MODIFIER_RIGHT_SHIFT (1 << 5)
+#define HID_MODIFIER_RIGHT_ALT (1 << 6)
+#define HID_MODIFIER_RIGHT_GUI (1 << 7)
+
+#define HID_KEYBOARD_INDEX_MODIFIER 0
+#define HID_KEYBOARD_INDEX_KEYS 2

 // USB HID protocol says 6 keys in an event is the requirement for BIOS
 // keyboard support, though OS could support more keys via modifying the report
 // desc. 6 should be enough for scrcpy.
-#define SC_HID_KEYBOARD_MAX_KEYS 6
-#define SC_HID_KEYBOARD_EVENT_SIZE \
-    (SC_HID_KEYBOARD_INDEX_KEYS + SC_HID_KEYBOARD_MAX_KEYS)
+#define HID_KEYBOARD_MAX_KEYS 6
+#define HID_KEYBOARD_EVENT_SIZE (2 + HID_KEYBOARD_MAX_KEYS)

-#define SC_HID_RESERVED 0x00
-#define SC_HID_ERROR_ROLL_OVER 0x01
+#define HID_RESERVED 0x00
+#define HID_ERROR_ROLL_OVER 0x01

 /**
- * For HID, only report descriptor is needed.
+ * For HID over AOAv2, only report descriptor is needed.
 *
 * The specification is available here:
 * <https://www.usb.org/sites/default/files/hid1_11.pdf>
@ -47,7 +52,7 @@
 *
 * (change vid:pid' to your device's vendor ID and product ID).
 */
-const uint8_t SC_HID_KEYBOARD_REPORT_DESC[] = {
+static const unsigned char keyboard_report_desc[]  = {
    // Usage Page (Generic Desktop)
    0x05, 0x01,
    // Usage (Keyboard)
@ -113,7 +118,7 @@ const uint8_t SC_HID_KEYBOARD_REPORT_DESC[] = {
    // Report Size (8)
    0x75, 0x08,
    // Report Count (6)
-    0x95, SC_HID_KEYBOARD_MAX_KEYS,
+    0x95, HID_KEYBOARD_MAX_KEYS,
    // Input (Data, Array): Keys
    0x81, 0x00,

@ -121,9 +126,6 @@ const uint8_t SC_HID_KEYBOARD_REPORT_DESC[] = {
    0xC0
 };

-const size_t SC_HID_KEYBOARD_REPORT_DESC_LEN =
-    sizeof(SC_HID_KEYBOARD_REPORT_DESC);
-
 /**
 * A keyboard HID event is 8 bytes long:
 *
@ -198,50 +200,51 @@ const size_t SC_HID_KEYBOARD_REPORT_DESC_LEN =
 *                  +---------------+
 */

-static void
-sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) {
-    hid_event->size = SC_HID_KEYBOARD_EVENT_SIZE;
-
-    uint8_t *data = hid_event->data;
-
-    data[SC_HID_KEYBOARD_INDEX_MODS] = SC_HID_MOD_NONE;
-    data[1] = SC_HID_RESERVED;
-    memset(&data[SC_HID_KEYBOARD_INDEX_KEYS], 0, SC_HID_KEYBOARD_MAX_KEYS);
-}
-
-static uint16_t
-sc_hid_mod_from_sdl_keymod(uint16_t mod) {
-    uint16_t mods = SC_HID_MOD_NONE;
+static unsigned char
+sdl_keymod_to_hid_modifiers(uint16_t mod) {
+    unsigned char modifiers = HID_MODIFIER_NONE;
    if (mod & SC_MOD_LCTRL) {
-        mods |= SC_HID_MOD_LEFT_CONTROL;
+        modifiers |= HID_MODIFIER_LEFT_CONTROL;
    }
    if (mod & SC_MOD_LSHIFT) {
-        mods |= SC_HID_MOD_LEFT_SHIFT;
+        modifiers |= HID_MODIFIER_LEFT_SHIFT;
    }
    if (mod & SC_MOD_LALT) {
-        mods |= SC_HID_MOD_LEFT_ALT;
+        modifiers |= HID_MODIFIER_LEFT_ALT;
    }
    if (mod & SC_MOD_LGUI) {
-        mods |= SC_HID_MOD_LEFT_GUI;
+        modifiers |= HID_MODIFIER_LEFT_GUI;
    }
    if (mod & SC_MOD_RCTRL) {
-        mods |= SC_HID_MOD_RIGHT_CONTROL;
+        modifiers |= HID_MODIFIER_RIGHT_CONTROL;
    }
    if (mod & SC_MOD_RSHIFT) {
-        mods |= SC_HID_MOD_RIGHT_SHIFT;
+        modifiers |= HID_MODIFIER_RIGHT_SHIFT;
    }
    if (mod & SC_MOD_RALT) {
-        mods |= SC_HID_MOD_RIGHT_ALT;
+        modifiers |= HID_MODIFIER_RIGHT_ALT;
    }
    if (mod & SC_MOD_RGUI) {
-        mods |= SC_HID_MOD_RIGHT_GUI;
+        modifiers |= HID_MODIFIER_RIGHT_GUI;
    }
-    return mods;
+    return modifiers;
 }

-void
-sc_hid_keyboard_init(struct sc_hid_keyboard *hid) {
-    memset(hid->keys, false, SC_HID_KEYBOARD_KEYS);
+static bool
+sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) {
+    unsigned char *buffer = malloc(HID_KEYBOARD_EVENT_SIZE);
+    if (!buffer) {
+        LOG_OOM();
+        return false;
+    }
+
+    buffer[HID_KEYBOARD_INDEX_MODIFIER] = HID_MODIFIER_NONE;
+    buffer[1] = HID_RESERVED;
+    memset(&buffer[HID_KEYBOARD_INDEX_KEYS], 0, HID_KEYBOARD_MAX_KEYS);
+
+    sc_hid_event_init(hid_event, HID_KEYBOARD_ACCESSORY_ID, buffer,
+                      HID_KEYBOARD_EVENT_SIZE);
+    return true;
 }

 static inline bool
@ -249,10 +252,10 @@ scancode_is_modifier(enum sc_scancode scancode) {
    return scancode >= SC_SCANCODE_LCTRL && scancode <= SC_SCANCODE_RGUI;
 }

-bool
-sc_hid_keyboard_event_from_key(struct sc_hid_keyboard *hid,
-                               struct sc_hid_event *hid_event,
-                               const struct sc_key_event *event) {
+static bool
+convert_hid_keyboard_event(struct sc_hid_keyboard *kb,
+                           struct sc_hid_event *hid_event,
+                           const struct sc_key_event *event) {
    enum sc_scancode scancode = event->scancode;
    assert(scancode >= 0);

@ -264,37 +267,39 @@ sc_hid_keyboard_event_from_key(struct sc_hid_keyboard *hid,
        return false;
    }

-    sc_hid_keyboard_event_init(hid_event);
+    if (!sc_hid_keyboard_event_init(hid_event)) {
+        LOGW("Could not initialize HID keyboard event");
+        return false;
+    }

-    uint16_t mods = sc_hid_mod_from_sdl_keymod(event->mods_state);
+    unsigned char modifiers = sdl_keymod_to_hid_modifiers(event->mods_state);

    if (scancode < SC_HID_KEYBOARD_KEYS) {
        // Pressed is true and released is false
-        hid->keys[scancode] = (event->action == SC_ACTION_DOWN);
+        kb->keys[scancode] = (event->action == SC_ACTION_DOWN);
        LOGV("keys[%02x] = %s", scancode,
-             hid->keys[scancode] ? "true" : "false");
+             kb->keys[scancode] ? "true" : "false");
    }

-    hid_event->data[SC_HID_KEYBOARD_INDEX_MODS] = mods;
+    hid_event->buffer[HID_KEYBOARD_INDEX_MODIFIER] = modifiers;

-    uint8_t *keys_data = &hid_event->data[SC_HID_KEYBOARD_INDEX_KEYS];
+    unsigned char *keys_buffer = &hid_event->buffer[HID_KEYBOARD_INDEX_KEYS];
    // Re-calculate pressed keys every time
    int keys_pressed_count = 0;
    for (int i = 0; i < SC_HID_KEYBOARD_KEYS; ++i) {
-        if (hid->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 >= SC_HID_KEYBOARD_MAX_KEYS) {
+            if (keys_pressed_count >= HID_KEYBOARD_MAX_KEYS) {
                // Phantom state:
                //  - Modifiers
                //  - Reserved
                //  - ErrorRollOver * HID_MAX_KEYS
-                memset(keys_data, SC_HID_ERROR_ROLL_OVER,
-                       SC_HID_KEYBOARD_MAX_KEYS);
+                memset(keys_buffer, HID_ERROR_ROLL_OVER, HID_KEYBOARD_MAX_KEYS);
                goto end;
            }

-            keys_data[keys_pressed_count] = i;
+            keys_buffer[keys_pressed_count] = i;
            ++keys_pressed_count;
        }
    }
@ -302,32 +307,124 @@ sc_hid_keyboard_event_from_key(struct sc_hid_keyboard *hid,
 end:
    LOGV("hid keyboard: key %-4s scancode=%02x (%u) mod=%02x",
         event->action == SC_ACTION_DOWN ? "down" : "up", event->scancode,
-         event->scancode, mods);
+         event->scancode, modifiers);

    return true;
 }

-bool
-sc_hid_keyboard_event_from_mods(struct sc_hid_event *event,
-                                uint16_t mods_state) {
+
+static bool
+push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t mods_state) {
    bool capslock = mods_state & SC_MOD_CAPS;
    bool numlock = mods_state & SC_MOD_NUM;
    if (!capslock && !numlock) {
        // Nothing to do
+        return true;
+    }
+
+    struct sc_hid_event hid_event;
+    if (!sc_hid_keyboard_event_init(&hid_event)) {
+        LOGW("Could not initialize HID keyboard event");
        return false;
    }

-    sc_hid_keyboard_event_init(event);
-
    unsigned i = 0;
    if (capslock) {
-        event->data[SC_HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;
+        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;
        ++i;
    }
    if (numlock) {
-        event->data[SC_HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_NUMLOCK;
+        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_NUMLOCK;
        ++i;
    }

+    if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
+        sc_hid_event_destroy(&hid_event);
+        LOGW("Could not request HID event (mod lock state)");
+        return false;
+    }
+
+    LOGD("HID keyboard state synchronized");
+
    return true;
 }
+
+static void
+sc_key_processor_process_key(struct sc_key_processor *kp,
+                             const struct sc_key_event *event,
+                             uint64_t ack_to_wait) {
+    if (event->repeat) {
+        // In USB HID protocol, key repeat is handled by the host (Android), so
+        // just ignore key repeat here.
+        return;
+    }
+
+    struct sc_hid_keyboard *kb = DOWNCAST(kp);
+
+    struct sc_hid_event hid_event;
+    // Not all keys are supported, just ignore unsupported keys
+    if (convert_hid_keyboard_event(kb, &hid_event, event)) {
+        if (!kb->mod_lock_synchronized) {
+            // Inject CAPSLOCK and/or NUMLOCK if necessary to synchronize
+            // keyboard state
+            if (push_mod_lock_state(kb, event->mods_state)) {
+                kb->mod_lock_synchronized = true;
+            }
+        }
+
+        if (ack_to_wait) {
+            // Ctrl+v is pressed, so clipboard synchronization has been
+            // requested. Wait until clipboard synchronization is acknowledged
+            // by the server, otherwise it could paste the old clipboard
+            // content.
+            hid_event.ack_to_wait = ack_to_wait;
+        }
+
+        if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
+            sc_hid_event_destroy(&hid_event);
+            LOGW("Could not request HID event (key)");
+        }
+    }
+}
+
+bool
+sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa) {
+    kb->aoa = aoa;
+
+    bool ok = sc_aoa_setup_hid(aoa, HID_KEYBOARD_ACCESSORY_ID,
+                               keyboard_report_desc,
+                               ARRAY_LEN(keyboard_report_desc));
+    if (!ok) {
+        LOGW("Register HID keyboard failed");
+        return false;
+    }
+
+    // Reset all states
+    memset(kb->keys, false, SC_HID_KEYBOARD_KEYS);
+
+    kb->mod_lock_synchronized = false;
+
+    static const struct sc_key_processor_ops ops = {
+        .process_key = sc_key_processor_process_key,
+        // Never forward text input via HID (all the keys are injected
+        // separately)
+        .process_text = NULL,
+    };
+
+    // Clipboard synchronization is requested over the control socket, while HID
+    // events are sent over AOA, so it must wait for clipboard synchronization
+    // to be acknowledged by the device before injecting Ctrl+v.
+    kb->key_processor.async_paste = true;
+    kb->key_processor.ops = &ops;
+
+    return true;
+}
+
+void
+sc_hid_keyboard_destroy(struct sc_hid_keyboard *kb) {
+    // Unregister HID keyboard so the soft keyboard shows again on Android
+    bool ok = sc_aoa_unregister_hid(kb->aoa, HID_KEYBOARD_ACCESSORY_ID);
+    if (!ok) {
+        LOGW("Could not unregister HID keyboard");
+    }
+}
--- a/app/src/usb/hid_keyboard.h
+++ b/app/src/usb/hid_keyboard.h
@ -5,8 +5,8 @@

 #include <stdbool.h>

-#include "hid/hid_event.h"
-#include "input_events.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
@ -14,9 +14,6 @@
 // 0x65 is Application, typically AT-101 Keyboard ends here.
 #define SC_HID_KEYBOARD_KEYS 0x66

-extern const uint8_t SC_HID_KEYBOARD_REPORT_DESC[];
-extern const size_t SC_HID_KEYBOARD_REPORT_DESC_LEN;
-
 /**
 * HID keyboard events are sequence-based, every time keyboard state changes
 * it sends an array of currently pressed keys, the host is responsible for
@ -30,19 +27,18 @@ extern const size_t SC_HID_KEYBOARD_REPORT_DESC_LEN;
 * phantom state.
 */
 struct sc_hid_keyboard {
+    struct sc_key_processor key_processor; // key processor trait
+
+    struct sc_aoa *aoa;
    bool keys[SC_HID_KEYBOARD_KEYS];
+
+    bool mod_lock_synchronized;
 };

+bool
+sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa);
+
 void
-sc_hid_keyboard_init(struct sc_hid_keyboard *hid);
-
-bool
-sc_hid_keyboard_event_from_key(struct sc_hid_keyboard *hid,
-                               struct sc_hid_event *hid_event,
-                               const struct sc_key_event *event);
-
-bool
-sc_hid_keyboard_event_from_mods(struct sc_hid_event *event,
-                                uint16_t mods_state);
+sc_hid_keyboard_destroy(struct sc_hid_keyboard *kb);

 #endif
--- a/app/src/usb/hid_mouse.c
+++ b/app/src/usb/hid_mouse.c
@ -0,0 +1,267 @@
+#include "hid_mouse.h"
+
+#include <assert.h>
+
+#include "input_events.h"
+#include "util/log.h"
+
+/** Downcast mouse processor to hid_mouse */
+#define DOWNCAST(MP) container_of(MP, struct sc_hid_mouse, mouse_processor)
+
+#define HID_MOUSE_ACCESSORY_ID 2
+
+// 1 byte for buttons + padding, 1 byte for X position, 1 byte for Y position
+#define HID_MOUSE_EVENT_SIZE 4
+
+/**
+ * Mouse descriptor from the specification:
+ * <https://www.usb.org/sites/default/files/hid1_11.pdf>
+ *
+ * Appendix E (p71): §E.10 Report Descriptor (Mouse)
+ *
+ * The usage tags (like Wheel) are listed in "HID Usage Tables":
+ * <https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf>
+ * §4 Generic Desktop Page (0x01) (p26)
+ */
+static const unsigned char mouse_report_desc[]  = {
+    // Usage Page (Generic Desktop)
+    0x05, 0x01,
+    // Usage (Mouse)
+    0x09, 0x02,
+
+    // Collection (Application)
+    0xA1, 0x01,
+
+    // Usage (Pointer)
+    0x09, 0x01,
+
+    // Collection (Physical)
+    0xA1, 0x00,
+
+    // Usage Page (Buttons)
+    0x05, 0x09,
+
+    // Usage Minimum (1)
+    0x19, 0x01,
+     // Usage Maximum (5)
+    0x29, 0x05,
+    // Logical Minimum (0)
+    0x15, 0x00,
+    // Logical Maximum (1)
+    0x25, 0x01,
+    // Report Count (5)
+    0x95, 0x05,
+    // Report Size (1)
+    0x75, 0x01,
+    // Input (Data, Variable, Absolute): 5 buttons bits
+    0x81, 0x02,
+
+    // Report Count (1)
+    0x95, 0x01,
+    // Report Size (3)
+    0x75, 0x03,
+    // Input (Constant): 3 bits padding
+    0x81, 0x01,
+
+    // Usage Page (Generic Desktop)
+    0x05, 0x01,
+    // Usage (X)
+    0x09, 0x30,
+    // Usage (Y)
+    0x09, 0x31,
+    // Usage (Wheel)
+    0x09, 0x38,
+    // Local Minimum (-127)
+    0x15, 0x81,
+    // Local Maximum (127)
+    0x25, 0x7F,
+    // Report Size (8)
+    0x75, 0x08,
+    // Report Count (3)
+    0x95, 0x03,
+    // Input (Data, Variable, Relative): 3 position bytes (X, Y, Wheel)
+    0x81, 0x06,
+
+    // End Collection
+    0xC0,
+
+    // End Collection
+    0xC0,
+};
+
+/**
+ * A mouse HID event is 3 bytes long:
+ *
+ *  - byte 0: buttons state
+ *  - byte 1: relative x motion (signed byte from -127 to 127)
+ *  - byte 2: relative y motion (signed byte from -127 to 127)
+ *
+ *                   7 6 5 4 3 2 1 0
+ *                  +---------------+
+ *         byte 0:  |0 0 0 . . . . .| buttons state
+ *                  +---------------+
+ *                         ^ ^ ^ ^ ^
+ *                         | | | | `- left button
+ *                         | | | `--- right button
+ *                         | | `----- middle button
+ *                         | `------- button 4
+ *                         `--------- button 5
+ *
+ *                  +---------------+
+ *         byte 1:  |. . . . . . . .| relative x motion
+ *                  +---------------+
+ *         byte 2:  |. . . . . . . .| relative y motion
+ *                  +---------------+
+ *         byte 3:  |. . . . . . . .| wheel motion (-1, 0 or 1)
+ *                  +---------------+
+ *
+ * As an example, here is the report for a motion of (x=5, y=-4) with left
+ * button pressed:
+ *
+ *                  +---------------+
+ *                  |0 0 0 0 0 0 0 1| left button pressed
+ *                  +---------------+
+ *                  |0 0 0 0 0 1 0 1| horizontal motion (x = 5)
+ *                  +---------------+
+ *                  |1 1 1 1 1 1 0 0| relative y motion (y = -4)
+ *                  +---------------+
+ *                  |0 0 0 0 0 0 0 0| wheel motion
+ *                  +---------------+
+ */
+
+static bool
+sc_hid_mouse_event_init(struct sc_hid_event *hid_event) {
+    unsigned char *buffer = calloc(1, HID_MOUSE_EVENT_SIZE);
+    if (!buffer) {
+        LOG_OOM();
+        return false;
+    }
+
+    sc_hid_event_init(hid_event, HID_MOUSE_ACCESSORY_ID, buffer,
+                      HID_MOUSE_EVENT_SIZE);
+    return true;
+}
+
+static unsigned char
+buttons_state_to_hid_buttons(uint8_t buttons_state) {
+    unsigned char c = 0;
+    if (buttons_state & SC_MOUSE_BUTTON_LEFT) {
+        c |= 1 << 0;
+    }
+    if (buttons_state & SC_MOUSE_BUTTON_RIGHT) {
+        c |= 1 << 1;
+    }
+    if (buttons_state & SC_MOUSE_BUTTON_MIDDLE) {
+        c |= 1 << 2;
+    }
+    if (buttons_state & SC_MOUSE_BUTTON_X1) {
+        c |= 1 << 3;
+    }
+    if (buttons_state & SC_MOUSE_BUTTON_X2) {
+        c |= 1 << 4;
+    }
+    return c;
+}
+
+static void
+sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
+                                    const struct sc_mouse_motion_event *event) {
+    struct sc_hid_mouse *mouse = DOWNCAST(mp);
+
+    struct sc_hid_event hid_event;
+    if (!sc_hid_mouse_event_init(&hid_event)) {
+        return;
+    }
+
+    unsigned char *buffer = hid_event.buffer;
+    buffer[0] = buttons_state_to_hid_buttons(event->buttons_state);
+    buffer[1] = CLAMP(event->xrel, -127, 127);
+    buffer[2] = CLAMP(event->yrel, -127, 127);
+    buffer[3] = 0; // wheel coordinates only used for scrolling
+
+    if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
+        sc_hid_event_destroy(&hid_event);
+        LOGW("Could not request HID event (mouse motion)");
+    }
+}
+
+static void
+sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
+                                   const struct sc_mouse_click_event *event) {
+    struct sc_hid_mouse *mouse = DOWNCAST(mp);
+
+    struct sc_hid_event hid_event;
+    if (!sc_hid_mouse_event_init(&hid_event)) {
+        return;
+    }
+
+    unsigned char *buffer = hid_event.buffer;
+    buffer[0] = buttons_state_to_hid_buttons(event->buttons_state);
+    buffer[1] = 0; // no x motion
+    buffer[2] = 0; // no y motion
+    buffer[3] = 0; // wheel coordinates only used for scrolling
+
+    if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
+        sc_hid_event_destroy(&hid_event);
+        LOGW("Could not request HID event (mouse click)");
+    }
+}
+
+static void
+sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
+                                    const struct sc_mouse_scroll_event *event) {
+    struct sc_hid_mouse *mouse = DOWNCAST(mp);
+
+    struct sc_hid_event hid_event;
+    if (!sc_hid_mouse_event_init(&hid_event)) {
+        return;
+    }
+
+    unsigned char *buffer = hid_event.buffer;
+    buffer[0] = 0; // buttons state irrelevant (and unknown)
+    buffer[1] = 0; // no x motion
+    buffer[2] = 0; // no y motion
+    // In practice, vscroll is always -1, 0 or 1, but in theory other values
+    // are possible
+    buffer[3] = CLAMP(event->vscroll, -127, 127);
+    // Horizontal scrolling ignored
+
+    if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
+        sc_hid_event_destroy(&hid_event);
+        LOGW("Could not request HID event (mouse scroll)");
+    }
+}
+
+bool
+sc_hid_mouse_init(struct sc_hid_mouse *mouse, struct sc_aoa *aoa) {
+    mouse->aoa = aoa;
+
+    bool ok = sc_aoa_setup_hid(aoa, HID_MOUSE_ACCESSORY_ID, mouse_report_desc,
+                               ARRAY_LEN(mouse_report_desc));
+    if (!ok) {
+        LOGW("Register HID mouse failed");
+        return false;
+    }
+
+    static const struct sc_mouse_processor_ops ops = {
+        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
+        .process_mouse_click = sc_mouse_processor_process_mouse_click,
+        .process_mouse_scroll = sc_mouse_processor_process_mouse_scroll,
+        // Touch events not supported (coordinates are not relative)
+        .process_touch = NULL,
+    };
+
+    mouse->mouse_processor.ops = &ops;
+
+    mouse->mouse_processor.relative_mode = true;
+
+    return true;
+}
+
+void
+sc_hid_mouse_destroy(struct sc_hid_mouse *mouse) {
+    bool ok = sc_aoa_unregister_hid(mouse->aoa, HID_MOUSE_ACCESSORY_ID);
+    if (!ok) {
+        LOGW("Could not unregister HID mouse");
+    }
+}
--- a/app/src/usb/hid_mouse.h
+++ b/app/src/usb/hid_mouse.h
@ -1,5 +1,5 @@
-#ifndef SC_MOUSE_AOA_H
-#define SC_MOUSE_AOA_H
+#ifndef SC_HID_MOUSE_H
+#define SC_HID_MOUSE_H

 #include "common.h"

@ -8,16 +8,16 @@
 #include "aoa_hid.h"
 #include "trait/mouse_processor.h"

-struct sc_mouse_aoa {
+struct sc_hid_mouse {
    struct sc_mouse_processor mouse_processor; // mouse processor trait

    struct sc_aoa *aoa;
 };

 bool
-sc_mouse_aoa_init(struct sc_mouse_aoa *mouse, struct sc_aoa *aoa);
+sc_hid_mouse_init(struct sc_hid_mouse *mouse, struct sc_aoa *aoa);

 void
-sc_mouse_aoa_destroy(struct sc_mouse_aoa *mouse);
+sc_hid_mouse_destroy(struct sc_hid_mouse *mouse);

 #endif
--- a/app/src/usb/keyboard_aoa.c
+++ b/app/src/usb/keyboard_aoa.c
@ -1,110 +0,0 @@
-#include "keyboard_aoa.h"
-
-#include <assert.h>
-
-#include "input_events.h"
-#include "util/log.h"
-
-/** Downcast key processor to keyboard_aoa */
-#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_aoa, key_processor)
-
-#define HID_KEYBOARD_ACCESSORY_ID 1
-
-static bool
-push_mod_lock_state(struct sc_keyboard_aoa *kb, uint16_t mods_state) {
-    struct sc_hid_event hid_event;
-    if (!sc_hid_keyboard_event_from_mods(&hid_event, mods_state)) {
-        // Nothing to do
-        return true;
-    }
-
-    if (!sc_aoa_push_hid_event(kb->aoa, HID_KEYBOARD_ACCESSORY_ID,
-                               &hid_event)) {
-        LOGW("Could not request HID event (mod lock state)");
-        return false;
-    }
-
-    LOGD("HID keyboard state synchronized");
-
-    return true;
-}
-
-static void
-sc_key_processor_process_key(struct sc_key_processor *kp,
-                             const struct sc_key_event *event,
-                             uint64_t ack_to_wait) {
-    if (event->repeat) {
-        // In USB HID protocol, key repeat is handled by the host (Android), so
-        // just ignore key repeat here.
-        return;
-    }
-
-    struct sc_keyboard_aoa *kb = DOWNCAST(kp);
-
-    struct sc_hid_event hid_event;
-
-    // Not all keys are supported, just ignore unsupported keys
-    if (sc_hid_keyboard_event_from_key(&kb->hid, &hid_event, event)) {
-        if (!kb->mod_lock_synchronized) {
-            // Inject CAPSLOCK and/or NUMLOCK if necessary to synchronize
-            // keyboard state
-            if (push_mod_lock_state(kb, event->mods_state)) {
-                kb->mod_lock_synchronized = true;
-            }
-        }
-
-        // If ack_to_wait is != SC_SEQUENCE_INVALID, then Ctrl+v is pressed, so
-        // clipboard synchronization has been requested. Wait until clipboard
-        // synchronization is acknowledged by the server, otherwise it could
-        // paste the old clipboard content.
-
-        if (!sc_aoa_push_hid_event_with_ack_to_wait(kb->aoa,
-                                                    HID_KEYBOARD_ACCESSORY_ID,
-                                                    &hid_event,
-                                                    ack_to_wait)) {
-            LOGW("Could not request HID event (key)");
-        }
-    }
-}
-
-bool
-sc_keyboard_aoa_init(struct sc_keyboard_aoa *kb, struct sc_aoa *aoa) {
-    kb->aoa = aoa;
-
-    bool ok = sc_aoa_setup_hid(aoa, HID_KEYBOARD_ACCESSORY_ID,
-                               SC_HID_KEYBOARD_REPORT_DESC,
-                               SC_HID_KEYBOARD_REPORT_DESC_LEN);
-    if (!ok) {
-        LOGW("Register HID keyboard failed");
-        return false;
-    }
-
-    sc_hid_keyboard_init(&kb->hid);
-
-    kb->mod_lock_synchronized = false;
-
-    static const struct sc_key_processor_ops ops = {
-        .process_key = sc_key_processor_process_key,
-        // Never forward text input via HID (all the keys are injected
-        // separately)
-        .process_text = NULL,
-    };
-
-    // Clipboard synchronization is requested over the control socket, while HID
-    // events are sent over AOA, so it must wait for clipboard synchronization
-    // to be acknowledged by the device before injecting Ctrl+v.
-    kb->key_processor.async_paste = true;
-    kb->key_processor.hid = true;
-    kb->key_processor.ops = &ops;
-
-    return true;
-}
-
-void
-sc_keyboard_aoa_destroy(struct sc_keyboard_aoa *kb) {
-    // Unregister HID keyboard so the soft keyboard shows again on Android
-    bool ok = sc_aoa_unregister_hid(kb->aoa, HID_KEYBOARD_ACCESSORY_ID);
-    if (!ok) {
-        LOGW("Could not unregister HID keyboard");
-    }
-}
--- a/app/src/usb/keyboard_aoa.h
+++ b/app/src/usb/keyboard_aoa.h
@ -1,27 +0,0 @@
-#ifndef SC_KEYBOARD_AOA_H
-#define SC_KEYBOARD_AOA_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "aoa_hid.h"
-#include "hid/hid_keyboard.h"
-#include "trait/key_processor.h"
-
-struct sc_keyboard_aoa {
-    struct sc_key_processor key_processor; // key processor trait
-
-    struct sc_hid_keyboard hid;
-    struct sc_aoa *aoa;
-
-    bool mod_lock_synchronized;
-};
-
-bool
-sc_keyboard_aoa_init(struct sc_keyboard_aoa *kb, struct sc_aoa *aoa);
-
-void
-sc_keyboard_aoa_destroy(struct sc_keyboard_aoa *kb);
-
-#endif
--- a/app/src/usb/mouse_aoa.c
+++ b/app/src/usb/mouse_aoa.c
@ -1,89 +0,0 @@
-#include "mouse_aoa.h"
-
-#include <assert.h>
-
-#include "hid/hid_mouse.h"
-#include "input_events.h"
-#include "util/log.h"
-
-/** Downcast mouse processor to mouse_aoa */
-#define DOWNCAST(MP) container_of(MP, struct sc_mouse_aoa, mouse_processor)
-
-#define HID_MOUSE_ACCESSORY_ID 2
-
-static void
-sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_motion_event *event) {
-    struct sc_mouse_aoa *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_motion(&hid_event, event);
-
-    if (!sc_aoa_push_hid_event(mouse->aoa, HID_MOUSE_ACCESSORY_ID,
-                               &hid_event)) {
-        LOGW("Could not request HID event (mouse motion)");
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
-                                   const struct sc_mouse_click_event *event) {
-    struct sc_mouse_aoa *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_click(&hid_event, event);
-
-    if (!sc_aoa_push_hid_event(mouse->aoa, HID_MOUSE_ACCESSORY_ID,
-                               &hid_event)) {
-        LOGW("Could not request HID event (mouse click)");
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_scroll_event *event) {
-    struct sc_mouse_aoa *mouse = DOWNCAST(mp);
-
-    struct sc_hid_event hid_event;
-    sc_hid_mouse_event_from_scroll(&hid_event, event);
-
-    if (!sc_aoa_push_hid_event(mouse->aoa, HID_MOUSE_ACCESSORY_ID,
-                               &hid_event)) {
-        LOGW("Could not request HID event (mouse scroll)");
-    }
-}
-
-bool
-sc_mouse_aoa_init(struct sc_mouse_aoa *mouse, struct sc_aoa *aoa) {
-    mouse->aoa = aoa;
-
-    bool ok = sc_aoa_setup_hid(aoa, HID_MOUSE_ACCESSORY_ID,
-                               SC_HID_MOUSE_REPORT_DESC,
-                               SC_HID_MOUSE_REPORT_DESC_LEN);
-    if (!ok) {
-        LOGW("Register HID mouse failed");
-        return false;
-    }
-
-    static const struct sc_mouse_processor_ops ops = {
-        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
-        .process_mouse_click = sc_mouse_processor_process_mouse_click,
-        .process_mouse_scroll = sc_mouse_processor_process_mouse_scroll,
-        // Touch events not supported (coordinates are not relative)
-        .process_touch = NULL,
-    };
-
-    mouse->mouse_processor.ops = &ops;
-
-    mouse->mouse_processor.relative_mode = true;
-
-    return true;
-}
-
-void
-sc_mouse_aoa_destroy(struct sc_mouse_aoa *mouse) {
-    bool ok = sc_aoa_unregister_hid(mouse->aoa, HID_MOUSE_ACCESSORY_ID);
-    if (!ok) {
-        LOGW("Could not unregister HID mouse");
-    }
-}
--- a/app/src/usb/scrcpy_otg.c
+++ b/app/src/usb/scrcpy_otg.c
@ -10,8 +10,8 @@
 struct scrcpy_otg {
    struct sc_usb usb;
    struct sc_aoa aoa;
-    struct sc_keyboard_aoa keyboard;
-    struct sc_mouse_aoa mouse;
+    struct sc_hid_keyboard keyboard;
+    struct sc_hid_mouse mouse;

    struct sc_screen_otg screen_otg;
 };
@ -62,7 +62,7 @@ scrcpy_otg(struct scrcpy_options *options) {
    // Minimal SDL initialization
    if (SDL_Init(SDL_INIT_EVENTS)) {
        LOGE("Could not initialize SDL: %s", SDL_GetError());
-        return SCRCPY_EXIT_FAILURE;
+        return false;
    }

    atexit(SDL_Quit);
@ -73,8 +73,8 @@ scrcpy_otg(struct scrcpy_options *options) {

    enum scrcpy_exit_code ret = SCRCPY_EXIT_FAILURE;

-    struct sc_keyboard_aoa *keyboard = NULL;
-    struct sc_mouse_aoa *mouse = NULL;
+    struct sc_hid_keyboard *keyboard = NULL;
+    struct sc_hid_mouse *mouse = NULL;
    bool usb_device_initialized = false;
    bool usb_connected = false;
    bool aoa_started = false;
@ -105,6 +105,10 @@ scrcpy_otg(struct scrcpy_options *options) {

    usb_device_initialized = true;

+    LOGI("USB device: %s (%04x:%04x) %s %s", usb_device.serial,
+         (unsigned) usb_device.vid, (unsigned) usb_device.pid,
+         usb_device.manufacturer, usb_device.product);
+
    ok = sc_usb_connect(&s->usb, usb_device.device, &cbs, NULL);
    if (!ok) {
        goto end;
@ -117,18 +121,19 @@ scrcpy_otg(struct scrcpy_options *options) {
    }
    aoa_initialized = true;

-    assert(options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_AOA
-        || options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_DISABLED);
-    assert(options->mouse_input_mode == SC_MOUSE_INPUT_MODE_AOA
-        || options->mouse_input_mode == SC_MOUSE_INPUT_MODE_DISABLED);
-
    bool enable_keyboard =
-        options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_AOA;
+        options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID;
    bool enable_mouse =
-        options->mouse_input_mode == SC_MOUSE_INPUT_MODE_AOA;
+        options->mouse_input_mode == SC_MOUSE_INPUT_MODE_HID;
+
+    // If neither --hid-keyboard or --hid-mouse is passed, enable both
+    if (!enable_keyboard && !enable_mouse) {
+        enable_keyboard = true;
+        enable_mouse = true;
+    }

    if (enable_keyboard) {
-        ok = sc_keyboard_aoa_init(&s->keyboard, &s->aoa);
+        ok = sc_hid_keyboard_init(&s->keyboard, &s->aoa);
        if (!ok) {
            goto end;
        }
@ -136,7 +141,7 @@ scrcpy_otg(struct scrcpy_options *options) {
    }

    if (enable_mouse) {
-        ok = sc_mouse_aoa_init(&s->mouse, &s->aoa);
+        ok = sc_hid_mouse_init(&s->mouse, &s->aoa);
        if (!ok) {
            goto end;
        }
@ -185,10 +190,10 @@ end:
    sc_usb_stop(&s->usb);

    if (mouse) {
-        sc_mouse_aoa_destroy(&s->mouse);
+        sc_hid_mouse_destroy(&s->mouse);
    }
    if (keyboard) {
-        sc_keyboard_aoa_destroy(&s->keyboard);
+        sc_hid_keyboard_destroy(&s->keyboard);
    }

    if (aoa_initialized) {
--- a/app/src/usb/screen_otg.h
+++ b/app/src/usb/screen_otg.h
@ -6,12 +6,12 @@
 #include <stdbool.h>
 #include <SDL2/SDL.h>

-#include "keyboard_aoa.h"
-#include "mouse_aoa.h"
+#include "hid_keyboard.h"
+#include "hid_mouse.h"

 struct sc_screen_otg {
-    struct sc_keyboard_aoa *keyboard;
-    struct sc_mouse_aoa *mouse;
+    struct sc_hid_keyboard *keyboard;
+    struct sc_hid_mouse *mouse;

    SDL_Window *window;
    SDL_Renderer *renderer;
@ -22,8 +22,8 @@ struct sc_screen_otg {
 };

 struct sc_screen_otg_params {
-    struct sc_keyboard_aoa *keyboard;
-    struct sc_mouse_aoa *mouse;
+    struct sc_hid_keyboard *keyboard;
+    struct sc_hid_mouse *mouse;

    const char *window_title;
    bool always_on_top;
--- a/app/src/usb/usb.c
+++ b/app/src/usb/usb.c
@ -93,7 +93,7 @@ sc_usb_device_move(struct sc_usb_device *dst, struct sc_usb_device *src) {
    src->product = NULL;
 }

-static void
+void
 sc_usb_devices_destroy(struct sc_vec_usb_devices *usb_devices) {
    for (size_t i = 0; i < usb_devices->size; ++i) {
        sc_usb_device_destroy(&usb_devices->data[i]);
@ -213,8 +213,8 @@ sc_usb_select_device(struct sc_usb *usb, const char *serial,
    assert(sel_count == 1); // sel_idx is valid only if sel_count == 1
    struct sc_usb_device *device = &vec.data[sel_idx];

-    LOGI("USB device found:");
-    sc_usb_devices_log(SC_LOG_LEVEL_INFO, vec.data, vec.size);
+    LOGD("USB device found:");
+    sc_usb_devices_log(SC_LOG_LEVEL_DEBUG, vec.data, vec.size);

    // Move device into out_device (do not destroy device)
    sc_usb_device_move(out_device, device);
--- a/app/src/util/audiobuf.c
+++ b/app/src/util/audiobuf.c
@ -1,112 +0,0 @@
-#include "audiobuf.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <util/log.h>
-#include <util/memory.h>
-
-bool
-sc_audiobuf_init(struct sc_audiobuf *buf, size_t sample_size,
-                 uint32_t capacity) {
-    assert(sample_size);
-    assert(capacity);
-
-    // The actual capacity is (alloc_size - 1) so that head == tail is
-    // non-ambiguous
-    buf->alloc_size = capacity + 1;
-    buf->data = sc_allocarray(buf->alloc_size, sample_size);
-    if (!buf->data) {
-        LOG_OOM();
-        return false;
-    }
-
-    buf->sample_size = sample_size;
-    atomic_init(&buf->head, 0);
-    atomic_init(&buf->tail, 0);
-
-    return true;
-}
-
-void
-sc_audiobuf_destroy(struct sc_audiobuf *buf) {
-    free(buf->data);
-}
-
-uint32_t
-sc_audiobuf_read(struct sc_audiobuf *buf, void *to_, uint32_t samples_count) {
-    assert(samples_count);
-
-    uint8_t *to = to_;
-
-    // Only the reader thread can write tail without synchronization, so
-    // memory_order_relaxed is sufficient
-    uint32_t tail = atomic_load_explicit(&buf->tail, memory_order_relaxed);
-
-    // The head cursor is updated after the data is written to the array
-    uint32_t head = atomic_load_explicit(&buf->head, memory_order_acquire);
-
-    uint32_t can_read = (buf->alloc_size + head - tail) % buf->alloc_size;
-    if (samples_count > can_read) {
-        samples_count = can_read;
-    }
-
-    if (to) {
-        uint32_t right_count = buf->alloc_size - tail;
-        if (right_count > samples_count) {
-            right_count = samples_count;
-        }
-        memcpy(to,
-               buf->data + (tail * buf->sample_size),
-               right_count * buf->sample_size);
-
-        if (samples_count > right_count) {
-            uint32_t left_count = samples_count - right_count;
-            memcpy(to + (right_count * buf->sample_size),
-                   buf->data,
-                   left_count * buf->sample_size);
-        }
-    }
-
-    uint32_t new_tail = (tail + samples_count) % buf->alloc_size;
-    atomic_store_explicit(&buf->tail, new_tail, memory_order_release);
-
-    return samples_count;
-}
-
-uint32_t
-sc_audiobuf_write(struct sc_audiobuf *buf, const void *from_,
-                  uint32_t samples_count) {
-    const uint8_t *from = from_;
-
-    // Only the writer thread can write head, so memory_order_relaxed is
-    // sufficient
-    uint32_t head = atomic_load_explicit(&buf->head, memory_order_relaxed);
-
-    // The tail cursor is updated after the data is consumed by the reader
-    uint32_t tail = atomic_load_explicit(&buf->tail, memory_order_acquire);
-
-    uint32_t can_write = (buf->alloc_size + tail - head - 1) % buf->alloc_size;
-    if (samples_count > can_write) {
-        samples_count = can_write;
-    }
-
-    uint32_t right_count = buf->alloc_size - head;
-    if (right_count > samples_count) {
-        right_count = samples_count;
-    }
-    memcpy(buf->data + (head * buf->sample_size),
-           from,
-           right_count * buf->sample_size);
-
-    if (samples_count > right_count) {
-        uint32_t left_count = samples_count - right_count;
-        memcpy(buf->data,
-               from + (right_count * buf->sample_size),
-               left_count * buf->sample_size);
-    }
-
-    uint32_t new_head = (head + samples_count) % buf->alloc_size;
-    atomic_store_explicit(&buf->head, new_head, memory_order_release);
-
-    return samples_count;
-}
--- a/app/src/util/audiobuf.h
+++ b/app/src/util/audiobuf.h
@ -3,25 +3,19 @@

 #include "common.h"

-#include <assert.h>
-#include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>

+#include "util/bytebuf.h"
+
 /**
 * Wrapper around bytebuf to read and write samples
 *
 * Each sample takes sample_size bytes.
 */
 struct sc_audiobuf {
-    uint8_t *data;
-    uint32_t alloc_size; // in samples
+    struct sc_bytebuf buf;
    size_t sample_size;
-
-    atomic_uint_least32_t head; // writer cursor, in samples
-    atomic_uint_least32_t tail; // reader cursor, in samples
-    // empty: tail == head
-    // full: ((tail + 1) % alloc_size) == head
 };

 static inline uint32_t
@ -35,31 +29,66 @@ sc_audiobuf_to_bytes(struct sc_audiobuf *buf, uint32_t samples) {
    return samples * buf->sample_size;
 }

-bool
+static inline bool
 sc_audiobuf_init(struct sc_audiobuf *buf, size_t sample_size,
-                 uint32_t capacity);
+                 uint32_t capacity) {
+    buf->sample_size = sample_size;
+    return sc_bytebuf_init(&buf->buf, capacity * sample_size + 1);
+}

-void
-sc_audiobuf_destroy(struct sc_audiobuf *buf);
+static inline void
+sc_audiobuf_read(struct sc_audiobuf *buf, uint8_t *to, uint32_t samples) {
+    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
+    sc_bytebuf_read(&buf->buf, to, bytes);
+}

-uint32_t
-sc_audiobuf_read(struct sc_audiobuf *buf, void *to, uint32_t samples_count);
+static inline void
+sc_audiobuf_skip(struct sc_audiobuf *buf, uint32_t samples) {
+    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
+    sc_bytebuf_skip(&buf->buf, bytes);
+}

-uint32_t
-sc_audiobuf_write(struct sc_audiobuf *buf, const void *from,
-                  uint32_t samples_count);
+static inline void
+sc_audiobuf_write(struct sc_audiobuf *buf, const uint8_t *from,
+                  uint32_t samples) {
+    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
+    sc_bytebuf_write(&buf->buf, from, bytes);
+}

-static inline uint32_t
-sc_audiobuf_capacity(struct sc_audiobuf *buf) {
-    assert(buf->alloc_size);
-    return buf->alloc_size - 1;
+static inline void
+sc_audiobuf_prepare_write(struct sc_audiobuf *buf, const uint8_t *from,
+                          uint32_t samples) {
+    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
+    sc_bytebuf_prepare_write(&buf->buf, from, bytes);
+}
+
+static inline void
+sc_audiobuf_commit_write(struct sc_audiobuf *buf, uint32_t samples) {
+    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
+    sc_bytebuf_commit_write(&buf->buf, bytes);
 }

 static inline uint32_t
 sc_audiobuf_can_read(struct sc_audiobuf *buf) {
-    uint32_t head = atomic_load_explicit(&buf->head, memory_order_acquire);
-    uint32_t tail = atomic_load_explicit(&buf->tail, memory_order_acquire);
-    return (buf->alloc_size + head - tail) % buf->alloc_size;
+    size_t bytes = sc_bytebuf_can_read(&buf->buf);
+    return sc_audiobuf_to_samples(buf, bytes);
+}
+
+static inline uint32_t
+sc_audiobuf_can_write(struct sc_audiobuf *buf) {
+    size_t bytes = sc_bytebuf_can_write(&buf->buf);
+    return sc_audiobuf_to_samples(buf, bytes);
+}
+
+static inline uint32_t
+sc_audiobuf_capacity(struct sc_audiobuf *buf) {
+    size_t bytes = sc_bytebuf_capacity(&buf->buf);
+    return sc_audiobuf_to_samples(buf, bytes);
+}
+
+static inline void
+sc_audiobuf_destroy(struct sc_audiobuf *buf) {
+    sc_bytebuf_destroy(&buf->buf);
 }

 #endif
--- a/app/src/util/bytebuf.c
+++ b/app/src/util/bytebuf.c
@ -0,0 +1,104 @@
+#include "bytebuf.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "util/log.h"
+
+bool
+sc_bytebuf_init(struct sc_bytebuf *buf, size_t alloc_size) {
+    assert(alloc_size);
+    buf->data = malloc(alloc_size);
+    if (!buf->data) {
+        LOG_OOM();
+        return false;
+    }
+
+    buf->alloc_size = alloc_size;
+    buf->head = 0;
+    buf->tail = 0;
+
+    return true;
+}
+
+void
+sc_bytebuf_destroy(struct sc_bytebuf *buf) {
+    free(buf->data);
+}
+
+void
+sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len) {
+    assert(len);
+    assert(len <= sc_bytebuf_can_read(buf));
+    assert(buf->tail != buf->head); // the buffer could not be empty
+
+    size_t right_limit = buf->tail < buf->head ? buf->head : buf->alloc_size;
+    size_t right_len = right_limit - buf->tail;
+    if (len < right_len) {
+        right_len = len;
+    }
+    memcpy(to, buf->data + buf->tail, right_len);
+
+    if (len > right_len) {
+        memcpy(to + right_len, buf->data, len - right_len);
+    }
+
+    buf->tail = (buf->tail + len) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len) {
+    assert(len);
+    assert(len <= sc_bytebuf_can_read(buf));
+    assert(buf->tail != buf->head); // the buffer could not be empty
+
+    buf->tail = (buf->tail + len) % buf->alloc_size;
+}
+
+static inline void
+sc_bytebuf_write_step0(struct sc_bytebuf *buf, const uint8_t *from,
+                       size_t len) {
+    size_t right_len = buf->alloc_size - buf->head;
+    if (len < right_len) {
+        right_len = len;
+    }
+    memcpy(buf->data + buf->head, from, right_len);
+
+    if (len > right_len) {
+        memcpy(buf->data, from + right_len, len - right_len);
+    }
+}
+
+static inline void
+sc_bytebuf_write_step1(struct sc_bytebuf *buf, size_t len) {
+    buf->head = (buf->head + len) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len) {
+    assert(len);
+    assert(len <= sc_bytebuf_can_write(buf));
+
+    sc_bytebuf_write_step0(buf, from, len);
+    sc_bytebuf_write_step1(buf, len);
+}
+
+void
+sc_bytebuf_prepare_write(struct sc_bytebuf *buf, const uint8_t *from,
+                         size_t len) {
+    // *This function MUST NOT access buf->tail (even in assert()).*
+    // The purpose of this function is to allow a reader and a writer to access
+    // different parts of the buffer in parallel simultaneously. It is intended
+    // to be called without lock (only sc_bytebuf_commit_write() is intended to
+    // be called with lock held).
+
+    assert(len < buf->alloc_size - 1);
+    sc_bytebuf_write_step0(buf, from, len);
+}
+
+void
+sc_bytebuf_commit_write(struct sc_bytebuf *buf, size_t len) {
+    assert(len <= sc_bytebuf_can_write(buf));
+    sc_bytebuf_write_step1(buf, len);
+}
--- a/app/src/util/bytebuf.h
+++ b/app/src/util/bytebuf.h
@ -0,0 +1,114 @@
+#ifndef SC_BYTEBUF_H
+#define SC_BYTEBUF_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+struct sc_bytebuf {
+    uint8_t *data;
+    // The actual capacity is (allocated - 1) so that head == tail is
+    // non-ambiguous
+    size_t alloc_size;
+    size_t head; // writter cursor
+    size_t tail; // reader cursor
+    // empty: tail == head
+    // full: ((tail + 1) % alloc_size) == head
+};
+
+bool
+sc_bytebuf_init(struct sc_bytebuf *buf, size_t alloc_size);
+
+/**
+ * Copy from the bytebuf to a user-provided array
+ *
+ * The caller must check that len <= sc_bytebuf_read_available() (it is an
+ * error to attempt to read more bytes than available).
+ *
+ * This function is guaranteed not to write to buf->head.
+ */
+void
+sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len);
+
+/**
+ * Drop len bytes from the buffer
+ *
+ * The caller must check that len <= sc_bytebuf_read_available() (it is an
+ * error to attempt to skip more bytes than available).
+ *
+ * This function is guaranteed not to write to buf->head.
+ *
+ * It is equivalent to call sc_bytebuf_read() to some array and discard the
+ * array (but this function is more efficient since there is no copy).
+ */
+void
+sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len);
+
+/**
+ * Copy the user-provided array to the bytebuf
+ *
+ * The caller must check that len <= sc_bytebuf_write_available() (it is an
+ * error to write more bytes than the remaining available space).
+ *
+ * This function is guaranteed not to write to buf->tail.
+ */
+void
+sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len);
+
+/**
+ * Copy the user-provided array to the bytebuf, but do not advance the cursor
+ *
+ * The caller must check that len <= sc_bytebuf_write_available() (it is an
+ * error to write more bytes than the remaining available space).
+ *
+ * After this function is called, the write must be committed with
+ * sc_bytebuf_commit_write().
+ *
+ * The purpose of this mechanism is to acquire a lock only to commit the write,
+ * but not to perform the actual copy.
+ *
+ * This function is guaranteed not to access buf->tail.
+ */
+void
+sc_bytebuf_prepare_write(struct sc_bytebuf *buf, const uint8_t *from,
+                         size_t len);
+
+/**
+ * Commit a prepared write
+ */
+void
+sc_bytebuf_commit_write(struct sc_bytebuf *buf, size_t len);
+
+/**
+ * Return the number of bytes which can be read
+ *
+ * It is an error to read more bytes than available.
+ */
+static inline size_t
+sc_bytebuf_can_read(struct sc_bytebuf *buf) {
+    return (buf->alloc_size + buf->head - buf->tail) % buf->alloc_size;
+}
+
+/**
+ * Return the number of bytes which can be written
+ *
+ * It is an error to write more bytes than available.
+ */
+static inline size_t
+sc_bytebuf_can_write(struct sc_bytebuf *buf) {
+    return (buf->alloc_size + buf->tail - buf->head - 1) % buf->alloc_size;
+}
+
+/**
+ * Return the actual capacity of the buffer (can_read() + can_write())
+ */
+static inline size_t
+sc_bytebuf_capacity(struct sc_bytebuf *buf) {
+    return buf->alloc_size - 1;
+}
+
+void
+sc_bytebuf_destroy(struct sc_bytebuf *buf);
+
+#endif
--- a/app/src/util/log.c
+++ b/app/src/util/log.c
@ -147,7 +147,7 @@ sc_sdl_log_print(void *userdata, int category, SDL_LogPriority priority,
 }

 void
-sc_log_configure(void) {
+sc_log_configure() {
    SDL_LogSetOutputFunction(sc_sdl_log_print, NULL);
    // Redirect FFmpeg logs to SDL logs
    av_log_set_callback(sc_av_log_callback);
--- a/app/src/util/log.h
+++ b/app/src/util/log.h
@ -36,6 +36,6 @@ sc_log_windows_error(const char *prefix, int error);
 #endif

 void
-sc_log_configure(void);
+sc_log_configure();

 #endif
--- a/app/src/util/str.c
+++ b/app/src/util/str.c
@ -3,7 +3,6 @@
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

@ -334,22 +333,3 @@ sc_str_remove_trailing_cr(char *s, size_t len) {
    }
    return len;
 }
-
-char *
-sc_str_to_hex_string(const uint8_t *data, size_t size) {
-    size_t buffer_size = size * 3 + 1;
-    char *buffer = malloc(buffer_size);
-    if (!buffer) {
-        LOG_OOM();
-        return NULL;
-    }
-
-    for (size_t i = 0; i < size; ++i) {
-        snprintf(buffer + i * 3, 4, "%02X ", data[i]);
-    }
-
-    // Remove the final space
-    buffer[size * 3] = '\0';
-
-    return buffer;
-}
--- a/app/src/util/str.h
+++ b/app/src/util/str.h
@ -138,10 +138,4 @@ sc_str_index_of_column(const char *s, unsigned col, const char *seps);
 size_t
 sc_str_remove_trailing_cr(char *s, size_t len);

-/**
- * Convert binary data to hexadecimal string
- */
-char *
-sc_str_to_hex_string(const uint8_t *data, size_t len);
-
 #endif
--- a/app/src/util/vecdeque.h
+++ b/app/src/util/vecdeque.h
@ -190,10 +190,10 @@ sc_vecdeque_reallocdata_(void *ptr, size_t newcap, size_t item_size,

    size_t right_len = MIN(size, oldcap - oldorigin);
    assert(right_len);
-    memcpy(newptr, (char *) ptr + (oldorigin * item_size), right_len * item_size);
+    memcpy(newptr, ptr + (oldorigin * item_size), right_len * item_size);

    if (size > right_len) {
-        memcpy((char *) newptr + (right_len * item_size), ptr,
+        memcpy(newptr + (right_len * item_size), ptr,
               (size - right_len) * item_size);
    }

--- a/app/tests/test_audiobuf.c
+++ b/app/tests/test_audiobuf.c
@ -1,128 +0,0 @@
-#include "common.h"
-
-#include <assert.h>
-#include <string.h>
-
-#include "util/audiobuf.h"
-
-static void test_audiobuf_simple(void) {
-    struct sc_audiobuf buf;
-    uint32_t data[20];
-
-    bool ok = sc_audiobuf_init(&buf, 4, 20);
-    assert(ok);
-
-    uint32_t samples[] = {1, 2, 3, 4, 5};
-    uint32_t w = sc_audiobuf_write(&buf, samples, 5);
-    assert(w == 5);
-
-    uint32_t r = sc_audiobuf_read(&buf, data, 4);
-    assert(r == 4);
-    assert(!memcmp(data, samples, 16));
-
-    uint32_t samples2[] = {6, 7, 8};
-    w = sc_audiobuf_write(&buf, samples2, 3);
-    assert(w == 3);
-
-    uint32_t single = 9;
-    w = sc_audiobuf_write(&buf, &single, 1);
-    assert(w == 1);
-
-    r = sc_audiobuf_read(&buf, &data[4], 8);
-    assert(r == 5);
-
-    uint32_t expected[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
-    assert(!memcmp(data, expected, 36));
-
-    sc_audiobuf_destroy(&buf);
-}
-
-static void test_audiobuf_boundaries(void) {
-    struct sc_audiobuf buf;
-    uint32_t data[20];
-
-    bool ok = sc_audiobuf_init(&buf, 4, 20);
-    assert(ok);
-
-    uint32_t samples[] = {1, 2, 3, 4, 5, 6};
-    uint32_t w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 6);
-
-    w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 6);
-
-    w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 6);
-
-    uint32_t r = sc_audiobuf_read(&buf, data, 9);
-    assert(r == 9);
-
-    uint32_t expected[] = {1, 2, 3, 4, 5, 6, 1, 2, 3};
-    assert(!memcmp(data, expected, 36));
-
-    uint32_t samples2[] = {7, 8, 9, 10, 11};
-    w = sc_audiobuf_write(&buf, samples2, 5);
-    assert(w == 5);
-
-    uint32_t single = 12;
-    w = sc_audiobuf_write(&buf, &single, 1);
-    assert(w == 1);
-
-    w = sc_audiobuf_read(&buf, NULL, 3);
-    assert(w == 3);
-
-    assert(sc_audiobuf_can_read(&buf) == 12);
-
-    r = sc_audiobuf_read(&buf, data, 12);
-    assert(r == 12);
-
-    uint32_t expected2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
-    assert(!memcmp(data, expected2, 48));
-
-    sc_audiobuf_destroy(&buf);
-}
-
-static void test_audiobuf_partial_read_write(void) {
-    struct sc_audiobuf buf;
-    uint32_t data[15];
-
-    bool ok = sc_audiobuf_init(&buf, 4, 10);
-    assert(ok);
-
-    uint32_t samples[] = {1, 2, 3, 4, 5, 6};
-    uint32_t w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 6);
-
-    w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 4);
-
-    w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 0);
-
-    uint32_t r = sc_audiobuf_read(&buf, data, 3);
-    assert(r == 3);
-
-    uint32_t expected[] = {1, 2, 3};
-    assert(!memcmp(data, expected, 12));
-
-    w = sc_audiobuf_write(&buf, samples, 6);
-    assert(w == 3);
-
-    r = sc_audiobuf_read(&buf, data, 15);
-    assert(r == 10);
-    uint32_t expected2[] = {4, 5, 6, 1, 2, 3, 4, 1, 2, 3};
-    assert(!memcmp(data, expected2, 12));
-
-    sc_audiobuf_destroy(&buf);
-}
-
-int main(int argc, char *argv[]) {
-    (void) argc;
-    (void) argv;
-
-    test_audiobuf_simple();
-    test_audiobuf_boundaries();
-    test_audiobuf_partial_read_write();
-
-    return 0;
-}
--- a/app/tests/test_bytebuf.c
+++ b/app/tests/test_bytebuf.c
@ -0,0 +1,126 @@
+#include "common.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "util/bytebuf.h"
+
+void test_bytebuf_simple(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[20];
+
+    bool ok = sc_bytebuf_init(&buf, 20);
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello", sizeof("hello") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 5);
+
+    sc_bytebuf_read(&buf, data, 4);
+    assert(!strncmp((char *) data, "hell", 4));
+
+    sc_bytebuf_write(&buf, (uint8_t *) " world", sizeof(" world") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 7);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
+    assert(sc_bytebuf_can_read(&buf) == 8);
+
+    sc_bytebuf_read(&buf, &data[4], 8);
+    assert(sc_bytebuf_can_read(&buf) == 0);
+
+    data[12] = '\0';
+    assert(!strcmp((char *) data, "hello world!"));
+    assert(sc_bytebuf_can_read(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+void test_bytebuf_boundaries(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[20];
+
+    bool ok = sc_bytebuf_init(&buf, 20);
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 6);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 12);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 18);
+
+    sc_bytebuf_read(&buf, data, 9);
+    assert(!strncmp((char *) data, "hello hel", 9));
+    assert(sc_bytebuf_can_read(&buf) == 9);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "world", sizeof("world") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 14);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
+    assert(sc_bytebuf_can_read(&buf) == 15);
+
+    sc_bytebuf_skip(&buf, 3);
+    assert(sc_bytebuf_can_read(&buf) == 12);
+
+    sc_bytebuf_read(&buf, data, 12);
+    data[12] = '\0';
+    assert(!strcmp((char *) data, "hello world!"));
+    assert(sc_bytebuf_can_read(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+void test_bytebuf_two_steps_write(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[20];
+
+    bool ok = sc_bytebuf_init(&buf, 20);
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 6);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 12);
+
+    sc_bytebuf_prepare_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 12); // write not committed yet
+
+    sc_bytebuf_read(&buf, data, 9);
+    assert(!strncmp((char *) data, "hello hel", 3));
+    assert(sc_bytebuf_can_read(&buf) == 3);
+
+    sc_bytebuf_commit_write(&buf, sizeof("hello ") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 9);
+
+    sc_bytebuf_prepare_write(&buf, (uint8_t *) "world", sizeof("world") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 9); // write not committed yet
+
+    sc_bytebuf_commit_write(&buf, sizeof("world") - 1);
+    assert(sc_bytebuf_can_read(&buf) == 14);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
+    assert(sc_bytebuf_can_read(&buf) == 15);
+
+    sc_bytebuf_skip(&buf, 3);
+    assert(sc_bytebuf_can_read(&buf) == 12);
+
+    sc_bytebuf_read(&buf, data, 12);
+    data[12] = '\0';
+    assert(!strcmp((char *) data, "hello world!"));
+    assert(sc_bytebuf_can_read(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+int main(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_bytebuf_simple();
+    test_bytebuf_boundaries();
+    test_bytebuf_two_steps_write();
+
+    return 0;
+}
--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@ -1,7 +1,6 @@
 #include "common.h"

 #include <assert.h>
-#include <stdint.h>
 #include <string.h>

 #include "control_msg.h"
@ -17,11 +16,11 @@ static void test_serialize_inject_keycode(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 14);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
        0x01, // AKEY_EVENT_ACTION_UP
        0x00, 0x00, 0x00, 0x42, // AKEYCODE_ENTER
@ -39,11 +38,11 @@ static void test_serialize_inject_text(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 18);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_INJECT_TEXT,
        0x00, 0x00, 0x00, 0x0d, // text length
        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
@ -59,11 +58,11 @@ static void test_serialize_inject_text_long(void) {
    text[SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
    msg.inject_text.text = text;

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);

-    uint8_t expected[5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
+    unsigned char expected[5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
    expected[0] = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
    expected[1] = 0x00;
    expected[2] = 0x00;
@ -96,11 +95,11 @@ static void test_serialize_inject_touch_event(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 32);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
        0x00, // AKEY_EVENT_ACTION_DOWN
        0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21, // pointer id
@ -133,11 +132,11 @@ static void test_serialize_inject_scroll_event(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 21);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
        0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x02, // 260 1026
        0x04, 0x38, 0x07, 0x80, // 1080 1920
@ -156,11 +155,11 @@ static void test_serialize_back_or_screen_on(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 2);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
        0x01, // AKEY_EVENT_ACTION_UP
    };
@ -172,11 +171,11 @@ static void test_serialize_expand_notification_panel(void) {
        .type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 1);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@ -187,11 +186,11 @@ static void test_serialize_expand_settings_panel(void) {
        .type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 1);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@ -202,11 +201,11 @@ static void test_serialize_collapse_panels(void) {
        .type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 1);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@ -220,11 +219,11 @@ static void test_serialize_get_clipboard(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 2);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
        SC_COPY_KEY_COPY,
    };
@ -241,11 +240,11 @@ static void test_serialize_set_clipboard(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 27);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
        1, // paste
@ -270,11 +269,11 @@ static void test_serialize_set_clipboard_long(void) {
    text[SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH] = '\0';
    msg.set_clipboard.text = text;

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == SC_CONTROL_MSG_MAX_SIZE);

-    uint8_t expected[SC_CONTROL_MSG_MAX_SIZE] = {
+    unsigned char expected[SC_CONTROL_MSG_MAX_SIZE] = {
        SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
        1, // paste
@ -297,11 +296,11 @@ static void test_serialize_set_screen_power_mode(void) {
        },
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 2);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
        0x02, // SC_SCREEN_POWER_MODE_NORMAL
    };
@ -313,78 +312,16 @@ static void test_serialize_rotate_device(void) {
        .type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
    };

-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
    assert(size == 1);

-    const uint8_t expected[] = {
+    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }

-static void test_serialize_uhid_create(void) {
-    const uint8_t report_desc[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_UHID_CREATE,
-        .uhid_create = {
-            .id = 42,
-            .report_desc_size = sizeof(report_desc),
-            .report_desc = report_desc,
-        },
-    };
-
-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 16);
-
-    const uint8_t expected[] = {
-        SC_CONTROL_MSG_TYPE_UHID_CREATE,
-        0, 42, // id
-        0, 11, // size
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_uhid_input(void) {
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_UHID_INPUT,
-        .uhid_input = {
-            .id = 42,
-            .size = 5,
-            .data = {1, 2, 3, 4, 5},
-        },
-    };
-
-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 10);
-
-    const uint8_t expected[] = {
-        SC_CONTROL_MSG_TYPE_UHID_INPUT,
-        0, 42, // id
-        0, 5, // size
-        1, 2, 3, 4, 5,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_open_hard_keyboard(void) {
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS,
-    };
-
-    uint8_t buf[SC_CONTROL_MSG_MAX_SIZE];
-    size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 1);
-
-    const uint8_t expected[] = {
-        SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;
@ -403,8 +340,5 @@ int main(int argc, char *argv[]) {
    test_serialize_set_clipboard_long();
    test_serialize_set_screen_power_mode();
    test_serialize_rotate_device();
-    test_serialize_uhid_create();
-    test_serialize_uhid_input();
-    test_serialize_open_hard_keyboard();
    return 0;
 }
--- a/app/tests/test_device_msg_deserialize.c
+++ b/app/tests/test_device_msg_deserialize.c
@ -1,32 +1,32 @@
 #include "common.h"

 #include <assert.h>
-#include <stdint.h>
-#include <stdio.h>
 #include <string.h>

 #include "device_msg.h"

+#include <stdio.h>
+
 static void test_deserialize_clipboard(void) {
-    const uint8_t input[] = {
+    const unsigned char input[] = {
        DEVICE_MSG_TYPE_CLIPBOARD,
        0x00, 0x00, 0x00, 0x03, // text length
        0x41, 0x42, 0x43, // "ABC"
    };

-    struct sc_device_msg msg;
-    ssize_t r = sc_device_msg_deserialize(input, sizeof(input), &msg);
+    struct device_msg msg;
+    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
    assert(r == 8);

    assert(msg.type == DEVICE_MSG_TYPE_CLIPBOARD);
    assert(msg.clipboard.text);
    assert(!strcmp("ABC", msg.clipboard.text));

-    sc_device_msg_destroy(&msg);
+    device_msg_destroy(&msg);
 }

 static void test_deserialize_clipboard_big(void) {
-    uint8_t input[DEVICE_MSG_MAX_SIZE];
+    unsigned char input[DEVICE_MSG_MAX_SIZE];
    input[0] = DEVICE_MSG_TYPE_CLIPBOARD;
    input[1] = (DEVICE_MSG_TEXT_MAX_LENGTH & 0xff000000u) >> 24;
    input[2] = (DEVICE_MSG_TEXT_MAX_LENGTH & 0x00ff0000u) >> 16;
@ -35,8 +35,8 @@ static void test_deserialize_clipboard_big(void) {

    memset(input + 5, 'a', DEVICE_MSG_TEXT_MAX_LENGTH);

-    struct sc_device_msg msg;
-    ssize_t r = sc_device_msg_deserialize(input, sizeof(input), &msg);
+    struct device_msg msg;
+    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
    assert(r == DEVICE_MSG_MAX_SIZE);

    assert(msg.type == DEVICE_MSG_TYPE_CLIPBOARD);
@ -44,45 +44,23 @@ static void test_deserialize_clipboard_big(void) {
    assert(strlen(msg.clipboard.text) == DEVICE_MSG_TEXT_MAX_LENGTH);
    assert(msg.clipboard.text[0] == 'a');

-    sc_device_msg_destroy(&msg);
+    device_msg_destroy(&msg);
 }

 static void test_deserialize_ack_set_clipboard(void) {
-    const uint8_t input[] = {
+    const unsigned char input[] = {
        DEVICE_MSG_TYPE_ACK_CLIPBOARD,
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
    };

-    struct sc_device_msg msg;
-    ssize_t r = sc_device_msg_deserialize(input, sizeof(input), &msg);
+    struct device_msg msg;
+    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
    assert(r == 9);

    assert(msg.type == DEVICE_MSG_TYPE_ACK_CLIPBOARD);
    assert(msg.ack_clipboard.sequence == UINT64_C(0x0102030405060708));
 }

-static void test_deserialize_uhid_output(void) {
-    const uint8_t input[] = {
-        DEVICE_MSG_TYPE_UHID_OUTPUT,
-        0, 42, // id
-        0, 5, // size
-        0x01, 0x02, 0x03, 0x04, 0x05, // data
-    };
-
-    struct sc_device_msg msg;
-    ssize_t r = sc_device_msg_deserialize(input, sizeof(input), &msg);
-    assert(r == 10);
-
-    assert(msg.type == DEVICE_MSG_TYPE_UHID_OUTPUT);
-    assert(msg.uhid_output.id == 42);
-    assert(msg.uhid_output.size == 5);
-
-    uint8_t expected[] = {1, 2, 3, 4, 5};
-    assert(!memcmp(msg.uhid_output.data, expected, sizeof(expected)));
-
-    sc_device_msg_destroy(&msg);
-}
-
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;
@ -90,6 +68,5 @@ int main(int argc, char *argv[]) {
    test_deserialize_clipboard();
    test_deserialize_clipboard_big();
    test_deserialize_ack_set_clipboard();
-    test_deserialize_uhid_output();
    return 0;
 }
--- a/app/tests/test_orientation.c
+++ b/app/tests/test_orientation.c
@ -1,91 +0,0 @@
-#include "common.h"
-
-#include <assert.h>
-
-#include "options.h"
-
-static void test_transforms(void) {
-    #define O(X) SC_ORIENTATION_ ## X
-    #define ASSERT_TRANSFORM(SRC, TR, RES) \
-        assert(sc_orientation_apply(O(SRC), O(TR)) == O(RES));
-
-    ASSERT_TRANSFORM(0, 0, 0);
-    ASSERT_TRANSFORM(0, 90, 90);
-    ASSERT_TRANSFORM(0, 180, 180);
-    ASSERT_TRANSFORM(0, 270, 270);
-    ASSERT_TRANSFORM(0, FLIP_0, FLIP_0);
-    ASSERT_TRANSFORM(0, FLIP_90, FLIP_90);
-    ASSERT_TRANSFORM(0, FLIP_180, FLIP_180);
-    ASSERT_TRANSFORM(0, FLIP_270, FLIP_270);
-
-    ASSERT_TRANSFORM(90, 0, 90);
-    ASSERT_TRANSFORM(90, 90, 180);
-    ASSERT_TRANSFORM(90, 180, 270);
-    ASSERT_TRANSFORM(90, 270, 0);
-    ASSERT_TRANSFORM(90, FLIP_0, FLIP_270);
-    ASSERT_TRANSFORM(90, FLIP_90, FLIP_0);
-    ASSERT_TRANSFORM(90, FLIP_180, FLIP_90);
-    ASSERT_TRANSFORM(90, FLIP_270, FLIP_180);
-
-    ASSERT_TRANSFORM(180, 0, 180);
-    ASSERT_TRANSFORM(180, 90, 270);
-    ASSERT_TRANSFORM(180, 180, 0);
-    ASSERT_TRANSFORM(180, 270, 90);
-    ASSERT_TRANSFORM(180, FLIP_0, FLIP_180);
-    ASSERT_TRANSFORM(180, FLIP_90, FLIP_270);
-    ASSERT_TRANSFORM(180, FLIP_180, FLIP_0);
-    ASSERT_TRANSFORM(180, FLIP_270, FLIP_90);
-
-    ASSERT_TRANSFORM(270, 0, 270);
-    ASSERT_TRANSFORM(270, 90, 0);
-    ASSERT_TRANSFORM(270, 180, 90);
-    ASSERT_TRANSFORM(270, 270, 180);
-    ASSERT_TRANSFORM(270, FLIP_0, FLIP_90);
-    ASSERT_TRANSFORM(270, FLIP_90, FLIP_180);
-    ASSERT_TRANSFORM(270, FLIP_180, FLIP_270);
-    ASSERT_TRANSFORM(270, FLIP_270, FLIP_0);
-
-    ASSERT_TRANSFORM(FLIP_0, 0, FLIP_0);
-    ASSERT_TRANSFORM(FLIP_0, 90, FLIP_90);
-    ASSERT_TRANSFORM(FLIP_0, 180, FLIP_180);
-    ASSERT_TRANSFORM(FLIP_0, 270, FLIP_270);
-    ASSERT_TRANSFORM(FLIP_0, FLIP_0, 0);
-    ASSERT_TRANSFORM(FLIP_0, FLIP_90, 90);
-    ASSERT_TRANSFORM(FLIP_0, FLIP_180, 180);
-    ASSERT_TRANSFORM(FLIP_0, FLIP_270, 270);
-
-    ASSERT_TRANSFORM(FLIP_90, 0, FLIP_90);
-    ASSERT_TRANSFORM(FLIP_90, 90, FLIP_180);
-    ASSERT_TRANSFORM(FLIP_90, 180, FLIP_270);
-    ASSERT_TRANSFORM(FLIP_90, 270, FLIP_0);
-    ASSERT_TRANSFORM(FLIP_90, FLIP_0, 270);
-    ASSERT_TRANSFORM(FLIP_90, FLIP_90, 0);
-    ASSERT_TRANSFORM(FLIP_90, FLIP_180, 90);
-    ASSERT_TRANSFORM(FLIP_90, FLIP_270, 180);
-
-    ASSERT_TRANSFORM(FLIP_180, 0, FLIP_180);
-    ASSERT_TRANSFORM(FLIP_180, 90, FLIP_270);
-    ASSERT_TRANSFORM(FLIP_180, 180, FLIP_0);
-    ASSERT_TRANSFORM(FLIP_180, 270, FLIP_90);
-    ASSERT_TRANSFORM(FLIP_180, FLIP_0, 180);
-    ASSERT_TRANSFORM(FLIP_180, FLIP_90, 270);
-    ASSERT_TRANSFORM(FLIP_180, FLIP_180, 0);
-    ASSERT_TRANSFORM(FLIP_180, FLIP_270, 90);
-
-    ASSERT_TRANSFORM(FLIP_270, 0, FLIP_270);
-    ASSERT_TRANSFORM(FLIP_270, 90, FLIP_0);
-    ASSERT_TRANSFORM(FLIP_270, 180, FLIP_90);
-    ASSERT_TRANSFORM(FLIP_270, 270, FLIP_180);
-    ASSERT_TRANSFORM(FLIP_270, FLIP_0, 90);
-    ASSERT_TRANSFORM(FLIP_270, FLIP_90, 180);
-    ASSERT_TRANSFORM(FLIP_270, FLIP_180, 270);
-    ASSERT_TRANSFORM(FLIP_270, FLIP_270, 0);
-}
-
-int main(int argc, char *argv[]) {
-    (void) argc;
-    (void) argv;
-
-    test_transforms();
-    return 0;
-}
--- a/app/tests/test_str.c
+++ b/app/tests/test_str.c
@ -269,25 +269,21 @@ static void test_parse_integer_with_suffix(void) {

    char buf[32];

-    int r = snprintf(buf, sizeof(buf), "%ldk", LONG_MAX / 2000);
-    assert(r >= 0 && (size_t) r < sizeof(buf));
+    sprintf(buf, "%ldk", LONG_MAX / 2000);
    ok = sc_str_parse_integer_with_suffix(buf, &value);
    assert(ok);
    assert(value == LONG_MAX / 2000 * 1000);

-    r = snprintf(buf, sizeof(buf), "%ldm", LONG_MAX / 2000);
-    assert(r >= 0 && (size_t) r < sizeof(buf));
+    sprintf(buf, "%ldm", LONG_MAX / 2000);
    ok = sc_str_parse_integer_with_suffix(buf, &value);
    assert(!ok);

-    r = snprintf(buf, sizeof(buf), "%ldk", LONG_MIN / 2000);
-    assert(r >= 0 && (size_t) r < sizeof(buf));
+    sprintf(buf, "%ldk", LONG_MIN / 2000);
    ok = sc_str_parse_integer_with_suffix(buf, &value);
    assert(ok);
    assert(value == LONG_MIN / 2000 * 1000);

-    r = snprintf(buf, sizeof(buf), "%ldm", LONG_MIN / 2000);
-    assert(r >= 0 && (size_t) r < sizeof(buf));
+    sprintf(buf, "%ldm", LONG_MIN / 2000);
    ok = sc_str_parse_integer_with_suffix(buf, &value);
    assert(!ok);
 }
@ -362,7 +358,7 @@ static void test_index_of_column(void) {
    assert(sc_str_index_of_column("  a bc  d", 1, " ") == 2);
 }

-static void test_remove_trailing_cr(void) {
+static void test_remove_trailing_cr() {
    char s[] = "abc\r";
    sc_str_remove_trailing_cr(s, sizeof(s) - 1);
    assert(!strcmp(s, "abc"));
--- a/app/tests/test_vecdeque.c
+++ b/app/tests/test_vecdeque.c
@ -102,7 +102,7 @@ static void test_vecdeque_reserve(void) {
    sc_vecdeque_destroy(&vdq);
 }

-static void test_vecdeque_grow(void) {
+static void test_vecdeque_grow() {
    struct SC_VECDEQUE(int) vdq = SC_VECDEQUE_INITIALIZER;

    bool ok = sc_vecdeque_reserve(&vdq, 20);
@ -142,7 +142,7 @@ static void test_vecdeque_grow(void) {
    sc_vecdeque_destroy(&vdq);
 }

-static void test_vecdeque_push_hole(void) {
+static void test_vecdeque_push_hole() {
    struct SC_VECDEQUE(int) vdq = SC_VECDEQUE_INITIALIZER;

    bool ok = sc_vecdeque_reserve(&vdq, 20);
--- a/app/tests/test_vector.c
+++ b/app/tests/test_vector.c
@ -187,7 +187,7 @@ static void test_vector_index_of(void) {
    sc_vector_destroy(&vec);
 }

-static void test_vector_grow(void) {
+static void test_vector_grow() {
    struct SC_VECTOR(int) vec = SC_VECTOR_INITIALIZER;

    bool ok;
--- a/build.gradle
+++ b/build.gradle
@ -7,7 +7,7 @@ buildscript {
        mavenCentral()
    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:8.1.3'
+        classpath 'com.android.tools.build:gradle:7.4.0'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
@ -23,3 +23,7 @@ allprojects {
        options.compilerArgs << "-Xlint:deprecation"
    }
 }
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}
--- a/config/android-checkstyle.gradle
+++ b/config/android-checkstyle.gradle
@ -2,7 +2,7 @@ apply plugin: 'checkstyle'
 check.dependsOn 'checkstyle'

 checkstyle {
-    toolVersion = '10.12.5'
+    toolVersion = '9.0.1'
 }

 task checkstyle(type: Checkstyle) {
--- a/cross_win32.txt
+++ b/cross_win32.txt
@ -6,7 +6,7 @@ c = 'i686-w64-mingw32-gcc'
 cpp = 'i686-w64-mingw32-g++'
 ar = 'i686-w64-mingw32-ar'
 strip = 'i686-w64-mingw32-strip'
-pkg-config = 'i686-w64-mingw32-pkg-config'
+pkgconfig = 'i686-w64-mingw32-pkg-config'
 windres = 'i686-w64-mingw32-windres'

 [host_machine]
@ -14,3 +14,8 @@ system = 'windows'
 cpu_family = 'x86'
 cpu = 'i686'
 endian = 'little'
+
+[properties]
+prebuilt_ffmpeg = 'ffmpeg-6.0-scrcpy-4/win32'
+prebuilt_sdl2 = 'SDL2-2.26.4/i686-w64-mingw32'
+prebuilt_libusb = 'libusb-1.0.26/libusb-MinGW-Win32'
--- a/cross_win64.txt
+++ b/cross_win64.txt
@ -6,7 +6,7 @@ c = 'x86_64-w64-mingw32-gcc'
 cpp = 'x86_64-w64-mingw32-g++'
 ar = 'x86_64-w64-mingw32-ar'
 strip = 'x86_64-w64-mingw32-strip'
-pkg-config = 'x86_64-w64-mingw32-pkg-config'
+pkgconfig = 'x86_64-w64-mingw32-pkg-config'
 windres = 'x86_64-w64-mingw32-windres'

 [host_machine]
@ -14,3 +14,8 @@ system = 'windows'
 cpu_family = 'x86'
 cpu = 'x86_64'
 endian = 'little'
+
+[properties]
+prebuilt_ffmpeg = 'ffmpeg-6.0-scrcpy-4/win64'
+prebuilt_sdl2 = 'SDL2-2.26.4/x86_64-w64-mingw32'
+prebuilt_libusb = 'libusb-1.0.26/libusb-MinGW-x64'
--- a/doc/audio.md
+++ b/doc/audio.md
@ -62,37 +62,15 @@ scrcpy --audio-source=mic --no-video --no-playback --record=file.opus

 ## Codec

-The audio codec can be selected. The possible values are `opus` (default),
-`aac`, `flac` and `raw` (uncompressed PCM 16-bit LE):
+The audio codec can be selected. The possible values are `opus` (default), `aac`
+and `raw` (uncompressed PCM 16-bit LE):

 ```bash
 scrcpy --audio-codec=opus  # default
 scrcpy --audio-codec=aac
-scrcpy --audio-codec=flac
 scrcpy --audio-codec=raw
 ```

-In particular, if you get the following error:
-
-> Failed to initialize audio/opus, error 0xfffffffe
-
-then your device has no Opus encoder: try `scrcpy --audio-codec=aac`.
-
-For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
-check `--audio-codec-options` in the manpage or in `scrcpy --help`.
-
-For example, to change the [FLAC compression level]:
-
-```bash
-scrcpy --audio-codec=flac --audio-codec-options=flac-compression-level=8
-```
-
-[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
-[FLAC compression level]: https://developer.android.com/reference/android/media/MediaFormat#KEY_FLAC_COMPRESSION_LEVEL
-
-
-## Encoder
-
 Several encoders may be available on the device. They can be listed by:

 ```bash
@ -101,14 +79,19 @@ scrcpy --list-encoders

 To select a specific encoder:

-```bash
+```
 scrcpy --audio-codec=opus --audio-encoder='c2.android.opus.encoder'
 ```

+For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
+check `--audio-codec-options` in the manpage or in `scrcpy --help`.
+
+[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
+

 ## Bit rate

-The default audio bit rate is 128Kbps. To change it:
+The default video bit-rate is 128Kbps. To change it:

 ```bash
 scrcpy --audio-bit-rate=64K
--- a/doc/build.md
+++ b/doc/build.md
@ -58,7 +58,7 @@ sudo apt install gcc git pkg-config meson ninja-build libsdl2-dev \
                 libswresample-dev libusb-1.0-0-dev

 # server build dependencies
-sudo apt install openjdk-17-jdk
+sudo apt install openjdk-11-jdk
 ```

 On old versions (like Ubuntu 16.04), `meson` is too old. In that case, install
@ -77,7 +77,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 libusb1-devel meson gcc make
+sudo dnf install SDL2-devel ffms2-devel libusb-devel meson gcc make

 # server build dependencies
 sudo dnf install java-devel
@ -100,7 +100,7 @@ sudo apt install mingw-w64 mingw-w64-tools
 You also need the JDK to build the server:

 ```bash
-sudo apt install openjdk-17-jdk
+sudo apt install openjdk-11-jdk
 ```

 Then generate the releases:
@ -168,13 +168,13 @@ brew install sdl2 ffmpeg libusb
 brew install pkg-config meson
 ```

-Additionally, if you want to build the server, install Java 17 from Caskroom, and
+Additionally, if you want to build the server, install Java 8 from Caskroom, and
 make it available from the `PATH`:

 ```bash
 brew tap homebrew/cask-versions
-brew install adoptopenjdk/openjdk/adoptopenjdk17
-export JAVA_HOME="$(/usr/libexec/java_home --version 1.17)"
+brew install adoptopenjdk/openjdk/adoptopenjdk11
+export JAVA_HOME="$(/usr/libexec/java_home --version 1.11)"
 export PATH="$JAVA_HOME/bin:$PATH"
 ```

@ -233,10 +233,10 @@ install` must be run as root)._

 #### Option 2: Use prebuilt server

- - [`scrcpy-server-v2.3.1`][direct-scrcpy-server]  
-   <sub>SHA-256: `f6814822fc308a7a532f253485c9038183c6296a6c5df470a9e383b4f8e7605b`</sub>
+ - [`scrcpy-server-v2.0`][direct-scrcpy-server]  
+   <sub>SHA-256: `9e241615f578cd690bb43311000debdecf6a9c50a7082b001952f18f6f21ddc2`</sub>

-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v2.3.1/scrcpy-server-v2.3.1
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v2.0/scrcpy-server-v2.0

 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/doc/camera.md
+++ b/doc/camera.md
@ -1,171 +0,0 @@
-# Camera
-
-Camera mirroring is supported for devices with Android 12 or higher.
-
-To capture the camera instead of the device screen:
-
-```
-scrcpy --video-source=camera
-```
-
-By default, it automatically switches [audio source](audio.md#source) to
-microphone (as if `--audio-source=mic` were also passed).
-
-```bash
-scrcpy --video-source=display  # default is --audio-source=output
-scrcpy --video-source=camera   # default is --audio-source=mic
-scrcpy --video-source=display --audio-source=mic    # force display AND microphone
-scrcpy --video-source=camera --audio-source=output  # force camera AND device audio output
-```
-
-Audio can be disabled:
-
-```bash
-# audio not captured at all
-scrcpy --video-source=camera --no-audio
-scrcpy --video-source=camera --no-audio --record=file.mp4
-
-# audio captured and recorded, but not played
-scrcpy --video-source=camera --no-audio-playback --record=file.mp4
-```
-
-
-## List
-
-To list the cameras available (with their declared valid sizes and frame rates):
-
-```
-scrcpy --list-cameras
-scrcpy --list-camera-sizes
-```
-
-_Note that the sizes and frame rates are declarative. They are not accurate on
-all devices: some of them are declared but not supported, while some others are
-not declared but supported._
-
-
-## Selection
-
-It is possible to pass an explicit camera id (as listed by `--list-cameras`):
-
-```
-scrcpy --video-source=camera --camera-id=0
-```
-
-Alternatively, the camera may be selected automatically:
-
-```bash
-scrcpy --video-source=camera                           # use the first camera
-scrcpy --video-source=camera --camera-facing=front     # use the first front camera
-scrcpy --video-source=camera --camera-facing=back      # use the first back camera
-scrcpy --video-source=camera --camera-facing=external  # use the first external camera
-```
-
-If `--camera-id` is specified, then `--camera-facing` is forbidden (the id
-already determines the camera):
-
-```bash
-scrcpy --video-source=camera --camera-id=0 --camera-facing=front  # error
-```
-
-
-### Size selection
-
-It is possible to pass an explicit camera size:
-
-```
-scrcpy --video-source=camera --camera-size=1920x1080
-```
-
-The given size may be listed among the declared valid sizes
-(`--list-camera-sizes`), but may also be anything else (some devices support
-arbitrary sizes):
-
-```
-scrcpy --video-source=camera --camera-size=1840x444
-```
-
-Alternatively, a declared valid size (among the ones listed by
-`list-camera-sizes`) may be selected automatically.
-
-Two constraints are supported:
- - `-m`/`--max-size` (already used for display mirroring), for example `-m1920`;
- - `--camera-ar` to specify an aspect ratio (`<num>:<den>`, `<value>` or
-   `sensor`).
-
-Some examples:
-
-```bash
-scrcpy --video-source=camera                          # use the greatest width and the greatest associated height
-scrcpy --video-source=camera -m1920                   # use the greatest width not above 1920 and the greatest associated height
-scrcpy --video-source=camera --camera-ar=4:3          # use the greatest size with an aspect ratio of 4:3 (+/- 10%)
-scrcpy --video-source=camera --camera-ar=1.6          # use the greatest size with an aspect ratio of 1.6 (+/- 10%)
-scrcpy --video-source=camera --camera-ar=sensor       # use the greatest size with the aspect ratio of the camera sensor (+/- 10%)
-scrcpy --video-source=camera -m1920 --camera-ar=16:9  # use the greatest width not above 1920 and the closest to 16:9 aspect ratio
-```
-
-If `--camera-size` is specified, then `-m`/`--max-size` and `--camera-ar` are
-forbidden (the size is determined by the value given explicitly):
-
-```bash
-scrcpy --video-source=camera --camera-size=1920x1080 -m3000  # error
-```
-
-
-## Rotation
-
-To rotate the captured video, use the [video orientation](video.md#orientation)
-option:
-
-```
-scrcpy --video-source=camera --camera-size=1920x1080 --orientation=90
-```
-
-
-## Frame rate
-
-By default, camera is captured at Android's default frame rate (30 fps).
-
-To configure a different frame rate:
-
-```
-scrcpy --video-source=camera --camera-fps=60
-```
-
-
-## High speed capture
-
-The Android camera API also supports a [high speed capture mode][high speed].
-
-This mode is restricted to specific resolutions and frame rates, listed by
-`--list-camera-sizes`.
-
-```
-scrcpy --video-source=camera --camera-size=1920x1080 --camera-fps=240
-```
-
-[high speed]: https://developer.android.com/reference/android/hardware/camera2/CameraConstrainedHighSpeedCaptureSession
-
-
-## Brace expansion tip
-
-All camera options start with `--camera-`, so if your shell supports it, you can
-benefit from [brace expansion] (for example, it is supported _bash_ and _zsh_):
-
-```bash
-scrcpy --video-source=camera --camera-{facing=back,ar=16:9,high-speed,fps=120}
-```
-
-This will be expanded as:
-
-```bash
-scrcpy --video-source=camera --camera-facing=back --camera-ar=16:9 --camera-high-speed --camera-fps=120
-```
-
-[brace expansion]: https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html
-
-
-## Webcam
-
-Combined with the [V4L2](v4l2.md) feature on Linux, the Android device camera
-may be used as a webcam on the computer.
--- a/doc/connection.md
+++ b/doc/connection.md
@ -1,125 +0,0 @@
-# Connection
-
-## Selection
-
-If exactly one device is connected (i.e. listed by `adb devices`), then it is
-automatically selected.
-
-However, if there are multiple devices connected, you must specify the one to
-use in one of 4 ways:
- - by its serial:
-   ```bash
-   scrcpy --serial=0123456789abcdef
-   scrcpy -s 0123456789abcdef   # short version
-
-   # the serial is the ip:port if connected over TCP/IP (same behavior as adb)
-   scrcpy --serial=192.168.1.1:5555
-   ```
- - the one connected over USB (if there is exactly one):
-   ```bash
-   scrcpy --select-usb
-   scrcpy -d   # short version
-   ```
- - the one connected over TCP/IP (if there is exactly one):
-   ```bash
-   scrcpy --select-tcpip
-   scrcpy -e   # short version
-   ```
- - a device already listening on TCP/IP (see [below](#tcpip-wireless)):
-   ```bash
-   scrcpy --tcpip=192.168.1.1:5555
-   scrcpy --tcpip=192.168.1.1        # default port is 5555
-   ```
-
-The serial may also be provided via the environment variable `ANDROID_SERIAL`
-(also used by `adb`):
-
-```bash
-# in bash
-export ANDROID_SERIAL=0123456789abcdef
-scrcpy
-```
-
-```cmd
-:: in cmd
-set ANDROID_SERIAL=0123456789abcdef
-scrcpy
-```
-
-```powershell
-# in PowerShell
-$env:ANDROID_SERIAL = '0123456789abcdef'
-scrcpy
-```
-
-
-## TCP/IP (wireless)
-
-_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
-device over TCP/IP. The device must be connected on the same network as the
-computer.
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-### Automatic
-
-An option `--tcpip` allows to configure the connection automatically. There are
-two variants.
-
-If the device (accessible at 192.168.1.1 in this example) already listens on a
-port (typically 5555) for incoming _adb_ connections, then run:
-
-```bash
-scrcpy --tcpip=192.168.1.1       # default port is 5555
-scrcpy --tcpip=192.168.1.1:5555
-```
-
-If _adb_ TCP/IP mode is disabled on the device (or if you don't know the IP
-address), connect the device over USB, then run:
-
-```bash
-scrcpy --tcpip   # without arguments
-```
-
-It will automatically find the device IP address and adb port, enable TCP/IP
-mode if necessary, then connect to the device before starting.
-
-
-### Manual
-
-Alternatively, it is possible to enable the TCP/IP connection manually using
-`adb`:
-
-1. Plug the device into a USB port on your computer.
-2. Connect the device to the same Wi-Fi network as your computer.
-3. Get your device IP address, in Settings → About phone → Status, or by
-   executing this command:
-
-    ```bash
-    adb shell ip route | awk '{print $9}'
-    ```
-
-4. Enable `adb` over TCP/IP on your device: `adb tcpip 5555`.
-5. Unplug your device.
-6. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`
-with the device IP address you found)_.
-7. Run `scrcpy` as usual.
-8. Run `adb disconnect` once you're done.
-
-Since Android 11, a [wireless debugging option][adb-wireless] allows to bypass
-having to physically connect your device directly to your computer.
-
-[adb-wireless]: https://developer.android.com/studio/command-line/adb#wireless-android11-command-line
-
-
-## Autostart
-
-A small tool (by the scrcpy author) allows to run arbitrary commands whenever a
-new Android device is connected: [AutoAdb]. It can be used to start scrcpy:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
--- a/doc/control.md
+++ b/doc/control.md
@ -10,9 +10,36 @@ scrcpy --no-control
 scrcpy -n   # short version
 ```

-## Keyboard and mouse

-Read [keyboard](keyboard.md) and [mouse](mouse.md).
+## Text injection preference
+
+Two kinds of [events][textevents] are generated when typing text:
+ - _key events_, signaling that a key is pressed or released;
+ - _text events_, signaling that a text has been entered.
+
+By default, letters are injected using key events, so that the keyboard behaves
+as expected in games (typically for WASD keys).
+
+But this may [cause issues][prefertext]. If you encounter such a problem, you
+can avoid it by:
+
+```bash
+scrcpy --prefer-text
+```
+
+(but this will break keyboard behavior in games)
+
+On the contrary, you could force to always inject raw key events:
+
+```bash
+scrcpy --raw-key-events
+```
+
+These options have no effect on HID keyboard (all key events are sent as
+scancodes in this mode).
+
+[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
+[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343


 ## Copy-paste
@ -58,8 +85,7 @@ way as <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
 To disable automatic clipboard synchronization, use
 `--no-clipboard-autosync`.

-
-## Pinch-to-zoom, rotate and tilt simulation
+## Pinch-to-zoom

 To simulate "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-and-move_.

@ -67,14 +93,23 @@ More precisely, hold down <kbd>Ctrl</kbd> while pressing the left-click button.
 Until the left-click button is released, all mouse movements scale and rotate
 the content (if supported by the app) relative to the center of the screen.

-To simulate a tilt gesture: <kbd>Shift</kbd>+_click-and-move-up-or-down_.
-
 Technically, _scrcpy_ generates additional touch events from a "virtual finger"
-at a location inverted through the center of the screen. When pressing
-<kbd>Ctrl</kbd> the x and y coordinates are inverted. Using <kbd>Shift</kbd>
-only inverts x.
+at a location inverted through the center of the screen.

-This only works for the default mouse mode (`--mouse=sdk`).
+
+## Key repeat
+
+By default, holding a key down generates repeated key events. This can cause
+performance problems in some games, where these events are useless anyway.
+
+To avoid forwarding repeated key events:
+
+```bash
+scrcpy --no-key-repeat
+```
+
+This option has no effect on HID keyboard (key repeat is handled by Android
+directly in this mode).


 ## Right-click and middle-click
@ -108,3 +143,7 @@ The target directory can be changed on start:
 ```bash
 scrcpy --push-target=/sdcard/Movies/
 ```
+
+## Physical keyboard and mouse simulation
+
+See the dedicated [HID/OTG](hid-otg.md) page.
--- a/doc/develop.md
+++ b/doc/develop.md
@ -9,52 +9,16 @@ This application is composed of two parts:
 The client is responsible to push the server to the device and start its
 execution.

-The client and the server establish communication using separate sockets for
-video, audio and controls. Any of them may be disabled (but not all), so
-there are 1, 2 or 3 socket(s).
+Once the client and the server are connected to each other, the server initially
+sends device information (name and initial screen dimensions), then starts to
+send a raw H.264 video stream of the device screen. The client decodes the video
+frames, and display them as soon as possible, without buffering, to minimize
+latency. The client is not aware of the device rotation (which is handled by the
+server), it just knows the dimensions of the video frames.

-The server initially sends the device name on the first socket (it is used for
-the scrcpy window title), then each socket is used for its own purpose. All
-reads and writes are performed from a dedicated thread for each socket, both on
-the client and on the server.
+The client captures relevant keyboard and mouse events, that it transmits to the
+server, which injects them to the device.

-If video is enabled, then the server sends a raw video stream (H.264 by default)
-of the device screen, with some additional headers for each packet. The client
-decodes the video frames, and displays them as soon as possible, without
-buffering (unless `--display-buffer=delay` is specified) to minimize latency.
-The client is not aware of the device rotation (which is handled by the server),
-it just knows the dimensions of the video frames it receives.
-
-Similarly, if audio is enabled, then the server sends a raw audio stream (OPUS
-by default) of the device audio output (or the microphone if
-`--audio-source=mic` is specified), with some additional headers for each
-packet. The client decodes the stream, attempts to keep a minimal latency by
-maintaining an average buffering. The [blog post][scrcpy2] of the scrcpy v2.0
-release gives more details about the audio feature.
-
-If control is enabled, then the client captures relevant keyboard and mouse
-events, that it transmits to the server, which injects them to the device. This
-is the only socket which is used in both direction: input events are sent from
-the client to the device, and when the device clipboard changes, the new content
-is sent from the device to the client to support seamless copy-paste.
-
-[scrcpy2]: https://blog.rom1v.com/2023/03/scrcpy-2-0-with-audio/
-
-Note that the client-server roles are expressed at the application level:
-
- - the server _serves_ video and audio streams, and handle requests from the
-   client,
- - the client _controls_ the device through the server.
-
-However, by default (when `--force-adb-forward` is not set), the roles are
-reversed at the network level:
-
- - the client opens a server socket and listen on a port before starting the
-   server,
- - the server connects to the client.
-
-This role inversion guarantees that the connection will not fail due to race
-conditions without polling.


 ## Server
@ -68,14 +32,15 @@ The server is a Java application (with a [`public static void main(String...
 args)`][main] method), compiled against the Android framework, and executed as
 `shell` on the Android device.

-[main]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Server.java#L193
+[main]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/Server.java#L123

 To run such a Java application, the classes must be [_dexed_][dex] (typically,
 to `classes.dex`). If `my.package.MainClass` is the main class, compiled to
 `classes.dex`, pushed to the device in `/data/local/tmp`, then it can be run
 with:

-    adb shell CLASSPATH=/data/local/tmp/classes.dex app_process / my.package.MainClass
+    adb shell CLASSPATH=/data/local/tmp/classes.dex \
+        app_process / my.package.MainClass

 _The path `/data/local/tmp` is a good candidate to push the server, since it's
 readable and writable by `shell`, but not world-writable, so a malicious
@ -84,7 +49,7 @@ application may not replace the server just before the client executes it._
 Instead of a raw _dex_ file, `app_process` accepts a _jar_ containing
 `classes.dex` (e.g. an [APK]). For simplicity, and to benefit from the gradle
 build system, the server is built to an (unsigned) APK (renamed to
-`scrcpy-server.jar`).
+`scrcpy-server`).

 [dex]: https://en.wikipedia.org/wiki/Dalvik_(software)
 [apk]: https://en.wikipedia.org/wiki/Android_application_package
@ -100,77 +65,42 @@ They can be called using reflection though. The communication with hidden
 components is provided by [_wrappers_ classes][wrappers] and [aidl].

 [hidden]: https://stackoverflow.com/a/31908373/1987178
-[wrappers]: https://github.com/Genymobile/scrcpy/tree/master/server/src/main/java/com/genymobile/scrcpy/wrappers
-[aidl]: https://github.com/Genymobile/scrcpy/tree/master/server/src/main/aidl
+[wrappers]: https://github.com/Genymobile/scrcpy/tree/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/wrappers
+[aidl]: https://github.com/Genymobile/scrcpy/tree/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/aidl/android/view


+### Threading

-### Execution
+The server uses 3 threads:

-The server is started by the client basically by executing the following
-commands:
+ - the **main** thread, encoding and streaming the video to the client;
+ - the **controller** thread, listening for _control messages_ (typically,
+   keyboard and mouse events) from the client;
+ - the **receiver** thread (managed by the controller), sending _device messages_
+   to the clients (currently, it is only used to send the device clipboard
+   content).

-```bash
-adb push scrcpy-server /data/local/tmp/scrcpy-server.jar
-adb forward tcp:27183 localabstract:scrcpy
-adb shell CLASSPATH=/data/local/tmp/scrcpy-server.jar app_process / com.genymobile.scrcpy.Server 2.1
-```
-
-The first argument (`2.1` in the example) is the client scrcpy version. The
-server fails if the client and the server do not have the exact same version.
-The protocol between the client and the server may change from version to
-version (see [protocol](#protocol) below), and there is no backward or forward
-compatibility (there is no point to use different client and server versions).
-This check allows to detect misconfiguration (running an older or newer server
-by mistake).
-
-It is followed by any number of arguments, in the form of `key=value` pairs.
-Their order is irrelevant. The possible keys and associated value types can be
-found in the [server][server-options] and [client][client-options] code.
-
-[server-options]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Options.java#L181
-[client-options]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/server.c#L226
-
-For example, if we execute `scrcpy -m1920 --no-audio`, then the server
-execution will look like this:
-
-```bash
-# scid is a random number to identify different clients running on the same device
-adb shell CLASSPATH=/data/local/tmp/scrcpy-server.jar app_process / com.genymobile.scrcpy.Server 2.1 scid=12345678 log_level=info audio=false max_size=1920
-```
-
-### Components
-
-When executed, its [`main()`][main] method is executed (on the "main" thread).
-It parses the arguments, establishes the connection with the client and starts
-the other "components":
- - the **video** streamer: it captures the video screen and send encoded video
-   packets on the _video_ socket (from the _video_ thread).
- - the **audio** streamer: it uses several threads to capture raw packets,
-   submits them to encoding and retrieve encoded packets, which it sends on the
-   _audio_ socket.
- - the **controller**: it receives _control messages_ (typically input events)
-   on the _control_ socket from one thread, and sends _device messages_ (e.g. to
-   transmit the device clipboard content to the client) on the same _control
-   socket_ from another thread. Thus, the _control_ socket is used in both
-   directions (contrary to the _video_ and _audio_ sockets).
+Since the video encoding is typically hardware, there would be no benefit in
+encoding and streaming in two different threads.


 ### Screen video encoding

 The encoding is managed by [`ScreenEncoder`].

-The video is encoded using the [`MediaCodec`] API. The codec encodes the content
-of a `Surface` associated to the display, and writes the encoding packets to the
-client (on the _video_ socket).
+The video is encoded using the [`MediaCodec`] API. The codec takes its input
+from a [surface] associated to the display, and writes the resulting H.264
+stream to the provided output stream (the socket connected to the client).

-[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
 [`MediaCodec`]: https://developer.android.com/reference/android/media/MediaCodec.html
+[surface]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L68-L69

-On device rotation (or folding), the encoding session is [reset] and restarted.
+On device [rotation], the codec, surface and display are reinitialized, and a
+new video stream is produced.

-New frames are produced only when changes occur on the surface. This avoids to
-send unnecessary frames, but by default there might be drawbacks:
+New frames are produced only when changes occur on the surface. This is good
+because it avoids to send unnecessary frames, but there are drawbacks:

 - it does not send any frame on start if the device screen does not change,
 - after fast motion changes, the last frame may have poor quality.
@ -178,24 +108,11 @@ send unnecessary frames, but by default there might be drawbacks:
 Both problems are [solved][repeat] by the flag
 [`KEY_REPEAT_PREVIOUS_FRAME_AFTER`][repeat-flag].

-[reset]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L179
 [rotation]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L90
-[repeat]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L246-L247
+[repeat]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L147-L148
 [repeat-flag]: https://developer.android.com/reference/android/media/MediaFormat.html#KEY_REPEAT_PREVIOUS_FRAME_AFTER


-### Audio encoding
-
-Similarly, the audio is [captured] using an [`AudioRecord`], and [encoded] using
-the [`MediaCodec`] asynchronous API.
-
-More details are available on the [blog post][scrcpy2] introducing the audio feature.
-
-[captured]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/AudioCapture.java
-[encoded]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/AudioEncoder.java
-[`AudioRecord`]: https://developer.android.com/reference/android/media/AudioRecord
-
-
 ### Input events injection

 _Control messages_ are received from the client by the [`Controller`] (run in a
@ -207,13 +124,13 @@ separate thread). There are several types of input events:
 - other commands (e.g. to switch the screen on or to copy the clipboard).

 Some of them need to inject input events to the system. To do so, they use the
-_hidden_ method [`InputManager.injectInputEvent()`] (exposed by the
+_hidden_ method [`InputManager.injectInputEvent`] (exposed by our
 [`InputManager` wrapper][inject-wrapper]).

-[`Controller`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Controller.java
+[`Controller`]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/Controller.java#L81
 [`KeyEvent`]: https://developer.android.com/reference/android/view/KeyEvent.html
 [`MotionEvent`]: https://developer.android.com/reference/android/view/MotionEvent.html
-[`InputManager.injectInputEvent()`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L34
+[`InputManager.injectInputEvent`]: https://android.googlesource.com/platform/frameworks/base/+/oreo-release/core/java/android/hardware/input/InputManager.java#857
 [inject-wrapper]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27


@ -223,222 +140,126 @@ _hidden_ method [`InputManager.injectInputEvent()`] (exposed by the
 The client relies on [SDL], which provides cross-platform API for UI, input
 events, threading, etc.

-The video and audio streams are decoded by [FFmpeg].
+The video stream is decoded by [libav] (FFmpeg).

 [SDL]: https://www.libsdl.org
-[ffmpeg]: https://ffmpeg.org/
-
+[libav]: https://www.libav.org/

 ### Initialization

-The client parses the command line arguments, then [runs one of two code
-paths][run]:
- - scrcpy in "normal" mode ([`scrcpy.c`])
- - scrcpy in [OTG mode](otg.md) ([`scrcpy_otg.c`])
+On startup, in addition to _libav_ and _SDL_ initialization, the client must
+push and start the server on the device, and open two sockets (one for the video
+stream, one for control) so that they may communicate.

-[run]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/main.c#L81-L82
-[`scrcpy.c`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/scrcpy.c#L292-L293
-[`scrcpy_otg.c`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/usb/scrcpy_otg.c#L51-L52
+Note that the client-server roles are expressed at the application level:

-In the remaining of this document, we assume that the "normal" mode is used
-(read the code for the OTG mode).
+ - the server _serves_ video stream and handle requests from the client,
+ - the client _controls_ the device through the server.

-On startup, the client:
- - opens the _video_, _audio_ and _control_ sockets;
- - pushes and starts the server on the device;
- - initializes its components (demuxers, decoders, recorder…).
+However, the roles are reversed at the network level:
+
+ - the client opens a server socket and listen on a port before starting the
+   server,
+ - the server connects to the client.
+
+This role inversion guarantees that the connection will not fail due to race
+conditions, and avoids polling.
+
+_(Note that over TCP/IP, the roles are not reversed, due to a bug in `adb
+reverse`. See commit [1038bad] and [issue #5].)_
+
+Once the server is connected, it sends the device information (name and initial
+screen dimensions). Thus, the client may init the window and renderer, before
+the first frame is available.
+
+To minimize startup time, SDL initialization is performed while listening for
+the connection from the server (see commit [90a46b4]).
+
+[1038bad]: https://github.com/Genymobile/scrcpy/commit/1038bad3850f18717a048a4d5c0f8110e54ee172
+[issue #5]: https://github.com/Genymobile/scrcpy/issues/5
+[90a46b4]: https://github.com/Genymobile/scrcpy/commit/90a46b4c45637d083e877020d85ade52a9a5fa8e


-### Video and audio streams
+### Threading

-Depending on the arguments passed to `scrcpy`, several components may be used.
-Here is an overview of the video and audio components:
+The client uses 4 threads:
+
+ - the **main** thread, executing the SDL event loop,
+ - the **stream** thread, receiving the video and used for decoding and
+   recording,
+ - the **controller** thread, sending _control messages_ to the server,
+ - the **receiver** thread (managed by the controller), receiving _device
+   messages_ from the server.
+
+In addition, another thread can be started if necessary to handle APK
+installation or file push requests (via drag&drop on the main window) or to
+print the framerate regularly in the console.
+
+
+
+### Stream
+
+The video [stream] is received from the socket (connected to the server on the
+device) in a separate thread.
+
+If a [decoder] is present (i.e. `--no-display` is not set), then it uses _libav_
+to decode the H.264 stream from the socket, and notifies the main thread when a
+new frame is available.
+
+There are two [frames][video_buffer] simultaneously in memory:
+ - the **decoding** frame, written by the decoder from the decoder thread,
+ - the **rendering** frame, rendered in a texture from the main thread.
+
+When a new decoded frame is available, the decoder _swaps_ the decoding and
+rendering frame (with proper synchronization). Thus, it immediately starts
+to decode a new frame while the main thread renders the last one.
+
+If a [recorder] is present (i.e. `--record` is enabled), then it muxes the raw
+H.264 packet to the output video file.
+
+[stream]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/stream.h
+[decoder]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/decoder.h
+[video_buffer]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/video_buffer.h
+[recorder]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/recorder.h

 ```
-                                                 V4L2 sink
-                                               /
-                                       decoder
-                                     /         \
-        VIDEO -------------> demuxer             display
-                                     \
-                                       recorder
-                                     /
-        AUDIO -------------> demuxer
-                                     \
-                                       decoder --- audio player
+                                   +----------+      +----------+
+                              ---> | decoder  | ---> |  screen  |
+             +---------+     /     +----------+      +----------+
+ socket ---> | stream  | ----
+             +---------+     \     +----------+
+                              ---> | recorder |
+                                   +----------+
 ```

-The _demuxer_ is responsible to extract video and audio packets (read some
-header, split the video stream into packets at correct boundaries, etc.).
-
-The demuxed packets may be sent to a _decoder_ (one per stream, to produce
-frames) and to a recorder (receiving both video and audio stream to record a
-single file). The packets are encoded on the device (by `MediaCodec`), but when
-recording, they are _muxed_ (asynchronously) into a container (MKV or MP4) on
-the client side.
-
-Video frames are sent to the screen/display to be rendered in the scrcpy window.
-They may also be sent to a [V4L2 sink](v4l2.md).
-
-Audio "frames" (an array of decoded samples) are sent to the audio player.
-
-
 ### Controller

-The _controller_ is responsible to send _control messages_ to the device. It
+The [controller] is responsible to send _control messages_ to the device. It
 runs in a separate thread, to avoid I/O on the main thread.

-On SDL event, received on the main thread, the _input manager_ creates
-appropriate _control messages_. It is responsible to convert SDL events to
-Android events. It then pushes the _control messages_ to a queue hold by the
-controller. On its own thread, the controller takes messages from the queue,
-that it serializes and sends to the client.
+On SDL event, received on the main thread, the [input manager][inputmanager]
+creates appropriate [_control messages_][controlmsg]. It is responsible to
+convert SDL events to Android events (using [convert]). It pushes the _control
+messages_ to a queue hold by the controller. On its own thread, the controller
+takes messages from the queue, that it serializes and sends to the client.
+
+[controller]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/controller.h
+[controlmsg]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/control_msg.h
+[inputmanager]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/input_manager.h
+[convert]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/convert.h


-## Protocol
+### UI and event loop

-The protocol between the client and the server must be considered _internal_: it
-may (and will) change at any time for any reason. Everything may change (the
-number of sockets, the order in which the sockets must be opened, the data
-format on the wire…) from version to version. A client must always be run with a
-matching server version.
+Initialization, input events and rendering are all [managed][scrcpy] in the main
+thread.

-This section documents the current protocol in scrcpy v2.1.
+Events are handled in the [event loop], which either updates the [screen] or
+delegates to the [input manager][inputmanager].

-### Connection
-
-Firstly, the client sets up an adb tunnel:
-
-```bash
-# By default, a reverse redirection: the computer listens, the device connects
-adb reverse localabstract:scrcpy_<SCID> tcp:27183
-
-# As a fallback (or if --force-adb forward is set), a forward redirection:
-# the device listens, the computer connects
-adb forward tcp:27183 localabstract:scrcpy_<SCID>
-```
-
-(`<SCID>` is a 31-bit random number, so that it does not fail when several
-scrcpy instances start "at the same time" for the same device.)
-
-Then, up to 3 sockets are opened, in that order:
- - a _video_ socket
- - an _audio_ socket
- - a _control_ socket
-
-Each one may be disabled (respectively by `--no-video`, `--no-audio` and
-`--no-control`, directly or indirectly). For example, if `--no-audio` is set,
-then the _video_ socket is opened first, then the _control_ socket.
-
-On the _first_ socket opened (whichever it is), if the tunnel is _forward_, then
-a [dummy byte] is sent from the device to the client. This allows to detect a
-connection error (the client connection does not fail as long as there is an adb
-forward redirection, even if nothing is listening on the device side).
-
-Still on this _first_ socket, the device sends some [metadata][device meta] to
-the client (currently only the device name, used as the window title, but there
-might be other fields in the future).
-
-[dummy byte]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java#L93
-[device meta]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java#L151
-
-You can read the [client][client-connection] and [server][server-connection]
-code for more details.
-
-[client-connection]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/server.c#L465-L466
-[server-connection]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java#L63
-
-Then each socket is used for its intended purpose.
-
-### Video and audio
-
-On the _video_ and _audio_ sockets, the device first sends some [codec
-metadata]:
- - On the _video_ socket, 12 bytes:
-   - the codec id (`u32`) (H264, H265 or AV1)
-   - the initial video width (`u32`)
-   - the initial video height (`u32`)
- - On the _audio_ socket, 4 bytes:
-   - the codec id (`u32`) (OPUS, AAC or RAW)
-
-[codec metadata]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Streamer.java#L33-L51
-
-Then each packet produced by `MediaCodec` is sent, prefixed by a 12-byte [frame
-header]:
- - config packet flag (`u1`)
- - key frame flag (`u1`)
- - PTS (`u62`)
- - packet size (`u32`)
-
-Here is a schema describing the frame header:
-
-```
-    [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
-     <-------------> <-----> <-----------------------------...
-           PTS        packet        raw packet
-                       size
-     <--------------------->
-           frame header
-
-The most significant bits of the PTS are used for packet flags:
-
-     byte 7   byte 6   byte 5   byte 4   byte 3   byte 2   byte 1   byte 0
-    CK...... ........ ........ ........ ........ ........ ........ ........
-    ^^<------------------------------------------------------------------->
-    ||                                PTS
-    | `- key frame
-     `-- config packet
-```
-
-[frame header]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Streamer.java#L83
-
-
-### Controls
-
-Controls messages are sent via a custom binary protocol.
-
-The only documentation for this protocol is the set of unit tests on both sides:
- - `ControlMessage` (from client to device): [serialization](https://github.com/Genymobile/scrcpy/blob/master/app/tests/test_control_msg_serialize.c) | [deserialization](https://github.com/Genymobile/scrcpy/blob/master/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java)
- - `DeviceMessage` (from device to client) [serialization](https://github.com/Genymobile/scrcpy/blob/master/server/src/test/java/com/genymobile/scrcpy/DeviceMessageWriterTest.java) | [deserialization](https://github.com/Genymobile/scrcpy/blob/master/app/tests/test_device_msg_deserialize.c)
-
-
-## Standalone server
-
-Although the server is designed to work for the scrcpy client, it can be used
-with any client which uses the same protocol.
-
-For simplicity, some [server-specific options] have been added to produce raw
-streams easily:
- - `send_device_meta=false`: disable the device metata (in practice, the device
-   name) sent on the _first_ socket
- - `send_frame_meta=false`: disable the 12-byte header for each packet
- - `send_dummy_byte`: disable the dummy byte sent on forward connections
- - `send_codec_meta`: disable the codec information (and initial device size for
-   video)
- - `raw_stream`: disable all the above
-
-[server-specific options]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Options.java#L309-L329
-
-Concretely, here is how to expose a raw H.264 stream on a TCP socket:
-
-```bash
-adb push scrcpy-server-v2.1 /data/local/tmp/scrcpy-server-manual.jar
-adb forward tcp:1234 localabstract:scrcpy
-adb shell CLASSPATH=/data/local/tmp/scrcpy-server-manual.jar \
-    app_process / com.genymobile.scrcpy.Server 2.1 \
-    tunnel_forward=true audio=false control=false cleanup=false \
-    raw_stream=true max_size=1920
-```
-
-As soon as a client connects over TCP on port 1234, the device will start
-streaming the video. For example, VLC can play the video (although you will
-experience a very high latency, more details [here][vlc-0latency]):
-
-```
-vlc -Idummy --demux=h264 --network-caching=0 tcp://localhost:1234
-```
-
-[vlc-0latency]: https://code.videolan.org/rom1v/vlc/-/merge_requests/20
+[scrcpy]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/scrcpy.c
+[event loop]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/scrcpy.c#L201
+[screen]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/screen.h


 ## Hack
--- a/doc/device.md
+++ b/doc/device.md
@ -1,9 +1,156 @@
 # Device

+## Selection
+
+If exactly one device is connected (i.e. listed by `adb devices`), then it is
+automatically selected.
+
+However, if there are multiple devices connected, you must specify the one to
+use in one of 4 ways:
+ - by its serial:
+   ```bash
+   scrcpy --serial=0123456789abcdef
+   scrcpy -s 0123456789abcdef   # short version
+
+   # the serial is the ip:port if connected over TCP/IP (same behavior as adb)
+   scrcpy --serial=192.168.1.1:5555
+   ```
+ - the one connected over USB (if there is exactly one):
+   ```bash
+   scrcpy --select-usb
+   scrcpy -d   # short version
+   ```
+ - the one connected over TCP/IP (if there is exactly one):
+   ```bash
+   scrcpy --select-tcpip
+   scrcpy -e   # short version
+   ```
+ - a device already listening on TCP/IP (see [below](#tcpip-wireless)):
+   ```bash
+   scrcpy --tcpip=192.168.1.1:5555
+   scrcpy --tcpip=192.168.1.1        # default port is 5555
+   ```
+
+The serial may also be provided via the environment variable `ANDROID_SERIAL`
+(also used by `adb`):
+
+```bash
+# in bash
+export ANDROID_SERIAL=0123456789abcdef
+scrcpy
+```
+
+```cmd
+:: in cmd
+set ANDROID_SERIAL=0123456789abcdef
+scrcpy
+```
+
+```powershell
+# in PowerShell
+$env:ANDROID_SERIAL = '0123456789abcdef'
+scrcpy
+```
+
+
+## TCP/IP (wireless)
+
+_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
+device over TCP/IP. The device must be connected on the same network as the
+computer.
+
+[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
+
+
+### Automatic
+
+An option `--tcpip` allows to configure the connection automatically. There are
+two variants.
+
+If the device (accessible at 192.168.1.1 in this example) already listens on a
+port (typically 5555) for incoming _adb_ connections, then run:
+
+```bash
+scrcpy --tcpip=192.168.1.1       # default port is 5555
+scrcpy --tcpip=192.168.1.1:5555
+```
+
+If _adb_ TCP/IP mode is disabled on the device (or if you don't know the IP
+address), connect the device over USB, then run:
+
+```bash
+scrcpy --tcpip   # without arguments
+```
+
+It will automatically find the device IP address and adb port, enable TCP/IP
+mode if necessary, then connect to the device before starting.
+
+
+### Manual
+
+Alternatively, it is possible to enable the TCP/IP connection manually using
+`adb`:
+
+1. Plug the device into a USB port on your computer.
+2. Connect the device to the same Wi-Fi network as your computer.
+3. Get your device IP address, in Settings → About phone → Status, or by
+   executing this command:
+
+    ```bash
+    adb shell ip route | awk '{print $9}'
+    ```
+
+4. Enable `adb` over TCP/IP on your device: `adb tcpip 5555`.
+5. Unplug your device.
+6. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`
+with the device IP address you found)_.
+7. Run `scrcpy` as usual.
+8. Run `adb disconnect` once you're done.
+
+Since Android 11, a [wireless debugging option][adb-wireless] allows to bypass
+having to physically connect your device directly to your computer.
+
+[adb-wireless]: https://developer.android.com/studio/command-line/adb#wireless-android11-command-line
+
+
+## Autostart
+
+A small tool (by the scrcpy author) allows to run arbitrary commands whenever a
+new Android device is connected: [AutoAdb]. It can be used to start scrcpy:
+
+```bash
+autoadb scrcpy -s '{}'
+```
+
+[AutoAdb]: https://github.com/rom1v/autoadb
+
+
+## Display
+
+If several displays are available on the Android device, it is possible to
+select the display to mirror:
+
+```bash
+scrcpy --display=1
+```
+
+The list of display ids can be retrieved by:
+
+```bash
+scrcpy --list-displays
+```
+
+A secondary display may only be controlled if the device runs at least Android
+10 (otherwise it is mirrored as read-only).
+
+
+## Actions
+
 Some command line arguments perform actions on the device itself while scrcpy is
 running.

-## Stay awake
+
+### Stay awake

 To prevent the device from sleeping after a delay **when the device is plugged
 in**:
@ -19,7 +166,7 @@ If the device is not plugged in (i.e. only connected over TCP/IP),
 `--stay-awake` has no effect (this is the Android behavior).


-## Turn screen off
+### Turn screen off

 It is possible to turn the device screen off while mirroring on start with a
 command-line option:
@ -47,7 +194,7 @@ scrcpy -Sw   # short version
 ```


-## Show touches
+### Show touches

 For presentations, it may be useful to show physical touches (on the physical
 device). Android exposes this feature in _Developers options_.
@ -63,7 +210,7 @@ scrcpy -t   # short version
 Note that it only shows _physical_ touches (by a finger on the device).


-## Power off on close
+### Power off on close

 To turn the device screen off when closing _scrcpy_:

@ -71,10 +218,11 @@ To turn the device screen off when closing _scrcpy_:
 scrcpy --power-off-on-close
 ```

-## Power on on start
+### Power on on start

 By default, on start, the device is powered on. To prevent this behavior:

 ```bash
 scrcpy --no-power-on
 ```
+
--- a/Show More
+++ b/Show More