Add intermediate frame in video buffer

There were only two frames simultaneously: - one used by the decoder; - one used by the renderer. When the decoder finished decoding a frame, it swapped it with the rendering frame. Adding a third frame provides several benefits: - the decoder do not have to wait for the renderer to release the mutex; - it simplifies the video_buffer API; - it makes the rendering frame valid until the next call to video_buffer_take_rendering_frame(), which will be useful for swscaling on window resize.
Assert non-recursive usage of mutexes
2021-02-04 08:12:22 +01:00 · 2021-02-04 08:12:22 +01:00 · 2021-02-04 08:12:22 +01:00 · 2021-02-04 08:12:22 +01:00 · 2021-02-04 08:12:22 +01:00 · 2021-02-04 08:12:22 +01:00
220 changed files with 6366 additions and 25308 deletions
--- a/BUILD.md
+++ b/BUILD.md
@ -2,51 +2,18 @@

 Here are the instructions to build _scrcpy_ (client and server).

+You may want to build only the client: the server binary, which will be pushed
+to the Android device, does not depend on your system and architecture. In that
+case, use the [prebuilt server] (so you will not need Java or the Android SDK).

-## Simple
-
-If you just want to install the latest release from `master`, follow this
-simplified process.
-
-First, you need to install the required packages:
-
-```bash
-# for Debian/Ubuntu
-sudo apt install ffmpeg libsdl2-2.0-0 adb wget \
-                 gcc git pkg-config meson ninja-build libsdl2-dev \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
-                 libusb-1.0-0 libusb-1.0-0-dev
-```
-
-Then clone the repo and execute the installation script
-([source](install_release.sh)):
-
-```bash
-git clone https://github.com/Genymobile/scrcpy
-cd scrcpy
-./install_release.sh
-```
-
-When a new release is out, update the repo and reinstall:
-
-```bash
-git pull
-./install_release.sh
-```
-
-To uninstall:
-
-```bash
-sudo ninja -Cbuild-auto uninstall
-```
-
+[prebuilt server]: #prebuilt-server

 ## Branches

 ### `master`

 The `master` branch concerns the latest release, and is the home page of the
-project on GitHub.
+project on Github.


 ### `dev`
@ -89,15 +56,15 @@ Install the required packages from your package manager.

 ```bash
 # runtime dependencies
-sudo apt install ffmpeg libsdl2-2.0-0 adb libusb-1.0-0
+sudo apt install ffmpeg libsdl2-2.0-0 adb

 # client build dependencies
-sudo apt install gcc git pkg-config meson ninja-build libsdl2-dev \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
-                 libusb-1.0-0-dev
+sudo apt install gcc git pkg-config meson ninja-build \
+                 libavcodec-dev libavformat-dev libavutil-dev \
+                 libsdl2-dev

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

 On old versions (like Ubuntu 16.04), `meson` is too old. In that case, install
@ -116,7 +83,7 @@ pip3 install meson
 sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm

 # client build dependencies
-sudo dnf install SDL2-devel ffms2-devel libusb-devel meson gcc make
+sudo dnf install SDL2-devel ffms2-devel meson gcc make

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

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

 Then generate the releases:

 ```bash
-./release.sh
+make -f Makefile.CrossWindows
 ```

 It will generate win32 and win64 releases into `dist/`.
@ -161,8 +128,7 @@ install the required packages:
 ```bash
 # runtime dependencies
 pacman -S mingw-w64-x86_64-SDL2 \
-          mingw-w64-x86_64-ffmpeg \
-          mingw-w64-x86_64-libusb
+          mingw-w64-x86_64-ffmpeg

 # client build dependencies
 pacman -S mingw-w64-x86_64-make \
@ -176,8 +142,7 @@ For a 32 bits version, replace `x86_64` by `i686`:
 ```bash
 # runtime dependencies
 pacman -S mingw-w64-i686-SDL2 \
-          mingw-w64-i686-ffmpeg \
-          mingw-w64-i686-libusb
+          mingw-w64-i686-ffmpeg

 # client build dependencies
 pacman -S mingw-w64-i686-make \
@ -201,19 +166,19 @@ Install the packages with [Homebrew]:

 ```bash
 # runtime dependencies
-brew install sdl2 ffmpeg libusb
+brew install sdl2 ffmpeg

 # client build dependencies
 brew install pkg-config meson
 ```

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

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

@ -224,27 +189,8 @@ See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).

 ## Common steps

-**As a non-root user**, clone the project:
-
-```bash
-git clone https://github.com/Genymobile/scrcpy
-cd scrcpy
-```
-
-
-### Build
-
-You may want to build only the client: the server binary, which will be pushed
-to the Android device, does not depend on your system and architecture. In that
-case, use the [prebuilt server] (so you will not need Java or the Android SDK).
-
-[prebuilt server]: #option-2-use-prebuilt-server
-
-
-#### Option 1: Build everything from sources
-
-Install the [Android SDK] (_Android Studio_), and set `ANDROID_SDK_ROOT` to its
-directory. For example:
+If you want to build the server, install the [Android SDK] (_Android Studio_),
+and set `ANDROID_SDK_ROOT` to its directory. For example:

 [Android SDK]: https://developer.android.com/studio/index.html

@ -257,11 +203,20 @@ export ANDROID_SDK_ROOT=~/Library/Android/sdk
 set ANDROID_SDK_ROOT=%LOCALAPPDATA%\Android\sdk
 ```

+If you don't want to build the server, use the [prebuilt server].
+
+Clone the project:
+
+```bash
+git clone https://github.com/Genymobile/scrcpy
+cd scrcpy
+```
+
 Then, build:

 ```bash
-meson x --buildtype=release --strip -Db_lto=true
-ninja -Cx  # DO NOT RUN AS ROOT
+meson x --buildtype release --strip -Db_lto=true
+ninja -Cx
 ```

 _Note: `ninja` [must][ninja-user] be run as a non-root user (only `ninja
@ -270,27 +225,9 @@ install` must be run as root)._
 [ninja-user]: https://github.com/Genymobile/scrcpy/commit/4c49b27e9f6be02b8e63b508b60535426bd0291a


-#### Option 2: Use prebuilt server
+### Run

- - [`scrcpy-server-v1.24`][direct-scrcpy-server]  
-   <sub>SHA-256: `ae74a81ea79c0dc7250e586627c278c0a9a8c5de46c9fb5c38c167fb1a36f056`</sub>
-
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-server-v1.24
-
-Download the prebuilt server somewhere, and specify its path during the Meson
-configuration:
-
-```bash
-meson x --buildtype=release --strip -Db_lto=true \
-    -Dprebuilt_server=/path/to/scrcpy-server
-ninja -Cx  # DO NOT RUN AS ROOT
-```
-
-The server only works with a matching client version (this server works with the
-`master` branch).
-
-
-### Run without installing:
+To run without installing:

 ```bash
 ./run x [options]
@ -305,19 +242,32 @@ After a successful build, you can install _scrcpy_ on the system:
 sudo ninja -Cx install    # without sudo on Windows
 ```

-This installs several files:
+This installs two files:

- - `/usr/local/bin/scrcpy` (main app)
- - `/usr/local/share/scrcpy/scrcpy-server` (server to push to the device)
- - `/usr/local/share/man/man1/scrcpy.1` (manpage)
- - `/usr/local/share/icons/hicolor/256x256/apps/icon.png` (app icon)
- - `/usr/local/share/zsh/site-functions/_scrcpy` (zsh completion)
- - `/usr/local/share/bash-completion/completions/scrcpy` (bash completion)
+ - `/usr/local/bin/scrcpy`
+ - `/usr/local/share/scrcpy/scrcpy-server`

-You can then [run](README.md#run) `scrcpy`.
+Just remove them to "uninstall" the application.

-### Uninstall
+You can then [run](README.md#run) _scrcpy_.
+
+
+## Prebuilt server
+
+ - [`scrcpy-server-v1.17`][direct-scrcpy-server]  
+   _(SHA-256: 11b5ad2d1bc9b9730fb7254a78efd71a8ff46b1938ff468e47a21b653a1b6725_
+
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-server-v1.17
+
+Download the prebuilt server somewhere, and specify its path during the Meson
+configuration:

 ```bash
-sudo ninja -Cx uninstall  # without sudo on Windows
+meson x --buildtype release --strip -Db_lto=true \
+    -Dprebuilt_server=/path/to/scrcpy-server
+ninja -Cx
+sudo ninja -Cx install
 ```
+
+The server only works with a matching client version (this server works with the
+`master` branch).
--- a/DEVELOP.md
+++ b/DEVELOP.md
@ -76,7 +76,7 @@ The server uses 3 threads:
 - the **main** thread, encoding and streaming the video to the client;
 - the **controller** thread, listening for _control messages_ (typically,
   keyboard and mouse events) from the client;
- - the **receiver** thread (managed by the controller), sending _device messages_
+ - the **receiver** thread (managed by the controller), sending _device messges_
   to the clients (currently, it is only used to send the device clipboard
   content).

@ -211,7 +211,7 @@ There are two [frames][video_buffer] simultaneously in memory:
 - the **rendering** frame, rendered in a texture from the main thread.

 When a new decoded frame is available, the decoder _swaps_ the decoding and
-rendering frame (with proper synchronization). Thus, it immediately starts
+rendering frame (with proper synchronization). Thus, it immediatly starts
 to decode a new frame while the main thread renders the last one.

 If a [recorder] is present (i.e. `--record` is enabled), then it muxes the raw
--- a/FAQ.it.md
+++ b/FAQ.it.md
@ -1,235 +0,0 @@
-_Apri le [FAQ](FAQ.md) originali e sempre aggiornate._
-
-# Domande Frequenti (FAQ)
-
-Questi sono i problemi più comuni riportati e i loro stati.
-
-
-## Problemi di `adb`
-
-`scrcpy` esegue comandi `adb` per inizializzare la connessione con il dispositivo. Se `adb` fallisce, scrcpy non funzionerà.
-
-In questo caso sarà stampato questo errore:
-
->     ERROR: "adb push" returned with value 1
-
-Questo solitamente non è un bug di _scrcpy_, ma un problema del tuo ambiente.
-
-Per trovare la causa, esegui:
-
-```bash
-adb devices
-```
-
-### `adb` not found (`adb` non trovato)
-
-È necessario che `adb` sia accessibile dal tuo `PATH`.
-
-In Windows, la cartella corrente è nel tuo `PATH` e `adb.exe` è incluso nella release, perciò dovrebbe già essere pronto all'uso.
-
-
-### Device unauthorized (Dispositivo non autorizzato)
-
-Controlla [stackoverflow][device-unauthorized] (in inglese).
-
-[device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
-
-
-### Device not detected (Dispositivo non rilevato)
-
->     adb: error: failed to get feature set: no devices/emulators found
-
-Controlla di aver abilitato correttamente il [debug con adb][enable-adb] (link in inglese).
-
-Se il tuo dispositivo non è rilevato, potresti avere bisogno dei [driver][drivers] (link in inglese) (in Windows).
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-[drivers]: https://developer.android.com/studio/run/oem-usb.html
-
-
-### Più dispositivi connessi
-
-Se più dispositivi sono connessi, riscontrerai questo errore:
-
->     adb: error: failed to get feature set: more than one device/emulator
-
-l'identificatore del tuo dispositivo deve essere fornito:
-
-```bash
-scrcpy -s 01234567890abcdef
-```
-
-Notare che se il tuo dispositivo è connesso mediante TCP/IP, riscontrerai questo messaggio:
-
->     adb: error: more than one device/emulator
->     ERROR: "adb reverse" returned with value 1
->     WARN: 'adb reverse' failed, fallback to 'adb forward'
-
-Questo è un problema atteso (a causa di un bug di una vecchia versione di Android, vedi [#5] (link in inglese)), ma in quel caso scrcpy ripiega su un metodo differente, il quale dovrebbe funzionare.
-
-[#5]: https://github.com/Genymobile/scrcpy/issues/5
-
-
-### Conflitti tra versioni di adb
-
->     adb server version (41) doesn't match this client (39); killing...
-
-L'errore compare quando usi più versioni di `adb` simultaneamente. Devi trovare il programma che sta utilizzando una versione differente di `adb` e utilizzare la stessa versione dappertutto.
-
-Puoi sovrascrivere i binari di `adb` nell'altro programma, oppure chiedere a _scrcpy_ di usare un binario specifico di `adb`, impostando la variabile d'ambiente `ADB`:
-
-```bash
-set ADB=/path/to/your/adb
-scrcpy
-```
-
-
-### Device disconnected (Dispositivo disconnesso)
-
-Se _scrcpy_ si interrompe con l'avviso "Device disconnected", allora la connessione `adb` è stata chiusa.
-
-Prova con un altro cavo USB o inseriscilo in un'altra porta USB. Vedi [#281] (in inglese) e [#283] (in inglese).
-
-[#281]: https://github.com/Genymobile/scrcpy/issues/281
-[#283]: https://github.com/Genymobile/scrcpy/issues/283
-
-
-
-## Problemi di controllo
-
-### Mouse e tastiera non funzionano
-
-Su alcuni dispositivi potresti dover abilitare un opzione che permette l'[input simulato][simulating input] (link in inglese). Nelle opzioni sviluppatore, abilita:
-
-> **Debug USB (Impostazioni di sicurezza)**
-> _Permetti la concessione dei permessi e la simulazione degli input mediante il debug USB_
-<!--- Ho tradotto personalmente il testo sopra, non conosco esattamente il testo reale --->
-
-[simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-### I caratteri speciali non funzionano
-
-Iniettare del testo in input è [limitato ai caratteri ASCII][text-input] (link in inglese). Un trucco permette di iniettare dei [caratteri accentati][accented-characters] (link in inglese), ma questo è tutto. Vedi [#37] (link in inglese).
-
-[text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
-[accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
-[#37]: https://github.com/Genymobile/scrcpy/issues/37
-
-
-## Problemi del client
-
-### La qualità è bassa
-
-Se la definizione della finestra del tuo client è minore di quella del tuo dispositivo, allora potresti avere una bassa qualità di visualizzazione, specialmente individuabile nei testi (vedi [#40] (link in inglese)).
-
-[#40]: https://github.com/Genymobile/scrcpy/issues/40
-
-Per migliorare la qualità di ridimensionamento (downscaling), il filtro trilineare è applicato automaticamente se il renderizzatore è OpenGL e se supporta la creazione di mipmap.
-
-In Windows, potresti voler forzare OpenGL:
-
-```
-scrcpy --render-driver=opengl
-```
-
-Potresti anche dover configurare il [comportamento di ridimensionamento][scaling behavior] (link in inglese):
-
-> `scrcpy.exe` > Propietà > Compatibilità > Modifica impostazioni DPI elevati > Esegui l'override del comportamento di ridimensionamento DPI elevati >  Ridimensionamento eseguito per:  _Applicazione_.
-
-[scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
-
-
-### Problema con Wayland
-
-Per impostazione predefinita, SDL utilizza x11 su Linux. Il [video driver] può essere cambiato attraversio la variabile d'ambiente `SDL_VIDEODRIVER`:
-
-[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
-
-```bash
-export SDL_VIDEODRIVER=wayland
-scrcpy
-```
-
-Su alcune distribuzioni (almeno Fedora), il pacchetto `libdecor` deve essere installato manualmente.
-
-Vedi le issues [#2554] e [#2559].
-
-[#2554]: https://github.com/Genymobile/scrcpy/issues/2554
-[#2559]: https://github.com/Genymobile/scrcpy/issues/2559
-
-
-### Crash del compositore KWin
-
-In Plasma Desktop, il compositore è disabilitato mentre _scrcpy_ è in esecuzione.
-
-Come soluzione alternativa, [disattiva la "composizione dei blocchi"][kwin] (link in inglese).
-<!--- Non sono sicuro di aver tradotto correttamente la stringa di testo del pulsante --->
-
-[kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
-
-
-## Crash
-
-### Eccezione
-
-Ci potrebbero essere molte ragioni. Una causa comune è che il codificatore hardware del tuo dispositivo non riesce a codificare alla definizione selezionata:
-
-> ```
-> ERROR: Exception on thread Thread[main,5,main]
-> android.media.MediaCodec$CodecException: Error 0xfffffc0e
-> ...
-> Exit due to uncaughtException in main thread:
-> ERROR: Could not open video stream
-> INFO: Initial texture: 1080x2336
-> ```
-
-o
-
-> ```
-> ERROR: Exception on thread Thread[main,5,main]
-> java.lang.IllegalStateException
->         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
-> ```
-
-Prova con una definizione inferiore:
-
-```
-scrcpy -m 1920
-scrcpy -m 1024
-scrcpy -m 800
-```
-
-Potresti anche provare un altro [codificatore](README.it.md#codificatore).
-
-
-## Linea di comando in Windows
-
-Alcuni utenti Windows non sono familiari con la riga di comando. Qui è descritto come aprire un terminale ed eseguire `scrcpy` con gli argomenti:
-
- 1. Premi <kbd>Windows</kbd>+<kbd>r</kbd>, questo apre una finestra di dialogo.
- 2. Scrivi `cmd` e premi <kbd>Enter</kbd>, questo apre un terminale.
- 3. Vai nella tua cartella di _scrcpy_ scrivendo (adatta il percorso):
-
-    ```bat
-    cd C:\Users\user\Downloads\scrcpy-win64-xxx
-    ```
-
-    e premi <kbd>Enter</kbd>
- 4. Scrivi il tuo comando. Per esempio:
-
-    ```bat
-    scrcpy --record file.mkv
-    ```
-
-Se pianifichi di utilizzare sempre gli stessi argomenti, crea un file `myscrcpy.bat` (abilita mostra [estensioni nomi file][show file extensions] per evitare di far confusione) contenente il tuo comando nella cartella di `scrcpy`. Per esempio:
-
-```bat
-scrcpy --prefer-text --turn-screen-off --stay-awake
-```
-
-Poi fai doppio click su quel file.
-
-Potresti anche modificare (una copia di) `scrcpy-console.bat` o `scrcpy-noconsole.vbs` per aggiungere alcuni argomenti.
-
-[show file extensions]: https://www.techpedia.it/14-windows/windows-10/171-visualizzare-le-estensioni-nomi-file-con-windows-10
--- a/FAQ.md
+++ b/FAQ.md
@ -1,19 +1,24 @@
 # Frequently Asked Questions

-[Read in another language](#translations)
-
 Here are the common reported problems and their status.

-If you encounter any error, the first step is to upgrade to the latest version.
-

 ## `adb` issues

 `scrcpy` execute `adb` commands to initialize the connection with the device. If
 `adb` fails, then scrcpy will not work.

+In that case, it will print this error:
+
+>     ERROR: "adb push" returned with value 1
+
 This is typically not a bug in _scrcpy_, but a problem in your environment.

+To find out the cause, execute:
+
+```bash
+adb devices
+```

 ### `adb` not found

@ -23,63 +28,35 @@ On Windows, the current directory is in your `PATH`, and `adb.exe` is included
 in the release, so it should work out-of-the-box.


-### Device not detected
-
->     ERROR: Could not find any ADB device
-
-Check that you correctly enabled [adb debugging][enable-adb].
-
-Your device must be detected by `adb`:
-
-```
-adb devices
-```
-
-If your device is not detected, you may need some [drivers] (on Windows). There is a separate [USB driver for Google devices][google-usb-driver].
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-[drivers]: https://developer.android.com/studio/run/oem-usb.html
-[google-usb-driver]: https://developer.android.com/studio/run/win-usb
-
-
 ### Device unauthorized

->    ERROR: Device is unauthorized:
->    ERROR:     -->   (usb)  0123456789abcdef          unauthorized
->    ERROR: A popup should open on the device to request authorization.
-
-When connecting, a popup should open on the device. You must authorize USB
-debugging.
-
-If it does not open, check [stackoverflow][device-unauthorized].
+Check [stackoverflow][device-unauthorized].

 [device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized


+### Device not detected
+
+>     adb: error: failed to get feature set: no devices/emulators found
+
+If your device is not detected, you may need some [drivers] (on Windows).
+
+[drivers]: https://developer.android.com/studio/run/oem-usb.html
+
+
 ### Several devices connected

 If several devices are connected, you will encounter this error:

-ERROR: Multiple (2) ADB devices:
-ERROR:     -->   (usb)  0123456789abcdef                device  Nexus_5
-ERROR:     --> (tcpip)  192.168.1.5:5555                device  GM1913
-ERROR: Select a device via -s (--serial), -d (--select-usb) or -e (--select-tcpip)
+>     adb: error: failed to get feature set: more than one device/emulator

-In that case, you can either provide the identifier of the device you want to
-mirror:
+the identifier of the device you want to mirror must be provided:

 ```bash
-scrcpy -s 0123456789abcdef
+scrcpy -s 01234567890abcdef
 ```

-Or request the single USB (or TCP/IP) device:
-
-```bash
-scrcpy -d  # USB device
-scrcpy -e  # TCP/IP device
-```
-
-Note that if your device is connected over TCP/IP, you might get this message:
+Note that if your device is connected over TCP/IP, you'll get this message:

 >     adb: error: more than one device/emulator
 >     ERROR: "adb reverse" returned with value 1
@ -134,19 +111,25 @@ In developer options, enable:
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323


+### Mouse clicks at wrong location
+
+On MacOS, with HiDPI support and multiple screens, input location are wrongly
+scaled. See [#15].
+
+[#15]: https://github.com/Genymobile/scrcpy/issues/15
+
+Open _scrcpy_ directly on the monitor you use it.
+
+
 ### Special characters do not work

-The default text injection method is [limited to ASCII characters][text-input].
-A trick allows to also inject some [accented characters][accented-characters],
-but that's all. See [#37].
-
-Since scrcpy v1.20 on Linux, it is possible to simulate a [physical
-keyboard][hid] (HID).
+Injecting text input is [limited to ASCII characters][text-input]. A trick
+allows to also inject some [accented characters][accented-characters], but
+that's all. See [#37].

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


 ## Client issues
@ -158,44 +141,22 @@ screen, then you might get poor quality, especially visible on text (see [#40]).

 [#40]: https://github.com/Genymobile/scrcpy/issues/40

-This problem should be fixed in scrcpy v1.22: **update to the latest version**.
+To improve downscaling quality, trilinear filtering is enabled automatically
+if the renderer is OpenGL and if it supports mipmapping.

-On older versions, you must configure the [scaling behavior]:
+On Windows, you might want to force OpenGL:
+
+```
+scrcpy --render-driver=opengl
+```
+
+You may also need to configure the [scaling behavior]:

 > `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
 > Override high DPI scaling behavior > Scaling performed by: _Application_.

 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723

-Also, to improve downscaling quality, trilinear filtering is enabled
-automatically if the renderer is OpenGL and if it supports mipmapping.
-
-On Windows, you might want to force OpenGL to enable mipmapping:
-
-```
-scrcpy --render-driver=opengl
-```
-
-
-### Issue with Wayland
-
-By default, SDL uses x11 on Linux. The [video driver] can be changed via the
-`SDL_VIDEODRIVER` environment variable:
-
-[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
-
-```bash
-export SDL_VIDEODRIVER=wayland
-scrcpy
-```
-
-On some distributions (at least Fedora), the package `libdecor` must be
-installed manually.
-
-See issues [#2554] and [#2559].
-
-[#2554]: https://github.com/Genymobile/scrcpy/issues/2554
-[#2559]: https://github.com/Genymobile/scrcpy/issues/2559


 ### KWin compositor crashes
@ -239,44 +200,13 @@ scrcpy -m 1024
 scrcpy -m 800
 ```

-Since scrcpy v1.22, scrcpy automatically tries again with a lower definition
-before failing. This behavior can be disabled with `--no-downsize-on-error`.
-
 You could also try another [encoder](README.md#encoder).


-If you encounter this exception on Android 12, then just upgrade to scrcpy >=
-1.18 (see [#2129]):
-
-```
-> ERROR: Exception on thread Thread[main,5,main]
-java.lang.AssertionError: java.lang.reflect.InvocationTargetException
-    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:75)
-    ...
-Caused by: java.lang.reflect.InvocationTargetException
-    at java.lang.reflect.Method.invoke(Native Method)
-    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:73)
-    ... 7 more
-Caused by: java.lang.IllegalArgumentException: displayToken must not be null
-    at android.view.SurfaceControl$Transaction.setDisplaySurface(SurfaceControl.java:3067)
-    at android.view.SurfaceControl.setDisplaySurface(SurfaceControl.java:2147)
-    ... 9 more
-```
-
-[#2129]: https://github.com/Genymobile/scrcpy/issues/2129
-
-
 ## Command line on Windows

-Since v1.22, a "shortcut" has been added to directly open a terminal in the
-scrcpy directory. Double-click on `open_a_terminal_here.bat`, then type your
-command. For example:
-
-```
-scrcpy --record file.mkv
-```
-
-You could also open a terminal and go to the scrcpy folder manually:
+Some Windows users are not familiar with the command line. Here is how to open a
+terminal and run `scrcpy` with arguments:

 1. Press <kbd>Windows</kbd>+<kbd>r</kbd>, this opens a dialog box.
 2. Type `cmd` and press <kbd>Enter</kbd>, this opens a terminal.
@ -307,12 +237,3 @@ You could also edit (a copy of) `scrcpy-console.bat` or `scrcpy-noconsole.vbs`
 to add some arguments.

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

   Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2022 Romain Vimont
+   Copyright (C) 2018-2021 Romain Vimont

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
--- a/README.de.md
+++ b/README.de.md
--- a/README.id.md
+++ b/README.id.md
@ -69,7 +69,10 @@ Anda juga bisa [membangun aplikasi secara manual][BUILD] (jangan khawatir, tidak

 Untuk Windows, untuk kesederhanaan, arsip prebuilt dengan semua dependensi (termasuk `adb`) tersedia :

- - [README](README.md#windows)
+ - [`scrcpy-win64-v1.16.zip`][direct-win64]  
+   _(SHA-256: 3f30dc5db1a2f95c2b40a0f5de91ec1642d9f53799250a8c529bc882bc0918f0)_
+
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.16/scrcpy-win64-v1.16.zip

 Ini juga tersedia di [Chocolatey]:

@ -218,7 +221,7 @@ variation] does not impact the recorded file.

 #### Wireless

-_Scrcpy_ menggunakan `adb` untuk berkomunikasi dengan perangkat, dan `adb` dapat [terhubung] ke perangkat melalui TCP / IP:
+_Scrcpy_ menggunakan `adb` untuk berkomunikasi dengan perangkat, dan` adb` dapat [terhubung] ke perangkat melalui TCP / IP:

 1. Hubungkan perangkat ke Wi-Fi yang sama dengan komputer Anda.
 2. Dapatkan alamat IP perangkat Anda (dalam Pengaturan → Tentang ponsel → Status).
@ -281,7 +284,7 @@ Dari terminal lain:
 scrcpy
 ```

-Untuk menghindari mengaktifkan penerusan port jarak jauh, Anda dapat memaksa sambungan maju sebagai gantinya (perhatikan `-L`, bukan `-R`):
+Untuk menghindari mengaktifkan penerusan port jarak jauh, Anda dapat memaksa sambungan maju sebagai gantinya (perhatikan `-L`, bukan` -R`):

 ```bash
 adb kill-server    # matikan server adb lokal di 5037
@ -579,7 +582,7 @@ Lihat juga [Masalah #14].

 Dalam daftar berikut, <kbd>MOD</kbd> adalah pengubah pintasan. Secara default, ini (kiri) <kbd>Alt</kbd> atau (kiri) <kbd>Super</kbd>.

-Ini dapat diubah menggunakan `--shortcut-mod`. Kunci yang memungkinkan adalah `lctrl`, `rctrl`, `lalt`, `ralt`, `lsuper` dan `rsuper`. Sebagai contoh:
+Ini dapat diubah menggunakan `--shortcut-mod`. Kunci yang memungkinkan adalah `lctrl`,`rctrl`, `lalt`,` ralt`, `lsuper` dan` rsuper`. Sebagai contoh:

 ```bash
 # gunakan RCtrl untuk jalan pintas
@ -672,7 +675,7 @@ Baca [halaman pengembang].
 ## Lisensi

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
--- a/README.it.md
+++ b/README.it.md
--- a/README.jp.md
+++ b/README.jp.md
@ -1,799 +0,0 @@
-_Only the original [README](README.md) is guaranteed to be up-to-date._
-
-# scrcpy (v1.19)
-
-このアプリケーションはUSB(もしくは[TCP/IP経由][article-tcpip])で接続されたAndroidデバイスの表示と制御を提供します。このアプリケーションは _root_ でのアクセスを必要としません。このアプリケーションは _GNU/Linux_ 、 _Windows_ そして _macOS_ 上で動作します。
-
-![screenshot](assets/screenshot-debian-600.jpg)
-
-以下に焦点を当てています:
-
- - **軽量** (ネイティブ、デバイス画面表示のみ)
- - **パフォーマンス**　(30~60fps)
- - **クオリティ**　(1920x1080以上)
- - **低遅延**　([35~70ms][lowlatency])
- - **短い起動時間**　(初回画像を1秒以内に表示)
- - **非侵入型**　(デバイスに何もインストールされていない状態になる)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-
-## 必要要件
-
-AndroidデバイスはAPI21(Android 5.0)以上。
-
-Androidデバイスで[adbデバッグが有効][enable-adb]であること。
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-一部のAndroidデバイスでは、キーボードとマウスを使用して制御する[追加オプション][control]を有効にする必要がある。
-
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-## アプリの取得
-
-<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
-
-### Linux
-
-Debian (_testing_ と _sid_) とUbuntu(20.04):
-
-```
-apt install scrcpy
-```
-
-[Snap]パッケージが利用可能: [`scrcpy`][snap-link]
-
-[snap-link]: https://snapstats.org/snaps/scrcpy
-
-[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
-
-Fedora用[COPR]パッケージが利用可能: [`scrcpy`][copr-link]
-
-[COPR]: https://fedoraproject.org/wiki/Category:Copr
-[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
-
-Arch Linux用[AUR]パッケージが利用可能: [`scrcpy`][aur-link]
-
-[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
-
-Gentoo用[Ebuild]が利用可能: [`scrcpy`][ebuild-link]
-
-[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
-[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-
-[自分でビルド][BUILD]も可能（心配しないでください、それほど難しくはありません。）
-
-
-### Windows
-
-Windowsでは簡単に、（`adb`を含む）すべての依存関係を構築済みのアーカイブを利用可能です。
-
- - [README](README.md#windows)
-
-[Chocolatey]でも利用可能です:
-
-[Chocolatey]: https://chocolatey.org/
-
-```bash
-choco install scrcpy
-choco install adb    # まだ入手していない場合
-```
-
-[Scoop]でも利用可能です:
-
-```bash
-scoop install scrcpy
-scoop install adb    # まだ入手していない場合
-```
-
-[Scoop]: https://scoop.sh
-
-また、[アプリケーションをビルド][BUILD]することも可能です。
-
-### macOS
-
-アプリケーションは[Homebrew]で利用可能です。ただインストールするだけです。
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-`PATH`からアクセス可能な`adb`が必要です。もし持っていない場合はインストールしてください。
-
-```bash
-brew install android-platform-tools
-```
-
-`adb`は[MacPorts]からでもインストールできます。
-
-```bash
-sudo port install scrcpy
-```
-
-[MacPorts]: https://www.macports.org/
-
-また、[アプリケーションをビルド][BUILD]することも可能です。
-
-## 実行
-
-Androidデバイスを接続し、実行:
-
-```bash
-scrcpy
-```
-
-次のコマンドでリストされるコマンドライン引数も受け付けます:
-
-```bash
-scrcpy --help
-```
-
-## 機能
-
-### キャプチャ構成
-
-#### サイズ削減
-
-Androidデバイスを低解像度でミラーリングする場合、パフォーマンス向上に便利な場合があります。
-
-幅と高さをある値(例：1024)に制限するには:
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # 短縮版
-```
-
-一方のサイズはデバイスのアスペクト比が維持されるように計算されます。この方法では、1920x1080のデバイスでは1024x576にミラーリングされます。
-
-
-#### ビットレート変更
-
-ビットレートの初期値は8Mbpsです。ビットレートを変更するには(例:2Mbpsに変更):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # 短縮版
-```
-
-#### フレームレート制限
-
-キャプチャするフレームレートを制限できます:
-
-```bash
-scrcpy --max-fps 15
-```
-
-この機能はAndroid 10からオフィシャルサポートとなっていますが、以前のバージョンでも動作する可能性があります。
-
-#### トリミング
-
-デバイスの画面は、画面の一部のみをミラーリングするようにトリミングできます。
-
-これは、例えばOculus Goの片方の目をミラーリングする場合に便利です。:
-
-```bash
-scrcpy --crop 1224:1440:0:0   # オフセット位置(0,0)で1224x1440
-```
-
-もし`--max-size`も指定されている場合、トリミング後にサイズ変更が適用されます。
-
-#### ビデオの向きをロックする
-
-ミラーリングの向きをロックするには:
-
-```bash
-scrcpy --lock-video-orientation     # 現在の向き
-scrcpy --lock-video-orientation=0   # 自然な向き
-scrcpy --lock-video-orientation=1   # 90°反時計回り
-scrcpy --lock-video-orientation=2   # 180°
-scrcpy --lock-video-orientation=3   # 90°時計回り
-```
-
-この設定は録画の向きに影響します。
-
-[ウィンドウは独立して回転することもできます](#回転)。
-
-
-#### エンコーダ
-
-いくつかのデバイスでは一つ以上のエンコーダを持ちます。それらのいくつかは、問題やクラッシュを引き起こします。別のエンコーダを選択することが可能です:
-
-
-```bash
-scrcpy --encoder OMX.qcom.video.encoder.avc
-```
-
-利用可能なエンコーダをリストするために、無効なエンコーダ名を渡すことができます。エラー表示で利用可能なエンコーダを提供します。
-
-```bash
-scrcpy --encoder _
-```
-
-### キャプチャ
-
-#### 録画
-
-ミラーリング中に画面の録画をすることが可能です:
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-録画中にミラーリングを無効にするには:
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# Ctrl+Cで録画を中断する
-```
-
-"スキップされたフレーム"は(パフォーマンス上の理由で)リアルタイムで表示されなくても録画されます。
-
-フレームはデバイス上で _タイムスタンプされる_ ため [パケット遅延のバリエーション] は録画されたファイルに影響を与えません。
-
-[パケット遅延のバリエーション]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-#### v4l2loopback
-
-Linuxでは、ビデオストリームをv4l2ループバックデバイスに送信することができます。
-v4l2loopbackのデバイスにビデオストリームを送信することで、Androidデバイスをウェブカメラのようにv4l2対応ツールで開くこともできます。
-
-`v4l2loopback` モジュールのインストールが必要です。
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-v4l2デバイスを作成する。
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-これにより、新しいビデオデバイスが `/dev/videoN` に作成されます。（`N` は整数）
-(複数のデバイスや特定のIDのデバイスを作成するために、より多くの[オプション](https://github.com/umlaeute/v4l2loopback#options)が利用可能です。
-多くの[オプション]()が利用可能で複数のデバイスや特定のIDのデバイスを作成できます。
-
-
-有効なデバイスを一覧表示する:
-
-```bash
-# v4l-utilsパッケージが必要
-v4l2-ctl --list-devices
-
-# シンプルですが十分これで確認できます
-ls /dev/video*
-```
-
-v4l2シンクを使用してscrcpyを起動する。
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # ミラーリングウィンドウを無効化する
-scrcpy --v4l2-sink=/dev/videoN -N            # 短縮版
-```
-
-(`N` をデバイス ID に置き換えて、`ls /dev/video*` で確認してください)
-有効にすると、v4l2対応のツールでビデオストリームを開けます。
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLCではバッファリングの遅延が発生する場合があります
-```
-
-例えばですが [OBS]の中にこの映像を取り込めことができます。
-
-[OBS]: https://obsproject.com/
-
-
-#### Buffering
-
-バッファリングを追加することも可能です。これによりレイテンシーは増加しますが、ジッターは減少します。（参照
-[#2464])
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-このオプションでディスプレイバッファリングを設定できます。
-
-```bash
-scrcpy --display-buffer=50  # ディスプレイに50msのバッファリングを追加する
-```
-
-V4L2の場合はこちらのオプションで設定できます。
-
-```bash
-scrcpy --v4l2-buffer=500    # add 500 ms buffering for v4l2 sink
-```
-
-### 接続
-
-#### ワイヤレス
-
-_Scrcpy_ はデバイスとの通信に`adb`を使用します。そして`adb`はTCP/IPを介しデバイスに[接続]することができます:
-
-1. あなたのコンピュータと同じWi-Fiに接続します。
-2. あなたのIPアドレスを取得します。設定 → 端末情報 → ステータス情報、もしくは、このコマンドを実行します:
-
-    ```bash
-    adb shell ip route | awk '{print $9}'
-    ```
-
-3. あなたのデバイスでTCP/IPを介したadbを有効にします: `adb tcpip 5555`
-4. あなたのデバイスの接続を外します。
-5. あなたのデバイスに接続します:
- `adb connect DEVICE_IP:5555` _(`DEVICE_IP`は置き換える)_
-6. 通常通り`scrcpy`を実行します。
-
-この方法はビットレートと解像度を減らすのにおそらく有用です:
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # 短縮版
-```
-
-[接続]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-#### マルチデバイス
-
-もし`adb devices`でいくつかのデバイスがリストされる場合、 _シリアルナンバー_ を指定する必要があります:
-
-```bash
-scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # 短縮版
-```
-
-デバイスがTCP/IPを介して接続されている場合:
-
-```bash
-scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # 短縮版
-```
-
-複数のデバイスに対して、複数の _scrcpy_ インスタンスを開始することができます。
-
-#### デバイス接続での自動起動
-
-[AutoAdb]を使用可能です:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
-
-#### SSHトンネル
-
-リモートデバイスに接続するため、ローカル`adb`クライアントからリモート`adb`サーバーへ接続することが可能です(同じバージョンの _adb_ プロトコルを使用している場合):
-
-```bash
-adb kill-server    # 5037ポートのローカルadbサーバーを終了する
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# オープンしたままにする
-```
-
-他の端末から:
-
-```bash
-scrcpy
-```
-
-リモートポート転送の有効化を回避するためには、代わりに転送接続を強制することができます(`-R`の代わりに`-L`を使用することに注意):
-
-```bash
-adb kill-server    # 5037ポートのローカルadbサーバーを終了する
-ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
-# オープンしたままにする
-```
-
-他の端末から:
-
-```bash
-scrcpy --force-adb-forward
-```
-
-
-ワイヤレス接続と同様に、クオリティを下げると便利な場合があります:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-### ウィンドウ構成
-
-#### タイトル
-
-ウィンドウのタイトルはデバイスモデルが初期値です。これは変更できます:
-
-```bash
-scrcpy --window-title 'My device'
-```
-
-#### 位置とサイズ
-
-ウィンドウの位置とサイズの初期値を指定できます:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-#### ボーダーレス
-
-ウィンドウの装飾を無効化するには:
-
-```bash
-scrcpy --window-borderless
-```
-
-#### 常に画面のトップ
-
-scrcpyの画面を常にトップにするには:
-
-```bash
-scrcpy --always-on-top
-```
-
-#### フルスクリーン
-
-アプリケーションを直接フルスクリーンで開始できます:
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # 短縮版
-```
-
-フルスクリーンは、次のコマンドで動的に切り替えることができます <kbd>MOD</kbd>+<kbd>f</kbd>
-
-
-#### 回転
-
-ウィンドウは回転することができます:
-
-```bash
-scrcpy --rotation 1
-```
-
-設定可能な値:
- - `0`: 回転なし
- - `1`: 90° 反時計回り
- - `2`: 180°
- - `3`: 90° 時計回り
-
-回転は次のコマンドで動的に変更することができます。 <kbd>MOD</kbd>+<kbd>←</kbd>_(左)_ 、 <kbd>MOD</kbd>+<kbd>→</kbd>_(右)_
-
-_scrcpy_ は3つの回転を管理することに注意:
- - <kbd>MOD</kbd>+<kbd>r</kbd>はデバイスに縦向きと横向きの切り替えを要求する(現在実行中のアプリで要求している向きをサポートしていない場合、拒否することがある)
- - [`--lock-video-orientation`](#ビデオの向きをロックする)は、ミラーリングする向きを変更する(デバイスからPCへ送信される向き)。録画に影響します。
- - `--rotation` (もしくは<kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)は、ウィンドウのコンテンツのみを回転します。これは表示にのみに影響し、録画には影響しません。
-
-### 他のミラーリングオプション
-
-#### Read-only　リードオンリー
-
-制御を無効にするには(デバイスと対話する全てのもの:入力キー、マウスイベント、ファイルのドラッグ&ドロップ):
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-#### ディスプレイ
-
-いくつか利用可能なディスプレイがある場合、ミラーリングするディスプレイを選択できます:
-
-```bash
-scrcpy --display 1
-```
-
-ディスプレイIDのリストは次の方法で取得できます:
-
-```
-adb shell dumpsys display   # search "mDisplayId=" in the output
-```
-
-セカンダリディスプレイは、デバイスが少なくともAndroid 10の場合にコントロール可能です。(それ以外ではリードオンリーでミラーリングされます)
-
-
-#### 起動状態にする
-
-デバイス接続時、少し遅れてからデバイスのスリープを防ぐには:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w
-```
-
-scrcpyが閉じられた時、初期状態に復元されます。
-
-#### 画面OFF
-
-コマンドラインオプションを使用することで、ミラーリングの開始時にデバイスの画面をOFFにすることができます:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-もしくは、<kbd>MOD</kbd>+<kbd>o</kbd>を押すことでいつでもできます。
-
-元に戻すには、<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>を押します。
-
-Androidでは、`POWER`ボタンはいつでも画面を表示します。便宜上、`POWER`がscrcpyを介して(右クリックもしくは<kbd>MOD</kbd>+<kbd>p</kbd>を介して)送信される場合、(ベストエフォートベースで)少し遅れて、強制的に画面を非表示にします。ただし、物理的な`POWER`ボタンを押した場合は、画面は表示されます。
-
-このオプションはデバイスがスリープしないようにすることにも役立ちます:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw
-```
-
-
-#### タッチを表示
-
-プレゼンテーションの場合(物理デバイス上で)物理的なタッチを表示すると便利な場合があります。
-
-Androidはこの機能を _開発者オプション_ で提供します。
-
-_Scrcpy_　は開始時にこの機能を有効にし、終了時に初期値を復元するオプションを提供します:
-
-```bash
-scrcpy --show-touches
-scrcpy -t
-```
-
-(デバイス上で指を使った) _物理的な_ タッチのみ表示されることに注意してください。
-
-
-#### スクリーンセーバー無効
-
-初期状態では、scrcpyはコンピュータ上でスクリーンセーバーが実行される事を妨げません。
-
-これを無効にするには:
-
-```bash
-scrcpy --disable-screensaver
-```
-
-
-### 入力制御
-
-#### デバイス画面の回転
-
-<kbd>MOD</kbd>+<kbd>r</kbd>を押すことで、縦向きと横向きを切り替えます。
-
-フォアグラウンドのアプリケーションが要求された向きをサポートしている場合のみ回転することに注意してください。
-
-#### コピー-ペースト
-
-Androidのクリップボードが変更される度に、コンピュータのクリップボードに自動的に同期されます。
-
-<kbd>Ctrl</kbd>のショートカットは全てデバイスに転送されます。特に:
- - <kbd>Ctrl</kbd>+<kbd>c</kbd> 通常はコピーします
- - <kbd>Ctrl</kbd>+<kbd>x</kbd> 通常はカットします
- - <kbd>Ctrl</kbd>+<kbd>v</kbd> 通常はペーストします(コンピュータとデバイスのクリップボードが同期された後)
-
-通常は期待通りに動作します。
-
-しかしながら、実際の動作はアクティブなアプリケーションに依存します。例えば、_Termux_ は代わりに<kbd>Ctrl</kbd>+<kbd>c</kbd>でSIGINTを送信します、そして、_K-9 Mail_ は新しいメッセージを作成します。
-
-このようなケースでコピー、カットそしてペーストをするには(Android 7以上でのサポートのみですが):
- - <kbd>MOD</kbd>+<kbd>c</kbd> `COPY`を挿入
- - <kbd>MOD</kbd>+<kbd>x</kbd> `CUT`を挿入
- - <kbd>MOD</kbd>+<kbd>v</kbd> `PASTE`を挿入(コンピュータとデバイスのクリップボードが同期された後)
-
-加えて、<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>はコンピュータのクリップボードテキストにキーイベントのシーケンスとして挿入することを許可します。これはコンポーネントがテキストのペーストを許可しない場合(例えば _Termux_)に有用ですが、非ASCIIコンテンツを壊す可能性があります。
-
-**警告:** デバイスにコンピュータのクリップボードを(<kbd>Ctrl</kbd>+<kbd>v</kbd>または<kbd>MOD</kbd>+<kbd>v</kbd>を介して)ペーストすることは、デバイスのクリップボードにコンテンツをコピーします。結果としてどのAndoridアプリケーションもそのコンテンツを読み取ることができます。機密性の高いコンテンツ(例えばパスワードなど)をこの方法でペーストすることは避けてください。
-
-プログラムでデバイスのクリップボードを設定した場合、一部のデバイスは期待どおりに動作しません。`--legacy-paste`オプションは、コンピュータのクリップボードテキストをキーイベントのシーケンスとして挿入するため(<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>と同じ方法)、<kbd>Ctrl</kbd>+<kbd>v</kbd>と<kbd>MOD</kbd>+<kbd>v</kbd>の動作の変更を提供します。
-
-#### ピンチしてズームする
-
-"ピンチしてズームする"をシミュレートするには: <kbd>Ctrl</kbd>+_クリック&移動_
-
-より正確にするには、左クリックボタンを押している間、<kbd>Ctrl</kbd>を押したままにします。左クリックボタンを離すまで、全てのマウスの動きは、(アプリでサポートされている場合)画面の中心を基準として、コンテンツを拡大縮小および回転します。
-
-具体的には、scrcpyは画面の中央を反転した位置にある"バーチャルフィンガー"から追加のタッチイベントを生成します。
-
-
-#### テキストインジェクション環境設定
-
-テキストをタイプした時に生成される2種類の[イベント][textevents]があります:
- - _key events_　はキーを押したときと離したことを通知します。
- - _text events_　はテキストが入力されたことを通知します。
-
-初期状態で、文字はキーイベントで挿入されるため、キーボードはゲームで期待通りに動作します(通常はWASDキー)。
-
-しかし、これは[問題を引き起こす][prefertext]かもしれません。もしこのような問題が発生した場合は、この方法で回避できます:
-
-```bash
-scrcpy --prefer-text
-```
-
-(しかしこの方法はゲームのキーボードの動作を壊します)
-
-[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
-[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-
-
-#### キーの繰り返し
-
-初期状態では、キーの押しっぱなしは繰り返しのキーイベントを生成します。これらのイベントが使われない場合でも、この方法は一部のゲームでパフォーマンスの問題を引き起す可能性があります。
-
-繰り返しのキーイベントの転送を回避するためには:
-
-```bash
-scrcpy --no-key-repeat
-```
-
-
-#### 右クリックと真ん中クリック
-
-初期状態では、右クリックはバックの動作(もしくはパワーオン)を起こし、真ん中クリックではホーム画面へ戻ります。このショートカットを無効にし、代わりにデバイスへクリックを転送するには:
-
-```bash
-scrcpy --forward-all-clicks
-```
-
-
-### ファイルのドロップ
-
-#### APKのインストール
-
-APKをインストールするには、(`.apk`で終わる)APKファイルを _scrcpy_ の画面にドラッグ&ドロップします。
-
-見た目のフィードバックはありません。コンソールにログが出力されます。
-
-
-#### デバイスにファイルを送る
-
-デバイスの`/sdcard/Download`ディレクトリにファイルを送るには、(APKではない)ファイルを _scrcpy_ の画面にドラッグ&ドロップします。
-
-見た目のフィードバックはありません。コンソールにログが出力されます。
-
-転送先ディレクトリを起動時に変更することができます:
-
-```bash
-scrcpy --push-target=/sdcard/Movies/
-```
-
-
-### 音声転送
-
-音声は _scrcpy_ では転送されません。[sndcpy]を使用します。
-
-[issue #14]も参照ください。
-
-[sndcpy]: https://github.com/rom1v/sndcpy
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
-
-
-## ショートカット
-
-次のリストでは、<kbd>MOD</kbd>でショートカット変更します。初期状態では、(left)<kbd>Alt</kbd>または(left)<kbd>Super</kbd>です。
-
-これは`--shortcut-mod`で変更することができます。可能なキーは`lctrl`、`rctrl`、`lalt`、 `ralt`、 `lsuper`そして`rsuper`です。例えば:
-
-```bash
-# RCtrlをショートカットとして使用します
-scrcpy --shortcut-mod=rctrl
-
-# ショートカットにLCtrl+LAltまたはLSuperのいずれかを使用します
-scrcpy --shortcut-mod=lctrl+lalt,lsuper
-```
-
-_<kbd>[Super]</kbd>は通常<kbd>Windows</kbd>もしくは<kbd>Cmd</kbd>キーです。_
-
-[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
-
- | アクション                                   |   ショートカット
- | ------------------------------------------- |:-----------------------------
- | フルスクリーンモードへの切り替え               | <kbd>MOD</kbd>+<kbd>f</kbd>
- | ディスプレイを左に回転                        | <kbd>MOD</kbd>+<kbd>←</kbd> _(左)_
- | ディスプレイを右に回転                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(右)_
- | ウィンドウサイズを変更して1:1に変更(ピクセルパーフェクト)  | <kbd>MOD</kbd>+<kbd>g</kbd>
- | ウィンドウサイズを変更して黒い境界線を削除      | <kbd>MOD</kbd>+<kbd>w</kbd> \| _ダブルクリック¹_
- | `HOME`をクリック                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _真ん中クリック_
- | `BACK`をクリック                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _右クリック²_
- | `APP_SWITCH`をクリック                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4クリック³_
- | `MENU` (画面のアンロック)をクリック            | <kbd>MOD</kbd>+<kbd>m</kbd>
- | `VOLUME_UP`をクリック                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上)_
- | `VOLUME_DOWN`をクリック                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下)_
- | `POWER`をクリック                            | <kbd>MOD</kbd>+<kbd>p</kbd>
- | 電源オン                                     | _右クリック²_
- | デバイス画面をオフにする(ミラーリングしたまま)  | <kbd>MOD</kbd>+<kbd>o</kbd>
- | デバイス画面をオンにする                      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
- | デバイス画面を回転する                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | 通知パネルを展開する                          | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5ボタンクリック³_
- | 設定パネルを展開する                          | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _5ダブルクリック³_
- | 通知パネルを折りたたむ                        | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | クリップボードへのコピー³                     | <kbd>MOD</kbd>+<kbd>c</kbd>
- | クリップボードへのカット³                     | <kbd>MOD</kbd>+<kbd>x</kbd>
- | クリップボードの同期とペースト³                | <kbd>MOD</kbd>+<kbd>v</kbd>
- | コンピュータのクリップボードテキストの挿入      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
- | FPSカウンタ有効/無効(標準入出力上)             | <kbd>MOD</kbd>+<kbd>i</kbd>
- | ピンチしてズームする                          | <kbd>Ctrl</kbd>+_クリック&移動_
-
-_¹黒い境界線を削除するため、境界線上でダブルクリック_  
-_²もしスクリーンがオフの場合、右クリックでスクリーンをオンする。それ以外の場合はBackを押します._  
-_³4と5はマウスのボタンです、もしあなたのマウスにボタンがあれば使えます._  
-_⁴Android 7以上のみ._
-
-キーを繰り返すショートカットはキーを離して2回目を押したら実行されます。例えば「設定パネルを展開する」を実行する場合は以下のように操作する。
-
- 1. <kbd>MOD</kbd> キーを押し、押したままにする.
- 2. その後に <kbd>n</kbd>キーを2回押す.
- 3. 最後に <kbd>MOD</kbd>キーを離す.
-
-全ての<kbd>Ctrl</kbd>+_キー_ ショートカットはデバイスに転送されます、そのためアクティブなアプリケーションによって処理されます。
-
-## カスタムパス
-
-特定の _adb_ バイナリを使用する場合、そのパスを環境変数`ADB`で構成します:
-
-    ADB=/path/to/adb scrcpy
-
-`scrcpy-server`ファイルのパスを上書きするには、`SCRCPY_SERVER_PATH`でそのパスを構成します。
-
-[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
-
-
-## なぜ _scrcpy_?
-
-同僚が私に、[gnirehtet]のように発音できない名前を見つけるように要求しました。
-
-[`strcpy`]は**str**ingをコピーします。`scrcpy`は**scr**eenをコピーします。
-
-[gnirehtet]: https://github.com/Genymobile/gnirehtet
-[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
-
-
-## ビルド方法は?
-
-[BUILD]を参照してください。
-
-[BUILD]: BUILD.md
-
-
-## よくある質問
-
-[FAQ](FAQ.md)を参照してください。
-
-
-## 開発者
-
-[開発者のページ]を読んでください。
-
-[開発者のページ]: DEVELOP.md
-
-
-## ライセンス
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## 記事
-
- [Introducing scrcpy][article-intro]
- [Scrcpy now works wirelessly][article-tcpip]
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.ko.md
+++ b/README.ko.md
@ -68,7 +68,9 @@ Gentoo에서 ,[Ebuild] 가 가능합니다 : [`scrcpy/`][ebuild-link].

 윈도우 상에서, 간단하게 설치하기 위해 종속성이 있는 사전 구축된 아카이브가 제공됩니다 (`adb` 포함) :
 해당 파일은 Readme원본 링크를 통해서 다운로드가 가능합니다.
- - [README](README.md#windows)
+ - [`scrcpy-win`][direct-win]
+
+[direct-win]: https://github.com/Genymobile/scrcpy/blob/master/README.md#windows


 [어플을 직접 설치][BUILD] 할 수도 있습니다.
@ -112,7 +114,7 @@ scrcpy --help
 ### 캡쳐 환경 설정


-### 사이즈 재정의
+###사이즈 재정의

 가끔씩 성능을 향상시키기위해 안드로이드 디바이스를 낮은 해상도에서 미러링하는 것이 유용할 때도 있습니다.

@ -136,7 +138,7 @@ scrcpy --bit-rate 2M
 scrcpy -b 2M  # 축약 버전
 ```

-### 프레임 비율 제한
+###프레임 비율 제한

 안드로이드 버전 10이상의 디바이스에서는, 다음의 명령어로 캡쳐 화면의 프레임 비율을 제한할 수 있습니다:

@ -475,7 +477,7 @@ _²화면이 꺼진 상태에서 우클릭 시 다시 켜지며, 그 외의 상
 ## 라이선스

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
--- a/README.md
+++ b/README.md
@ -1,51 +1,35 @@
-# scrcpy (v1.24)
-
-<img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
-
-_pronounced "**scr**een **c**o**py**"_
+# scrcpy (v1.17)

 [Read in another language](#translations)

-This application provides display and control of Android devices connected via
-USB or [over TCP/IP](#tcpip-wireless). It does not require any _root_ access.
+This application provides display and control of Android devices connected on
+USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
 It works on _GNU/Linux_, _Windows_ and _macOS_.

 ![screenshot](assets/screenshot-debian-600.jpg)

 It focuses on:

- - **lightness**: native, displays only the device screen
- - **performance**: 30~120fps, depending on the device
- - **quality**: 1920×1080 or above
- - **low latency**: [35~70ms][lowlatency]
- - **low startup time**: ~1 second to display the first image
- - **non-intrusiveness**: nothing is left installed on the Android device
- - **user benefits**: no account, no ads, no internet required
- - **freedom**: free and open source software
+ - **lightness** (native, displays only the device screen)
+ - **performance** (30~60fps)
+ - **quality** (1920×1080 or above)
+ - **low latency** ([35~70ms][lowlatency])
+ - **low startup time** (~1 second to display the first image)
+ - **non-intrusiveness** (nothing is left installed on the device)

 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646

-Its features include:
- - [recording](#recording)
- - mirroring with [Android device screen off](#turn-screen-off)
- - [copy-paste](#copy-paste) in both directions
- - [configurable quality](#capture-configuration)
- - Android device [as a webcam (V4L2)](#v4l2loopback) (Linux-only)
- - [physical keyboard simulation (HID)](#physical-keyboard-simulation-hid)
- - [physical mouse simulation (HID)](#physical-mouse-simulation-hid)
- - [OTG mode](#otg)
- - and more…

 ## Requirements

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

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

 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling

 On some devices, you also need to enable [an additional option][control] to
-control it using a keyboard and mouse.
+control it using keyboard and mouse.

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

@ -54,32 +38,14 @@ control it using a keyboard and mouse.

 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>

-### Summary
-
- - Linux: `apt install scrcpy`
- - Windows: [download][direct-win64]
- - macOS: `brew install scrcpy`
-
-Build from sources: [BUILD] ([simplified process][BUILD_simple])
-
-[BUILD]: BUILD.md
-[BUILD_simple]: BUILD.md#simple
-
-
 ### Linux

-On Debian and Ubuntu:
+On Debian (_testing_ and _sid_ for now) and Ubuntu (20.04):

 ```
 apt install scrcpy
 ```

-On Arch Linux:
-
-```
-pacman -S scrcpy
-```
-
 A [Snap] package is available: [`scrcpy`][snap-link].

 [snap-link]: https://snapstats.org/snaps/scrcpy
@ -91,25 +57,30 @@ For Fedora, a [COPR] package is available: [`scrcpy`][copr-link].
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/

+For Arch Linux, an [AUR] package is available: [`scrcpy`][aur-link].
+
+[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
+[aur-link]: https://aur.archlinux.org/packages/scrcpy/

 For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].

 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy

-You can also [build the app manually][BUILD] ([simplified
-process][BUILD_simple]).
+You could also [build the app manually][BUILD] (don't worry, it's not that
+hard).
+


 ### Windows

-For Windows, a prebuilt archive with all the dependencies (including `adb`) is
-available:
+For Windows, for simplicity, a prebuilt archive with all the dependencies
+(including `adb`) is available:

- - [`scrcpy-win64-v1.24.zip`][direct-win64]  
-   <sub>SHA-256: `6ccb64cba0a3e75715e85a188daeb4f306a1985f8ce123eba92ba74fc9b27367`</sub>
+ - [`scrcpy-win64-v1.17.zip`][direct-win64]  
+   _(SHA-256: 8b9e57993c707367ed10ebfe0e1ef563c7a29d9af4a355cd8b6a52a317c73eea)_

-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-win64-v1.24.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-win64-v1.17.zip

 It is also available in [Chocolatey]:

@ -145,24 +116,19 @@ brew install scrcpy
 You need `adb`, accessible from your `PATH`. If you don't have it yet:

 ```bash
-brew install android-platform-tools
+# Homebrew >= 2.6.0
+brew install --cask android-platform-tools
+
+# Homebrew < 2.6.0
+brew cask install android-platform-tools
 ```

-It's also available in [MacPorts], which sets up `adb` for you:
-
-```bash
-sudo port install scrcpy
-```
-
-[MacPorts]: https://www.macports.org/
-
-
 You can also [build the app manually][BUILD].


 ## Run

-Plug an Android device into your computer, and execute:
+Plug an Android device, and execute:

 ```bash
 scrcpy
@ -180,7 +146,7 @@ scrcpy --help

 #### Reduce size

-Sometimes, it is useful to mirror an Android device at a lower resolution to
+Sometimes, it is useful to mirror an Android device at a lower definition to
 increase performance.

 To limit both the width and height to some value (e.g. 1024):
@ -190,8 +156,8 @@ scrcpy --max-size 1024
 scrcpy -m 1024  # short version
 ```

-The other dimension is computed so that the Android device aspect ratio is
-preserved. That way, a device in 1920×1080 will be mirrored at 1024×576.
+The other dimension is computed to that the device aspect ratio is preserved.
+That way, a device in 1920×1080 will be mirrored at 1024×576.


 #### Change bit-rate
@ -213,20 +179,11 @@ scrcpy --max-fps 15

 This is officially supported since Android 10, but may work on earlier versions.

-The actual capture framerate may be printed to the console:
-
-```
-scrcpy --print-fps
-```
-
-It may also be enabled or disabled at any time with <kbd>MOD</kbd>+<kbd>i</kbd>.
-
-
 #### Crop

 The device screen may be cropped to mirror only part of the screen.

-This is useful, for example, to mirror only one eye of the Oculus Go:
+This is useful for example to mirror only one eye of the Oculus Go:

 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
@ -237,14 +194,14 @@ If `--max-size` is also specified, resizing is applied after cropping.

 #### Lock video orientation

+
 To lock the orientation of the mirroring:

 ```bash
-scrcpy --lock-video-orientation     # initial (current) orientation
-scrcpy --lock-video-orientation=0   # natural orientation
-scrcpy --lock-video-orientation=1   # 90° counterclockwise
-scrcpy --lock-video-orientation=2   # 180°
-scrcpy --lock-video-orientation=3   # 90° clockwise
+scrcpy --lock-video-orientation 0   # natural orientation
+scrcpy --lock-video-orientation 1   # 90° counterclockwise
+scrcpy --lock-video-orientation 2   # 180°
+scrcpy --lock-video-orientation 3   # 90° clockwise
 ```

 This affects recording orientation.
@ -261,16 +218,14 @@ crash. It is possible to select a different encoder:
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```

-To list the available encoders, you can pass an invalid encoder name; the
+To list the available encoders, you could pass an invalid encoder name, the
 error will give the available encoders:

 ```bash
 scrcpy --encoder _
 ```

-### Capture
-
-#### Recording
+### Recording

 It is possible to record the screen while mirroring:

@ -294,141 +249,27 @@ variation] does not impact the recorded file.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation


-#### v4l2loopback
-
-On Linux, it is possible to send the video stream to a v4l2 loopback device, so
-that the Android device can be opened like a webcam by any v4l2-capable tool.
-
-The module `v4l2loopback` must be installed:
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-To create a v4l2 device:
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-This will create a new video device in `/dev/videoN`, where `N` is an integer
-(more [options](https://github.com/umlaeute/v4l2loopback#options) are available
-to create several devices or devices with specific IDs).
-
-To list the enabled devices:
-
-```bash
-# requires v4l-utils package
-v4l2-ctl --list-devices
-
-# simple but might be sufficient
-ls /dev/video*
-```
-
-To start `scrcpy` using a v4l2 sink:
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # disable mirroring window
-scrcpy --v4l2-sink=/dev/videoN -N            # short version
-```
-
-(replace `N` with the device ID, check with `ls /dev/video*`)
-
-Once enabled, you can open your video stream with a v4l2-capable tool:
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLC might add some buffering delay
-```
-
-For example, you could capture the video within [OBS].
-
-[OBS]: https://obsproject.com/
-
-
-#### Buffering
-
-It is possible to add buffering. This increases latency, but reduces jitter (see
-[#2464]).
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-The option is available for display buffering:
-
-```bash
-scrcpy --display-buffer=50  # add 50 ms buffering for display
-```
-
-and V4L2 sink:
-
-```bash
-scrcpy --v4l2-buffer=500    # add 500 ms buffering for v4l2 sink
-```
-
-
 ### Connection

-#### TCP/IP (wireless)
+#### Wireless

 _Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
-device over TCP/IP. The device must be connected on the same network as the
-computer.
+device over TCP/IP:

-##### Automatic
-
-An option `--tcpip` allows to configure the connection automatically. There are
-two variants.
-
-If the device (accessible at 192.168.1.1 in this example) already listens on a
-port (typically 5555) for incoming _adb_ connections, then run:
-
-```bash
-scrcpy --tcpip=192.168.1.1       # default port is 5555
-scrcpy --tcpip=192.168.1.1:5555
-```
-
-If _adb_ TCP/IP mode is disabled on the device (or if you don't know the IP
-address), connect the device over USB, then run:
-
-```bash
-scrcpy --tcpip    # without arguments
-```
-
-It will automatically find the device IP address, enable TCP/IP mode, then
-connect to the device before starting.
-
-##### Manual
-
-Alternatively, it is possible to enable the TCP/IP connection manually using
-`adb`:
-
-1. 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
+1. Connect the device to the same Wi-Fi as your computer.
+2. Get your device IP address, in Settings → About phone → Status, or by
   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.
+3. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
+4. Unplug your device.
+5. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`)_.
+6. Run `scrcpy` as usual.

-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#connect-to-a-device-over-wi-fi-android-11+
-
-If the connection randomly drops, run your `scrcpy` command to reconnect. If it
-says there are no devices/emulators found, try running `adb connect
-DEVICE_IP:5555` again, and then `scrcpy` as usual. If it still says there are
-none found, try running `adb disconnect`, and then run those two commands again.
-
-It may be useful to decrease the bit-rate and the resolution:
+It may be useful to decrease the bit-rate and the definition:

 ```bash
 scrcpy --bit-rate 2M --max-size 800
@ -440,16 +281,13 @@ scrcpy -b2M -m800  # short version

 #### Multi-devices

-If several devices are listed in `adb devices`, you can specify the _serial_:
+If several devices are listed in `adb devices`, you must specify the _serial_:

 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # short version
 ```

-The serial may also be provided via the environment variable `ANDROID_SERIAL`
-(also used by `adb`).
-
 If the device is connected over TCP/IP:

 ```bash
@ -457,19 +295,6 @@ scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # short version
 ```

-If only one device is connected via either USB or TCP/IP, it is possible to
-select it automatically:
-
-```bash
-# Select the only device connected via USB
-scrcpy -d             # like adb -d
-scrcpy --select-usb   # long version
-
-# Select the only device connected via TCP/IP
-scrcpy -e             # like adb -e
-scrcpy --select-tcpip # long version
-```
-
 You can start several instances of _scrcpy_ for several devices.

 #### Autostart on device connection
@ -482,67 +307,21 @@ autoadb scrcpy -s '{}'

 [AutoAdb]: https://github.com/rom1v/autoadb

-#### Tunnels
+#### SSH tunnel

 To connect to a remote device, it is possible to connect a local `adb` client to
 a remote `adb` server (provided they use the same version of the _adb_
-protocol).
-
-##### Remote ADB server
-
-To connect to a remote _adb server_, make the server listen on all interfaces:
+protocol):

 ```bash
-adb kill-server
-adb -a nodaemon server start
+adb kill-server    # kill the local adb server on 5037
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # keep this open
 ```

-**Warning: all communications between clients and the _adb server_ are
-unencrypted.**
-
-Suppose that this server is accessible at 192.168.1.2. Then, from another
-terminal, run `scrcpy`:
+From another terminal:

 ```bash
-export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
-scrcpy --tunnel-host=192.168.1.2
-```
-
-By default, `scrcpy` uses the local port used for `adb forward` tunnel
-establishment (typically `27183`, see `--port`). It is also possible to force a
-different tunnel port (it may be useful in more complex situations, when more
-redirections are involved):
-
-```
-scrcpy --tunnel-port=1234
-```
-
-
-##### SSH tunnel
-
-To communicate with a remote _adb server_ securely, it is preferable to use an
-SSH tunnel.
-
-First, make sure the _adb server_ is running on the remote computer:
-
-```bash
-adb start-server
-```
-
-Then, establish an SSH tunnel:
-
-```bash
-# local  5038 --> remote  5037
-# local 27183 <-- remote 27183
-ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# keep this open
-```
-
-From another terminal, run `scrcpy`:
-
-```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```

@ -550,16 +329,14 @@ To avoid enabling remote port forwarding, you could force a forward connection
 instead (notice the `-L` instead of `-R`):

 ```bash
-# local  5038 --> remote  5037
-# local 27183 --> remote 27183
-ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
+adb kill-server    # kill the local adb server on 5037
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # keep this open
 ```

-From another terminal, run `scrcpy`:
+From another terminal:

 ```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```

@ -598,7 +375,7 @@ scrcpy --window-borderless

 #### Always on top

-To keep the _scrcpy_ window always on top:
+To keep the scrcpy window always on top:

 ```bash
 scrcpy --always-on-top
@ -623,7 +400,7 @@ The window may be rotated:
 scrcpy --rotation 1
 ```

-Possible values:
+Possibles values are:
 - `0`: no rotation
 - `1`: 90 degrees counterclockwise
 - `2`: 180 degrees
@ -634,7 +411,7 @@ _(left)_ and <kbd>MOD</kbd>+<kbd>→</kbd> _(right)_.

 Note that _scrcpy_ manages 3 different rotations:
 - <kbd>MOD</kbd>+<kbd>r</kbd> requests the device to switch between portrait
-   and landscape (the current running app may refuse, if it does not support the
+   and landscape (the current running app may refuse, if it does support the
   requested orientation).
 - [`--lock-video-orientation`](#lock-video-orientation) changes the mirroring
   orientation (the orientation of the video sent from the device to the
@ -667,24 +444,24 @@ scrcpy --display 1

 The list of display ids can be retrieved by:

-```bash
+```
 adb shell dumpsys display   # search "mDisplayId=" in the output
 ```

 The secondary display may only be controlled if the device runs at least Android
-10 (otherwise it is mirrored as read-only).
+10 (otherwise it is mirrored in read-only).


 #### Stay awake

-To prevent the device from sleeping after a delay when the device is plugged in:
+To prevent the device to sleep after some delay when the device is plugged in:

 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```

-The initial state is restored when _scrcpy_ is closed.
+The initial state is restored when scrcpy is closed.


 #### Turn screen off
@ -702,10 +479,9 @@ Or by pressing <kbd>MOD</kbd>+<kbd>o</kbd> at any time.
 To turn it back on, press <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.

 On Android, the `POWER` button always turns the screen on. For convenience, if
-`POWER` is sent via _scrcpy_ (via right-click or <kbd>MOD</kbd>+<kbd>p</kbd>),
-it will force to turn the screen off after a small delay (on a best effort
-basis).  The physical `POWER` button will still cause the screen to be turned
-on.
+`POWER` is sent via scrcpy (via right-click or <kbd>MOD</kbd>+<kbd>p</kbd>), it
+will force to turn the screen off after a small delay (on a best effort basis).
+The physical `POWER` button will still cause the screen to be turned on.

 It can also be useful to prevent the device from sleeping:

@ -714,25 +490,19 @@ scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```

-#### Power off on close

-To turn the device screen off when closing _scrcpy_:
+#### Render expired frames
+
+By default, to minimize latency, _scrcpy_ always renders the last decoded frame
+available, and drops any previous one.
+
+To force the rendering of all frames (at a cost of a possible increased
+latency), use:

 ```bash
-scrcpy --power-off-on-close
+scrcpy --render-expired-frames
 ```

-#### Power on on start
-
-By default, on start, the device is powered on.
-
-To prevent this behavior:
-
-```bash
-scrcpy --no-power-on
-```
-
-
 #### Show touches

 For presentations, it may be useful to show physical touches (on the physical
@ -748,13 +518,12 @@ scrcpy --show-touches
 scrcpy -t
 ```

-Note that it only shows _physical_ touches (by a finger on the device).
+Note that it only shows _physical_ touches (with the finger on the device).


 #### Disable screensaver

-By default, _scrcpy_ does not prevent the screensaver from running on the
-computer.
+By default, scrcpy does not prevent the screensaver to run on the computer.

 To disable it:

@ -796,144 +565,38 @@ To copy, cut and paste in such cases (but only supported on Android >= 7):
 - <kbd>MOD</kbd>+<kbd>v</kbd> injects `PASTE` (after computer-to-device
   clipboard synchronization)

-In addition, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> injects the computer
-clipboard text as a sequence of key events. This is useful when the component
-does not accept text pasting (for example in _Termux_), but it can break
-non-ASCII content.
+In addition, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> allows to inject the
+computer clipboard text as a sequence of key events. This is useful when the
+component does not accept text pasting (for example in _Termux_), but it can
+break non-ASCII content.

 **WARNING:** Pasting the computer clipboard to the device (either via
 <kbd>Ctrl</kbd>+<kbd>v</kbd> or <kbd>MOD</kbd>+<kbd>v</kbd>) copies the content
-into the Android clipboard. As a consequence, any Android application could read
-its content. You should avoid pasting sensitive content (like passwords) that
+into the device clipboard. As a consequence, any Android application could read
+its content. You should avoid to paste sensitive content (like passwords) that
 way.

-Some Android devices do not behave as expected when setting the device clipboard
+Some devices do not behave as expected when setting the device clipboard
 programmatically. An option `--legacy-paste` is provided to change the behavior
 of <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> so that they
 also inject the computer clipboard text as a sequence of key events (the same
 way as <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).

-To disable automatic clipboard synchronization, use
-`--no-clipboard-autosync`.
-
 #### Pinch-to-zoom

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

-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.
+More precisely, hold <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.

-Technically, _scrcpy_ generates additional touch events from a "virtual finger"
-at a location inverted through the center of the screen.
-
-#### Physical keyboard simulation (HID)
-
-By default, _scrcpy_ uses Android key or text injection: it works everywhere,
-but is limited to ASCII.
-
-Alternatively, `scrcpy` can simulate a physical USB keyboard on Android to
-provide a better input experience (using [USB HID over AOAv2][hid-aoav2]): the
-virtual keyboard is disabled and it works for all characters and IME.
-
-[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
-
-However, it only works if the device is connected via USB.
-
-Note: On Windows, it may only work in [OTG mode](#otg), not while mirroring (it
-is not possible to open a USB device if it is already open by another process
-like the _adb daemon_).
-
-To enable this mode:
-
-```bash
-scrcpy --hid-keyboard
-scrcpy -K  # short version
-```
-
-If it fails for some reason (for example because the device is not connected via
-USB), it automatically fallbacks to the default mode (with a log in the
-console). This allows using the same command line options when connected over
-USB and TCP/IP.
-
-In this mode, raw key events (scancodes) are sent to the device, independently
-of the host key mapping. Therefore, if your keyboard layout does not match, it
-must be configured on the Android device, in Settings → System → Languages and
-input → [Physical keyboard].
-
-This settings page can be started directly:
-
-```bash
-adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
-```
-
-However, the option is only available when the HID keyboard is enabled (or when
-a physical keyboard is connected).
-
-[Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
-
-#### Physical mouse simulation (HID)
-
-Similarly to the physical keyboard simulation, it is possible to simulate a
-physical mouse. Likewise, it only works if the device is connected by USB.
-
-By default, _scrcpy_ uses Android mouse events injection with absolute
-coordinates. By simulating a physical mouse, a mouse pointer appears on the
-Android device, and relative mouse motion, clicks and scrolls are injected.
-
-To enable this mode:
-
-```bash
-scrcpy --hid-mouse
-scrcpy -M  # short version
-```
-
-You can also add `--forward-all-clicks` to [forward all mouse
-buttons][forward_all_clicks].
-
-[forward_all_clicks]: #right-click-and-middle-click
-
-When this mode is enabled, the computer mouse is "captured" (the mouse pointer
-disappears from the computer and appears on the Android device instead).
-
-Special capture keys, either <kbd>Alt</kbd> or <kbd>Super</kbd>, toggle
-(disable or enable) the mouse capture. Use one of them to give the control of
-the mouse back to the computer.
-
-
-#### OTG
-
-It is possible to run _scrcpy_ with only physical keyboard and mouse simulation
-(HID), as if the computer keyboard and mouse were plugged directly to the device
-via an OTG cable.
-
-In this mode, `adb` (USB debugging) is not necessary, and mirroring is disabled.
-
-To enable OTG mode:
-
-```bash
-scrcpy --otg
-# Pass the serial if several USB devices are available
-scrcpy --otg -s 0123456789abcdef
-```
-
-It is possible to enable only HID keyboard or HID mouse:
-
-```bash
-scrcpy --otg --hid-keyboard              # keyboard only
-scrcpy --otg --hid-mouse                 # mouse only
-scrcpy --otg --hid-keyboard --hid-mouse  # keyboard and mouse
-# for convenience, enable both by default
-scrcpy --otg                             # keyboard and mouse
-```
-
-Like `--hid-keyboard` and `--hid-mouse`, it only works if the device is
-connected by USB.
+Concretely, scrcpy generates additional touch events from a "virtual finger" at
+a location inverted through the center of the screen.


 #### Text injection preference

-Two kinds of [events][textevents] are generated when typing text:
+There are two kinds of [events][textevents] generated when typing text:
 - _key events_, signaling that a key is pressed or released;
 - _text events_, signaling that a text has been entered.

@ -949,15 +612,6 @@ scrcpy --prefer-text

 (but this will break keyboard behavior in games)

-On the contrary, you could force to always inject raw key events:
-
-```bash
-scrcpy --raw-key-events
-```
-
-These options have no effect on HID keyboard (all key events are sent as
-scancodes in this mode).
-
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343

@ -973,9 +627,6 @@ To avoid forwarding repeated key events:
 scrcpy --no-key-repeat
 ```

-This option has no effect on HID keyboard (key repeat is handled by Android
-directly in this mode).
-

 #### Right-click and middle-click

@ -999,15 +650,15 @@ There is no visual feedback, a log is printed to the console.

 #### Push file to device

-To push a file to `/sdcard/Download/` on the device, drag & drop a (non-APK)
-file to the _scrcpy_ window.
+To push a file to `/sdcard/` on the device, drag & drop a (non-APK) file to the
+_scrcpy_ window.

 There is no visual feedback, a log is printed to the console.

 The target directory can be changed on start:

 ```bash
-scrcpy --push-target=/sdcard/Movies/
+scrcpy --push-target /sdcard/foo/bar/
 ```


@ -1047,11 +698,11 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
 | Rotate display left                         | <kbd>MOD</kbd>+<kbd>←</kbd> _(left)_
 | Rotate display right                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(right)_
 | Resize window to 1:1 (pixel-perfect)        | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Resize window to remove black borders       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Double-left-click¹_
+ | Resize window to remove black borders       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Double-click¹_
 | Click on `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Middle-click_
 | Click on `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Right-click²_
- | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4th-click³_
- | Click on `MENU` (unlock screen)⁴            | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd>
+ | Click on `MENU` (unlock screen)             | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Click on `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(up)_
 | Click on `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(down)_
 | Click on `POWER`                            | <kbd>MOD</kbd>+<kbd>p</kbd>
@ -1059,30 +710,18 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
 | Turn device screen off (keep mirroring)     | <kbd>MOD</kbd>+<kbd>o</kbd>
 | Turn device screen on                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Rotate device screen                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5th-click³_
- | Expand settings panel                       | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Double-5th-click³_
- | Collapse panels                             | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copy to clipboard⁵                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Cut to clipboard⁵                           | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Synchronize clipboards and paste⁵           | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd>
+ | Collapse notification panel                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copy to clipboard³                          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Cut to clipboard³                           | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Synchronize clipboards and paste³           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Inject computer clipboard text              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Enable/disable FPS counter (on stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
 | Pinch-to-zoom                               | <kbd>Ctrl</kbd>+_click-and-move_
- | Drag & drop APK file                        | Install APK from computer
- | Drag & drop non-APK file                    | [Push file to device](#push-file-to-device)

 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._  
-_³4th and 5th mouse buttons, if your mouse has them._  
-_⁴For react-native apps in development, `MENU` triggers development menu._  
-_⁵Only on Android >= 7._
-
-Shortcuts with repeated keys are executed by releasing and pressing the key a
-second time. For example, to execute "Expand settings panel":
-
- 1. Press and keep pressing <kbd>MOD</kbd>.
- 2. Then double-press <kbd>n</kbd>.
- 3. Finally, release <kbd>MOD</kbd>.
+_³Only on Android >= 7._

 All <kbd>Ctrl</kbd>+_key_ shortcuts are forwarded to the device, so they are
 handled by the active application.
@ -1090,20 +729,18 @@ handled by the active application.

 ## Custom paths

-To use a specific `adb` binary, configure its path in the environment variable
+To use a specific _adb_ binary, configure its path in the environment variable
 `ADB`:

-```bash
-ADB=/path/to/adb scrcpy
-```
+    ADB=/path/to/adb scrcpy

 To override the path of the `scrcpy-server` file, configure its path in
 `SCRCPY_SERVER_PATH`.

-To override the icon, configure its path in `SCRCPY_ICON_PATH`.
+[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345


-## Why the name _scrcpy_?
+## Why _scrcpy_?

 A colleague challenged me to find a name as unpronounceable as [gnirehtet].

@ -1117,12 +754,12 @@ A colleague challenged me to find a name as unpronounceable as [gnirehtet].

 See [BUILD].

+[BUILD]: BUILD.md
+

 ## Common issues

-See the [FAQ].
-
-[FAQ]: FAQ.md
+See the [FAQ](FAQ.md).


 ## Developers
@ -1135,7 +772,7 @@ Read the [developers page].
 ## Licence

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@ -1157,30 +794,14 @@ Read the [developers page].
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/

-## Contact
-
-If you encounter a bug, please read the [FAQ] first, then open an [issue].
-
-[issue]: https://github.com/Genymobile/scrcpy/issues
-
-For general questions or discussions, you can also use:
-
- - Reddit: [`r/scrcpy`](https://www.reddit.com/r/scrcpy)
- - Twitter: [`@scrcpy_app`](https://twitter.com/scrcpy_app)
-
 ## Translations

 This README is available in other languages:

- [Deutsch (German, `de`) - v1.22](README.de.md)
 - [Indonesian (Indonesia, `id`) - v1.16](README.id.md)
- [Italiano (Italiano, `it`) - v1.23](README.it.md)
- [日本語 (Japanese, `jp`) - v1.19](README.jp.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
- [Português Brasileiro (Brazilian Portuguese, `pt-BR`) - v1.19](README.pt-br.md)
- [Español (Spanish, `sp`) - v1.21](README.sp.md)
- [简体中文 (Simplified Chinese, `zh-Hans`) - v1.22](README.zh-Hans.md)
+- [português brasileiro (Brazilian Portuguese, `pt-BR`) - v1.12.1](README.pt-br.md)
+- [简体中文 (Simplified Chinese, `zh-Hans`) - v1.16](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
- [Turkish (Turkish, `tr`) - v1.18](README.tr.md)

 Only this README file is guaranteed to be up-to-date.
--- a/README.pt-br.md
+++ b/README.pt-br.md
@ -1,16 +1,16 @@
-_Apenas o [README](README.md) original é garantido estar atualizado._
+_Only the original [README](README.md) is guaranteed to be up-to-date._

-# scrcpy (v1.19)
+# scrcpy (v1.12.1)

-Esta aplicação fornece exibição e controle de dispositivos Android conectados via
-USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso _root_.
+Esta aplicação fornece visualização e controle de dispositivos Android conectados via
+USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso root.
 Funciona em _GNU/Linux_, _Windows_ e _macOS_.

 ![screenshot](assets/screenshot-debian-600.jpg)

 Foco em:

- - **leveza** (nativo, mostra apenas a tela do dispositivo)
+ - **leveza** (Nativo, mostra apenas a tela do dispositivo)
 - **performance** (30~60fps)
 - **qualidade** (1920×1080 ou acima)
 - **baixa latência** ([35~70ms][lowlatency])
@ -22,53 +22,36 @@ Foco em:

 ## Requisitos

-O dispositivo Android requer pelo menos a API 21 (Android 5.0).
+O Dispositivo Android requer pelo menos a API 21 (Android 5.0).

-Tenha certeza de ter [ativado a depuração adb][enable-adb] no(s) seu(s) dispositivo(s).
+
+Tenha certeza de ter [ativado a depuração USB][enable-adb] no(s) seu(s) dispositivo(s).

 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling

-Em alguns dispositivos, você também precisa ativar [uma opção adicional][control] para
-controlá-lo usando teclado e mouse.
+
+Em alguns dispositivos, você também precisará ativar [uma opção adicional][control] para controlá-lo usando o teclado e mouse.

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


-## Obter o app
-
-<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
-
-### Sumário
-
- - Linux: `apt install scrcpy`
- - Windows: [baixar][direct-win64]
- - macOS: `brew install scrcpy`
-
-  Compilar pelos arquivos fontes: [BUILD] ([processo simplificado][BUILD_simple])
-
-[BUILD]: BUILD.md
-[BUILD_simple]: BUILD.md#simple
+## Obtendo o app


 ### Linux

-No Debian (_testing_ e _sid_ por enquanto) e Ubuntu (20.04):
+No Debian (_em testes_ e _sid_ por enquanto):

 ```
 apt install scrcpy
 ```

-Um pacote [Snap] está disponível: [`scrcpy`][snap-link].
+O pacote [Snap] está disponível: [`scrcpy`][snap-link].

 [snap-link]: https://snapstats.org/snaps/scrcpy

 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)

-Para Fedora, um pacote [COPR] está disponível: [`scrcpy`][copr-link].
-
-[COPR]: https://fedoraproject.org/wiki/Category:Copr
-[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
-
 Para Arch Linux, um pacote [AUR] está disponível: [`scrcpy`][aur-link].

 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
@ -79,17 +62,21 @@ Para Gentoo, uma [Ebuild] está disponível: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy

-Você também pode [compilar o app manualmente][BUILD] ([processo simplificado][BUILD_simple]).
+
+Você também pode [compilar a aplicação manualmente][BUILD] (não se preocupe, não é tão difícil).


 ### Windows

-Para Windows, por simplicidade, um arquivo pré-compilado com todas as dependências
+Para Windows, para simplicidade, um arquivo pré-compilado com todas as dependências
 (incluindo `adb`) está disponível:

- - [README](README.md#windows)
+ - [`scrcpy-win64-v1.12.1.zip`][direct-win64]  
+   _(SHA-256: 57d34b6d16cfd9fe169bc37c4df58ebd256d05c1ea3febc63d9cb0a027ab47c9)_

-Também está disponível em [Chocolatey]:
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win64-v1.12.1.zip
+
+Também disponível em [Chocolatey]:

 [Chocolatey]: https://chocolatey.org/

@ -107,12 +94,12 @@ scoop install adb    # se você ainda não o tem

 [Scoop]: https://scoop.sh

-Você também pode [compilar o app manualmente][BUILD].
+Você também pode [compilar a aplicação manualmente][BUILD].


 ### macOS

-A aplicação está disponível em [Homebrew]. Apenas instale-a:
+A aplicação está disponível em [Homebrew]. Apenas a instale:

 [Homebrew]: https://brew.sh/

@ -120,27 +107,18 @@ A aplicação está disponível em [Homebrew]. Apenas instale-a:
 brew install scrcpy
 ```

-Você precisa do `adb`, acessível pelo seu `PATH`. Se você ainda não o tem:
+Você precisa do `adb`, acessível através do seu `PATH`. Se você ainda não o tem:

 ```bash
-brew install android-platform-tools
+brew cask install android-platform-tools
 ```

-Está também disponivel em [MacPorts], que prepara o adb para você:
-
-```bash
-sudo port install scrcpy
-```
-
-[MacPorts]: https://www.macports.org/
-
-
-Você também pode [compilar o app manualmente][BUILD].
+Você também pode [compilar a aplicação manualmente][BUILD].


 ## Executar

-Conecte um dispositivo Android e execute:
+Plugue um dispositivo Android e execute:

 ```bash
 scrcpy
@ -156,91 +134,53 @@ scrcpy --help

 ### Configuração de captura

-#### Reduzir tamanho
+#### Redução de tamanho

 Algumas vezes, é útil espelhar um dispositivo Android em uma resolução menor para
-aumentar a performance.
+aumentar performance.

-Para limitar ambos (largura e altura) para algum valor (ex: 1024):
+Para limitar ambos(largura e altura) para algum valor (ex: 1024):

 ```bash
 scrcpy --max-size 1024
-scrcpy -m 1024  # versão curta
+scrcpy -m 1024  # versão reduzida
 ```

 A outra dimensão é calculada para que a proporção do dispositivo seja preservada.
-Dessa forma, um dispositivo de 1920x1080 será espelhado em 1024x576.
+Dessa forma, um dispositivo em 1920x1080 será espelhado em 1024x576.


-#### Mudar bit-rate
+#### Mudanças no bit-rate

-O bit-rate padrão é 8 Mbps. Para mudar o bit-rate do vídeo (ex: para 2 Mbps):
+O Padrão de bit-rate é 8 mbps. Para mudar o bitrate do vídeo (ex: para 2 Mbps):

 ```bash
 scrcpy --bit-rate 2M
-scrcpy -b 2M  # versão curta
+scrcpy -b 2M  # versão reduzida
 ```

-#### Limitar frame rate
+#### Limitar frame rates

-O frame rate de captura pode ser limitado:
+Em dispositivos com Android >= 10, a captura de frame rate pode ser limitada:

 ```bash
 scrcpy --max-fps 15
 ```

-Isso é oficialmente suportado desde o Android 10, mas pode funcionar em versões anteriores.
-
 #### Cortar

 A tela do dispositivo pode ser cortada para espelhar apenas uma parte da tela.

-Isso é útil por exemplo, para espelhar apenas um olho do Oculus Go:
+Isso é útil por exemplo, ao espelhar apenas um olho do Oculus Go:

 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 no deslocamento (0,0)
 ```

-Se `--max-size` também for especificado, o redimensionamento é aplicado após o corte.
+Se `--max-size` também for especificado, redimensionar é aplicado após os cortes.


-#### Travar orientação do vídeo
-
-
-Para travar a orientação do espelhamento:
-
-```bash
-scrcpy --lock-video-orientation     # orientação inicial (Atual)
-scrcpy --lock-video-orientation=0   # orientação natural
-scrcpy --lock-video-orientation=1   # 90° sentido anti-horário
-scrcpy --lock-video-orientation=2   # 180°
-scrcpy --lock-video-orientation=3   # 90° sentido horário
-```
-
-Isso afeta a orientação de gravação.
-
-A [janela também pode ser rotacionada](#rotação) independentemente.
-
-
-#### Encoder
-
-Alguns dispositivos têm mais de um encoder, e alguns deles podem causar problemas ou
-travar. É possível selecionar um encoder diferente:
-
-```bash
-scrcpy --encoder OMX.qcom.video.encoder.avc
-```
-
-Para listar os encoders disponíveis, você pode passar um nome de encoder inválido, o
-erro dará os encoders disponíveis:
-
-```bash
-scrcpy --encoder _
-```
-
-### Captura
-
-#### Gravando
+### Gravando

 É possível gravar a tela enquanto ocorre o espelhamento:

@ -254,157 +194,65 @@ Para desativar o espelhamento durante a gravação:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
-# interrompa a gravação com Ctrl+C
+# interrompe a gravação com Ctrl+C
+# Ctrl+C não encerrar propriamente no Windows, então desconecte o dispositivo
 ```

-"Frames pulados" são gravados, mesmo que não sejam exibidos em tempo real (por
-motivos de performance). Frames têm seu _horário carimbado_ no dispositivo, então [variação de atraso nos
-pacotes][packet delay variation] não impacta o arquivo gravado.
+"Frames pulados" são gravados, mesmo que não sejam mostrado em tempo real (por motivos de performance).
+Frames tem seu _horário_ _carimbado_ no dispositivo, então [Variação de atraso nos pacotes] não impacta na gravação do arquivo.

-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
+[Variação de atraso de pacote]: https://en.wikipedia.org/wiki/Packet_delay_variation


-#### v4l2loopback
-
-Em Linux, é possível enviar a transmissão do video para um disposiivo v4l2 loopback, assim
-o dispositivo Android pode ser aberto como uma webcam por qualquer ferramneta capaz de v4l2
-
-The module `v4l2loopback` must be installed:
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-Para criar um dispositivo v4l2:
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-Isso criara um novo dispositivo de vídeo em `/dev/videoN`, onde `N` é uma integer
-(mais [opções](https://github.com/umlaeute/v4l2loopback#options) estão disponiveis
-para criar varios dispositivos ou dispositivos com IDs específicas).
-
-Para listar os dispositivos disponíveis:
-
-```bash
-# requer o pacote v4l-utils
-v4l2-ctl --list-devices
-
-# simples, mas pode ser suficiente
-ls /dev/video*
-```
-
-Para iniciar o scrcpy usando o coletor v4l2 (sink):
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # desativa a janela espelhada
-scrcpy --v4l2-sink=/dev/videoN -N            # versão curta
-```
-
-(troque `N` pelo ID do dipositivo, verifique com `ls /dev/video*`)
-
-Uma vez ativado, você pode abrir suas trasmissões de videos com uma ferramenta capaz de v4l2:
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLC pode adicionar um pouco de atraso de buffering
-```
-
-Por exemplo, você pode capturar o video dentro do [OBS].
-
-[OBS]: https://obsproject.com/
-
-
-#### Buffering
-
-É possivel adicionar buffering. Isso aumenta a latência, mas reduz a tenção (jitter) (veja
-[#2464]).
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-A opção éta disponivel para buffering de exibição:
-
-```bash
-scrcpy --display-buffer=50  # adiciona 50 ms de buffering para a exibição
-```
-
-e coletor V4L2:
-
-```bash
-scrcpy --v4l2-buffer=500    # adiciona 500 ms de buffering para coletor V4L2
-```
-
-,
 ### Conexão

-#### Sem fio
+#### Wireless/Sem fio

-_Scrcpy_ usa `adb` para se comunicar com o dispositivo, e `adb` pode [conectar-se][connect] a um
-dispositivo via TCP/IP:
-
-1. Conecte o dispositivo no mesmo Wi-Fi do seu computador.
-2. Pegue o endereço IP do seu dispositivo, em Configurações → Sobre o telefone → Status, ou
-   executando este comando:
-
-    ```bash
-    adb shell ip route | awk '{print $9}'
-    ```
+_Scrcpy_ usa `adb` para se comunicar com o dispositivo, e `adb` pode [conectar-se] à um dispositivo via TCP/IP:

+1. Conecte o dispositivo a mesma rede Wi-Fi do seu computador.
+2. Pegue o endereço de IP do seu dispositivo (Em Configurações → Sobre o Telefone → Status).
 3. Ative o adb via TCP/IP no seu dispositivo: `adb tcpip 5555`.
-4. Desconecte seu dispositivo.
-5. Conecte-se ao seu dispositivo: `adb connect DEVICE_IP:5555` _(substitua `DEVICE_IP`)_.
+4. Desplugue seu dispositivo.
+5. Conecte-se ao seu dispositivo: `adb connect DEVICE_IP:5555` _(substitua o `DEVICE_IP`)_.
 6. Execute `scrcpy` como de costume.

 Pode ser útil diminuir o bit-rate e a resolução:

 ```bash
 scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # versão curta
+scrcpy -b2M -m800  # versão reduzida
 ```

-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
+[conectar-se]: https://developer.android.com/studio/command-line/adb.html#wireless


-#### Múltiplos dispositivos
+#### N-dispositivos

-Se vários dispositivos são listados em `adb devices`, você deve especificar o _serial_:
+Se alguns dispositivos estão listados em `adb devices`, você precisa especificar o _serial_:

 ```bash
 scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # versão curta
+scrcpy -s 0123456789abcdef  # versão reduzida
 ```

 Se o dispositivo está conectado via TCP/IP:

 ```bash
 scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # versão curta
+scrcpy -s 192.168.0.1:5555  # versão reduzida
 ```

-Você pode iniciar várias instâncias do _scrcpy_ para vários dispositivos.
+Você pode iniciar algumas instâncias do _scrcpy_ para alguns dispositivos.

-#### Iniciar automaticamente quando dispositivo é conectado
+#### Conexão via SSH

-Você pode usar [AutoAdb]:
+Para conectar-se à um dispositivo remoto, é possível se conectar um cliente local `adb`  à um servidor `adb` remoto (contanto que eles usem a mesma versão do protocolo _adb_):

 ```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
-
-#### Túnel SSH
-
-Para conectar-se a um dispositivo remoto, é possível conectar um cliente `adb` local a
-um servidor `adb` remoto (contanto que eles usem a mesma versão do protocolo
-_adb_):
-
-```bash
-adb kill-server    # encerra o servidor adb local em 5037
+adb kill-server    # encerra o servidor local na 5037
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# mantenha isso aberto
+# mantém isso aberto
 ```

 De outro terminal:
@ -413,33 +261,17 @@ De outro terminal:
 scrcpy
 ```

-Para evitar ativar o encaminhamento de porta remota, você pode forçar uma conexão
-de encaminhamento (note o `-L` em vez de `-R`):
-
-```bash
-adb kill-server    # encerra o servidor adb local em 5037
-ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
-# mantenha isso aberto
-```
-
-De outro terminal:
-
-```bash
-scrcpy --force-adb-forward
-```
-
-
-Igual a conexões sem fio, pode ser útil reduzir a qualidade:
+Igual para conexões sem fio, pode ser útil reduzir a qualidade:

 ```
 scrcpy -b2M -m800 --max-fps 15
 ```

-### Configuração de janela
+### Configurações de Janela

 #### Título

-Por padrão, o título da janela é o modelo do dispositivo. Isso pode ser mudado:
+Por padrão, o título da janela é o modelo do dispositivo. Isto pode ser mudado:

 ```bash
 scrcpy --window-title 'Meu dispositivo'
@ -455,15 +287,15 @@ scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600

 #### Sem bordas

-Para desativar decorações de janela:
+Para desativar decorações da janela:

 ```bash
 scrcpy --window-borderless
 ```

-#### Sempre no topo
+#### Sempre visível

-Para manter a janela do scrcpy sempre no topo:
+Para manter a janela do scrcpy sempre visível:

 ```bash
 scrcpy --always-on-top
@ -475,119 +307,53 @@ A aplicação pode ser iniciada diretamente em tela cheia:

 ```bash
 scrcpy --fullscreen
-scrcpy -f  # versão curta
+scrcpy -f  # versão reduzida
 ```

-Tela cheia pode ser alternada dinamicamente com <kbd>MOD</kbd>+<kbd>f</kbd>.
-
-#### Rotação
-
-A janela pode ser rotacionada:
-
-```bash
-scrcpy --rotation 1
-```
-
-Valores possíveis são:
- - `0`: sem rotação
- - `1`: 90 graus sentido anti-horário
- - `2`: 180 graus
- - `3`: 90 graus sentido horário
-
-A rotação também pode ser mudada dinamicamente com <kbd>MOD</kbd>+<kbd>←</kbd>
-_(esquerda)_ e <kbd>MOD</kbd>+<kbd>→</kbd> _(direita)_.
-
-Note que _scrcpy_ controla 3 rotações diferentes:
- - <kbd>MOD</kbd>+<kbd>r</kbd> requisita ao dispositivo para mudar entre retrato
-   e paisagem (a aplicação em execução pode se recusar, se ela não suporta a
-   orientação requisitada).
- - [`--lock-video-orientation`](#travar-orientação-do-vídeo) muda a orientação de
-   espelhamento (a orientação do vídeo enviado pelo dispositivo para o
-   computador). Isso afeta a gravação.
- - `--rotation` (ou <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
-   rotaciona apenas o conteúdo da janela. Isso afeta apenas a exibição, não a
-   gravação.
+Tela cheia pode ser alternada dinamicamente com `Ctrl`+`f`.


 ### Outras opções de espelhamento

 #### Apenas leitura

-Para desativar controles (tudo que possa interagir com o dispositivo: teclas de entrada,
-eventos de mouse, arrastar e soltar arquivos):
+Para desativar controles (tudo que possa interagir com o dispositivo: teclas de entrada, eventos de mouse, arrastar e soltar arquivos):

 ```bash
 scrcpy --no-control
 scrcpy -n
 ```

-#### Display
+#### Desligar a tela

-Se vários displays estão disponíveis, é possível selecionar o display para
-espelhar:
-
-```bash
-scrcpy --display 1
-```
-
-A lista de IDs dos displays pode ser obtida por:
-
-```
-adb shell dumpsys display   # busca "mDisplayId=" na saída
-```
-
-O display secundário pode apenas ser controlado se o dispositivo roda pelo menos Android
-10 (caso contrário é espelhado como apenas leitura).
-
-
-#### Permanecer ativo
-
-Para evitar que o dispositivo seja suspenso após um delay quando o dispositivo é conectado:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w
-```
-
-O estado inicial é restaurado quando o scrcpy é fechado.
-
-
-#### Desligar tela
-
-É possível desligar a tela do dispositivo durante o início do espelhamento com uma
-opção de linha de comando:
+É possível desligar a tela do dispositivo durante o início do espelhamento com uma opção de linha de comando:

 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```

-Ou apertando <kbd>MOD</kbd>+<kbd>o</kbd> a qualquer momento.
+Ou apertando `Ctrl`+`o` durante qualquer momento.

-Para ligar novamente, pressione <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
+Para ligar novamente, pressione `POWER` (ou `Ctrl`+`p`).

-No Android, o botão de `POWER` sempre liga a tela. Por conveniência, se
-`POWER` é enviado via scrcpy (via clique-direito ou <kbd>MOD</kbd>+<kbd>p</kbd>), ele
-forçará a desligar a tela após um delay pequeno (numa base de melhor esforço).
-O botão `POWER` físico ainda causará a tela ser ligada.
+#### Frames expirados de renderização

-Também pode ser útil evitar que o dispositivo seja suspenso:
+Por padrão, para minimizar a latência, _scrcpy_ sempre renderiza o último frame decodificado disponível e descarta o anterior.
+
+Para forçar a renderização de todos os frames ( com o custo de aumento de latência), use:

 ```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw
+scrcpy --render-expired-frames
 ```

-
 #### Mostrar toques

-Para apresentações, pode ser útil mostrar toques físicos (no dispositivo
-físico).
+Para apresentações, pode ser útil mostrar toques físicos(dispositivo físico).

-Android fornece esta funcionalidade nas _Opções do desenvolvedor_.
+Android fornece esta funcionalidade nas _Opções do Desenvolvedor_.

-_Scrcpy_ fornece esta opção de ativar esta funcionalidade no início e restaurar o
-valor inicial no encerramento:
+_Scrcpy_ fornece esta opção de ativar esta funcionalidade no início e desativar no encerramento:

 ```bash
 scrcpy --show-touches
@ -597,137 +363,59 @@ scrcpy -t
 Note que isto mostra apenas toques _físicos_ (com o dedo no dispositivo).


-#### Desativar descanso de tela
-
-Por padrão, scrcpy não evita que o descanso de tela rode no computador.
-
-Para desativá-lo:
-
-```bash
-scrcpy --disable-screensaver
-```
-
-
 ### Controle de entrada

 #### Rotacionar a tela do dispositivo

-Pressione <kbd>MOD</kbd>+<kbd>r</kbd> para mudar entre os modos retrato e
-paisagem.
+Pressione `Ctrl`+`r` para mudar entre os modos Retrato e Paisagem.

-Note que só será rotacionado se a aplicação em primeiro plano suportar a
-orientação requisitada.
+Note que só será rotacionado se a aplicação em primeiro plano tiver suporte para o modo requisitado.

-#### Copiar-colar
+#### Copiar-Colar

-Sempre que a área de transferência do Android muda, é automaticamente sincronizada com a
-área de transferência do computador.
+É possível sincronizar áreas de transferência entre computador e o dispositivo,
+para ambas direções:

-Qualquer atalho com <kbd>Ctrl</kbd> é encaminhado para o dispositivo. Em particular:
- - <kbd>Ctrl</kbd>+<kbd>c</kbd> tipicamente copia
- - <kbd>Ctrl</kbd>+<kbd>x</kbd> tipicamente recorta
- - <kbd>Ctrl</kbd>+<kbd>v</kbd> tipicamente cola (após a sincronização de área de transferência
-   computador-para-dispositivo)
+ - `Ctrl`+`c` copia a área de transferência do dispositivo para a área de trasferência do computador;
+ - `Ctrl`+`Shift`+`v` copia a área de transferência do computador para a área de transferência do dispositivo;
+ - `Ctrl`+`v` _cola_ a área de transferência do computador como uma sequência de eventos de texto (mas
+   quebra caracteres não-ASCII).

-Isso tipicamente funciona como esperado.
+#### Preferências de injeção de texto

-O comportamento de fato depende da aplicação ativa, no entanto. Por exemplo,
-_Termux_ envia SIGINT com <kbd>Ctrl</kbd>+<kbd>c</kbd>, e _K-9 Mail_
-compõe uma nova mensagem.
-
-Para copiar, recortar e colar em tais casos (mas apenas suportado no Android >= 7):
- - <kbd>MOD</kbd>+<kbd>c</kbd> injeta `COPY`
- - <kbd>MOD</kbd>+<kbd>x</kbd> injeta `CUT`
- - <kbd>MOD</kbd>+<kbd>v</kbd> injeta `PASTE` (após a sincronização de área de transferência
-   computador-para-dispositivo)
-
-Em adição, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permite injetar o
-texto da área de transferência do computador como uma sequência de eventos de tecla. Isso é útil quando o
-componente não aceita colar texto (por exemplo no _Termux_), mas pode
-quebrar conteúdo não-ASCII.
-
-**ADVERTÊNCIA:** Colar a área de transferência do computador para o dispositivo (tanto via
-<kbd>Ctrl</kbd>+<kbd>v</kbd> quanto <kbd>MOD</kbd>+<kbd>v</kbd>) copia o conteúdo
-para a área de transferência do dispositivo. Como consequência, qualquer aplicação Android pode ler
-o seu conteúdo. Você deve evitar colar conteúdo sensível (como senhas) dessa
-forma.
-
-Alguns dispositivos não se comportam como esperado quando a área de transferência é definida
-programaticamente. Uma opção `--legacy-paste` é fornecida para mudar o comportamento
-de <kbd>Ctrl</kbd>+<kbd>v</kbd> e <kbd>MOD</kbd>+<kbd>v</kbd> para que eles
-também injetem o texto da área de transferência do computador como uma sequência de eventos de tecla (da mesma
-forma que <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
-
-#### Pinçar para dar zoom
-
-Para simular "pinçar para dar zoom": <kbd>Ctrl</kbd>+_clicar-e-mover_.
-
-Mais precisamente, segure <kbd>Ctrl</kbd> enquanto pressiona o botão de clique-esquerdo. Até que
-o botão de clique-esquerdo seja liberado, todos os movimentos do mouse ampliar e rotacionam o
-conteúdo (se suportado pelo app) relativo ao centro da tela.
-
-Concretamente, scrcpy gera eventos adicionais de toque de um "dedo virtual" em
-uma posição invertida em relação ao centro da tela.
-
-
-#### Preferência de injeção de texto
-
-Existem dois tipos de [eventos][textevents] gerados ao digitar um texto:
- - _eventos de tecla_, sinalizando que a tecla foi pressionada ou solta;
+Existe dois tipos de [eventos][textevents] gerados ao digitar um texto:
+ - _eventos de teclas_, sinalizando que a tecla foi pressionada ou solta;
 - _eventos de texto_, sinalizando que o texto foi inserido.

-Por padrão, letras são injetadas usando eventos de tecla, assim o teclado comporta-se
-como esperado em jogos (normalmente para teclas WASD).
+Por padrão, letras são injetadas usando eventos de teclas, assim teclados comportam-se
+como esperado em jogos (normalmente para tecladas WASD)

-Mas isso pode [causar problemas][prefertext]. Se você encontrar tal problema, você
-pode evitá-lo com:
+Mas isto pode [causar problemas][prefertext]. Se você encontrar tal problema,
+pode evitá-lo usando:

 ```bash
 scrcpy --prefer-text
 ```

-(mas isso vai quebrar o comportamento do teclado em jogos)
+(mas isto vai quebrar o comportamento do teclado em jogos)

 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343


-#### Repetir tecla
-
-Por padrão, segurar uma tecla gera eventos de tecla repetidos. Isso pode causar
-problemas de performance em alguns jogos, onde esses eventos são inúteis de qualquer forma.
-
-Para evitar o encaminhamento eventos de tecla repetidos:
-
-```bash
-scrcpy --no-key-repeat
-```
-
-
-#### Clique-direito e clique-do-meio
-
-Por padrão, clique-direito dispara BACK (ou POWER) e clique-do-meio dispara
-HOME. Para desabilitar esses atalhos e encaminhar os cliques para o dispositivo:
-
-```bash
-scrcpy --forward-all-clicks
-```
-
-
-### Soltar arquivo
+### Transferência de arquivo

 #### Instalar APK

-Para instalar um APK, arraste e solte o arquivo APK (com extensão `.apk`) na janela
-_scrcpy_.
+Para instalar um APK, arraste e solte o arquivo APK(com extensão `.apk`) na janela _scrcpy_.

 Não existe feedback visual, um log é imprimido no console.


-#### Enviar arquivo para dispositivo
+#### Enviar arquivo para o dispositivo

-Para enviar um arquivo para `/sdcard/Download/` no dispositivo, arraste e solte um arquivo (não-APK) para a
-janela do _scrcpy_.
+Para enviar um arquivo para o diretório `/sdcard/` no dispositivo, arraste e solte um arquivo não APK para a janela do
+_scrcpy_.

 Não existe feedback visual, um log é imprimido no console.

@ -740,86 +428,47 @@ scrcpy --push-target /sdcard/foo/bar/

 ### Encaminhamento de áudio

-Áudio não é encaminhado pelo _scrcpy_. Use [sndcpy].
+Áudio não é encaminhando pelo _scrcpy_. Use [USBaudio] (Apenas linux).

 Também veja [issue #14].

-[sndcpy]: https://github.com/rom1v/sndcpy
+[USBaudio]: https://github.com/rom1v/usbaudio
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14


 ## Atalhos

-Na lista a seguir, <kbd>MOD</kbd> é o modificador de atalho. Por padrão, é
-<kbd>Alt</kbd> (esquerdo) ou <kbd>Super</kbd> (esquerdo).
+ | Ação                                                          |   Atalho                        |   Atalho (macOS)
+ | ------------------------------------------------------------- |:------------------------------- |:-----------------------------
+ | Alternar para modo de tela cheia                              | `Ctrl`+`f`                      | `Cmd`+`f`
+ | Redimensionar janela para pixel-perfect(Escala 1:1)           | `Ctrl`+`g`                      | `Cmd`+`g`
+ | Redimensionar janela para tirar as bordas pretas              | `Ctrl`+`x` \| _Clique-duplo¹_   | `Cmd`+`x`  \| _Clique-duplo¹_
+ | Clicar em `HOME`                                              | `Ctrl`+`h` \| _Clique-central_  | `Ctrl`+`h` \| _Clique-central_
+ | Clicar em `BACK`                                              | `Ctrl`+`b` \| _Clique-direito²_ | `Cmd`+`b`  \| _Clique-direito²_
+ | Clicar em `APP_SWITCH`                                        | `Ctrl`+`s`                      | `Cmd`+`s`
+ | Clicar em `MENU`                                              | `Ctrl`+`m`                      | `Ctrl`+`m`
+ | Clicar em `VOLUME_UP`                                         | `Ctrl`+`↑` _(cima)_             | `Cmd`+`↑` _(cima)_
+ | Clicar em `VOLUME_DOWN`                                       | `Ctrl`+`↓` _(baixo)_            | `Cmd`+`↓` _(baixo)_
+ | Clicar em `POWER`                                             | `Ctrl`+`p`                      | `Cmd`+`p`
+ | Ligar                                                         | _Clique-direito²_               | _Clique-direito²_
+ | Desligar a tela do dispositivo                                | `Ctrl`+`o`                      | `Cmd`+`o`
+ | Rotacionar tela do dispositivo                                | `Ctrl`+`r`                      | `Cmd`+`r`
+ | Expandir painel de notificação                                | `Ctrl`+`n`                      | `Cmd`+`n`
+ | Esconder painel de notificação                                | `Ctrl`+`Shift`+`n`              | `Cmd`+`Shift`+`n`
+ | Copiar área de transferência do dispositivo para o computador | `Ctrl`+`c`                      | `Cmd`+`c`
+ | Colar área de transferência do computador para o dispositivo  | `Ctrl`+`v`                      | `Cmd`+`v`
+ | Copiar área de transferência do computador para dispositivo   | `Ctrl`+`Shift`+`v`              | `Cmd`+`Shift`+`v`
+ | Ativar/desativar contador de FPS(Frames por segundo)          | `Ctrl`+`i`                      | `Cmd`+`i`

-Ele pode ser mudado usando `--shortcut-mod`. Possíveis teclas são `lctrl`, `rctrl`,
-`lalt`, `ralt`, `lsuper` e `rsuper`. Por exemplo:
-
-```bash
-# usar RCtrl para atalhos
-scrcpy --shortcut-mod=rctrl
-
-# usar tanto LCtrl+LAlt quanto LSuper para atalhos
-scrcpy --shortcut-mod=lctrl+lalt,lsuper
-```
-
-_<kbd>[Super]</kbd> é tipicamente a tecla <kbd>Windows</kbd> ou <kbd>Cmd</kbd>._
-
-[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
-
- | Ação                                        |   Atalho
- | ------------------------------------------- |:-----------------------------
- | Mudar modo de tela cheia                    | <kbd>MOD</kbd>+<kbd>f</kbd>
- | Rotacionar display para esquerda            | <kbd>MOD</kbd>+<kbd>←</kbd> _(esquerda)_
- | Rotacionar display para direita             | <kbd>MOD</kbd>+<kbd>→</kbd> _(direita)_
- | Redimensionar janela para 1:1 (pixel-perfeito) | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Redimensionar janela para remover bordas pretas | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Clique-duplo-esquerdo¹_
- | Clicar em `HOME`                            | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Clique-do-meio_
- | Clicar em `BACK`                            | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Clique-direito²_
- | Clicar em `APP_SWITCH`                      | <kbd>MOD</kbd>+<kbd>s</kbd> \| _Clique-do-4.°³_
- | Clicar em `MENU` (desbloquear tela)         | <kbd>MOD</kbd>+<kbd>m</kbd>
- | Clicar em `VOLUME_UP`                       | <kbd>MOD</kbd>+<kbd>↑</kbd> _(cima)_
- | Clicar em `VOLUME_DOWN`                     | <kbd>MOD</kbd>+<kbd>↓</kbd> _(baixo)_
- | Clicar em `POWER`                           | <kbd>MOD</kbd>+<kbd>p</kbd>
- | Ligar                                       | _Clique-direito²_
- | Desligar tela do dispositivo (continuar espelhando) | <kbd>MOD</kbd>+<kbd>o</kbd>
- | Ligar tela do dispositivo                   | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
- | Rotacionar tela do dispositivo              | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Expandir painel de notificação              | <kbd>MOD</kbd>+<kbd>n</kbd> \| _Clique-do-5.°³_
- | Expandir painel de configurção              | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Clique-duplo-do-5.°³_
- | Colapsar paineis                            | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copiar para área de transferência⁴          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Recortar para área de transferência⁴        | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Sincronizar áreas de transferência e colar⁴ | <kbd>MOD</kbd>+<kbd>v</kbd>
- | Injetar texto da área de transferência do computador | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
- | Ativar/desativar contador de FPS (em stdout) | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Pinçar para dar zoom                        | <kbd>Ctrl</kbd>+_Clicar-e-mover_
-
-_¹Clique-duplo-esquerdo na borda preta para remove-la._  
-_²Clique-direito liga a tela caso esteja desligada, pressione BACK caso contrário._  
-_³4.° and 5.° botões do mouse, caso o mouse possua._  
-_⁴Apenas em Android >= 7._
-
-Atalhos com teclas reptidas são executados soltando e precionando a tecla
-uma segunda vez. Por exemplo, para executar "Expandir painel de Configurção":
-
- 1. Mantenha pressionado <kbd>MOD</kbd>.
- 2. Depois click duas vezes <kbd>n</kbd>.
- 3. Finalmente, solte <kbd>MOD</kbd>.
-
-Todos os atalhos <kbd>Ctrl</kbd>+_tecla_ são encaminhados para o dispositivo, para que eles sejam
-tratados pela aplicação ativa.
+_¹Clique-duplo em bordas pretas para removê-las._  
+_²Botão direito liga a tela se ela estiver desligada, clique BACK para o contrário._


 ## Caminhos personalizados

-Para usar um binário _adb_ específico, configure seu caminho na variável de ambiente
-`ADB`:
+Para usar um binário específico _adb_, configure seu caminho na variável de ambiente `ADB`:

-```bash
-ADB=/caminho/para/adb scrcpy
-```
+    ADB=/caminho/para/adb scrcpy

 Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em
 `SCRCPY_SERVER_PATH`.
@ -829,7 +478,7 @@ Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em

 ## Por quê _scrcpy_?

-Um colega me desafiou a encontrar um nome tão impronunciável quanto [gnirehtet].
+Um colega me desafiou a encontrar um nome impronunciável como [gnirehtet].

 [`strcpy`] copia uma **str**ing; `scrcpy` copia uma **scr**een.

@ -841,15 +490,17 @@ Um colega me desafiou a encontrar um nome tão impronunciável quanto [gnirehtet

 Veja [BUILD].

+[BUILD]: BUILD.md
+

 ## Problemas comuns

-Veja o [FAQ](FAQ.md).
+Veja [FAQ](FAQ.md).


 ## Desenvolvedores

-Leia a [página dos desenvolvedores][developers page].
+Leia a  [developers page].

 [developers page]: DEVELOP.md

@ -857,7 +508,7 @@ Leia a [página dos desenvolvedores][developers page].
 ## Licença

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
--- a/README.sp.md
+++ b/README.sp.md
@ -1,974 +0,0 @@
-Solo se garantiza que el archivo [README](README.md) original esté actualizado.
-
-# scrcpy (v1.21)
-
-<img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
-
-Esta aplicación proporciona control e imagen de un dispositivo Android conectado
-por USB (o [por TCP/IP](#conexión)). No requiere acceso _root_.
-Compatible con _GNU/Linux_, _Windows_ y _macOS_.
-
-![screenshot](assets/screenshot-debian-600.jpg)
-
-Se enfoca en:
- - **ser ligera**: aplicación nativa, solo muestra la imagen del dispositivo
- - **rendimiento**: 30~120fps, dependiendo del dispositivo
- - **calidad**: 1920×1080 o superior
- - **baja latencia**: [35~70ms][lowlatency]
- - **inicio rápido**: ~1 segundo para mostrar la primera imagen
- - **no intrusivo**: no deja nada instalado en el dispositivo
- - **beneficios**: sin cuentas, sin anuncios, no requiere acceso a internet
- - **libertad**: software gratis y de código abierto
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-Con la aplicación puede:
- - [grabar la pantalla](#capturas-y-grabaciones)
- - duplicar la imagen con [la pantalla apagada](#apagar-la-pantalla)
- - [copiar y pegar](#copiar-y-pegar) en ambos sentidos
- - [configurar la calidad](#configuración-de-captura)
- - usar la pantalla del dispositivo [como webcam (V4L2)](#v4l2loopback) (solo en Linux)
- - [emular un teclado físico (HID)](#emular-teclado-físico-hid)
-   (solo en Linux)
- - y mucho más…
-
-## Requisitos
-
-El dispositivo Android requiere como mínimo API 21 (Android 5.0).
-
-Asegurate de [habilitar el adb debugging][enable-adb] en tu(s) dispositivo(s).
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-En algunos dispositivos, también necesitas habilitar [una opción adicional][control] para controlarlo con el teclado y ratón.
-
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-## Consigue la app
-
-<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
-
-### Resumen
-
- - Linux: `apt install scrcpy`
- - Windows: [download](README.md#windows)
- - macOS: `brew install scrcpy`
-
-Construir desde la fuente: [BUILD] ([proceso simplificado][BUILD_simple])
-
-[BUILD]: BUILD.md
-[BUILD_simple]: BUILD.md#simple
-
-
-### Linux
-
-En Debian y Ubuntu:
-
-```
-apt install scrcpy
-```
-
-Hay un paquete [Snap]: [`scrcpy`][snap-link].
-
-[snap-link]: https://snapstats.org/snaps/scrcpy
-
-[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
-
-Para Fedora, hay un paquete [COPR]: [`scrcpy`][copr-link].
-
-[COPR]: https://fedoraproject.org/wiki/Category:Copr
-[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
-
-Para Arch Linux, hay un paquete [AUR]: [`scrcpy`][aur-link].
-
-[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
-
-Para Gentoo, hay un paquete [Ebuild]: [`scrcpy/`][ebuild-link].
-
-[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
-[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-
-También puedes [construir la aplicación manualmente][BUILD] ([proceso simplificado][BUILD_simple]).
-
-
-### Windows
-
-Para Windows, por simplicidad, hay un pre-compilado con todas las dependencias
-(incluyendo `adb`):
-
- - [README](README.md#windows)
-
-También está disponible en [Chocolatey]:
-
-[Chocolatey]: https://chocolatey.org/
-
-```bash
-choco install scrcpy
-choco install adb    # si aún no está instalado
-```
-
-Y en [Scoop]:
-
-```bash
-scoop install scrcpy
-scoop install adb    # si aún no está instalado
-```
-
-[Scoop]: https://scoop.sh
-
-También puedes [construir la aplicación manualmente][BUILD].
-
-
-### macOS
-
-La aplicación está disponible en [Homebrew]. Solo instalala:
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-Necesitarás `adb`, accesible desde `PATH`. Si aún no lo tienes:
-
-```bash
-brew install android-platform-tools
-```
-
-También está disponible en [MacPorts], que configura el adb automáticamente:
-
-```bash
-sudo port install scrcpy
-```
-
-[MacPorts]: https://www.macports.org/
-
-
-También puedes [construir la aplicación manualmente][BUILD].
-
-
-## Ejecutar
-
-Enchufa el dispositivo Android, y ejecuta:
-
-```bash
-scrcpy
-```
-
-Acepta argumentos desde la línea de comandos, listados en:
-
-```bash
-scrcpy --help
-```
-
-## Características
-
-### Configuración de captura
-
-#### Reducir la definición
-
-A veces es útil reducir la definición de la imagen del dispositivo Android para aumentar el desempeño.
-
-Para limitar el ancho y la altura a un valor específico (ej. 1024):
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # versión breve
-```
-
-La otra dimensión es calculada para conservar el aspect ratio del dispositivo.
-De esta forma, un dispositivo en 1920×1080 será transmitido a 1024×576.
-
-
-#### Cambiar el bit-rate
-
-El bit-rate por defecto es 8 Mbps. Para cambiar el bit-rate del video (ej. a 2 Mbps):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # versión breve
-```
-
-#### Limitar los fps
-
-El fps puede ser limitado:
-
-```bash
-scrcpy --max-fps 15
-```
-
-Es oficialmente soportado desde Android 10, pero puede funcionar en versiones anteriores.
-
-#### Recortar
-
-La imagen del dispositivo puede ser recortada para transmitir solo una parte de la pantalla.
-
-Por ejemplo, puede ser útil para transmitir la imagen de un solo ojo del Oculus Go:
-
-```bash
-scrcpy --crop 1224:1440:0:0   # 1224x1440 con coordenadas de origen en (0,0)
-```
-
-Si `--max-size` también está especificado, el cambio de tamaño es aplicado después de cortar.
-
-
-#### Fijar la rotación del video
-
-
-Para fijar la rotación de la transmisión:
-
-```bash
-scrcpy --lock-video-orientation     # orientación inicial
-scrcpy --lock-video-orientation=0   # orientación normal
-scrcpy --lock-video-orientation=1   # 90° contrarreloj
-scrcpy --lock-video-orientation=2   # 180°
-scrcpy --lock-video-orientation=3   # 90° sentido de las agujas del reloj
-```
-
-Esto afecta la rotación de la grabación.
-
-La [ventana también puede ser rotada](#rotación) independientemente.
-
-
-#### Codificador
-
-Algunos dispositivos pueden tener más de una rotación, y algunos pueden causar problemas o errores. Es posible seleccionar un codificador diferente:
-
-```bash
-scrcpy --encoder OMX.qcom.video.encoder.avc
-```
-
-Para listar los codificadores disponibles, puedes pasar un nombre de codificador inválido, el error te dará los codificadores disponibles:
-
-```bash
-scrcpy --encoder _
-```
-
-### Capturas y grabaciones
-
-
-#### Grabación
-
-Es posible grabar la pantalla mientras se transmite:
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-Para grabar sin transmitir la pantalla:
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# interrumpe la grabación con Ctrl+C
-```
-
-Los "skipped frames" son grabados, incluso si no se mostrados en tiempo real (por razones de desempeño). Los frames tienen _marcas de tiempo_ en el dispositivo, por lo que el "[packet delay
-variation]" no impacta el archivo grabado.
-
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-
-#### v4l2loopback
-
-En Linux se puede mandar el stream del video a un dispositivo loopback v4l2, por
-lo que se puede abrir el dispositivo Android como una webcam con cualquier
-programa compatible con v4l2.
-
-Se debe instalar el modulo `v4l2loopback`:
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-Para crear un dispositivo v4l2:
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-Esto va a crear un nuevo dispositivo de video en `/dev/videoN`, donde `N` es un número
-(hay más [opciones](https://github.com/umlaeute/v4l2loopback#options) disponibles
-para crear múltiples dispositivos o usar un ID en específico).
-
-Para ver los dispositivos disponibles:
-
-```bash
-# requiere el paquete v4l-utils
-v4l2-ctl --list-devices
-# simple pero generalmente suficiente
-ls /dev/video*
-```
-
-Para iniciar scrcpy usando una fuente v4l2:
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # deshabilita la transmisión de imagen
-scrcpy --v4l2-sink=/dev/videoN -N            # más corto
-```
-
-(reemplace `N` con el ID del dispositivo, compruebe con `ls /dev/video*`)
-
-Una vez habilitado, podés abrir el stream del video con una herramienta compatible con v4l2:
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLC puede agregar un delay por buffering
-```
-
-Por ejemplo, podrías capturar el video usando [OBS].
-
-[OBS]: https://obsproject.com/
-
-
-#### Buffering
-
-Es posible agregar buffering al video. Esto reduce el ruido en la imagen ("jitter")
-pero aumenta la latencia (vea [#2464]).
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-La opción de buffering está disponible para la transmisión de imagen:
-
-```bash
-scrcpy --display-buffer=50  # agrega 50 ms de buffering a la imagen
-```
-
-y las fuentes V4L2:
-
-```bash
-scrcpy --v4l2-buffer=500    # agrega 500 ms de buffering a la fuente v4l2
-```
-
-
-### Conexión
-
-#### TCP/IP (Inalámbrica)
-
-_Scrcpy_ usa `adb` para comunicarse con el dispositivo, y `adb` puede [conectarse] vía TCP/IP.
-El dispositivo debe estar conectado a la misma red que la computadora:
-
-##### Automático
-
-La opción `--tcpip` permite configurar la conexión automáticamente. Hay 2 variables.
-
-Si el dispositivo (accesible en 192.168.1.1 para este ejemplo) ya está escuchando
-en un puerto (generalmente 5555) esperando una conexión adb entrante, entonces corré:
-
-```bash
-scrcpy --tcpip=192.168.1.1       # el puerto default es 5555
-scrcpy --tcpip=192.168.1.1:5555
-```
-
-Si el dispositivo no tiene habilitado el modo adb TCP/IP (o si no sabés la dirección IP),
-entonces conectá el dispositivo por USB y corré:
-
-```bash
-scrcpy --tcpip    # sin argumentos
-```
-
-El programa buscará automáticamente la IP del dispositivo, habilitará el modo TCP/IP, y
-se conectará al dispositivo antes de comenzar a transmitir la imagen.
-
-##### Manual
-
-Como alternativa, se puede habilitar la conexión TCP/IP manualmente usando `adb`:
-
-1. Conecta el dispositivo al mismo Wi-Fi que tu computadora.
-2. Obtén la dirección IP del dispositivo, en Ajustes → Acerca del dispositivo → Estado, o ejecutando este comando:
-
-    ```bash
-    adb shell ip route | awk '{print $9}'
-    ```
-
-3. Habilita adb vía TCP/IP en el dispositivo: `adb tcpip 5555`.
-4. Desenchufa el dispositivo.
-5. Conéctate a tu dispositivo: `adb connect IP_DEL_DISPOSITIVO:5555` _(reemplaza `IP_DEL_DISPOSITIVO`)_.
-6. Ejecuta `scrcpy` con normalidad.
-
-Podría resultar útil reducir el bit-rate y la definición:
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # versión breve
-```
-
-[conectarse]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-#### Múltiples dispositivos
-
-Si hay muchos dispositivos listados en `adb devices`, será necesario especificar el _número de serie_:
-
-```bash
-scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # versión breve
-```
-
-Si el dispositivo está conectado por TCP/IP:
-
-```bash
-scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # versión breve
-```
-
-Puedes iniciar múltiples instancias de _scrcpy_ para múltiples dispositivos.
-
-#### Iniciar automáticamente al detectar dispositivo
-
-Puedes utilizar [AutoAdb]:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
-
-#### Túneles
-
-Para conectarse a un dispositivo remoto, es posible conectar un cliente local `adb` a un servidor remoto `adb` (siempre y cuando utilicen la misma versión de protocolos _adb_).
-
-##### Servidor ADB remoto
-
-Para conectarse a un servidor ADB remoto, haz que el servidor escuche en todas las interfaces:
-
-```bash
-adb kill-server
-adb -a nodaemon server start
-# conserva este servidor abierto
-```
-
-**Advertencia: todas las comunicaciones entre los clientes y el servidor ADB están desencriptadas.**
-
-Supondremos que este servidor se puede acceder desde 192.168.1.2. Entonces, desde otra
-terminal, corré scrcpy:
-
-```bash
-export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
-scrcpy --tunnel-host=192.168.1.2
-```
-
-Por default, scrcpy usa el puerto local que se usó para establecer el tunel
-`adb forward` (típicamente `27183`, vea `--port`). También es posible forzar un
-puerto diferente (puede resultar útil en situaciones más complejas, donde haya
-múltiples redirecciones):
-
-```
-scrcpy --tunnel-port=1234
-```
-
-
-##### Túnel SSH
-
-Para comunicarse con un servidor ADB remoto de forma segura, es preferible usar un túnel SSH.
-
-Primero, asegurate que el servidor ADB está corriendo en la computadora remota:
-
-```bash
-adb start-server
-```
-
-Después, establecé el túnel SSH:
-
-```bash
-# local  5038 --> remoto  5037
-# local 27183 <-- remoto 27183
-ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# conserva este servidor abierto
-```
-
-Desde otra terminal, corré scrcpy:
-
-```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
-scrcpy
-```
-
-Para evitar habilitar "remote port forwarding", puedes forzar una "forward connection" (nótese el argumento `-L` en vez de `-R`):
-
-```bash
-# local  5038 --> remoto  5037
-# local 27183 --> remoto 27183
-ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
-# conserva este servidor abierto
-```
-
-Desde otra terminal, corré scrcpy:
-
-```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
-scrcpy --force-adb-forward
-```
-
-Al igual que las conexiones inalámbricas, puede resultar útil reducir la calidad:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-### Configuración de la ventana
-
-#### Título
-
-Por defecto, el título de la ventana es el modelo del dispositivo. Puede ser modificado:
-
-```bash
-scrcpy --window-title 'My device'
-```
-
-#### Posición y tamaño
-
-La posición y tamaño inicial de la ventana puede ser especificado:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-#### Sin bordes
-
-Para deshabilitar el diseño de la ventana:
-
-```bash
-scrcpy --window-borderless
-```
-
-#### Siempre adelante
-
-Para mantener la ventana de scrcpy siempre adelante:
-
-```bash
-scrcpy --always-on-top
-```
-
-#### Pantalla completa
-
-La aplicación puede ser iniciada en pantalla completa:
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # versión breve
-```
-
-Puede entrar y salir de la pantalla completa con la combinación <kbd>MOD</kbd>+<kbd>f</kbd>.
-
-#### Rotación
-
-Se puede rotar la ventana:
-
-```bash
-scrcpy --rotation 1
-```
-
-Los posibles valores son:
- - `0`: sin rotación
- - `1`: 90 grados contrarreloj
- - `2`: 180 grados
- - `3`: 90 grados en sentido de las agujas del reloj
-
-La rotación también puede ser modificada con la combinación de teclas <kbd>MOD</kbd>+<kbd>←</kbd> _(izquierda)_ y <kbd>MOD</kbd>+<kbd>→</kbd> _(derecha)_.
-
-Nótese que _scrcpy_ maneja 3 diferentes rotaciones:
- - <kbd>MOD</kbd>+<kbd>r</kbd> solicita al dispositivo cambiar entre vertical y horizontal (la aplicación en uso puede rechazarlo si no soporta la orientación solicitada).
- - [`--lock-video-orientation`](#fijar-la-rotación-del-video) cambia la rotación de la transmisión (la orientación del video enviado a la PC). Esto afecta a la grabación.
- - `--rotation` (o <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) rota solo el contenido de la imagen. Esto solo afecta a la imagen mostrada, no a la grabación.
-
-
-### Otras opciones
-
-#### Solo lectura ("Read-only")
-
-Para deshabilitar los controles (todo lo que interactúe con el dispositivo: eventos del teclado, eventos del mouse, arrastrar y soltar archivos):
-
-```bash
-scrcpy --no-control
-scrcpy -n  # versión breve
-```
-
-#### Pantalla
-
-Si múltiples pantallas están disponibles, es posible elegir cual transmitir:
-
-```bash
-scrcpy --display 1
-```
-
-Los ids de las pantallas se pueden obtener con el siguiente comando:
-
-```bash
-adb shell dumpsys display   # busque "mDisplayId=" en la respuesta
-```
-
-La segunda pantalla solo puede ser manejada si el dispositivo cuenta con Android 10 (en caso contrario será transmitida en el modo solo lectura).
-
-
-#### Permanecer activo
-
-Para evitar que el dispositivo descanse después de un tiempo mientras está conectado:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w  # versión breve
-```
-
-La configuración original se restaura al cerrar scrcpy.
-
-
-#### Apagar la pantalla
-
-Es posible apagar la pantalla mientras se transmite al iniciar con el siguiente comando:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S  # versión breve
-```
-
-O presionando <kbd>MOD</kbd>+<kbd>o</kbd> en cualquier momento.
-
-Para volver a prenderla, presione <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
-
-En Android, el botón de `POWER` siempre prende la pantalla. Por conveniencia, si `POWER` es enviado vía scrcpy (con click-derecho o <kbd>MOD</kbd>+<kbd>p</kbd>), esto forzará a apagar la pantalla con un poco de atraso (en la mejor de las situaciones). El botón físico `POWER` seguirá prendiendo la pantalla.
-
-También puede resultar útil para evitar que el dispositivo entre en inactividad:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw  # versión breve
-```
-
-
-#### Apagar al cerrar la aplicación
-
-Para apagar la pantalla del dispositivo al cerrar scrcpy:
-
-```bash
-scrcpy --power-off-on-close
-```
-
-#### Mostrar clicks
-
-Para presentaciones, puede resultar útil mostrar los clicks físicos (en el dispositivo físicamente).
-
-Android provee esta opción en _Opciones para desarrolladores_.
-
-_Scrcpy_ provee una opción para habilitar esta función al iniciar la aplicación y restaurar el valor original al salir:
-
-```bash
-scrcpy --show-touches
-scrcpy -t  # versión breve
-```
-
-Nótese que solo muestra los clicks _físicos_ (con el dedo en el dispositivo).
-
-
-#### Desactivar protector de pantalla
-
-Por defecto, scrcpy no evita que el protector de pantalla se active en la computadora.
-
-Para deshabilitarlo:
-
-```bash
-scrcpy --disable-screensaver
-```
-
-
-### Control
-
-#### Rotar pantalla del dispositivo
-
-Presione <kbd>MOD</kbd>+<kbd>r</kbd> para cambiar entre posición vertical y horizontal.
-
-Nótese que solo rotará si la aplicación activa soporta la orientación solicitada.
-
-#### Copiar y pegar
-
-Cuando que el portapapeles de Android cambia, automáticamente se sincroniza al portapapeles de la computadora.
-
-Cualquier shortcut con <kbd>Ctrl</kbd> es enviado al dispositivo. En particular:
- - <kbd>Ctrl</kbd>+<kbd>c</kbd> normalmente copia
- - <kbd>Ctrl</kbd>+<kbd>x</kbd> normalmente corta
- - <kbd>Ctrl</kbd>+<kbd>v</kbd> normalmente pega (después de la sincronización de portapapeles entre la computadora y el dispositivo)
-
-Esto normalmente funciona como es esperado.
-
-Sin embargo, este comportamiento depende de la aplicación en uso. Por ejemplo, _Termux_ envía SIGINT con <kbd>Ctrl</kbd>+<kbd>c</kbd>, y _K-9 Mail_ crea un nuevo mensaje.
-
-Para copiar, cortar y pegar, en tales casos (solo soportado en Android >= 7):
- - <kbd>MOD</kbd>+<kbd>c</kbd> inyecta `COPY`
- - <kbd>MOD</kbd>+<kbd>x</kbd> inyecta `CUT`
- - <kbd>MOD</kbd>+<kbd>v</kbd> inyecta `PASTE` (después de la sincronización de portapapeles entre la computadora y el dispositivo)
-
-Además, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permite inyectar el texto en el portapapeles de la computadora como una secuencia de teclas. Esto es útil cuando el componente no acepta pegado de texto (por ejemplo en _Termux_), pero puede romper caracteres no pertenecientes a ASCII.
-
-**AVISO:** Pegar de la computadora al dispositivo (tanto con <kbd>Ctrl</kbd>+<kbd>v</kbd> o <kbd>MOD</kbd>+<kbd>v</kbd>) copia el contenido al portapapeles del dispositivo. Como consecuencia, cualquier aplicación de Android puede leer su contenido. Debería evitar pegar contenido sensible (como contraseñas) de esta forma.
-
-Algunos dispositivos no se comportan como es esperado al establecer el portapapeles programáticamente. La opción `--legacy-paste` está disponible para cambiar el comportamiento de <kbd>Ctrl</kbd>+<kbd>v</kbd> y <kbd>MOD</kbd>+<kbd>v</kbd> para que también inyecten el texto del portapapeles de la computadora como una secuencia de teclas (de la misma forma que <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
-
-Para deshabilitar la auto-sincronización del portapapeles, use `--no-clipboard-autosync`.
-
-#### Pellizcar para zoom
-
-Para simular "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-y-mover_.
-
-Más precisamente, mantén <kbd>Ctrl</kbd> mientras presionas botón izquierdo. Hasta que no se suelte el botón, todos los movimientos del mouse cambiarán el tamaño y rotación del contenido (si es soportado por la app en uso) respecto al centro de la pantalla.
-
-Concretamente, scrcpy genera clicks adicionales con un "dedo virtual" en la posición invertida respecto al centro de la pantalla.
-
-#### Emular teclado físico (HID)
-
-Por default, scrcpy usa el sistema de Android para la injección de teclas o texto:
-funciona en todas partes, pero está limitado a ASCII.
-
-En Linux, scrcpy puede emular un teclado USB físico en Android para proveer
-una mejor experiencia al enviar _inputs_ (usando [USB HID vía AOAv2][hid-aoav2]):
-deshabilita el teclado virtual y funciona para todos los caracteres y IME.
-
-[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
-
-Sin embargo, solo funciona si el dispositivo está conectado por USB, y por ahora
-solo funciona en Linux.
-
-Para habilitar este modo:
-
-```bash
-scrcpy --hid-keyboard
-scrcpy -K  # más corto
-```
-
-Si por alguna razón falla (por ejemplo si el dispositivo no está conectado vía
-USB), automáticamente vuelve al modo default (un mensaje se escribirá en la consola).
-Se puede usar los mismos argumentos en la línea de comandos tanto si se conecta con
-USB o vía TCP/IP.
-
-En este modo, los _raw key events_ (_scancodes_) se envían al dispositivo, independientemente
-del mapeo del teclado en el host. Por eso, si el diseño de tu teclado no concuerda, debe ser
-configurado en el dispositivo Android, en Ajustes → Sistema → Idioma y Entrada de Texto
-→ [Teclado Físico].
-
-Se puede iniciar automáticamente en esta página de ajustes:
-
-```bash
-adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
-```
-
-Sin embargo, la opción solo está disponible cuando el teclado HID está activo
-(o cuando se conecta un teclado físico).
-
-[Teclado Físico]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
-
-
-#### Preferencias de inyección de texto
-
-Existen dos tipos de [eventos][textevents] generados al escribir texto:
- - _key events_, marcando si la tecla es presionada o soltada;
- - _text events_, marcando si un texto fue introducido.
-
-Por defecto, las letras son inyectadas usando _key events_, para que el teclado funcione como es esperado en juegos (típicamente las teclas WASD).
-
-Pero esto puede [causar problemas][prefertext]. Si encuentras tales problemas, los puedes evitar con:
-
-```bash
-scrcpy --prefer-text
-```
-
-(Pero esto romperá el comportamiento del teclado en los juegos)
-
-Por el contrario, se puede forzar scrcpy para siempre injectar _raw key events_:
-
-```bash
-scrcpy --raw-key-events
-```
-
-Estas opciones no tienen efecto en los teclados HID (todos los _key events_ son enviados como
-_scancodes_ en este modo).
-
-[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
-[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-
-
-#### Repetir tecla
-
-Por defecto, mantener una tecla presionada genera múltiples _key events_. Esto puede
-causar problemas de desempeño en algunos juegos, donde estos eventos no tienen sentido de todos modos.
-
-Para evitar enviar _key events_ repetidos:
-
-```bash
-scrcpy --no-key-repeat
-```
-
-Estas opciones no tienen efecto en los teclados HID (Android maneja directamente
-las repeticiones de teclas en este modo)
-
-
-#### Botón derecho y botón del medio
-
-Por defecto, botón derecho ejecuta RETROCEDER (o ENCENDIDO) y botón del medio INICIO. Para inhabilitar estos atajos y enviar los clicks al dispositivo:
-
-```bash
-scrcpy --forward-all-clicks
-```
-
-
-### Arrastrar y soltar archivos
-
-#### Instalar APKs
-
-Para instalar un APK, arrastre y suelte el archivo APK (terminado en `.apk`) a la ventana de _scrcpy_.
-
-No hay respuesta visual, un mensaje se escribirá en la consola.
-
-
-#### Enviar archivos al dispositivo
-
-Para enviar un archivo a `/sdcard/Download/` en el dispositivo, arrastre y suelte
-un archivo (no APK) a la ventana de _scrcpy_.
-
-No hay ninguna respuesta visual, un mensaje se escribirá en la consola.
-
-El directorio de destino puede ser modificado al iniciar:
-
-```bash
-scrcpy --push-target=/sdcard/Movies/
-```
-
-
-### Envío de Audio
-
-_Scrcpy_ no envía el audio. Use [sndcpy].
-
-También lea [issue #14].
-
-[sndcpy]: https://github.com/rom1v/sndcpy
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
-
-
-## Atajos
-
-En la siguiente lista, <kbd>MOD</kbd> es el atajo modificador. Por defecto es <kbd>Alt</kbd> (izquierdo) o <kbd>Super</kbd> (izquierdo).
-
-Se puede modificar usando `--shortcut-mod`. Las posibles teclas son `lctrl` (izquierdo), `rctrl` (derecho), `lalt` (izquierdo), `ralt` (derecho), `lsuper` (izquierdo) y `rsuper` (derecho). Por ejemplo:
-
-```bash
-# use RCtrl para los atajos
-scrcpy --shortcut-mod=rctrl
-
-# use tanto LCtrl+LAlt o LSuper para los atajos
-scrcpy --shortcut-mod=lctrl+lalt,lsuper
-```
-
-_<kbd>[Super]</kbd> es generalmente la tecla <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
-
-[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
-
- | Acción                                       |   Atajo
- | -------------------------------------------  |:-----------------------------
- | Alterne entre pantalla compelta              | <kbd>MOD</kbd>+<kbd>f</kbd>
- | Rotar pantalla hacia la izquierda            | <kbd>MOD</kbd>+<kbd>←</kbd> _(izquierda)_
- | Rotar pantalla hacia la derecha              | <kbd>MOD</kbd>+<kbd>→</kbd> _(derecha)_
- | Ajustar ventana a 1:1 ("pixel-perfect")      | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Ajustar ventana para quitar los bordes negros| <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doble click izquierdo¹_
- | Click en `INICIO`                            | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Click medio_
- | Click en `RETROCEDER`                        | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Click derecho²_
- | Click en `CAMBIAR APLICACIÓN`                | <kbd>MOD</kbd>+<kbd>s</kbd> \| _Cuarto botón³_
- | Click en `MENÚ` (desbloquear pantalla)⁴      | <kbd>MOD</kbd>+<kbd>m</kbd>
- | Click en `SUBIR VOLUMEN`                     | <kbd>MOD</kbd>+<kbd>↑</kbd> _(arriba)_
- | Click en `BAJAR VOLUME`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(abajo)_
- | Click en `ENCENDIDO`                         | <kbd>MOD</kbd>+<kbd>p</kbd>
- | Encendido                                    | _Botón derecho²_
- | Apagar pantalla (manteniendo la transmisión) | <kbd>MOD</kbd>+<kbd>o</kbd>
- | Encender pantalla                            | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
- | Rotar pantalla del dispositivo               | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Abrir panel de notificaciones                | <kbd>MOD</kbd>+<kbd>n</kbd> \| _Quinto botón³_
- | Abrir panel de configuración                 | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Doble quinto botón³_
- | Cerrar paneles                               | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copiar al portapapeles⁵                      | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Cortar al portapapeles⁵                      | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Synchronizar portapapeles y pegar⁵           | <kbd>MOD</kbd>+<kbd>v</kbd>
- | Inyectar texto del portapapeles de la PC     | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
- | Habilitar/Deshabilitar contador de FPS (en stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Pellizcar para zoom                          | <kbd>Ctrl</kbd>+_click-y-mover_
- | Arrastrar y soltar un archivo (APK)          | Instalar APK desde la computadora
- | Arrastrar y soltar un archivo (no APK)       | [Mover archivo al dispositivo](#enviar-archivos-al-dispositivo)
-
-_¹Doble click en los bordes negros para eliminarlos._  
-_²Botón derecho enciende la pantalla si estaba apagada, sino ejecuta RETROCEDER._  
-_³Cuarto y quinto botón del mouse, si tu mouse los tiene._  
-_⁴Para las apps react-native en desarrollo, `MENU` activa el menú de desarrollo._  
-_⁵Solo en Android >= 7._
-
-Los shortcuts con teclas repetidas se ejecutan soltando y volviendo a apretar la tecla
-por segunda vez. Por ejemplo, para ejecutar "Abrir panel de configuración":
-
- 1. Apretá y mantené apretado <kbd>MOD</kbd>.
- 2. Después apretá dos veces la tecla <kbd>n</kbd>.
- 3. Por último, soltá la tecla <kbd>MOD</kbd>.
-
-Todos los atajos <kbd>Ctrl</kbd>+_tecla_ son enviados al dispositivo para que sean manejados por la aplicación activa.
-
-
-## Path personalizado
-
-Para usar un binario de _adb_ en particular, configure el path `ADB` en las variables de entorno:
-
-```bash
-ADB=/path/to/adb scrcpy
-```
-
-Para sobreescribir el path del archivo `scrcpy-server`, configure el path en `SCRCPY_SERVER_PATH`.
-
-Para sobreescribir el ícono, configure el path en `SCRCPY_ICON_PATH`.
-
-
-## ¿Por qué _scrcpy_?
-
-Un colega me retó a encontrar un nombre tan impronunciable como [gnirehtet].
-
-[`strcpy`] copia un **str**ing; `scrcpy` copia un **scr**een.
-
-[gnirehtet]: https://github.com/Genymobile/gnirehtet
-[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
-
-
-## ¿Cómo construir (BUILD)?
-
-Véase [BUILD] (en inglés).
-
-
-## Problemas generales
-
-Vea las [preguntas frecuentes (en inglés)](FAQ.md).
-
-
-## Desarrolladores
-
-Lea la [hoja de desarrolladores (en inglés)](DEVELOP.md).
-
-
-## Licencia
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## Artículos
-
- [Introducing scrcpy][article-intro] (en inglés)
- [Scrcpy now works wirelessly][article-tcpip] (en inglés)
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.tr.md
+++ b/README.tr.md
@ -1,824 +0,0 @@
-# scrcpy (v1.18)
-
-Bu uygulama Android cihazların USB (ya da [TCP/IP][article-tcpip]) üzerinden
-görüntülenmesini ve kontrol edilmesini sağlar. _root_ erişimine ihtiyaç duymaz.
-_GNU/Linux_, _Windows_ ve _macOS_ sistemlerinde çalışabilir.
-
-![screenshot](assets/screenshot-debian-600.jpg)
-
-Öne çıkan özellikler:
-
- **hafiflik** (doğal, sadece cihazın ekranını gösterir)
- **performans** (30~60fps)
- **kalite** (1920×1080 ya da üzeri)
- **düşük gecikme süresi** ([35~70ms][lowlatency])
- **düşük başlangıç süresi** (~1 saniye ilk kareyi gösterme süresi)
- **müdaheleci olmama** (cihazda kurulu yazılım kalmaz)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-## Gereksinimler
-
-Android cihaz en düşük API 21 (Android 5.0) olmalıdır.
-
-[Adb hata ayıklamasının][enable-adb] cihazınızda aktif olduğundan emin olun.
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-Bazı cihazlarda klavye ve fare ile kontrol için [ilave bir seçenek][control] daha
-etkinleştirmeniz gerekebilir.
-
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-## Uygulamayı indirin
-
-<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
-
-### Özet
-
- Linux: `apt install scrcpy`
- Windows: [indir][direct-win64]
- macOS: `brew install scrcpy`
-
-Kaynak kodu derle: [BUILD] ([basitleştirilmiş süreç][build_simple])
-
-[build]: BUILD.md
-[build_simple]: BUILD.md#simple
-
-### Linux
-
-Debian (şimdilik _testing_ ve _sid_) ve Ubuntu (20.04) için:
-
-```
-apt install scrcpy
-```
-
-[Snap] paketi: [`scrcpy`][snap-link].
-
-[snap-link]: https://snapstats.org/snaps/scrcpy
-[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
-
-Fedora için, [COPR] paketi: [`scrcpy`][copr-link].
-
-[copr]: https://fedoraproject.org/wiki/Category:Copr
-[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
-
-Arch Linux için, [AUR] paketi: [`scrcpy`][aur-link].
-
-[aur]: https://wiki.archlinux.org/index.php/Arch_User_Repository
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
-
-Gentoo için, [Ebuild] mevcut: [`scrcpy/`][ebuild-link].
-
-[ebuild]: https://wiki.gentoo.org/wiki/Ebuild
-[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-
-Ayrıca [uygulamayı el ile de derleyebilirsiniz][build] ([basitleştirilmiş süreç][build_simple]).
-
-### Windows
-
-Windows için (`adb` dahil) tüm gereksinimleri ile derlenmiş bir arşiv mevcut:
-
- - [README](README.md#windows)
-
-[Chocolatey] ile kurulum:
-
-[chocolatey]: https://chocolatey.org/
-
-```bash
-choco install scrcpy
-choco install adb    # if you don't have it yet
-```
-
-[Scoop] ile kurulum:
-
-```bash
-scoop install scrcpy
-scoop install adb    # if you don't have it yet
-```
-
-[scoop]: https://scoop.sh
-
-Ayrıca [uygulamayı el ile de derleyebilirsiniz][build].
-
-### macOS
-
-Uygulama [Homebrew] içerisinde mevcut. Sadece kurun:
-
-[homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-`adb`, `PATH` içerisinden erişilebilir olmalıdır. Eğer değilse:
-
-```bash
-brew install android-platform-tools
-```
-
-[MacPorts] kullanılarak adb ve uygulamanın birlikte kurulumu yapılabilir:
-
-```bash
-sudo port install scrcpy
-```
-
-[macports]: https://www.macports.org/
-
-Ayrıca [uygulamayı el ile de derleyebilirsiniz][build].
-
-## Çalıştırma
-
-Android cihazınızı bağlayın ve aşağıdaki komutu çalıştırın:
-
-```bash
-scrcpy
-```
-
-Komut satırı argümanları aşağıdaki komut ile listelenebilir:
-
-```bash
-scrcpy --help
-```
-
-## Özellikler
-
-### Ekran yakalama ayarları
-
-#### Boyut azaltma
-
-Bazen, Android cihaz ekranını daha düşük seviyede göstermek performansı artırabilir.
-
-Hem genişliği hem de yüksekliği bir değere sabitlemek için (ör. 1024):
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # kısa versiyon
-```
-
-Diğer boyut en-boy oranı korunacak şekilde hesaplanır.
-Bu şekilde ekran boyutu 1920x1080 olan bir cihaz 1024x576 olarak görünür.
-
-#### Bit-oranı değiştirme
-
-Varsayılan bit-oranı 8 Mbps'dir. Değiştirmek için (ör. 2 Mbps):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # kısa versiyon
-```
-
-#### Çerçeve oranı sınırlama
-
-Ekran yakalama için maksimum çerçeve oranı için sınır koyulabilir:
-
-```bash
-scrcpy --max-fps 15
-```
-
-Bu özellik Android 10 ve sonrası sürümlerde resmi olarak desteklenmektedir,
-ancak daha önceki sürümlerde çalışmayabilir.
-
-#### Kesme
-
-Cihaz ekranının sadece bir kısmı görünecek şekilde kesilebilir.
-
-Bu özellik Oculus Go'nun bir gözünü yakalamak gibi durumlarda kullanışlı olur:
-
-```bash
-scrcpy --crop 1224:1440:0:0   # (0,0) noktasından 1224x1440
-```
-
-Eğer `--max-size` belirtilmişse yeniden boyutlandırma kesme işleminden sonra yapılır.
-
-#### Video yönünü kilitleme
-
-Videonun yönünü kilitlemek için:
-
-```bash
-scrcpy --lock-video-orientation     # başlangıç yönü
-scrcpy --lock-video-orientation=0   # doğal yön
-scrcpy --lock-video-orientation=1   # 90° saatin tersi yönü
-scrcpy --lock-video-orientation=2   # 180°
-scrcpy --lock-video-orientation=3   # 90° saat yönü
-```
-
-Bu özellik kaydetme yönünü de etkiler.
-
-[Pencere ayrı olarak döndürülmüş](#rotation) olabilir.
-
-#### Kodlayıcı
-
-Bazı cihazlar birden fazla kodlayıcıya sahiptir, ve bunların bazıları programın
-kapanmasına sebep olabilir. Bu durumda farklı bir kodlayıcı seçilebilir:
-
-```bash
-scrcpy --encoder OMX.qcom.video.encoder.avc
-```
-
-Mevcut kodlayıcıları listelemek için geçerli olmayan bir kodlayıcı ismi girebilirsiniz,
-hata mesajı mevcut kodlayıcıları listeleyecektir:
-
-```bash
-scrcpy --encoder _
-```
-
-### Yakalama
-
-#### Kaydetme
-
-Ekran yakalama sırasında kaydedilebilir:
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-Yakalama olmadan kayıt için:
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# Ctrl+C ile kayıt kesilebilir
-```
-
-"Atlanan kareler" gerçek zamanlı olarak gösterilmese (performans sebeplerinden ötürü) dahi kaydedilir.
-Kareler cihazda _zamandamgası_ ile saklanır, bu sayede [paket gecikme varyasyonu]
-kayıt edilen dosyayı etkilemez.
-
-[paket gecikme varyasyonu]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-#### v4l2loopback
-
-Linux'ta video akışı bir v4l2 loopback cihazına gönderilebilir. Bu sayede Android
-cihaz bir web kamerası gibi davranabilir.
-
-Bu işlem için `v4l2loopback` modülü kurulu olmalıdır:
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-v4l2 cihazı oluşturmak için:
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-Bu komut `/dev/videoN` adresinde `N` yerine bir tamsayı koyarak yeni bir video
-cihazı oluşturacaktır.
-(birden fazla cihaz oluşturmak veya spesifik ID'ye sahip cihazlar için
-diğer [seçenekleri](https://github.com/umlaeute/v4l2loopback#options) inceleyebilirsiniz.)
-
-Aktif cihazları listelemek için:
-
-```bash
-# v4l-utils paketi ile
-v4l2-ctl --list-devices
-
-# daha basit ama yeterli olabilecek şekilde
-ls /dev/video*
-```
-
-v4l2 kullanarak scrpy kullanmaya başlamak için:
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # ayna penceresini kapatarak
-scrcpy --v4l2-sink=/dev/videoN -N            # kısa versiyon
-```
-
-(`N` harfini oluşturulan cihaz ID numarası ile değiştirin. `ls /dev/video*` cihaz ID'lerini görebilirsiniz.)
-
-Aktifleştirildikten sonra video akışını herhangi bir v4l2 özellikli araçla açabilirsiniz:
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLC kullanırken yükleme gecikmesi olabilir
-```
-
-Örneğin, [OBS] ile video akışını kullanabilirsiniz.
-
-[obs]: https://obsproject.com/
-
-### Bağlantı
-
-#### Kablosuz
-
-_Scrcpy_ cihazla iletişim kurmak için `adb`'yi kullanır, Ve `adb`
-bir cihaza TCP/IP kullanarak [bağlanabilir].
-
-1. Cihazınızı bilgisayarınızla aynı Wi-Fi ağına bağlayın.
-2. Cihazınızın IP adresini bulun. Ayarlar → Telefon Hakkında → Durum sekmesinden veya
-   aşağıdaki komutu çalıştırarak öğrenebilirsiniz:
-
-   ```bash
-   adb shell ip route | awk '{print $9}'
-   ```
-
-3. Cihazınızda TCP/IP üzerinden adb kullanımını etkinleştirin: `adb tcpip 5555`.
-4. Cihazınızı bilgisayarınızdan sökün.
-5. Cihazınıza bağlanın: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` değerini değiştirin)_.
-6. `scrcpy` komutunu normal olarak çalıştırın.
-
-Bit-oranını ve büyüklüğü azaltmak yararlı olabilir:
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # kısa version
-```
-
-[bağlanabilir]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-#### Birden fazla cihaz
-
-Eğer `adb devices` komutu birden fazla cihaz listeliyorsa _serial_ değerini belirtmeniz gerekir:
-
-```bash
-scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # kısa versiyon
-```
-
-Eğer cihaz TCP/IP üzerinden bağlanmışsa:
-
-```bash
-scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # kısa version
-```
-
-Birden fazla cihaz için birden fazla _scrcpy_ uygulaması çalıştırabilirsiniz.
-
-#### Cihaz bağlantısı ile otomatik başlatma
-
-[AutoAdb] ile yapılabilir:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[autoadb]: https://github.com/rom1v/autoadb
-
-#### SSH Tünel
-
-Uzaktaki bir cihaza erişmek için lokal `adb` istemcisi, uzaktaki bir `adb` sunucusuna
-(aynı _adb_ sürümünü kullanmak şartı ile) bağlanabilir :
-
-```bash
-adb kill-server    # 5037 portunda çalışan lokal adb sunucusunu kapat
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# bunu açık tutun
-```
-
-Başka bir terminalde:
-
-```bash
-scrcpy
-```
-
-Uzaktan port yönlendirme ileri yönlü bağlantı kullanabilirsiniz
-(`-R` yerine `-L` olduğuna dikkat edin):
-
-```bash
-adb kill-server    # 5037 portunda çalışan lokal adb sunucusunu kapat
-ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
-# bunu açık tutun
-```
-
-Başka bir terminalde:
-
-```bash
-scrcpy --force-adb-forward
-```
-
-Kablosuz bağlantı gibi burada da kalite düşürmek faydalı olabilir:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-### Pencere ayarları
-
-#### İsim
-
-Cihaz modeli varsayılan pencere ismidir. Değiştirmek için:
-
-```bash
-scrcpy --window-title 'Benim cihazım'
-```
-
-#### Konum ve
-
-Pencerenin başlangıç konumu ve boyutu belirtilebilir:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-#### Kenarlıklar
-
-Pencere dekorasyonunu kapatmak için:
-
-```bash
-scrcpy --window-borderless
-```
-
-#### Her zaman üstte
-
-Scrcpy penceresini her zaman üstte tutmak için:
-
-```bash
-scrcpy --always-on-top
-```
-
-#### Tam ekran
-
-Uygulamayı tam ekran başlatmak için:
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # kısa versiyon
-```
-
-Tam ekran <kbd>MOD</kbd>+<kbd>f</kbd> ile dinamik olarak değiştirilebilir.
-
-#### Döndürme
-
-Pencere döndürülebilir:
-
-```bash
-scrcpy --rotation 1
-```
-
-Seçilebilecek değerler:
-
- `0`: döndürme yok
- `1`: 90 derece saat yönünün tersi
- `2`: 180 derece
- `3`: 90 derece saat yönü
-
-Döndürme <kbd>MOD</kbd>+<kbd>←</kbd>_(sol)_ ve
-<kbd>MOD</kbd>+<kbd>→</kbd> _(sağ)_ ile dinamik olarak değiştirilebilir.
-
-_scrcpy_'de 3 farklı döndürme olduğuna dikkat edin:
-
- <kbd>MOD</kbd>+<kbd>r</kbd> cihazın yatay veya dikey modda çalışmasını sağlar.
-  (çalışan uygulama istenilen oryantasyonda çalışmayı desteklemiyorsa döndürme
-  işlemini reddedebilir.)
- [`--lock-video-orientation`](#lock-video-orientation) görüntü yakalama oryantasyonunu
-  (cihazdan bilgisayara gelen video akışının oryantasyonu) değiştirir. Bu kayıt işlemini
-  etkiler.
- `--rotation` (or <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
-  pencere içeriğini dönderir. Bu sadece canlı görüntüyü etkiler, kayıt işlemini etkilemez.
-
-### Diğer ekran yakalama seçenekleri
-
-#### Yazma korumalı
-
-Kontrolleri devre dışı bırakmak için (cihazla etkileşime geçebilecek her şey: klavye ve
-fare girdileri, dosya sürükleyip bırakma):
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-#### Ekran
-
-Eğer cihazın birden fazla ekranı varsa hangi ekranın kullanılacağını seçebilirsiniz:
-
-```bash
-scrcpy --display 1
-```
-
-Kullanılabilecek ekranları listelemek için:
-
-```bash
-adb shell dumpsys display   # çıktı içerisinde "mDisplayId=" terimini arayın
-```
-
-İkinci ekran ancak cihaz Android sürümü 10 veya üzeri olmalıdır (değilse yazma korumalı
-olarak görüntülenir).
-
-#### Uyanık kalma
-
-Cihazın uyku moduna girmesini engellemek için:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w
-```
-
-scrcpy kapandığında cihaz başlangıç durumuna geri döner.
-
-#### Ekranı kapatma
-
-Ekran yakalama sırasında cihazın ekranı kapatılabilir:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-Ya da <kbd>MOD</kbd>+<kbd>o</kbd> kısayolunu kullanabilirsiniz.
-
-Tekrar açmak için ise <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd> tuşlarına basın.
-
-Android'de, `GÜÇ` tuşu her zaman ekranı açar. Eğer `GÜÇ` sinyali scrcpy ile
-gönderilsiyse (sağ tık veya <kbd>MOD</kbd>+<kbd>p</kbd>), ekran kısa bir gecikme
-ile kapanacaktır. Fiziksel `GÜÇ` tuşuna basmak hala ekranın açılmasına sebep olacaktır.
-
-Bu cihazın uykuya geçmesini engellemek için kullanılabilir:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw
-```
-
-#### Dokunuşları gösterme
-
-Sunumlar sırasında fiziksel dokunuşları (fiziksel cihazdaki) göstermek
-faydalı olabilir.
-
-Android'de bu özellik _Geliştici seçenekleri_ içerisinde bulunur.
-
-_Scrcpy_ bu özelliği çalışırken etkinleştirebilir ve kapanırken eski
-haline geri getirebilir:
-
-```bash
-scrcpy --show-touches
-scrcpy -t
-```
-
-Bu opsiyon sadece _fiziksel_ dokunuşları (cihaz ekranındaki) gösterir.
-
-#### Ekran koruyucuyu devre dışı bırakma
-
-Scrcpy varsayılan ayarlarında ekran koruyucuyu devre dışı bırakmaz.
-
-Bırakmak için:
-
-```bash
-scrcpy --disable-screensaver
-```
-
-### Girdi kontrolü
-
-#### Cihaz ekranını dönderme
-
-<kbd>MOD</kbd>+<kbd>r</kbd> tuşları ile yatay ve dikey modlar arasında
-geçiş yapabilirsiniz.
-
-Bu kısayol ancak çalışan uygulama desteklediği takdirde ekranı döndürecektir.
-
-#### Kopyala yapıştır
-
-Ne zaman Android cihazdaki pano değişse bilgisayardaki pano otomatik olarak
-senkronize edilir.
-
-Tüm <kbd>Ctrl</kbd> kısayolları cihaza iletilir:
-
- <kbd>Ctrl</kbd>+<kbd>c</kbd> genelde kopyalar
- <kbd>Ctrl</kbd>+<kbd>x</kbd> genelde keser
- <kbd>Ctrl</kbd>+<kbd>v</kbd> genelde yapıştırır (bilgisayar ve cihaz arasındaki
-  pano senkronizasyonundan sonra)
-
-Bu kısayollar genelde beklediğiniz gibi çalışır.
-
-Ancak kısayolun gerçekten yaptığı eylemi açık olan uygulama belirler.
-Örneğin, _Termux_ <kbd>Ctrl</kbd>+<kbd>c</kbd> ile kopyalama yerine
-SIGINT sinyali gönderir, _K-9 Mail_ ise yeni mesaj oluşturur.
-
-Bu tip durumlarda kopyalama, kesme ve yapıştırma için (Android versiyon 7 ve
-üstü):
-
- <kbd>MOD</kbd>+<kbd>c</kbd> `KOPYALA`
- <kbd>MOD</kbd>+<kbd>x</kbd> `KES`
- <kbd>MOD</kbd>+<kbd>v</kbd> `YAPIŞTIR` (bilgisayar ve cihaz arasındaki
-  pano senkronizasyonundan sonra)
-
-Bunlara ek olarak, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> tuşları
-bilgisayar pano içeriğini tuş basma eylemleri şeklinde gönderir. Bu metin
-yapıştırmayı desteklemeyen (_Termux_ gibi) uygulamar için kullanışlıdır,
-ancak ASCII olmayan içerikleri bozabilir.
-
-**UYARI:** Bilgisayar pano içeriğini cihaza yapıştırmak
-(<kbd>Ctrl</kbd>+<kbd>v</kbd> ya da <kbd>MOD</kbd>+<kbd>v</kbd> tuşları ile)
-içeriği cihaz panosuna kopyalar. Sonuç olarak, herhangi bir Android uygulaması
-içeriğe erişebilir. Hassas içerikler (parolalar gibi) için bu özelliği kullanmaktan
-kaçının.
-
-Bazı cihazlar pano değişikleri konusunda beklenilen şekilde çalışmayabilir.
-Bu durumlarda `--legacy-paste` argümanı kullanılabilir. Bu sayede
-<kbd>Ctrl</kbd>+<kbd>v</kbd> ve <kbd>MOD</kbd>+<kbd>v</kbd> tuşları da
-pano içeriğini tuş basma eylemleri şeklinde gönderir
-(<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> ile aynı şekilde).
-
-#### İki parmak ile yakınlaştırma
-
-"İki parmak ile yakınlaştırma" için: <kbd>Ctrl</kbd>+_tıkla-ve-sürükle_.
-
-Daha açıklayıcı şekilde, <kbd>Ctrl</kbd> tuşuna sol-tık ile birlikte basılı
-tutun. Sol-tık serbest bırakılıncaya kadar yapılan tüm fare hareketleri
-ekran içeriğini ekranın merkezini baz alarak dönderir, büyütür veya küçültür
-(eğer uygulama destekliyorsa).
-
-Scrcpy ekranın merkezinde bir "sanal parmak" varmış gibi davranır.
-
-#### Metin gönderme tercihi
-
-Metin girilirken ili çeşit [eylem][textevents] gerçekleştirilir:
-
- _tuş eylemleri_, bir tuşa basıldığı sinyalini verir;
- _metin eylemleri_, bir metin girildiği sinyalini verir.
-
-Varsayılan olarak, harfler tuş eylemleri kullanılarak gönderilir. Bu sayede
-klavye oyunlarda beklenilene uygun olarak çalışır (Genelde WASD tuşları).
-
-Ancak bu [bazı problemlere][prefertext] yol açabilir. Eğer bu problemler ile
-karşılaşırsanız metin eylemlerini tercih edebilirsiniz:
-
-```bash
-scrcpy --prefer-text
-```
-
-(Ama bu oyunlardaki klavye davranışlarını bozacaktır)
-
-[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
-[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-
-#### Tuş tekrarı
-
-Varsayılan olarak, bir tuşa basılı tutmak tuş eylemini tekrarlar. Bu durum
-bazı oyunlarda problemlere yol açabilir.
-
-Tuş eylemlerinin tekrarını kapatmak için:
-
-```bash
-scrcpy --no-key-repeat
-```
-
-#### Sağ-tık ve Orta-tık
-
-Varsayılan olarak, sağ-tık GERİ (ya da GÜÇ açma) eylemlerini, orta-tık ise
-ANA EKRAN eylemini tetikler. Bu kısayolları devre dışı bırakmak için:
-
-```bash
-scrcpy --forward-all-clicks
-```
-
-### Dosya bırakma
-
-#### APK kurulumu
-
-APK kurmak için, bilgisayarınızdaki APK dosyasını (`.apk` ile biten) _scrcpy_
-penceresine sürükleyip bırakın.
-
-Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır.
-
-#### Dosyayı cihaza gönderme
-
-Bir dosyayı cihazdaki `/sdcard/Download/` dizinine atmak için, (APK olmayan)
-bir dosyayı _scrcpy_ penceresine sürükleyip bırakın.
-
-Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır.
-
-Hedef dizin uygulama başlatılırken değiştirilebilir:
-
-```bash
-scrcpy --push-target=/sdcard/Movies/
-```
-
-### Ses iletimi
-
-_Scrcpy_ ses iletimi yapmaz. Yerine [sndcpy] kullanabilirsiniz.
-
-Ayrıca bakınız [issue #14].
-
-[sndcpy]: https://github.com/rom1v/sndcpy
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
-
-## Kısayollar
-
-Aşağıdaki listede, <kbd>MOD</kbd> kısayol tamamlayıcısıdır. Varsayılan olarak
-(sol) <kbd>Alt</kbd> veya (sol) <kbd>Super</kbd> tuşudur.
-
-Bu tuş `--shortcut-mod` argümanı kullanılarak `lctrl`, `rctrl`,
-`lalt`, `ralt`, `lsuper` ve `rsuper` tuşlarından biri ile değiştirilebilir.
-Örneğin:
-
-```bash
-# Sağ Ctrl kullanmak için
-scrcpy --shortcut-mod=rctrl
-
-# Sol Ctrl, Sol Alt veya Sol Super tuşlarından birini kullanmak için
-scrcpy --shortcut-mod=lctrl+lalt,lsuper
-```
-
-_<kbd>[Super]</kbd> tuşu genelde <kbd>Windows</kbd> veya <kbd>Cmd</kbd> tuşudur._
-
-[super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
-
-| Action                                           | Shortcut                                                  |
-| ------------------------------------------------ | :-------------------------------------------------------- |
-| Tam ekran modunu değiştirme                      | <kbd>MOD</kbd>+<kbd>f</kbd>                               |
-| Ekranı sola çevirme                              | <kbd>MOD</kbd>+<kbd>←</kbd> _(sol)_                       |
-| Ekranı sağa çevirme                              | <kbd>MOD</kbd>+<kbd>→</kbd> _(sağ)_                       |
-| Pencereyi 1:1 oranına çevirme (pixel-perfect)    | <kbd>MOD</kbd>+<kbd>g</kbd>                               |
-| Penceredeki siyah kenarlıkları kaldırma          | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Çift-sol-tık¹_            |
-| `ANA EKRAN` tuşu                                 | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Orta-tık_                 |
-| `GERİ` tuşu                                      | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Sağ-tık²_                 |
-| `UYGULAMA_DEĞİŞTİR` tuşu                         | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4.tık³_                   |
-| `MENÜ` tuşu (ekran kilidini açma)                | <kbd>MOD</kbd>+<kbd>m</kbd>                               |
-| `SES_AÇ` tuşu                                    | <kbd>MOD</kbd>+<kbd>↑</kbd> _(yukarı)_                    |
-| `SES_KIS` tuşu                                   | <kbd>MOD</kbd>+<kbd>↓</kbd> _(aşağı)_                     |
-| `GÜÇ` tuşu                                       | <kbd>MOD</kbd>+<kbd>p</kbd>                               |
-| Gücü açma                                        | _Sağ-tık²_                                                |
-| Cihaz ekranını kapatma (ekran yakalama durmadan) | <kbd>MOD</kbd>+<kbd>o</kbd>                               |
-| Cihaz ekranını açma                              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>              |
-| Cihaz ekranını dönderme                          | <kbd>MOD</kbd>+<kbd>r</kbd>                               |
-| Bildirim panelini genişletme                     | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5.tık³_                   |
-| Ayarlar panelini genişletme                      | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Çift-5.tık³_ |
-| Panelleri kapatma                                | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>              |
-| Panoya kopyalama⁴                                | <kbd>MOD</kbd>+<kbd>c</kbd>                               |
-| Panoya kesme⁴                                    | <kbd>MOD</kbd>+<kbd>x</kbd>                               |
-| Panoları senkronize ederek yapıştırma⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>                               |
-| Bilgisayar panosundaki metini girme              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>              |
-| FPS sayacını açma/kapatma (terminalde)           | <kbd>MOD</kbd>+<kbd>i</kbd>                               |
-| İki parmakla yakınlaştırma                       | <kbd>Ctrl</kbd>+_tıkla-ve-sürükle_                        |
-
-_¹Siyah kenarlıkları silmek için üzerine çift tıklayın._  
-_²Sağ-tık ekran kapalıysa açar, değilse GERİ sinyali gönderir._  
-_³4. ve 5. fare tuşları (eğer varsa)._  
-_⁴Sadece Android 7 ve üzeri versiyonlarda._
-
-Tekrarlı tuşu olan kısayollar tuş bırakılıp tekrar basılarak tekrar çalıştırılır.
-Örneğin, "Ayarlar panelini genişletmek" için:
-
-1.  <kbd>MOD</kbd> tuşuna basın ve basılı tutun.
-2.  <kbd>n</kbd> tuşuna iki defa basın.
-3.  <kbd>MOD</kbd> tuşuna basmayı bırakın.
-
-Tüm <kbd>Ctrl</kbd>+_tuş_ kısayolları cihaza gönderilir. Bu sayede istenilen komut
-uygulama tarafından çalıştırılır.
-
-## Özel dizinler
-
-Varsayılandan farklı bir _adb_ programı çalıştırmak için `ADB` ortam değişkenini
-ayarlayın:
-
-```bash
-ADB=/path/to/adb scrcpy
-```
-
-`scrcpy-server` programının dizinini değiştirmek için `SCRCPY_SERVER_PATH`
-değişkenini ayarlayın.
-
-[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
-
-## Neden _scrcpy_?
-
-Bir meslektaşım [gnirehtet] gibi söylenmesi zor bir isim bulmam için bana meydan okudu.
-
-[`strcpy`] **str**ing kopyalıyor; `scrcpy` **scr**een kopyalıyor.
-
-[gnirehtet]: https://github.com/Genymobile/gnirehtet
-[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
-
-## Nasıl derlenir?
-
-Bakınız [BUILD].
-
-## Yaygın problemler
-
-Bakınız [FAQ](FAQ.md).
-
-## Geliştiriciler
-
-[Geliştiriciler sayfası]nı okuyun.
-
-[geliştiriciler sayfası]: DEVELOP.md
-
-## Lisans
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## Makaleler
-
- [Introducing scrcpy][article-intro]
- [Scrcpy now works wirelessly][article-tcpip]
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.zh-Hans.md
+++ b/README.zh-Hans.md
--- a/README.zh-Hant.md
+++ b/README.zh-Hant.md
@ -80,7 +80,10 @@ apt install scrcpy

 為了保持簡單，Windows 用戶可以下載一個包含所有必需軟體 (包含 `adb`) 的壓縮包:

- - [README](README.md#windows)
+- [`scrcpy-win64-v1.15.zip`][direct-win64]  
+   _(SHA-256: dd514bb591e63ef4cd52a53c30f1153a28f59722d64690eb07bd017849edcba2)_
+
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.15/scrcpy-win64-v1.15.zip

 [Chocolatey] 上也可以下載:

@ -679,7 +682,7 @@ _³只支援 Android 7+。_
 ## Licence

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2022 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
--- a/app/data/bash-completion/scrcpy
+++ b/app/data/bash-completion/scrcpy
@ -1,122 +0,0 @@
-_scrcpy() {
-    local cur prev words cword
-    local opts="
-        --always-on-top
-        -b --bit-rate=
-        --codec-options=
-        --crop=
-        -d --select-usb
-        --disable-screensaver
-        --display=
-        --display-buffer=
-        -e --select-tcpip
-        --encoder=
-        --force-adb-forward
-        --forward-all-clicks
-        -f --fullscreen
-        -K --hid-keyboard
-        -h --help
-        --legacy-paste
-        --lock-video-orientation
-        --lock-video-orientation=
-        --max-fps=
-        -M --hid-mouse
-        -m --max-size=
-        --no-cleanup
-        --no-clipboard-on-error
-        --no-downsize-on-error
-        -n --no-control
-        -N --no-display
-        --no-key-repeat
-        --no-mipmaps
-        --no-power-on
-        --otg
-        -p --port=
-        --power-off-on-close
-        --prefer-text
-        --print-fps
-        --push-target=
-        --raw-key-events
-        -r --record=
-        --record-format=
-        --render-driver=
-        --rotation=
-        -s --serial=
-        --shortcut-mod=
-        -S --turn-screen-off
-        -t --show-touches
-        --tcpip
-        --tcpip=
-        --tunnel-host=
-        --tunnel-port=
-        --v4l2-buffer=
-        --v4l2-sink=
-        -V --verbosity=
-        -v --version
-        -w --stay-awake
-        --window-borderless
-        --window-title=
-        --window-x=
-        --window-y=
-        --window-width=
-        --window-height="
-
-    _init_completion -s || return
-
-    case "$prev" in
-        --lock-video-orientation)
-            COMPREPLY=($(compgen -W 'unlocked initial 0 1 2 3' -- "$cur"))
-            return
-            ;;
-        -r|--record)
-            COMPREPLY=($(compgen -f -- "$cur"))
-            return
-            ;;
-        --record-format)
-            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"))
-            return
-            ;;
-        -V|--verbosity)
-            COMPREPLY=($(compgen -W 'verbose debug info warn error' -- "$cur"))
-            return
-            ;;
-        -b|--bitrate \
-        |--codec-options \
-        |--crop \
-        |--display \
-        |--display-buffer \
-        |--encoder \
-        |--max-fps \
-        |-m|--max-size \
-        |-p|--port \
-        |--push-target \
-        |-s|--serial \
-        |--tunnel-host \
-        |--tunnel-port \
-        |--v4l2-buffer \
-        |--v4l2-sink \
-        |--tcpip \
-        |--window-*)
-            # Option accepting an argument, but nothing to auto-complete
-            return
-            ;;
-    esac
-
-    COMPREPLY=($(compgen -W "$opts" -- "$cur"))
-    [[ $COMPREPLY == *= ]] && compopt -o nospace
-}
-
-complete -F _scrcpy scrcpy
--- a/app/data/icon.ico
+++ b/app/data/icon.ico
--- a/app/data/icon.png
+++ b/app/data/icon.png
--- a/app/data/icon.svg
+++ b/app/data/icon.svg
@ -1,16 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" version="1.1">
- <path style="opacity:0.2" d="m 16.846877,12 c -1.116351,0 -2.227419,0.912229 -2.015075,2 l 3.122973,16 -5.596557,11.109375 C 11.959876,41.871734 11.885244,42.336988 12.177176,43 c 0.278672,0.632897 0.998812,1 1.747448,1 H 24 34.075375 c 0.748637,0 1.468777,-0.367103 1.747448,-1 0.291932,-0.663012 0.217302,-1.128266 -0.181041,-1.890625 L 30.045225,30 33.168198,14 c 0.212344,-1.087771 -0.898724,-2 -2.015075,-2 H 24 Z"/>
- <path style="fill:#cccccc" d="m 16.846877,11 c -1.116351,0 -2.227419,0.912229 -2.015075,2 l 3.122973,16 -5.596557,11.109375 C 11.959876,40.871734 11.885244,41.336988 12.177176,42 c 0.278672,0.632897 0.998812,1 1.747448,1 H 24 34.075375 c 0.748637,0 1.468777,-0.367103 1.747448,-1 0.291932,-0.663012 0.217302,-1.128266 -0.181041,-1.890625 L 30.045225,29 33.168198,13 c 0.212344,-1.087771 -0.898724,-2 -2.015075,-2 H 24 Z"/>
- <rect style="opacity:0.2" width="40" height="32" x="4" y="6" rx="2" ry="2"/>
- <path style="fill:#e4e4e4" d="m 4,33 v 2 c 0,1.108 0.892,2 2,2 h 36 c 1.108,0 2,-0.892 2,-2 v -2 z"/>
- <path style="opacity:0.1" d="m 11.494141,15 a 1.5,1.5 0 0 0 -0.832032,0.255859 1.5,1.5 0 0 0 -0.40625,2.082032 l 3.13086,4.654297 C 10.404945,24.606192 8.4012371,28.299159 8.0019531,32.460938 7.9284599,34.000879 9.5546875,34 9.5546875,34 H 38.40625 c 0,0 1.672856,-3.38e-4 1.591797,-1.617188 -0.416529,-4.131451 -2.415618,-7.796833 -5.380859,-10.394531 l 3.126953,-4.65039 a 1.5,1.5 0 0 0 -0.40625,-2.082032 1.5,1.5 0 0 0 -1.125,-0.228515 1.5,1.5 0 0 0 -0.957032,0.634765 l -3.072265,4.566407 C 29.78649,18.814887 26.990024,18 24.001953,18 c -2.989385,0 -5.786177,0.815488 -8.183594,2.230469 l -3.074218,-4.56836 A 1.5,1.5 0 0 0 11.787109,15.027344 1.5,1.5 0 0 0 11.494141,15 Z"/>
- <path style="fill:#077063" d="M 6,5 C 4.892,5 4,5.892 4,7 V 33 H 44 V 7 C 44,5.892 43.108,5 42,5 Z"/>
- <path style="opacity:0.1;fill:#ffffff" d="M 6,5 C 4.892,5 4,5.892 4,7 V 8 C 4,6.892 4.892,6 6,6 h 36 c 1.108,0 2,0.892 2,2 V 7 C 44,5.892 43.108,5 42,5 Z"/>
- <path style="fill:none;stroke:#30dd81;stroke-width:3;stroke-linecap:round" d="M 15.1998,21.000026 11.5,15.5"/>
- <path style="fill:none;stroke:#30dd81;stroke-width:3;stroke-linecap:round" d="M 32.799764,21.000026 36.5,15.5"/>
- <path style="fill:#30dd81" d="m 24.002386,17.000034 c -8.355868,0 -15.2214979,6.346843 -15.9999669,14.460906 C 7.9289259,33.000882 9.5544999,33 9.5544999,33 H 38.406003 c 0,0 1.672201,-3.35e-4 1.591142,-1.617185 C 39.182807,23.305596 32.331836,17.000034 24.002386,17.000034 Z"/>
- <path style="opacity:0.2" d="m 16,25 a 1.9999959,1.9999959 0 0 0 -2,2 1.9999959,1.9999959 0 0 0 2,2 1.9999959,1.9999959 0 0 0 2,-2 1.9999959,1.9999959 0 0 0 -2,-2 z m 16,0 a 1.9999959,1.9999959 0 0 0 -2,2 1.9999959,1.9999959 0 0 0 2,2 1.9999959,1.9999959 0 0 0 2,-2 1.9999959,1.9999959 0 0 0 -2,-2 z"/>
- <path style="fill:#ffffff" d="M 15.999996,24.000008 A 1.9999959,1.9999959 0 0 1 17.999992,26.000004 1.9999959,1.9999959 0 0 1 15.999996,28 1.9999959,1.9999959 0 0 1 14,26.000004 1.9999959,1.9999959 0 0 1 15.999996,24.000008 Z"/>
- <path style="fill:#ffffff" d="M 31.999996,24.000008 A 1.9999959,1.9999959 0 0 1 33.999991,26.000004 1.9999959,1.9999959 0 0 1 31.999996,28 1.9999959,1.9999959 0 0 1 30,26.000004 1.9999959,1.9999959 0 0 1 31.999996,24.000008 Z"/>
- <path style="fill:#ffffff;opacity:0.2" d="M 11.494141 14 A 1.5 1.5 0 0 0 10.662109 14.255859 A 1.5 1.5 0 0 0 10.115234 16.001953 A 1.5 1.5 0 0 1 10.662109 15.255859 A 1.5 1.5 0 0 1 11.494141 15 A 1.5 1.5 0 0 1 11.787109 15.027344 A 1.5 1.5 0 0 1 12.744141 15.662109 L 15.818359 20.230469 C 18.215776 18.815488 21.012568 18 24.001953 18 C 26.990024 18 29.78649 18.814887 32.183594 20.228516 L 35.255859 15.662109 A 1.5 1.5 0 0 1 36.212891 15.027344 A 1.5 1.5 0 0 1 37.337891 15.255859 A 1.5 1.5 0 0 1 37.910156 16.001953 A 1.5 1.5 0 0 0 37.337891 14.255859 A 1.5 1.5 0 0 0 36.212891 14.027344 A 1.5 1.5 0 0 0 35.255859 14.662109 L 32.183594 19.228516 C 29.78649 17.814887 26.990024 17 24.001953 17 C 21.012568 17 18.215776 17.815488 15.818359 19.230469 L 12.744141 14.662109 A 1.5 1.5 0 0 0 11.787109 14.027344 A 1.5 1.5 0 0 0 11.494141 14 z M 35.033203 21.369141 L 34.617188 21.988281 C 37.477056 24.493668 39.433905 27.993356 39.943359 31.945312 C 39.986866 31.783283 40.008864 31.598575 39.998047 31.382812 C 39.601372 27.448291 37.768055 23.938648 35.033203 21.369141 z M 12.970703 21.373047 C 10.220358 23.959215 8.3822757 27.496796 8.0019531 31.460938 C 7.9920657 31.668114 8.0150508 31.844846 8.0585938 32 C 8.5570234 28.027243 10.515755 24.509049 13.386719 21.992188 L 12.970703 21.373047 z"/>
-</svg>
--- a/app/data/open_a_terminal_here.bat
+++ b/app/data/open_a_terminal_here.bat
@ -1 +0,0 @@
-@cmd
--- a/app/data/scrcpy-noconsole.vbs
+++ b/app/data/scrcpy-noconsole.vbs
@ -1,7 +0,0 @@
-strCommand = "cmd /c scrcpy.exe"
-
-For Each Arg In WScript.Arguments
-    strCommand = strCommand & " """ & replace(Arg, """", """""""""") & """"
-Next
-
-CreateObject("Wscript.Shell").Run strCommand, 0, false
--- a/app/data/zsh-completion/_scrcpy
+++ b/app/data/zsh-completion/_scrcpy
@ -1,70 +0,0 @@
-#compdef -N scrcpy -N scrcpy.exe
-#
-# name: scrcpy
-# auth: hltdev [hltdev8642@gmail.com]
-# desc: completion file for scrcpy (all OSes)
-#
-
-local arguments
-
-arguments=(
-    '--always-on-top[Make scrcpy window always on top \(above other windows\)]'
-    {-b,--bit-rate=}'[Encode the video at the given bit-rate]'
-    '--codec-options=[Set a list of comma-separated key\:type=value options for the device encoder]'
-    '--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]'
-    {-e,--select-tcpip}'[Use TCP/IP device]'
-    '--encoder=[Use a specific MediaCodec encoder \(must be a H.264 encoder\)]'
-    '--force-adb-forward[Do not attempt to use \"adb reverse\" to connect to the device]'
-    '--forward-all-clicks[Forward clicks to device]'
-    {-f,--fullscreen}'[Start in fullscreen]'
-    {-K,--hid-keyboard}'[Simulate a physical keyboard by using HID over AOAv2]'
-    {-h,--help}'[Print the help]'
-    '--legacy-paste[Inject computer clipboard text as a sequence of key events on Ctrl+v]'
-    '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 1 2 3)'
-    '--max-fps=[Limit the frame rate of screen capture]'
-    {-M,--hid-mouse}'[Simulate a physical mouse by using HID over AOAv2]'
-    {-m,--max-size=}'[Limit both the width and height of the video to value]'
-    '--no-cleanup[Disable device cleanup actions on exit]'
-    '--no-clipboard-autosync[Disable automatic clipboard synchronization]'
-    '--no-downsize-on-error[Disable lowering definition on MediaCodec error]'
-    {-n,--no-control}'[Disable device control \(mirror the device in read only\)]'
-    {-N,--no-display}'[Do not display device \(during screen recording or when V4L2 sink is enabled\)]'
-    '--no-key-repeat[Do not forward repeated key events when a key is held down]'
-    '--no-mipmaps[Disable the generation of mipmaps]'
-    '--no-power-on[Do not power on the device on start]'
-    '--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]'
-    '--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]'
-    '--raw-key-events[Inject key events for all input keys, and ignore text events]'
-    {-r,--record=}'[Record screen to file]:record file:_files'
-    '--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)'
-    '--rotation=[Set the initial display rotation]:rotation values:(0 1 2 3)'
-    {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]'
-    '--shortcut-mod=[\[key1,key2+key3,...\] Specify the modifiers to use for scrcpy shortcuts]:shortcut mod:(lctrl rctrl lalt ralt lsuper rsuper)'
-    {-S,--turn-screen-off}'[Turn the device screen off immediately]'
-    {-t,--show-touches}'[Show physical touches]'
-    '--tcpip[\(optional \[ip\:port\]\) Configure and connect the device over TCP/IP]'
-    '--tunnel-host=[Set the IP address of the adb tunnel to reach the scrcpy server]'
-    '--tunnel-port=[Set the TCP port of the adb tunnel to reach the scrcpy server]'
-    '--v4l2-buffer=[Add a buffering delay \(in milliseconds\) before pushing frames]'
-    '--v4l2-sink=[\[\/dev\/videoN\] Output to v4l2loopback device]'
-    {-V,--verbosity=}'[Set the log level]:verbosity:(verbose debug info warn error)'
-    {-v,--version}'[Print the version of scrcpy]'
-    {-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]'
-    '--window-x=[Set the initial window horizontal position]'
-    '--window-y=[Set the initial window vertical position]'
-    '--window-width=[Set the initial window width]'
-    '--window-height=[Set the initial window height]'
-)
-
-_arguments -s $arguments
--- a/app/meson.build
+++ b/app/meson.build
@ -1,119 +1,61 @@
 src = [
    'src/main.c',
-    'src/adb/adb.c',
-    'src/adb/adb_device.c',
-    'src/adb/adb_parser.c',
-    'src/adb/adb_tunnel.c',
+    'src/adb.c',
    'src/cli.c',
-    'src/clock.c',
    'src/compat.c',
    'src/control_msg.c',
    'src/controller.c',
    'src/decoder.c',
-    'src/demuxer.c',
+    'src/device.c',
    'src/device_msg.c',
-    'src/icon.c',
-    'src/file_pusher.c',
+    'src/event_converter.c',
+    'src/file_handler.c',
    'src/fps_counter.c',
-    'src/frame_buffer.c',
    'src/input_manager.c',
-    'src/keyboard_inject.c',
-    'src/mouse_inject.c',
    'src/opengl.c',
-    'src/options.c',
    'src/receiver.c',
    'src/recorder.c',
    'src/scrcpy.c',
    'src/screen.c',
    'src/server.c',
-    'src/version.c',
+    'src/stream.c',
+    'src/tiny_xpm.c',
    'src/video_buffer.c',
-    'src/util/acksync.c',
-    'src/util/file.c',
-    'src/util/intmap.c',
-    'src/util/intr.c',
-    'src/util/log.c',
    'src/util/net.c',
-    'src/util/net_intr.c',
    'src/util/process.c',
-    'src/util/process_intr.c',
-    'src/util/strbuf.c',
-    'src/util/str.c',
-    'src/util/term.c',
+    'src/util/str_util.c',
    'src/util/thread.c',
-    'src/util/tick.c',
 ]

-conf = configuration_data()
-
-conf.set('_POSIX_C_SOURCE', '200809L')
-conf.set('_XOPEN_SOURCE', '700')
-conf.set('_GNU_SOURCE', true)
-
 if host_machine.system() == 'windows'
-    windows = import('windows')
-    src += [
-        'src/sys/win/file.c',
-        'src/sys/win/process.c',
-        windows.compile_resources('scrcpy-windows.rc'),
-    ]
-    conf.set('_WIN32_WINNT', '0x0600')
-    conf.set('WINVER', '0x0600')
+    src += [ 'src/sys/win/process.c' ]
 else
-    src += [
-        'src/sys/unix/file.c',
-        'src/sys/unix/process.c',
-    ]
-    if host_machine.system() == 'darwin'
-        conf.set('_DARWIN_C_SOURCE', true)
-    endif
+    src += [ 'src/sys/unix/process.c' ]
 endif

-v4l2_support = get_option('v4l2') and host_machine.system() == 'linux'
-if v4l2_support
-    src += [ 'src/v4l2_sink.c' ]
-endif
-
-usb_support = get_option('usb')
-if usb_support
-    src += [
-        'src/usb/aoa_hid.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',
-    ]
-endif
+check_functions = [
+    'strdup'
+]

 cc = meson.get_compiler('c')

-crossbuild_windows = meson.is_cross_build() and host_machine.system() == 'windows'
-
-if not crossbuild_windows
+if not get_option('crossbuild_windows')

    # native build
    dependencies = [
-        dependency('libavformat', version: '>= 57.33'),
-        dependency('libavcodec', version: '>= 57.37'),
+        dependency('libavformat'),
+        dependency('libavcodec'),
        dependency('libavutil'),
-        dependency('sdl2', version: '>= 2.0.5'),
+        dependency('sdl2'),
    ]

-    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_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
+    sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/lib'
+    sdl2_include_dir = '../prebuilt-deps/' + prebuilt_sdl2 + '/include'

    sdl2 = declare_dependency(
        dependencies: [
@ -123,40 +65,22 @@ else
        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 versions are different for win32 and win64 builds
-    ffmpeg_avcodec = meson.get_cross_property('ffmpeg_avcodec')
-    ffmpeg_avformat = meson.get_cross_property('ffmpeg_avformat')
-    ffmpeg_avutil = meson.get_cross_property('ffmpeg_avutil')
-
+    prebuilt_ffmpeg_shared = meson.get_cross_property('prebuilt_ffmpeg_shared')
+    prebuilt_ffmpeg_dev = meson.get_cross_property('prebuilt_ffmpeg_dev')
+    ffmpeg_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_ffmpeg_shared + '/bin'
+    ffmpeg_include_dir = '../prebuilt-deps/' + prebuilt_ffmpeg_dev + '/include'
    ffmpeg = declare_dependency(
        dependencies: [
-            cc.find_library(ffmpeg_avcodec, dirs: ffmpeg_bin_dir),
-            cc.find_library(ffmpeg_avformat, dirs: ffmpeg_bin_dir),
-            cc.find_library(ffmpeg_avutil, dirs: ffmpeg_bin_dir),
+            cc.find_library('avcodec-58', dirs: ffmpeg_bin_dir),
+            cc.find_library('avformat-58', dirs: ffmpeg_bin_dir),
+            cc.find_library('avutil-56', dirs: ffmpeg_bin_dir),
        ],
        include_directories: include_directories(ffmpeg_include_dir)
    )

-    prebuilt_libusb = meson.get_cross_property('prebuilt_libusb')
-    prebuilt_libusb_root = meson.get_cross_property('prebuilt_libusb_root')
-    libusb_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_libusb
-    libusb_include_dir = 'prebuilt-deps/data/' + prebuilt_libusb_root + '/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')
    ]

@ -166,11 +90,7 @@ if host_machine.system() == 'windows'
    dependencies += cc.find_library('ws2_32')
 endif

-check_functions = [
-    'strdup',
-    'asprintf',
-    'vasprintf',
-]
+conf = configuration_data()

 foreach f : check_functions
  if cc.has_function(f)
@ -179,8 +99,8 @@ foreach f : check_functions
  endif
 endforeach

-conf.set('HAVE_SOCK_CLOEXEC', host_machine.system() != 'windows' and
-                              cc.has_header_symbol('sys/socket.h', 'SOCK_CLOEXEC'))
+# expose the build type
+conf.set('NDEBUG', get_option('buildtype') != 'debug')

 # the version, updated on release
 conf.set_quoted('SCRCPY_VERSION', meson.project_version())
@ -197,22 +117,29 @@ conf.set('PORTABLE', get_option('portable'))
 conf.set('DEFAULT_LOCAL_PORT_RANGE_FIRST', '27183')
 conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')

+# the default max video size for both dimensions, in pixels
+# overridden by option --max-size
+conf.set('DEFAULT_MAX_SIZE', '0')  # 0: unlimited
+
+# the default video orientation
+# natural device orientation is 0 and each increment adds 90 degrees
+# counterclockwise
+# overridden by option --lock-video-orientation
+conf.set('DEFAULT_LOCK_VIDEO_ORIENTATION', '-1')  # -1: unlocked
+
 # the default video bitrate, in bits/second
 # overridden by option --bit-rate
 conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps

+# enable High DPI support
+conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
+
 # run a server debugger and wait for a client to be attached
 conf.set('SERVER_DEBUGGER', get_option('server_debugger'))

 # select the debugger method ('old' for Android < 9, 'new' for Android >= 9)
 conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == 'new')

-# enable V4L2 support (linux only)
-conf.set('HAVE_V4L2', v4l2_support)
-
-# enable HID over AOA support (linux only)
-conf.set('HAVE_USB', usb_support)
-
 configure_file(configuration: conf, output: 'config.h')

 src_dir = include_directories('src')
@ -224,13 +151,6 @@ executable('scrcpy', src,
           c_args: [])

 install_man('scrcpy.1')
-install_data('data/icon.png',
-             rename: 'scrcpy.png',
-             install_dir: 'share/icons/hicolor/256x256/apps')
-install_data('data/zsh-completion/_scrcpy',
-             install_dir: 'share/zsh/site-functions')
-install_data('data/bash-completion/scrcpy',
-             install_dir: 'share/bash-completion/completions')


 ### TESTS
@ -238,15 +158,8 @@ install_data('data/bash-completion/scrcpy',
 # do not build tests in release (assertions would not be executed at all)
 if get_option('buildtype') == 'debug'
    tests = [
-        ['test_adb_parser', [
-            'tests/test_adb_parser.c',
-            'src/adb/adb_device.c',
-            'src/adb/adb_parser.c',
-            'src/util/str.c',
-            'src/util/strbuf.c',
-        ]],
        ['test_buffer_util', [
-            'tests/test_buffer_util.c',
+            'tests/test_buffer_util.c'
        ]],
        ['test_cbuf', [
            'tests/test_cbuf.c',
@ -254,21 +167,12 @@ if get_option('buildtype') == 'debug'
        ['test_cli', [
            'tests/test_cli.c',
            'src/cli.c',
-            'src/options.c',
-            'src/util/net.c',
-            'src/util/str.c',
-            'src/util/strbuf.c',
-            'src/util/term.c',
-        ]],
-        ['test_clock', [
-            'tests/test_clock.c',
-            'src/clock.c',
+            'src/util/str_util.c',
        ]],
        ['test_control_msg_serialize', [
            'tests/test_control_msg_serialize.c',
            'src/control_msg.c',
-            'src/util/str.c',
-            'src/util/strbuf.c',
+            'src/util/str_util.c',
        ]],
        ['test_device_msg_deserialize', [
            'tests/test_device_msg_deserialize.c',
@ -277,17 +181,9 @@ if get_option('buildtype') == 'debug'
        ['test_queue', [
            'tests/test_queue.c',
        ]],
-        ['test_strbuf', [
-            'tests/test_strbuf.c',
-            'src/util/strbuf.c',
-        ]],
-        ['test_str', [
-            'tests/test_str.c',
-            'src/util/str.c',
-            'src/util/strbuf.c',
-        ]],
-        ['test_vector', [
-            'tests/test_vector.c',
+        ['test_strutil', [
+            'tests/test_strutil.c',
+            'src/util/str_util.c',
        ]],
    ]

--- a/app/prebuilt-deps/.gitignore
+++ b/app/prebuilt-deps/.gitignore
@ -1 +0,0 @@
-/data
--- a/app/prebuilt-deps/common
+++ b/app/prebuilt-deps/common
@ -1,22 +0,0 @@
-PREBUILT_DATA_DIR=data
-
-checksum() {
-    local file="$1"
-    local sum="$2"
-    echo "$file: verifying checksum..."
-    echo "$sum  $file" | sha256sum -c
-}
-
-get_file() {
-    local url="$1"
-    local file="$2"
-    local sum="$3"
-    if [[ -f "$file" ]]
-    then
-        echo "$file: found"
-    else
-        echo "$file: not found, downloading..."
-        wget "$url" -O "$file"
-    fi
-    checksum "$file" "$sum"
-}
--- a/app/prebuilt-deps/prepare-adb.sh
+++ b/app/prebuilt-deps/prepare-adb.sh
@ -1,32 +0,0 @@
-#!/usr/bin/env bash
-set -e
-DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DIR"
-. common
-mkdir -p "$PREBUILT_DATA_DIR"
-cd "$PREBUILT_DATA_DIR"
-
-DEP_DIR=platform-tools-33.0.1
-
-FILENAME=platform-tools_r33.0.1-windows.zip
-SHA256SUM=c1f02d42ea24ef4ff2a405ae7370e764ef4546f9b3e4520f5571a00ed5012c42
-
-if [[ -d "$DEP_DIR" ]]
-then
-    echo "$DEP_DIR" found
-    exit 0
-fi
-
-get_file "https://dl.google.com/android/repository/$FILENAME" \
-    "$FILENAME" "$SHA256SUM"
-
-mkdir "$DEP_DIR"
-cd "$DEP_DIR"
-
-ZIP_PREFIX=platform-tools
-unzip "../$FILENAME" \
-    "$ZIP_PREFIX"/AdbWinApi.dll \
-    "$ZIP_PREFIX"/AdbWinUsbApi.dll \
-    "$ZIP_PREFIX"/adb.exe
-mv "$ZIP_PREFIX"/* .
-rmdir "$ZIP_PREFIX"
--- a/app/prebuilt-deps/prepare-ffmpeg-win32.sh
+++ b/app/prebuilt-deps/prepare-ffmpeg-win32.sh
@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-set -e
-DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DIR"
-. common
-mkdir -p "$PREBUILT_DATA_DIR"
-cd "$PREBUILT_DATA_DIR"
-
-DEP_DIR=ffmpeg-win32-4.3.1
-
-FILENAME_SHARED=ffmpeg-4.3.1-win32-shared.zip
-SHA256SUM_SHARED=357af9901a456f4dcbacd107e83a934d344c9cb07ddad8aaf80612eeab7d26d2
-
-FILENAME_DEV=ffmpeg-4.3.1-win32-dev.zip
-SHA256SUM_DEV=230efb08e9bcf225bd474da29676c70e591fc94d8790a740ca801408fddcb78b
-
-if [[ -d "$DEP_DIR" ]]
-then
-    echo "$DEP_DIR" found
-    exit 0
-fi
-
-get_file "https://github.com/Genymobile/scrcpy/releases/download/v1.16/$FILENAME_SHARED" \
-    "$FILENAME_SHARED" "$SHA256SUM_SHARED"
-get_file "https://github.com/Genymobile/scrcpy/releases/download/v1.16/$FILENAME_DEV" \
-    "$FILENAME_DEV" "$SHA256SUM_DEV"
-
-mkdir "$DEP_DIR"
-cd "$DEP_DIR"
-
-ZIP_PREFIX_SHARED=ffmpeg-4.3.1-win32-shared
-unzip "../$FILENAME_SHARED" \
-    "$ZIP_PREFIX_SHARED"/bin/avutil-56.dll \
-    "$ZIP_PREFIX_SHARED"/bin/avcodec-58.dll \
-    "$ZIP_PREFIX_SHARED"/bin/avformat-58.dll \
-    "$ZIP_PREFIX_SHARED"/bin/swresample-3.dll \
-    "$ZIP_PREFIX_SHARED"/bin/swscale-5.dll
-
-ZIP_PREFIX_DEV=ffmpeg-4.3.1-win32-dev
-unzip "../$FILENAME_DEV" \
-    "$ZIP_PREFIX_DEV/include/*"
-
-mv "$ZIP_PREFIX_SHARED"/* .
-mv "$ZIP_PREFIX_DEV"/* .
-rmdir "$ZIP_PREFIX_SHARED" "$ZIP_PREFIX_DEV"
--- a/app/prebuilt-deps/prepare-ffmpeg-win64.sh
+++ b/app/prebuilt-deps/prepare-ffmpeg-win64.sh
@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-set -e
-DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DIR"
-. common
-mkdir -p "$PREBUILT_DATA_DIR"
-cd "$PREBUILT_DATA_DIR"
-
-VERSION=5.0.1
-DEP_DIR=ffmpeg-win64-$VERSION
-
-FILENAME=ffmpeg-$VERSION-full_build-shared.7z
-SHA256SUM=ded28435b6f04b74f5ef5a6a13761233bce9e8e9f8ecb0eabe936fd36a778b0c
-
-if [[ -d "$DEP_DIR" ]]
-then
-    echo "$DEP_DIR" found
-    exit 0
-fi
-
-get_file "https://github.com/GyanD/codexffmpeg/releases/download/$VERSION/$FILENAME" \
-    "$FILENAME" "$SHA256SUM"
-
-mkdir "$DEP_DIR"
-cd "$DEP_DIR"
-
-ZIP_PREFIX=ffmpeg-$VERSION-full_build-shared
-7z x "../$FILENAME" \
-    "$ZIP_PREFIX"/bin/avutil-57.dll \
-    "$ZIP_PREFIX"/bin/avcodec-59.dll \
-    "$ZIP_PREFIX"/bin/avformat-59.dll \
-    "$ZIP_PREFIX"/bin/swresample-4.dll \
-    "$ZIP_PREFIX"/bin/swscale-6.dll \
-    "$ZIP_PREFIX"/include
-mv "$ZIP_PREFIX"/* .
-rmdir "$ZIP_PREFIX"
--- a/app/prebuilt-deps/prepare-libusb.sh
+++ b/app/prebuilt-deps/prepare-libusb.sh
@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-set -e
-DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DIR"
-. common
-mkdir -p "$PREBUILT_DATA_DIR"
-cd "$PREBUILT_DATA_DIR"
-
-DEP_DIR=libusb-1.0.26
-
-FILENAME=libusb-1.0.26-binaries.7z
-SHA256SUM=9c242696342dbde9cdc47239391f71833939bf9f7aa2bbb28cdaabe890465ec5
-
-if [[ -d "$DEP_DIR" ]]
-then
-    echo "$DEP_DIR" found
-    exit 0
-fi
-
-get_file "https://github.com/libusb/libusb/releases/download/v1.0.26/$FILENAME" "$FILENAME" "$SHA256SUM"
-
-mkdir "$DEP_DIR"
-cd "$DEP_DIR"
-
-# include/ is the same in all folders of the archive
-7z x "../$FILENAME" \
-    libusb-1.0.26-binaries/libusb-MinGW-Win32/bin/msys-usb-1.0.dll \
-    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-1.0.26-binaries/libusb-MinGW-Win32/bin MinGW-Win32
-mv libusb-1.0.26-binaries/libusb-MinGW-x64/bin MinGW-x64
-mv libusb-1.0.26-binaries/libusb-MinGW-x64/include .
-rm -rf libusb-1.0.26-binaries
--- a/app/prebuilt-deps/prepare-sdl.sh
+++ b/app/prebuilt-deps/prepare-sdl.sh
@ -1,32 +0,0 @@
-#!/usr/bin/env bash
-set -e
-DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DIR"
-. common
-mkdir -p "$PREBUILT_DATA_DIR"
-cd "$PREBUILT_DATA_DIR"
-
-DEP_DIR=SDL2-2.0.22
-
-FILENAME=SDL2-devel-2.0.22-mingw.tar.gz
-SHA256SUM=0e91e35973366aa1e6f81ee368924d9b4f93f9da4d2f2a89ec80b06eadcf23d1
-
-if [[ -d "$DEP_DIR" ]]
-then
-    echo "$DEP_DIR" found
-    exit 0
-fi
-
-get_file "https://libsdl.org/release/$FILENAME" "$FILENAME" "$SHA256SUM"
-
-mkdir "$DEP_DIR"
-cd "$DEP_DIR"
-
-TAR_PREFIX="$DEP_DIR" # root directory inside the tar has the same name
-tar xf "../$FILENAME" --strip-components=1 \
-    "$TAR_PREFIX"/i686-w64-mingw32/bin/SDL2.dll \
-    "$TAR_PREFIX"/i686-w64-mingw32/include/ \
-    "$TAR_PREFIX"/i686-w64-mingw32/lib/ \
-    "$TAR_PREFIX"/x86_64-w64-mingw32/bin/SDL2.dll \
-    "$TAR_PREFIX"/x86_64-w64-mingw32/include/ \
-    "$TAR_PREFIX"/x86_64-w64-mingw32/lib/ \
--- a/app/scrcpy-windows.manifest
+++ b/app/scrcpy-windows.manifest
@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
-  <asmv3:application>
-    <asmv3:windowsSettings>
-      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
-      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
-    </asmv3:windowsSettings>
-  </asmv3:application>
-</assembly>
--- a/app/scrcpy-windows.rc
+++ b/app/scrcpy-windows.rc
@ -1,23 +0,0 @@
-#include <winuser.h>
-
-0 ICON "data/icon.ico"
-1 RT_MANIFEST "scrcpy-windows.manifest"
-2 VERSIONINFO
-BEGIN
-  BLOCK "StringFileInfo"
-  BEGIN
-    BLOCK "040904E4"
-    BEGIN
-      VALUE "FileDescription", "Display and control your Android device"
-      VALUE "InternalName", "scrcpy"
-      VALUE "LegalCopyright", "Romain Vimont, Genymobile"
-      VALUE "OriginalFilename", "scrcpy.exe"
-      VALUE "ProductName", "scrcpy"
-      VALUE "ProductVersion", "1.24"
-    END
-  END
-  BLOCK "VarFileInfo"
-  BEGIN
-    VALUE "Translation", 0x409, 1252
-  END
-END
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -43,12 +43,6 @@ The values are expressed in the device natural orientation (typically, portrait
 .B \-\-max\-size
 value is computed on the cropped size.

-.TP
-.B \-d, \-\-select\-usb
-Use USB device (if there is exactly one, like adb -d).
-
-Also see \fB\-e\fR (\fB\-\-select\-tcpip\fR).
-
 .TP
 .BI "\-\-disable-screensaver"
 Disable screensaver while scrcpy is running.
@ -62,18 +56,6 @@ The list of possible display ids can be listed by "adb shell dumpsys display"

 Default is 0.

-.TP
-.BI "\-\-display\-buffer ms
-Add a buffering delay (in milliseconds) before displaying. This increases latency to compensate for jitter.
-
-Default is 0 (no buffering).
-
-.TP
-.B \-e, \-\-select\-tcpip
-Use TCP/IP device (if there is exactly one, like adb -e).
-
-Also see \fB\-d\fR (\fB\-\-select\-usb\fR).
-
 .TP
 .BI "\-\-encoder " name
 Use a specific MediaCodec encoder (must be a H.264 encoder).
@ -94,22 +76,6 @@ Start in fullscreen.
 .B \-h, \-\-help
 Print this help.

-.TP
-.B \-K, \-\-hid\-keyboard
-Simulate a physical keyboard by using HID over AOAv2.
-
-This provides a better experience for IME users, and allows to generate non-ASCII characters, contrary to the default injection method.
-
-It may only work over USB.
-
-The keyboard layout must be configured (once and for all) on the device, via Settings -> System -> Languages and input -> Physical keyboard. This settings page can be started directly:
-
-    adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
-
-However, the option is only available when the HID keyboard is enabled (or a physical keyboard is connected).
-
-Also see \fB\-\-hid\-mouse\fR.
-
 .TP
 .B \-\-legacy\-paste
 Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+Shift+v).
@ -117,12 +83,10 @@ Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+S
 This is a workaround for some devices not behaving as expected when setting the device clipboard programmatically.

 .TP
-.BI "\-\-lock\-video\-orientation[=value]
-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.
+.BI "\-\-lock\-video\-orientation " value
+Lock video orientation to \fIvalue\fR. Possible values are -1 (unlocked), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.

-Default is "unlocked".
-
-Passing the option without argument is equivalent to passing "initial".
+Default is -1 (unlocked).

 .TP
 .BI "\-\-max\-fps " value
@ -134,36 +98,6 @@ Limit both the width and height of the video to \fIvalue\fR. The other dimension

 Default is 0 (unlimited).

-.TP
-.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
-.B \-\-no\-cleanup
-By default, scrcpy removes the server binary from the device and restores the device state (show touches, stay awake and power mode) on exit.
-
-This option disables this cleanup.
-
-.TP
-.B \-\-no\-clipboard\-autosync
-By default, scrcpy automatically synchronizes the computer clipboard to the device clipboard before injecting Ctrl+v, and the device clipboard to the computer clipboard whenever it changes.
-
-This option disables this automatic synchronization.
-
-.TP
-.B \-\-no\-downsize\-on\-error
-By default, on MediaCodec error, scrcpy automatically tries again with a lower definition.
-
-This option disables this behavior.
-
 .TP
 .B \-n, \-\-no\-control
 Disable device control (mirror the device in read\-only).
@ -180,34 +114,12 @@ Do not forward repeated key events when a key is held down.
 .B \-\-no\-mipmaps
 If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then mipmaps are automatically generated to improve downscaling quality. This option disables the generation of mipmaps.

-.TP
-.B \-\-no\-power\-on
-Do not power on the device on start.
-
-.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.
-
-In this mode, adb (USB debugging) is not necessary, and mirroring is disabled.
-
-LAlt, LSuper or RSuper toggle the mouse capture mode, to give control of the mouse back to the computer.
-
-If any of \fB\-\-hid\-keyboard\fR or \fB\-\-hid\-mouse\fR is set, only enable keyboard or mouse respectively, otherwise enable both.
-
-It may only work over USB.
-
-See \fB\-\-hid\-keyboard\fR and \fB\-\-hid\-mouse\fR.
-
 .TP
 .BI "\-p, \-\-port " port[:port]
 Set the TCP port (range) used by the client to listen.

 Default is 27183:27199.

-.TP
-.B \-\-power\-off\-on\-close
-Turn the device screen off when closing scrcpy.
-
 .TP
 .B \-\-prefer\-text
 Inject alpha characters and space as text events instead of key events.
@ -215,19 +127,11 @@ Inject alpha characters and space as text events instead of key events.
 This avoids issues when combining multiple keys to enter special characters,
 but breaks the expected behavior of alpha keys in games (typically WASD).

-.TP
-.B "\-\-print\-fps
-Start FPS counter, to print framerate logs to the console. It can be started or stopped at any time with MOD+i.
-
 .TP
 .BI "\-\-push\-target " path
 Set the target directory for pushing files to the device by drag & drop. It is passed as\-is to "adb push".

-Default is "/sdcard/Download/".
-
-.TP
-.B \-\-raw\-key\-events
-Inject key events for all input keys, and ignore text events.
+Default is "/sdcard/".

 .TP
 .BI "\-r, \-\-record " file
@ -251,6 +155,10 @@ Supported names are currently "direct3d", "opengl", "opengles2", "opengles", "me
 .UR https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER
 .UE

+.TP
+.B \-\-render\-expired\-frames
+By default, to minimize latency, scrcpy always renders the last available decoded frame, and drops any previous ones. This flag forces to render all frames, at a cost of a possible increased latency.
+
 .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.
@ -269,14 +177,6 @@ For example, to use either LCtrl+LAlt or LSuper for scrcpy shortcuts, pass "lctr

 Default is "lalt,lsuper" (left-Alt or left-Super).

-.TP
-.BI "\-\-tcpip[=ip[:port]]
-Configure and reconnect the device over TCP/IP.
-
-If a destination address is provided, then scrcpy connects to this address before starting. The device must listen on the given TCP port (default is 5555).
-
-If no destination address is provided, then scrcpy attempts to find the IP address of the current device (typically connected over USB), enables TCP/IP mode, then connects to this address before starting.
-
 .TP
 .B \-S, \-\-turn\-screen\-off
 Turn the device screen off immediately.
@ -288,41 +188,15 @@ Enable "show touches" on start, restore the initial value on exit.
 It only shows physical touches (not clicks from scrcpy).

 .TP
-.BI "\-\-tunnel\-host " ip
-Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
-
-Default is localhost.
-
-.TP
-.BI "\-\-tunnel\-port " port
-Set the TCP port of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
-
-Default is 0 (not forced): the local port used for establishing the tunnel will be used.
-
-.TP
-.BI "\-\-v4l2-sink " /dev/videoN
-Output to v4l2loopback device.
-
-It requires to lock the video orientation (see \fB\-\-lock\-video\-orientation\fR).
-
-.TP
-.BI "\-\-v4l2-buffer " ms
-Add a buffering delay (in milliseconds) before pushing frames. This increases latency to compensate for jitter.
-
-This option is similar to \fB\-\-display\-buffer\fR, but specific to V4L2 sink.
-
-Default is 0 (no buffering).
+.B \-v, \-\-version
+Print the version of scrcpy.

 .TP
 .BI "\-V, \-\-verbosity " value
-Set the log level ("verbose", "debug", "info", "warn" or "error").
+Set the log level ("debug", "info", "warn" or "error").

 Default is "info" for release builds, "debug" for debug builds.

-.TP
-.B \-v, \-\-version
-Print the version of scrcpy.
-
 .TP
 .B \-w, \-\-stay-awake
 Keep the device on while scrcpy is running, when the device is plugged in.
@ -339,36 +213,30 @@ Set a custom window title.
 .BI "\-\-window\-x " value
 Set the initial window horizontal position.

-Default is "auto".
+Default is "auto".\n

 .TP
 .BI "\-\-window\-y " value
 Set the initial window vertical position.

-Default is "auto".
+Default is "auto".\n

 .TP
 .BI "\-\-window\-width " value
 Set the initial window width.

-Default is 0 (automatic).
+Default is 0 (automatic).\n

 .TP
 .BI "\-\-window\-height " value
 Set the initial window height.

-Default is 0 (automatic).
-
-.SH EXIT STATUS
-.B scrcpy
-will exit with code 0 on normal program termination. If an initial
-connection cannot be established, the exit code 1 will be returned. If the
-device disconnects while a session is active, exit code 2 will be returned.
+Default is 0 (automatic).\n

 .SH SHORTCUTS

 In the following list, MOD is the shortcut modifier. By default, it's (left)
-Alt or (left) Super, but it can be configured by \fB\-\-shortcut\-mod\fR (see above).
+Alt or (left) Super, but it can be configured by \-\-shortcut-mod (see above).

 .TP
 .B MOD+f
@ -470,28 +338,16 @@ Pinch-to-zoom from the center of the screen
 .B Drag & drop APK file
 Install APK from computer

-.TP
-.B Drag & drop non-APK file
-Push file to device (see \fB\-\-push\-target\fR)
-

 .SH Environment variables

 .TP
 .B ADB
-Path to adb.
-
-.TP
-.B ANDROID_SERIAL
-Device serial to use if no selector (-s, -d, -e or --tcpip=<addr>) is specified.
-
-.TP
-.B SCRCPY_ICON_PATH
-Path to the program icon.
+Specify the path to adb.

 .TP
 .B SCRCPY_SERVER_PATH
-Path to the server binary.
+Specify the path to server binary.


 .SH AUTHORS
@ -516,7 +372,7 @@ Copyright \(co 2018 Genymobile
 Genymobile
 .UE

-Copyright \(co 2018\-2022
+Copyright \(co 2018\-2020
 .MT rom@rom1v.com
 Romain Vimont
 .ME
--- a/app/src/adb.c
+++ b/app/src/adb.c
@ -0,0 +1,211 @@
+#include "adb.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "util/log.h"
+#include "util/str_util.h"
+
+static const char *adb_command;
+
+static inline const char *
+get_adb_command(void) {
+    if (!adb_command) {
+        adb_command = getenv("ADB");
+        if (!adb_command)
+            adb_command = "adb";
+    }
+    return adb_command;
+}
+
+// serialize argv to string "[arg1], [arg2], [arg3]"
+static size_t
+argv_to_string(const char *const *argv, char *buf, size_t bufsize) {
+    size_t idx = 0;
+    bool first = true;
+    while (*argv) {
+        const char *arg = *argv;
+        size_t len = strlen(arg);
+        // count space for "[], ...\0"
+        if (idx + len + 8 >= bufsize) {
+            // not enough space, truncate
+            assert(idx < bufsize - 4);
+            memcpy(&buf[idx], "...", 3);
+            idx += 3;
+            break;
+        }
+        if (first) {
+            first = false;
+        } else {
+            buf[idx++] = ',';
+            buf[idx++] = ' ';
+        }
+        buf[idx++] = '[';
+        memcpy(&buf[idx], arg, len);
+        idx += len;
+        buf[idx++] = ']';
+        argv++;
+    }
+    assert(idx < bufsize);
+    buf[idx] = '\0';
+    return idx;
+}
+
+static void
+show_adb_installation_msg() {
+#ifndef __WINDOWS__
+    static const struct {
+        const char *binary;
+        const char *command;
+    } pkg_managers[] = {
+        {"apt", "apt install adb"},
+        {"apt-get", "apt-get install adb"},
+        {"brew", "brew cask install android-platform-tools"},
+        {"dnf", "dnf install android-tools"},
+        {"emerge", "emerge dev-util/android-tools"},
+        {"pacman", "pacman -S android-tools"},
+    };
+    for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
+        if (search_executable(pkg_managers[i].binary)) {
+            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
+            return;
+        }
+    }
+#endif
+
+    LOGI("You may download and install 'adb' from "
+         "https://developer.android.com/studio/releases/platform-tools");
+}
+
+static void
+show_adb_err_msg(enum process_result err, const char *const argv[]) {
+    char buf[512];
+    switch (err) {
+        case PROCESS_ERROR_GENERIC:
+            argv_to_string(argv, buf, sizeof(buf));
+            LOGE("Failed to execute: %s", buf);
+            break;
+        case PROCESS_ERROR_MISSING_BINARY:
+            argv_to_string(argv, buf, sizeof(buf));
+            LOGE("Command not found: %s", buf);
+            LOGE("(make 'adb' accessible from your PATH or define its full"
+                 "path in the ADB environment variable)");
+            show_adb_installation_msg();
+            break;
+        case PROCESS_SUCCESS:
+            // do nothing
+            break;
+    }
+}
+
+process_t
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
+    const char *cmd[len + 4];
+    int i;
+    process_t process;
+    cmd[0] = get_adb_command();
+    if (serial) {
+        cmd[1] = "-s";
+        cmd[2] = serial;
+        i = 3;
+    } else {
+        i = 1;
+    }
+
+    memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
+    cmd[len + i] = NULL;
+    enum process_result r = process_execute(cmd, &process);
+    if (r != PROCESS_SUCCESS) {
+        show_adb_err_msg(r, cmd);
+        return PROCESS_NONE;
+    }
+    return process;
+}
+
+process_t
+adb_forward(const char *serial, uint16_t local_port,
+            const char *device_socket_name) {
+    char local[4 + 5 + 1]; // tcp:PORT
+    char remote[108 + 14 + 1]; // localabstract:NAME
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
+    const char *const adb_cmd[] = {"forward", local, remote};
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+}
+
+process_t
+adb_forward_remove(const char *serial, uint16_t local_port) {
+    char local[4 + 5 + 1]; // tcp:PORT
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    const char *const adb_cmd[] = {"forward", "--remove", local};
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+}
+
+process_t
+adb_reverse(const char *serial, const char *device_socket_name,
+            uint16_t local_port) {
+    char local[4 + 5 + 1]; // tcp:PORT
+    char remote[108 + 14 + 1]; // localabstract:NAME
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
+    const char *const adb_cmd[] = {"reverse", remote, local};
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+}
+
+process_t
+adb_reverse_remove(const char *serial, const char *device_socket_name) {
+    char remote[108 + 14 + 1]; // localabstract:NAME
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
+    const char *const adb_cmd[] = {"reverse", "--remove", remote};
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+}
+
+process_t
+adb_push(const char *serial, const char *local, const char *remote) {
+#ifdef __WINDOWS__
+    // Windows will parse the string, so the paths must be quoted
+    // (see sys/win/command.c)
+    local = strquote(local);
+    if (!local) {
+        return PROCESS_NONE;
+    }
+    remote = strquote(remote);
+    if (!remote) {
+        free((void *) local);
+        return PROCESS_NONE;
+    }
+#endif
+
+    const char *const adb_cmd[] = {"push", local, remote};
+    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+
+#ifdef __WINDOWS__
+    free((void *) remote);
+    free((void *) local);
+#endif
+
+    return proc;
+}
+
+process_t
+adb_install(const char *serial, const char *local) {
+#ifdef __WINDOWS__
+    // Windows will parse the string, so the local name must be quoted
+    // (see sys/win/command.c)
+    local = strquote(local);
+    if (!local) {
+        return PROCESS_NONE;
+    }
+#endif
+
+    const char *const adb_cmd[] = {"install", "-r", local};
+    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+
+#ifdef __WINDOWS__
+    free((void *) local);
+#endif
+
+    return proc;
+}
--- a/app/src/adb.h
+++ b/app/src/adb.h
@ -0,0 +1,34 @@
+#ifndef SC_ADB_H
+#define SC_ADB_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <inttypes.h>
+
+#include "util/process.h"
+
+process_t
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
+
+process_t
+adb_forward(const char *serial, uint16_t local_port,
+            const char *device_socket_name);
+
+process_t
+adb_forward_remove(const char *serial, uint16_t local_port);
+
+process_t
+adb_reverse(const char *serial, const char *device_socket_name,
+            uint16_t local_port);
+
+process_t
+adb_reverse_remove(const char *serial, const char *device_socket_name);
+
+process_t
+adb_push(const char *serial, const char *local, const char *remote);
+
+process_t
+adb_install(const char *serial, const char *local);
+
+#endif
--- a/app/src/adb/adb.c
+++ b/app/src/adb/adb.c
@ -1,759 +0,0 @@
-#include "adb.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "adb_device.h"
-#include "adb_parser.h"
-#include "util/file.h"
-#include "util/log.h"
-#include "util/process_intr.h"
-#include "util/str.h"
-
-/* Convenience macro to expand:
- *
- *     const char *const argv[] =
- *         SC_ADB_COMMAND("shell", "echo", "hello");
- *
- * to:
- *
- *     const char *const argv[] =
- *         { sc_adb_get_executable(), "shell", "echo", "hello", NULL };
- */
-#define SC_ADB_COMMAND(...) { sc_adb_get_executable(), __VA_ARGS__, NULL }
-
-static const char *adb_executable;
-
-const char *
-sc_adb_get_executable(void) {
-    if (!adb_executable) {
-        adb_executable = getenv("ADB");
-        if (!adb_executable)
-            adb_executable = "adb";
-    }
-    return adb_executable;
-}
-
-// serialize argv to string "[arg1], [arg2], [arg3]"
-static size_t
-argv_to_string(const char *const *argv, char *buf, size_t bufsize) {
-    size_t idx = 0;
-    bool first = true;
-    while (*argv) {
-        const char *arg = *argv;
-        size_t len = strlen(arg);
-        // count space for "[], ...\0"
-        if (idx + len + 8 >= bufsize) {
-            // not enough space, truncate
-            assert(idx < bufsize - 4);
-            memcpy(&buf[idx], "...", 3);
-            idx += 3;
-            break;
-        }
-        if (first) {
-            first = false;
-        } else {
-            buf[idx++] = ',';
-            buf[idx++] = ' ';
-        }
-        buf[idx++] = '[';
-        memcpy(&buf[idx], arg, len);
-        idx += len;
-        buf[idx++] = ']';
-        argv++;
-    }
-    assert(idx < bufsize);
-    buf[idx] = '\0';
-    return idx;
-}
-
-static void
-show_adb_installation_msg() {
-#ifndef __WINDOWS__
-    static const struct {
-        const char *binary;
-        const char *command;
-    } pkg_managers[] = {
-        {"apt", "apt install adb"},
-        {"apt-get", "apt-get install adb"},
-        {"brew", "brew cask install android-platform-tools"},
-        {"dnf", "dnf install android-tools"},
-        {"emerge", "emerge dev-util/android-tools"},
-        {"pacman", "pacman -S android-tools"},
-    };
-    for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
-        if (sc_file_executable_exists(pkg_managers[i].binary)) {
-            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
-            return;
-        }
-    }
-#endif
-}
-
-static void
-show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
-#define MAX_COMMAND_STRING_LEN 1024
-    char *buf = malloc(MAX_COMMAND_STRING_LEN);
-    if (!buf) {
-        LOG_OOM();
-        LOGE("Failed to execute");
-        return;
-    }
-
-    switch (err) {
-        case SC_PROCESS_ERROR_GENERIC:
-            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
-            LOGE("Failed to execute: %s", buf);
-            break;
-        case SC_PROCESS_ERROR_MISSING_BINARY:
-            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
-            LOGE("Command not found: %s", buf);
-            LOGE("(make 'adb' accessible from your PATH or define its full"
-                 "path in the ADB environment variable)");
-            show_adb_installation_msg();
-            break;
-        case SC_PROCESS_SUCCESS:
-            // do nothing
-            break;
-    }
-
-    free(buf);
-}
-
-static bool
-process_check_success_internal(sc_pid pid, const char *name, bool close,
-                               unsigned flags) {
-    bool log_errors = !(flags & SC_ADB_NO_LOGERR);
-
-    if (pid == SC_PROCESS_NONE) {
-        if (log_errors) {
-            LOGE("Could not execute \"%s\"", name);
-        }
-        return false;
-    }
-    sc_exit_code exit_code = sc_process_wait(pid, close);
-    if (exit_code) {
-        if (log_errors) {
-            if (exit_code != SC_EXIT_CODE_NONE) {
-                LOGE("\"%s\" returned with value %" SC_PRIexitcode, name,
-                     exit_code);
-            } else {
-                LOGE("\"%s\" exited unexpectedly", name);
-            }
-        }
-        return false;
-    }
-    return true;
-}
-
-static bool
-process_check_success_intr(struct sc_intr *intr, sc_pid pid, const char *name,
-                           unsigned flags) {
-    if (intr && !sc_intr_set_process(intr, pid)) {
-        // Already interrupted
-        return false;
-    }
-
-    // Always pass close=false, interrupting would be racy otherwise
-    bool ret = process_check_success_internal(pid, name, false, flags);
-
-    if (intr) {
-        sc_intr_set_process(intr, SC_PROCESS_NONE);
-    }
-
-    // Close separately
-    sc_process_close(pid);
-
-    return ret;
-}
-
-static sc_pid
-sc_adb_execute_p(const char *const argv[], unsigned flags, sc_pipe *pout) {
-    unsigned process_flags = 0;
-    if (flags & SC_ADB_NO_STDOUT) {
-        process_flags |= SC_PROCESS_NO_STDOUT;
-    }
-    if (flags & SC_ADB_NO_STDERR) {
-        process_flags |= SC_PROCESS_NO_STDERR;
-    }
-
-    sc_pid pid;
-    enum sc_process_result r =
-        sc_process_execute_p(argv, &pid, process_flags, NULL, pout, NULL);
-    if (r != SC_PROCESS_SUCCESS) {
-        // If the execution itself failed (not the command exit code), log the
-        // error in all cases
-        show_adb_err_msg(r, argv);
-        pid = SC_PROCESS_NONE;
-    }
-
-    return pid;
-}
-
-sc_pid
-sc_adb_execute(const char *const argv[], unsigned flags) {
-    return sc_adb_execute_p(argv, flags, NULL);
-}
-
-bool
-sc_adb_start_server(struct sc_intr *intr, unsigned flags) {
-    const char *const argv[] = SC_ADB_COMMAND("start-server");
-
-    sc_pid pid = sc_adb_execute(argv, flags);
-    return process_check_success_intr(intr, pid, "adb start-server", flags);
-}
-
-bool
-sc_adb_kill_server(struct sc_intr *intr, unsigned flags) {
-    const char *const argv[] = SC_ADB_COMMAND("kill-server");
-
-    sc_pid pid = sc_adb_execute(argv, flags);
-    return process_check_success_intr(intr, pid, "adb kill-server", flags);
-}
-
-bool
-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
-    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, "forward", local, remote);
-
-    sc_pid pid = sc_adb_execute(argv, flags);
-    return process_check_success_intr(intr, pid, "adb forward", flags);
-}
-
-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
-    sprintf(local, "tcp:%" PRIu16, local_port);
-
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "forward", "--remove", local);
-
-    sc_pid pid = sc_adb_execute(argv, flags);
-    return process_check_success_intr(intr, pid, "adb forward --remove", flags);
-}
-
-bool
-sc_adb_reverse(struct sc_intr *intr, const char *serial,
-               const char *device_socket_name, uint16_t local_port,
-               unsigned flags) {
-    char local[4 + 5 + 1]; // tcp:PORT
-    char remote[108 + 14 + 1]; // localabstract:NAME
-    sprintf(local, "tcp:%" PRIu16, local_port);
-    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "reverse", remote, local);
-
-    sc_pid pid = sc_adb_execute(argv, flags);
-    return process_check_success_intr(intr, pid, "adb reverse", flags);
-}
-
-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
-    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
-
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "reverse", "--remove", remote);
-
-    sc_pid pid = sc_adb_execute(argv, flags);
-    return process_check_success_intr(intr, pid, "adb reverse --remove", flags);
-}
-
-bool
-sc_adb_push(struct sc_intr *intr, const char *serial, const char *local,
-            const char *remote, unsigned flags) {
-#ifdef __WINDOWS__
-    // Windows will parse the string, so the paths must be quoted
-    // (see sys/win/command.c)
-    local = sc_str_quote(local);
-    if (!local) {
-        return SC_PROCESS_NONE;
-    }
-    remote = sc_str_quote(remote);
-    if (!remote) {
-        free((void *) local);
-        return SC_PROCESS_NONE;
-    }
-#endif
-
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "push", local, remote);
-
-    sc_pid pid = sc_adb_execute(argv, flags);
-
-#ifdef __WINDOWS__
-    free((void *) remote);
-    free((void *) local);
-#endif
-
-    return process_check_success_intr(intr, pid, "adb push", flags);
-}
-
-bool
-sc_adb_install(struct sc_intr *intr, const char *serial, const char *local,
-               unsigned flags) {
-#ifdef __WINDOWS__
-    // Windows will parse the string, so the local name must be quoted
-    // (see sys/win/command.c)
-    local = sc_str_quote(local);
-    if (!local) {
-        return SC_PROCESS_NONE;
-    }
-#endif
-
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "install", "-r", local);
-
-    sc_pid pid = sc_adb_execute(argv, flags);
-
-#ifdef __WINDOWS__
-    free((void *) local);
-#endif
-
-    return process_check_success_intr(intr, pid, "adb install", flags);
-}
-
-bool
-sc_adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
-             unsigned flags) {
-    char port_string[5 + 1];
-    sprintf(port_string, "%" PRIu16, port);
-
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "tcpip", port_string);
-
-    sc_pid pid = sc_adb_execute(argv, flags);
-    return process_check_success_intr(intr, pid, "adb tcpip", flags);
-}
-
-bool
-sc_adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
-    const char *const argv[] = SC_ADB_COMMAND("connect", ip_port);
-
-    sc_pipe pout;
-    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGE("Could not execute \"adb connect\"");
-        return false;
-    }
-
-    // "adb connect" always returns successfully (with exit code 0), even in
-    // case of failure. As a workaround, check if its output starts with
-    // "connected".
-    char buf[128];
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf) - 1);
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "adb connect", flags);
-    if (!ok) {
-        return false;
-    }
-
-    if (r == -1) {
-        return false;
-    }
-
-    assert((size_t) r < sizeof(buf));
-    buf[r] = '\0';
-
-    ok = !strncmp("connected", buf, sizeof("connected") - 1);
-    if (!ok && !(flags & SC_ADB_NO_STDERR)) {
-        // "adb connect" also prints errors to stdout. Since we capture it,
-        // re-print the error to stderr.
-        size_t len = strcspn(buf, "\r\n");
-        buf[len] = '\0';
-        fprintf(stderr, "%s\n", buf);
-    }
-    return ok;
-}
-
-bool
-sc_adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
-    assert(ip_port);
-    const char *const argv[] = SC_ADB_COMMAND("disconnect", ip_port);
-
-    sc_pid pid = sc_adb_execute(argv, flags);
-    return process_check_success_intr(intr, pid, "adb disconnect", flags);
-}
-
-static bool
-sc_adb_list_devices(struct sc_intr *intr, unsigned flags,
-                    struct sc_vec_adb_devices *out_vec) {
-    const char *const argv[] = SC_ADB_COMMAND("devices", "-l");
-
-#define BUFSIZE 65536
-    char *buf = malloc(BUFSIZE);
-    if (!buf) {
-        return false;
-    }
-
-    sc_pipe pout;
-    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGE("Could not execute \"adb devices -l\"");
-        free(buf);
-        return false;
-    }
-
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, BUFSIZE - 1);
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "adb devices -l", flags);
-    if (!ok) {
-        free(buf);
-        return false;
-    }
-
-    if (r == -1) {
-        free(buf);
-        return false;
-    }
-
-    assert((size_t) r < BUFSIZE);
-    if (r == BUFSIZE - 1)  {
-        // The implementation assumes that the output of "adb devices -l" fits
-        // in the buffer in a single pass
-        LOGW("Result of \"adb devices -l\" does not fit in 64Kb. "
-             "Please report an issue.");
-        return false;
-    }
-
-    // It is parsed as a NUL-terminated string
-    buf[r] = '\0';
-
-    // List all devices to the output list directly
-    ok = sc_adb_parse_devices(buf, out_vec);
-    free(buf);
-    return ok;
-}
-
-static bool
-sc_adb_accept_device(const struct sc_adb_device *device,
-                     const struct sc_adb_device_selector *selector) {
-    switch (selector->type) {
-        case SC_ADB_DEVICE_SELECT_ALL:
-            return true;
-        case SC_ADB_DEVICE_SELECT_SERIAL:
-            assert(selector->serial);
-            char *device_serial_colon = strchr(device->serial, ':');
-            if (device_serial_colon) {
-                // The device serial is an IP:port...
-                char *serial_colon = strchr(selector->serial, ':');
-                if (!serial_colon) {
-                    // But the requested serial has no ':', so only consider
-                    // the IP part of the device serial. This allows to use
-                    // "192.168.1.1" to match any "192.168.1.1:port".
-                    size_t serial_len = strlen(selector->serial);
-                    size_t device_ip_len = device_serial_colon - device->serial;
-                    if (serial_len != device_ip_len) {
-                        // They are not equal, they don't even have the same
-                        // length
-                        return false;
-                    }
-                    return !strncmp(selector->serial, device->serial,
-                                    device_ip_len);
-                }
-            }
-            return !strcmp(selector->serial, device->serial);
-        case SC_ADB_DEVICE_SELECT_USB:
-            return sc_adb_device_get_type(device->serial) ==
-                    SC_ADB_DEVICE_TYPE_USB;
-        case SC_ADB_DEVICE_SELECT_TCPIP:
-            // Both emulators and TCP/IP devices are selected via -e
-            return sc_adb_device_get_type(device->serial) !=
-                    SC_ADB_DEVICE_TYPE_USB;
-        default:
-            assert(!"Missing SC_ADB_DEVICE_SELECT_* handling");
-            break;
-    }
-
-    return false;
-}
-
-static size_t
-sc_adb_devices_select(struct sc_adb_device *devices, size_t len,
-                      const struct sc_adb_device_selector *selector,
-                      size_t *idx_out) {
-    size_t count = 0;
-    for (size_t i = 0; i < len; ++i) {
-        struct sc_adb_device *device = &devices[i];
-        device->selected = sc_adb_accept_device(device, selector);
-        if (device->selected) {
-            if (idx_out && !count) {
-                *idx_out = i;
-            }
-            ++count;
-        }
-    }
-
-    return count;
-}
-
-static void
-sc_adb_devices_log(enum sc_log_level level, struct sc_adb_device *devices,
-                   size_t count) {
-    for (size_t i = 0; i < count; ++i) {
-        struct sc_adb_device *d = &devices[i];
-        const char *selection = d->selected ? "-->" : "   ";
-        bool is_usb =
-            sc_adb_device_get_type(d->serial) == SC_ADB_DEVICE_TYPE_USB;
-        const char *type = is_usb ? "  (usb)"
-                                  : "(tcpip)";
-        LOG(level, "    %s %s  %-20s  %16s  %s",
-             selection, type, d->serial, d->state, d->model ? d->model : "");
-    }
-}
-
-static bool
-sc_adb_device_check_state(struct sc_adb_device *device,
-                          struct sc_adb_device *devices, size_t count) {
-    const char *state = device->state;
-
-    if (!strcmp("device", state)) {
-        return true;
-    }
-
-    if (!strcmp("unauthorized", state)) {
-        LOGE("Device is unauthorized:");
-        sc_adb_devices_log(SC_LOG_LEVEL_ERROR, devices, count);
-        LOGE("A popup should open on the device to request authorization.");
-        LOGE("Check the FAQ: "
-             "<https://github.com/Genymobile/scrcpy/blob/master/FAQ.md>");
-    } else {
-        LOGE("Device could not be connected (state=%s)", state);
-    }
-
-    return false;
-}
-
-bool
-sc_adb_select_device(struct sc_intr *intr,
-                     const struct sc_adb_device_selector *selector,
-                     unsigned flags, struct sc_adb_device *out_device) {
-    struct sc_vec_adb_devices vec = SC_VECTOR_INITIALIZER;
-    bool ok = sc_adb_list_devices(intr, flags, &vec);
-    if (!ok) {
-        LOGE("Could not list ADB devices");
-        return false;
-    }
-
-    if (vec.size == 0) {
-        LOGE("Could not find any ADB device");
-        return false;
-    }
-
-    size_t sel_idx; // index of the single matching device if sel_count == 1
-    size_t sel_count =
-        sc_adb_devices_select(vec.data, vec.size, selector, &sel_idx);
-
-    if (sel_count == 0) {
-        // if count > 0 && sel_count == 0, then necessarily a selection is
-        // requested
-        assert(selector->type != SC_ADB_DEVICE_SELECT_ALL);
-
-        switch (selector->type) {
-            case SC_ADB_DEVICE_SELECT_SERIAL:
-                assert(selector->serial);
-                LOGE("Could not find ADB device %s:", selector->serial);
-                break;
-            case SC_ADB_DEVICE_SELECT_USB:
-                LOGE("Could not find any ADB device over USB:");
-                break;
-            case SC_ADB_DEVICE_SELECT_TCPIP:
-                LOGE("Could not find any ADB device over TCP/IP:");
-                break;
-            default:
-                assert(!"Unexpected selector type");
-                break;
-        }
-
-        sc_adb_devices_log(SC_LOG_LEVEL_ERROR, vec.data, vec.size);
-        sc_adb_devices_destroy(&vec);
-        return false;
-    }
-
-    if (sel_count > 1) {
-        switch (selector->type) {
-            case SC_ADB_DEVICE_SELECT_ALL:
-                LOGE("Multiple (%" SC_PRIsizet ") ADB devices:", sel_count);
-                break;
-            case SC_ADB_DEVICE_SELECT_SERIAL:
-                assert(selector->serial);
-                LOGE("Multiple (%" SC_PRIsizet ") ADB devices with serial %s:",
-                     sel_count, selector->serial);
-                break;
-            case SC_ADB_DEVICE_SELECT_USB:
-                LOGE("Multiple (%" SC_PRIsizet ") ADB devices over USB:",
-                     sel_count);
-                break;
-            case SC_ADB_DEVICE_SELECT_TCPIP:
-                LOGE("Multiple (%" SC_PRIsizet ") ADB devices over TCP/IP:",
-                     sel_count);
-                break;
-            default:
-                assert(!"Unexpected selector type");
-                break;
-        }
-        sc_adb_devices_log(SC_LOG_LEVEL_ERROR, vec.data, vec.size);
-        LOGE("Select a device via -s (--serial), -d (--select-usb) or -e "
-             "(--select-tcpip)");
-        sc_adb_devices_destroy(&vec);
-        return false;
-    }
-
-    assert(sel_count == 1); // sel_idx is valid only if sel_count == 1
-    struct sc_adb_device *device = &vec.data[sel_idx];
-
-    ok = sc_adb_device_check_state(device, vec.data, vec.size);
-    if (!ok) {
-        sc_adb_devices_destroy(&vec);
-        return false;
-    }
-
-    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);
-    sc_adb_devices_destroy(&vec);
-    return true;
-}
-
-char *
-sc_adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
-               unsigned flags) {
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "shell", "getprop", prop);
-
-    sc_pipe pout;
-    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGE("Could not execute \"adb getprop\"");
-        return NULL;
-    }
-
-    char buf[128];
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf) - 1);
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "adb getprop", flags);
-    if (!ok) {
-        return NULL;
-    }
-
-    if (r == -1) {
-        return NULL;
-    }
-
-    assert((size_t) r < sizeof(buf));
-    buf[r] = '\0';
-    size_t len = strcspn(buf, " \r\n");
-    buf[len] = '\0';
-
-    return strdup(buf);
-}
-
-char *
-sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "shell", "ip", "route");
-
-    sc_pipe pout;
-    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGD("Could not execute \"ip route\"");
-        return NULL;
-    }
-
-    // "adb shell ip route" output should contain only a few lines
-    char buf[1024];
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf) - 1);
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "ip route", flags);
-    if (!ok) {
-        return NULL;
-    }
-
-    if (r == -1) {
-        return NULL;
-    }
-
-    assert((size_t) r < sizeof(buf));
-    if (r == sizeof(buf) - 1)  {
-        // The implementation assumes that the output of "ip route" fits in the
-        // buffer in a single pass
-        LOGW("Result of \"ip route\" does not fit in 1Kb. "
-             "Please report an issue.");
-        return NULL;
-    }
-
-    // It is parsed as a NUL-terminated string
-    buf[r] = '\0';
-
-    return sc_adb_parse_device_ip(buf);
-}
-
-char *
-sc_adb_get_installed_apk_path(struct sc_intr *intr, const char *serial,
-                              unsigned flags) {
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "shell", "pm", "list", "package", "-f",
-                       SC_ANDROID_PACKAGE);
-
-    sc_pipe pout;
-    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGD("Could not execute \"pm list packages\"");
-        return NULL;
-    }
-
-    // "pm list packages -f <package>" output should contain only one line, so
-    // the output should be short
-    char buf[1024];
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf) - 1);
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "pm list packages", flags);
-    if (!ok) {
-        return NULL;
-    }
-
-    if (r == -1) {
-        return NULL;
-    }
-
-    assert((size_t) r < sizeof(buf));
-    if (r == sizeof(buf) - 1)  {
-        // The implementation assumes that the output of "ip route" fits in the
-        // buffer in a single pass
-        LOGW("Result of \"pm list package\" does not fit in 1Kb. "
-             "Please report an issue.");
-        return NULL;
-    }
-
-    // It is parsed as a NUL-terminated string
-    buf[r] = '\0';
-
-    return sc_adb_parse_installed_apk_path(buf);
-}
--- a/app/src/adb/adb.h
+++ b/app/src/adb/adb.h
@ -1,126 +0,0 @@
-#ifndef SC_ADB_H
-#define SC_ADB_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <inttypes.h>
-
-#include "adb_device.h"
-#include "util/intr.h"
-
-#define SC_ADB_NO_STDOUT (1 << 0)
-#define SC_ADB_NO_STDERR (1 << 1)
-#define SC_ADB_NO_LOGERR (1 << 2)
-
-#define SC_ADB_SILENT (SC_ADB_NO_STDOUT | SC_ADB_NO_STDERR | SC_ADB_NO_LOGERR)
-
-#define SC_ANDROID_PACKAGE "com.genymobile.scrcpy"
-
-const char *
-sc_adb_get_executable(void);
-
-enum sc_adb_device_selector_type {
-    SC_ADB_DEVICE_SELECT_ALL,
-    SC_ADB_DEVICE_SELECT_SERIAL,
-    SC_ADB_DEVICE_SELECT_USB,
-    SC_ADB_DEVICE_SELECT_TCPIP,
-};
-
-struct sc_adb_device_selector {
-    enum sc_adb_device_selector_type type;
-    const char *serial;
-};
-
-sc_pid
-sc_adb_execute(const char *const argv[], unsigned flags);
-
-bool
-sc_adb_start_server(struct sc_intr *intr, unsigned flags);
-
-bool
-sc_adb_kill_server(struct sc_intr *intr, unsigned flags);
-
-bool
-sc_adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
-               const char *device_socket_name, unsigned flags);
-
-bool
-sc_adb_forward_remove(struct sc_intr *intr, const char *serial,
-                      uint16_t local_port, unsigned flags);
-
-bool
-sc_adb_reverse(struct sc_intr *intr, const char *serial,
-               const char *device_socket_name, uint16_t local_port,
-               unsigned flags);
-
-bool
-sc_adb_reverse_remove(struct sc_intr *intr, const char *serial,
-                      const char *device_socket_name, unsigned flags);
-
-bool
-sc_adb_push(struct sc_intr *intr, const char *serial, const char *local,
-            const char *remote, unsigned flags);
-
-bool
-sc_adb_install(struct sc_intr *intr, const char *serial, const char *local,
-               unsigned flags);
-
-/**
- * Execute `adb tcpip <port>`
- */
-bool
-sc_adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
-             unsigned flags);
-
-/**
- * Execute `adb connect <ip_port>`
- *
- * `ip_port` may not be NULL.
- */
-bool
-sc_adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags);
-
-/**
- * Execute `adb disconnect [<ip_port>]`
- *
- * If `ip_port` is NULL, execute `adb disconnect`.
- * Otherwise, execute `adb disconnect <ip_port>`.
- */
-bool
-sc_adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags);
-
-/**
- * Execute `adb devices` and parse the result to select a device
- *
- * Return true if a single matching device is found, and write it to out_device.
- */
-bool
-sc_adb_select_device(struct sc_intr *intr,
-                     const struct sc_adb_device_selector *selector,
-                     unsigned flags, struct sc_adb_device *out_device);
-
-/**
- * Execute `adb getprop <prop>`
- */
-char *
-sc_adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
-               unsigned flags);
-
-/**
- * Attempt to retrieve the device IP
- *
- * Return the IP as a string of the form "xxx.xxx.xxx.xxx", to be freed by the
- * caller, or NULL on error.
- */
-char *
-sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags);
-
-/**
- * Return the path of the installed APK for com.genymobile.scrcpy (if any)
- */
-char *
-sc_adb_get_installed_apk_path(struct sc_intr *intr, const char *serial,
-                              unsigned flags);
-
-#endif
--- a/app/src/adb/adb_device.c
+++ b/app/src/adb/adb_device.c
@ -1,43 +0,0 @@
-#include "adb_device.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-void
-sc_adb_device_destroy(struct sc_adb_device *device) {
-    free(device->serial);
-    free(device->state);
-    free(device->model);
-}
-
-void
-sc_adb_device_move(struct sc_adb_device *dst, struct sc_adb_device *src) {
-    *dst = *src;
-    src->serial = NULL;
-    src->state = NULL;
-    src->model = NULL;
-}
-
-void
-sc_adb_devices_destroy(struct sc_vec_adb_devices *devices) {
-    for (size_t i = 0; i < devices->size; ++i) {
-        sc_adb_device_destroy(&devices->data[i]);
-    }
-    sc_vector_destroy(devices);
-}
-
-enum sc_adb_device_type
-sc_adb_device_get_type(const char *serial) {
-    // Starts with "emulator-"
-    if (!strncmp(serial, "emulator-", sizeof("emulator-") - 1)) {
-        return SC_ADB_DEVICE_TYPE_EMULATOR;
-    }
-
-    // If the serial contains a ':', then it is a TCP/IP device (it is
-    // sufficient to distinguish an ip:port from a real USB serial)
-    if (strchr(serial, ':')) {
-        return SC_ADB_DEVICE_TYPE_TCPIP;
-    }
-
-    return SC_ADB_DEVICE_TYPE_USB;
-}
--- a/app/src/adb/adb_device.h
+++ b/app/src/adb/adb_device.h
@ -1,50 +0,0 @@
-#ifndef SC_ADB_DEVICE_H
-#define SC_ADB_DEVICE_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-
-#include "util/vector.h"
-
-struct sc_adb_device {
-    char *serial;
-    char *state;
-    char *model;
-    bool selected;
-};
-
-enum sc_adb_device_type {
-    SC_ADB_DEVICE_TYPE_USB,
-    SC_ADB_DEVICE_TYPE_TCPIP,
-    SC_ADB_DEVICE_TYPE_EMULATOR,
-};
-
-struct sc_vec_adb_devices SC_VECTOR(struct sc_adb_device);
-
-void
-sc_adb_device_destroy(struct sc_adb_device *device);
-
-/**
- * Move src to dst
- *
- * After this call, the content of src is undefined, except that
- * sc_adb_device_destroy() can be called.
- *
- * This is useful to take a device from a list that will be destroyed, without
- * making unnecessary copies.
- */
-void
-sc_adb_device_move(struct sc_adb_device *dst, struct sc_adb_device *src);
-
-void
-sc_adb_devices_destroy(struct sc_vec_adb_devices *devices);
-
-/**
- * Deduce the device type from the serial
- */
-enum sc_adb_device_type
-sc_adb_device_get_type(const char *serial);
-
-#endif
--- a/app/src/adb/adb_parser.c
+++ b/app/src/adb/adb_parser.c
@ -1,255 +0,0 @@
-#include "adb_parser.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "util/log.h"
-#include "util/str.h"
-
-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 "
-    //     "device:MyDevice transport_id:1"
-
-    if (line[0] == '*') {
-        // Garbage lines printed by adb daemon while starting start with a '*'
-        return false;
-    }
-
-    if (!strncmp("adb server", line, sizeof("adb server") - 1)) {
-        // Ignore lines starting with "adb server":
-        //   adb server version (41) doesn't match this client (39); killing...
-        return false;
-    }
-
-    char *s = line; // cursor in the line
-
-    // After the serial:
-    //  - "adb devices" writes a single '\t'
-    //  - "adb devices -l" writes multiple spaces
-    // For flexibility, accept both.
-    size_t serial_len = strcspn(s, " \t");
-    if (!serial_len) {
-        // empty serial
-        return false;
-    }
-    bool eol = s[serial_len] == '\0';
-    if (eol) {
-        // serial alone is unexpected
-        return false;
-    }
-    s[serial_len] = '\0';
-    char *serial = s;
-    s += serial_len + 1;
-    // After the serial, there might be several spaces
-    s += strspn(s, " \t"); // consume all separators
-
-    size_t state_len = strcspn(s, " ");
-    if (!state_len) {
-        // empty state
-        return false;
-    }
-    eol = s[state_len] == '\0';
-    s[state_len] = '\0';
-    char *state = s;
-
-    char *model = NULL;
-    if (!eol) {
-        s += state_len + 1;
-
-        // Iterate over all properties "key:value key:value ..."
-        for (;;) {
-            size_t token_len = strcspn(s, " ");
-            if (!token_len) {
-                break;
-            }
-            eol = s[token_len] == '\0';
-            s[token_len] = '\0';
-            char *token = s;
-
-            if (!strncmp("model:", token, sizeof("model:") - 1)) {
-                model = &token[sizeof("model:") - 1];
-                // We only need the model
-                break;
-            }
-
-            if (eol) {
-                break;
-            } else {
-                s+= token_len + 1;
-            }
-        }
-    }
-
-    device->serial = strdup(serial);
-    if (!device->serial) {
-        return false;
-    }
-
-    device->state = strdup(state);
-    if (!device->state) {
-        free(device->serial);
-        return false;
-    }
-
-    if (model) {
-        device->model = strdup(model);
-        if (!device->model) {
-            LOG_OOM();
-            // model is optional, do not fail
-        }
-    } else {
-        device->model = NULL;
-    }
-
-    device->selected = false;
-
-    return true;
-}
-
-bool
-sc_adb_parse_devices(char *str, struct sc_vec_adb_devices *out_vec) {
-#define HEADER "List of devices attached"
-#define HEADER_LEN (sizeof(HEADER) - 1)
-    bool header_found = false;
-
-    size_t idx_line = 0;
-    while (str[idx_line] != '\0') {
-        char *line = &str[idx_line];
-        size_t len = strcspn(line, "\n");
-
-        // The next line starts after the '\n' (replaced by `\0`)
-        idx_line += len;
-
-        if (str[idx_line] != '\0') {
-            // The next line starts after the '\n'
-            ++idx_line;
-        }
-
-        if (!header_found) {
-            if (!strncmp(line, HEADER, HEADER_LEN)) {
-                header_found = true;
-            }
-            // Skip everything until the header, there might be garbage lines
-            // related to daemon starting before
-            continue;
-        }
-
-        // The line, but without any trailing '\r'
-        size_t line_len = sc_str_remove_trailing_cr(line, len);
-        line[line_len] = '\0';
-
-        struct sc_adb_device device;
-        bool ok = sc_adb_parse_device(line, &device);
-        if (!ok) {
-            continue;
-        }
-
-        ok = sc_vector_push(out_vec, device);
-        if (!ok) {
-            LOG_OOM();
-            LOGE("Could not push adb_device to vector");
-            sc_adb_device_destroy(&device);
-            // continue anyway
-            continue;
-        }
-    }
-
-    assert(header_found || out_vec->size == 0);
-    return header_found;
-}
-
-static char *
-sc_adb_parse_device_ip_from_line(char *line) {
-    // One line from "ip route" looks like:
-    // "192.168.1.0/24 dev wlan0  proto kernel  scope link  src 192.168.1.x"
-
-    // Get the location of the device name (index of "wlan0" in the example)
-    ssize_t idx_dev_name = sc_str_index_of_column(line, 2, " ");
-    if (idx_dev_name == -1) {
-        return NULL;
-    }
-
-    // Get the location of the ip address (column 8, but column 6 if we start
-    // from column 2). Must be computed before truncating individual columns.
-    ssize_t idx_ip = sc_str_index_of_column(&line[idx_dev_name], 6, " ");
-    if (idx_ip == -1) {
-        return NULL;
-    }
-    // idx_ip is searched from &line[idx_dev_name]
-    idx_ip += idx_dev_name;
-
-    char *dev_name = &line[idx_dev_name];
-    size_t dev_name_len = strcspn(dev_name, " \t");
-    dev_name[dev_name_len] = '\0';
-
-    char *ip = &line[idx_ip];
-    size_t ip_len = strcspn(ip, " \t");
-    ip[ip_len] = '\0';
-
-    // Only consider lines where the device name starts with "wlan"
-    if (strncmp(dev_name, "wlan", sizeof("wlan") - 1)) {
-        LOGD("Device ip lookup: ignoring %s (%s)", ip, dev_name);
-        return NULL;
-    }
-
-    return strdup(ip);
-}
-
-char *
-sc_adb_parse_device_ip(char *str) {
-    size_t idx_line = 0;
-    while (str[idx_line] != '\0') {
-        char *line = &str[idx_line];
-        size_t len = strcspn(line, "\n");
-
-        // The same, but without any trailing '\r'
-        size_t line_len = sc_str_remove_trailing_cr(line, len);
-        line[line_len] = '\0';
-
-        char *ip = sc_adb_parse_device_ip_from_line(line);
-        if (ip) {
-            // Found
-            return ip;
-        }
-
-        idx_line += len;
-
-        if (str[idx_line] != '\0') {
-            // The next line starts after the '\n'
-            ++idx_line;
-        }
-    }
-
-    return NULL;
-}
-
-char *
-sc_adb_parse_installed_apk_path(char *str) {
-    // str is expected to look like:
-    // "package:/data/app/.../base.apk=com.genymobile.scrcpy"
-    //          ^^^^^^^^^^^^^^^^^^^^^^
-    // We want to extract the path (which may contain '=', even in practice)
-
-    if (strncmp(str, "package:", 8)) {
-        // Does not start with "package:"
-        return NULL;
-    }
-
-    char *s = str + 8;
-    size_t len = strcspn(s, " \r\n");
-    s[len] = '\0';
-
-    char *p = strrchr(s, '=');
-    if (!p) {
-        // No '=' found
-        return NULL;
-    }
-
-    // Truncate at the last '='
-    *p = '\0';
-
-    return strdup(s);
-}
--- a/app/src/adb/adb_parser.h
+++ b/app/src/adb/adb_parser.h
@ -1,41 +0,0 @@
-#ifndef SC_ADB_PARSER_H
-#define SC_ADB_PARSER_H
-
-#include "common.h"
-
-#include <stddef.h>
-
-#include "adb_device.h"
-
-/**
- * Parse the available devices from the output of `adb devices`
- *
- * The parameter must be a NUL-terminated string.
- *
- * Warning: this function modifies the buffer for optimization purposes.
- */
-bool
-sc_adb_parse_devices(char *str, struct sc_vec_adb_devices *out_vec);
-
-/**
- * Parse the ip from the output of `adb shell ip route`
- *
- * The parameter must be a NUL-terminated string.
- *
- * Warning: this function modifies the buffer for optimization purposes.
- */
-char *
-sc_adb_parse_device_ip(char *str);
-
-/**
- * Parse the package path from the output of
- * `adb shell pm list packages -f <package>`
- *
- * The parameter must be a NUL-terminated string.
- *
- * Warning: this function modifies the buffer for optimization purposes.
- */
-char *
-sc_adb_parse_installed_apk_path(char *str);
-
-#endif
--- a/app/src/adb/adb_tunnel.c
+++ b/app/src/adb/adb_tunnel.c
@ -1,170 +0,0 @@
-#include "adb_tunnel.h"
-
-#include <assert.h>
-
-#include "adb.h"
-#include "util/log.h"
-#include "util/net_intr.h"
-#include "util/process_intr.h"
-
-#define SC_SOCKET_NAME "scrcpy"
-
-static bool
-listen_on_port(struct sc_intr *intr, sc_socket socket, uint16_t port) {
-    return net_listen_intr(intr, socket, IPV4_LOCALHOST, port, 1);
-}
-
-static bool
-enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
-                               struct sc_intr *intr, const char *serial,
-                               struct sc_port_range port_range) {
-    uint16_t port = port_range.first;
-    for (;;) {
-        if (!sc_adb_reverse(intr, serial, SC_SOCKET_NAME, port,
-                            SC_ADB_NO_STDOUT)) {
-            // the command itself failed, it will fail on any port
-            return false;
-        }
-
-        // At the application level, the device part is "the server" because it
-        // serves video stream and control. However, at the network level, the
-        // client listens and the server connects to the client. That way, the
-        // client can listen before starting the server app, so there is no
-        // need to try to connect until the server socket is listening on the
-        // device.
-        sc_socket server_socket = net_socket();
-        if (server_socket != SC_SOCKET_NONE) {
-            bool ok = listen_on_port(intr, server_socket, port);
-            if (ok) {
-                // success
-                tunnel->server_socket = server_socket;
-                tunnel->local_port = port;
-                tunnel->enabled = true;
-                return true;
-            }
-
-            net_close(server_socket);
-        }
-
-        if (sc_intr_is_interrupted(intr)) {
-            // Stop immediately
-            return false;
-        }
-
-        // failure, disable tunnel and try another port
-        if (!sc_adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
-                                SC_ADB_NO_STDOUT)) {
-            LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
-        }
-
-        // check before incrementing to avoid overflow on port 65535
-        if (port < port_range.last) {
-            LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
-                 port, (uint16_t) (port + 1));
-            port++;
-            continue;
-        }
-
-        if (port_range.first == port_range.last) {
-            LOGE("Could not listen on port %" PRIu16, port_range.first);
-        } else {
-            LOGE("Could not listen on any port in range %" PRIu16 ":%" PRIu16,
-                 port_range.first, port_range.last);
-        }
-        return false;
-    }
-}
-
-static bool
-enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
-                               struct sc_intr *intr, const char *serial,
-                               struct sc_port_range port_range) {
-    tunnel->forward = true;
-
-    uint16_t port = port_range.first;
-    for (;;) {
-        if (sc_adb_forward(intr, serial, port, SC_SOCKET_NAME,
-                           SC_ADB_NO_STDOUT)) {
-            // success
-            tunnel->local_port = port;
-            tunnel->enabled = true;
-            return true;
-        }
-
-        if (sc_intr_is_interrupted(intr)) {
-            // Stop immediately
-            return false;
-        }
-
-        if (port < port_range.last) {
-            LOGW("Could not forward port %" PRIu16", retrying on %" PRIu16,
-                 port, (uint16_t) (port + 1));
-            port++;
-            continue;
-        }
-
-        if (port_range.first == port_range.last) {
-            LOGE("Could not forward port %" PRIu16, port_range.first);
-        } else {
-            LOGE("Could not forward any port in range %" PRIu16 ":%" PRIu16,
-                 port_range.first, port_range.last);
-        }
-        return false;
-    }
-}
-
-void
-sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel) {
-    tunnel->enabled = false;
-    tunnel->forward = false;
-    tunnel->server_socket = SC_SOCKET_NONE;
-    tunnel->local_port = 0;
-}
-
-bool
-sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                   const char *serial, struct sc_port_range port_range,
-                   bool force_adb_forward) {
-    assert(!tunnel->enabled);
-
-    if (!force_adb_forward) {
-        // Attempt to use "adb reverse"
-        if (enable_tunnel_reverse_any_port(tunnel, intr, serial, port_range)) {
-            return true;
-        }
-
-        // if "adb reverse" does not work (e.g. over "adb connect"), it
-        // fallbacks to "adb forward", so the app socket is the client
-
-        LOGW("'adb reverse' failed, fallback to 'adb forward'");
-    }
-
-    return enable_tunnel_forward_any_port(tunnel, intr, serial, port_range);
-}
-
-bool
-sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                    const char *serial) {
-    assert(tunnel->enabled);
-
-    bool ret;
-    if (tunnel->forward) {
-        ret = sc_adb_forward_remove(intr, serial, tunnel->local_port,
-                                    SC_ADB_NO_STDOUT);
-    } else {
-        ret = sc_adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
-                                    SC_ADB_NO_STDOUT);
-
-        assert(tunnel->server_socket != SC_SOCKET_NONE);
-        if (!net_close(tunnel->server_socket)) {
-            LOGW("Could not close server socket");
-        }
-
-        // server_socket is never used anymore
-    }
-
-    // Consider tunnel disabled even if the command failed
-    tunnel->enabled = false;
-
-    return ret;
-}
--- a/app/src/adb/adb_tunnel.h
+++ b/app/src/adb/adb_tunnel.h
@ -1,47 +0,0 @@
-#ifndef SC_ADB_TUNNEL_H
-#define SC_ADB_TUNNEL_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "options.h"
-#include "util/intr.h"
-#include "util/net.h"
-
-struct sc_adb_tunnel {
-    bool enabled;
-    bool forward; // use "adb forward" instead of "adb reverse"
-    sc_socket server_socket; // only used if !forward
-    uint16_t local_port;
-};
-
-/**
- * Initialize the adb tunnel struct to default values
- */
-void
-sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel);
-
-/**
- * Open a tunnel
- *
- * Blocking calls may be interrupted asynchronously via `intr`.
- *
- * If `force_adb_forward` is not set, then attempts to set up an "adb reverse"
- * tunnel first. Only if it fails (typical on old Android version connected via
- * TCP/IP), use "adb forward".
- */
-bool
-sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                   const char *serial, struct sc_port_range port_range,
-                   bool force_adb_forward);
-
-/**
- * Close the tunnel
- */
-bool
-sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                    const char *serial);
-
-#endif
--- a/app/src/android/input.h
+++ b/app/src/android/input.h
@ -21,7 +21,7 @@
 #define _ANDROID_INPUT_H

 /**
- * Meta key / modifier state.
+ * Meta key / modifer state.
 */
 enum android_metastate {
    /** No meta keys are pressed. */
--- a/app/src/cli.c
+++ b/app/src/cli.c
--- a/app/src/cli.h
+++ b/app/src/cli.h
@ -5,7 +5,7 @@

 #include <stdbool.h>

-#include "options.h"
+#include "scrcpy.h"

 struct scrcpy_cli_args {
    struct scrcpy_options opts;
--- a/app/src/clock.c
+++ b/app/src/clock.c
@ -1,111 +0,0 @@
-#include "clock.h"
-
-#include "util/log.h"
-
-#define SC_CLOCK_NDEBUG // comment to debug
-
-void
-sc_clock_init(struct sc_clock *clock) {
-    clock->count = 0;
-    clock->head = 0;
-    clock->left_sum.system = 0;
-    clock->left_sum.stream = 0;
-    clock->right_sum.system = 0;
-    clock->right_sum.stream = 0;
-}
-
-// Estimate the affine function f(stream) = slope * stream + offset
-static void
-sc_clock_estimate(struct sc_clock *clock,
-                  double *out_slope, sc_tick *out_offset) {
-    assert(clock->count > 1); // two points are necessary
-
-    struct sc_clock_point left_avg = {
-        .system = clock->left_sum.system / (clock->count / 2),
-        .stream = clock->left_sum.stream / (clock->count / 2),
-    };
-    struct sc_clock_point right_avg = {
-        .system = clock->right_sum.system / ((clock->count + 1) / 2),
-        .stream = clock->right_sum.stream / ((clock->count + 1) / 2),
-    };
-
-    double slope = (double) (right_avg.system - left_avg.system)
-                 / (right_avg.stream - left_avg.stream);
-
-    if (clock->count < SC_CLOCK_RANGE) {
-        /* The first frames are typically received and decoded with more delay
-         * than the others, causing a wrong slope estimation on start. To
-         * compensate, assume an initial slope of 1, then progressively use the
-         * estimated slope. */
-        slope = (clock->count * slope + (SC_CLOCK_RANGE - clock->count))
-              / SC_CLOCK_RANGE;
-    }
-
-    struct sc_clock_point global_avg = {
-        .system = (clock->left_sum.system + clock->right_sum.system)
-                 / clock->count,
-        .stream = (clock->left_sum.stream + clock->right_sum.stream)
-                 / clock->count,
-    };
-
-    sc_tick offset = global_avg.system - (sc_tick) (global_avg.stream * slope);
-
-    *out_slope = slope;
-    *out_offset = offset;
-}
-
-void
-sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
-    struct sc_clock_point *point = &clock->points[clock->head];
-
-    if (clock->count == SC_CLOCK_RANGE || clock->count & 1) {
-        // One point passes from the right sum to the left sum
-
-        unsigned mid;
-        if (clock->count == SC_CLOCK_RANGE) {
-            mid = (clock->head + SC_CLOCK_RANGE / 2) % SC_CLOCK_RANGE;
-        } else {
-            // Only for the first frames
-            mid = clock->count / 2;
-        }
-
-        struct sc_clock_point *mid_point = &clock->points[mid];
-        clock->left_sum.system += mid_point->system;
-        clock->left_sum.stream += mid_point->stream;
-        clock->right_sum.system -= mid_point->system;
-        clock->right_sum.stream -= mid_point->stream;
-    }
-
-    if (clock->count == SC_CLOCK_RANGE) {
-        // The current point overwrites the previous value in the circular
-        // array, update the left sum accordingly
-        clock->left_sum.system -= point->system;
-        clock->left_sum.stream -= point->stream;
-    } else {
-        ++clock->count;
-    }
-
-    point->system = system;
-    point->stream = stream;
-
-    clock->right_sum.system += system;
-    clock->right_sum.stream += stream;
-
-    clock->head = (clock->head + 1) % SC_CLOCK_RANGE;
-
-    if (clock->count > 1) {
-        // Update estimation
-        sc_clock_estimate(clock, &clock->slope, &clock->offset);
-
-#ifndef SC_CLOCK_NDEBUG
-        LOGD("Clock estimation: %g * pts + %" PRItick,
-             clock->slope, clock->offset);
-#endif
-    }
-}
-
-sc_tick
-sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream) {
-    assert(clock->count > 1); // sc_clock_update() must have been called
-    return (sc_tick) (stream * clock->slope) + clock->offset;
-}
--- a/app/src/clock.h
+++ b/app/src/clock.h
@ -1,70 +0,0 @@
-#ifndef SC_CLOCK_H
-#define SC_CLOCK_H
-
-#include "common.h"
-
-#include <assert.h>
-
-#include "util/tick.h"
-
-#define SC_CLOCK_RANGE 32
-static_assert(!(SC_CLOCK_RANGE & 1), "SC_CLOCK_RANGE must be even");
-
-struct sc_clock_point {
-    sc_tick system;
-    sc_tick stream;
-};
-
-/**
- * The clock aims to estimate the affine relation between the stream (device)
- * time and the system time:
- *
- *     f(stream) = slope * stream + offset
- *
- * To that end, it stores the SC_CLOCK_RANGE last clock points (the timestamps
- * of a frame expressed both in stream time and system time) in a circular
- * array.
- *
- * To estimate the slope, it splits the last SC_CLOCK_RANGE points into two
- * sets of SC_CLOCK_RANGE/2 points, and computes their centroid ("average
- * point"). The slope of the estimated affine function is that of the line
- * passing through these two points.
- *
- * To estimate the offset, it computes the centroid of all the SC_CLOCK_RANGE
- * points. The resulting affine function passes by this centroid.
- *
- * With a circular array, the rolling sums (and average) are quick to compute.
- * In practice, the estimation is stable and the evolution is smooth.
- */
-struct sc_clock {
-    // Circular array
-    struct sc_clock_point points[SC_CLOCK_RANGE];
-
-    // Number of points in the array (count <= SC_CLOCK_RANGE)
-    unsigned count;
-
-    // Index of the next point to write
-    unsigned head;
-
-    // Sum of the first count/2 points
-    struct sc_clock_point left_sum;
-
-    // Sum of the last (count+1)/2 points
-    struct sc_clock_point right_sum;
-
-    // Estimated slope and offset
-    // (computed on sc_clock_update(), used by sc_clock_to_system_time())
-    double slope;
-    sc_tick offset;
-};
-
-void
-sc_clock_init(struct sc_clock *clock);
-
-void
-sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream);
-
-sc_tick
-sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream);
-
-#endif
--- a/app/src/common.h
+++ b/app/src/common.h
@ -1,5 +1,5 @@
-#ifndef SC_COMMON_H
-#define SC_COMMON_H
+#ifndef COMMON_H
+#define COMMON_H

 #include "config.h"
 #include "compat.h"
@ -7,9 +7,5 @@
 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
 #define MIN(X,Y) (X) < (Y) ? (X) : (Y)
 #define MAX(X,Y) (X) > (Y) ? (X) : (Y)
-#define CLAMP(V,X,Y) MIN( MAX((V),(X)), (Y) )
-
-#define container_of(ptr, type, member) \
-    ((type *) (((char *) (ptr)) - offsetof(type, member)))

 #endif
--- a/app/src/compat.c
+++ b/app/src/compat.c
@ -2,12 +2,6 @@

 #include "config.h"

-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-
 #ifndef HAVE_STRDUP
 char *strdup(const char *s) {
    size_t size = strlen(s) + 1;
@ -18,36 +12,3 @@ char *strdup(const char *s) {
    return dup;
 }
 #endif
-
-#ifndef HAVE_ASPRINTF
-int asprintf(char **strp, const char *fmt, ...) {
-    va_list va;
-    va_start(va, fmt);
-    int ret = vasprintf(strp, fmt, va);
-    va_end(va);
-    return ret;
-}
-#endif
-
-#ifndef HAVE_VASPRINTF
-int vasprintf(char **strp, const char *fmt, va_list ap) {
-    va_list va;
-    va_copy(va, ap);
-    int len = vsnprintf(NULL, 0, fmt, va);
-    va_end(va);
-
-    char *str = malloc(len + 1);
-    if (!str) {
-        return -1;
-    }
-
-    va_copy(va, ap);
-    int len2 = vsnprintf(str, len + 1, fmt, va);
-    (void) len2;
-    assert(len == len2);
-    va_end(va);
-
-    *strp = str;
-    return len;
-}
-#endif
--- a/app/src/compat.h
+++ b/app/src/compat.h
@ -1,17 +1,25 @@
-#ifndef SC_COMPAT_H
-#define SC_COMPAT_H
+#ifndef COMPAT_H
+#define COMPAT_H

-#include "config.h"
+#define _POSIX_C_SOURCE 200809L
+#define _XOPEN_SOURCE 700
+#define _GNU_SOURCE
+#ifdef __APPLE__
+# define _DARWIN_C_SOURCE
+#endif

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

-#ifndef __WIN32
-# define PRIu64_ PRIu64
-# define SC_PRIsizet "zu"
-#else
-# define PRIu64_ "I64u"  // Windows...
-# define SC_PRIsizet "Iu"
+// In ffmpeg/doc/APIchanges:
+// 2016-04-11 - 6f69f7a / 9200514 - lavf 57.33.100 / 57.5.0 - avformat.h
+//   Add AVStream.codecpar, deprecate AVStream.codec.
+#if    (LIBAVFORMAT_VERSION_MICRO >= 100 /* FFmpeg */ && \
+        LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 33, 100)) \
+    || (LIBAVFORMAT_VERSION_MICRO < 100 && /* Libav */ \
+        LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 5, 0))
+# define SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_API
 #endif

 // In ffmpeg/doc/APIchanges:
@ -25,21 +33,22 @@
 # define SCRCPY_LAVF_REQUIRES_REGISTER_ALL
 #endif

-
 // In ffmpeg/doc/APIchanges:
-// 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
-//   Deprecate AVFormatContext filename field which had limited length, use the
-//   new dynamically allocated url field instead.
-//
-// 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
-//   Add url field to AVFormatContext and add ff_format_set_url helper function.
-#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 7, 100)
-# define SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
+// 2016-04-21 - 7fc329e - lavc 57.37.100 - avcodec.h
+//   Add a new audio/video encoding and decoding API with decoupled input
+//   and output -- avcodec_send_packet(), avcodec_receive_frame(),
+//   avcodec_send_frame() and avcodec_receive_packet().
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 37, 100)
+# define SCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
 #endif

-#if SDL_VERSION_ATLEAST(2, 0, 6)
-// <https://github.com/libsdl-org/SDL/commit/d7a318de563125e5bb465b1000d6bc9576fbc6fc>
-# define SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
+#if SDL_VERSION_ATLEAST(2, 0, 5)
+// <https://wiki.libsdl.org/SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH>
+# define SCRCPY_SDL_HAS_HINT_MOUSE_FOCUS_CLICKTHROUGH
+// <https://wiki.libsdl.org/SDL_GetDisplayUsableBounds>
+# define SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
+// <https://wiki.libsdl.org/SDL_WindowFlags>
+# define SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
 #endif

 #if SDL_VERSION_ATLEAST(2, 0, 8)
@ -47,16 +56,8 @@
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
 #endif

-#ifndef HAVE_STRDUP
+#ifdef HAVE_STRDUP
 char *strdup(const char *s);
 #endif

-#ifndef HAVE_ASPRINTF
-int asprintf(char **strp, const char *fmt, ...);
-#endif
-
-#ifndef HAVE_VASPRINTF
-int vasprintf(char **strp, const char *fmt, va_list ap);
-#endif
-
 #endif
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@ -1,79 +1,26 @@
 #include "control_msg.h"

 #include <assert.h>
-#include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>

 #include "util/buffer_util.h"
 #include "util/log.h"
-#include "util/str.h"
-
-/**
- * Map an enum value to a string based on an array, without crashing on an
- * out-of-bounds index.
- */
-#define ENUM_TO_LABEL(labels, value) \
-    ((size_t) (value) < ARRAY_LEN(labels) ? labels[value] : "???")
-
-#define KEYEVENT_ACTION_LABEL(value) \
-    ENUM_TO_LABEL(android_keyevent_action_labels, value)
-
-#define MOTIONEVENT_ACTION_LABEL(value) \
-    ENUM_TO_LABEL(android_motionevent_action_labels, value)
-
-#define SCREEN_POWER_MODE_LABEL(value) \
-    ENUM_TO_LABEL(screen_power_mode_labels, value)
-
-static const char *const android_keyevent_action_labels[] = {
-    "down",
-    "up",
-    "multi",
-};
-
-static const char *const android_motionevent_action_labels[] = {
-    "down",
-    "up",
-    "move",
-    "cancel",
-    "outside",
-    "ponter-down",
-    "pointer-up",
-    "hover-move",
-    "scroll",
-    "hover-enter",
-    "hover-exit",
-    "btn-press",
-    "btn-release",
-};
-
-static const char *const screen_power_mode_labels[] = {
-    "off",
-    "doze",
-    "normal",
-    "doze-suspend",
-    "suspend",
-};
-
-static const char *const copy_key_labels[] = {
-    "none",
-    "copy",
-    "cut",
-};
+#include "util/str_util.h"

 static void
-write_position(uint8_t *buf, const struct sc_position *position) {
-    sc_write32be(&buf[0], position->point.x);
-    sc_write32be(&buf[4], position->point.y);
-    sc_write16be(&buf[8], position->screen_size.width);
-    sc_write16be(&buf[10], position->screen_size.height);
+write_position(uint8_t *buf, const struct position *position) {
+    buffer_write32be(&buf[0], position->point.x);
+    buffer_write32be(&buf[4], position->point.y);
+    buffer_write16be(&buf[8], position->screen_size.width);
+    buffer_write16be(&buf[10], position->screen_size.height);
 }

-// write length (4 bytes) + string (non null-terminated)
+// write length (2 bytes) + string (non nul-terminated)
 static size_t
 write_string(const char *utf8, size_t max_len, unsigned char *buf) {
-    size_t len = sc_str_utf8_truncation_index(utf8, max_len);
-    sc_write32be(buf, len);
+    size_t len = utf8_truncation_index(utf8, max_len);
+    buffer_write32be(buf, len);
    memcpy(&buf[4], utf8, len);
    return 4 + len;
 }
@ -89,58 +36,52 @@ to_fixed_point_16(float f) {
 }

 size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
+control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
    buf[0] = msg->type;
    switch (msg->type) {
-        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
+        case CONTROL_MSG_TYPE_INJECT_KEYCODE:
            buf[1] = msg->inject_keycode.action;
-            sc_write32be(&buf[2], msg->inject_keycode.keycode);
-            sc_write32be(&buf[6], msg->inject_keycode.repeat);
-            sc_write32be(&buf[10], msg->inject_keycode.metastate);
+            buffer_write32be(&buf[2], msg->inject_keycode.keycode);
+            buffer_write32be(&buf[6], msg->inject_keycode.repeat);
+            buffer_write32be(&buf[10], msg->inject_keycode.metastate);
            return 14;
-        case SC_CONTROL_MSG_TYPE_INJECT_TEXT: {
+        case CONTROL_MSG_TYPE_INJECT_TEXT: {
            size_t len =
                write_string(msg->inject_text.text,
-                             SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
+                             CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
            return 1 + len;
        }
-        case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
+        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
            buf[1] = msg->inject_touch_event.action;
-            sc_write64be(&buf[2], msg->inject_touch_event.pointer_id);
+            buffer_write64be(&buf[2], msg->inject_touch_event.pointer_id);
            write_position(&buf[10], &msg->inject_touch_event.position);
            uint16_t pressure =
                to_fixed_point_16(msg->inject_touch_event.pressure);
-            sc_write16be(&buf[22], pressure);
-            sc_write32be(&buf[24], msg->inject_touch_event.buttons);
+            buffer_write16be(&buf[22], pressure);
+            buffer_write32be(&buf[24], msg->inject_touch_event.buttons);
            return 28;
-        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
+        case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
            write_position(&buf[1], &msg->inject_scroll_event.position);
-            sc_write32be(&buf[13],
+            buffer_write32be(&buf[13],
                             (uint32_t) msg->inject_scroll_event.hscroll);
-            sc_write32be(&buf[17],
+            buffer_write32be(&buf[17],
                             (uint32_t) msg->inject_scroll_event.vscroll);
-            sc_write32be(&buf[21], msg->inject_scroll_event.buttons);
-            return 25;
-        case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
-            buf[1] = msg->inject_keycode.action;
-            return 2;
-        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
-            buf[1] = msg->get_clipboard.copy_key;
-            return 2;
-        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
-            sc_write64be(&buf[1], msg->set_clipboard.sequence);
-            buf[9] = !!msg->set_clipboard.paste;
+            return 21;
+        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
+            buf[1] = !!msg->set_clipboard.paste;
            size_t len = write_string(msg->set_clipboard.text,
-                                      SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-                                      &buf[10]);
-            return 10 + len;
-        case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
+                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
+                                      &buf[2]);
+            return 2 + len;
+        }
+        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
            buf[1] = msg->set_screen_power_mode.mode;
            return 2;
-        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 CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
+        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
+        case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
+        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
+        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
            // no additional data
            return 1;
        default:
@ -150,98 +91,12 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
 }

 void
-sc_control_msg_log(const struct sc_control_msg *msg) {
-#define LOG_CMSG(fmt, ...) LOGV("input: " fmt, ## __VA_ARGS__)
+control_msg_destroy(struct control_msg *msg) {
    switch (msg->type) {
-        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
-            LOG_CMSG("key %-4s code=%d repeat=%" PRIu32 " meta=%06lx",
-                     KEYEVENT_ACTION_LABEL(msg->inject_keycode.action),
-                     (int) msg->inject_keycode.keycode,
-                     msg->inject_keycode.repeat,
-                     (long) msg->inject_keycode.metastate);
-            break;
-        case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
-            LOG_CMSG("text \"%s\"", msg->inject_text.text);
-            break;
-        case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: {
-            int action = msg->inject_touch_event.action
-                       & AMOTION_EVENT_ACTION_MASK;
-            uint64_t id = msg->inject_touch_event.pointer_id;
-            if (id == POINTER_ID_MOUSE || id == POINTER_ID_VIRTUAL_FINGER) {
-                // string pointer id
-                LOG_CMSG("touch [id=%s] %-4s position=%" PRIi32 ",%" PRIi32
-                             " pressure=%g buttons=%06lx",
-                         id == POINTER_ID_MOUSE ? "mouse" : "vfinger",
-                         MOTIONEVENT_ACTION_LABEL(action),
-                         msg->inject_touch_event.position.point.x,
-                         msg->inject_touch_event.position.point.y,
-                         msg->inject_touch_event.pressure,
-                         (long) msg->inject_touch_event.buttons);
-            } else {
-                // numeric pointer id
-                LOG_CMSG("touch [id=%" PRIu64_ "] %-4s position=%" PRIi32 ",%"
-                             PRIi32 " pressure=%g buttons=%06lx",
-                         id,
-                         MOTIONEVENT_ACTION_LABEL(action),
-                         msg->inject_touch_event.position.point.x,
-                         msg->inject_touch_event.position.point.y,
-                         msg->inject_touch_event.pressure,
-                         (long) msg->inject_touch_event.buttons);
-            }
-            break;
-        }
-        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
-            LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%" PRIi32
-                         " vscroll=%" PRIi32 " buttons=%06lx",
-                     msg->inject_scroll_event.position.point.x,
-                     msg->inject_scroll_event.position.point.y,
-                     msg->inject_scroll_event.hscroll,
-                     msg->inject_scroll_event.vscroll,
-                     (long) msg->inject_scroll_event.buttons);
-            break;
-        case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
-            LOG_CMSG("back-or-screen-on %s",
-                     KEYEVENT_ACTION_LABEL(msg->inject_keycode.action));
-            break;
-        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
-            LOG_CMSG("get clipboard copy_key=%s",
-                     copy_key_labels[msg->get_clipboard.copy_key]);
-            break;
-        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
-            LOG_CMSG("clipboard %" PRIu64_ " %s \"%s\"",
-                     msg->set_clipboard.sequence,
-                     msg->set_clipboard.paste ? "paste" : "nopaste",
-                     msg->set_clipboard.text);
-            break;
-        case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
-            LOG_CMSG("power mode %s",
-                     SCREEN_POWER_MODE_LABEL(msg->set_screen_power_mode.mode));
-            break;
-        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-            LOG_CMSG("expand notification panel");
-            break;
-        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
-            LOG_CMSG("expand settings panel");
-            break;
-        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
-            LOG_CMSG("collapse panels");
-            break;
-        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
-            LOG_CMSG("rotate device");
-            break;
-        default:
-            LOG_CMSG("unknown type: %u", (unsigned) msg->type);
-            break;
-    }
-}
-
-void
-sc_control_msg_destroy(struct sc_control_msg *msg) {
-    switch (msg->type) {
-        case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
+        case CONTROL_MSG_TYPE_INJECT_TEXT:
            free(msg->inject_text.text);
            break;
-        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
+        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
            free(msg->set_clipboard.text);
            break;
        default:
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@ -1,5 +1,5 @@
-#ifndef SC_CONTROLMSG_H
-#define SC_CONTROLMSG_H
+#ifndef CONTROLMSG_H
+#define CONTROLMSG_H

 #include "common.h"

@ -11,44 +11,37 @@
 #include "android/keycodes.h"
 #include "coords.h"

-#define SC_CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
+#define CONTROL_MSG_MAX_SIZE (1 << 18) // 256k

-#define SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
-// type: 1 byte; sequence: 8 bytes; paste flag: 1 byte; length: 4 bytes
-#define SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (SC_CONTROL_MSG_MAX_SIZE - 14)
+#define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
+// type: 1 byte; paste flag: 1 byte; length: 4 bytes
+#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (CONTROL_MSG_MAX_SIZE - 6)

-#define POINTER_ID_MOUSE UINT64_C(-1)
-#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2)
+#define POINTER_ID_MOUSE UINT64_C(-1);
+#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2);

-enum sc_control_msg_type {
-    SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
-    SC_CONTROL_MSG_TYPE_INJECT_TEXT,
-    SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-    SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
-    SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
-    SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
-    SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
-    SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
-    SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
-    SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
-    SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
-    SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
+enum control_msg_type {
+    CONTROL_MSG_TYPE_INJECT_KEYCODE,
+    CONTROL_MSG_TYPE_INJECT_TEXT,
+    CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+    CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
+    CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
+    CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
+    CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
+    CONTROL_MSG_TYPE_GET_CLIPBOARD,
+    CONTROL_MSG_TYPE_SET_CLIPBOARD,
+    CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
+    CONTROL_MSG_TYPE_ROTATE_DEVICE,
 };

-enum sc_screen_power_mode {
+enum screen_power_mode {
    // see <https://android.googlesource.com/platform/frameworks/base.git/+/pie-release-2/core/java/android/view/SurfaceControl.java#305>
-    SC_SCREEN_POWER_MODE_OFF = 0,
-    SC_SCREEN_POWER_MODE_NORMAL = 2,
+    SCREEN_POWER_MODE_OFF = 0,
+    SCREEN_POWER_MODE_NORMAL = 2,
 };

-enum sc_copy_key {
-    SC_COPY_KEY_NONE,
-    SC_COPY_KEY_COPY,
-    SC_COPY_KEY_CUT,
-};
-
-struct sc_control_msg {
-    enum sc_control_msg_type type;
+struct control_msg {
+    enum control_msg_type type;
    union {
        struct {
            enum android_keyevent_action action;
@ -63,29 +56,20 @@ struct sc_control_msg {
            enum android_motionevent_action action;
            enum android_motionevent_buttons buttons;
            uint64_t pointer_id;
-            struct sc_position position;
+            struct position position;
            float pressure;
        } inject_touch_event;
        struct {
-            struct sc_position position;
+            struct position position;
            int32_t hscroll;
            int32_t vscroll;
-            enum android_motionevent_buttons buttons;
        } inject_scroll_event;
        struct {
-            enum android_keyevent_action action; // action for the BACK key
-            // screen may only be turned on on ACTION_DOWN
-        } back_or_screen_on;
-        struct {
-            enum sc_copy_key copy_key;
-        } get_clipboard;
-        struct {
-            uint64_t sequence;
            char *text; // owned, to be freed by free()
            bool paste;
        } set_clipboard;
        struct {
-            enum sc_screen_power_mode mode;
+            enum screen_power_mode mode;
        } set_screen_power_mode;
    };
 };
@ -93,12 +77,9 @@ struct sc_control_msg {
 // 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, unsigned char *buf);
+control_msg_serialize(const struct control_msg *msg, unsigned char *buf);

 void
-sc_control_msg_log(const struct sc_control_msg *msg);
-
-void
-sc_control_msg_destroy(struct sc_control_msg *msg);
+control_msg_destroy(struct control_msg *msg);

 #endif
--- a/app/src/controller.c
+++ b/app/src/controller.c
@ -5,11 +5,10 @@
 #include "util/log.h"

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

-    bool ok = receiver_init(&controller->receiver, control_socket, acksync);
+    bool ok = receiver_init(&controller->receiver, control_socket);
    if (!ok) {
        return false;
    }
@ -34,25 +33,21 @@ sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
 }

 void
-sc_controller_destroy(struct sc_controller *controller) {
+controller_destroy(struct controller *controller) {
    sc_cond_destroy(&controller->msg_cond);
    sc_mutex_destroy(&controller->mutex);

-    struct sc_control_msg msg;
+    struct control_msg msg;
    while (cbuf_take(&controller->queue, &msg)) {
-        sc_control_msg_destroy(&msg);
+        control_msg_destroy(&msg);
    }

    receiver_destroy(&controller->receiver);
 }

 bool
-sc_controller_push_msg(struct sc_controller *controller,
-                       const struct sc_control_msg *msg) {
-    if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
-        sc_control_msg_log(msg);
-    }
-
+controller_push_msg(struct controller *controller,
+                      const struct control_msg *msg) {
    sc_mutex_lock(&controller->mutex);
    bool was_empty = cbuf_is_empty(&controller->queue);
    bool res = cbuf_push(&controller->queue, *msg);
@ -64,21 +59,20 @@ sc_controller_push_msg(struct sc_controller *controller,
 }

 static bool
-process_msg(struct sc_controller *controller,
-            const struct sc_control_msg *msg) {
-    static unsigned char serialized_msg[SC_CONTROL_MSG_MAX_SIZE];
-    size_t length = sc_control_msg_serialize(msg, serialized_msg);
+process_msg(struct controller *controller,
+              const struct control_msg *msg) {
+    static unsigned char serialized_msg[CONTROL_MSG_MAX_SIZE];
+    size_t length = control_msg_serialize(msg, serialized_msg);
    if (!length) {
        return false;
    }
-    ssize_t w =
-        net_send_all(controller->control_socket, serialized_msg, length);
+    int w = net_send_all(controller->control_socket, serialized_msg, length);
    return (size_t) w == length;
 }

 static int
 run_controller(void *data) {
-    struct sc_controller *controller = data;
+    struct controller *controller = data;

    for (;;) {
        sc_mutex_lock(&controller->mutex);
@ -90,14 +84,14 @@ run_controller(void *data) {
            sc_mutex_unlock(&controller->mutex);
            break;
        }
-        struct sc_control_msg msg;
+        struct control_msg msg;
        bool non_empty = cbuf_take(&controller->queue, &msg);
        assert(non_empty);
        (void) non_empty;
        sc_mutex_unlock(&controller->mutex);

        bool ok = process_msg(controller, &msg);
-        sc_control_msg_destroy(&msg);
+        control_msg_destroy(&msg);
        if (!ok) {
            LOGD("Could not write msg to socket");
            break;
@ -107,18 +101,18 @@ run_controller(void *data) {
 }

 bool
-sc_controller_start(struct sc_controller *controller) {
+controller_start(struct controller *controller) {
    LOGD("Starting controller thread");

    bool ok = sc_thread_create(&controller->thread, run_controller,
-                               "scrcpy-ctl", controller);
+                               "controller", controller);
    if (!ok) {
-        LOGE("Could not start controller thread");
+        LOGC("Could not start controller thread");
        return false;
    }

    if (!receiver_start(&controller->receiver)) {
-        sc_controller_stop(controller);
+        controller_stop(controller);
        sc_thread_join(&controller->thread, NULL);
        return false;
    }
@ -127,7 +121,7 @@ sc_controller_start(struct sc_controller *controller) {
 }

 void
-sc_controller_stop(struct sc_controller *controller) {
+controller_stop(struct controller *controller) {
    sc_mutex_lock(&controller->mutex);
    controller->stopped = true;
    sc_cond_signal(&controller->msg_cond);
@ -135,7 +129,7 @@ sc_controller_stop(struct sc_controller *controller) {
 }

 void
-sc_controller_join(struct sc_controller *controller) {
+controller_join(struct controller *controller) {
    sc_thread_join(&controller->thread, NULL);
    receiver_join(&controller->receiver);
 }
--- a/app/src/controller.h
+++ b/app/src/controller.h
@ -1,5 +1,5 @@
-#ifndef SC_CONTROLLER_H
-#define SC_CONTROLLER_H
+#ifndef CONTROLLER_H
+#define CONTROLLER_H

 #include "common.h"

@ -7,41 +7,39 @@

 #include "control_msg.h"
 #include "receiver.h"
-#include "util/acksync.h"
 #include "util/cbuf.h"
 #include "util/net.h"
 #include "util/thread.h"

-struct sc_control_msg_queue CBUF(struct sc_control_msg, 64);
+struct control_msg_queue CBUF(struct control_msg, 64);

-struct sc_controller {
-    sc_socket control_socket;
+struct controller {
+    socket_t control_socket;
    sc_thread thread;
    sc_mutex mutex;
    sc_cond msg_cond;
    bool stopped;
-    struct sc_control_msg_queue queue;
+    struct control_msg_queue queue;
    struct receiver receiver;
 };

 bool
-sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
-                   struct sc_acksync *acksync);
+controller_init(struct controller *controller, socket_t control_socket);

 void
-sc_controller_destroy(struct sc_controller *controller);
+controller_destroy(struct controller *controller);

 bool
-sc_controller_start(struct sc_controller *controller);
+controller_start(struct controller *controller);

 void
-sc_controller_stop(struct sc_controller *controller);
+controller_stop(struct controller *controller);

 void
-sc_controller_join(struct sc_controller *controller);
+controller_join(struct controller *controller);

 bool
-sc_controller_push_msg(struct sc_controller *controller,
-                       const struct sc_control_msg *msg);
+controller_push_msg(struct controller *controller,
+                    const struct control_msg *msg);

 #endif
--- a/app/src/coords.h
+++ b/app/src/coords.h
@ -3,22 +3,22 @@

 #include <stdint.h>

-struct sc_size {
+struct size {
    uint16_t width;
    uint16_t height;
 };

-struct sc_point {
+struct point {
    int32_t x;
    int32_t y;
 };

-struct sc_position {
+struct position {
    // The video screen size may be different from the real device screen size,
    // so store to which size the absolute position apply, to scale it
    // accordingly.
-    struct sc_size screen_size;
-    struct sc_point point;
+    struct size screen_size;
+    struct point point;
 };

 #endif
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@ -1,164 +1,97 @@
 #include "decoder.h"

-#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
+#include <libavutil/time.h>
+#include <SDL2/SDL_events.h>
+#include <unistd.h>

 #include "events.h"
+#include "recorder.h"
 #include "video_buffer.h"
-#include "trait/frame_sink.h"
+#include "util/buffer_util.h"
 #include "util/log.h"

-/** Downcast packet_sink to decoder */
-#define DOWNCAST(SINK) container_of(SINK, struct sc_decoder, packet_sink)
-
+// set the decoded frame as ready for rendering, and notify
 static void
-sc_decoder_close_first_sinks(struct sc_decoder *decoder, unsigned count) {
-    while (count) {
-        struct sc_frame_sink *sink = decoder->sinks[--count];
-        sink->ops->close(sink);
+push_frame(struct decoder *decoder) {
+    bool previous_frame_skipped;
+    video_buffer_offer_decoded_frame(decoder->video_buffer,
+                                     &previous_frame_skipped);
+    if (previous_frame_skipped) {
+        // the previous EVENT_NEW_FRAME will consume this frame
+        return;
    }
+    static SDL_Event new_frame_event = {
+        .type = EVENT_NEW_FRAME,
+    };
+    SDL_PushEvent(&new_frame_event);
 }

-static inline void
-sc_decoder_close_sinks(struct sc_decoder *decoder) {
-    sc_decoder_close_first_sinks(decoder, decoder->sink_count);
+void
+decoder_init(struct decoder *decoder, struct video_buffer *vb) {
+    decoder->video_buffer = vb;
 }

-static bool
-sc_decoder_open_sinks(struct sc_decoder *decoder) {
-    for (unsigned i = 0; i < decoder->sink_count; ++i) {
-        struct sc_frame_sink *sink = decoder->sinks[i];
-        if (!sink->ops->open(sink)) {
-            LOGE("Could not open frame sink %d", i);
-            sc_decoder_close_first_sinks(decoder, i);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static bool
-sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
+bool
+decoder_open(struct decoder *decoder, const AVCodec *codec) {
    decoder->codec_ctx = avcodec_alloc_context3(codec);
    if (!decoder->codec_ctx) {
-        LOG_OOM();
+        LOGC("Could not allocate decoder context");
        return false;
    }

-    decoder->codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;
-
    if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
        LOGE("Could not open codec");
        avcodec_free_context(&decoder->codec_ctx);
        return false;
    }

-    decoder->frame = av_frame_alloc();
-    if (!decoder->frame) {
-        LOG_OOM();
-        avcodec_close(decoder->codec_ctx);
-        avcodec_free_context(&decoder->codec_ctx);
-        return false;
-    }
-
-    if (!sc_decoder_open_sinks(decoder)) {
-        LOGE("Could not open decoder sinks");
-        av_frame_free(&decoder->frame);
-        avcodec_close(decoder->codec_ctx);
-        avcodec_free_context(&decoder->codec_ctx);
-        return false;
-    }
-
    return true;
 }

-static void
-sc_decoder_close(struct sc_decoder *decoder) {
-    sc_decoder_close_sinks(decoder);
-    av_frame_free(&decoder->frame);
+void
+decoder_close(struct decoder *decoder) {
    avcodec_close(decoder->codec_ctx);
    avcodec_free_context(&decoder->codec_ctx);
 }

-static bool
-push_frame_to_sinks(struct sc_decoder *decoder, const AVFrame *frame) {
-    for (unsigned i = 0; i < decoder->sink_count; ++i) {
-        struct sc_frame_sink *sink = decoder->sinks[i];
-        if (!sink->ops->push(sink, frame)) {
-            LOGE("Could not send frame to sink %d", i);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static bool
-sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {
-    bool is_config = packet->pts == AV_NOPTS_VALUE;
-    if (is_config) {
-        // nothing to do
-        return true;
-    }
-
-    int ret = avcodec_send_packet(decoder->codec_ctx, packet);
-    if (ret < 0 && ret != AVERROR(EAGAIN)) {
+bool
+decoder_push(struct decoder *decoder, const AVPacket *packet) {
+// the new decoding/encoding API has been introduced by:
+// <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=7fc329e2dd6226dfecaa4a1d7adf353bf2773726>
+#ifdef SCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
+    int ret;
+    if ((ret = avcodec_send_packet(decoder->codec_ctx, packet)) < 0) {
        LOGE("Could not send video packet: %d", ret);
        return false;
    }
-    ret = avcodec_receive_frame(decoder->codec_ctx, decoder->frame);
+    ret = avcodec_receive_frame(decoder->codec_ctx,
+                                decoder->video_buffer->decoding_frame);
    if (!ret) {
        // a frame was received
-        bool ok = push_frame_to_sinks(decoder, decoder->frame);
-        // A frame lost should not make the whole pipeline fail. The error, if
-        // any, is already logged.
-        (void) ok;
-
-        av_frame_unref(decoder->frame);
+        push_frame(decoder);
    } else if (ret != AVERROR(EAGAIN)) {
        LOGE("Could not receive video frame: %d", ret);
        return false;
    }
+#else
+    int got_picture;
+    int len = avcodec_decode_video2(decoder->codec_ctx,
+                                    decoder->video_buffer->decoding_frame,
+                                    &got_picture,
+                                    packet);
+    if (len < 0) {
+        LOGE("Could not decode video packet: %d", len);
+        return false;
+    }
+    if (got_picture) {
+        push_frame(decoder);
+    }
+#endif
    return true;
 }

-static bool
-sc_decoder_packet_sink_open(struct sc_packet_sink *sink, const AVCodec *codec) {
-    struct sc_decoder *decoder = DOWNCAST(sink);
-    return sc_decoder_open(decoder, codec);
-}
-
-static void
-sc_decoder_packet_sink_close(struct sc_packet_sink *sink) {
-    struct sc_decoder *decoder = DOWNCAST(sink);
-    sc_decoder_close(decoder);
-}
-
-static bool
-sc_decoder_packet_sink_push(struct sc_packet_sink *sink,
-                            const AVPacket *packet) {
-    struct sc_decoder *decoder = DOWNCAST(sink);
-    return sc_decoder_push(decoder, packet);
-}
-
 void
-sc_decoder_init(struct sc_decoder *decoder) {
-    decoder->sink_count = 0;
-
-    static const struct sc_packet_sink_ops ops = {
-        .open = sc_decoder_packet_sink_open,
-        .close = sc_decoder_packet_sink_close,
-        .push = sc_decoder_packet_sink_push,
-    };
-
-    decoder->packet_sink.ops = &ops;
-}
-
-void
-sc_decoder_add_sink(struct sc_decoder *decoder, struct sc_frame_sink *sink) {
-    assert(decoder->sink_count < SC_DECODER_MAX_SINKS);
-    assert(sink);
-    assert(sink->ops);
-    decoder->sinks[decoder->sink_count++] = sink;
+decoder_interrupt(struct decoder *decoder) {
+    video_buffer_interrupt(decoder->video_buffer);
 }
--- a/app/src/decoder.h
+++ b/app/src/decoder.h
@ -1,30 +1,31 @@
-#ifndef SC_DECODER_H
-#define SC_DECODER_H
+#ifndef DECODER_H
+#define DECODER_H

 #include "common.h"

-#include "trait/packet_sink.h"
-
 #include <stdbool.h>
-#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>

-#define SC_DECODER_MAX_SINKS 2
-
-struct sc_decoder {
-    struct sc_packet_sink packet_sink; // packet sink trait
-
-    struct sc_frame_sink *sinks[SC_DECODER_MAX_SINKS];
-    unsigned sink_count;
+struct video_buffer;

+struct decoder {
+    struct video_buffer *video_buffer;
    AVCodecContext *codec_ctx;
-    AVFrame *frame;
 };

 void
-sc_decoder_init(struct sc_decoder *decoder);
+decoder_init(struct decoder *decoder, struct video_buffer *vb);
+
+bool
+decoder_open(struct decoder *decoder, const AVCodec *codec);

 void
-sc_decoder_add_sink(struct sc_decoder *decoder, struct sc_frame_sink *sink);
+decoder_close(struct decoder *decoder);
+
+bool
+decoder_push(struct decoder *decoder, const AVPacket *packet);
+
+void
+decoder_interrupt(struct decoder *decoder);

 #endif
--- a/app/src/demuxer.c
+++ b/app/src/demuxer.c
@ -1,280 +0,0 @@
-#include "demuxer.h"
-
-#include <assert.h>
-#include <libavutil/time.h>
-#include <unistd.h>
-
-#include "decoder.h"
-#include "events.h"
-#include "recorder.h"
-#include "util/buffer_util.h"
-#include "util/log.h"
-
-#define SC_PACKET_HEADER_SIZE 12
-
-#define SC_PACKET_FLAG_CONFIG    (UINT64_C(1) << 63)
-#define SC_PACKET_FLAG_KEY_FRAME (UINT64_C(1) << 62)
-
-#define SC_PACKET_PTS_MASK (SC_PACKET_FLAG_KEY_FRAME - 1)
-
-static bool
-sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
-    // The video stream contains raw packets, without time information. When we
-    // record, we retrieve the timestamps separately, from a "meta" header
-    // added by the server before each raw packet.
-    //
-    // The "meta" header length is 12 bytes:
-    // [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
-    //  <-------------> <-----> <-----------------------------...
-    //        PTS        packet        raw packet
-    //                    size
-    //
-    // It is followed by <packet_size> bytes containing the packet/frame.
-    //
-    // 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
-    // | `- config packet
-    //  `-- key frame
-
-    uint8_t header[SC_PACKET_HEADER_SIZE];
-    ssize_t r = net_recv_all(demuxer->socket, header, SC_PACKET_HEADER_SIZE);
-    if (r < SC_PACKET_HEADER_SIZE) {
-        return false;
-    }
-
-    uint64_t pts_flags = sc_read64be(header);
-    uint32_t len = sc_read32be(&header[8]);
-    assert(len);
-
-    if (av_new_packet(packet, len)) {
-        LOG_OOM();
-        return false;
-    }
-
-    r = net_recv_all(demuxer->socket, packet->data, len);
-    if (r < 0 || ((uint32_t) r) < len) {
-        av_packet_unref(packet);
-        return false;
-    }
-
-    if (pts_flags & SC_PACKET_FLAG_CONFIG) {
-        packet->pts = AV_NOPTS_VALUE;
-    } else {
-        packet->pts = pts_flags & SC_PACKET_PTS_MASK;
-    }
-
-    if (pts_flags & SC_PACKET_FLAG_KEY_FRAME) {
-        packet->flags |= AV_PKT_FLAG_KEY;
-    }
-
-    packet->dts = packet->pts;
-    return true;
-}
-
-static bool
-push_packet_to_sinks(struct sc_demuxer *demuxer, const AVPacket *packet) {
-    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
-        struct sc_packet_sink *sink = demuxer->sinks[i];
-        if (!sink->ops->push(sink, packet)) {
-            LOGE("Could not send config packet to sink %d", i);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static bool
-sc_demuxer_push_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
-    bool is_config = packet->pts == AV_NOPTS_VALUE;
-
-    // A config packet must not be decoded immediately (it contains no
-    // frame); instead, it must be concatenated with the future data packet.
-    if (demuxer->pending || is_config) {
-        size_t offset;
-        if (demuxer->pending) {
-            offset = demuxer->pending->size;
-            if (av_grow_packet(demuxer->pending, packet->size)) {
-                LOG_OOM();
-                return false;
-            }
-        } else {
-            offset = 0;
-            demuxer->pending = av_packet_alloc();
-            if (!demuxer->pending) {
-                LOG_OOM();
-                return false;
-            }
-            if (av_new_packet(demuxer->pending, packet->size)) {
-                LOG_OOM();
-                av_packet_free(&demuxer->pending);
-                return false;
-            }
-        }
-
-        memcpy(demuxer->pending->data + offset, packet->data, packet->size);
-
-        if (!is_config) {
-            // prepare the concat packet to send to the decoder
-            demuxer->pending->pts = packet->pts;
-            demuxer->pending->dts = packet->dts;
-            demuxer->pending->flags = packet->flags;
-            packet = demuxer->pending;
-        }
-    }
-
-    bool ok = push_packet_to_sinks(demuxer, packet);
-
-    if (!is_config && demuxer->pending) {
-        // the pending packet must be discarded (consumed or error)
-        av_packet_free(&demuxer->pending);
-    }
-
-    if (!ok) {
-        LOGE("Could not process packet");
-        return false;
-    }
-
-    return true;
-}
-
-static void
-sc_demuxer_close_first_sinks(struct sc_demuxer *demuxer, unsigned count) {
-    while (count) {
-        struct sc_packet_sink *sink = demuxer->sinks[--count];
-        sink->ops->close(sink);
-    }
-}
-
-static inline void
-sc_demuxer_close_sinks(struct sc_demuxer *demuxer) {
-    sc_demuxer_close_first_sinks(demuxer, demuxer->sink_count);
-}
-
-static bool
-sc_demuxer_open_sinks(struct sc_demuxer *demuxer, const AVCodec *codec) {
-    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
-        struct sc_packet_sink *sink = demuxer->sinks[i];
-        if (!sink->ops->open(sink, codec)) {
-            LOGE("Could not open packet sink %d", i);
-            sc_demuxer_close_first_sinks(demuxer, i);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static int
-run_demuxer(void *data) {
-    struct sc_demuxer *demuxer = data;
-
-    const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
-    if (!codec) {
-        LOGE("H.264 decoder not found");
-        goto end;
-    }
-
-    demuxer->codec_ctx = avcodec_alloc_context3(codec);
-    if (!demuxer->codec_ctx) {
-        LOG_OOM();
-        goto end;
-    }
-
-    if (!sc_demuxer_open_sinks(demuxer, codec)) {
-        LOGE("Could not open demuxer sinks");
-        goto finally_free_codec_ctx;
-    }
-
-    demuxer->parser = av_parser_init(AV_CODEC_ID_H264);
-    if (!demuxer->parser) {
-        LOGE("Could not initialize parser");
-        goto finally_close_sinks;
-    }
-
-    // We must only pass complete frames to av_parser_parse2()!
-    // It's more complicated, but this allows to reduce the latency by 1 frame!
-    demuxer->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
-
-    AVPacket *packet = av_packet_alloc();
-    if (!packet) {
-        LOG_OOM();
-        goto finally_close_parser;
-    }
-
-    for (;;) {
-        bool ok = sc_demuxer_recv_packet(demuxer, packet);
-        if (!ok) {
-            // end of stream
-            break;
-        }
-
-        ok = sc_demuxer_push_packet(demuxer, packet);
-        av_packet_unref(packet);
-        if (!ok) {
-            // cannot process packet (error already logged)
-            break;
-        }
-    }
-
-    LOGD("End of frames");
-
-    if (demuxer->pending) {
-        av_packet_free(&demuxer->pending);
-    }
-
-    av_packet_free(&packet);
-finally_close_parser:
-    av_parser_close(demuxer->parser);
-finally_close_sinks:
-    sc_demuxer_close_sinks(demuxer);
-finally_free_codec_ctx:
-    avcodec_free_context(&demuxer->codec_ctx);
-end:
-    demuxer->cbs->on_eos(demuxer, demuxer->cbs_userdata);
-
-    return 0;
-}
-
-void
-sc_demuxer_init(struct sc_demuxer *demuxer, sc_socket socket,
-                const struct sc_demuxer_callbacks *cbs, void *cbs_userdata) {
-    demuxer->socket = socket;
-    demuxer->pending = NULL;
-    demuxer->sink_count = 0;
-
-    assert(cbs && cbs->on_eos);
-
-    demuxer->cbs = cbs;
-    demuxer->cbs_userdata = cbs_userdata;
-}
-
-void
-sc_demuxer_add_sink(struct sc_demuxer *demuxer, struct sc_packet_sink *sink) {
-    assert(demuxer->sink_count < SC_DEMUXER_MAX_SINKS);
-    assert(sink);
-    assert(sink->ops);
-    demuxer->sinks[demuxer->sink_count++] = sink;
-}
-
-bool
-sc_demuxer_start(struct sc_demuxer *demuxer) {
-    LOGD("Starting demuxer thread");
-
-    bool ok = sc_thread_create(&demuxer->thread, run_demuxer, "scrcpy-demuxer",
-                               demuxer);
-    if (!ok) {
-        LOGE("Could not start demuxer thread");
-        return false;
-    }
-    return true;
-}
-
-void
-sc_demuxer_join(struct sc_demuxer *demuxer) {
-    sc_thread_join(&demuxer->thread, NULL);
-}
--- a/app/src/demuxer.h
+++ b/app/src/demuxer.h
@ -1,51 +0,0 @@
-#ifndef SC_DEMUXER_H
-#define SC_DEMUXER_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-
-#include "trait/packet_sink.h"
-#include "util/net.h"
-#include "util/thread.h"
-
-#define SC_DEMUXER_MAX_SINKS 2
-
-struct sc_demuxer {
-    sc_socket socket;
-    sc_thread thread;
-
-    struct sc_packet_sink *sinks[SC_DEMUXER_MAX_SINKS];
-    unsigned sink_count;
-
-    AVCodecContext *codec_ctx;
-    AVCodecParserContext *parser;
-    // successive packets may need to be concatenated, until a non-config
-    // packet is available
-    AVPacket *pending;
-
-    const struct sc_demuxer_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct sc_demuxer_callbacks {
-    void (*on_eos)(struct sc_demuxer *demuxer, void *userdata);
-};
-
-void
-sc_demuxer_init(struct sc_demuxer *demuxer, sc_socket socket,
-                const struct sc_demuxer_callbacks *cbs, void *cbs_userdata);
-
-void
-sc_demuxer_add_sink(struct sc_demuxer *demuxer, struct sc_packet_sink *sink);
-
-bool
-sc_demuxer_start(struct sc_demuxer *demuxer);
-
-void
-sc_demuxer_join(struct sc_demuxer *demuxer);
-
-#endif
--- a/app/src/device.c
+++ b/app/src/device.c
@ -0,0 +1,23 @@
+#include "device.h"
+
+#include "util/log.h"
+
+bool
+device_read_info(socket_t device_socket, char *device_name, struct size *size) {
+    unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
+    int r = net_recv_all(device_socket, buf, sizeof(buf));
+    if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
+        LOGE("Could not retrieve device information");
+        return false;
+    }
+    // in case the client sends garbage
+    buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
+    // strcpy is safe here, since name contains at least
+    // DEVICE_NAME_FIELD_LENGTH bytes and strlen(buf) < DEVICE_NAME_FIELD_LENGTH
+    strcpy(device_name, (char *) buf);
+    size->width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
+            | buf[DEVICE_NAME_FIELD_LENGTH + 1];
+    size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
+            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
+    return true;
+}
--- a/app/src/device.h
+++ b/app/src/device.h
@ -0,0 +1,17 @@
+#ifndef DEVICE_H
+#define DEVICE_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "coords.h"
+#include "util/net.h"
+
+#define DEVICE_NAME_FIELD_LENGTH 64
+
+// name must be at least DEVICE_NAME_FIELD_LENGTH bytes
+bool
+device_read_info(socket_t device_socket, char *device_name, struct size *size);
+
+#endif
--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@ -1,6 +1,5 @@
 #include "device_msg.h"

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

@ -18,13 +17,13 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
    msg->type = buf[0];
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
-            size_t clipboard_len = sc_read32be(&buf[1]);
+            size_t clipboard_len = buffer_read32be(&buf[1]);
            if (clipboard_len > len - 5) {
                return 0; // not available
            }
            char *text = malloc(clipboard_len + 1);
            if (!text) {
-                LOG_OOM();
+                LOGW("Could not allocate text for clipboard");
                return -1;
            }
            if (clipboard_len) {
@ -35,11 +34,6 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
            msg->clipboard.text = text;
            return 5 + clipboard_len;
        }
-        case DEVICE_MSG_TYPE_ACK_CLIPBOARD: {
-            uint64_t sequence = sc_read64be(&buf[1]);
-            msg->ack_clipboard.sequence = sequence;
-            return 9;
-        }
        default:
            LOGW("Unknown device message type: %d", (int) msg->type);
            return -1; // error, we cannot recover
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@ -1,5 +1,5 @@
-#ifndef SC_DEVICEMSG_H
-#define SC_DEVICEMSG_H
+#ifndef DEVICEMSG_H
+#define DEVICEMSG_H

 #include "common.h"

@ -13,7 +13,6 @@

 enum device_msg_type {
    DEVICE_MSG_TYPE_CLIPBOARD,
-    DEVICE_MSG_TYPE_ACK_CLIPBOARD,
 };

 struct device_msg {
@ -22,9 +21,6 @@ struct device_msg {
        struct {
            char *text; // owned, to be freed by free()
        } clipboard;
-        struct {
-            uint64_t sequence;
-        } ack_clipboard;
    };
 };

--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@ -0,0 +1,195 @@
+#include "event_converter.h"
+
+#define MAP(FROM, TO) case FROM: *to = TO; return true
+#define FAIL default: return false
+
+bool
+convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
+    switch (from) {
+        MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
+        MAP(SDL_KEYUP,   AKEY_EVENT_ACTION_UP);
+        FAIL;
+    }
+}
+
+static enum android_metastate
+autocomplete_metastate(enum android_metastate metastate) {
+    // fill dependant flags
+    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
+        metastate |= AMETA_SHIFT_ON;
+    }
+    if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
+        metastate |= AMETA_CTRL_ON;
+    }
+    if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
+        metastate |= AMETA_ALT_ON;
+    }
+    if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
+        metastate |= AMETA_META_ON;
+    }
+
+    return metastate;
+}
+
+enum android_metastate
+convert_meta_state(SDL_Keymod mod) {
+    enum android_metastate metastate = 0;
+    if (mod & KMOD_LSHIFT) {
+        metastate |= AMETA_SHIFT_LEFT_ON;
+    }
+    if (mod & KMOD_RSHIFT) {
+        metastate |= AMETA_SHIFT_RIGHT_ON;
+    }
+    if (mod & KMOD_LCTRL) {
+        metastate |= AMETA_CTRL_LEFT_ON;
+    }
+    if (mod & KMOD_RCTRL) {
+        metastate |= AMETA_CTRL_RIGHT_ON;
+    }
+    if (mod & KMOD_LALT) {
+        metastate |= AMETA_ALT_LEFT_ON;
+    }
+    if (mod & KMOD_RALT) {
+        metastate |= AMETA_ALT_RIGHT_ON;
+    }
+    if (mod & KMOD_LGUI) { // Windows key
+        metastate |= AMETA_META_LEFT_ON;
+    }
+    if (mod & KMOD_RGUI) { // Windows key
+        metastate |= AMETA_META_RIGHT_ON;
+    }
+    if (mod & KMOD_NUM) {
+        metastate |= AMETA_NUM_LOCK_ON;
+    }
+    if (mod & KMOD_CAPS) {
+        metastate |= AMETA_CAPS_LOCK_ON;
+    }
+    if (mod & KMOD_MODE) { // Alt Gr
+        // no mapping?
+    }
+
+    // fill the dependent fields
+    return autocomplete_metastate(metastate);
+}
+
+bool
+convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
+                bool prefer_text) {
+    switch (from) {
+        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
+        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
+        MAP(SDLK_ESCAPE,       AKEYCODE_ESCAPE);
+        MAP(SDLK_BACKSPACE,    AKEYCODE_DEL);
+        MAP(SDLK_TAB,          AKEYCODE_TAB);
+        MAP(SDLK_PAGEUP,       AKEYCODE_PAGE_UP);
+        MAP(SDLK_DELETE,       AKEYCODE_FORWARD_DEL);
+        MAP(SDLK_HOME,         AKEYCODE_MOVE_HOME);
+        MAP(SDLK_END,          AKEYCODE_MOVE_END);
+        MAP(SDLK_PAGEDOWN,     AKEYCODE_PAGE_DOWN);
+        MAP(SDLK_RIGHT,        AKEYCODE_DPAD_RIGHT);
+        MAP(SDLK_LEFT,         AKEYCODE_DPAD_LEFT);
+        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
+        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
+        MAP(SDLK_LCTRL,        AKEYCODE_CTRL_LEFT);
+        MAP(SDLK_RCTRL,        AKEYCODE_CTRL_RIGHT);
+        MAP(SDLK_LSHIFT,       AKEYCODE_SHIFT_LEFT);
+        MAP(SDLK_RSHIFT,       AKEYCODE_SHIFT_RIGHT);
+    }
+
+    if (!(mod & (KMOD_NUM | KMOD_SHIFT))) {
+        // Handle Numpad events when Num Lock is disabled
+        // If SHIFT is pressed, a text event will be sent instead
+        switch(from) {
+            MAP(SDLK_KP_0,            AKEYCODE_INSERT);
+            MAP(SDLK_KP_1,            AKEYCODE_MOVE_END);
+            MAP(SDLK_KP_2,            AKEYCODE_DPAD_DOWN);
+            MAP(SDLK_KP_3,            AKEYCODE_PAGE_DOWN);
+            MAP(SDLK_KP_4,            AKEYCODE_DPAD_LEFT);
+            MAP(SDLK_KP_6,            AKEYCODE_DPAD_RIGHT);
+            MAP(SDLK_KP_7,            AKEYCODE_MOVE_HOME);
+            MAP(SDLK_KP_8,            AKEYCODE_DPAD_UP);
+            MAP(SDLK_KP_9,            AKEYCODE_PAGE_UP);
+            MAP(SDLK_KP_PERIOD,       AKEYCODE_FORWARD_DEL);
+        }
+    }
+
+    if (prefer_text && !(mod & KMOD_CTRL)) {
+        // do not forward alpha and space key events (unless Ctrl is pressed)
+        return false;
+    }
+
+    if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
+        return false;
+    }
+    // if ALT and META are not pressed, also handle letters and space
+    switch (from) {
+        MAP(SDLK_a,            AKEYCODE_A);
+        MAP(SDLK_b,            AKEYCODE_B);
+        MAP(SDLK_c,            AKEYCODE_C);
+        MAP(SDLK_d,            AKEYCODE_D);
+        MAP(SDLK_e,            AKEYCODE_E);
+        MAP(SDLK_f,            AKEYCODE_F);
+        MAP(SDLK_g,            AKEYCODE_G);
+        MAP(SDLK_h,            AKEYCODE_H);
+        MAP(SDLK_i,            AKEYCODE_I);
+        MAP(SDLK_j,            AKEYCODE_J);
+        MAP(SDLK_k,            AKEYCODE_K);
+        MAP(SDLK_l,            AKEYCODE_L);
+        MAP(SDLK_m,            AKEYCODE_M);
+        MAP(SDLK_n,            AKEYCODE_N);
+        MAP(SDLK_o,            AKEYCODE_O);
+        MAP(SDLK_p,            AKEYCODE_P);
+        MAP(SDLK_q,            AKEYCODE_Q);
+        MAP(SDLK_r,            AKEYCODE_R);
+        MAP(SDLK_s,            AKEYCODE_S);
+        MAP(SDLK_t,            AKEYCODE_T);
+        MAP(SDLK_u,            AKEYCODE_U);
+        MAP(SDLK_v,            AKEYCODE_V);
+        MAP(SDLK_w,            AKEYCODE_W);
+        MAP(SDLK_x,            AKEYCODE_X);
+        MAP(SDLK_y,            AKEYCODE_Y);
+        MAP(SDLK_z,            AKEYCODE_Z);
+        MAP(SDLK_SPACE,        AKEYCODE_SPACE);
+        FAIL;
+    }
+}
+
+enum android_motionevent_buttons
+convert_mouse_buttons(uint32_t state) {
+    enum android_motionevent_buttons buttons = 0;
+    if (state & SDL_BUTTON_LMASK) {
+        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
+    }
+    if (state & SDL_BUTTON_RMASK) {
+        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
+    }
+    if (state & SDL_BUTTON_MMASK) {
+        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
+    }
+    if (state & SDL_BUTTON_X1MASK) {
+        buttons |= AMOTION_EVENT_BUTTON_BACK;
+    }
+    if (state & SDL_BUTTON_X2MASK) {
+        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
+    }
+    return buttons;
+}
+
+bool
+convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
+    switch (from) {
+        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
+        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
+        FAIL;
+    }
+}
+
+bool
+convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
+    switch (from) {
+        MAP(SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE);
+        MAP(SDL_FINGERDOWN,   AMOTION_EVENT_ACTION_DOWN);
+        MAP(SDL_FINGERUP,     AMOTION_EVENT_ACTION_UP);
+        FAIL;
+    }
+}
--- a/app/src/event_converter.h
+++ b/app/src/event_converter.h
@ -0,0 +1,30 @@
+#ifndef CONVERT_H
+#define CONVERT_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <SDL2/SDL_events.h>
+
+#include "control_msg.h"
+
+bool
+convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to);
+
+enum android_metastate
+convert_meta_state(SDL_Keymod mod);
+
+bool
+convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
+                bool prefer_text);
+
+enum android_motionevent_buttons
+convert_mouse_buttons(uint32_t state);
+
+bool
+convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to);
+
+bool
+convert_touch_action(SDL_EventType from, enum android_motionevent_action *to);
+
+#endif
--- a/app/src/events.h
+++ b/app/src/events.h
@ -1,5 +1,3 @@
-#define EVENT_NEW_FRAME                 SDL_USEREVENT
-#define EVENT_STREAM_STOPPED           (SDL_USEREVENT + 1)
-#define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
-#define EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
-#define EVENT_USB_DEVICE_DISCONNECTED  (SDL_USEREVENT + 4)
+#define EVENT_NEW_SESSION SDL_USEREVENT
+#define EVENT_NEW_FRAME (SDL_USEREVENT + 1)
+#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 2)
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@ -0,0 +1,197 @@
+#include "file_handler.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "adb.h"
+#include "util/log.h"
+
+#define DEFAULT_PUSH_TARGET "/sdcard/"
+
+static void
+file_handler_request_destroy(struct file_handler_request *req) {
+    free(req->file);
+}
+
+bool
+file_handler_init(struct file_handler *file_handler, const char *serial,
+                  const char *push_target) {
+
+    cbuf_init(&file_handler->queue);
+
+    bool ok = sc_mutex_init(&file_handler->mutex);
+    if (!ok) {
+        return false;
+    }
+
+    ok = sc_cond_init(&file_handler->event_cond);
+    if (!ok) {
+        sc_mutex_destroy(&file_handler->mutex);
+        return false;
+    }
+
+    if (serial) {
+        file_handler->serial = strdup(serial);
+        if (!file_handler->serial) {
+            LOGW("Could not strdup serial");
+            sc_cond_destroy(&file_handler->event_cond);
+            sc_mutex_destroy(&file_handler->mutex);
+            return false;
+        }
+    } else {
+        file_handler->serial = NULL;
+    }
+
+    // lazy initialization
+    file_handler->initialized = false;
+
+    file_handler->stopped = false;
+    file_handler->current_process = PROCESS_NONE;
+
+    file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
+
+    return true;
+}
+
+void
+file_handler_destroy(struct file_handler *file_handler) {
+    sc_cond_destroy(&file_handler->event_cond);
+    sc_mutex_destroy(&file_handler->mutex);
+    free(file_handler->serial);
+
+    struct file_handler_request req;
+    while (cbuf_take(&file_handler->queue, &req)) {
+        file_handler_request_destroy(&req);
+    }
+}
+
+static process_t
+install_apk(const char *serial, const char *file) {
+    return adb_install(serial, file);
+}
+
+static process_t
+push_file(const char *serial, const char *file, const char *push_target) {
+    return adb_push(serial, file, push_target);
+}
+
+bool
+file_handler_request(struct file_handler *file_handler,
+                     file_handler_action_t action, char *file) {
+    // start file_handler if it's used for the first time
+    if (!file_handler->initialized) {
+        if (!file_handler_start(file_handler)) {
+            return false;
+        }
+        file_handler->initialized = true;
+    }
+
+    LOGI("Request to %s %s", action == ACTION_INSTALL_APK ? "install" : "push",
+                             file);
+    struct file_handler_request req = {
+        .action = action,
+        .file = file,
+    };
+
+    sc_mutex_lock(&file_handler->mutex);
+    bool was_empty = cbuf_is_empty(&file_handler->queue);
+    bool res = cbuf_push(&file_handler->queue, req);
+    if (was_empty) {
+        sc_cond_signal(&file_handler->event_cond);
+    }
+    sc_mutex_unlock(&file_handler->mutex);
+    return res;
+}
+
+static int
+run_file_handler(void *data) {
+    struct file_handler *file_handler = data;
+
+    for (;;) {
+        sc_mutex_lock(&file_handler->mutex);
+        file_handler->current_process = PROCESS_NONE;
+        while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
+            sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
+        }
+        if (file_handler->stopped) {
+            // stop immediately, do not process further events
+            sc_mutex_unlock(&file_handler->mutex);
+            break;
+        }
+        struct file_handler_request req;
+        bool non_empty = cbuf_take(&file_handler->queue, &req);
+        assert(non_empty);
+        (void) non_empty;
+
+        process_t process;
+        if (req.action == ACTION_INSTALL_APK) {
+            LOGI("Installing %s...", req.file);
+            process = install_apk(file_handler->serial, req.file);
+        } else {
+            LOGI("Pushing %s...", req.file);
+            process = push_file(file_handler->serial, req.file,
+                                file_handler->push_target);
+        }
+        file_handler->current_process = process;
+        sc_mutex_unlock(&file_handler->mutex);
+
+        if (req.action == ACTION_INSTALL_APK) {
+            if (process_check_success(process, "adb install", false)) {
+                LOGI("%s successfully installed", req.file);
+            } else {
+                LOGE("Failed to install %s", req.file);
+            }
+        } else {
+            if (process_check_success(process, "adb push", false)) {
+                LOGI("%s successfully pushed to %s", req.file,
+                                                     file_handler->push_target);
+            } else {
+                LOGE("Failed to push %s to %s", req.file,
+                                                file_handler->push_target);
+            }
+        }
+
+        sc_mutex_lock(&file_handler->mutex);
+        // Close the process (it is necessary already terminated)
+        // Execute this call with mutex locked to avoid race conditions with
+        // file_handler_stop()
+        process_close(file_handler->current_process);
+        file_handler->current_process = PROCESS_NONE;
+        sc_mutex_unlock(&file_handler->mutex);
+
+        file_handler_request_destroy(&req);
+    }
+    return 0;
+}
+
+bool
+file_handler_start(struct file_handler *file_handler) {
+    LOGD("Starting file_handler thread");
+
+    bool ok = sc_thread_create(&file_handler->thread, run_file_handler,
+                               "file_handler", file_handler);
+    if (!ok) {
+        LOGC("Could not start file_handler thread");
+        return false;
+    }
+
+    return true;
+}
+
+void
+file_handler_stop(struct file_handler *file_handler) {
+    sc_mutex_lock(&file_handler->mutex);
+    file_handler->stopped = true;
+    sc_cond_signal(&file_handler->event_cond);
+    if (file_handler->current_process != PROCESS_NONE) {
+        if (!process_terminate(file_handler->current_process)) {
+            LOGW("Could not terminate push/install process");
+        }
+    }
+    sc_mutex_unlock(&file_handler->mutex);
+}
+
+void
+file_handler_join(struct file_handler *file_handler) {
+    sc_thread_join(&file_handler->thread, NULL);
+}
--- a/app/src/file_handler.h
+++ b/app/src/file_handler.h
@ -0,0 +1,58 @@
+#ifndef FILE_HANDLER_H
+#define FILE_HANDLER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "adb.h"
+#include "util/cbuf.h"
+#include "util/thread.h"
+
+typedef enum {
+    ACTION_INSTALL_APK,
+    ACTION_PUSH_FILE,
+} file_handler_action_t;
+
+struct file_handler_request {
+    file_handler_action_t action;
+    char *file;
+};
+
+struct file_handler_request_queue CBUF(struct file_handler_request, 16);
+
+struct file_handler {
+    char *serial;
+    const char *push_target;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond event_cond;
+    bool stopped;
+    bool initialized;
+    process_t current_process;
+    struct file_handler_request_queue queue;
+};
+
+bool
+file_handler_init(struct file_handler *file_handler, const char *serial,
+                  const char *push_target);
+
+void
+file_handler_destroy(struct file_handler *file_handler);
+
+bool
+file_handler_start(struct file_handler *file_handler);
+
+void
+file_handler_stop(struct file_handler *file_handler);
+
+void
+file_handler_join(struct file_handler *file_handler);
+
+// take ownership of file, and will free() it
+bool
+file_handler_request(struct file_handler *file_handler,
+                     file_handler_action_t action,
+                     char *file);
+
+#endif
--- a/app/src/file_pusher.c
+++ b/app/src/file_pusher.c
@ -1,178 +0,0 @@
-#include "file_pusher.h"
-
-#include <assert.h>
-#include <string.h>
-
-#include "adb/adb.h"
-#include "util/log.h"
-#include "util/process_intr.h"
-
-#define DEFAULT_PUSH_TARGET "/sdcard/Download/"
-
-static void
-sc_file_pusher_request_destroy(struct sc_file_pusher_request *req) {
-    free(req->file);
-}
-
-bool
-sc_file_pusher_init(struct sc_file_pusher *fp, const char *serial,
-                    const char *push_target) {
-    assert(serial);
-
-    cbuf_init(&fp->queue);
-
-    bool ok = sc_mutex_init(&fp->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&fp->event_cond);
-    if (!ok) {
-        sc_mutex_destroy(&fp->mutex);
-        return false;
-    }
-
-    ok = sc_intr_init(&fp->intr);
-    if (!ok) {
-        sc_cond_destroy(&fp->event_cond);
-        sc_mutex_destroy(&fp->mutex);
-        return false;
-    }
-
-    fp->serial = strdup(serial);
-    if (!fp->serial) {
-        LOG_OOM();
-        sc_intr_destroy(&fp->intr);
-        sc_cond_destroy(&fp->event_cond);
-        sc_mutex_destroy(&fp->mutex);
-        return false;
-    }
-
-    // lazy initialization
-    fp->initialized = false;
-
-    fp->stopped = false;
-
-    fp->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
-
-    return true;
-}
-
-void
-sc_file_pusher_destroy(struct sc_file_pusher *fp) {
-    sc_cond_destroy(&fp->event_cond);
-    sc_mutex_destroy(&fp->mutex);
-    sc_intr_destroy(&fp->intr);
-    free(fp->serial);
-
-    struct sc_file_pusher_request req;
-    while (cbuf_take(&fp->queue, &req)) {
-        sc_file_pusher_request_destroy(&req);
-    }
-}
-
-bool
-sc_file_pusher_request(struct sc_file_pusher *fp,
-                       enum sc_file_pusher_action action, char *file) {
-    // start file_pusher if it's used for the first time
-    if (!fp->initialized) {
-        if (!sc_file_pusher_start(fp)) {
-            return false;
-        }
-        fp->initialized = true;
-    }
-
-    LOGI("Request to %s %s", action == SC_FILE_PUSHER_ACTION_INSTALL_APK
-                                 ? "install" : "push",
-                             file);
-    struct sc_file_pusher_request req = {
-        .action = action,
-        .file = file,
-    };
-
-    sc_mutex_lock(&fp->mutex);
-    bool was_empty = cbuf_is_empty(&fp->queue);
-    bool res = cbuf_push(&fp->queue, req);
-    if (was_empty) {
-        sc_cond_signal(&fp->event_cond);
-    }
-    sc_mutex_unlock(&fp->mutex);
-    return res;
-}
-
-static int
-run_file_pusher(void *data) {
-    struct sc_file_pusher *fp = data;
-    struct sc_intr *intr = &fp->intr;
-
-    const char *serial = fp->serial;
-    assert(serial);
-
-    const char *push_target = fp->push_target;
-    assert(push_target);
-
-    for (;;) {
-        sc_mutex_lock(&fp->mutex);
-        while (!fp->stopped && cbuf_is_empty(&fp->queue)) {
-            sc_cond_wait(&fp->event_cond, &fp->mutex);
-        }
-        if (fp->stopped) {
-            // stop immediately, do not process further events
-            sc_mutex_unlock(&fp->mutex);
-            break;
-        }
-        struct sc_file_pusher_request req;
-        bool non_empty = cbuf_take(&fp->queue, &req);
-        assert(non_empty);
-        (void) non_empty;
-        sc_mutex_unlock(&fp->mutex);
-
-        if (req.action == SC_FILE_PUSHER_ACTION_INSTALL_APK) {
-            LOGI("Installing %s...", req.file);
-            bool ok = sc_adb_install(intr, serial, req.file, 0);
-            if (ok) {
-                LOGI("%s successfully installed", req.file);
-            } else {
-                LOGE("Failed to install %s", req.file);
-            }
-        } else {
-            LOGI("Pushing %s...", req.file);
-            bool ok = sc_adb_push(intr, serial, req.file, push_target, 0);
-            if (ok) {
-                LOGI("%s successfully pushed to %s", req.file, push_target);
-            } else {
-                LOGE("Failed to push %s to %s", req.file, push_target);
-            }
-        }
-
-        sc_file_pusher_request_destroy(&req);
-    }
-    return 0;
-}
-
-bool
-sc_file_pusher_start(struct sc_file_pusher *fp) {
-    LOGD("Starting file_pusher thread");
-
-    bool ok = sc_thread_create(&fp->thread, run_file_pusher, "scrcpy-file", fp);
-    if (!ok) {
-        LOGE("Could not start file_pusher thread");
-        return false;
-    }
-
-    return true;
-}
-
-void
-sc_file_pusher_stop(struct sc_file_pusher *fp) {
-    sc_mutex_lock(&fp->mutex);
-    fp->stopped = true;
-    sc_cond_signal(&fp->event_cond);
-    sc_intr_interrupt(&fp->intr);
-    sc_mutex_unlock(&fp->mutex);
-}
-
-void
-sc_file_pusher_join(struct sc_file_pusher *fp) {
-    sc_thread_join(&fp->thread, NULL);
-}
--- a/app/src/file_pusher.h
+++ b/app/src/file_pusher.h
@ -1,58 +0,0 @@
-#ifndef SC_FILE_PUSHER_H
-#define SC_FILE_PUSHER_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "util/cbuf.h"
-#include "util/thread.h"
-#include "util/intr.h"
-
-enum sc_file_pusher_action {
-    SC_FILE_PUSHER_ACTION_INSTALL_APK,
-    SC_FILE_PUSHER_ACTION_PUSH_FILE,
-};
-
-struct sc_file_pusher_request {
-    enum sc_file_pusher_action action;
-    char *file;
-};
-
-struct sc_file_pusher_request_queue CBUF(struct sc_file_pusher_request, 16);
-
-struct sc_file_pusher {
-    char *serial;
-    const char *push_target;
-    sc_thread thread;
-    sc_mutex mutex;
-    sc_cond event_cond;
-    bool stopped;
-    bool initialized;
-    struct sc_file_pusher_request_queue queue;
-
-    struct sc_intr intr;
-};
-
-bool
-sc_file_pusher_init(struct sc_file_pusher *fp, const char *serial,
-                    const char *push_target);
-
-void
-sc_file_pusher_destroy(struct sc_file_pusher *fp);
-
-bool
-sc_file_pusher_start(struct sc_file_pusher *fp);
-
-void
-sc_file_pusher_stop(struct sc_file_pusher *fp);
-
-void
-sc_file_pusher_join(struct sc_file_pusher *fp);
-
-// take ownership of file, and will free() it
-bool
-sc_file_pusher_request(struct sc_file_pusher *fp,
-                       enum sc_file_pusher_action action, char *file);
-
-#endif
--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@ -1,13 +1,14 @@
 #include "fps_counter.h"

 #include <assert.h>
+#include <SDL2/SDL_timer.h>

 #include "util/log.h"

-#define SC_FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1)
+#define FPS_COUNTER_INTERVAL_MS 1000

 bool
-sc_fps_counter_init(struct sc_fps_counter *counter) {
+fps_counter_init(struct fps_counter *counter) {
    bool ok = sc_mutex_init(&counter->mutex);
    if (!ok) {
        return false;
@ -27,26 +28,26 @@ sc_fps_counter_init(struct sc_fps_counter *counter) {
 }

 void
-sc_fps_counter_destroy(struct sc_fps_counter *counter) {
+fps_counter_destroy(struct fps_counter *counter) {
    sc_cond_destroy(&counter->state_cond);
    sc_mutex_destroy(&counter->mutex);
 }

 static inline bool
-is_started(struct sc_fps_counter *counter) {
+is_started(struct fps_counter *counter) {
    return atomic_load_explicit(&counter->started, memory_order_acquire);
 }

 static inline void
-set_started(struct sc_fps_counter *counter, bool started) {
+set_started(struct fps_counter *counter, bool started) {
    atomic_store_explicit(&counter->started, started, memory_order_release);
 }

 // must be called with mutex locked
 static void
-display_fps(struct sc_fps_counter *counter) {
+display_fps(struct fps_counter *counter) {
    unsigned rendered_per_second =
-        counter->nr_rendered * SC_TICK_FREQ / SC_FPS_COUNTER_INTERVAL;
+        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;
    if (counter->nr_skipped) {
        LOGI("%u fps (+%u frames skipped)", rendered_per_second,
                                            counter->nr_skipped);
@ -57,7 +58,7 @@ display_fps(struct sc_fps_counter *counter) {

 // must be called with mutex locked
 static void
-check_interval_expired(struct sc_fps_counter *counter, sc_tick now) {
+check_interval_expired(struct fps_counter *counter, uint32_t now) {
    if (now < counter->next_timestamp) {
        return;
    }
@ -67,13 +68,13 @@ check_interval_expired(struct sc_fps_counter *counter, sc_tick now) {
    counter->nr_skipped = 0;
    // add a multiple of the interval
    uint32_t elapsed_slices =
-        (now - counter->next_timestamp) / SC_FPS_COUNTER_INTERVAL + 1;
-    counter->next_timestamp += SC_FPS_COUNTER_INTERVAL * elapsed_slices;
+        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL_MS + 1;
+    counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;
 }

 static int
 run_fps_counter(void *data) {
-    struct sc_fps_counter *counter = data;
+    struct fps_counter *counter = data;

    sc_mutex_lock(&counter->mutex);
    while (!counter->interrupted) {
@ -81,12 +82,14 @@ run_fps_counter(void *data) {
            sc_cond_wait(&counter->state_cond, &counter->mutex);
        }
        while (!counter->interrupted && is_started(counter)) {
-            sc_tick now = sc_tick_now();
+            uint32_t now = SDL_GetTicks();
            check_interval_expired(counter, now);

+            assert(counter->next_timestamp > now);
+            uint32_t remaining = counter->next_timestamp - now;
+
            // ignore the reason (timeout or signaled), we just loop anyway
-            sc_cond_timedwait(&counter->state_cond, &counter->mutex,
-                              counter->next_timestamp);
+            sc_cond_timedwait(&counter->state_cond, &counter->mutex, remaining);
        }
    }
    sc_mutex_unlock(&counter->mutex);
@ -94,9 +97,9 @@ run_fps_counter(void *data) {
 }

 bool
-sc_fps_counter_start(struct sc_fps_counter *counter) {
+fps_counter_start(struct fps_counter *counter) {
    sc_mutex_lock(&counter->mutex);
-    counter->next_timestamp = sc_tick_now() + SC_FPS_COUNTER_INTERVAL;
+    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
    counter->nr_rendered = 0;
    counter->nr_skipped = 0;
    sc_mutex_unlock(&counter->mutex);
@ -108,7 +111,7 @@ sc_fps_counter_start(struct sc_fps_counter *counter) {
    // same thread, no need to lock
    if (!counter->thread_started) {
        bool ok = sc_thread_create(&counter->thread, run_fps_counter,
-                                   "scrcpy-fps", counter);
+                                   "fps counter", counter);
        if (!ok) {
            LOGE("Could not start FPS counter thread");
            return false;
@ -117,24 +120,22 @@ sc_fps_counter_start(struct sc_fps_counter *counter) {
        counter->thread_started = true;
    }

-    LOGI("FPS counter started");
    return true;
 }

 void
-sc_fps_counter_stop(struct sc_fps_counter *counter) {
+fps_counter_stop(struct fps_counter *counter) {
    set_started(counter, false);
    sc_cond_signal(&counter->state_cond);
-    LOGI("FPS counter stopped");
 }

 bool
-sc_fps_counter_is_started(struct sc_fps_counter *counter) {
+fps_counter_is_started(struct fps_counter *counter) {
    return is_started(counter);
 }

 void
-sc_fps_counter_interrupt(struct sc_fps_counter *counter) {
+fps_counter_interrupt(struct fps_counter *counter) {
    if (!counter->thread_started) {
        return;
    }
@ -147,37 +148,33 @@ sc_fps_counter_interrupt(struct sc_fps_counter *counter) {
 }

 void
-sc_fps_counter_join(struct sc_fps_counter *counter) {
+fps_counter_join(struct fps_counter *counter) {
    if (counter->thread_started) {
-        // interrupted must be set by the thread calling join(), so no need to
-        // lock for the assertion
-        assert(counter->interrupted);
-
        sc_thread_join(&counter->thread, NULL);
    }
 }

 void
-sc_fps_counter_add_rendered_frame(struct sc_fps_counter *counter) {
+fps_counter_add_rendered_frame(struct fps_counter *counter) {
    if (!is_started(counter)) {
        return;
    }

    sc_mutex_lock(&counter->mutex);
-    sc_tick now = sc_tick_now();
+    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_rendered;
    sc_mutex_unlock(&counter->mutex);
 }

 void
-sc_fps_counter_add_skipped_frame(struct sc_fps_counter *counter) {
+fps_counter_add_skipped_frame(struct fps_counter *counter) {
    if (!is_started(counter)) {
        return;
    }

    sc_mutex_lock(&counter->mutex);
-    sc_tick now = sc_tick_now();
+    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_skipped;
    sc_mutex_unlock(&counter->mutex);
--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@ -1,5 +1,5 @@
-#ifndef SC_FPSCOUNTER_H
-#define SC_FPSCOUNTER_H
+#ifndef FPSCOUNTER_H
+#define FPSCOUNTER_H

 #include "common.h"

@ -9,7 +9,7 @@

 #include "util/thread.h"

-struct sc_fps_counter {
+struct fps_counter {
    sc_thread thread;
    sc_mutex mutex;
    sc_cond state_cond;
@ -24,36 +24,36 @@ struct sc_fps_counter {
    bool interrupted;
    unsigned nr_rendered;
    unsigned nr_skipped;
-    sc_tick next_timestamp;
+    uint32_t next_timestamp;
 };

 bool
-sc_fps_counter_init(struct sc_fps_counter *counter);
+fps_counter_init(struct fps_counter *counter);

 void
-sc_fps_counter_destroy(struct sc_fps_counter *counter);
+fps_counter_destroy(struct fps_counter *counter);

 bool
-sc_fps_counter_start(struct sc_fps_counter *counter);
+fps_counter_start(struct fps_counter *counter);

 void
-sc_fps_counter_stop(struct sc_fps_counter *counter);
+fps_counter_stop(struct fps_counter *counter);

 bool
-sc_fps_counter_is_started(struct sc_fps_counter *counter);
+fps_counter_is_started(struct fps_counter *counter);

 // request to stop the thread (on quit)
-// must be called before sc_fps_counter_join()
+// must be called before fps_counter_join()
 void
-sc_fps_counter_interrupt(struct sc_fps_counter *counter);
+fps_counter_interrupt(struct fps_counter *counter);

 void
-sc_fps_counter_join(struct sc_fps_counter *counter);
+fps_counter_join(struct fps_counter *counter);

 void
-sc_fps_counter_add_rendered_frame(struct sc_fps_counter *counter);
+fps_counter_add_rendered_frame(struct fps_counter *counter);

 void
-sc_fps_counter_add_skipped_frame(struct sc_fps_counter *counter);
+fps_counter_add_skipped_frame(struct fps_counter *counter);

 #endif
--- a/app/src/frame_buffer.c
+++ b/app/src/frame_buffer.c
@ -1,90 +0,0 @@
-#include "frame_buffer.h"
-
-#include <assert.h>
-#include <libavutil/avutil.h>
-#include <libavformat/avformat.h>
-
-#include "util/log.h"
-
-bool
-sc_frame_buffer_init(struct sc_frame_buffer *fb) {
-    fb->pending_frame = av_frame_alloc();
-    if (!fb->pending_frame) {
-        LOG_OOM();
-        return false;
-    }
-
-    fb->tmp_frame = av_frame_alloc();
-    if (!fb->tmp_frame) {
-        LOG_OOM();
-        av_frame_free(&fb->pending_frame);
-        return false;
-    }
-
-    bool ok = sc_mutex_init(&fb->mutex);
-    if (!ok) {
-        av_frame_free(&fb->pending_frame);
-        av_frame_free(&fb->tmp_frame);
-        return false;
-    }
-
-    // there is initially no frame, so consider it has already been consumed
-    fb->pending_frame_consumed = true;
-
-    return true;
-}
-
-void
-sc_frame_buffer_destroy(struct sc_frame_buffer *fb) {
-    sc_mutex_destroy(&fb->mutex);
-    av_frame_free(&fb->pending_frame);
-    av_frame_free(&fb->tmp_frame);
-}
-
-static inline void
-swap_frames(AVFrame **lhs, AVFrame **rhs) {
-    AVFrame *tmp = *lhs;
-    *lhs = *rhs;
-    *rhs = tmp;
-}
-
-bool
-sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
-                     bool *previous_frame_skipped) {
-    // Use a temporary frame to preserve pending_frame in case of error.
-    // tmp_frame is an empty frame, no need to call av_frame_unref() beforehand.
-    int r = av_frame_ref(fb->tmp_frame, frame);
-    if (r) {
-        LOGE("Could not ref frame: %d", r);
-        return false;
-    }
-
-    sc_mutex_lock(&fb->mutex);
-
-    // Now that av_frame_ref() succeeded, we can replace the previous
-    // pending_frame
-    swap_frames(&fb->pending_frame, &fb->tmp_frame);
-    av_frame_unref(fb->tmp_frame);
-
-    if (previous_frame_skipped) {
-        *previous_frame_skipped = !fb->pending_frame_consumed;
-    }
-    fb->pending_frame_consumed = false;
-
-    sc_mutex_unlock(&fb->mutex);
-
-    return true;
-}
-
-void
-sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst) {
-    sc_mutex_lock(&fb->mutex);
-    assert(!fb->pending_frame_consumed);
-    fb->pending_frame_consumed = true;
-
-    av_frame_move_ref(dst, fb->pending_frame);
-    // av_frame_move_ref() resets its source frame, so no need to call
-    // av_frame_unref()
-
-    sc_mutex_unlock(&fb->mutex);
-}
--- a/app/src/frame_buffer.h
+++ b/app/src/frame_buffer.h
@ -1,44 +0,0 @@
-#ifndef SC_FRAME_BUFFER_H
-#define SC_FRAME_BUFFER_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "util/thread.h"
-
-// forward declarations
-typedef struct AVFrame AVFrame;
-
-/**
- * A frame buffer holds 1 pending frame, which is the last frame received from
- * the producer (typically, the decoder).
- *
- * If a pending frame has not been consumed when the producer pushes a new
- * frame, then it is lost. The intent is to always provide access to the very
- * last frame to minimize latency.
- */
-
-struct sc_frame_buffer {
-    AVFrame *pending_frame;
-    AVFrame *tmp_frame; // To preserve the pending frame on error
-
-    sc_mutex mutex;
-
-    bool pending_frame_consumed;
-};
-
-bool
-sc_frame_buffer_init(struct sc_frame_buffer *fb);
-
-void
-sc_frame_buffer_destroy(struct sc_frame_buffer *fb);
-
-bool
-sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
-                     bool *skipped);
-
-void
-sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst);
-
-#endif
--- a/app/src/icon.c
+++ b/app/src/icon.c
@ -1,291 +0,0 @@
-#include "icon.h"
-
-#include <assert.h>
-#include <stdbool.h>
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavutil/pixdesc.h>
-#include <libavutil/pixfmt.h>
-
-#include "config.h"
-#include "compat.h"
-#include "util/file.h"
-#include "util/log.h"
-#include "util/str.h"
-
-#define SCRCPY_PORTABLE_ICON_FILENAME "icon.png"
-#define SCRCPY_DEFAULT_ICON_PATH \
-    PREFIX "/share/icons/hicolor/256x256/apps/scrcpy.png"
-
-static char *
-get_icon_path(void) {
-#ifdef __WINDOWS__
-    const wchar_t *icon_path_env = _wgetenv(L"SCRCPY_ICON_PATH");
-#else
-    const char *icon_path_env = getenv("SCRCPY_ICON_PATH");
-#endif
-    if (icon_path_env) {
-        // if the envvar is set, use it
-#ifdef __WINDOWS__
-        char *icon_path = sc_str_from_wchars(icon_path_env);
-#else
-        char *icon_path = strdup(icon_path_env);
-#endif
-        if (!icon_path) {
-            LOG_OOM();
-            return NULL;
-        }
-        LOGD("Using SCRCPY_ICON_PATH: %s", icon_path);
-        return icon_path;
-    }
-
-#ifndef PORTABLE
-    LOGD("Using icon: " SCRCPY_DEFAULT_ICON_PATH);
-    char *icon_path = strdup(SCRCPY_DEFAULT_ICON_PATH);
-    if (!icon_path) {
-        LOG_OOM();
-        return NULL;
-    }
-#else
-    char *icon_path = sc_file_get_local_path(SCRCPY_PORTABLE_ICON_FILENAME);
-    if (!icon_path) {
-        LOGE("Could not get icon path");
-        return NULL;
-    }
-    LOGD("Using icon (portable): %s", icon_path);
-#endif
-
-    return icon_path;
-}
-
-static AVFrame *
-decode_image(const char *path) {
-    AVFrame *result = NULL;
-
-    AVFormatContext *ctx = avformat_alloc_context();
-    if (!ctx) {
-        LOG_OOM();
-        return NULL;
-    }
-
-    if (avformat_open_input(&ctx, path, NULL, NULL) < 0) {
-        LOGE("Could not open image codec: %s", path);
-        goto free_ctx;
-    }
-
-    if (avformat_find_stream_info(ctx, NULL) < 0) {
-        LOGE("Could not find image stream info");
-        goto close_input;
-    }
-
-    int stream = av_find_best_stream(ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
-    if (stream < 0 ) {
-        LOGE("Could not find best image stream");
-        goto close_input;
-    }
-
-    AVCodecParameters *params = ctx->streams[stream]->codecpar;
-
-    const AVCodec *codec = avcodec_find_decoder(params->codec_id);
-    if (!codec) {
-        LOGE("Could not find image decoder");
-        goto close_input;
-    }
-
-    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
-    if (!codec_ctx) {
-        LOG_OOM();
-        goto close_input;
-    }
-
-    if (avcodec_parameters_to_context(codec_ctx, params) < 0) {
-        LOGE("Could not fill codec context");
-        goto free_codec_ctx;
-    }
-
-    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
-        LOGE("Could not open image codec");
-        goto free_codec_ctx;
-    }
-
-    AVFrame *frame = av_frame_alloc();
-    if (!frame) {
-        LOG_OOM();
-        goto close_codec;
-    }
-
-    AVPacket *packet = av_packet_alloc();
-    if (!packet) {
-        LOG_OOM();
-        av_frame_free(&frame);
-        goto close_codec;
-    }
-
-    if (av_read_frame(ctx, packet) < 0) {
-        LOGE("Could not read frame");
-        av_packet_free(&packet);
-        av_frame_free(&frame);
-        goto close_codec;
-    }
-
-    int ret;
-    if ((ret = avcodec_send_packet(codec_ctx, packet)) < 0) {
-        LOGE("Could not send icon packet: %d", ret);
-        av_packet_free(&packet);
-        av_frame_free(&frame);
-        goto close_codec;
-    }
-
-    if ((ret = avcodec_receive_frame(codec_ctx, frame)) != 0) {
-        LOGE("Could not receive icon frame: %d", ret);
-        av_packet_free(&packet);
-        av_frame_free(&frame);
-        goto close_codec;
-    }
-
-    av_packet_free(&packet);
-
-    result = frame;
-
-close_codec:
-    avcodec_close(codec_ctx);
-free_codec_ctx:
-    avcodec_free_context(&codec_ctx);
-close_input:
-    avformat_close_input(&ctx);
-free_ctx:
-    avformat_free_context(ctx);
-
-    return result;
-}
-
-#if !SDL_VERSION_ATLEAST(2, 0, 10)
-// SDL_PixelFormatEnum has been introduced in SDL 2.0.10. Use int for older SDL
-// versions.
-typedef int SDL_PixelFormatEnum;
-#endif
-
-static SDL_PixelFormatEnum
-to_sdl_pixel_format(enum AVPixelFormat fmt) {
-    switch (fmt) {
-        case AV_PIX_FMT_RGB24: return SDL_PIXELFORMAT_RGB24;
-        case AV_PIX_FMT_BGR24: return SDL_PIXELFORMAT_BGR24;
-        case AV_PIX_FMT_ARGB: return SDL_PIXELFORMAT_ARGB32;
-        case AV_PIX_FMT_RGBA: return SDL_PIXELFORMAT_RGBA32;
-        case AV_PIX_FMT_ABGR: return SDL_PIXELFORMAT_ABGR32;
-        case AV_PIX_FMT_BGRA: return SDL_PIXELFORMAT_BGRA32;
-        case AV_PIX_FMT_RGB565BE: return SDL_PIXELFORMAT_RGB565;
-        case AV_PIX_FMT_RGB555BE: return SDL_PIXELFORMAT_RGB555;
-        case AV_PIX_FMT_BGR565BE: return SDL_PIXELFORMAT_BGR565;
-        case AV_PIX_FMT_BGR555BE: return SDL_PIXELFORMAT_BGR555;
-        case AV_PIX_FMT_RGB444BE: return SDL_PIXELFORMAT_RGB444;
-#if SDL_VERSION_ATLEAST(2, 0, 12)
-        case AV_PIX_FMT_BGR444BE: return SDL_PIXELFORMAT_BGR444;
-#endif
-        case AV_PIX_FMT_PAL8: return SDL_PIXELFORMAT_INDEX8;
-        default: return SDL_PIXELFORMAT_UNKNOWN;
-    }
-}
-
-static SDL_Surface *
-load_from_path(const char *path) {
-    AVFrame *frame = decode_image(path);
-    if (!frame) {
-        return NULL;
-    }
-
-    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
-    if (!desc) {
-        LOGE("Could not get icon format descriptor");
-        goto error;
-    }
-
-    bool is_packed = !(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
-    if (!is_packed) {
-        LOGE("Could not load non-packed icon");
-        goto error;
-    }
-
-    SDL_PixelFormatEnum format = to_sdl_pixel_format(frame->format);
-    if (format == SDL_PIXELFORMAT_UNKNOWN) {
-        LOGE("Unsupported icon pixel format: %s (%d)", desc->name,
-                                                       frame->format);
-        goto error;
-    }
-
-    int bits_per_pixel = av_get_bits_per_pixel(desc);
-    SDL_Surface *surface =
-        SDL_CreateRGBSurfaceWithFormatFrom(frame->data[0],
-                                           frame->width, frame->height,
-                                           bits_per_pixel,
-                                           frame->linesize[0],
-                                           format);
-
-    if (!surface) {
-        LOGE("Could not create icon surface");
-        goto error;
-    }
-
-    if (frame->format == AV_PIX_FMT_PAL8) {
-        // Initialize the SDL palette
-        uint8_t *data = frame->data[1];
-        SDL_Color colors[256];
-        for (int i = 0; i < 256; ++i) {
-            SDL_Color *color = &colors[i];
-
-            // The palette is transported in AVFrame.data[1], is 1024 bytes
-            // long (256 4-byte entries) and is formatted the same as in
-            // AV_PIX_FMT_RGB32 described above (i.e., it is also
-            // endian-specific).
-            // <https://ffmpeg.org/doxygen/4.1/pixfmt_8h.html#a9a8e335cf3be472042bc9f0cf80cd4c5>
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-            color->a = data[i * 4];
-            color->r = data[i * 4 + 1];
-            color->g = data[i * 4 + 2];
-            color->b = data[i * 4 + 3];
-#else
-            color->a = data[i * 4 + 3];
-            color->r = data[i * 4 + 2];
-            color->g = data[i * 4 + 1];
-            color->b = data[i * 4];
-#endif
-        }
-
-        SDL_Palette *palette = surface->format->palette;
-        assert(palette);
-        int ret = SDL_SetPaletteColors(palette, colors, 0, 256);
-        if (ret) {
-            LOGE("Could not set palette colors");
-            SDL_FreeSurface(surface);
-            goto error;
-        }
-    }
-
-    surface->userdata = frame; // frame owns the data
-
-    return surface;
-
-error:
-    av_frame_free(&frame);
-    return NULL;
-}
-
-SDL_Surface *
-scrcpy_icon_load() {
-    char *icon_path = get_icon_path();
-    if (!icon_path) {
-        return NULL;
-    }
-
-    SDL_Surface *icon = load_from_path(icon_path);
-    free(icon_path);
-    return icon;
-}
-
-void
-scrcpy_icon_destroy(SDL_Surface *icon) {
-    AVFrame *frame = icon->userdata;
-    assert(frame);
-    av_frame_free(&frame);
-    SDL_FreeSurface(icon);
-}
--- a/app/src/icon.h
+++ b/app/src/icon.h
@ -1,16 +0,0 @@
-#ifndef SC_ICON_H
-#define SC_ICON_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <SDL2/SDL.h>
-#include <libavformat/avformat.h>
-
-SDL_Surface *
-scrcpy_icon_load(void);
-
-void
-scrcpy_icon_destroy(SDL_Surface *icon);
-
-#endif
--- a/app/src/icon.xpm
+++ b/app/src/icon.xpm
@ -0,0 +1,53 @@
+/* XPM */
+static char * icon_xpm[] = {
+"48 48 2 1",
+" 	c None",
+".	c #96C13E",
+"              ..                ..              ",
+"              ...              ...              ",
+"               ...   ......   ...               ",
+"                ................                ",
+"                 ..............                 ",
+"                ................                ",
+"               ..................               ",
+"              ....................              ",
+"             .....  ........  .....             ",
+"             .....  ........  .....             ",
+"             ......................             ",
+"            ........................            ",
+"            ........................            ",
+"            ........................            ",
+"                                                ",
+"                                                ",
+"     ....   ........................   ....     ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"     ....   ........................   ....     ",
+"            ........................            ",
+"             ......................             ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                 ....      ....                 "};
--- a/app/src/input_events.h
+++ b/app/src/input_events.h
@ -1,452 +0,0 @@
-#ifndef SC_INPUT_EVENTS_H
-#define SC_INPUT_EVENTS_H
-
-#include "common.h"
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <SDL2/SDL_events.h>
-
-#include "coords.h"
-
-/* The representation of input events in scrcpy is very close to the SDL API,
- * for simplicity.
- *
- * This scrcpy input events API is designed to be consumed by input event
- * processors (sc_key_processor and sc_mouse_processor, see app/src/trait/).
- *
- * One major semantic difference between SDL input events and scrcpy input
- * events is their frame of reference (for mouse and touch events): SDL events
- * coordinates are expressed in SDL window coordinates (the visible UI), while
- * scrcpy events are expressed in device frame coordinates.
- *
- * In particular, the window may be visually scaled or rotated (with --rotation
- * or MOD+Left/Right), but this does not impact scrcpy input events (contrary
- * to SDL input events). This allows to abstract these display details from the
- * input event processors (and to make them independent from the "screen").
- *
- * For many enums below, the values are purposely the same as the SDL
- * constants (though not all SDL values are represented), so that the
- * implementation to convert from the SDL version to the scrcpy version is
- * straightforward.
- *
- * In practice, there are 3 levels of input events:
- *  1. SDL input events (as received from SDL)
- *  2. scrcpy input events (this API)
- *  3. the key/mouse processors input events (Android API or HID events)
- *
- * An input event is first received (1), then (if accepted) converted to an
- * scrcpy input event (2), then submitted to the relevant key/mouse processor,
- * which (if accepted) is converted to an Android event (to be sent to the
- * server) or to an HID event (to be sent over USB/AOA directly).
- */
-
-enum sc_mod {
-    SC_MOD_LSHIFT = KMOD_LSHIFT,
-    SC_MOD_RSHIFT = KMOD_RSHIFT,
-    SC_MOD_LCTRL = KMOD_LCTRL,
-    SC_MOD_RCTRL = KMOD_RCTRL,
-    SC_MOD_LALT = KMOD_LALT,
-    SC_MOD_RALT = KMOD_RALT,
-    SC_MOD_LGUI = KMOD_LGUI,
-    SC_MOD_RGUI = KMOD_RGUI,
-
-    SC_MOD_NUM = KMOD_NUM,
-    SC_MOD_CAPS = KMOD_CAPS,
-};
-
-enum sc_action {
-    SC_ACTION_DOWN, // key or button pressed
-    SC_ACTION_UP, // key or button released
-};
-
-enum sc_keycode {
-    SC_KEYCODE_UNKNOWN = SDLK_UNKNOWN,
-
-    SC_KEYCODE_RETURN = SDLK_RETURN,
-    SC_KEYCODE_ESCAPE = SDLK_ESCAPE,
-    SC_KEYCODE_BACKSPACE = SDLK_BACKSPACE,
-    SC_KEYCODE_TAB = SDLK_TAB,
-    SC_KEYCODE_SPACE = SDLK_SPACE,
-    SC_KEYCODE_EXCLAIM = SDLK_EXCLAIM,
-    SC_KEYCODE_QUOTEDBL = SDLK_QUOTEDBL,
-    SC_KEYCODE_HASH = SDLK_HASH,
-    SC_KEYCODE_PERCENT = SDLK_PERCENT,
-    SC_KEYCODE_DOLLAR = SDLK_DOLLAR,
-    SC_KEYCODE_AMPERSAND = SDLK_AMPERSAND,
-    SC_KEYCODE_QUOTE = SDLK_QUOTE,
-    SC_KEYCODE_LEFTPAREN = SDLK_LEFTPAREN,
-    SC_KEYCODE_RIGHTPAREN = SDLK_RIGHTPAREN,
-    SC_KEYCODE_ASTERISK = SDLK_ASTERISK,
-    SC_KEYCODE_PLUS = SDLK_PLUS,
-    SC_KEYCODE_COMMA = SDLK_COMMA,
-    SC_KEYCODE_MINUS = SDLK_MINUS,
-    SC_KEYCODE_PERIOD = SDLK_PERIOD,
-    SC_KEYCODE_SLASH = SDLK_SLASH,
-    SC_KEYCODE_0 = SDLK_0,
-    SC_KEYCODE_1 = SDLK_1,
-    SC_KEYCODE_2 = SDLK_2,
-    SC_KEYCODE_3 = SDLK_3,
-    SC_KEYCODE_4 = SDLK_4,
-    SC_KEYCODE_5 = SDLK_5,
-    SC_KEYCODE_6 = SDLK_6,
-    SC_KEYCODE_7 = SDLK_7,
-    SC_KEYCODE_8 = SDLK_8,
-    SC_KEYCODE_9 = SDLK_9,
-    SC_KEYCODE_COLON = SDLK_COLON,
-    SC_KEYCODE_SEMICOLON = SDLK_SEMICOLON,
-    SC_KEYCODE_LESS = SDLK_LESS,
-    SC_KEYCODE_EQUALS = SDLK_EQUALS,
-    SC_KEYCODE_GREATER = SDLK_GREATER,
-    SC_KEYCODE_QUESTION = SDLK_QUESTION,
-    SC_KEYCODE_AT = SDLK_AT,
-
-    SC_KEYCODE_LEFTBRACKET = SDLK_LEFTBRACKET,
-    SC_KEYCODE_BACKSLASH = SDLK_BACKSLASH,
-    SC_KEYCODE_RIGHTBRACKET = SDLK_RIGHTBRACKET,
-    SC_KEYCODE_CARET = SDLK_CARET,
-    SC_KEYCODE_UNDERSCORE = SDLK_UNDERSCORE,
-    SC_KEYCODE_BACKQUOTE = SDLK_BACKQUOTE,
-    SC_KEYCODE_a = SDLK_a,
-    SC_KEYCODE_b = SDLK_b,
-    SC_KEYCODE_c = SDLK_c,
-    SC_KEYCODE_d = SDLK_d,
-    SC_KEYCODE_e = SDLK_e,
-    SC_KEYCODE_f = SDLK_f,
-    SC_KEYCODE_g = SDLK_g,
-    SC_KEYCODE_h = SDLK_h,
-    SC_KEYCODE_i = SDLK_i,
-    SC_KEYCODE_j = SDLK_j,
-    SC_KEYCODE_k = SDLK_k,
-    SC_KEYCODE_l = SDLK_l,
-    SC_KEYCODE_m = SDLK_m,
-    SC_KEYCODE_n = SDLK_n,
-    SC_KEYCODE_o = SDLK_o,
-    SC_KEYCODE_p = SDLK_p,
-    SC_KEYCODE_q = SDLK_q,
-    SC_KEYCODE_r = SDLK_r,
-    SC_KEYCODE_s = SDLK_s,
-    SC_KEYCODE_t = SDLK_t,
-    SC_KEYCODE_u = SDLK_u,
-    SC_KEYCODE_v = SDLK_v,
-    SC_KEYCODE_w = SDLK_w,
-    SC_KEYCODE_x = SDLK_x,
-    SC_KEYCODE_y = SDLK_y,
-    SC_KEYCODE_z = SDLK_z,
-
-    SC_KEYCODE_CAPSLOCK = SDLK_CAPSLOCK,
-
-    SC_KEYCODE_F1 = SDLK_F1,
-    SC_KEYCODE_F2 = SDLK_F2,
-    SC_KEYCODE_F3 = SDLK_F3,
-    SC_KEYCODE_F4 = SDLK_F4,
-    SC_KEYCODE_F5 = SDLK_F5,
-    SC_KEYCODE_F6 = SDLK_F6,
-    SC_KEYCODE_F7 = SDLK_F7,
-    SC_KEYCODE_F8 = SDLK_F8,
-    SC_KEYCODE_F9 = SDLK_F9,
-    SC_KEYCODE_F10 = SDLK_F10,
-    SC_KEYCODE_F11 = SDLK_F11,
-    SC_KEYCODE_F12 = SDLK_F12,
-
-    SC_KEYCODE_PRINTSCREEN = SDLK_PRINTSCREEN,
-    SC_KEYCODE_SCROLLLOCK = SDLK_SCROLLLOCK,
-    SC_KEYCODE_PAUSE = SDLK_PAUSE,
-    SC_KEYCODE_INSERT = SDLK_INSERT,
-    SC_KEYCODE_HOME = SDLK_HOME,
-    SC_KEYCODE_PAGEUP = SDLK_PAGEUP,
-    SC_KEYCODE_DELETE = SDLK_DELETE,
-    SC_KEYCODE_END = SDLK_END,
-    SC_KEYCODE_PAGEDOWN = SDLK_PAGEDOWN,
-    SC_KEYCODE_RIGHT = SDLK_RIGHT,
-    SC_KEYCODE_LEFT = SDLK_LEFT,
-    SC_KEYCODE_DOWN = SDLK_DOWN,
-    SC_KEYCODE_UP = SDLK_UP,
-
-    SC_KEYCODE_KP_DIVIDE = SDLK_KP_DIVIDE,
-    SC_KEYCODE_KP_MULTIPLY = SDLK_KP_MULTIPLY,
-    SC_KEYCODE_KP_MINUS = SDLK_KP_MINUS,
-    SC_KEYCODE_KP_PLUS = SDLK_KP_PLUS,
-    SC_KEYCODE_KP_ENTER = SDLK_KP_ENTER,
-    SC_KEYCODE_KP_1 = SDLK_KP_1,
-    SC_KEYCODE_KP_2 = SDLK_KP_2,
-    SC_KEYCODE_KP_3 = SDLK_KP_3,
-    SC_KEYCODE_KP_4 = SDLK_KP_4,
-    SC_KEYCODE_KP_5 = SDLK_KP_5,
-    SC_KEYCODE_KP_6 = SDLK_KP_6,
-    SC_KEYCODE_KP_7 = SDLK_KP_7,
-    SC_KEYCODE_KP_8 = SDLK_KP_8,
-    SC_KEYCODE_KP_9 = SDLK_KP_9,
-    SC_KEYCODE_KP_0 = SDLK_KP_0,
-    SC_KEYCODE_KP_PERIOD = SDLK_KP_PERIOD,
-    SC_KEYCODE_KP_EQUALS = SDLK_KP_EQUALS,
-    SC_KEYCODE_KP_LEFTPAREN = SDLK_KP_LEFTPAREN,
-    SC_KEYCODE_KP_RIGHTPAREN = SDLK_KP_RIGHTPAREN,
-
-    SC_KEYCODE_LCTRL = SDLK_LCTRL,
-    SC_KEYCODE_LSHIFT = SDLK_LSHIFT,
-    SC_KEYCODE_LALT = SDLK_LALT,
-    SC_KEYCODE_LGUI = SDLK_LGUI,
-    SC_KEYCODE_RCTRL = SDLK_RCTRL,
-    SC_KEYCODE_RSHIFT = SDLK_RSHIFT,
-    SC_KEYCODE_RALT = SDLK_RALT,
-    SC_KEYCODE_RGUI = SDLK_RGUI,
-};
-
-enum sc_scancode {
-    SC_SCANCODE_UNKNOWN = SDL_SCANCODE_UNKNOWN,
-
-    SC_SCANCODE_A = SDL_SCANCODE_A,
-    SC_SCANCODE_B = SDL_SCANCODE_B,
-    SC_SCANCODE_C = SDL_SCANCODE_C,
-    SC_SCANCODE_D = SDL_SCANCODE_D,
-    SC_SCANCODE_E = SDL_SCANCODE_E,
-    SC_SCANCODE_F = SDL_SCANCODE_F,
-    SC_SCANCODE_G = SDL_SCANCODE_G,
-    SC_SCANCODE_H = SDL_SCANCODE_H,
-    SC_SCANCODE_I = SDL_SCANCODE_I,
-    SC_SCANCODE_J = SDL_SCANCODE_J,
-    SC_SCANCODE_K = SDL_SCANCODE_K,
-    SC_SCANCODE_L = SDL_SCANCODE_L,
-    SC_SCANCODE_M = SDL_SCANCODE_M,
-    SC_SCANCODE_N = SDL_SCANCODE_N,
-    SC_SCANCODE_O = SDL_SCANCODE_O,
-    SC_SCANCODE_P = SDL_SCANCODE_P,
-    SC_SCANCODE_Q = SDL_SCANCODE_Q,
-    SC_SCANCODE_R = SDL_SCANCODE_R,
-    SC_SCANCODE_S = SDL_SCANCODE_S,
-    SC_SCANCODE_T = SDL_SCANCODE_T,
-    SC_SCANCODE_U = SDL_SCANCODE_U,
-    SC_SCANCODE_V = SDL_SCANCODE_V,
-    SC_SCANCODE_W = SDL_SCANCODE_W,
-    SC_SCANCODE_X = SDL_SCANCODE_X,
-    SC_SCANCODE_Y = SDL_SCANCODE_Y,
-    SC_SCANCODE_Z = SDL_SCANCODE_Z,
-
-    SC_SCANCODE_1 = SDL_SCANCODE_1,
-    SC_SCANCODE_2 = SDL_SCANCODE_2,
-    SC_SCANCODE_3 = SDL_SCANCODE_3,
-    SC_SCANCODE_4 = SDL_SCANCODE_4,
-    SC_SCANCODE_5 = SDL_SCANCODE_5,
-    SC_SCANCODE_6 = SDL_SCANCODE_6,
-    SC_SCANCODE_7 = SDL_SCANCODE_7,
-    SC_SCANCODE_8 = SDL_SCANCODE_8,
-    SC_SCANCODE_9 = SDL_SCANCODE_9,
-    SC_SCANCODE_0 = SDL_SCANCODE_0,
-
-    SC_SCANCODE_RETURN = SDL_SCANCODE_RETURN,
-    SC_SCANCODE_ESCAPE = SDL_SCANCODE_ESCAPE,
-    SC_SCANCODE_BACKSPACE = SDL_SCANCODE_BACKSPACE,
-    SC_SCANCODE_TAB = SDL_SCANCODE_TAB,
-    SC_SCANCODE_SPACE = SDL_SCANCODE_SPACE,
-
-    SC_SCANCODE_MINUS = SDL_SCANCODE_MINUS,
-    SC_SCANCODE_EQUALS = SDL_SCANCODE_EQUALS,
-    SC_SCANCODE_LEFTBRACKET = SDL_SCANCODE_LEFTBRACKET,
-    SC_SCANCODE_RIGHTBRACKET = SDL_SCANCODE_RIGHTBRACKET,
-    SC_SCANCODE_BACKSLASH = SDL_SCANCODE_BACKSLASH,
-    SC_SCANCODE_NONUSHASH = SDL_SCANCODE_NONUSHASH,
-    SC_SCANCODE_SEMICOLON = SDL_SCANCODE_SEMICOLON,
-    SC_SCANCODE_APOSTROPHE = SDL_SCANCODE_APOSTROPHE,
-    SC_SCANCODE_GRAVE = SDL_SCANCODE_GRAVE,
-    SC_SCANCODE_COMMA = SDL_SCANCODE_COMMA,
-    SC_SCANCODE_PERIOD = SDL_SCANCODE_PERIOD,
-    SC_SCANCODE_SLASH = SDL_SCANCODE_SLASH,
-
-    SC_SCANCODE_CAPSLOCK = SDL_SCANCODE_CAPSLOCK,
-
-    SC_SCANCODE_F1 = SDL_SCANCODE_F1,
-    SC_SCANCODE_F2 = SDL_SCANCODE_F2,
-    SC_SCANCODE_F3 = SDL_SCANCODE_F3,
-    SC_SCANCODE_F4 = SDL_SCANCODE_F4,
-    SC_SCANCODE_F5 = SDL_SCANCODE_F5,
-    SC_SCANCODE_F6 = SDL_SCANCODE_F6,
-    SC_SCANCODE_F7 = SDL_SCANCODE_F7,
-    SC_SCANCODE_F8 = SDL_SCANCODE_F8,
-    SC_SCANCODE_F9 = SDL_SCANCODE_F9,
-    SC_SCANCODE_F10 = SDL_SCANCODE_F10,
-    SC_SCANCODE_F11 = SDL_SCANCODE_F11,
-    SC_SCANCODE_F12 = SDL_SCANCODE_F12,
-
-    SC_SCANCODE_PRINTSCREEN = SDL_SCANCODE_PRINTSCREEN,
-    SC_SCANCODE_SCROLLLOCK = SDL_SCANCODE_SCROLLLOCK,
-    SC_SCANCODE_PAUSE = SDL_SCANCODE_PAUSE,
-    SC_SCANCODE_INSERT = SDL_SCANCODE_INSERT,
-    SC_SCANCODE_HOME = SDL_SCANCODE_HOME,
-    SC_SCANCODE_PAGEUP = SDL_SCANCODE_PAGEUP,
-    SC_SCANCODE_DELETE = SDL_SCANCODE_DELETE,
-    SC_SCANCODE_END = SDL_SCANCODE_END,
-    SC_SCANCODE_PAGEDOWN = SDL_SCANCODE_PAGEDOWN,
-    SC_SCANCODE_RIGHT = SDL_SCANCODE_RIGHT,
-    SC_SCANCODE_LEFT = SDL_SCANCODE_LEFT,
-    SC_SCANCODE_DOWN = SDL_SCANCODE_DOWN,
-    SC_SCANCODE_UP = SDL_SCANCODE_UP,
-
-    SC_SCANCODE_NUMLOCK = SDL_SCANCODE_NUMLOCKCLEAR,
-    SC_SCANCODE_KP_DIVIDE = SDL_SCANCODE_KP_DIVIDE,
-    SC_SCANCODE_KP_MULTIPLY = SDL_SCANCODE_KP_MULTIPLY,
-    SC_SCANCODE_KP_MINUS = SDL_SCANCODE_KP_MINUS,
-    SC_SCANCODE_KP_PLUS = SDL_SCANCODE_KP_PLUS,
-    SC_SCANCODE_KP_ENTER = SDL_SCANCODE_KP_ENTER,
-    SC_SCANCODE_KP_1 = SDL_SCANCODE_KP_1,
-    SC_SCANCODE_KP_2 = SDL_SCANCODE_KP_2,
-    SC_SCANCODE_KP_3 = SDL_SCANCODE_KP_3,
-    SC_SCANCODE_KP_4 = SDL_SCANCODE_KP_4,
-    SC_SCANCODE_KP_5 = SDL_SCANCODE_KP_5,
-    SC_SCANCODE_KP_6 = SDL_SCANCODE_KP_6,
-    SC_SCANCODE_KP_7 = SDL_SCANCODE_KP_7,
-    SC_SCANCODE_KP_8 = SDL_SCANCODE_KP_8,
-    SC_SCANCODE_KP_9 = SDL_SCANCODE_KP_9,
-    SC_SCANCODE_KP_0 = SDL_SCANCODE_KP_0,
-    SC_SCANCODE_KP_PERIOD = SDL_SCANCODE_KP_PERIOD,
-
-    SC_SCANCODE_LCTRL = SDL_SCANCODE_LCTRL,
-    SC_SCANCODE_LSHIFT = SDL_SCANCODE_LSHIFT,
-    SC_SCANCODE_LALT = SDL_SCANCODE_LALT,
-    SC_SCANCODE_LGUI = SDL_SCANCODE_LGUI,
-    SC_SCANCODE_RCTRL = SDL_SCANCODE_RCTRL,
-    SC_SCANCODE_RSHIFT = SDL_SCANCODE_RSHIFT,
-    SC_SCANCODE_RALT = SDL_SCANCODE_RALT,
-    SC_SCANCODE_RGUI = SDL_SCANCODE_RGUI,
-};
-
-// On purpose, only use the "mask" values (1, 2, 4, 8, 16) for a single button,
-// to avoid unnecessary conversions (and confusion).
-enum sc_mouse_button {
-    SC_MOUSE_BUTTON_UNKNOWN = 0,
-    SC_MOUSE_BUTTON_LEFT = SDL_BUTTON(SDL_BUTTON_LEFT),
-    SC_MOUSE_BUTTON_RIGHT = SDL_BUTTON(SDL_BUTTON_RIGHT),
-    SC_MOUSE_BUTTON_MIDDLE = SDL_BUTTON(SDL_BUTTON_MIDDLE),
-    SC_MOUSE_BUTTON_X1 = SDL_BUTTON(SDL_BUTTON_X1),
-    SC_MOUSE_BUTTON_X2 = SDL_BUTTON(SDL_BUTTON_X2),
-};
-
-static_assert(sizeof(enum sc_mod) >= sizeof(SDL_Keymod),
-              "SDL_Keymod must be convertible to sc_mod");
-
-static_assert(sizeof(enum sc_keycode) >= sizeof(SDL_Keycode),
-              "SDL_Keycode must be convertible to sc_keycode");
-
-static_assert(sizeof(enum sc_scancode) >= sizeof(SDL_Scancode),
-              "SDL_Scancode must be convertible to sc_scancode");
-
-enum sc_touch_action {
-    SC_TOUCH_ACTION_MOVE,
-    SC_TOUCH_ACTION_DOWN,
-    SC_TOUCH_ACTION_UP,
-};
-
-struct sc_key_event {
-    enum sc_action action;
-    enum sc_keycode keycode;
-    enum sc_scancode scancode;
-    uint16_t mods_state; // bitwise-OR of sc_mod values
-    bool repeat;
-};
-
-struct sc_text_event {
-    const char *text; // not owned
-};
-
-struct sc_mouse_click_event {
-    struct sc_position position;
-    enum sc_action action;
-    enum sc_mouse_button button;
-    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
-};
-
-struct sc_mouse_scroll_event {
-    struct sc_position position;
-    int32_t hscroll;
-    int32_t vscroll;
-    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
-};
-
-struct sc_mouse_motion_event {
-    struct sc_position position;
-    int32_t xrel;
-    int32_t yrel;
-    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
-};
-
-struct sc_touch_event {
-    struct sc_position position;
-    enum sc_touch_action action;
-    uint64_t pointer_id;
-    float pressure;
-};
-
-static inline uint16_t
-sc_mods_state_from_sdl(uint16_t mods_state) {
-    return mods_state;
-}
-
-static inline enum sc_keycode
-sc_keycode_from_sdl(SDL_Keycode keycode) {
-    return (enum sc_keycode) keycode;
-}
-
-static inline enum sc_scancode
-sc_scancode_from_sdl(SDL_Scancode scancode) {
-    return (enum sc_scancode) scancode;
-}
-
-static inline enum sc_action
-sc_action_from_sdl_keyboard_type(uint32_t type) {
-    assert(type == SDL_KEYDOWN || type == SDL_KEYUP);
-    if (type == SDL_KEYDOWN) {
-        return SC_ACTION_DOWN;
-    }
-    return SC_ACTION_UP;
-}
-
-static inline enum sc_action
-sc_action_from_sdl_mousebutton_type(uint32_t type) {
-    assert(type == SDL_MOUSEBUTTONDOWN || type == SDL_MOUSEBUTTONUP);
-    if (type == SDL_MOUSEBUTTONDOWN) {
-        return SC_ACTION_DOWN;
-    }
-    return SC_ACTION_UP;
-}
-
-static inline enum sc_touch_action
-sc_touch_action_from_sdl(uint32_t type) {
-    assert(type == SDL_FINGERMOTION || type == SDL_FINGERDOWN ||
-           type == SDL_FINGERUP);
-    if (type == SDL_FINGERMOTION) {
-        return SC_TOUCH_ACTION_MOVE;
-    }
-    if (type == SDL_FINGERDOWN) {
-        return SC_TOUCH_ACTION_DOWN;
-    }
-    return SC_TOUCH_ACTION_UP;
-}
-
-static inline enum sc_mouse_button
-sc_mouse_button_from_sdl(uint8_t button) {
-    if (button >= SDL_BUTTON_LEFT && button <= SDL_BUTTON_X2) {
-        // SC_MOUSE_BUTTON_* constants are initialized from SDL_BUTTON(index)
-        return SDL_BUTTON(button);
-    }
-
-    return SC_MOUSE_BUTTON_UNKNOWN;
-}
-
-static inline uint8_t
-sc_mouse_buttons_state_from_sdl(uint32_t buttons_state,
-                                bool forward_all_clicks) {
-    assert(buttons_state < 0x100); // fits in uint8_t
-
-    uint8_t mask = SC_MOUSE_BUTTON_LEFT;
-    if (forward_all_clicks) {
-        mask |= SC_MOUSE_BUTTON_RIGHT
-              | SC_MOUSE_BUTTON_MIDDLE
-              | SC_MOUSE_BUTTON_X1
-              | SC_MOUSE_BUTTON_X2;
-    }
-
-    return buttons_state & mask;
-}
-
-#endif
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@ -1,5 +1,5 @@
-#ifndef SC_INPUTMANAGER_H
-#define SC_INPUTMANAGER_H
+#ifndef INPUTMANAGER_H
+#define INPUTMANAGER_H

 #include "common.h"

@ -8,23 +8,25 @@
 #include <SDL2/SDL.h>

 #include "controller.h"
-#include "file_pusher.h"
 #include "fps_counter.h"
-#include "options.h"
-#include "trait/key_processor.h"
-#include "trait/mouse_processor.h"
+#include "scrcpy.h"
+#include "screen.h"
+#include "video_buffer.h"

-struct sc_input_manager {
-    struct sc_controller *controller;
-    struct sc_file_pusher *fp;
-    struct sc_screen *screen;
+struct input_manager {
+    struct controller *controller;
+    struct video_buffer *video_buffer;
+    struct screen *screen;

-    struct sc_key_processor *kp;
-    struct sc_mouse_processor *mp;
+    // SDL reports repeated events as a boolean, but Android expects the actual
+    // number of repetitions. This variable keeps track of the count.
+    unsigned repeat;

+    bool control;
+    bool forward_key_repeat;
+    bool prefer_text;
    bool forward_all_clicks;
    bool legacy_paste;
-    bool clipboard_autosync;

    struct {
        unsigned data[SC_MAX_SHORTCUT_MODS];
@ -32,35 +34,34 @@ struct sc_input_manager {
    } sdl_shortcut_mods;

    bool vfinger_down;
-
-    // Tracks the number of identical consecutive shortcut key down events.
-    // Not to be confused with event->repeat, which counts the number of
-    // system-generated repeated key presses.
-    unsigned key_repeat;
-    SDL_Keycode last_keycode;
-    uint16_t last_mod;
-
-    uint64_t next_sequence; // used for request acknowledgements
-};
-
-struct sc_input_manager_params {
-    struct sc_controller *controller;
-    struct sc_file_pusher *fp;
-    struct sc_screen *screen;
-    struct sc_key_processor *kp;
-    struct sc_mouse_processor *mp;
-
-    bool forward_all_clicks;
-    bool legacy_paste;
-    bool clipboard_autosync;
-    const struct sc_shortcut_mods *shortcut_mods;
 };

 void
-sc_input_manager_init(struct sc_input_manager *im,
-                      const struct sc_input_manager_params *params);
+input_manager_init(struct input_manager *im,
+                   const struct scrcpy_options *options);

 void
-sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event);
+input_manager_process_text_input(struct input_manager *im,
+                                 const SDL_TextInputEvent *event);
+
+void
+input_manager_process_key(struct input_manager *im,
+                          const SDL_KeyboardEvent *event);
+
+void
+input_manager_process_mouse_motion(struct input_manager *im,
+                                   const SDL_MouseMotionEvent *event);
+
+void
+input_manager_process_touch(struct input_manager *im,
+                            const SDL_TouchFingerEvent *event);
+
+void
+input_manager_process_mouse_button(struct input_manager *im,
+                                   const SDL_MouseButtonEvent *event);
+
+void
+input_manager_process_mouse_wheel(struct input_manager *im,
+                                  const SDL_MouseWheelEvent *event);

 #endif
--- a/app/src/keyboard_inject.c
+++ b/app/src/keyboard_inject.c
@ -1,344 +0,0 @@
-#include "keyboard_inject.h"
-
-#include <assert.h>
-
-#include "android/input.h"
-#include "control_msg.h"
-#include "controller.h"
-#include "input_events.h"
-#include "util/intmap.h"
-#include "util/log.h"
-
-/** Downcast key processor to sc_keyboard_inject */
-#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_inject, key_processor)
-
-static enum android_keyevent_action
-convert_keycode_action(enum sc_action action) {
-    if (action == SC_ACTION_DOWN) {
-        return AKEY_EVENT_ACTION_DOWN;
-    }
-    assert(action == SC_ACTION_UP);
-    return AKEY_EVENT_ACTION_UP;
-}
-
-static bool
-convert_keycode(enum sc_keycode from, enum android_keycode *to, uint16_t mod,
-                enum sc_key_inject_mode key_inject_mode) {
-    // Navigation keys and ENTER.
-    // Used in all modes.
-    static const struct sc_intmap_entry special_keys[] = {
-        {SC_KEYCODE_RETURN,    AKEYCODE_ENTER},
-        {SC_KEYCODE_KP_ENTER,  AKEYCODE_NUMPAD_ENTER},
-        {SC_KEYCODE_ESCAPE,    AKEYCODE_ESCAPE},
-        {SC_KEYCODE_BACKSPACE, AKEYCODE_DEL},
-        {SC_KEYCODE_TAB,       AKEYCODE_TAB},
-        {SC_KEYCODE_PAGEUP,    AKEYCODE_PAGE_UP},
-        {SC_KEYCODE_DELETE,    AKEYCODE_FORWARD_DEL},
-        {SC_KEYCODE_HOME,      AKEYCODE_MOVE_HOME},
-        {SC_KEYCODE_END,       AKEYCODE_MOVE_END},
-        {SC_KEYCODE_PAGEDOWN,  AKEYCODE_PAGE_DOWN},
-        {SC_KEYCODE_RIGHT,     AKEYCODE_DPAD_RIGHT},
-        {SC_KEYCODE_LEFT,      AKEYCODE_DPAD_LEFT},
-        {SC_KEYCODE_DOWN,      AKEYCODE_DPAD_DOWN},
-        {SC_KEYCODE_UP,        AKEYCODE_DPAD_UP},
-        {SC_KEYCODE_LCTRL,     AKEYCODE_CTRL_LEFT},
-        {SC_KEYCODE_RCTRL,     AKEYCODE_CTRL_RIGHT},
-        {SC_KEYCODE_LSHIFT,    AKEYCODE_SHIFT_LEFT},
-        {SC_KEYCODE_RSHIFT,    AKEYCODE_SHIFT_RIGHT},
-    };
-
-    // Numpad navigation keys.
-    // Used in all modes, when NumLock and Shift are disabled.
-    static const struct sc_intmap_entry kp_nav_keys[] = {
-        {SC_KEYCODE_KP_0,      AKEYCODE_INSERT},
-        {SC_KEYCODE_KP_1,      AKEYCODE_MOVE_END},
-        {SC_KEYCODE_KP_2,      AKEYCODE_DPAD_DOWN},
-        {SC_KEYCODE_KP_3,      AKEYCODE_PAGE_DOWN},
-        {SC_KEYCODE_KP_4,      AKEYCODE_DPAD_LEFT},
-        {SC_KEYCODE_KP_6,      AKEYCODE_DPAD_RIGHT},
-        {SC_KEYCODE_KP_7,      AKEYCODE_MOVE_HOME},
-        {SC_KEYCODE_KP_8,      AKEYCODE_DPAD_UP},
-        {SC_KEYCODE_KP_9,      AKEYCODE_PAGE_UP},
-        {SC_KEYCODE_KP_PERIOD, AKEYCODE_FORWARD_DEL},
-    };
-
-    // Letters and space.
-    // Used in non-text mode.
-    static const struct sc_intmap_entry alphaspace_keys[] = {
-        {SC_KEYCODE_a,         AKEYCODE_A},
-        {SC_KEYCODE_b,         AKEYCODE_B},
-        {SC_KEYCODE_c,         AKEYCODE_C},
-        {SC_KEYCODE_d,         AKEYCODE_D},
-        {SC_KEYCODE_e,         AKEYCODE_E},
-        {SC_KEYCODE_f,         AKEYCODE_F},
-        {SC_KEYCODE_g,         AKEYCODE_G},
-        {SC_KEYCODE_h,         AKEYCODE_H},
-        {SC_KEYCODE_i,         AKEYCODE_I},
-        {SC_KEYCODE_j,         AKEYCODE_J},
-        {SC_KEYCODE_k,         AKEYCODE_K},
-        {SC_KEYCODE_l,         AKEYCODE_L},
-        {SC_KEYCODE_m,         AKEYCODE_M},
-        {SC_KEYCODE_n,         AKEYCODE_N},
-        {SC_KEYCODE_o,         AKEYCODE_O},
-        {SC_KEYCODE_p,         AKEYCODE_P},
-        {SC_KEYCODE_q,         AKEYCODE_Q},
-        {SC_KEYCODE_r,         AKEYCODE_R},
-        {SC_KEYCODE_s,         AKEYCODE_S},
-        {SC_KEYCODE_t,         AKEYCODE_T},
-        {SC_KEYCODE_u,         AKEYCODE_U},
-        {SC_KEYCODE_v,         AKEYCODE_V},
-        {SC_KEYCODE_w,         AKEYCODE_W},
-        {SC_KEYCODE_x,         AKEYCODE_X},
-        {SC_KEYCODE_y,         AKEYCODE_Y},
-        {SC_KEYCODE_z,         AKEYCODE_Z},
-        {SC_KEYCODE_SPACE,     AKEYCODE_SPACE},
-    };
-
-    // Numbers and punctuation keys.
-    // Used in raw mode only.
-    static const struct sc_intmap_entry numbers_punct_keys[] = {
-        {SC_KEYCODE_HASH,          AKEYCODE_POUND},
-        {SC_KEYCODE_PERCENT,       AKEYCODE_PERIOD},
-        {SC_KEYCODE_QUOTE,         AKEYCODE_APOSTROPHE},
-        {SC_KEYCODE_ASTERISK,      AKEYCODE_STAR},
-        {SC_KEYCODE_PLUS,          AKEYCODE_PLUS},
-        {SC_KEYCODE_COMMA,         AKEYCODE_COMMA},
-        {SC_KEYCODE_MINUS,         AKEYCODE_MINUS},
-        {SC_KEYCODE_PERIOD,        AKEYCODE_PERIOD},
-        {SC_KEYCODE_SLASH,         AKEYCODE_SLASH},
-        {SC_KEYCODE_0,             AKEYCODE_0},
-        {SC_KEYCODE_1,             AKEYCODE_1},
-        {SC_KEYCODE_2,             AKEYCODE_2},
-        {SC_KEYCODE_3,             AKEYCODE_3},
-        {SC_KEYCODE_4,             AKEYCODE_4},
-        {SC_KEYCODE_5,             AKEYCODE_5},
-        {SC_KEYCODE_6,             AKEYCODE_6},
-        {SC_KEYCODE_7,             AKEYCODE_7},
-        {SC_KEYCODE_8,             AKEYCODE_8},
-        {SC_KEYCODE_9,             AKEYCODE_9},
-        {SC_KEYCODE_SEMICOLON,     AKEYCODE_SEMICOLON},
-        {SC_KEYCODE_EQUALS,        AKEYCODE_EQUALS},
-        {SC_KEYCODE_AT,            AKEYCODE_AT},
-        {SC_KEYCODE_LEFTBRACKET,   AKEYCODE_LEFT_BRACKET},
-        {SC_KEYCODE_BACKSLASH,     AKEYCODE_BACKSLASH},
-        {SC_KEYCODE_RIGHTBRACKET,  AKEYCODE_RIGHT_BRACKET},
-        {SC_KEYCODE_BACKQUOTE,     AKEYCODE_GRAVE},
-        {SC_KEYCODE_KP_1,          AKEYCODE_NUMPAD_1},
-        {SC_KEYCODE_KP_2,          AKEYCODE_NUMPAD_2},
-        {SC_KEYCODE_KP_3,          AKEYCODE_NUMPAD_3},
-        {SC_KEYCODE_KP_4,          AKEYCODE_NUMPAD_4},
-        {SC_KEYCODE_KP_5,          AKEYCODE_NUMPAD_5},
-        {SC_KEYCODE_KP_6,          AKEYCODE_NUMPAD_6},
-        {SC_KEYCODE_KP_7,          AKEYCODE_NUMPAD_7},
-        {SC_KEYCODE_KP_8,          AKEYCODE_NUMPAD_8},
-        {SC_KEYCODE_KP_9,          AKEYCODE_NUMPAD_9},
-        {SC_KEYCODE_KP_0,          AKEYCODE_NUMPAD_0},
-        {SC_KEYCODE_KP_DIVIDE,     AKEYCODE_NUMPAD_DIVIDE},
-        {SC_KEYCODE_KP_MULTIPLY,   AKEYCODE_NUMPAD_MULTIPLY},
-        {SC_KEYCODE_KP_MINUS,      AKEYCODE_NUMPAD_SUBTRACT},
-        {SC_KEYCODE_KP_PLUS,       AKEYCODE_NUMPAD_ADD},
-        {SC_KEYCODE_KP_PERIOD,     AKEYCODE_NUMPAD_DOT},
-        {SC_KEYCODE_KP_EQUALS,     AKEYCODE_NUMPAD_EQUALS},
-        {SC_KEYCODE_KP_LEFTPAREN,  AKEYCODE_NUMPAD_LEFT_PAREN},
-        {SC_KEYCODE_KP_RIGHTPAREN, AKEYCODE_NUMPAD_RIGHT_PAREN},
-    };
-
-    const struct sc_intmap_entry *entry =
-        SC_INTMAP_FIND_ENTRY(special_keys, from);
-    if (entry) {
-        *to = entry->value;
-        return true;
-    }
-
-    if (!(mod & (SC_MOD_NUM | SC_MOD_LSHIFT | SC_MOD_RSHIFT))) {
-        // Handle Numpad events when Num Lock is disabled
-        // If SHIFT is pressed, a text event will be sent instead
-        entry = SC_INTMAP_FIND_ENTRY(kp_nav_keys, from);
-        if (entry) {
-            *to = entry->value;
-            return true;
-        }
-    }
-
-    if (key_inject_mode == SC_KEY_INJECT_MODE_TEXT &&
-            !(mod & (SC_MOD_LCTRL | SC_MOD_RCTRL))) {
-        // do not forward alpha and space key events (unless Ctrl is pressed)
-        return false;
-    }
-
-    if (mod & (SC_MOD_LALT | SC_MOD_RALT | SC_MOD_LGUI | SC_MOD_RGUI)) {
-        return false;
-    }
-
-    // if ALT and META are not pressed, also handle letters and space
-    entry = SC_INTMAP_FIND_ENTRY(alphaspace_keys, from);
-    if (entry) {
-        *to = entry->value;
-        return true;
-    }
-
-    if (key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
-        entry = SC_INTMAP_FIND_ENTRY(numbers_punct_keys, from);
-        if (entry) {
-            *to = entry->value;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-static enum android_metastate
-autocomplete_metastate(enum android_metastate metastate) {
-    // fill dependent flags
-    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
-        metastate |= AMETA_SHIFT_ON;
-    }
-    if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
-        metastate |= AMETA_CTRL_ON;
-    }
-    if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
-        metastate |= AMETA_ALT_ON;
-    }
-    if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
-        metastate |= AMETA_META_ON;
-    }
-
-    return metastate;
-}
-
-static enum android_metastate
-convert_meta_state(uint16_t mod) {
-    enum android_metastate metastate = 0;
-    if (mod & SC_MOD_LSHIFT) {
-        metastate |= AMETA_SHIFT_LEFT_ON;
-    }
-    if (mod & SC_MOD_RSHIFT) {
-        metastate |= AMETA_SHIFT_RIGHT_ON;
-    }
-    if (mod & SC_MOD_LCTRL) {
-        metastate |= AMETA_CTRL_LEFT_ON;
-    }
-    if (mod & SC_MOD_RCTRL) {
-        metastate |= AMETA_CTRL_RIGHT_ON;
-    }
-    if (mod & SC_MOD_LALT) {
-        metastate |= AMETA_ALT_LEFT_ON;
-    }
-    if (mod & SC_MOD_RALT) {
-        metastate |= AMETA_ALT_RIGHT_ON;
-    }
-    if (mod & SC_MOD_LGUI) { // Windows key
-        metastate |= AMETA_META_LEFT_ON;
-    }
-    if (mod & SC_MOD_RGUI) { // Windows key
-        metastate |= AMETA_META_RIGHT_ON;
-    }
-    if (mod & SC_MOD_NUM) {
-        metastate |= AMETA_NUM_LOCK_ON;
-    }
-    if (mod & SC_MOD_CAPS) {
-        metastate |= AMETA_CAPS_LOCK_ON;
-    }
-
-    // fill the dependent fields
-    return autocomplete_metastate(metastate);
-}
-
-static bool
-convert_input_key(const struct sc_key_event *event, struct sc_control_msg *msg,
-                  enum sc_key_inject_mode key_inject_mode, uint32_t repeat) {
-    msg->type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
-
-    if (!convert_keycode(event->keycode, &msg->inject_keycode.keycode,
-                         event->mods_state, key_inject_mode)) {
-        return false;
-    }
-
-    msg->inject_keycode.action = convert_keycode_action(event->action);
-    msg->inject_keycode.repeat = repeat;
-    msg->inject_keycode.metastate = convert_meta_state(event->mods_state);
-
-    return true;
-}
-
-static void
-sc_key_processor_process_key(struct sc_key_processor *kp,
-                             const struct sc_key_event *event,
-                             uint64_t ack_to_wait) {
-    // The device clipboard synchronization and the key event messages are
-    // serialized, there is nothing special to do to ensure that the clipboard
-    // is set before injecting Ctrl+v.
-    (void) ack_to_wait;
-
-    struct sc_keyboard_inject *ki = DOWNCAST(kp);
-
-    if (event->repeat) {
-        if (!ki->forward_key_repeat) {
-            return;
-        }
-        ++ki->repeat;
-    } else {
-        ki->repeat = 0;
-    }
-
-    struct sc_control_msg 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'");
-        }
-    }
-}
-
-static void
-sc_key_processor_process_text(struct sc_key_processor *kp,
-                              const struct sc_text_event *event) {
-    struct sc_keyboard_inject *ki = DOWNCAST(kp);
-
-    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
-        // Never inject text events
-        return;
-    }
-
-    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_MIXED) {
-        char c = event->text[0];
-        if (isalpha(c) || c == ' ') {
-            assert(event->text[1] == '\0');
-            // Letters and space are handled as raw key events
-            return;
-        }
-    }
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = strdup(event->text);
-    if (!msg.inject_text.text) {
-        LOGW("Could not strdup input text");
-        return;
-    }
-    if (!sc_controller_push_msg(ki->controller, &msg)) {
-        free(msg.inject_text.text);
-        LOGW("Could not request 'inject text'");
-    }
-}
-
-void
-sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
-                        struct 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;
-
-    ki->repeat = 0;
-
-    static const struct sc_key_processor_ops ops = {
-        .process_key = sc_key_processor_process_key,
-        .process_text = sc_key_processor_process_text,
-    };
-
-    // Key injection and clipboard synchronization are serialized
-    ki->key_processor.async_paste = false;
-    ki->key_processor.ops = &ops;
-}
--- a/app/src/keyboard_inject.h
+++ b/app/src/keyboard_inject.h
@ -1,31 +0,0 @@
-#ifndef SC_KEYBOARD_INJECT_H
-#define SC_KEYBOARD_INJECT_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "controller.h"
-#include "options.h"
-#include "trait/key_processor.h"
-
-struct sc_keyboard_inject {
-    struct sc_key_processor key_processor; // key processor trait
-
-    struct sc_controller *controller;
-
-    // SDL reports repeated events as a boolean, but Android expects the actual
-    // number of repetitions. This variable keeps track of the count.
-    unsigned repeat;
-
-    enum sc_key_inject_mode key_inject_mode;
-    bool forward_key_repeat;
-};
-
-void
-sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
-                        struct 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
@ -1,21 +1,52 @@
+#include "scrcpy.h"
+
 #include "common.h"

 #include <assert.h>
 #include <stdbool.h>
 #include <unistd.h>
 #include <libavformat/avformat.h>
-#ifdef HAVE_V4L2
-# include <libavdevice/avdevice.h>
-#endif
 #define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
 #include <SDL2/SDL.h>

 #include "cli.h"
-#include "options.h"
-#include "scrcpy.h"
-#include "usb/scrcpy_otg.h"
 #include "util/log.h"
-#include "version.h"
+
+static void
+print_version(void) {
+    fprintf(stderr, "scrcpy %s\n\n", SCRCPY_VERSION);
+
+    fprintf(stderr, "dependencies:\n");
+    fprintf(stderr, " - SDL %d.%d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION,
+                                         SDL_PATCHLEVEL);
+    fprintf(stderr, " - libavcodec %d.%d.%d\n", LIBAVCODEC_VERSION_MAJOR,
+                                                LIBAVCODEC_VERSION_MINOR,
+                                                LIBAVCODEC_VERSION_MICRO);
+    fprintf(stderr, " - libavformat %d.%d.%d\n", LIBAVFORMAT_VERSION_MAJOR,
+                                                 LIBAVFORMAT_VERSION_MINOR,
+                                                 LIBAVFORMAT_VERSION_MICRO);
+    fprintf(stderr, " - libavutil %d.%d.%d\n", LIBAVUTIL_VERSION_MAJOR,
+                                               LIBAVUTIL_VERSION_MINOR,
+                                               LIBAVUTIL_VERSION_MICRO);
+}
+
+static SDL_LogPriority
+convert_log_level_to_sdl(enum sc_log_level level) {
+    switch (level) {
+        case SC_LOG_LEVEL_DEBUG:
+            return SDL_LOG_PRIORITY_DEBUG;
+        case SC_LOG_LEVEL_INFO:
+            return SDL_LOG_PRIORITY_INFO;
+        case SC_LOG_LEVEL_WARN:
+            return SDL_LOG_PRIORITY_WARN;
+        case SC_LOG_LEVEL_ERROR:
+            return SDL_LOG_PRIORITY_ERROR;
+        default:
+            assert(!"unexpected log level");
+            return SDL_LOG_PRIORITY_INFO;
+    }
+}
+

 int
 main(int argc, char *argv[]) {
@ -26,11 +57,8 @@ main(int argc, char *argv[]) {
    setbuf(stderr, NULL);
 #endif

-    printf("scrcpy " SCRCPY_VERSION
-           " <https://github.com/Genymobile/scrcpy>\n");
-
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
@ -40,43 +68,35 @@ main(int argc, char *argv[]) {
 #endif

    if (!scrcpy_parse_args(&args, argc, argv)) {
-        return SCRCPY_EXIT_FAILURE;
+        return 1;
    }

-    sc_set_log_level(args.opts.log_level);
+    SDL_LogPriority sdl_log = convert_log_level_to_sdl(args.opts.log_level);
+    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, sdl_log);

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

    if (args.version) {
-        scrcpy_print_version();
-        return SCRCPY_EXIT_SUCCESS;
+        print_version();
+        return 0;
    }

+    LOGI("scrcpy " SCRCPY_VERSION " <https://github.com/Genymobile/scrcpy>");
+
 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
    av_register_all();
 #endif

-#ifdef HAVE_V4L2
-    if (args.opts.v4l2_device) {
-        avdevice_register_all();
-    }
-#endif
-
    if (avformat_network_init()) {
-        return SCRCPY_EXIT_FAILURE;
+        return 1;
    }

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

    avformat_network_deinit(); // ignore failure

-    return ret;
+    return res;
 }
--- a/app/src/mouse_inject.c
+++ b/app/src/mouse_inject.c
@ -1,161 +0,0 @@
-#include "mouse_inject.h"
-
-#include <assert.h>
-
-#include "android/input.h"
-#include "control_msg.h"
-#include "controller.h"
-#include "input_events.h"
-#include "util/intmap.h"
-#include "util/log.h"
-
-/** Downcast mouse processor to sc_mouse_inject */
-#define DOWNCAST(MP) container_of(MP, struct sc_mouse_inject, mouse_processor)
-
-static enum android_motionevent_buttons
-convert_mouse_buttons(uint32_t state) {
-    enum android_motionevent_buttons buttons = 0;
-    if (state & SC_MOUSE_BUTTON_LEFT) {
-        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
-    }
-    if (state & SC_MOUSE_BUTTON_RIGHT) {
-        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
-    }
-    if (state & SC_MOUSE_BUTTON_MIDDLE) {
-        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
-    }
-    if (state & SC_MOUSE_BUTTON_X1) {
-        buttons |= AMOTION_EVENT_BUTTON_BACK;
-    }
-    if (state & SC_MOUSE_BUTTON_X2) {
-        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
-    }
-    return buttons;
-}
-
-static enum android_motionevent_action
-convert_mouse_action(enum sc_action action) {
-    if (action == SC_ACTION_DOWN) {
-        return AMOTION_EVENT_ACTION_DOWN;
-    }
-    assert(action == SC_ACTION_UP);
-    return AMOTION_EVENT_ACTION_UP;
-}
-
-static enum android_motionevent_action
-convert_touch_action(enum sc_touch_action action) {
-    switch (action) {
-        case SC_TOUCH_ACTION_MOVE:
-            return AMOTION_EVENT_ACTION_MOVE;
-        case SC_TOUCH_ACTION_DOWN:
-            return AMOTION_EVENT_ACTION_DOWN;
-        default:
-            assert(action == SC_TOUCH_ACTION_UP);
-            return AMOTION_EVENT_ACTION_UP;
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_motion_event *event) {
-    if (!event->buttons_state) {
-        // Do not send motion events when no click is pressed
-        return;
-    }
-
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-        .inject_touch_event = {
-            .action = AMOTION_EVENT_ACTION_MOVE,
-            .pointer_id = POINTER_ID_MOUSE,
-            .position = event->position,
-            .pressure = 1.f,
-            .buttons = convert_mouse_buttons(event->buttons_state),
-        },
-    };
-
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
-        LOGW("Could not request 'inject mouse motion event'");
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_click_event *event) {
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-        .inject_touch_event = {
-            .action = convert_mouse_action(event->action),
-            .pointer_id = POINTER_ID_MOUSE,
-            .position = event->position,
-            .pressure = event->action == SC_ACTION_DOWN ? 1.f : 0.f,
-            .buttons = convert_mouse_buttons(event->buttons_state),
-        },
-    };
-
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
-        LOGW("Could not request 'inject mouse click event'");
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
-                                   const struct sc_mouse_scroll_event *event) {
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
-        .inject_scroll_event = {
-            .position = event->position,
-            .hscroll = event->hscroll,
-            .vscroll = event->vscroll,
-            .buttons = convert_mouse_buttons(event->buttons_state),
-        },
-    };
-
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
-        LOGW("Could not request 'inject mouse scroll event'");
-    }
-}
-
-static void
-sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
-                                 const struct sc_touch_event *event) {
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-        .inject_touch_event = {
-            .action = convert_touch_action(event->action),
-            .pointer_id = event->pointer_id,
-            .position = event->position,
-            .pressure = event->pressure,
-            .buttons = 0,
-        },
-    };
-
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
-        LOGW("Could not request 'inject touch event'");
-    }
-}
-
-void
-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,
-        .process_mouse_click = sc_mouse_processor_process_mouse_click,
-        .process_mouse_scroll = sc_mouse_processor_process_mouse_scroll,
-        .process_touch = sc_mouse_processor_process_touch,
-    };
-
-    mi->mouse_processor.ops = &ops;
-
-    mi->mouse_processor.relative_mode = false;
-}
--- a/app/src/mouse_inject.h
+++ b/app/src/mouse_inject.h
@ -1,22 +0,0 @@
-#ifndef SC_MOUSE_INJECT_H
-#define SC_MOUSE_INJECT_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "controller.h"
-#include "screen.h"
-#include "trait/mouse_processor.h"
-
-struct sc_mouse_inject {
-    struct sc_mouse_processor mouse_processor; // mouse processor trait
-
-    struct sc_controller *controller;
-};
-
-void
-sc_mouse_inject_init(struct sc_mouse_inject *mi,
-                     struct sc_controller *controller);
-
-#endif
--- a/app/src/opengl.c
+++ b/app/src/opengl.c
@ -28,7 +28,7 @@ sc_opengl_init(struct sc_opengl *gl) {
                               sizeof(OPENGL_ES_PREFIX) - 1);
    if (gl->is_opengles) {
        /* skip the prefix */
-        version += sizeof(OPENGL_ES_PREFIX) - 1;
+        version += sizeof(PREFIX) - 1;
    }

    int r = sscanf(version, "%d.%d", &gl->version_major, &gl->version_minor);
--- a/app/src/options.c
+++ b/app/src/options.c
@ -1,68 +0,0 @@
-#include "options.h"
-
-const struct scrcpy_options scrcpy_options_default = {
-    .serial = NULL,
-    .crop = NULL,
-    .record_filename = NULL,
-    .window_title = NULL,
-    .push_target = NULL,
-    .render_driver = NULL,
-    .codec_options = NULL,
-    .encoder_name = NULL,
-#ifdef HAVE_V4L2
-    .v4l2_device = NULL,
-#endif
-    .log_level = SC_LOG_LEVEL_INFO,
-    .record_format = SC_RECORD_FORMAT_AUTO,
-    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
-    .port_range = {
-        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
-        .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
-    },
-    .tunnel_host = 0,
-    .tunnel_port = 0,
-    .shortcut_mods = {
-        .data = {SC_SHORTCUT_MOD_LALT, SC_SHORTCUT_MOD_LSUPER},
-        .count = 2,
-    },
-    .max_size = 0,
-    .bit_rate = DEFAULT_BIT_RATE,
-    .max_fps = 0,
-    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
-    .rotation = 0,
-    .window_x = SC_WINDOW_POSITION_UNDEFINED,
-    .window_y = SC_WINDOW_POSITION_UNDEFINED,
-    .window_width = 0,
-    .window_height = 0,
-    .display_id = 0,
-    .display_buffer = 0,
-    .v4l2_buffer = 0,
-#ifdef HAVE_USB
-    .otg = false,
-#endif
-    .show_touches = false,
-    .fullscreen = false,
-    .always_on_top = false,
-    .control = true,
-    .display = true,
-    .turn_screen_off = false,
-    .key_inject_mode = SC_KEY_INJECT_MODE_MIXED,
-    .window_borderless = false,
-    .mipmaps = true,
-    .stay_awake = false,
-    .force_adb_forward = false,
-    .disable_screensaver = false,
-    .forward_key_repeat = true,
-    .forward_all_clicks = false,
-    .legacy_paste = false,
-    .power_off_on_close = false,
-    .clipboard_autosync = true,
-    .downsize_on_error = true,
-    .tcpip = false,
-    .tcpip_dst = NULL,
-    .select_tcpip = false,
-    .select_usb = false,
-    .cleanup = true,
-    .start_fps_counter = false,
-    .power_on = true,
-};
--- a/app/src/options.h
+++ b/app/src/options.h
@ -1,147 +0,0 @@
-#ifndef SCRCPY_OPTIONS_H
-#define SCRCPY_OPTIONS_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "util/tick.h"
-
-enum sc_log_level {
-    SC_LOG_LEVEL_VERBOSE,
-    SC_LOG_LEVEL_DEBUG,
-    SC_LOG_LEVEL_INFO,
-    SC_LOG_LEVEL_WARN,
-    SC_LOG_LEVEL_ERROR,
-};
-
-enum sc_record_format {
-    SC_RECORD_FORMAT_AUTO,
-    SC_RECORD_FORMAT_MP4,
-    SC_RECORD_FORMAT_MKV,
-};
-
-enum sc_lock_video_orientation {
-    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
-    // lock the current orientation when scrcpy starts
-    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
-    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
-    SC_LOCK_VIDEO_ORIENTATION_1,
-    SC_LOCK_VIDEO_ORIENTATION_2,
-    SC_LOCK_VIDEO_ORIENTATION_3,
-};
-
-enum sc_keyboard_input_mode {
-    SC_KEYBOARD_INPUT_MODE_INJECT,
-    SC_KEYBOARD_INPUT_MODE_HID,
-};
-
-enum sc_mouse_input_mode {
-    SC_MOUSE_INPUT_MODE_INJECT,
-    SC_MOUSE_INPUT_MODE_HID,
-};
-
-enum sc_key_inject_mode {
-    // Inject special keys, letters and space as key events.
-    // Inject numbers and punctuation as text events.
-    // This is the default mode.
-    SC_KEY_INJECT_MODE_MIXED,
-
-    // Inject special keys as key events.
-    // Inject letters and space, numbers and punctuation as text events.
-    SC_KEY_INJECT_MODE_TEXT,
-
-    // Inject everything as key events.
-    SC_KEY_INJECT_MODE_RAW,
-};
-
-#define SC_MAX_SHORTCUT_MODS 8
-
-enum sc_shortcut_mod {
-    SC_SHORTCUT_MOD_LCTRL = 1 << 0,
-    SC_SHORTCUT_MOD_RCTRL = 1 << 1,
-    SC_SHORTCUT_MOD_LALT = 1 << 2,
-    SC_SHORTCUT_MOD_RALT = 1 << 3,
-    SC_SHORTCUT_MOD_LSUPER = 1 << 4,
-    SC_SHORTCUT_MOD_RSUPER = 1 << 5,
-};
-
-struct sc_shortcut_mods {
-    unsigned data[SC_MAX_SHORTCUT_MODS];
-    unsigned count;
-};
-
-struct sc_port_range {
-    uint16_t first;
-    uint16_t last;
-};
-
-#define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
-
-struct scrcpy_options {
-    const char *serial;
-    const char *crop;
-    const char *record_filename;
-    const char *window_title;
-    const char *push_target;
-    const char *render_driver;
-    const char *codec_options;
-    const char *encoder_name;
-#ifdef HAVE_V4L2
-    const char *v4l2_device;
-#endif
-    enum sc_log_level log_level;
-    enum sc_record_format record_format;
-    enum sc_keyboard_input_mode keyboard_input_mode;
-    enum sc_mouse_input_mode mouse_input_mode;
-    struct sc_port_range port_range;
-    uint32_t tunnel_host;
-    uint16_t tunnel_port;
-    struct sc_shortcut_mods shortcut_mods;
-    uint16_t max_size;
-    uint32_t bit_rate;
-    uint16_t max_fps;
-    enum sc_lock_video_orientation lock_video_orientation;
-    uint8_t rotation;
-    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
-    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
-    uint16_t window_width;
-    uint16_t window_height;
-    uint32_t display_id;
-    sc_tick display_buffer;
-    sc_tick v4l2_buffer;
-#ifdef HAVE_USB
-    bool otg;
-#endif
-    bool show_touches;
-    bool fullscreen;
-    bool always_on_top;
-    bool control;
-    bool display;
-    bool turn_screen_off;
-    enum sc_key_inject_mode key_inject_mode;
-    bool window_borderless;
-    bool mipmaps;
-    bool stay_awake;
-    bool force_adb_forward;
-    bool disable_screensaver;
-    bool forward_key_repeat;
-    bool forward_all_clicks;
-    bool legacy_paste;
-    bool power_off_on_close;
-    bool clipboard_autosync;
-    bool downsize_on_error;
-    bool tcpip;
-    const char *tcpip_dst;
-    bool select_usb;
-    bool select_tcpip;
-    bool cleanup;
-    bool start_fps_counter;
-    bool power_on;
-};
-
-extern const struct scrcpy_options scrcpy_options_default;
-
-#endif
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@ -7,16 +7,12 @@
 #include "util/log.h"

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

@ -26,7 +22,7 @@ receiver_destroy(struct receiver *receiver) {
 }

 static void
-process_msg(struct receiver *receiver, struct device_msg *msg) {
+process_msg(struct device_msg *msg) {
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
            char *current = SDL_GetClipboardText();
@ -41,17 +37,11 @@ process_msg(struct receiver *receiver, struct device_msg *msg) {
            SDL_SetClipboardText(msg->clipboard.text);
            break;
        }
-        case DEVICE_MSG_TYPE_ACK_CLIPBOARD:
-            assert(receiver->acksync);
-            LOGD("Ack device clipboard sequence=%" PRIu64_,
-                 msg->ack_clipboard.sequence);
-            sc_acksync_ack(receiver->acksync, msg->ack_clipboard.sequence);
-            break;
    }
 }

 static ssize_t
-process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
+process_msgs(const unsigned char *buf, size_t len) {
    size_t head = 0;
    for (;;) {
        struct device_msg msg;
@ -63,7 +53,7 @@ process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
            return head;
        }

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

        head += r;
@ -91,7 +81,7 @@ run_receiver(void *data) {
        }

        head += r;
-        ssize_t consumed = process_msgs(receiver, buf, head);
+        ssize_t consumed = process_msgs(buf, head);
        if (consumed == -1) {
            // an error occurred
            break;
@ -111,10 +101,10 @@ bool
 receiver_start(struct receiver *receiver) {
    LOGD("Starting receiver thread");

-    bool ok = sc_thread_create(&receiver->thread, run_receiver,
-                               "scrcpy-receiver", receiver);
+    bool ok = sc_thread_create(&receiver->thread, run_receiver, "receiver",
+                               receiver);
    if (!ok) {
-        LOGE("Could not start receiver thread");
+        LOGC("Could not start receiver thread");
        return false;
    }

--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@ -1,27 +1,23 @@
-#ifndef SC_RECEIVER_H
-#define SC_RECEIVER_H
+#ifndef RECEIVER_H
+#define RECEIVER_H

 #include "common.h"

 #include <stdbool.h>

-#include "util/acksync.h"
 #include "util/net.h"
 #include "util/thread.h"

 // receive events from the device
 // managed by the controller
 struct receiver {
-    sc_socket control_socket;
+    socket_t control_socket;
    sc_thread thread;
    sc_mutex mutex;
-
-    struct sc_acksync *acksync;
 };

 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
-              struct sc_acksync *acksync);
+receiver_init(struct receiver *receiver, socket_t control_socket);

 void
 receiver_destroy(struct receiver *receiver);
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@ -1,15 +1,9 @@
 #include "recorder.h"

 #include <assert.h>
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
 #include <libavutil/time.h>

 #include "util/log.h"
-#include "util/str.h"
-
-/** Downcast packet_sink to recorder */
-#define DOWNCAST(SINK) container_of(SINK, struct sc_recorder, packet_sink)

 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us

@ -25,28 +19,23 @@ find_muxer(const char *name) {
 #else
        oformat = av_oformat_next(oformat);
 #endif
-        // until null or containing the requested name
-    } while (oformat && !sc_str_list_contains(oformat->name, ',', name));
+        // until null or with name "mp4"
+    } while (oformat && strcmp(oformat->name, name));
    return oformat;
 }

-static struct sc_record_packet *
-sc_record_packet_new(const AVPacket *packet) {
-    struct sc_record_packet *rec = malloc(sizeof(*rec));
+static struct record_packet *
+record_packet_new(const AVPacket *packet) {
+    struct record_packet *rec = malloc(sizeof(*rec));
    if (!rec) {
-        LOG_OOM();
        return NULL;
    }

-    rec->packet = av_packet_alloc();
-    if (!rec->packet) {
-        LOG_OOM();
-        free(rec);
-        return NULL;
-    }
+    // av_packet_ref() does not initialize all fields in old FFmpeg versions
+    // See <https://github.com/Genymobile/scrcpy/issues/707>
+    av_init_packet(&rec->packet);

-    if (av_packet_ref(rec->packet, packet)) {
-        av_packet_free(&rec->packet);
+    if (av_packet_ref(&rec->packet, packet)) {
        free(rec);
        return NULL;
    }
@ -54,22 +43,66 @@ sc_record_packet_new(const AVPacket *packet) {
 }

 static void
-sc_record_packet_delete(struct sc_record_packet *rec) {
-    av_packet_free(&rec->packet);
+record_packet_delete(struct record_packet *rec) {
+    av_packet_unref(&rec->packet);
    free(rec);
 }

 static void
-sc_recorder_queue_clear(struct sc_recorder_queue *queue) {
-    while (!sc_queue_is_empty(queue)) {
-        struct sc_record_packet *rec;
-        sc_queue_take(queue, next, &rec);
-        sc_record_packet_delete(rec);
+recorder_queue_clear(struct recorder_queue *queue) {
+    while (!queue_is_empty(queue)) {
+        struct record_packet *rec;
+        queue_take(queue, next, &rec);
+        record_packet_delete(rec);
    }
 }

+bool
+recorder_init(struct recorder *recorder,
+              const char *filename,
+              enum sc_record_format format,
+              struct size declared_frame_size) {
+    recorder->filename = strdup(filename);
+    if (!recorder->filename) {
+        LOGE("Could not strdup filename");
+        return false;
+    }
+
+    bool ok = sc_mutex_init(&recorder->mutex);
+    if (!ok) {
+        LOGC("Could not create mutex");
+        free(recorder->filename);
+        return false;
+    }
+
+    ok = sc_cond_init(&recorder->queue_cond);
+    if (!ok) {
+        LOGC("Could not create cond");
+        sc_mutex_destroy(&recorder->mutex);
+        free(recorder->filename);
+        return false;
+    }
+
+    queue_init(&recorder->queue);
+    recorder->stopped = false;
+    recorder->failed = false;
+    recorder->format = format;
+    recorder->declared_frame_size = declared_frame_size;
+    recorder->header_written = false;
+    recorder->previous = NULL;
+
+    return true;
+}
+
+void
+recorder_destroy(struct recorder *recorder) {
+    sc_cond_destroy(&recorder->queue_cond);
+    sc_mutex_destroy(&recorder->mutex);
+    free(recorder->filename);
+}
+
 static const char *
-sc_recorder_get_format_name(enum sc_record_format format) {
+recorder_get_format_name(enum sc_record_format format) {
    switch (format) {
        case SC_RECORD_FORMAT_MP4: return "mp4";
        case SC_RECORD_FORMAT_MKV: return "matroska";
@ -77,185 +110,20 @@ sc_recorder_get_format_name(enum sc_record_format format) {
    }
 }

-static bool
-sc_recorder_write_header(struct sc_recorder *recorder, const AVPacket *packet) {
-    AVStream *ostream = recorder->ctx->streams[0];
-
-    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
-    if (!extradata) {
-        LOG_OOM();
-        return false;
-    }
-
-    // copy the first packet to the extra data
-    memcpy(extradata, packet->data, packet->size);
-
-    ostream->codecpar->extradata = extradata;
-    ostream->codecpar->extradata_size = packet->size;
-
-    int ret = avformat_write_header(recorder->ctx, NULL);
-    if (ret < 0) {
-        LOGE("Failed to write header to %s", recorder->filename);
-        return false;
-    }
-
-    return true;
-}
-
-static void
-sc_recorder_rescale_packet(struct sc_recorder *recorder, AVPacket *packet) {
-    AVStream *ostream = recorder->ctx->streams[0];
-    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
-}
-
-static bool
-sc_recorder_write(struct sc_recorder *recorder, AVPacket *packet) {
-    if (!recorder->header_written) {
-        if (packet->pts != AV_NOPTS_VALUE) {
-            LOGE("The first packet is not a config packet");
-            return false;
-        }
-        bool ok = sc_recorder_write_header(recorder, packet);
-        if (!ok) {
-            return false;
-        }
-        recorder->header_written = true;
-        return true;
-    }
-
-    if (packet->pts == AV_NOPTS_VALUE) {
-        // ignore config packets
-        return true;
-    }
-
-    sc_recorder_rescale_packet(recorder, packet);
-    return av_write_frame(recorder->ctx, packet) >= 0;
-}
-
-static int
-run_recorder(void *data) {
-    struct sc_recorder *recorder = data;
-
-    for (;;) {
-        sc_mutex_lock(&recorder->mutex);
-
-        while (!recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
-            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
-        }
-
-        // if stopped is set, continue to process the remaining events (to
-        // finish the recording) before actually stopping
-
-        if (recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
-            sc_mutex_unlock(&recorder->mutex);
-            struct sc_record_packet *last = recorder->previous;
-            if (last) {
-                // assign an arbitrary duration to the last packet
-                last->packet->duration = 100000;
-                bool ok = sc_recorder_write(recorder, last->packet);
-                if (!ok) {
-                    // failing to write the last frame is not very serious, no
-                    // future frame may depend on it, so the resulting file
-                    // will still be valid
-                    LOGW("Could not record last packet");
-                }
-                sc_record_packet_delete(last);
-            }
-            break;
-        }
-
-        struct sc_record_packet *rec;
-        sc_queue_take(&recorder->queue, next, &rec);
-
-        sc_mutex_unlock(&recorder->mutex);
-
-        // recorder->previous is only written from this thread, no need to lock
-        struct sc_record_packet *previous = recorder->previous;
-        recorder->previous = rec;
-
-        if (!previous) {
-            // we just received the first packet
-            continue;
-        }
-
-        // config packets have no PTS, we must ignore them
-        if (rec->packet->pts != AV_NOPTS_VALUE
-            && previous->packet->pts != AV_NOPTS_VALUE) {
-            // we now know the duration of the previous packet
-            previous->packet->duration =
-                rec->packet->pts - previous->packet->pts;
-        }
-
-        bool ok = sc_recorder_write(recorder, previous->packet);
-        sc_record_packet_delete(previous);
-        if (!ok) {
-            LOGE("Could not record packet");
-
-            sc_mutex_lock(&recorder->mutex);
-            recorder->failed = true;
-            // discard pending packets
-            sc_recorder_queue_clear(&recorder->queue);
-            sc_mutex_unlock(&recorder->mutex);
-            break;
-        }
-    }
-
-    if (!recorder->failed) {
-        if (recorder->header_written) {
-            int ret = av_write_trailer(recorder->ctx);
-            if (ret < 0) {
-                LOGE("Failed to write trailer to %s", recorder->filename);
-                recorder->failed = true;
-            }
-        } else {
-            // the recorded file is empty
-            recorder->failed = true;
-        }
-    }
-
-    if (recorder->failed) {
-        LOGE("Recording failed to %s", recorder->filename);
-    } else {
-        const char *format_name = sc_recorder_get_format_name(recorder->format);
-        LOGI("Recording complete to %s file: %s", format_name,
-                                                  recorder->filename);
-    }
-
-    LOGD("Recorder thread ended");
-
-    return 0;
-}
-
-static bool
-sc_recorder_open(struct sc_recorder *recorder, const AVCodec *input_codec) {
-    bool ok = sc_mutex_init(&recorder->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&recorder->queue_cond);
-    if (!ok) {
-        goto error_mutex_destroy;
-    }
-
-    sc_queue_init(&recorder->queue);
-    recorder->stopped = false;
-    recorder->failed = false;
-    recorder->header_written = false;
-    recorder->previous = NULL;
-
-    const char *format_name = sc_recorder_get_format_name(recorder->format);
+bool
+recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
+    const char *format_name = recorder_get_format_name(recorder->format);
    assert(format_name);
    const AVOutputFormat *format = find_muxer(format_name);
    if (!format) {
        LOGE("Could not find muxer");
-        goto error_cond_destroy;
+        return false;
    }

    recorder->ctx = avformat_alloc_context();
    if (!recorder->ctx) {
-        LOG_OOM();
-        goto error_cond_destroy;
+        LOGE("Could not allocate output context");
+        return false;
    }

    // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
@ -269,64 +137,223 @@ sc_recorder_open(struct sc_recorder *recorder, const AVCodec *input_codec) {

    AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
    if (!ostream) {
-        goto error_avformat_free_context;
+        avformat_free_context(recorder->ctx);
+        return false;
    }

+#ifdef SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_API
    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
    ostream->codecpar->codec_id = input_codec->id;
    ostream->codecpar->format = AV_PIX_FMT_YUV420P;
    ostream->codecpar->width = recorder->declared_frame_size.width;
    ostream->codecpar->height = recorder->declared_frame_size.height;
+#else
+    ostream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+    ostream->codec->codec_id = input_codec->id;
+    ostream->codec->pix_fmt = AV_PIX_FMT_YUV420P;
+    ostream->codec->width = recorder->declared_frame_size.width;
+    ostream->codec->height = recorder->declared_frame_size.height;
+#endif

    int ret = avio_open(&recorder->ctx->pb, recorder->filename,
                        AVIO_FLAG_WRITE);
    if (ret < 0) {
        LOGE("Failed to open output file: %s", recorder->filename);
        // ostream will be cleaned up during context cleaning
-        goto error_avformat_free_context;
-    }
-
-    LOGD("Starting recorder thread");
-    ok = sc_thread_create(&recorder->thread, run_recorder, "scrcpy-recorder",
-                          recorder);
-    if (!ok) {
-        LOGE("Could not start recorder thread");
-        goto error_avio_close;
+        avformat_free_context(recorder->ctx);
+        return false;
    }

    LOGI("Recording started to %s file: %s", format_name, recorder->filename);

    return true;
+}

-error_avio_close:
+void
+recorder_close(struct recorder *recorder) {
+    if (recorder->header_written) {
+        int ret = av_write_trailer(recorder->ctx);
+        if (ret < 0) {
+            LOGE("Failed to write trailer to %s", recorder->filename);
+            recorder->failed = true;
+        }
+    } else {
+        // the recorded file is empty
+        recorder->failed = true;
+    }
    avio_close(recorder->ctx->pb);
-error_avformat_free_context:
    avformat_free_context(recorder->ctx);
-error_cond_destroy:
-    sc_cond_destroy(&recorder->queue_cond);
-error_mutex_destroy:
-    sc_mutex_destroy(&recorder->mutex);

-    return false;
+    if (recorder->failed) {
+        LOGE("Recording failed to %s", recorder->filename);
+    } else {
+        const char *format_name = recorder_get_format_name(recorder->format);
+        LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
+    }
+}
+
+static bool
+recorder_write_header(struct recorder *recorder, const AVPacket *packet) {
+    AVStream *ostream = recorder->ctx->streams[0];
+
+    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
+    if (!extradata) {
+        LOGC("Could not allocate extradata");
+        return false;
+    }
+
+    // copy the first packet to the extra data
+    memcpy(extradata, packet->data, packet->size);
+
+#ifdef SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_API
+    ostream->codecpar->extradata = extradata;
+    ostream->codecpar->extradata_size = packet->size;
+#else
+    ostream->codec->extradata = extradata;
+    ostream->codec->extradata_size = packet->size;
+#endif
+
+    int ret = avformat_write_header(recorder->ctx, NULL);
+    if (ret < 0) {
+        LOGE("Failed to write header to %s", recorder->filename);
+        return false;
+    }
+
+    return true;
 }

 static void
-sc_recorder_close(struct sc_recorder *recorder) {
+recorder_rescale_packet(struct recorder *recorder, AVPacket *packet) {
+    AVStream *ostream = recorder->ctx->streams[0];
+    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
+}
+
+bool
+recorder_write(struct recorder *recorder, AVPacket *packet) {
+    if (!recorder->header_written) {
+        if (packet->pts != AV_NOPTS_VALUE) {
+            LOGE("The first packet is not a config packet");
+            return false;
+        }
+        bool ok = recorder_write_header(recorder, packet);
+        if (!ok) {
+            return false;
+        }
+        recorder->header_written = true;
+        return true;
+    }
+
+    if (packet->pts == AV_NOPTS_VALUE) {
+        // ignore config packets
+        return true;
+    }
+
+    recorder_rescale_packet(recorder, packet);
+    return av_write_frame(recorder->ctx, packet) >= 0;
+}
+
+static int
+run_recorder(void *data) {
+    struct recorder *recorder = data;
+
+    for (;;) {
+        sc_mutex_lock(&recorder->mutex);
+
+        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
+            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
+        }
+
+        // if stopped is set, continue to process the remaining events (to
+        // finish the recording) before actually stopping
+
+        if (recorder->stopped && queue_is_empty(&recorder->queue)) {
+            sc_mutex_unlock(&recorder->mutex);
+            struct record_packet *last = recorder->previous;
+            if (last) {
+                // assign an arbitrary duration to the last packet
+                last->packet.duration = 100000;
+                bool ok = recorder_write(recorder, &last->packet);
+                if (!ok) {
+                    // failing to write the last frame is not very serious, no
+                    // future frame may depend on it, so the resulting file
+                    // will still be valid
+                    LOGW("Could not record last packet");
+                }
+                record_packet_delete(last);
+            }
+            break;
+        }
+
+        struct record_packet *rec;
+        queue_take(&recorder->queue, next, &rec);
+
+        sc_mutex_unlock(&recorder->mutex);
+
+        // recorder->previous is only written from this thread, no need to lock
+        struct record_packet *previous = recorder->previous;
+        recorder->previous = rec;
+
+        if (!previous) {
+            // we just received the first packet
+            continue;
+        }
+
+        // config packets have no PTS, we must ignore them
+        if (rec->packet.pts != AV_NOPTS_VALUE
+            && previous->packet.pts != AV_NOPTS_VALUE) {
+            // we now know the duration of the previous packet
+            previous->packet.duration = rec->packet.pts - previous->packet.pts;
+        }
+
+        bool ok = recorder_write(recorder, &previous->packet);
+        record_packet_delete(previous);
+        if (!ok) {
+            LOGE("Could not record packet");
+
+            sc_mutex_lock(&recorder->mutex);
+            recorder->failed = true;
+            // discard pending packets
+            recorder_queue_clear(&recorder->queue);
+            sc_mutex_unlock(&recorder->mutex);
+            break;
+        }
+
+    }
+
+    LOGD("Recorder thread ended");
+
+    return 0;
+}
+
+bool
+recorder_start(struct recorder *recorder) {
+    LOGD("Starting recorder thread");
+
+    bool ok = sc_thread_create(&recorder->thread, run_recorder, "recorder",
+                               recorder);
+    if (!ok) {
+        LOGC("Could not start recorder thread");
+        return false;
+    }
+
+    return true;
+}
+
+void
+recorder_stop(struct recorder *recorder) {
    sc_mutex_lock(&recorder->mutex);
    recorder->stopped = true;
    sc_cond_signal(&recorder->queue_cond);
    sc_mutex_unlock(&recorder->mutex);
-
-    sc_thread_join(&recorder->thread, NULL);
-
-    avio_close(recorder->ctx->pb);
-    avformat_free_context(recorder->ctx);
-    sc_cond_destroy(&recorder->queue_cond);
-    sc_mutex_destroy(&recorder->mutex);
 }

-static bool
-sc_recorder_push(struct sc_recorder *recorder, const AVPacket *packet) {
+void
+recorder_join(struct recorder *recorder) {
+    sc_thread_join(&recorder->thread, NULL);
+}
+
+bool
+recorder_push(struct recorder *recorder, const AVPacket *packet) {
    sc_mutex_lock(&recorder->mutex);
    assert(!recorder->stopped);

@ -336,66 +363,16 @@ sc_recorder_push(struct sc_recorder *recorder, const AVPacket *packet) {
        return false;
    }

-    struct sc_record_packet *rec = sc_record_packet_new(packet);
+    struct record_packet *rec = record_packet_new(packet);
    if (!rec) {
-        LOG_OOM();
+        LOGC("Could not allocate record packet");
        sc_mutex_unlock(&recorder->mutex);
        return false;
    }

-    sc_queue_push(&recorder->queue, next, rec);
+    queue_push(&recorder->queue, next, rec);
    sc_cond_signal(&recorder->queue_cond);

    sc_mutex_unlock(&recorder->mutex);
    return true;
 }
-
-static bool
-sc_recorder_packet_sink_open(struct sc_packet_sink *sink,
-                             const AVCodec *codec) {
-    struct sc_recorder *recorder = DOWNCAST(sink);
-    return sc_recorder_open(recorder, codec);
-}
-
-static void
-sc_recorder_packet_sink_close(struct sc_packet_sink *sink) {
-    struct sc_recorder *recorder = DOWNCAST(sink);
-    sc_recorder_close(recorder);
-}
-
-static bool
-sc_recorder_packet_sink_push(struct sc_packet_sink *sink,
-                             const AVPacket *packet) {
-    struct sc_recorder *recorder = DOWNCAST(sink);
-    return sc_recorder_push(recorder, packet);
-}
-
-bool
-sc_recorder_init(struct sc_recorder *recorder,
-                 const char *filename,
-                 enum sc_record_format format,
-                 struct sc_size declared_frame_size) {
-    recorder->filename = strdup(filename);
-    if (!recorder->filename) {
-        LOG_OOM();
-        return false;
-    }
-
-    recorder->format = format;
-    recorder->declared_frame_size = declared_frame_size;
-
-    static const struct sc_packet_sink_ops ops = {
-        .open = sc_recorder_packet_sink_open,
-        .close = sc_recorder_packet_sink_close,
-        .push = sc_recorder_packet_sink_push,
-    };
-
-    recorder->packet_sink.ops = &ops;
-
-    return true;
-}
-
-void
-sc_recorder_destroy(struct sc_recorder *recorder) {
-    free(recorder->filename);
-}
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@ -1,5 +1,5 @@
-#ifndef SC_RECORDER_H
-#define SC_RECORDER_H
+#ifndef RECORDER_H
+#define RECORDER_H

 #include "common.h"

@ -7,47 +7,61 @@
 #include <libavformat/avformat.h>

 #include "coords.h"
-#include "options.h"
-#include "trait/packet_sink.h"
+#include "scrcpy.h"
 #include "util/queue.h"
 #include "util/thread.h"

-struct sc_record_packet {
-    AVPacket *packet;
-    struct sc_record_packet *next;
+struct record_packet {
+    AVPacket packet;
+    struct record_packet *next;
 };

-struct sc_recorder_queue SC_QUEUE(struct sc_record_packet);
-
-struct sc_recorder {
-    struct sc_packet_sink packet_sink; // packet sink trait
+struct recorder_queue QUEUE(struct record_packet);

+struct recorder {
    char *filename;
    enum sc_record_format format;
    AVFormatContext *ctx;
-    struct sc_size declared_frame_size;
+    struct size declared_frame_size;
    bool header_written;

    sc_thread thread;
    sc_mutex mutex;
    sc_cond queue_cond;
-    bool stopped; // set on recorder_close()
+    bool stopped; // set on recorder_stop() by the stream reader
    bool failed; // set on packet write failure
-    struct sc_recorder_queue queue;
+    struct recorder_queue queue;

    // we can write a packet only once we received the next one so that we can
    // set its duration (next_pts - current_pts)
    // "previous" is only accessed from the recorder thread, so it does not
    // need to be protected by the mutex
-    struct sc_record_packet *previous;
+    struct record_packet *previous;
 };

 bool
-sc_recorder_init(struct sc_recorder *recorder, const char *filename,
-                 enum sc_record_format format,
-                 struct sc_size declared_frame_size);
+recorder_init(struct recorder *recorder, const char *filename,
+              enum sc_record_format format, struct size declared_frame_size);

 void
-sc_recorder_destroy(struct sc_recorder *recorder);
+recorder_destroy(struct recorder *recorder);
+
+bool
+recorder_open(struct recorder *recorder, const AVCodec *input_codec);
+
+void
+recorder_close(struct recorder *recorder);
+
+bool
+recorder_start(struct recorder *recorder);
+
+void
+recorder_stop(struct recorder *recorder);
+
+void
+recorder_join(struct recorder *recorder);
+
+bool
+recorder_push(struct recorder *recorder, const AVPacket *packet);

 #endif
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -15,82 +15,79 @@

 #include "controller.h"
 #include "decoder.h"
-#include "demuxer.h"
+#include "device.h"
 #include "events.h"
-#include "file_pusher.h"
-#include "keyboard_inject.h"
-#include "mouse_inject.h"
+#include "file_handler.h"
+#include "fps_counter.h"
+#include "input_manager.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
-#ifdef HAVE_USB
-# include "usb/aoa_hid.h"
-# include "usb/hid_keyboard.h"
-# include "usb/hid_mouse.h"
-# include "usb/usb.h"
-#endif
-#include "util/acksync.h"
+#include "stream.h"
+#include "tiny_xpm.h"
+#include "video_buffer.h"
 #include "util/log.h"
 #include "util/net.h"
-#ifdef HAVE_V4L2
-# include "v4l2_sink.h"
-#endif

-struct scrcpy {
-    struct sc_server server;
-    struct sc_screen screen;
-    struct sc_demuxer demuxer;
-    struct sc_decoder decoder;
-    struct sc_recorder recorder;
-#ifdef HAVE_V4L2
-    struct sc_v4l2_sink v4l2_sink;
-#endif
-    struct sc_controller controller;
-    struct sc_file_pusher file_pusher;
-#ifdef HAVE_USB
-    struct sc_usb usb;
-    struct sc_aoa aoa;
-    // sequence/ack helper to synchronize clipboard and Ctrl+v via HID
-    struct sc_acksync acksync;
-#endif
-    union {
-        struct sc_keyboard_inject keyboard_inject;
-#ifdef HAVE_USB
-        struct sc_hid_keyboard keyboard_hid;
-#endif
-    };
-    union {
-        struct sc_mouse_inject mouse_inject;
-#ifdef HAVE_USB
-        struct sc_hid_mouse mouse_hid;
-#endif
-    };
+static struct server server;
+static struct screen screen = SCREEN_INITIALIZER;
+static struct fps_counter fps_counter;
+static struct video_buffer video_buffer;
+static struct stream stream;
+static struct decoder decoder;
+static struct recorder recorder;
+static struct controller controller;
+static struct file_handler file_handler;
+
+static struct input_manager input_manager = {
+    .controller = &controller,
+    .video_buffer = &video_buffer,
+    .screen = &screen,
+    .repeat = 0,
+
+    // initialized later
+    .prefer_text = false,
+    .sdl_shortcut_mods = {
+        .data = {0},
+        .count = 0,
+    },
 };

-static inline void
-push_event(uint32_t type, const char *name) {
-    SDL_Event event;
-    event.type = type;
-    int ret = SDL_PushEvent(&event);
-    if (ret < 0) {
-        LOGE("Could not post %s event: %s", name, SDL_GetError());
-        // What could we do?
-    }
-}
-#define PUSH_EVENT(TYPE) push_event(TYPE, # TYPE)
-
 #ifdef _WIN32
 BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
    if (ctrl_type == CTRL_C_EVENT) {
-        PUSH_EVENT(SDL_QUIT);
+        SDL_Event event;
+        event.type = SDL_QUIT;
+        SDL_PushEvent(&event);
        return TRUE;
    }
    return FALSE;
 }
 #endif // _WIN32

-static void
-sdl_set_hints(const char *render_driver) {
+// init SDL and set appropriate hints
+static bool
+sdl_init_and_configure(bool display, const char *render_driver,
+                       bool disable_screensaver) {
+    uint32_t flags = display ? SDL_INIT_VIDEO : SDL_INIT_EVENTS;
+    if (SDL_Init(flags)) {
+        LOGC("Could not initialize SDL: %s", SDL_GetError());
+        return false;
+    }
+
+    atexit(SDL_Quit);
+
+#ifdef _WIN32
+    // Clean up properly on Ctrl+C on Windows
+    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
+    if (!ok) {
+        LOGW("Could not set Ctrl+C handler");
+    }
+#endif // _WIN32
+
+    if (!display) {
+        return true;
+    }

    if (render_driver && !SDL_SetHint(SDL_HINT_RENDER_DRIVER, render_driver)) {
        LOGW("Could not set render driver");
@ -101,18 +98,11 @@ sdl_set_hints(const char *render_driver) {
        LOGW("Could not enable linear filtering");
    }

+#ifdef SCRCPY_SDL_HAS_HINT_MOUSE_FOCUS_CLICKTHROUGH
    // Handle a click to gain focus as any other click
    if (!SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1")) {
        LOGW("Could not enable mouse focus clickthrough");
    }
-
-#ifdef SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
-    // Disable synthetic mouse events from touch events
-    // Touch events with id SDL_TOUCH_MOUSEID are ignored anyway, but it is
-    // better not to generate them in the first place.
-    if (!SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0")) {
-        LOGW("Could not disable synthetic mouse events");
-    }
 #endif

 #ifdef SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
@ -126,71 +116,155 @@ sdl_set_hints(const char *render_driver) {
    if (!SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0")) {
        LOGW("Could not disable minimize on focus loss");
    }
-}
-
-static void
-sdl_configure(bool display, bool disable_screensaver) {
-#ifdef _WIN32
-    // Clean up properly on Ctrl+C on Windows
-    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
-    if (!ok) {
-        LOGW("Could not set Ctrl+C handler");
-    }
-#endif // _WIN32
-
-    if (!display) {
-        return;
-    }

    if (disable_screensaver) {
+        LOGD("Screensaver disabled");
        SDL_DisableScreenSaver();
    } else {
+        LOGD("Screensaver enabled");
        SDL_EnableScreenSaver();
    }
+
+    return true;
 }

-static enum scrcpy_exit_code
-event_loop(struct scrcpy *s) {
-    SDL_Event event;
-    while (SDL_WaitEvent(&event)) {
-        switch (event.type) {
-            case EVENT_STREAM_STOPPED:
-                LOGW("Device disconnected");
-                return SCRCPY_EXIT_DISCONNECTED;
-            case SDL_QUIT:
-                LOGD("User requested to quit");
-                return SCRCPY_EXIT_SUCCESS;
-            default:
-                sc_screen_handle_event(&s->screen, &event);
-                break;
-        }
+
+#if defined(__APPLE__) || defined(__WINDOWS__)
+# define CONTINUOUS_RESIZING_WORKAROUND
+#endif
+
+#ifdef CONTINUOUS_RESIZING_WORKAROUND
+// On Windows and MacOS, resizing blocks the event loop, so resizing events are
+// not triggered. As a workaround, handle them in an event handler.
+//
+// <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
+// <https://stackoverflow.com/a/40693139/1987178>
+static int
+event_watcher(void *data, SDL_Event *event) {
+    (void) data;
+    if (event->type == SDL_WINDOWEVENT
+            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
+        // In practice, it seems to always be called from the same thread in
+        // that specific case. Anyway, it's just a workaround.
+        screen_render(&screen, true);
    }
-    return SCRCPY_EXIT_FAILURE;
+    return 0;
 }
+#endif

-// Return true on success, false on error
 static bool
-await_for_server(bool *connected) {
+is_apk(const char *file) {
+    const char *ext = strrchr(file, '.');
+    return ext && !strcmp(ext, ".apk");
+}
+
+enum event_result {
+    EVENT_RESULT_CONTINUE,
+    EVENT_RESULT_STOPPED_BY_USER,
+    EVENT_RESULT_STOPPED_BY_EOS,
+};
+
+static enum event_result
+handle_event(SDL_Event *event, const struct scrcpy_options *options) {
+    switch (event->type) {
+        case EVENT_STREAM_STOPPED:
+            LOGD("Video stream stopped");
+            return EVENT_RESULT_STOPPED_BY_EOS;
+        case SDL_QUIT:
+            LOGD("User requested to quit");
+            return EVENT_RESULT_STOPPED_BY_USER;
+        case EVENT_NEW_FRAME:
+            if (!screen.has_frame) {
+                screen.has_frame = true;
+                // this is the very first frame, show the window
+                screen_show_window(&screen);
+            }
+            if (!screen_update_frame(&screen, &video_buffer)) {
+                return EVENT_RESULT_CONTINUE;
+            }
+            break;
+        case SDL_WINDOWEVENT:
+            screen_handle_window_event(&screen, &event->window);
+            break;
+        case SDL_TEXTINPUT:
+            if (!options->control) {
+                break;
+            }
+            input_manager_process_text_input(&input_manager, &event->text);
+            break;
+        case SDL_KEYDOWN:
+        case SDL_KEYUP:
+            // some key events do not interact with the device, so process the
+            // event even if control is disabled
+            input_manager_process_key(&input_manager, &event->key);
+            break;
+        case SDL_MOUSEMOTION:
+            if (!options->control) {
+                break;
+            }
+            input_manager_process_mouse_motion(&input_manager, &event->motion);
+            break;
+        case SDL_MOUSEWHEEL:
+            if (!options->control) {
+                break;
+            }
+            input_manager_process_mouse_wheel(&input_manager, &event->wheel);
+            break;
+        case SDL_MOUSEBUTTONDOWN:
+        case SDL_MOUSEBUTTONUP:
+            // some mouse events do not interact with the device, so process
+            // the event even if control is disabled
+            input_manager_process_mouse_button(&input_manager, &event->button);
+            break;
+        case SDL_FINGERMOTION:
+        case SDL_FINGERDOWN:
+        case SDL_FINGERUP:
+            input_manager_process_touch(&input_manager, &event->tfinger);
+            break;
+        case SDL_DROPFILE: {
+            if (!options->control) {
+                break;
+            }
+            char *file = strdup(event->drop.file);
+            SDL_free(event->drop.file);
+            if (!file) {
+                LOGW("Could not strdup drop filename\n");
+                break;
+            }
+
+            file_handler_action_t action;
+            if (is_apk(file)) {
+                action = ACTION_INSTALL_APK;
+            } else {
+                action = ACTION_PUSH_FILE;
+            }
+            file_handler_request(&file_handler, action, file);
+            break;
+        }
+    }
+    return EVENT_RESULT_CONTINUE;
+}
+
+static bool
+event_loop(const struct scrcpy_options *options) {
+#ifdef CONTINUOUS_RESIZING_WORKAROUND
+    if (options->display) {
+        SDL_AddEventWatch(event_watcher, NULL);
+    }
+#endif
    SDL_Event event;
    while (SDL_WaitEvent(&event)) {
-        switch (event.type) {
-            case SDL_QUIT:
-                LOGD("User requested to quit");
-                *connected = false;
+        enum event_result result = handle_event(&event, options);
+        switch (result) {
+            case EVENT_RESULT_STOPPED_BY_USER:
                return true;
-            case EVENT_SERVER_CONNECTION_FAILED:
-                LOGE("Server connection failed");
+            case EVENT_RESULT_STOPPED_BY_EOS:
+                LOGW("Device disconnected");
                return false;
-            case EVENT_SERVER_CONNECTED:
-                LOGD("Server connected");
-                *connected = true;
-                return true;
-            default:
+            case EVENT_RESULT_CONTINUE:
                break;
        }
    }
-
-    LOGE("SDL_WaitEvent() error: %s", SDL_GetError());
    return false;
 }

@ -218,95 +292,40 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
    if (priority == 0) {
        return;
    }
-
-    size_t fmt_len = strlen(fmt);
-    char *local_fmt = malloc(fmt_len + 10);
+    char *local_fmt = malloc(strlen(fmt) + 10);
    if (!local_fmt) {
-        LOG_OOM();
+        LOGC("Could not allocate string");
        return;
    }
-    memcpy(local_fmt, "[FFmpeg] ", 9); // do not write the final '\0'
-    memcpy(local_fmt + 9, fmt, fmt_len + 1); // include '\0'
+    // strcpy is safe here, the destination is large enough
+    strcpy(local_fmt, "[FFmpeg] ");
+    strcpy(local_fmt + 9, fmt);
    SDL_LogMessageV(SDL_LOG_CATEGORY_VIDEO, priority, local_fmt, vl);
    free(local_fmt);
 }

-static void
-sc_demuxer_on_eos(struct sc_demuxer *demuxer, void *userdata) {
-    (void) demuxer;
-    (void) userdata;
-
-    PUSH_EVENT(EVENT_STREAM_STOPPED);
-}
-
-static void
-sc_server_on_connection_failed(struct sc_server *server, void *userdata) {
-    (void) server;
-    (void) userdata;
-
-    PUSH_EVENT(EVENT_SERVER_CONNECTION_FAILED);
-}
-
-static void
-sc_server_on_connected(struct sc_server *server, void *userdata) {
-    (void) server;
-    (void) userdata;
-
-    PUSH_EVENT(EVENT_SERVER_CONNECTED);
-}
-
-static void
-sc_server_on_disconnected(struct sc_server *server, void *userdata) {
-    (void) server;
-    (void) userdata;
-
-    LOGD("Server disconnected");
-    // Do nothing, the disconnection will be handled by the "stream stopped"
-    // event
-}
-
-enum scrcpy_exit_code
-scrcpy(struct scrcpy_options *options) {
-    static struct scrcpy scrcpy;
-    struct scrcpy *s = &scrcpy;
-
-    // Minimal SDL initialization
-    if (SDL_Init(SDL_INIT_EVENTS)) {
-        LOGE("Could not initialize SDL: %s", SDL_GetError());
-        return SCRCPY_EXIT_FAILURE;
+bool
+scrcpy(const struct scrcpy_options *options) {
+    if (!server_init(&server)) {
+        return false;
    }

-    atexit(SDL_Quit);
-
-    enum scrcpy_exit_code ret = SCRCPY_EXIT_FAILURE;
+    bool ret = false;

    bool server_started = false;
-    bool file_pusher_initialized = false;
+    bool fps_counter_initialized = false;
+    bool video_buffer_initialized = false;
+    bool file_handler_initialized = false;
    bool recorder_initialized = false;
-#ifdef HAVE_V4L2
-    bool v4l2_sink_initialized = false;
-#endif
-    bool demuxer_started = false;
-#ifdef HAVE_USB
-    bool aoa_hid_initialized = false;
-    bool hid_keyboard_initialized = false;
-    bool hid_mouse_initialized = false;
-#endif
+    bool stream_started = false;
    bool controller_initialized = false;
    bool controller_started = false;
-    bool screen_initialized = false;

-    struct sc_acksync *acksync = NULL;
-
-    struct sc_server_params params = {
-        .req_serial = options->serial,
-        .select_usb = options->select_usb,
-        .select_tcpip = options->select_tcpip,
+    bool record = !!options->record_filename;
+    struct server_params params = {
        .log_level = options->log_level,
        .crop = options->crop,
        .port_range = options->port_range,
-        .tunnel_host = options->tunnel_host,
-        .tunnel_port = options->tunnel_port,
        .max_size = options->max_size,
        .bit_rate = options->bit_rate,
        .max_fps = options->max_fps,
@ -318,405 +337,179 @@ scrcpy(struct scrcpy_options *options) {
        .codec_options = options->codec_options,
        .encoder_name = options->encoder_name,
        .force_adb_forward = options->force_adb_forward,
-        .power_off_on_close = options->power_off_on_close,
-        .clipboard_autosync = options->clipboard_autosync,
-        .downsize_on_error = options->downsize_on_error,
-        .tcpip = options->tcpip,
-        .tcpip_dst = options->tcpip_dst,
-        .cleanup = options->cleanup,
-        .power_on = options->power_on,
    };
-
-    static const struct sc_server_callbacks cbs = {
-        .on_connection_failed = sc_server_on_connection_failed,
-        .on_connected = sc_server_on_connected,
-        .on_disconnected = sc_server_on_disconnected,
-    };
-    if (!sc_server_init(&s->server, &params, &cbs, NULL)) {
-        return SCRCPY_EXIT_FAILURE;
-    }
-
-    if (!sc_server_start(&s->server)) {
+    if (!server_start(&server, options->serial, &params)) {
        goto end;
    }

    server_started = true;

+    if (!sdl_init_and_configure(options->display, options->render_driver,
+                                options->disable_screensaver)) {
+        goto end;
+    }
+
+    if (!server_connect_to(&server)) {
+        goto end;
+    }
+
+    char device_name[DEVICE_NAME_FIELD_LENGTH];
+    struct size frame_size;
+
+    // screenrecord does not send frames when the screen content does not
+    // change therefore, we transmit the screen size before the video stream,
+    // to be able to init the window immediately
+    if (!device_read_info(server.video_socket, device_name, &frame_size)) {
+        goto end;
+    }
+
+    struct decoder *dec = NULL;
    if (options->display) {
-        sdl_set_hints(options->render_driver);
-    }
-
-    // Initialize SDL video in addition if display is enabled
-    if (options->display && SDL_Init(SDL_INIT_VIDEO)) {
-        LOGE("Could not initialize SDL: %s", SDL_GetError());
-        goto end;
-    }
-
-    sdl_configure(options->display, options->disable_screensaver);
-
-    // Await for server without blocking Ctrl+C handling
-    bool connected;
-    if (!await_for_server(&connected)) {
-        goto end;
-    }
-
-    if (!connected) {
-        // This is not an error, user requested to quit
-        ret = SCRCPY_EXIT_SUCCESS;
-        goto end;
-    }
-
-    // It is necessarily initialized here, since the device is connected
-    struct sc_server_info *info = &s->server.info;
-
-    const char *serial = s->server.serial;
-    assert(serial);
-
-    struct sc_file_pusher *fp = NULL;
-
-    if (options->display && options->control) {
-        if (!sc_file_pusher_init(&s->file_pusher, serial,
-                                 options->push_target)) {
+        if (!fps_counter_init(&fps_counter)) {
            goto end;
        }
-        fp = &s->file_pusher;
-        file_pusher_initialized = true;
-    }
+        fps_counter_initialized = true;

-    struct sc_decoder *dec = NULL;
-    bool needs_decoder = options->display;
-#ifdef HAVE_V4L2
-    needs_decoder |= !!options->v4l2_device;
-#endif
-    if (needs_decoder) {
-        sc_decoder_init(&s->decoder);
-        dec = &s->decoder;
-    }
-
-    struct sc_recorder *rec = NULL;
-    if (options->record_filename) {
-        if (!sc_recorder_init(&s->recorder,
-                              options->record_filename,
-                              options->record_format,
-                              info->frame_size)) {
+        if (!video_buffer_init(&video_buffer, &fps_counter,
+                               options->render_expired_frames)) {
            goto end;
        }
-        rec = &s->recorder;
+        video_buffer_initialized = true;
+
+        if (options->control) {
+            if (!file_handler_init(&file_handler, server.serial,
+                                   options->push_target)) {
+                goto end;
+            }
+            file_handler_initialized = true;
+        }
+
+        decoder_init(&decoder, &video_buffer);
+        dec = &decoder;
+    }
+
+    struct recorder *rec = NULL;
+    if (record) {
+        if (!recorder_init(&recorder,
+                           options->record_filename,
+                           options->record_format,
+                           frame_size)) {
+            goto end;
+        }
+        rec = &recorder;
        recorder_initialized = true;
    }

    av_log_set_callback(av_log_callback);

-    static const struct sc_demuxer_callbacks demuxer_cbs = {
-        .on_eos = sc_demuxer_on_eos,
-    };
-    sc_demuxer_init(&s->demuxer, s->server.video_socket, &demuxer_cbs, NULL);
+    stream_init(&stream, server.video_socket, dec, rec);

-    if (dec) {
-        sc_demuxer_add_sink(&s->demuxer, &dec->packet_sink);
+    // now we consumed the header values, the socket receives the video stream
+    // start the stream
+    if (!stream_start(&stream)) {
+        goto end;
    }
+    stream_started = true;

-    if (rec) {
-        sc_demuxer_add_sink(&s->demuxer, &rec->packet_sink);
-    }
-
-    struct sc_controller *controller = NULL;
-    struct sc_key_processor *kp = NULL;
-    struct sc_mouse_processor *mp = NULL;
-
-    if (options->control) {
-#ifdef HAVE_USB
-        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) {
+    if (options->display) {
+        if (options->control) {
+            if (!controller_init(&controller, server.control_socket)) {
                goto end;
            }
+            controller_initialized = true;

-            ok = sc_usb_init(&s->usb);
-            if (!ok) {
-                LOGE("Failed to initialize USB");
-                sc_acksync_destroy(&s->acksync);
-                goto aoa_hid_end;
+            if (!controller_start(&controller)) {
+                goto end;
            }
-
-            assert(serial);
-            struct sc_usb_device usb_device;
-            ok = sc_usb_select_device(&s->usb, serial, &usb_device);
-            if (!ok) {
-                sc_usb_destroy(&s->usb);
-                goto aoa_hid_end;
-            }
-
-            LOGI("USB device: %s (%04" PRIx16 ":%04" PRIx16 ") %s %s",
-                 usb_device.serial, usb_device.vid, usb_device.pid,
-                 usb_device.manufacturer, usb_device.product);
-
-            ok = sc_usb_connect(&s->usb, usb_device.device, NULL, NULL);
-            sc_usb_device_destroy(&usb_device);
-            if (!ok) {
-                LOGE("Failed to connect to USB device %s", serial);
-                sc_usb_destroy(&s->usb);
-                sc_acksync_destroy(&s->acksync);
-                goto aoa_hid_end;
-            }
-
-            ok = sc_aoa_init(&s->aoa, &s->usb, &s->acksync);
-            if (!ok) {
-                LOGE("Failed to enable HID over AOA");
-                sc_usb_disconnect(&s->usb);
-                sc_usb_destroy(&s->usb);
-                sc_acksync_destroy(&s->acksync);
-                goto aoa_hid_end;
-            }
-
-            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_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 = 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 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_HID);
-        assert(options->mouse_input_mode != SC_MOUSE_INPUT_MODE_HID);
-#endif
-
-        // keyboard_input_mode may have been reset if HID mode failed
-        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_INJECT) {
-            sc_keyboard_inject_init(&s->keyboard_inject, &s->controller,
-                                    options->key_inject_mode,
-                                    options->forward_key_repeat);
-            kp = &s->keyboard_inject.key_processor;
+            controller_started = true;
        }

-        // 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;
-        }
+        const char *window_title =
+            options->window_title ? options->window_title : device_name;

-        if (!sc_controller_init(&s->controller, s->server.control_socket,
-                                acksync)) {
+        if (!screen_init_rendering(&screen, window_title, frame_size,
+                                   options->always_on_top, options->window_x,
+                                   options->window_y, options->window_width,
+                                   options->window_height,
+                                   options->window_borderless,
+                                   options->rotation, options->mipmaps)) {
            goto end;
        }
-        controller_initialized = true;
-
-        if (!sc_controller_start(&s->controller)) {
-            goto end;
-        }
-        controller_started = true;
-        controller = &s->controller;

        if (options->turn_screen_off) {
-            struct sc_control_msg msg;
-            msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
-            msg.set_screen_power_mode.mode = SC_SCREEN_POWER_MODE_OFF;
+            struct control_msg msg;
+            msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
+            msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF;

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

-    }
-
-    // There is a controller if and only if control is enabled
-    assert(options->control == !!controller);
-
-    if (options->display) {
-        const char *window_title =
-            options->window_title ? options->window_title : info->device_name;
-
-        struct sc_screen_params screen_params = {
-            .controller = controller,
-            .fp = fp,
-            .kp = kp,
-            .mp = mp,
-            .forward_all_clicks = options->forward_all_clicks,
-            .legacy_paste = options->legacy_paste,
-            .clipboard_autosync = options->clipboard_autosync,
-            .shortcut_mods = &options->shortcut_mods,
-            .window_title = window_title,
-            .frame_size = info->frame_size,
-            .always_on_top = options->always_on_top,
-            .window_x = options->window_x,
-            .window_y = options->window_y,
-            .window_width = options->window_width,
-            .window_height = options->window_height,
-            .window_borderless = options->window_borderless,
-            .rotation = options->rotation,
-            .mipmaps = options->mipmaps,
-            .fullscreen = options->fullscreen,
-            .start_fps_counter = options->start_fps_counter,
-            .buffering_time = options->display_buffer,
-        };
-
-        if (!sc_screen_init(&s->screen, &screen_params)) {
-            goto end;
+        if (options->fullscreen) {
+            screen_switch_fullscreen(&screen);
        }
-        screen_initialized = true;
-
-        sc_decoder_add_sink(&s->decoder, &s->screen.frame_sink);
    }

-#ifdef HAVE_V4L2
-    if (options->v4l2_device) {
-        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device,
-                               info->frame_size, options->v4l2_buffer)) {
-            goto end;
-        }
+    input_manager_init(&input_manager, options);

-        sc_decoder_add_sink(&s->decoder, &s->v4l2_sink.frame_sink);
-
-        v4l2_sink_initialized = true;
-    }
-#endif
-
-    // now we consumed the header values, the socket receives the video stream
-    // start the demuxer
-    if (!sc_demuxer_start(&s->demuxer)) {
-        goto end;
-    }
-    demuxer_started = true;
-
-    ret = event_loop(s);
+    ret = event_loop(options);
    LOGD("quit...");

-    // Close the window immediately on closing, because screen_destroy() may
-    // only be called once the demuxer thread is joined (it may take time)
-    sc_screen_hide_window(&s->screen);
+    screen_destroy(&screen);

 end:
-    // The demuxer is not stopped explicitly, because it will stop by itself on
-    // end-of-stream
-#ifdef HAVE_USB
-    if (aoa_hid_initialized) {
-        if (hid_keyboard_initialized) {
-            sc_hid_keyboard_destroy(&s->keyboard_hid);
-        }
-        if (hid_mouse_initialized) {
-            sc_hid_mouse_destroy(&s->mouse_hid);
-        }
-        sc_aoa_stop(&s->aoa);
-        sc_usb_stop(&s->usb);
+    // stop stream and controller so that they don't continue once their socket
+    // is shutdown
+    if (stream_started) {
+        stream_stop(&stream);
    }
-    if (acksync) {
-        sc_acksync_destroy(acksync);
-    }
-#endif
    if (controller_started) {
-        sc_controller_stop(&s->controller);
+        controller_stop(&controller);
    }
-    if (file_pusher_initialized) {
-        sc_file_pusher_stop(&s->file_pusher);
+    if (file_handler_initialized) {
+        file_handler_stop(&file_handler);
    }
-    if (screen_initialized) {
-        sc_screen_interrupt(&s->screen);
+    if (fps_counter_initialized) {
+        fps_counter_interrupt(&fps_counter);
    }

    if (server_started) {
        // shutdown the sockets and kill the server
-        sc_server_stop(&s->server);
+        server_stop(&server);
    }

-    // now that the sockets are shutdown, the demuxer and controller are
+    // now that the sockets are shutdown, the stream and controller are
    // interrupted, we can join them
-    if (demuxer_started) {
-        sc_demuxer_join(&s->demuxer);
+    if (stream_started) {
+        stream_join(&stream);
    }
-
-#ifdef HAVE_V4L2
-    if (v4l2_sink_initialized) {
-        sc_v4l2_sink_destroy(&s->v4l2_sink);
-    }
-#endif
-
-#ifdef HAVE_USB
-    if (aoa_hid_initialized) {
-        sc_aoa_join(&s->aoa);
-        sc_aoa_destroy(&s->aoa);
-        sc_usb_join(&s->usb);
-        sc_usb_disconnect(&s->usb);
-        sc_usb_destroy(&s->usb);
-    }
-#endif
-
-    // Destroy the screen only after the demuxer is guaranteed to be finished,
-    // because otherwise the screen could receive new frames after destruction
-    if (screen_initialized) {
-        sc_screen_join(&s->screen);
-        sc_screen_destroy(&s->screen);
-    }
-
    if (controller_started) {
-        sc_controller_join(&s->controller);
+        controller_join(&controller);
    }
    if (controller_initialized) {
-        sc_controller_destroy(&s->controller);
+        controller_destroy(&controller);
    }

    if (recorder_initialized) {
-        sc_recorder_destroy(&s->recorder);
+        recorder_destroy(&recorder);
    }

-    if (file_pusher_initialized) {
-        sc_file_pusher_join(&s->file_pusher);
-        sc_file_pusher_destroy(&s->file_pusher);
+    if (file_handler_initialized) {
+        file_handler_join(&file_handler);
+        file_handler_destroy(&file_handler);
    }

-    sc_server_destroy(&s->server);
+    if (video_buffer_initialized) {
+        video_buffer_destroy(&video_buffer);
+    }
+
+    if (fps_counter_initialized) {
+        fps_counter_join(&fps_counter);
+        fps_counter_destroy(&fps_counter);
+    }
+
+    server_destroy(&server);

    return ret;
 }
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@ -4,20 +4,134 @@
 #include "common.h"

 #include <stdbool.h>
-#include "options.h"
+#include <stddef.h>
+#include <stdint.h>

-enum scrcpy_exit_code {
-    // Normal program termination
-    SCRCPY_EXIT_SUCCESS,
-
-    // No connection could be established
-    SCRCPY_EXIT_FAILURE,
-
-    // Device was disconnected while running
-    SCRCPY_EXIT_DISCONNECTED,
+enum sc_log_level {
+    SC_LOG_LEVEL_DEBUG,
+    SC_LOG_LEVEL_INFO,
+    SC_LOG_LEVEL_WARN,
+    SC_LOG_LEVEL_ERROR,
 };

-enum scrcpy_exit_code
-scrcpy(struct scrcpy_options *options);
+enum sc_record_format {
+    SC_RECORD_FORMAT_AUTO,
+    SC_RECORD_FORMAT_MP4,
+    SC_RECORD_FORMAT_MKV,
+};
+
+#define SC_MAX_SHORTCUT_MODS 8
+
+enum sc_shortcut_mod {
+    SC_MOD_LCTRL = 1 << 0,
+    SC_MOD_RCTRL = 1 << 1,
+    SC_MOD_LALT = 1 << 2,
+    SC_MOD_RALT = 1 << 3,
+    SC_MOD_LSUPER = 1 << 4,
+    SC_MOD_RSUPER = 1 << 5,
+};
+
+struct sc_shortcut_mods {
+    unsigned data[SC_MAX_SHORTCUT_MODS];
+    unsigned count;
+};
+
+struct sc_port_range {
+    uint16_t first;
+    uint16_t last;
+};
+
+#define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
+
+struct scrcpy_options {
+    const char *serial;
+    const char *crop;
+    const char *record_filename;
+    const char *window_title;
+    const char *push_target;
+    const char *render_driver;
+    const char *codec_options;
+    const char *encoder_name;
+    enum sc_log_level log_level;
+    enum sc_record_format record_format;
+    struct sc_port_range port_range;
+    struct sc_shortcut_mods shortcut_mods;
+    uint16_t max_size;
+    uint32_t bit_rate;
+    uint16_t max_fps;
+    int8_t lock_video_orientation;
+    uint8_t rotation;
+    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
+    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
+    uint16_t window_width;
+    uint16_t window_height;
+    uint32_t display_id;
+    bool show_touches;
+    bool fullscreen;
+    bool always_on_top;
+    bool control;
+    bool display;
+    bool turn_screen_off;
+    bool render_expired_frames;
+    bool prefer_text;
+    bool window_borderless;
+    bool mipmaps;
+    bool stay_awake;
+    bool force_adb_forward;
+    bool disable_screensaver;
+    bool forward_key_repeat;
+    bool forward_all_clicks;
+    bool legacy_paste;
+};
+
+#define SCRCPY_OPTIONS_DEFAULT { \
+    .serial = NULL, \
+    .crop = NULL, \
+    .record_filename = NULL, \
+    .window_title = NULL, \
+    .push_target = NULL, \
+    .render_driver = NULL, \
+    .codec_options = NULL, \
+    .encoder_name = NULL, \
+    .log_level = SC_LOG_LEVEL_INFO, \
+    .record_format = SC_RECORD_FORMAT_AUTO, \
+    .port_range = { \
+        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
+        .last = DEFAULT_LOCAL_PORT_RANGE_LAST, \
+    }, \
+    .shortcut_mods = { \
+        .data = {SC_MOD_LALT, SC_MOD_LSUPER}, \
+        .count = 2, \
+    }, \
+    .max_size = DEFAULT_MAX_SIZE, \
+    .bit_rate = DEFAULT_BIT_RATE, \
+    .max_fps = 0, \
+    .lock_video_orientation = DEFAULT_LOCK_VIDEO_ORIENTATION, \
+    .rotation = 0, \
+    .window_x = SC_WINDOW_POSITION_UNDEFINED, \
+    .window_y = SC_WINDOW_POSITION_UNDEFINED, \
+    .window_width = 0, \
+    .window_height = 0, \
+    .display_id = 0, \
+    .show_touches = false, \
+    .fullscreen = false, \
+    .always_on_top = false, \
+    .control = true, \
+    .display = true, \
+    .turn_screen_off = false, \
+    .render_expired_frames = false, \
+    .prefer_text = false, \
+    .window_borderless = false, \
+    .mipmaps = true, \
+    .stay_awake = false, \
+    .force_adb_forward = false, \
+    .disable_screensaver = false, \
+    .forward_key_repeat = true, \
+    .forward_all_clicks = false, \
+    .legacy_paste = false, \
+}
+
+bool
+scrcpy(const struct scrcpy_options *options);

 #endif
--- a/app/src/screen.c
+++ b/app/src/screen.c
--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -7,48 +7,24 @@
 #include <SDL2/SDL.h>
 #include <libavformat/avformat.h>

-#include "controller.h"
 #include "coords.h"
-#include "fps_counter.h"
-#include "input_manager.h"
 #include "opengl.h"
-#include "trait/key_processor.h"
-#include "trait/frame_sink.h"
-#include "trait/mouse_processor.h"
-#include "video_buffer.h"

-struct sc_screen {
-    struct sc_frame_sink frame_sink; // frame sink trait
-
-#ifndef NDEBUG
-    bool open; // track the open/close state to assert correct behavior
-#endif
-
-    struct sc_input_manager im;
-    struct sc_video_buffer vb;
-    struct sc_fps_counter fps_counter;
-
-    // The initial requested window properties
-    struct {
-        int16_t x;
-        int16_t y;
-        uint16_t width;
-        uint16_t height;
-        bool fullscreen;
-        bool start_fps_counter;
-    } req;
+struct video_buffer;

+struct screen {
    SDL_Window *window;
    SDL_Renderer *renderer;
    SDL_Texture *texture;
+    bool use_opengl;
    struct sc_opengl gl;
-    struct sc_size frame_size;
-    struct sc_size content_size; // rotated frame_size
+    struct size frame_size;
+    struct size content_size; // rotated frame_size

    bool resize_pending; // resize requested while fullscreen or maximized
    // The content size the last time the window was not maximized or
    // fullscreen (meaningful only when resize_pending is true)
-    struct sc_size windowed_content_size;
+    struct size windowed_content_size;

    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
    unsigned rotation;
@ -57,109 +33,112 @@ struct sc_screen {
    bool has_frame;
    bool fullscreen;
    bool maximized;
+    bool no_window;
    bool mipmaps;
-
-    bool event_failed; // in case SDL_PushEvent() returned an error
-
-    // To enable/disable mouse capture, a mouse capture key (LALT, LGUI or
-    // RGUI) must be pressed. This variable tracks the pressed capture key.
-    SDL_Keycode mouse_capture_key_pressed;
-
-    AVFrame *frame;
 };

-struct sc_screen_params {
-    struct sc_controller *controller;
-    struct sc_file_pusher *fp;
-    struct sc_key_processor *kp;
-    struct sc_mouse_processor *mp;
+#define SCREEN_INITIALIZER { \
+    .window = NULL, \
+    .renderer = NULL, \
+    .texture = NULL, \
+    .use_opengl = false, \
+    .gl = {0}, \
+    .frame_size = { \
+        .width = 0, \
+        .height = 0, \
+    }, \
+    .content_size = { \
+        .width = 0, \
+        .height = 0, \
+    }, \
+    .resize_pending = false, \
+    .windowed_content_size = { \
+        .width = 0, \
+        .height = 0, \
+    }, \
+    .rotation = 0, \
+    .rect = { \
+        .x = 0, \
+        .y = 0, \
+        .w = 0, \
+        .h = 0, \
+    }, \
+    .has_frame = false, \
+    .fullscreen = false, \
+    .maximized = false, \
+    .no_window = false, \
+    .mipmaps = false, \
+}

-    bool forward_all_clicks;
-    bool legacy_paste;
-    bool clipboard_autosync;
-    const struct sc_shortcut_mods *shortcut_mods;
-
-    const char *window_title;
-    struct sc_size frame_size;
-    bool always_on_top;
-
-    int16_t window_x; // accepts SC_WINDOW_POSITION_UNDEFINED
-    int16_t window_y; // accepts SC_WINDOW_POSITION_UNDEFINED
-    uint16_t window_width;
-    uint16_t window_height;
-
-    bool window_borderless;
-
-    uint8_t rotation;
-    bool mipmaps;
-
-    bool fullscreen;
-    bool start_fps_counter;
-
-    sc_tick buffering_time;
-};
+// initialize default values
+void
+screen_init(struct screen *screen);

 // initialize screen, create window, renderer and texture (window is hidden)
+// window_x and window_y accept SC_WINDOW_POSITION_UNDEFINED
 bool
-sc_screen_init(struct sc_screen *screen, const struct sc_screen_params *params);
+screen_init_rendering(struct screen *screen, const char *window_title,
+                      struct size frame_size, bool always_on_top,
+                      int16_t window_x, int16_t window_y, uint16_t window_width,
+                      uint16_t window_height, bool window_borderless,
+                      uint8_t rotation, bool mipmaps);

-// request to interrupt any inner thread
-// must be called before screen_join()
+// show the window
 void
-sc_screen_interrupt(struct sc_screen *screen);
-
-// join any inner thread
-void
-sc_screen_join(struct sc_screen *screen);
+screen_show_window(struct screen *screen);

 // destroy window, renderer and texture (if any)
 void
-sc_screen_destroy(struct sc_screen *screen);
+screen_destroy(struct screen *screen);

-// hide the window
+// resize if necessary and write the rendered frame into the texture
+bool
+screen_update_frame(struct screen *screen, struct video_buffer *vb);
+
+// render the texture to the renderer
 //
-// It is used to hide the window immediately on closing without waiting for
-// screen_destroy()
+// Set the update_content_rect flag if the window or content size may have
+// changed, so that the content rectangle is recomputed
 void
-sc_screen_hide_window(struct sc_screen *screen);
+screen_render(struct screen *screen, bool update_content_rect);

 // switch the fullscreen mode
 void
-sc_screen_switch_fullscreen(struct sc_screen *screen);
+screen_switch_fullscreen(struct screen *screen);

 // resize window to optimal size (remove black borders)
 void
-sc_screen_resize_to_fit(struct sc_screen *screen);
+screen_resize_to_fit(struct screen *screen);

 // resize window to 1:1 (pixel-perfect)
 void
-sc_screen_resize_to_pixel_perfect(struct sc_screen *screen);
+screen_resize_to_pixel_perfect(struct screen *screen);

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

-// react to SDL events
+// react to window events
 void
-sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event);
+screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);

 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels
-struct sc_point
-sc_screen_convert_window_to_frame_coords(struct sc_screen *screen,
-                                        int32_t x, int32_t y);
+struct point
+screen_convert_window_to_frame_coords(struct screen *screen,
+                                      int32_t x, int32_t y);

 // convert point from drawable coordinates to frame coordinates
 // x and y are expressed in pixels
-struct sc_point
-sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen,
-                                          int32_t x, int32_t y);
+struct point
+screen_convert_drawable_to_frame_coords(struct screen *screen,
+                                        int32_t x, int32_t y);

 // Convert coordinates from window to drawable.
 // Events are expressed in window coordinates, but content is expressed in
 // drawable coordinates. They are the same if HiDPI scaling is 1, but differ
 // otherwise.
 void
-sc_screen_hidpi_scale_coords(struct sc_screen *screen, int32_t *x, int32_t *y);
+screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y);

 #endif
--- a/app/src/server.c
+++ b/app/src/server.c
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Romain Vimont	5f2cf12acf	Add intermediate frame in video buffer There were only two frames simultaneously: - one used by the decoder; - one used by the renderer. When the decoder finished decoding a frame, it swapped it with the rendering frame. Adding a third frame provides several benefits: - the decoder do not have to wait for the renderer to release the mutex; - it simplifies the video_buffer API; - it makes the rendering frame valid until the next call to video_buffer_take_rendering_frame(), which will be useful for swscaling on window resize.	2021-02-04 08:12:22 +01:00
Romain Vimont	2a3c6b64dd	Assert non-recursive usage of mutexes	2021-02-04 08:12:22 +01:00
Romain Vimont	a9582b1d43	Add mutex assertions	2021-02-04 08:12:22 +01:00
Romain Vimont	fa3e84b700	Expose mutex assertions Add a function to assert that the mutex is held (or not).	2021-02-04 08:12:22 +01:00
Romain Vimont	1521de9051	Expose thread id	2021-02-04 08:12:22 +01:00
Romain Vimont	eabaabdb78	Wrap SDL thread functions into scrcpy-specific API The goal is to expose a consistent API for system tools, and paves the way to make the "core" independant of SDL in the future.	2021-02-04 08:12:22 +01:00
Romain Vimont	8b48003074	Replace SDL_strdup() by strdup() The functions SDL_malloc(), SDL_free() and SDL_strdup() were used only because strdup() was not available everywhere. Now that it is available, use the native version of these functions.	2021-02-04 08:12:22 +01:00
Romain Vimont	74bd25a0ed	Provide strdup() compat Make strdup() available on all platforms.	2021-02-04 08:12:22 +01:00