Apply workaround on "honor" devices

This makes audio work on those devices.

Fixes #4015 <https://github.com/Genymobile/scrcpy/issues/4015>

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

FAQ.ko.md

@@ -1,84 +0,0 @@
-# 자주하는 질문 (FAQ)
-
-다음은 자주 제보되는 문제들과 그들의 현황입니다.
-
-
-### Windows 운영체제에서, 디바이스가 발견되지 않습니다.
-
-가장 흔한 제보는 `adb`에 발견되지 않는 디바이스 혹은 권한 관련 문제입니다.
-다음 명령어를 호출하여 모든 것들에 이상이 없는지 확인하세요:
-
-    adb devices
-
-Windows는 당신의 디바이스를 감지하기 위해 [드라이버]가 필요할 수도 있습니다.
-
-[드라이버]: https://developer.android.com/studio/run/oem-usb.html
-
-
-### 내 디바이스의 미러링만 가능하고, 디바이스와 상호작용을 할 수 없습니다.
-
-일부 디바이스에서는, [simulating input]을 허용하기 위해서 한가지 옵션을 활성화해야 할 수도 있습니다.
-개발자 옵션에서 (developer options) 다음을 활성화 하세요:
-
-> **USB debugging (Security settings)**
-> _권한 부여와 USB 디버깅을 통한 simulating input을 허용한다_
-
-[simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-### 마우스 클릭이 다른 곳에 적용됩니다.
-
-Mac 운영체제에서, HiDPI support 와 여러 스크린 창이 있는 경우, 입력 위치가 잘못 파악될 수 있습니다.
-[issue 15]를 참고하세요.
-
-[issue 15]: https://github.com/Genymobile/scrcpy/issues/15
-
-차선책은 HiDPI support을 비활성화 하고 build하는 방법입니다:
-
-```bash
-meson x --buildtype release -Dhidpi_support=false
-```
-
-하지만, 동영상은 낮은 해상도로 재생될 것 입니다.
-
-
-### HiDPI display의 화질이 낮습니다.
-
-Windows에서는, [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
-
-
-### KWin compositor가 실행되지 않습니다
-
-Plasma Desktop에서는,_scrcpy_ 가 실행중에는 compositor가 비활성화 됩니다.
-
-차석책으로는, ["Block compositing"를 비활성화하세요][kwin].
-
-[kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
-
-
-###비디오 스트림을 열 수 없는 에러가 발생합니다.(Could not open video stream).
-
-여러가지 원인이 있을 수 있습니다. 가장 흔한 원인은 디바이스의 하드웨어 인코더(hardware encoder)가
-주어진 해상도를 인코딩할 수 없는 경우입니다.
-
-```
-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
-```
-
-더 낮은 해상도로 시도 해보세요:
-
-```
-scrcpy -m 1920
-scrcpy -m 1024
-scrcpy -m 800
-```

FAQ.md

@@ -4,23 +4,16 @@
 
 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
+
+## `adb` and USB 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
 
@@ -30,38 +23,63 @@ 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 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
+>     ERROR: Could not find any ADB device
 
 Check that you correctly enabled [adb debugging][enable-adb].
 
-If your device is not detected, you may need some [drivers] (on Windows).
+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].
+
+[device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
 
 
 ### Several devices connected
 
 If several devices are connected, you will encounter this error:
 
->     adb: error: failed to get feature set: more than one device/emulator
+>     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)
 
-the identifier of the device you want to mirror must be provided:
+In that case, you can either provide the identifier of the device you want to
+mirror:
 
 ```bash
-scrcpy -s 01234567890abcdef
+scrcpy -s 0123456789abcdef
 ```
 
-Note that if your device is connected over TCP/IP, you'll get this message:
+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:
 
 >     adb: error: more than one device/emulator
 >     ERROR: "adb reverse" returned with value 1
@@ -85,7 +103,20 @@ You could overwrite the `adb` binary in the other program, or ask _scrcpy_ to
 use a specific `adb` binary, by setting the `ADB` environment variable:
 
 ```bash
-set ADB=/path/to/your/adb
+# in bash
+export ADB=/path/to/your/adb
+scrcpy
+```
+
+```cmd
+:: in cmd
+set ADB=C:\path\to\your\adb.exe
+scrcpy
+```
+
+```powershell
+# in PowerShell
+$env:ADB = 'C:\path\to\your\adb.exe'
 scrcpy
 ```
 
@@ -102,6 +133,21 @@ Try with another USB cable or plug it into another USB port. See [#281] and
 [#283]: https://github.com/Genymobile/scrcpy/issues/283
 
 
+## HID/OTG issues on Windows
+
+On Windows, if `scrcpy --otg` (or `--hid-keyboard`/`--hid-mouse`) results in:
+
+>     ERROR: Could not find any USB device
+
+(or if only unrelated USB devices are detected), there might be drivers issues.
+
+Please read [#3654], in particular [this comment][#3654-comment1] and [the next
+one][#3654-comment2].
+
+[#3654]: https://github.com/Genymobile/scrcpy/issues/3654
+[#3654-comment1]: https://github.com/Genymobile/scrcpy/issues/3654#issuecomment-1369278232
+[#3654-comment2]: https://github.com/Genymobile/scrcpy/issues/3654#issuecomment-1369295011
+
 
 ## Control issues
 
@@ -122,8 +168,7 @@ 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).
+Since scrcpy v1.20, it is possible to simulate a [physical keyboard][hid] (HID).
 
 [text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
 [accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
@@ -133,30 +178,6 @@ keyboard][hid] (HID).
 
 ## Client issues
 
-### The quality is low
-
-If the definition of your client window is smaller than that of your device
-screen, then you might get poor quality, especially visible on text (see [#40]).
-
-[#40]: https://github.com/Genymobile/scrcpy/issues/40
-
-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:
-
-```
-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
-
-
 ### Issue with Wayland
 
 By default, SDL uses x11 on Linux. The [video driver] can be changed via the
@@ -191,98 +212,21 @@ As a workaround, [disable "Block compositing"][kwin].
 
 ### Exception
 
-There may be many reasons. One common cause is that the hardware encoder of your
-device is not able to encode at the given definition:
-
-> ```
-> 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
-> ```
-
-or
-
-> ```
-> ERROR: Exception on thread Thread[main,5,main]
-> java.lang.IllegalStateException
->         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
-> ```
-
-Just try with a lower definition:
+If you get any exception related to `MediaCodec`:
 
 ```
-scrcpy -m 1920
-scrcpy -m 1024
-scrcpy -m 800
+ERROR: Exception on thread Thread[main,5,main]
+java.lang.IllegalStateException
+        at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
 ```
 
-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
-
-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.
- 3. Go to your _scrcpy_ directory, by typing (adapt the path):
-
-    ```bat
-    cd C:\Users\user\Downloads\scrcpy-win64-xxx
-    ```
-
-    and press <kbd>Enter</kbd>
- 4. Type your command. For example:
-
-    ```bat
-    scrcpy --record file.mkv
-    ```
-
-If you plan to always use the same arguments, create a file `myscrcpy.bat`
-(enable [show file extensions] to avoid confusion) in the `scrcpy` directory,
-containing your command. For example:
-
-```bat
-scrcpy --prefer-text --turn-screen-off --stay-awake
-```
-
-Then just double-click on that file.
-
-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/
+then try with another [encoder](doc/video.md#codec).
 
 
 ## Translations
 
-This FAQ is available in other languages:
+Translations of this FAQ in other languages are available in the [wiki].
 
- - [Italiano (Italiano, `it`) - v1.19](FAQ.it.md)
- - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md)
- - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.18](FAQ.zh-Hans.md)
+[wiki]: https://github.com/Genymobile/scrcpy/wiki
+
+Only this README file is guaranteed to be up-to-date.

FAQ.zh-Hans.md

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

LICENSE

@@ -188,7 +188,7 @@
       identification within third-party archives.
 
    Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2021 Romain Vimont
+   Copyright (C) 2018-2023 Romain Vimont
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.id.md

@@ -1,696 +0,0 @@
-_Only the original [README](README.md) is guaranteed to be up-to-date._
-
-# scrcpy (v1.16)
-
-Aplikasi ini menyediakan tampilan dan kontrol perangkat Android yang terhubung pada USB (atau [melalui TCP/IP][article-tcpip]). Ini tidak membutuhkan akses _root_ apa pun. Ini bekerja pada _GNU/Linux_, _Windows_ and _macOS_.
-
-![screenshot](assets/screenshot-debian-600.jpg)
-
-Ini berfokus pada:
-
-  - **keringanan** (asli, hanya menampilkan layar perangkat)
-  - **kinerja** (30~60fps)
-  - **kualitas** (1920×1080 atau lebih)
-  - **latensi** rendah ([35~70ms][lowlatency])
-  - **waktu startup rendah** (~1 detik untuk menampilkan gambar pertama)
-  - **tidak mengganggu** (tidak ada yang terpasang di perangkat)
-
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-
-## Persyaratan
-Perangkat Android membutuhkan setidaknya API 21 (Android 5.0).
-
-Pastikan Anda [mengaktifkan debugging adb][enable-adb] pada perangkat Anda.
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-Di beberapa perangkat, Anda juga perlu mengaktifkan [opsi tambahan][control] untuk mengontrolnya menggunakan keyboard dan mouse.
-
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-## Dapatkan aplikasinya
-
-### Linux
-
-Di Debian (_testing_ dan _sid_ untuk saat ini) dan Ubuntu (20.04):
-
-```
-apt install scrcpy
-```
-
-Paket [Snap] tersedia: [`scrcpy`][snap-link].
-
-[snap-link]: https://snapstats.org/snaps/scrcpy
-
-[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
-
-Untuk Fedora, paket [COPR] tersedia: [`scrcpy`][copr-link].
-
-[COPR]: https://fedoraproject.org/wiki/Category:Copr
-[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
-
-Untuk Arch Linux, paket [AUR] tersedia: [`scrcpy`][aur-link].
-
-[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
-
-Untuk Gentoo, tersedia [Ebuild]: [`scrcpy/`][ebuild-link].
-
-[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
-[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-
-Anda juga bisa [membangun aplikasi secara manual][BUILD] (jangan khawatir, tidak terlalu sulit).
-
-
-### Windows
-
-Untuk Windows, untuk kesederhanaan, arsip prebuilt dengan semua dependensi (termasuk `adb`) tersedia :
-
- - [README](README.md#windows)
-
-Ini juga tersedia di [Chocolatey]:
-
-[Chocolatey]: https://chocolatey.org/
-
-```bash
-choco install scrcpy
-choco install adb    # jika Anda belum memilikinya
-```
-
-Dan di [Scoop]:
-
-```bash
-scoop install scrcpy
-scoop install adb    # jika Anda belum memilikinya
-```
-
-[Scoop]: https://scoop.sh
-
-Anda juga dapat [membangun aplikasi secara manual][BUILD].
-
-
-### macOS
-
-Aplikasi ini tersedia di [Homebrew]. Instal saja:
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-Anda membutuhkan `adb`, dapat diakses dari `PATH` Anda. Jika Anda belum memilikinya:
-
-```bash
-brew cask install android-platform-tools
-```
-
-Anda juga dapat [membangun aplikasi secara manual][BUILD].
-
-
-## Menjalankan
-
-Pasang perangkat Android, dan jalankan:
-
-```bash
-scrcpy
-```
-
-Ini menerima argumen baris perintah, didaftarkan oleh:
-
-```bash
-scrcpy --help
-```
-
-## Fitur
-
-### Menangkap konfigurasi
-
-#### Mengurangi ukuran
-
-Kadang-kadang, berguna untuk mencerminkan perangkat Android dengan definisi yang lebih rendah untuk meningkatkan kinerja.
-
-Untuk membatasi lebar dan tinggi ke beberapa nilai (mis. 1024):
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # versi pendek
-```
-
-Dimensi lain dihitung agar rasio aspek perangkat dipertahankan.
-Dengan begitu, perangkat 1920×1080 akan dicerminkan pada 1024×576.
-
-#### Ubah kecepatan bit
-
-Kecepatan bit default adalah 8 Mbps. Untuk mengubah bitrate video (mis. Menjadi 2 Mbps):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # versi pendek
-```
-
-#### Batasi frekuensi gambar
-
-Kecepatan bingkai pengambilan dapat dibatasi:
-
-```bash
-scrcpy --max-fps 15
-```
-
-Ini secara resmi didukung sejak Android 10, tetapi dapat berfungsi pada versi sebelumnya.
-
-#### Memotong
-
-Layar perangkat dapat dipotong untuk mencerminkan hanya sebagian dari layar.
-
-Ini berguna misalnya untuk mencerminkan hanya satu mata dari Oculus Go:
-
-```bash
-scrcpy --crop 1224:1440:0:0   # 1224x1440 Mengimbangi (0,0)
-```
-
-Jika `--max-size` juga ditentukan, pengubahan ukuran diterapkan setelah pemotongan.
-
-
-#### Kunci orientasi video
-
-Untuk mengunci orientasi pencerminan:
-
-```bash
-scrcpy --lock-video-orientation 0   # orientasi alami
-scrcpy --lock-video-orientation 1   # 90° berlawanan arah jarum jam
-scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation 3   # 90° searah jarum jam
-```
-
-Ini mempengaruhi orientasi perekaman.
-
-
-### Rekaman
-
-Anda dapat merekam layar saat melakukan mirroring:
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-Untuk menonaktifkan pencerminan saat merekam:
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# berhenti merekam dengan Ctrl+C
-```
-
-"Skipped frames" are recorded, even if they are not displayed in real time (for
-performance reasons). Frames are _timestamped_ on the device, so [packet delay
-variation] does not impact the recorded file.
-
-"Frame yang dilewati" direkam, meskipun tidak ditampilkan secara real time (untuk alasan performa). Bingkai *diberi stempel waktu* pada perangkat, jadi [variasi penundaan paket] tidak memengaruhi file yang direkam.
-
-[variasi penundaan paket]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-
-### Koneksi
-
-#### Wireless
-
-_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).
-3. Aktifkan adb melalui TCP / IP pada perangkat Anda: `adb tcpip 5555`.
-4. Cabut perangkat Anda.
-5. Hubungkan ke perangkat Anda: `adb connect DEVICE_IP: 5555` (*ganti* *`DEVICE_IP`*).
-6. Jalankan `scrcpy` seperti biasa.
-
-Mungkin berguna untuk menurunkan kecepatan bit dan definisi:
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # versi pendek
-```
-
-[terhubung]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-#### Multi-perangkat
-
-Jika beberapa perangkat dicantumkan di `adb devices`, Anda harus menentukan _serial_:
-
-```bash
-scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # versi pendek
-```
-
-If the device is connected over TCP/IP:
-
-```bash
-scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # versi pendek
-```
-
-Anda dapat memulai beberapa contoh _scrcpy_ untuk beberapa perangkat.
-
-#### Mulai otomatis pada koneksi perangkat
-
-Anda bisa menggunakan [AutoAdb]:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
-
-#### Koneksi via SSH tunnel
-
-Untuk menyambung ke perangkat jarak jauh, dimungkinkan untuk menghubungkan klien `adb` lokal ke server `adb` jarak jauh (asalkan mereka menggunakan versi yang sama dari _adb_ protocol):
-
-```bash
-adb kill-server    # matikan server adb lokal di 5037
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 komputer_jarak_jauh_anda
-# jaga agar tetap terbuka
-```
-
-Dari terminal lain:
-
-```bash
-scrcpy
-```
-
-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
-ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 komputer_jarak_jauh_anda
-# jaga agar tetap terbuka
-```
-
-Dari terminal lain:
-
-```bash
-scrcpy --force-adb-forward
-```
-
-Seperti koneksi nirkabel, mungkin berguna untuk mengurangi kualitas:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-### Konfigurasi Jendela
-
-#### Judul
-
-Secara default, judul jendela adalah model perangkat. Itu bisa diubah:
-
-```bash
-scrcpy --window-title 'Perangkat Saya'
-```
-
-#### Posisi dan ukuran
-
-Posisi dan ukuran jendela awal dapat ditentukan:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-#### Jendela tanpa batas
-
-Untuk menonaktifkan dekorasi jendela:
-
-```bash
-scrcpy --window-borderless
-```
-
-#### Selalu di atas
-
-Untuk menjaga jendela scrcpy selalu di atas:
-
-```bash
-scrcpy --always-on-top
-```
-
-#### Layar penuh
-
-Aplikasi dapat dimulai langsung dalam layar penuh::
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # versi pendek
-```
-
-Layar penuh kemudian dapat diubah secara dinamis dengan <kbd>MOD</kbd>+<kbd>f</kbd>.
-
-#### Rotasi
-
-Jendela mungkin diputar:
-
-```bash
-scrcpy --rotation 1
-```
-
-Nilai yang mungkin adalah:
- - `0`: tidak ada rotasi
- - `1`: 90 derajat berlawanan arah jarum jam
- - `2`: 180 derajat
- - `3`: 90 derajat searah jarum jam
-
-Rotasi juga dapat diubah secara dinamis dengan <kbd>MOD</kbd>+<kbd>←</kbd>
-_(kiri)_ and <kbd>MOD</kbd>+<kbd>→</kbd> _(kanan)_.
-
-Perhatikan bahwa _scrcpy_ mengelola 3 rotasi berbeda::
- - <kbd>MOD</kbd>+<kbd>r</kbd> meminta perangkat untuk beralih antara potret dan lanskap (aplikasi yang berjalan saat ini mungkin menolak, jika mendukung orientasi yang diminta).
- - `--lock-video-orientation` mengubah orientasi pencerminan (orientasi video yang dikirim dari perangkat ke komputer). Ini mempengaruhi rekaman.
- - `--rotation` (atau <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
-   memutar hanya konten jendela. Ini hanya mempengaruhi tampilan, bukan rekaman.
-
-
-### Opsi pencerminan lainnya
-
-#### Hanya-baca
-
-Untuk menonaktifkan kontrol (semua yang dapat berinteraksi dengan perangkat: tombol input, peristiwa mouse, seret & lepas file):
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-#### Layar
-
-Jika beberapa tampilan tersedia, Anda dapat memilih tampilan untuk cermin:
-
-```bash
-scrcpy --display 1
-```
-
-Daftar id tampilan dapat diambil dengan::
-
-```
-adb shell dumpsys display   # cari "mDisplayId=" di keluaran
-```
-
-Tampilan sekunder hanya dapat dikontrol jika perangkat menjalankan setidaknya Android 10 (jika tidak maka akan dicerminkan dalam hanya-baca).
-
-
-#### Tetap terjaga
-
-Untuk mencegah perangkat tidur setelah beberapa penundaan saat perangkat dicolokkan:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w
-```
-
-Keadaan awal dipulihkan ketika scrcpy ditutup.
-
-
-#### Matikan layar
-
-Dimungkinkan untuk mematikan layar perangkat saat pencerminan mulai dengan opsi baris perintah:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-Atau dengan menekan <kbd>MOD</kbd>+<kbd>o</kbd> kapan saja.
-
-Untuk menyalakannya kembali, tekan <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
-
-Di Android, tombol `POWER` selalu menyalakan layar. Untuk kenyamanan, jika `POWER` dikirim melalui scrcpy (melalui klik kanan atau<kbd>MOD</kbd>+<kbd>p</kbd>), itu akan memaksa untuk mematikan layar setelah penundaan kecil (atas dasar upaya terbaik).
-Tombol fisik `POWER` masih akan menyebabkan layar dihidupkan.
-
-Ini juga berguna untuk mencegah perangkat tidur:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw
-```
-
-#### Render frame kedaluwarsa
-
-Secara default, untuk meminimalkan latensi, _scrcpy_ selalu menampilkan frame yang terakhir didekodekan tersedia, dan menghapus frame sebelumnya.
-
-Untuk memaksa rendering semua frame (dengan kemungkinan peningkatan latensi), gunakan:
-
-```bash
-scrcpy --render-expired-frames
-```
-
-#### Tunjukkan sentuhan
-
-Untuk presentasi, mungkin berguna untuk menunjukkan sentuhan fisik (pada perangkat fisik).
-
-Android menyediakan fitur ini di _Opsi Pengembang_.
-
-_Scrcpy_ menyediakan opsi untuk mengaktifkan fitur ini saat mulai dan mengembalikan nilai awal saat keluar:
-
-```bash
-scrcpy --show-touches
-scrcpy -t
-```
-
-Perhatikan bahwa ini hanya menunjukkan sentuhan _fisik_ (dengan jari di perangkat).
-
-
-#### Nonaktifkan screensaver
-
-Secara default, scrcpy tidak mencegah screensaver berjalan di komputer.
-
-Untuk menonaktifkannya:
-
-```bash
-scrcpy --disable-screensaver
-```
-
-
-### Kontrol masukan
-
-#### Putar layar perangkat
-
-Tekan <kbd>MOD</kbd>+<kbd>r</kbd> untuk beralih antara mode potret dan lanskap.
-
-Perhatikan bahwa itu berputar hanya jika aplikasi di latar depan mendukung orientasi yang diminta.
-
-#### Salin-tempel
-
-Setiap kali papan klip Android berubah, secara otomatis disinkronkan ke papan klip komputer.
-
-Apa saja <kbd>Ctrl</kbd> pintasan diteruskan ke perangkat. Khususnya:
- - <kbd>Ctrl</kbd>+<kbd>c</kbd> biasanya salinan
- - <kbd>Ctrl</kbd>+<kbd>x</kbd> biasanya memotong
- - <kbd>Ctrl</kbd>+<kbd>v</kbd> biasanya menempel (setelah sinkronisasi papan klip komputer-ke-perangkat)
-
-Ini biasanya berfungsi seperti yang Anda harapkan.
-
-Perilaku sebenarnya tergantung pada aplikasi yang aktif. Sebagai contoh,
-_Termux_ mengirim SIGINT ke <kbd>Ctrl</kbd>+<kbd>c</kbd> sebagai gantinya, dan _K-9 Mail_ membuat pesan baru.
-
-Untuk menyalin, memotong dan menempel dalam kasus seperti itu (tetapi hanya didukung di Android> = 7):
- - <kbd>MOD</kbd>+<kbd>c</kbd> injeksi `COPY` _(salin)_
- - <kbd>MOD</kbd>+<kbd>x</kbd> injeksi `CUT` _(potong)_
- - <kbd>MOD</kbd>+<kbd>v</kbd> injeksi `PASTE` (setelah sinkronisasi papan klip komputer-ke-perangkat)
-
-Tambahan, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> memungkinkan untuk memasukkan teks papan klip komputer sebagai urutan peristiwa penting. Ini berguna ketika komponen tidak menerima penempelan teks (misalnya di _Termux_), tetapi dapat merusak konten non-ASCII.
-
-**PERINGATAN:** Menempelkan papan klip komputer ke perangkat (baik melalui
-<kbd>Ctrl</kbd>+<kbd>v</kbd> or <kbd>MOD</kbd>+<kbd>v</kbd>) menyalin konten ke clipboard perangkat. Akibatnya, aplikasi Android apa pun dapat membaca kontennya. Anda harus menghindari menempelkan konten sensitif (seperti kata sandi) seperti itu.
-
-
-#### Cubit untuk memperbesar/memperkecil
-
-Untuk mensimulasikan "cubit-untuk-memperbesar/memperkecil": <kbd>Ctrl</kbd>+_klik-dan-pindah_.
-
-Lebih tepatnya, tahan <kbd>Ctrl</kbd> sambil menekan tombol klik kiri. Hingga tombol klik kiri dilepaskan, semua gerakan mouse berskala dan memutar konten (jika didukung oleh aplikasi) relatif ke tengah layar.
-
-Secara konkret, scrcpy menghasilkan kejadian sentuh tambahan dari "jari virtual" di lokasi yang dibalik melalui bagian tengah layar.
-
-
-#### Preferensi injeksi teks
-
-Ada dua jenis [peristiwa][textevents] dihasilkan saat mengetik teks:
-- _peristiwa penting_, menandakan bahwa tombol ditekan atau dilepaskan;
-- _peristiwa teks_, menandakan bahwa teks telah dimasukkan.
-
-Secara default, huruf dimasukkan menggunakan peristiwa kunci, sehingga keyboard berperilaku seperti yang diharapkan dalam game (biasanya untuk tombol WASD).
-
-Tapi ini mungkin [menyebabkan masalah][prefertext]. Jika Anda mengalami masalah seperti itu, Anda dapat menghindarinya dengan:
-
-```bash
-scrcpy --prefer-text
-```
-
-(tapi ini akan merusak perilaku keyboard dalam game)
-
-[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
-[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-
-
-#### Ulangi kunci
-
-Secara default, menahan tombol akan menghasilkan peristiwa kunci yang berulang. Ini dapat menyebabkan masalah kinerja di beberapa game, di mana acara ini tidak berguna.
-
-Untuk menghindari penerusan peristiwa penting yang berulang:
-
-```bash
-scrcpy --no-key-repeat
-```
-
-
-### Seret/jatuhkan file
-
-#### Pasang APK
-
-Untuk menginstal APK, seret & lepas file APK (diakhiri dengan `.apk`) ke jendela _scrcpy_.
-
-Tidak ada umpan balik visual, log dicetak ke konsol.
-
-
-#### Dorong file ke perangkat
-
-Untuk mendorong file ke `/sdcard/` di perangkat, seret & jatuhkan file (non-APK) ke jendela _scrcpy_.
-
-Tidak ada umpan balik visual, log dicetak ke konsol.
-
-Direktori target dapat diubah saat mulai:
-
-```bash
-scrcpy --push-target /sdcard/foo/bar/
-```
-
-
-### Penerusan audio
-
-Audio tidak diteruskan oleh _scrcpy_. Gunakan [sndcpy].
-
-Lihat juga [Masalah #14].
-
-[sndcpy]: https://github.com/rom1v/sndcpy
-[Masalah #14]: https://github.com/Genymobile/scrcpy/issues/14
-
-
-## Pintasan
-
-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:
-
-```bash
-# gunakan RCtrl untuk jalan pintas
-scrcpy --shortcut-mod=rctrl
-
-# gunakan baik LCtrl+LAlt atau LSuper untuk jalan pintas
-scrcpy --shortcut-mod=lctrl+lalt,lsuper
-```
-
-_<kbd>[Super]</kbd> biasanya adalah <kbd>Windows</kbd> atau <kbd>Cmd</kbd> key._
-
-[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
-
- | Aksi                                                  |   Pintasan
- | ------------------------------------------------------|:-----------------------------
- | Alihkan mode layar penuh                              | <kbd>MOD</kbd>+<kbd>f</kbd>
- | Putar layar kiri                                      | <kbd>MOD</kbd>+<kbd>←</kbd> _(kiri)_
- | Putar layar kanan                                     | <kbd>MOD</kbd>+<kbd>→</kbd> _(kanan)_
- | Ubah ukuran jendela menjadi 1:1 (piksel-sempurna)     | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Ubah ukuran jendela menjadi hapus batas hitam         | <kbd>MOD</kbd>+<kbd>w</kbd> \| _klik-dua-kali¹_
- | Klik `HOME`                                           | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Klik-tengah_
- | Klik `BACK`                                           | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Klik-kanan²_
- | Klik `APP_SWITCH`                                     | <kbd>MOD</kbd>+<kbd>s</kbd>
- | Klik `MENU` (buka kunci layar)                        | <kbd>MOD</kbd>+<kbd>m</kbd>
- | Klik `VOLUME_UP`                                      | <kbd>MOD</kbd>+<kbd>↑</kbd> _(naik)_
- | Klik `VOLUME_DOWN`                                    | <kbd>MOD</kbd>+<kbd>↓</kbd> _(turun)_
- | Klik `POWER`                                          | <kbd>MOD</kbd>+<kbd>p</kbd>
- | Menyalakan                                            | _Klik-kanan²_
- | Matikan layar perangkat (tetap mirroring)             | <kbd>MOD</kbd>+<kbd>o</kbd>
- | Hidupkan layar perangkat                              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
- | Putar layar perangkat                                 | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Luaskan panel notifikasi                              | <kbd>MOD</kbd>+<kbd>n</kbd>
- | Ciutkan panel notifikasi                              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Menyalin ke papan klip³                               | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Potong ke papan klip³                                 | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Sinkronkan papan klip dan tempel³                     | <kbd>MOD</kbd>+<kbd>v</kbd>
- | Masukkan teks papan klip komputer                     | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
- | Mengaktifkan/menonaktifkan penghitung FPS (di stdout) | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Cubit-untuk-memperbesar/memperkecil                   | <kbd>Ctrl</kbd>+_klik-dan-pindah_
-
-_¹Klik-dua-kali pada batas hitam untuk menghapusnya._  
-_²Klik-kanan akan menghidupkan layar jika mati, tekan BACK jika tidak._  
-_³Hanya di Android >= 7._
-
-Semua <kbd>Ctrl</kbd>+_key_ pintasan diteruskan ke perangkat, demikian adanya
-ditangani oleh aplikasi aktif.
-
-
-## Jalur kustom
-
-Untuk menggunakan biner _adb_ tertentu, konfigurasikan jalurnya di variabel lingkungan `ADB`:
-
-    ADB=/path/to/adb scrcpy
-
-Untuk mengganti jalur file `scrcpy-server`, konfigurasikan jalurnya di
-`SCRCPY_SERVER_PATH`.
-
-[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
-
-
-## Mengapa _scrcpy_?
-
-Seorang kolega menantang saya untuk menemukan nama yang tidak dapat diucapkan seperti [gnirehtet].
-
-[`strcpy`] menyalin sebuah **str**ing; `scrcpy` menyalin sebuah **scr**een.
-
-[gnirehtet]: https://github.com/Genymobile/gnirehtet
-[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
-
-
-## Bagaimana Cara membangun?
-
-Lihat [BUILD].
-
-[BUILD]: BUILD.md
-
-
-## Masalah umum
-
-Lihat [FAQ](FAQ.md).
-
-
-## Pengembang
-
-Baca [halaman pengembang].
-
-[halaman pengembang]: DEVELOP.md
-
-
-## Lisensi
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2021 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## Artikel
-
-- [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/
-

README.it.md

@@ -1,813 +0,0 @@
-_Apri il [README](README.md) originale e sempre aggiornato._
-
-# scrcpy (v1.19)
-
-Questa applicazione fornisce la visualizzazione e il controllo dei dispositivi Android collegati via USB (o [via TCP/IP][article-tcpip]). Non richiede alcun accesso _root_.
-Funziona su _GNU/Linux_, _Windows_ e _macOS_.
-
-![screenshot](assets/screenshot-debian-600.jpg)
-
-Si concentra su:
-
- - **leggerezza** (nativo, mostra solo lo schermo del dispositivo)
- - **prestazioni** (30~60fps)
- - **qualità** (1920×1080 o superiore)
- - **bassa latenza** ([35~70ms][lowlatency])
- - **tempo di avvio basso** (~ 1secondo per visualizzare la prima immagine)
- - **non invadenza** (nulla viene lasciato installato sul dispositivo)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-
-## Requisiti
-
-Il dispositivo Android richiede almeno le API 21 (Android 5.0).
-
-Assiucurati di aver [attivato il debug usb][enable-adb] sul(/i) tuo(i) dispositivo(/i).
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-In alcuni dispositivi, devi anche abilitare [un'opzione aggiuntiva][control] per controllarli con tastiera e mouse.
-
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-## Ottieni l'app
-
-<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
-
-### Sommario
-
- - Linux: `apt install scrcpy`
- - Windows: [download](README.md#windows)
- - macOS: `brew install scrcpy`
-
-Compila dai sorgenti: [BUILD] (in inglese) ([procedimento semplificato][BUILD_simple] (in inglese))
-
-[BUILD]: BUILD.md
-[BUILD_simple]: BUILD.md#simple
-
-
-### Linux
-
-Su Debian (_testing_ e _sid_ per ora) e Ubuntu (20.04):
-
-```
-apt install scrcpy
-```
-
-È disponibile anche un pacchetto [Snap]: [`scrcpy`][snap-link].
-
-[snap-link]: https://snapstats.org/snaps/scrcpy
-
-[snap]: https://it.wikipedia.org/wiki/Snappy_(gestore_pacchetti)
-
-Per Fedora, è disponibile un pacchetto [COPR]: [`scrcpy`][copr-link].
-
-[COPR]: https://fedoraproject.org/wiki/Category:Copr
-[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
-
-Per Arch Linux, è disponibile un pacchetto [AUR]: [`scrcpy`][aur-link].
-
-[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
-
-Per Gentoo, è disponibile una [Ebuild]: [`scrcpy/`][ebuild-link].
-
-[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
-[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-
-Puoi anche [compilare l'app manualmente][BUILD] (in inglese) ([procedimento semplificato][BUILD_simple] (in inglese)).
-
-
-### Windows
-
-Per Windows, per semplicità è disponibile un archivio precompilato con tutte le dipendenze (incluso `adb`):
-
- - [README](README.md#windows) (Link al README originale per l'ultima versione)
-
-È anche disponibile in [Chocolatey]:
-
-[Chocolatey]: https://chocolatey.org/
-
-```bash
-choco install scrcpy
-choco install adb    # se non lo hai già
-```
-
-E in [Scoop]:
-
-```bash
-scoop install scrcpy
-scoop install adb    # se non lo hai già
-```
-
-[Scoop]: https://scoop.sh
-
-Puoi anche [compilare l'app manualmente][BUILD] (in inglese).
-
-
-### macOS
-
-L'applicazione è disponibile in [Homebrew]. Basta installarlo:
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-Serve che `adb` sia accessibile dal tuo `PATH`. Se non lo hai già:
-
-```bash
-brew install android-platform-tools
-```
-
-È anche disponibile in [MacPorts], che imposta adb per te:
-
-```bash
-sudo port install scrcpy
-```
-
-[MacPorts]: https://www.macports.org/
-
-
-Puoi anche [compilare l'app manualmente][BUILD] (in inglese).
-
-
-## Esecuzione
-
-Collega un dispositivo Android ed esegui:
-
-```bash
-scrcpy
-```
-
-Scrcpy accetta argomenti da riga di comando, essi sono listati con:
-
-```bash
-scrcpy --help
-```
-
-## Funzionalità
-
-### Configurazione di acquisizione
-
-#### Riduci dimensione
-
-Qualche volta è utile trasmettere un dispositvo Android ad una definizione inferiore per aumentare le prestazioni.
-
-Per limitare sia larghezza che altezza ad un certo valore (ad es. 1024):
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # versione breve
-```
-
-L'altra dimensione è calcolata in modo tale che il rapporto di forma del dispositivo sia preservato.
-In questo esempio un dispositivo in 1920x1080 viene trasmesso a 1024x576.
-
-
-#### Cambia bit-rate (velocità di trasmissione)
-
-Il bit-rate predefinito è 8 Mbps. Per cambiare il bitrate video (ad es. a 2 Mbps):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # versione breve
-```
-
-#### Limitare il frame rate (frequenza di fotogrammi)
-
-Il frame rate di acquisizione può essere limitato:
-
-```bash
-scrcpy --max-fps 15
-```
-
-Questo è supportato ufficialmente a partire da Android 10, ma potrebbe funzionare in versioni precedenti.
-
-#### Ritaglio
-
-Lo schermo del dispositivo può essere ritagliato per visualizzare solo parte di esso.
-
-Questo può essere utile, per esempio, per trasmettere solo un occhio dell'Oculus Go:
-
-```bash
-scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
-```
-
-Se anche `--max-size` è specificata, il ridimensionamento è applicato dopo il ritaglio.
-
-
-#### Blocca orientamento del video
-
-
-Per bloccare l'orientamento della trasmissione:
-
-```bash
-scrcpy --lock-video-orientation     # orientamento iniziale (corrente)
-scrcpy --lock-video-orientation=0   # orientamento naturale
-scrcpy --lock-video-orientation=1   # 90° antiorario
-scrcpy --lock-video-orientation=2   # 180°
-scrcpy --lock-video-orientation=3   # 90° orario
-```
-
-Questo influisce sull'orientamento della registrazione.
-
-
-La [finestra può anche essere ruotata](#rotazione) indipendentemente.
-
-
-#### Codificatore
-
-Alcuni dispositivi hanno più di un codificatore e alcuni di questi possono provocare problemi o crash. È possibile selezionare un encoder diverso:
-
-```bash
-scrcpy --encoder OMX.qcom.video.encoder.avc
-```
-
-Per elencare i codificatori disponibili puoi immettere un nome di codificatore non valido e l'errore mostrerà i codificatori disponibili:
-
-```bash
-scrcpy --encoder _
-```
-
-### Cattura
-
-#### Registrazione
-
-È possibile registrare lo schermo durante la trasmissione:
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-Per disabilitare la trasmissione durante la registrazione:
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# interrompere la registrazione con Ctrl+C
-```
-
-I "fotogrammi saltati" sono registrati nonostante non siano mostrati in tempo reale (per motivi di prestazioni). I fotogrammi sono _datati_ sul dispositivo, così una [variazione di latenza dei pacchetti][packet delay variation] non impatta il file registrato.
-
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-
-#### v4l2loopback
-
-Su Linux è possibile inviare il flusso video ad un dispositivo v4l2 loopback, cosicchè un dispositivo Android possa essere aperto come una webcam da qualsiasi strumento compatibile con v4l2.
-
-Il modulo `v4l2loopback` deve essere installato:
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-Per creare un dispositvo v4l2:
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-Questo creerà un nuovo dispositivo video in `/dev/videoN` dove `N` è un intero (più [opzioni](https://github.com/umlaeute/v4l2loopback#options) sono disponibili per crere più dispositivi o dispositivi con ID specifici).
-
-Per elencare i dispositvi attivati:
-
-```bash
-# necessita del pacchetto v4l-utils
-v4l2-ctl --list-devices
-
-# semplice ma potrebbe essere sufficiente
-ls /dev/video*
-```
-
-Per avviare scrcpy utilizzando un v4l2 sink:
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # disabilita la finestra di trasmissione
-scrcpy --v4l2-sink=/dev/videoN -N            # versione corta
-```
-
-(sostituisci `N` con l'ID del dispositivo, controlla con `ls /dev/video*`)
-
-Una volta abilitato, puoi aprire il tuo flusso video con uno strumento compatibile con v4l2:
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLC potrebbe aggiungere del ritardo per il buffer
-```
-
-Per esempio potresti catturare il video in [OBS].
-
-[OBS]: https://obsproject.com/
-
-
-#### Buffering
-
-È possibile aggiungere del buffer. Questo aumenta la latenza ma riduce il jitter (vedi [#2464]).
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-L'opzione è disponibile per il buffer della visualizzazione:
-
-```bash
-scrcpy --display-buffer=50  # aggiungi 50 ms di buffer per la visualizzazione
-```
-
-e per il V4L2 sink:
-
-```bash
-scrcpy --v4l2-buffer=500    #  aggiungi 50 ms di buffer per il v4l2 sink
-```
-
-
-### Connessione
-
-#### Wireless
-
-
-_Scrcpy_ usa `adb` per comunicare col dispositivo e `adb` può [connettersi][connect] al dispositivo mediante TCP/IP:
-
-1. Connetti il dispositivo alla stessa rete Wi-Fi del tuo computer.
-2. Trova l'indirizzo IP del tuo dispositivo in Impostazioni → Informazioni sul telefono → Stato, oppure   eseguendo questo comando:
-
-    ```bash
-    adb shell ip route | awk '{print $9}'
-    ```
-
-3. Abilita adb via TCP/IP sul tuo dispositivo: `adb tcpip 5555`.
-4. Scollega il tuo dispositivo.
-5. Connetti il tuo dispositivo: `adb connect IP_DISPOSITVO:5555` _(rimpiazza `IP_DISPOSITIVO`)_.
-6. Esegui `scrcpy` come al solito.
-
-Potrebbe essere utile diminuire il bit-rate e la definizione
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # versione breve
-```
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-#### Multi dispositivo
-
-Se in `adb devices` sono listati più dispositivi, è necessario specificare il _seriale_:
-
-```bash
-scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # versione breve
-```
-
-Se il dispositivo è collegato mediante TCP/IP:
-
-```bash
-scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # versione breve
-```
-
-Puoi avviare più istanze di _scrcpy_ per diversi dispositivi.
-
-
-#### Avvio automativo alla connessione del dispositivo
-
-Potresti usare [AutoAdb]:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
-
-#### Tunnel SSH
-
-Per connettersi a un dispositivo remoto è possibile collegare un client `adb` locale ad un server `adb` remoto (assunto che entrambi stiano usando la stessa versione del protocollo _adb_):
-
-```bash
-adb kill-server    # termina il server adb locale su 5037
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# tieni questo aperto
-```
-
-Da un altro terminale:
-
-```bash
-scrcpy
-```
-
-Per evitare l'abilitazione dell'apertura porte remota potresti invece forzare una "forward connection" (notare il `-L` invece di `-R`)
-
-```bash
-adb kill-server    # termina il server adb locale su 5037
-ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
-# tieni questo aperto
-```
-
-Da un altro terminale:
-
-```bash
-scrcpy --force-adb-forward
-```
-
-
-Come per le connessioni wireless potrebbe essere utile ridurre la qualità:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-### Configurazione della finestra
-
-#### Titolo
-
-Il titolo della finestra è il modello del dispositivo per impostazione predefinita. Esso può essere cambiato:
-
-```bash
-scrcpy --window-title 'My device'
-```
-
-#### Posizione e dimensione
-
-La posizione e la dimensione iniziale della finestra può essere specificata:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-#### Senza bordi
-
-Per disabilitare le decorazioni della finestra:
-
-```bash
-scrcpy --window-borderless
-```
-
-#### Sempre in primo piano
-
-Per tenere scrcpy sempre in primo piano:
-
-```bash
-scrcpy --always-on-top
-```
-
-#### Schermo intero
-
-L'app può essere avviata direttamente a schermo intero:
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # versione breve
-```
-
-Lo schermo intero può anche essere attivato/disattivato con <kbd>MOD</kbd>+<kbd>f</kbd>.
-
-#### Rotazione
-
-La finestra può essere ruotata:
-
-```bash
-scrcpy --rotation 1
-```
-
-I valori possibili sono:
- - `0`: nessuna rotazione
- - `1`: 90 gradi antiorari
- - `2`: 180 gradi
- - `3`: 90 gradi orari
-
-La rotazione può anche essere cambiata dinamicamente con <kbd>MOD</kbd>+<kbd>←</kbd>
-_(sinistra)_ e <kbd>MOD</kbd>+<kbd>→</kbd> _(destra)_.
-
-Notare che _scrcpy_ gestisce 3 diversi tipi di rotazione:
- - <kbd>MOD</kbd>+<kbd>r</kbd> richiede al dispositvo di cambiare tra orientamento verticale (portrait) e orizzontale (landscape) (l'app in uso potrebbe rifiutarsi se non supporta l'orientamento richiesto).
- - [`--lock-video-orientation`](#blocca-orientamento-del-video) cambia l'orientamento della trasmissione (l'orientamento del video inviato dal dispositivo al computer). Questo influenza la registrazione.
- - `--rotation` (o <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) ruota solo il contenuto della finestra. Questo influenza solo la visualizzazione, non la registrazione.
-
-
-### Altre opzioni di trasmissione
-
-#### "Sola lettura"
-
-Per disabilitare i controlli (tutto ciò che può interagire col dispositivo: tasti di input, eventi del mouse, trascina e rilascia (drag&drop) file):
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-#### Schermo
-
-Se sono disponibili più schermi, è possibile selezionare lo schermo da trasmettere:
-
-```bash
-scrcpy --display 1
-```
-
-La lista degli id schermo può essere ricavata da:
-
-```bash
-adb shell dumpsys display   # cerca "mDisplayId=" nell'output
-```
-
-Lo schermo secondario potrebbe essere possibile controllarlo solo se il dispositivo esegue almeno Android 10 (in caso contrario è trasmesso in modalità sola lettura).
-
-
-#### Mantenere sbloccato
-
-Per evitare che il dispositivo si blocchi dopo un po' che il dispositivo è collegato:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w
-```
-
-Lo stato iniziale è ripristinato quando scrcpy viene chiuso.
-
-
-#### Spegnere lo schermo
-
-È possibile spegnere lo schermo del dispositivo durante la trasmissione con un'opzione da riga di comando:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-Oppure premendo <kbd>MOD</kbd>+<kbd>o</kbd> in qualsiasi momento.
-
-Per riaccenderlo premere <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
-
-In Android il pulsante `POWER` (tasto di accensione) accende sempre lo schermo. Per comodità, se `POWER` è inviato via scrcpy (con click destro o con <kbd>MOD</kbd>+<kbd>p</kbd>), si forza il dispositivo a spegnere lo schermo dopo un piccolo ritardo (appena possibile).
-Il pulsante fisico `POWER` continuerà ad accendere lo schermo normalmente.
-
-Può anche essere utile evitare il blocco del dispositivo:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw
-```
-
-
-#### Mostrare i tocchi
-
-Per le presentazioni può essere utile mostrare i tocchi fisici (sul dispositivo fisico).
-
-Android fornisce questa funzionalità nelle _Opzioni sviluppatore_.
-
-_Scrcpy_ fornisce un'opzione per abilitare questa funzionalità all'avvio e ripristinare il valore iniziale alla chiusura:
-
-```bash
-scrcpy --show-touches
-scrcpy -t
-```
-
-Notare che mostra solo i tocchi _fisici_ (con le dita sul dispositivo).
-
-
-#### Disabilitare il salvaschermo
-
-In maniera predefinita scrcpy non previene l'attivazione del salvaschermo del computer.
-
-Per disabilitarlo:
-
-```bash
-scrcpy --disable-screensaver
-```
-
-
-### Input di controlli
-
-#### Rotazione dello schermo del dispostivo
-
-Premere <kbd>MOD</kbd>+<kbd>r</kbd> per cambiare tra le modalità verticale (portrait) e orizzontale (landscape).
-
-Notare che la rotazione avviene solo se l'applicazione in primo piano supporta l'orientamento richiesto.
-
-#### Copia-incolla
-
-Quando gli appunti di Android cambiano, essi vengono automaticamente sincronizzati con gli appunti del computer.
-
-Qualsiasi scorciatoia <kbd>Ctrl</kbd> viene inoltrata al dispositivo. In particolare:
- - <kbd>Ctrl</kbd>+<kbd>c</kbd> copia
- - <kbd>Ctrl</kbd>+<kbd>x</kbd> taglia
- - <kbd>Ctrl</kbd>+<kbd>v</kbd> incolla (dopo la sincronizzazione degli appunti da computer a dispositivo)
-
-Questo solitamente funziona nella maniera più comune.
-
-Il comportamento reale, però, dipende dall'applicazione attiva. Per esempio _Termux_ invia SIGINT con <kbd>Ctrl</kbd>+<kbd>c</kbd>, e _K-9 Mail_ compone un nuovo messaggio.
-
-Per copiare, tagliare e incollare in questi casi (ma è solo supportato in Android >= 7):
- - <kbd>MOD</kbd>+<kbd>c</kbd> inietta `COPY`
- - <kbd>MOD</kbd>+<kbd>x</kbd> inietta `CUT`
- - <kbd>MOD</kbd>+<kbd>v</kbd> inietta `PASTE` (dopo la sincronizzazione degli appunti da computer a dispositivo)
-
-In aggiunta, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permette l'iniezione del testo degli appunti del computer come una sequenza di eventi pressione dei tasti. Questo è utile quando il componente non accetta l'incollaggio di testo (per esempio in _Termux_), ma questo può rompere il contenuto non ASCII.
-
-**AVVISO:** Incollare gli appunti del computer nel dispositivo (sia con <kbd>Ctrl</kbd>+<kbd>v</kbd> che con <kbd>MOD</kbd>+<kbd>v</kbd>) copia il contenuto negli appunti del dispositivo. Come conseguenza, qualsiasi applicazione Android potrebbe leggere il suo contenuto. Dovresti evitare di incollare contenuti sensibili (come password) in questa maniera.
-
-Alcuni dispositivi non si comportano come aspettato quando si modificano gli appunti del dispositivo a livello di codice. L'opzione `--legacy-paste` è fornita per cambiare il comportamento di <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> in modo tale che anch'essi iniettino il testo gli appunti del computer come una sequenza di eventi pressione dei tasti (nella stessa maniera di <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
-
-#### Pizzica per zoomare (pinch-to-zoom)
-
-Per simulare il "pizzica per zoomare": <kbd>Ctrl</kbd>+_click e trascina_.
-
-Più precisamente, tieni premuto <kbd>Ctrl</kbd> mentre premi il pulsante sinistro. Finchè il pulsante non sarà rilasciato, tutti i movimenti del mouse ridimensioneranno e ruoteranno il contenuto (se supportato dall'applicazione) relativamente al centro dello schermo.
-
-Concretamente scrcpy genera degli eventi di tocco addizionali di un "dito virtuale" nella posizione simmetricamente opposta rispetto al centro dello schermo.
-
-
-#### Preferenze di iniezione del testo
-
-Ci sono due tipi di [eventi][textevents] generati quando si scrive testo:
- - _eventi di pressione_, segnalano che tasto è stato premuto o rilasciato;
- - _eventi di testo_, segnalano che del testo è stato inserito.
-
-In maniera predefinita le lettere sono "iniettate" usando gli eventi di pressione, in maniera tale che la tastiera si comporti come aspettato nei giochi (come accade solitamente per i tasti WASD).
-
-Questo, però, può [causare problemi][prefertext]. Se incontri un problema del genere, puoi evitarlo con:
-
-```bash
-scrcpy --prefer-text
-```
-
-(ma questo romperà il normale funzionamento della tastiera nei giochi)
-
-[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
-[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-
-
-#### Ripetizione di tasti
-
-In maniera predefinita tenere premuto un tasto genera una ripetizione degli eventi di pressione di tale tasto. Questo può creare problemi di performance in alcuni giochi, dove questi eventi sono inutilizzati.
-
-Per prevenire l'inoltro ripetuto degli eventi di pressione:
-
-```bash
-scrcpy --no-key-repeat
-```
-
-#### Click destro e click centrale
-
-In maniera predefinita, click destro aziona BACK (indietro) e il click centrale aziona HOME. Per disabilitare queste scorciatoie e, invece, inviare i click al dispositivo:
-
-```bash
-scrcpy --forward-all-clicks
-```
-
-
-### Rilascio di file
-
-#### Installare APK
-
-Per installare un APK, trascina e rilascia un file APK (finisce con `.apk`) nella finestra di _scrcpy_.
-
-Non c'è alcuna risposta visiva, un log è stampato nella console.
-
-
-#### Trasferimento di file verso il dispositivo
-
-Per trasferire un file in `/sdcard/Download` del dispositivo trascina e rilascia un file (non APK) nella finestra di _scrcpy_.
-
-Non c'è alcuna risposta visiva, un log è stampato nella console.
-
-La cartella di destinazione può essere cambiata all'avvio:
-
-```bash
-scrcpy --push-target=/sdcard/Movies/
-```
-
-
-### Inoltro dell'audio
-
-L'audio non è inoltrato da _scrcpy_. Usa [sndcpy].
-
-Vedi anche la [issue #14].
-
-[sndcpy]: https://github.com/rom1v/sndcpy
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
-
-
-## Scociatoie
-
-Nella lista seguente, <kbd>MOD</kbd> è il modificatore delle scorciatoie. In maniera predefinita è <kbd>Alt</kbd> (sinistro) o <kbd>Super</kbd> (sinistro).
-
-Può essere cambiato usando `--shortcut-mod`. I tasti possibili sono `lctrl`, `rctrl`, `lalt`, `ralt`, `lsuper` and `rsuper` (`l` significa sinistro e `r` significa destro). Per esempio:
-
-```bash
-# usa ctrl destro per le scorciatoie
-scrcpy --shortcut-mod=rctrl
-
-# use sia "ctrl sinistro"+"alt sinistro" che "super sinistro" per le scorciatoie
-scrcpy --shortcut-mod=lctrl+lalt,lsuper
-```
-
-_<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
-
-[Super]: https://it.wikipedia.org/wiki/Tasto_Windows
-<!-- https://en.wikipedia.org/wiki/Super_key_(keyboard_button) è la pagina originale di Wikipedia inglese, l'ho sostituita con una simile in quello italiano -->
-
- | Azione                                      |   Scorciatoia
- | ------------------------------------------- |:-----------------------------
- | Schermo intero                      | <kbd>MOD</kbd>+<kbd>f</kbd>
- | Rotazione schermo a sinistra                         | <kbd>MOD</kbd>+<kbd>←</kbd> _(sinistra)_
- | Rotazione schermo a destra                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(destra)_
- | Ridimensiona finestra a 1:1 (pixel-perfect)        | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Ridimensiona la finestra per rimuovere i bordi neri       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doppio click sinistro¹_
- | Premi il tasto `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Click centrale_
- | Premi il tasto `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Click destro²_
- | Premi il tasto `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4° click³_
- | Premi il tasto `MENU` (sblocca lo schermo)             | <kbd>MOD</kbd>+<kbd>m</kbd>
- | Premi il tasto `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(su)_
- | Premi il tasto `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(giù)_
- | Premi il tasto `POWER`                            | <kbd>MOD</kbd>+<kbd>p</kbd>
- | Accendi                                    | _Click destro²_
- | Spegni lo schermo del dispositivo (continua a trasmettere)     | <kbd>MOD</kbd>+<kbd>o</kbd>
- | Accendi lo schermo del dispositivo                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
- | Ruota lo schermo del dispositivo                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Espandi il pannello delle notifiche                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5° click³_
- | Espandi il pannello delle impostazioni                   | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Doppio 5° click³_
- | Chiudi pannelli                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copia negli appunti⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Taglia negli appunti⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Sincronizza gli appunti e incolla⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>
- | Inietta il testo degli appunti del computer              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
- | Abilita/Disabilita il contatore FPS (su stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Pizzica per zoomare                               | <kbd>Ctrl</kbd>+_click e trascina_
-
-_¹Doppio click sui bordi neri per rimuoverli._  
-_²Il tasto destro accende lo schermo se era spento, preme BACK in caso contrario._  
-_³4° e 5° pulsante del mouse, se il tuo mouse ne dispone._  
-_⁴Solo in Android >= 7._
-
-Le scorciatoie con pulsanti ripetuti sono eseguite rilasciando e premendo il pulsante una seconda volta. Per esempio, per eseguire "Espandi il pannello delle impostazioni":
-
-1. Premi e tieni premuto <kbd>MOD</kbd>.
-2. Poi premi due volte <kbd>n</kbd>.
-3. Infine rilascia <kbd>MOD</kbd>.
-
-Tutte le scorciatoie <kbd>Ctrl</kbd>+_tasto_ sono inoltrate al dispositivo, così sono gestite dall'applicazione attiva.
-
-## Path personalizzati
-
-Per utilizzare dei binari _adb_ specifici, configura il suo path nella variabile d'ambente `ADB`:
-
-```bash
-ADB=/percorso/per/adb scrcpy
-```
-
-Per sovrascrivere il percorso del file `scrcpy-server`, configura il percorso in `SCRCPY_SERVER_PATH`.
-
-## Perchè _scrcpy_?
-
-Un collega mi ha sfidato a trovare un nome tanto impronunciabile quanto [gnirehtet].
-
-[`strcpy`] copia una **str**ing (stringa); `scrcpy` copia uno **scr**een (schermo).
-
-[gnirehtet]: https://github.com/Genymobile/gnirehtet
-[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
-
-## Come compilare?
-
-Vedi [BUILD] (in inglese).
-
-
-## Problemi comuni
-
-Vedi le [FAQ](FAQ.it.md).
-
-
-## Sviluppatori
-
-Leggi la [pagina per sviluppatori].
-
-[pagina per sviluppatori]: DEVELOP.md
-
-
-## Licenza (in inglese)
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2021 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## Articoli (in inglese)
-
-- [Introducendo scrcpy][article-intro]
-- [Scrcpy ora funziona wireless][article-tcpip]
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/

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-2021 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## 記事
-
-- [Introducing scrcpy][article-intro]
-- [Scrcpy now works wirelessly][article-tcpip]
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/

README.ko.md

@@ -1,498 +0,0 @@
-_Only the original [README](README.md) is guaranteed to be up-to-date._
-
-# scrcpy (v1.11)
-
-This document will be updated frequently along with the original Readme file
-이 문서는 원어 리드미 파일의 업데이트에 따라 종종 업데이트 될 것입니다
-
- 이 어플리케이션은 UBS ( 혹은 [TCP/IP][article-tcpip] ) 로 연결된 Android 디바이스를 화면에 보여주고 관리하는 것을 제공합니다.
- _GNU/Linux_, _Windows_ 와 _macOS_ 상에서 작동합니다.
- (아래 설명에서 디바이스는 안드로이드 핸드폰을 의미합니다.)
-
-[article-tcpip]:https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
-
-![screenshot](https://github.com/Genymobile/scrcpy/blob/master/assets/screenshot-debian-600.jpg?raw=true)
-
-주요 기능은 다음과 같습니다.
-
- - **가벼움** (기본적이며 디바이스의 화면만을 보여줌)
- - **뛰어난 성능** (30~60fps)
- - **높은 품질** (1920×1080 이상의 해상도)
- - **빠른 반응 속도** ([35~70ms][lowlatency])
- - **짧은 부팅 시간** (첫 사진을 보여주는데 최대 1초 소요됨)
- - **장치 설치와는 무관함** (디바이스에 설치하지 않아도 됨)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-
-## 요구사항
-
-안드로이드 장치는 최소 API 21 (Android 5.0) 을 필요로 합니다.
-
-디바이스에 [adb debugging][enable-adb]이 가능한지 확인하십시오.
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-어떤 디바이스에서는, 키보드와 마우스를 사용하기 위해서 [추가 옵션][control] 이 필요하기도 합니다.
-
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-## 앱 설치하기
-
-
-### Linux (리눅스)
-
-리눅스 상에서는 보통 [어플을 직접 설치][BUILD] 해야합니다. 어렵지 않으므로 걱정하지 않아도 됩니다.
-
-[BUILD]:https://github.com/Genymobile/scrcpy/blob/master/BUILD.md
-
-[Snap] 패키지가 가능합니다 : [`scrcpy`][snap-link].
-
-[snap-link]: https://snapstats.org/snaps/scrcpy
-
-[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
-
-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
-
-
-### Windows (윈도우)
-
-윈도우 상에서, 간단하게 설치하기 위해 종속성이 있는 사전 구축된 아카이브가 제공됩니다 (`adb` 포함) :
-해당 파일은 Readme원본 링크를 통해서 다운로드가 가능합니다.
- - [README](README.md#windows)
-
-
-[어플을 직접 설치][BUILD] 할 수도 있습니다.
-
-
-### macOS (맥 OS)
-
-이 어플리케이션은 아래 사항을 따라 설치한다면 [Homebrew] 에서도 사용 가능합니다 :
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-`PATH` 로부터 접근 가능한 `adb` 가 필요합니다. 아직 설치하지 않았다면 다음을 따라 설치해야 합니다 :
-
-```bash
-brew cask install android-platform-tools
-```
-
-[어플을 직접 설치][BUILD] 할 수도 있습니다.
-
-
-## 실행
-
-안드로이드 디바이스를 연결하고 실행하십시오:
-
-```bash
-scrcpy
-```
-
-다음과 같이 명령창 옵션 기능도 제공합니다.
-
-```bash
-scrcpy --help
-```
-
-## 기능
-
-### 캡쳐 환경 설정
-
-
-### 사이즈 재정의
-
-가끔씩 성능을 향상시키기위해 안드로이드 디바이스를 낮은 해상도에서 미러링하는 것이 유용할 때도 있습니다.
-
-너비와 높이를 제한하기 위해 특정 값으로 지정할 수 있습니다 (e.g. 1024) :
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # 축약 버전
-```
-
-이 외의 크기도 디바이스의 가로 세로 비율이 유지된 상태에서 계산됩니다.
-이러한 방식으로 디바이스 상에서 1920×1080 는 모니터 상에서1024×576로 미러링될 것 입니다.
-
-
-### bit-rate 변경
-
-기본 bit-rate 는 8 Mbps입니다. 비디오 bit-rate 를 변경하기 위해선 다음과 같이 입력하십시오 (e.g. 2 Mbps로 변경):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # 축약 버전
-```
-
-### 프레임 비율 제한
-
-안드로이드 버전 10이상의 디바이스에서는, 다음의 명령어로 캡쳐 화면의 프레임 비율을 제한할 수 있습니다:
-
-```bash
-scrcpy --max-fps 15
-```
-
-
-### Crop (잘라내기)
-
-디바이스 화면은 화면의 일부만 미러링하기 위해 잘라질 것입니다.
-
-예를 들어, *Oculus Go* 의 한 쪽 눈만 미러링할 때 유용합니다 :
-
-```bash
-scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
-scrcpy -c 1224:1440:0:0       # 축약 버전
-```
-
-만약 `--max-size` 도 지정하는 경우, 잘라낸 다음에 재정의된 크기가 적용될 것입니다.
-
-
-### 화면 녹화
-
-미러링하는 동안 화면 녹화를 할 수 있습니다 :
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-녹화하는 동안 미러링을 멈출 수 있습니다 :
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# Ctrl+C 로 녹화를 중단할 수 있습니다.
-# 윈도우 상에서 Ctrl+C 는 정상정으로 종료되지 않을 수 있으므로, 디바이스 연결을 해제하십시오.
-```
-
-"skipped frames" 은 모니터 화면에 보여지지 않았지만 녹화되었습니다 ( 성능 문제로 인해 ). 프레임은 디바이스 상에서 _타임 스탬프 ( 어느 시점에 데이터가 존재했다는 사실을 증명하기 위해 특정 위치에 시각을 표시 )_ 되었으므로, [packet delay
-variation] 은 녹화된 파일에 영향을 끼치지 않습니다.
-
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-## 연결
-
-### 무선연결
-
-_Scrcpy_ 장치와 정보를 주고받기 위해 `adb` 를 사용합니다.  `adb` 는 TCIP/IP 를 통해 디바이스와 [연결][connect] 할 수 있습니다 :
-
-1. 컴퓨터와 디바이스를 동일한 Wi-Fi 에 연결합니다.
-2. 디바이스의 IP address 를 확인합니다 (설정 → 내 기기 → 상태 / 혹은 인터넷에 '내 IP'검색 시 확인 가능합니다. ).
-3. TCP/IP 를 통해 디바이스에서 adb 를 사용할 수 있게 합니다: `adb tcpip 5555`.
-4. 디바이스 연결을 해제합니다.
-5. adb 를 통해 디바이스에 연결을 합니다\: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` 대신)_.
-6. `scrcpy` 실행합니다.
-
-다음은 bit-rate 와 해상도를 줄이는데 유용합니다 :
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # 축약 버전
-```
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-
-### 여러 디바이스 사용 가능
-
-만약에 여러 디바이스들이 `adb devices` 목록에 표시되었다면, _serial_ 을 명시해야합니다:
-
-```bash
-scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # 축약 버전
-```
-
-_scrcpy_ 로 여러 디바이스를 연결해 사용할 수 있습니다.
-
-
-#### SSH tunnel
-
-떨어져 있는 디바이스와 연결하기 위해서는, 로컬 `adb` client와 떨어져 있는 `adb` 서버를 연결해야 합니다.  (디바이스와 클라이언트가 동일한 버전의 _adb_ protocol을 사용할 경우에 제공됩니다.):
-
-```bash
-adb kill-server    # 5037의 로컬 local adb server를 중단
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# 실행 유지
-```
-
-다른 터미널에서는 :
-
-```bash
-scrcpy
-```
-
-무선 연결과 동일하게, 화질을 줄이는 것이 나을 수 있습니다:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-## Window에서의 배치
-
-### 맞춤형 window 제목
-
-기본적으로, window의 이름은 디바이스의 모델명 입니다.
-다음의 명령어를 통해 변경하세요.
-
-```bash
-scrcpy --window-title 'My device'
-```
-
-
-### 배치와 크기
-
-초기 window창의 배치와 크기는 다음과 같이 설정할 수 있습니다:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-
-### 경계 없애기
-
-윈도우 장식(경계선 등)을 다음과 같이 제거할 수 있습니다:
-
-```bash
-scrcpy --window-borderless
-```
-
-### 항상 모든 윈도우 위에 실행창 고정
-
-이 어플리케이션의 윈도우 창은 다음의 명령어로 다른 window 위에 디스플레이 할 수 있습니다:
-
-```bash
-scrcpy --always-on-top
-scrcpy -T  # 축약 버전
-```
-
-### 전체 화면
-
-이 어플리케이션은 전체화면으로 바로 시작할 수 있습니다.
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # short version
-```
-
-전체 화면은  `Ctrl`+`f`키로 끄거나 켤 수 있습니다.
-
-
-## 다른 미러링 옵션
-
-### 읽기 전용(Read-only)
-
-권한을 제한하기 위해서는 (디바이스와 관련된 모든 것: 입력 키, 마우스 이벤트 , 파일의 드래그 앤 드랍(drag&drop)):
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-### 화면 끄기
-
-미러링을 실행하는 와중에 디바이스의 화면을 끌 수 있게 하기 위해서는
-다음의 커맨드 라인 옵션을(command line option) 입력하세요:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-혹은 `Ctrl`+`o`을 눌러 언제든지 디바이스의 화면을 끌 수 있습니다.
-
-다시 화면을 켜기 위해서는`POWER` (혹은 `Ctrl`+`p`)를 누르세요.
-
-
-### 유효기간이 지난 프레임 제공 (Render expired frames)
-
-디폴트로, 대기시간을 최소화하기 위해 _scrcpy_ 는 항상 마지막으로 디코딩된 프레임을 제공합니다
-과거의 프레임은 하나씩 삭제합니다.
-
-모든 프레임을 강제로 렌더링하기 위해서는 (대기 시간이 증가될 수 있습니다)
-다음의 명령어를 사용하세요:
-
-```bash
-scrcpy --render-expired-frames
-```
-
-
-### 화면에 터치 나타내기
-
-발표를 할 때, 물리적인 기기에 한 물리적 터치를 나타내는 것이 유용할 수 있습니다.
-
-안드로이드 운영체제는 이런 기능을 _Developers options_에서 제공합니다.
-
-_Scrcpy_ 는 이런 기능을 시작할 때와 종료할 때 옵션으로 제공합니다.
-
-```bash
-scrcpy --show-touches
-scrcpy -t
-```
-
-화면에 _물리적인 터치만_ 나타나는 것에 유의하세요 (손가락을 디바이스에 대는 행위).
-
-
-### 입력 제어
-
-#### 복사-붙여넣기
-
-컴퓨터와 디바이스 양방향으로 클립보드를 복사하는 것이 가능합니다:
-
- - `Ctrl`+`c` 디바이스의 클립보드를 컴퓨터로 복사합니다;
- - `Ctrl`+`Shift`+`v` 컴퓨터의 클립보드를 디바이스로 복사합니다;
- - `Ctrl`+`v` 컴퓨터의 클립보드를 text event 로써 _붙여넣습니다_  ( 그러나, ASCII 코드가 아닌 경우 실행되지 않습니다 )
-
-#### 텍스트 삽입 우선 순위
-
-텍스트를 입력할 때 생성되는 두 가지의 [events][textevents] 가 있습니다:
- - _key events_, 키가 눌려있는 지에 대한 신호;
- - _text events_, 텍스트가 입력되었는지에 대한 신호.
-
-기본적으로, 글자들은 key event 를 이용해 입력되기 때문에, 키보드는 게임에서처럼 처리합니다 ( 보통 WASD 키에 대해서 ).
-
-그러나 이는 [issues 를 발생][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
-
-
-### 파일 드랍
-
-### APK 실행하기
-
-APK를 실행하기 위해서는, APK file(파일명이`.apk`로 끝나는 파일)을  드래그하고 _scrcpy_ window에 드랍하세요 (drag and drop)
-
-시각적인 피드백은 없고,log 하나가 콘솔에 출력될 것입니다.
-
-### 디바이스에 파일 push하기
-
-디바이스의`/sdcard/`에 파일을 push하기 위해서는,
-APK파일이 아닌 파일을_scrcpy_ window에 드래그하고 드랍하세요.(drag and drop).
-
-시각적인 피드백은 없고,log 하나가 콘솔에 출력될 것입니다.
-
-해당 디렉토리는 시작할 때 변경이 가능합니다:
-
-```bash
-scrcpy --push-target /sdcard/foo/bar/
-```
-
-### 오디오의 전달
-
-_scrcpy_는 오디오를 직접 전달해주지 않습니다. [USBaudio] (Linux-only)를 사용하세요.
-
-추가적으로 [issue #14]를 참고하세요.
-
-[USBaudio]: https://github.com/rom1v/usbaudio
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
-
-## 단축키
-
- | 실행내용                                |   단축키                       |   단축키 (macOS)
- | -------------------------------------- |:----------------------------- |:-----------------------------
- | 전체화면 모드로 전환                      | `Ctrl`+`f`                    | `Cmd`+`f`
- | window를 1:1비율로 전환하기(픽셀 맞춤)   | `Ctrl`+`g`                    | `Cmd`+`g`
- | 검은 공백 제거 위한 window 크기 조정  | `Ctrl`+`x` \| _Double-click¹_ | `Cmd`+`x`  \| _Double-click¹_
- |`HOME` 클릭                        | `Ctrl`+`h` \| _Middle-click_  | `Ctrl`+`h` \| _Middle-click_
- | `BACK` 클릭                      | `Ctrl`+`b` \| _Right-click²_  | `Cmd`+`b`  \| _Right-click²_
- | `APP_SWITCH` 클릭                 | `Ctrl`+`s`                    | `Cmd`+`s`
- | `MENU` 클릭                       | `Ctrl`+`m`                    | `Ctrl`+`m`
- | `VOLUME_UP` 클릭                   | `Ctrl`+`↑` _(up)_             | `Cmd`+`↑` _(up)_
- | `VOLUME_DOWN` 클릭                | `Ctrl`+`↓` _(down)_           | `Cmd`+`↓` _(down)_
- | `POWER` 클릭                      | `Ctrl`+`p`                    | `Cmd`+`p`
- | 전원 켜기                               | _Right-click²_                | _Right-click²_
- | 미러링 중 디바이스 화면 끄기    | `Ctrl`+`o`                    | `Cmd`+`o`
- | 알림 패널 늘리기               | `Ctrl`+`n`                    | `Cmd`+`n`
- | 알림 패널 닫기            | `Ctrl`+`Shift`+`n`            | `Cmd`+`Shift`+`n`
- | 디바이스의 clipboard 컴퓨터로 복사하기      | `Ctrl`+`c`                    | `Cmd`+`c`
- | 컴퓨터의 clipboard 디바이스에 붙여넣기     | `Ctrl`+`v`                    | `Cmd`+`v`
- | Copy computer clipboard to device      | `Ctrl`+`Shift`+`v`            | `Cmd`+`Shift`+`v`
- | Enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    | `Cmd`+`i`
-
-_¹검은 공백을 제거하기 위해서는 그 부분을 더블 클릭하세요_
-_²화면이 꺼진 상태에서 우클릭 시 다시 켜지며, 그 외의 상태에서는 뒤로 돌아갑니다.
-
-## 맞춤 경로 (custom path)
-
-특정한 _adb_ binary를 사용하기 위해서는, 그것의 경로를 환경변수로 설정하세요.
-`ADB`:
-
-    ADB=/path/to/adb scrcpy
-
-`scrcpy-server.jar`파일의 경로에 오버라이드 하기 위해서는, 그것의 경로를 `SCRCPY_SERVER_PATH`에 저장하세요.
-
-[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
-
-
-## _scrcpy_ 인 이유?
-
-한 동료가 [gnirehtet]와 같이 발음하기 어려운 이름을 찾을 수 있는지 도발했습니다.
-
-[`strcpy`] 는 **str**ing을 copy하고; `scrcpy`는 **scr**een을 copy합니다.
-
-[gnirehtet]: https://github.com/Genymobile/gnirehtet
-[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
-
-
-
-## 빌드하는 방법?
-
-[BUILD]을 참고하세요.
-
-[BUILD]: BUILD.md
-
-## 흔한 issue
-
-[FAQ](FAQ.md)을 참고하세요.
-
-
-## 개발자들
-
-[developers page]를 참고하세요.
-
-[developers page]: DEVELOP.md
-
-
-## 라이선스
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2021 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## 관련 글 (articles)
-
-- [scrcpy 소개][article-intro]
-- [무선으로 연결하는 Scrcpy][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/

README.pt-br.md

@@ -1,880 +0,0 @@
-_Apenas o [README](README.md) original é garantido estar atualizado._
-
-# scrcpy (v1.19)
-
-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_.
-Funciona em _GNU/Linux_, _Windows_ e _macOS_.
-
-![screenshot](assets/screenshot-debian-600.jpg)
-
-Foco em:
-
- - **leveza** (nativo, mostra apenas a tela do dispositivo)
- - **performance** (30~60fps)
- - **qualidade** (1920×1080 ou acima)
- - **baixa latência** ([35~70ms][lowlatency])
- - **baixo tempo de inicialização** (~1 segundo para mostrar a primeira imagem)
- - **não intrusivo** (nada é deixado instalado no dispositivo)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-
-## Requisitos
-
-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).
-
-[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.
-
-[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
-
-
-### Linux
-
-No Debian (_testing_ e _sid_ por enquanto) e Ubuntu (20.04):
-
-```
-apt install scrcpy
-```
-
-Um 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
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
-
-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]).
-
-
-### Windows
-
-Para Windows, por simplicidade, um arquivo pré-compilado com todas as dependências
-(incluindo `adb`) está disponível:
-
- - [README](README.md#windows)
-
-Também está disponível em [Chocolatey]:
-
-[Chocolatey]: https://chocolatey.org/
-
-```bash
-choco install scrcpy
-choco install adb    # se você ainda não o tem
-```
-
-E no [Scoop]:
-
-```bash
-scoop install scrcpy
-scoop install adb    # se você ainda não o tem
-```
-
-[Scoop]: https://scoop.sh
-
-Você também pode [compilar o app manualmente][BUILD].
-
-
-### macOS
-
-A aplicação está disponível em [Homebrew]. Apenas instale-a:
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-Você precisa do `adb`, acessível pelo seu `PATH`. Se você ainda não o tem:
-
-```bash
-brew install android-platform-tools
-```
-
-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].
-
-
-## Executar
-
-Conecte um dispositivo Android e execute:
-
-```bash
-scrcpy
-```
-
-Também aceita argumentos de linha de comando, listados por:
-
-```bash
-scrcpy --help
-```
-
-## Funcionalidades
-
-### Configuração de captura
-
-#### Reduzir tamanho
-
-Algumas vezes, é útil espelhar um dispositivo Android em uma resolução menor para
-aumentar a performance.
-
-Para limitar ambos (largura e altura) para algum valor (ex: 1024):
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # versão curta
-```
-
-A outra dimensão é calculada para que a proporção do dispositivo seja preservada.
-Dessa forma, um dispositivo de 1920x1080 será espelhado em 1024x576.
-
-
-#### Mudar bit-rate
-
-O bit-rate padrão é 8 Mbps. Para mudar o bit-rate do vídeo (ex: para 2 Mbps):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # versão curta
-```
-
-#### Limitar frame rate
-
-O frame rate de captura pode ser limitado:
-
-```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:
-
-```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.
-
-
-#### 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
-
-É possível gravar a tela enquanto ocorre o espelhamento:
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-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
-```
-
-"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.
-
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-
-#### v4l2loopback
-
-Em Linux, é possível enviar a transmissão do video para um disposiivo v4l2 loopback, assim
-o dispositivo Android pode ser aberto como uma webcam por qualquer ferramneta capaz de v4l2
-
-The module `v4l2loopback` must be installed:
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-Para criar um dispositivo v4l2:
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-Isso criara um novo dispositivo de vídeo em `/dev/videoN`, onde `N` é uma integer
-(mais [opções](https://github.com/umlaeute/v4l2loopback#options) estão disponiveis
-para criar varios dispositivos ou dispositivos com IDs específicas).
-
-Para listar os dispositivos disponíveis:
-
-```bash
-# requer o pacote v4l-utils
-v4l2-ctl --list-devices
-
-# simples, mas pode ser suficiente
-ls /dev/video*
-```
-
-Para iniciar o scrcpy usando o coletor v4l2 (sink):
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # desativa a janela espelhada
-scrcpy --v4l2-sink=/dev/videoN -N            # versão curta
-```
-
-(troque `N` pelo ID do dipositivo, verifique com `ls /dev/video*`)
-
-Uma vez ativado, você pode abrir suas trasmissões de videos com uma ferramenta capaz de v4l2:
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLC pode adicionar um pouco de atraso de buffering
-```
-
-Por exemplo, você pode capturar o video dentro do [OBS].
-
-[OBS]: https://obsproject.com/
-
-
-#### Buffering
-
-É possivel adicionar buffering. Isso aumenta a latência, mas reduz a tenção (jitter) (veja
-[#2464]).
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-A opção éta disponivel para buffering de exibição:
-
-```bash
-scrcpy --display-buffer=50  # adiciona 50 ms de buffering para a exibição
-```
-
-e coletor V4L2:
-
-```bash
-scrcpy --v4l2-buffer=500    # adiciona 500 ms de buffering para coletor V4L2
-```
-
-,
-### Conexão
-
-#### Sem fio
-
-_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}'
-    ```
-
-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`)_.
-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
-```
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-#### Múltiplos dispositivos
-
-Se vários dispositivos são listados em `adb devices`, você deve especificar o _serial_:
-
-```bash
-scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # versão curta
-```
-
-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
-```
-
-Você pode iniciar várias instâncias do _scrcpy_ para vários dispositivos.
-
-#### Iniciar automaticamente quando dispositivo é conectado
-
-Você pode usar [AutoAdb]:
-
-```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
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# mantenha isso aberto
-```
-
-De outro terminal:
-
-```bash
-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:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-### Configuração de janela
-
-#### Título
-
-Por padrão, o título da janela é o modelo do dispositivo. Isso pode ser mudado:
-
-```bash
-scrcpy --window-title 'Meu dispositivo'
-```
-
-#### Posição e tamanho
-
-A posição e tamanho iniciais da janela podem ser especificados:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-#### Sem bordas
-
-Para desativar decorações de janela:
-
-```bash
-scrcpy --window-borderless
-```
-
-#### Sempre no topo
-
-Para manter a janela do scrcpy sempre no topo:
-
-```bash
-scrcpy --always-on-top
-```
-
-#### Tela cheia
-
-A aplicação pode ser iniciada diretamente em tela cheia:
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # versão curta
-```
-
-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.
-
-
-### 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):
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-#### Display
-
-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:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-Ou apertando <kbd>MOD</kbd>+<kbd>o</kbd> a qualquer momento.
-
-Para ligar novamente, pressione <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
-
-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.
-
-Também pode ser útil evitar que o dispositivo seja suspenso:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw
-```
-
-
-#### Mostrar toques
-
-Para apresentações, pode ser útil mostrar toques físicos (no dispositivo
-físico).
-
-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:
-
-```bash
-scrcpy --show-touches
-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.
-
-Note que só será rotacionado se a aplicação em primeiro plano suportar a
-orientação requisitada.
-
-#### Copiar-colar
-
-Sempre que a área de transferência do Android muda, é automaticamente sincronizada com a
-área de transferência do computador.
-
-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)
-
-Isso tipicamente funciona como esperado.
-
-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;
- - _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).
-
-Mas isso pode [causar problemas][prefertext]. Se você encontrar tal problema, você
-pode evitá-lo com:
-
-```bash
-scrcpy --prefer-text
-```
-
-(mas isso 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
-
-#### Instalar APK
-
-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
-
-Para enviar um arquivo para `/sdcard/Download/` 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.
-
-O diretório alvo pode ser mudado ao iniciar:
-
-```bash
-scrcpy --push-target /sdcard/foo/bar/
-```
-
-
-### Encaminhamento de áudio
-
-Áudio não é encaminhado pelo _scrcpy_. Use [sndcpy].
-
-Também veja [issue #14].
-
-[sndcpy]: https://github.com/rom1v/sndcpy
-[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).
-
-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.
-
-
-## Caminhos personalizados
-
-Para usar um binário _adb_ específico, configure seu caminho na variável de ambiente
-`ADB`:
-
-```bash
-ADB=/caminho/para/adb scrcpy
-```
-
-Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em
-`SCRCPY_SERVER_PATH`.
-
-[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
-
-
-## Por quê _scrcpy_?
-
-Um colega me desafiou a encontrar um nome tão impronunciável quanto [gnirehtet].
-
-[`strcpy`] copia uma **str**ing; `scrcpy` copia uma **scr**een.
-
-[gnirehtet]: https://github.com/Genymobile/gnirehtet
-[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
-
-
-## Como compilar?
-
-Veja [BUILD].
-
-
-## Problemas comuns
-
-Veja o [FAQ](FAQ.md).
-
-
-## Desenvolvedores
-
-Leia a [página dos desenvolvedores][developers page].
-
-[developers page]: DEVELOP.md
-
-
-## Licença
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2021 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## Artigos
-
-- [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/

README.sp.md

@@ -1,743 +0,0 @@
-Solo se garantiza que el archivo [README](README.md) original esté actualizado.
-
-# scrcpy (v1.17)
-
-Esta aplicación proporciona imagen y control de un dispositivo Android conectado
-por USB (o [por TCP/IP][article-tcpip]). No requiere acceso _root_.
-Compatible con _GNU/Linux_, _Windows_ y _macOS_.
-
-![screenshot](assets/screenshot-debian-600.jpg)
-
-Sus características principales son:
-
- - **ligero** (nativo, solo muestra la imagen del dispositivo)
- - **desempeño** (30~60fps)
- - **calidad** (1920×1080 o superior)
- - **baja latencia** ([35~70ms][lowlatency])
- - **corto tiempo de inicio** (~1 segundo para mostrar la primera imagen)
- - **no intrusivo** (no se deja nada instalado en el dispositivo)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-
-## Requisitos
-
-El dispositivo Android requiere como mínimo API 21 (Android 5.0).
-
-Asegurate de [habilitar el adb debugging][enable-adb] en tu(s) dispositivo(s).
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-En algunos dispositivos, también necesitas habilitar [una opción adicional][control] para controlarlo con el teclado y ratón.
-
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-## Consigue la app
-
-<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
-
-### Resumen
-
- - Linux: `apt install scrcpy`
- - Windows: [download](README.md#windows)
- - macOS: `brew install scrcpy`
-
-Construir desde la fuente: [BUILD] ([proceso simplificado][BUILD_simple])
-
-[BUILD]: BUILD.md
-[BUILD_simple]: BUILD.md#simple
-
-
-### Linux
-
-En Debian (_test_ y _sid_ por ahora) y Ubuntu (20.04):
-
-```
-apt install scrcpy
-```
-
-Hay un paquete [Snap]: [`scrcpy`][snap-link].
-
-[snap-link]: https://snapstats.org/snaps/scrcpy
-
-[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
-
-Para Fedora, hay un paquete [COPR]: [`scrcpy`][copr-link].
-
-[COPR]: https://fedoraproject.org/wiki/Category:Copr
-[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
-
-Para Arch Linux, hay un paquete [AUR]: [`scrcpy`][aur-link].
-
-[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
-
-Para Gentoo, hay un paquete [Ebuild]: [`scrcpy/`][ebuild-link].
-
-[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
-[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-
-También puedes [construir la aplicación manualmente][BUILD] ([proceso simplificado][BUILD_simple]).
-
-
-### Windows
-
-Para Windows, por simplicidad, hay un pre-compilado con todas las dependencias
-(incluyendo `adb`):
-
- - [README](README.md#windows)
-
-También está disponible en [Chocolatey]:
-
-[Chocolatey]: https://chocolatey.org/
-
-```bash
-choco install scrcpy
-choco install adb    # si aún no está instalado
-```
-
-Y en [Scoop]:
-
-```bash
-scoop install scrcpy
-scoop install adb    # si aún no está instalado
-```
-
-[Scoop]: https://scoop.sh
-
-También puedes [construir la aplicación manualmente][BUILD].
-
-
-### macOS
-
-La aplicación está disponible en [Homebrew]. Solo instalala:
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-Necesitarás `adb`, accesible desde `PATH`. Si aún no lo tienes:
-
-```bash
-brew install android-platform-tools
-```
-
-También está disponible en [MacPorts], que configurará el adb automáticamente:
-
-```bash
-sudo port install scrcpy
-```
-
-[MacPorts]: https://www.macports.org/
-
-
-También puedes [construir la aplicación manualmente][BUILD].
-
-
-## Ejecutar
-
-Enchufa el dispositivo Android, y ejecuta:
-
-```bash
-scrcpy
-```
-
-Acepta argumentos desde la línea de comandos, listados en:
-
-```bash
-scrcpy --help
-```
-
-## Características
-
-### Capturar configuración
-
-#### Reducir la definición
-
-A veces es útil reducir la definición de la imagen del dispositivo Android para aumentar el desempeño.
-
-Para limitar el ancho y la altura a un valor específico (ej. 1024):
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # versión breve
-```
-
-La otra dimensión es calculada para conservar el aspect ratio del dispositivo.
-De esta forma, un dispositivo en 1920×1080 será transmitido a 1024×576.
-
-
-#### Cambiar el bit-rate
-
-El bit-rate por defecto es 8 Mbps. Para cambiar el bit-rate del video (ej. a 2 Mbps):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # versión breve
-```
-
-#### Limitar los fps
-
-El fps puede ser limitado:
-
-```bash
-scrcpy --max-fps 15
-```
-
-Es oficialmente soportado desde Android 10, pero puede funcionar en versiones anteriores.
-
-#### Recortar
-
-La imagen del dispositivo puede ser recortada para transmitir solo una parte de la pantalla.
-
-Por ejemplo, puede ser útil para transmitir la imagen de un solo ojo del Oculus Go:
-
-```bash
-scrcpy --crop 1224:1440:0:0   # 1224x1440 con coordenadas de origen en (0,0)
-```
-
-Si `--max-size` también está especificado, el cambio de tamaño es aplicado después de cortar.
-
-
-#### Fijar la rotación del video
-
-
-Para fijar la rotación de la transmisión:
-
-```bash
-scrcpy --lock-video-orientation 0   # orientación normal
-scrcpy --lock-video-orientation 1   # 90° contrarreloj
-scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation 3   # 90° sentido de las agujas del reloj
-```
-
-Esto afecta la rotación de la grabación.
-
-La [ventana también puede ser rotada](#rotación) independientemente.
-
-
-#### Codificador
-
-Algunos dispositivos pueden tener más de una rotación, y algunos pueden causar problemas o errores. Es posible seleccionar un codificador diferente:
-
-```bash
-scrcpy --encoder OMX.qcom.video.encoder.avc
-```
-
-Para listar los codificadores disponibles, puedes pasar un nombre de codificador inválido, el error te dará los codificadores disponibles:
-
-```bash
-scrcpy --encoder _
-```
-
-### Grabación
-
-Es posible grabar la pantalla mientras se transmite:
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-Para grabar sin transmitir la pantalla:
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# interrumpe la grabación con Ctrl+C
-```
-
-"Skipped frames" son grabados, incluso si no son mostrados en tiempo real (por razones de desempeño). Los frames tienen _marcas de tiempo_ en el dispositivo, por lo que el "[packet delay
-variation]" no impacta el archivo grabado.
-
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-
-### Conexión
-
-#### Inalámbrica
-
-_Scrcpy_ usa `adb` para comunicarse con el dispositivo, y `adb` puede [conectarse] vía TCP/IP:
-
-1. Conecta el dispositivo al mismo Wi-Fi que tu computadora.
-2. Obtén la dirección IP del dispositivo, en Ajustes → Acerca del dispositivo → Estado, o ejecutando este comando:
-
-    ```bash
-    adb shell ip route | awk '{print $9}'
-    ```
-
-3. Habilita adb vía TCP/IP en el dispositivo: `adb tcpip 5555`.
-4. Desenchufa el dispositivo.
-5. Conéctate a tu dispositivo: `adb connect IP_DEL_DISPOSITIVO:5555` _(reemplaza `IP_DEL_DISPOSITIVO`)_.
-6. Ejecuta `scrcpy` con normalidad.
-
-Podría resultar útil reducir el bit-rate y la definición:
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # versión breve
-```
-
-[conectarse]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-#### Múltiples dispositivos
-
-Si hay muchos dispositivos listados en `adb devices`, será necesario especificar el _número de serie_:
-
-```bash
-scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # versión breve
-```
-
-Si el dispositivo está conectado por TCP/IP:
-
-```bash
-scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # versión breve
-```
-
-Puedes iniciar múltiples instancias de _scrcpy_ para múltiples dispositivos.
-
-#### Autoiniciar al detectar dispositivo
-
-Puedes utilizar [AutoAdb]:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
-
-#### Túnel SSH
-
-Para conectarse a un dispositivo remoto, es posible conectar un cliente local de `adb` a un servidor remoto `adb` (siempre y cuando utilicen la misma versión de protocolos _adb_):
-
-```bash
-adb kill-server    # cierra el servidor local adb en 5037
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# conserva este servidor abierto
-```
-
-Desde otra terminal:
-
-```bash
-scrcpy
-```
-
-Para evitar habilitar "remote port forwarding", puedes forzar una "forward connection" (nótese el argumento `-L` en vez de `-R`):
-
-```bash
-adb kill-server    # cierra el servidor local adb en 5037
-ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
-# conserva este servidor abierto
-```
-
-Desde otra terminal:
-
-```bash
-scrcpy --force-adb-forward
-```
-
-
-Al igual que las conexiones inalámbricas, puede resultar útil reducir la calidad:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-### Configuración de la ventana
-
-#### Título
-
-Por defecto, el título de la ventana es el modelo del dispositivo. Puede ser modificado:
-
-```bash
-scrcpy --window-title 'My device'
-```
-
-#### Posición y tamaño
-
-La posición y tamaño inicial de la ventana puede ser especificado:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-#### Sin bordes
-
-Para deshabilitar el diseño de la ventana:
-
-```bash
-scrcpy --window-borderless
-```
-
-#### Siempre adelante
-
-Para mantener la ventana de scrcpy siempre adelante:
-
-```bash
-scrcpy --always-on-top
-```
-
-#### Pantalla completa
-
-La aplicación puede ser iniciada en pantalla completa:
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # versión breve
-```
-
-Puede entrar y salir de la pantalla completa con la combinación <kbd>MOD</kbd>+<kbd>f</kbd>.
-
-#### Rotación
-
-Se puede rotar la ventana:
-
-```bash
-scrcpy --rotation 1
-```
-
-Los valores posibles son:
- - `0`: sin rotación
- - `1`: 90 grados contrarreloj
- - `2`: 180 grados
- - `3`: 90 grados en sentido de las agujas del reloj
-
-La rotación también puede ser modificada con la combinación de teclas <kbd>MOD</kbd>+<kbd>←</kbd> _(izquierda)_ y <kbd>MOD</kbd>+<kbd>→</kbd> _(derecha)_.
-
-Nótese que _scrcpy_ maneja 3 diferentes rotaciones:
- - <kbd>MOD</kbd>+<kbd>r</kbd> solicita al dispositivo cambiar entre vertical y horizontal (la aplicación en uso puede rechazarlo si no soporta la orientación solicitada).
- - [`--lock-video-orientation`](#fijar-la-rotación-del-video) cambia la rotación de la transmisión (la orientación del video enviado a la PC). Esto afecta a la grabación.
- - `--rotation` (o <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) rota solo el contenido de la imagen. Esto solo afecta a la imagen mostrada, no a la grabación.
-
-
-### Otras opciones menores
-
-#### Solo lectura ("Read-only")
-
-Para deshabilitar los controles (todo lo que interactúe con el dispositivo: eventos del teclado, eventos del mouse, arrastrar y soltar archivos):
-
-```bash
-scrcpy --no-control
-scrcpy -n  # versión breve
-```
-
-#### Pantalla
-
-Si múltiples pantallas están disponibles, es posible elegir cual transmitir:
-
-```bash
-scrcpy --display 1
-```
-
-Los ids de las pantallas se pueden obtener con el siguiente comando:
-
-```bash
-adb shell dumpsys display   # busque "mDisplayId=" en la respuesta
-```
-
-La segunda pantalla solo puede ser manejada si el dispositivo cuenta con Android 10 (en caso contrario será transmitida en el modo solo lectura).
-
-
-#### Permanecer activo
-
-Para evitar que el dispositivo descanse después de un tiempo mientras está conectado:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w  # versión breve
-```
-
-La configuración original se restaura al cerrar scrcpy.
-
-
-#### Apagar la pantalla
-
-Es posible apagar la pantalla mientras se transmite al iniciar con el siguiente comando:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S  # versión breve
-```
-
-O presionando <kbd>MOD</kbd>+<kbd>o</kbd> en cualquier momento.
-
-Para volver a prenderla, presione <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
-
-En Android, el botón de `POWER` siempre prende la pantalla. Por conveniencia, si `POWER` es enviado vía scrcpy (con click-derecho o <kbd>MOD</kbd>+<kbd>p</kbd>), esto forzará a apagar la pantalla con un poco de atraso (en la mejor de las situaciones). El botón físico `POWER` seguirá prendiendo la pantalla.
-
-También puede resultar útil para evitar que el dispositivo entre en inactividad:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw  # versión breve
-```
-
-
-#### Renderizar frames vencidos
-
-Por defecto, para minimizar la latencia, _scrcpy_ siempre renderiza el último frame disponible decodificado, e ignora cualquier frame anterior.
-
-Para forzar el renderizado de todos los frames (a costo de posible aumento de latencia), use:
-
-```bash
-scrcpy --render-expired-frames
-```
-
-#### Mostrar clicks
-
-Para presentaciones, puede resultar útil mostrar los clicks físicos (en el dispositivo físicamente).
-
-Android provee esta opción en _Opciones para desarrolladores_.
-
-_Scrcpy_ provee una opción para habilitar esta función al iniciar la aplicación y restaurar el valor original al salir:
-
-```bash
-scrcpy --show-touches
-scrcpy -t  # versión breve
-```
-
-Nótese que solo muestra los clicks _físicos_ (con el dedo en el dispositivo).
-
-
-#### Desactivar protector de pantalla
-
-Por defecto, scrcpy no evita que el protector de pantalla se active en la computadora.
-
-Para deshabilitarlo:
-
-```bash
-scrcpy --disable-screensaver
-```
-
-
-### Control
-
-#### Rotar pantalla del dispositivo
-
-Presione <kbd>MOD</kbd>+<kbd>r</kbd> para cambiar entre posición vertical y horizontal.
-
-Nótese que solo rotará si la aplicación activa soporta la orientación solicitada.
-
-#### Copiar y pegar
-
-Cuando que el portapapeles de Android cambia, automáticamente se sincroniza al portapapeles de la computadora.
-
-Cualquier shortcut con <kbd>Ctrl</kbd> es enviado al dispositivo. En particular:
- - <kbd>Ctrl</kbd>+<kbd>c</kbd> normalmente copia
- - <kbd>Ctrl</kbd>+<kbd>x</kbd> normalmente corta
- - <kbd>Ctrl</kbd>+<kbd>v</kbd> normalmente pega (después de la sincronización de portapapeles entre la computadora y el dispositivo)
-
-Esto normalmente funciona como es esperado.
-
-Sin embargo, este comportamiento depende de la aplicación en uso. Por ejemplo, _Termux_ envía SIGINT con <kbd>Ctrl</kbd>+<kbd>c</kbd>, y _K-9 Mail_ crea un nuevo mensaje.
-
-Para copiar, cortar y pegar, en tales casos (solo soportado en Android >= 7):
- - <kbd>MOD</kbd>+<kbd>c</kbd> inyecta `COPY`
- - <kbd>MOD</kbd>+<kbd>x</kbd> inyecta `CUT`
- - <kbd>MOD</kbd>+<kbd>v</kbd> inyecta `PASTE` (después de la sincronización de portapapeles entre la computadora y el dispositivo)
-
-Además, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permite inyectar el texto en el portapapeles de la computadora como una secuencia de teclas. Esto es útil cuando el componente no acepta pegado de texto (por ejemplo en _Termux_), pero puede romper caracteres no pertenecientes a ASCII.
-
-**AVISO:** Pegar de la computadora al dispositivo (tanto con <kbd>Ctrl</kbd>+<kbd>v</kbd> o <kbd>MOD</kbd>+<kbd>v</kbd>) copia el contenido al portapapeles del dispositivo. Como consecuencia, cualquier aplicación de Android puede leer su contenido. Debería evitar pegar contenido sensible (como contraseñas) de esta forma.
-
-Algunos dispositivos no se comportan como es esperado al establecer el portapapeles programáticamente. La opción `--legacy-paste` está disponible para cambiar el comportamiento de <kbd>Ctrl</kbd>+<kbd>v</kbd> y <kbd>MOD</kbd>+<kbd>v</kbd> para que también inyecten el texto del portapapeles de la computadora como una secuencia de teclas (de la misma forma que <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
-
-#### Pellizcar para zoom
-
-Para simular "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-y-mover_.
-
-Más precisamente, mantén <kbd>Ctrl</kbd> mientras presionas botón izquierdo. Hasta que no se suelte el botón, todos los movimientos del mouse cambiarán el tamaño y rotación del contenido (si es soportado por la app en uso) respecto al centro de la pantalla.
-
-Concretamente, scrcpy genera clicks adicionales con un "dedo virtual" en la posición invertida respecto al centro de la pantalla.
-
-
-#### Preferencias de inyección de texto
-
-Existen dos tipos de [eventos][textevents] generados al escribir texto:
- - _key events_, marcando si la tecla es presionada o soltada;
- - _text events_, marcando si un texto fue introducido.
-
-Por defecto, las letras son inyectadas usando _key events_, para que el teclado funcione como es esperado en juegos (típicamente las teclas WASD).
-
-Pero esto puede [causar problemas][prefertext]. Si encuentras tales problemas, los puedes evitar con:
-
-```bash
-scrcpy --prefer-text
-```
-
-(Pero esto romperá el comportamiento del teclado en los juegos)
-
-[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
-[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-
-
-#### Repetir tecla
-
-Por defecto, mantener una tecla presionada genera múltiples _key events_. Esto puede causar problemas de desempeño en algunos juegos, donde estos eventos no tienen sentido de todos modos.
-
-Para evitar enviar _key events_ repetidos:
-
-```bash
-scrcpy --no-key-repeat
-```
-
-
-#### Botón derecho y botón del medio
-
-Por defecto, botón derecho ejecuta RETROCEDER (o ENCENDIDO) y botón del medio INICIO. Para inhabilitar estos atajos y enviar los clicks al dispositivo:
-
-```bash
-scrcpy --forward-all-clicks
-```
-
-
-### Arrastrar y soltar archivos
-
-#### Instalar APKs
-
-Para instalar un APK, arrastre y suelte el archivo APK (terminado en `.apk`) a la ventana de _scrcpy_.
-
-No hay respuesta visual, un mensaje se escribirá en la consola.
-
-
-#### Enviar archivos al dispositivo
-
-Para enviar un archivo a `/sdcard/` en el dispositivo, arrastre y suelte un archivo (no APK) a la ventana de _scrcpy_.
-
-No hay respuesta visual, un mensaje se escribirá en la consola.
-
-El directorio de destino puede ser modificado al iniciar:
-
-```bash
-scrcpy --push-target=/sdcard/Download/
-```
-
-
-### Envío de Audio
-
-_Scrcpy_ no envía el audio. Use [sndcpy].
-
-También lea [issue #14].
-
-[sndcpy]: https://github.com/rom1v/sndcpy
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
-
-
-## Atajos
-
-En la siguiente lista, <kbd>MOD</kbd> es el atajo modificador. Por defecto es <kbd>Alt</kbd> (izquierdo) o <kbd>Super</kbd> (izquierdo).
-
-Se puede modificar usando `--shortcut-mod`. Las posibles teclas son `lctrl` (izquierdo), `rctrl` (derecho), `lalt` (izquierdo), `ralt` (derecho), `lsuper` (izquierdo) y `rsuper` (derecho). Por ejemplo:
-
-```bash
-# use RCtrl para los atajos
-scrcpy --shortcut-mod=rctrl
-
-# use tanto LCtrl+LAlt o LSuper para los atajos
-scrcpy --shortcut-mod=lctrl+lalt,lsuper
-```
-
-_<kbd>[Super]</kbd> es generalmente la tecla <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
-
-[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
-
- | Acción                                      |   Atajo
- | ------------------------------------------- |:-----------------------------
- | Alterne entre pantalla compelta             | <kbd>MOD</kbd>+<kbd>f</kbd>
- | Rotar pantalla hacia la izquierda           | <kbd>MOD</kbd>+<kbd>←</kbd> _(izquierda)_
- | Rotar pantalla hacia la derecha             | <kbd>MOD</kbd>+<kbd>→</kbd> _(derecha)_
- | Ajustar ventana a 1:1 ("pixel-perfect")     | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Ajustar ventana para quitar los bordes negros| <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doble click¹_
- | Click en `INICIO`                           | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Botón del medio_
- | Click en `RETROCEDER`                       | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Botón derecho²_
- | Click en `CAMBIAR APLICACIÓN`               | <kbd>MOD</kbd>+<kbd>s</kbd>
- | Click en `MENÚ` (desbloquear pantalla)      | <kbd>MOD</kbd>+<kbd>m</kbd>
- | Click en `SUBIR VOLUMEN`                    | <kbd>MOD</kbd>+<kbd>↑</kbd> _(arriba)_
- | Click en `BAJAR VOLUME`                     | <kbd>MOD</kbd>+<kbd>↓</kbd> _(abajo)_
- | Click en `ENCENDIDO`                        | <kbd>MOD</kbd>+<kbd>p</kbd>
- | Encendido                                   | _Botón derecho²_
- | Apagar pantalla (manteniendo la transmisión)| <kbd>MOD</kbd>+<kbd>o</kbd>
- | Encender pantalla                           | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
- | Rotar pantalla del dispositivo              | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Abrir panel de notificaciones               | <kbd>MOD</kbd>+<kbd>n</kbd>
- | Cerrar panel de notificaciones              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copiar al portapapeles³                     | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Cortar al portapapeles³                     | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Synchronizar portapapeles y pegar³          | <kbd>MOD</kbd>+<kbd>v</kbd>
- | inyectar texto del portapapeles de la PC    | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
- | Habilitar/Deshabilitar contador de FPS (en stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Pellizcar para zoom                         | <kbd>Ctrl</kbd>+_click-y-mover_
-
-_¹Doble click en los bordes negros para eliminarlos._  
-_²Botón derecho enciende la pantalla si estaba apagada, sino ejecuta RETROCEDER._  
-_³Solo en Android >= 7._
-
-Todos los atajos <kbd>Ctrl</kbd>+_tecla_ son enviados al dispositivo para que sean manejados por la aplicación activa.
-
-
-## Path personalizado
-
-Para usar un binario de _adb_ en particular, configure el path `ADB` en las variables de entorno:
-
-```bash
-ADB=/path/to/adb scrcpy
-```
-
-Para sobreescribir el path del archivo `scrcpy-server`, configure el path en `SCRCPY_SERVER_PATH`.
-
-
-## ¿Por qué _scrcpy_?
-
-Un colega me retó a encontrar un nombre tan impronunciable como [gnirehtet].
-
-[`strcpy`] copia un **str**ing; `scrcpy` copia un **scr**een.
-
-[gnirehtet]: https://github.com/Genymobile/gnirehtet
-[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
-
-
-## ¿Cómo construir (BUILD)?
-
-Véase [BUILD] (en inglés).
-
-
-## Problemas generales
-
-Vea las [preguntas frecuentes (en inglés)](FAQ.md).
-
-
-## Desarrolladores
-
-Lea la [hoja de desarrolladores (en inglés)](DEVELOP.md).
-
-
-## Licencia
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2021 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## Artículos
-
-- [Introducing scrcpy][article-intro] (en inglés)
-- [Scrcpy now works wirelessly][article-tcpip] (en inglés)
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/

README.tr.md

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

README.zh-Hans.md

@@ -1,865 +0,0 @@
-_Only the original [README](README.md) is guaranteed to be up-to-date._
-
-只有原版的[README](README.md)会保持最新。
-
-Current version is based on [65b023a]
-
-本文根据[65b023a]进行翻译。
-
-[65b023a]: https://github.com/Genymobile/scrcpy/blob/65b023ac6d586593193fd5290f65e25603b68e02/README.md
-
-# scrcpy (v1.20)
-
-<img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
-
-本应用程序可以显示并控制通过 USB (或 [TCP/IP][article-tcpip]) 连接的安卓设备，且不需要任何 _root_ 权限。本程序支持 _GNU/Linux_, _Windows_ 和 _macOS_。
-
-![screenshot](assets/screenshot-debian-600.jpg)
-
-本应用专注于：
-
- - **轻量**： 原生，仅显示设备屏幕
- - **性能**： 30~120fps，取决于设备
- - **质量**： 分辨率可达 1920×1080 或更高
- - **低延迟**： [35~70ms][lowlatency]
- - **快速启动**： 最快 1 秒内即可显示第一帧
- - **无侵入性**： 不会在设备上遗留任何程序
- - **用户利益**： 无需帐号，无广告，无需联网
- - **自由**： 自由和开源软件
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-功能：
- - [屏幕录制](#屏幕录制)
- - 镜像时[关闭设备屏幕](#关闭设备屏幕)
- - 双向[复制粘贴](#复制粘贴)
- - [可配置显示质量](#采集设置)
- - 以设备屏幕[作为摄像头(V4L2)](#v4l2loopback) (仅限 Linux)
- - [模拟物理键盘 (HID)](#物理键盘模拟-hid) (仅限 Linux)
- - 更多 ……
-
-## 系统要求
-
-安卓设备最低需要支持 API 21 (Android 5.0)。
-
-确保设备已[开启 adb 调试][enable-adb]。
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-在某些设备上，还需要开启[额外的选项][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: `apt install scrcpy`
- - Windows: [下载][direct-win64]
- - macOS: `brew install scrcpy`
-
-从源代码编译: [构建][BUILD] ([简化过程][BUILD_simple])
-
-[BUILD]: BUILD.md
-[BUILD_simple]: BUILD.md#simple
-
-### 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] ([简化过程][BUILD_simple])。
-
-
-### Windows
-
-在 Windows 上，为简便起见，我们提供包含了所有依赖 (包括 `adb`) 的预编译包。
-
- - [README](README.md#windows)
-
-也可以使用 [Chocolatey]：
-
-[Chocolatey]: https://chocolatey.org/
-
-```bash
-choco install scrcpy
-choco install adb    # 如果还没有 adb
-```
-
-或者 [Scoop]:
-
-```bash
-scoop install scrcpy
-scoop install adb    # 如果还没有 adb
-```
-
-[Scoop]: https://scoop.sh
-
-您也可以[自行构建][BUILD]。
-
-
-### macOS
-
-本程序已发布到 [Homebrew]。直接安装即可：
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-你还需要在 `PATH` 内有 `adb`。如果还没有：
-
-```bash
-brew install android-platform-tools
-```
-
-或者通过 [MacPorts]，该方法同时设置好 adb：
-
-```bash
-sudo port install scrcpy
-```
-
-[MacPorts]: https://www.macports.org/
-
-您也可以[自行构建][BUILD]。
-
-
-## 运行
-
-连接安卓设备，然后执行：
-
-```bash
-scrcpy
-```
-
-本程序支持命令行参数，查看参数列表：
-
-```bash
-scrcpy --help
-```
-
-## 功能介绍
-
-### 采集设置
-
-#### 降低分辨率
-
-有时候，可以通过降低镜像的分辨率来提高性能。
-
-要同时限制宽度和高度到某个值 (例如 1024)：
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # 简写
-```
-
-另一边会被按比例缩小以保持设备的显示比例。这样，1920×1080 分辨率的设备会以 1024×576 的分辨率进行镜像。
-
-
-#### 修改码率
-
-默认码率是 8 Mbps。改变视频码率 (例如改为 2 Mbps)：
-
-```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 停止录制
-```
-
-录制时会包含“被跳过的帧”，即使它们由于性能原因没有实时显示。设备会为每一帧打上 _时间戳_ ，所以 [包时延抖动][packet delay variation] 不会影响录制的文件。
-
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-
-#### v4l2loopback
-
-在 Linux 上，可以将视频流发送至 v4l2 回环 (loopback) 设备，因此可以使用任何 v4l2 工具像摄像头一样打开安卓设备。
-
-需安装 `v4l2loopback` 模块：
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-创建一个 v4l2 设备：
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-这样会在 `/dev/videoN` 创建一个新的视频设备，其中 `N` 是整数。 ([更多选项](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/
-
-
-#### 缓冲
-
-可以加入缓冲，会增加延迟，但可以减少抖动 (见 [#2464])。
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-对于显示缓冲：
-
-```bash
-scrcpy --display-buffer=50  # 为显示增加 50 毫秒的缓冲
-```
-
-对于 V4L2 漏:
-
-```bash
-scrcpy --v4l2-buffer=500    # 为 v4l2 漏增加 500 毫秒的缓冲
-```
-
-
-### 连接
-
-#### 无线
-
-_Scrcpy_ 使用 `adb` 与设备通信，并且 `adb` 支持通过 TCP/IP [连接]到设备:
-
-1. 将设备和电脑连接至同一 Wi-Fi。
-2. 打开 设置 → 关于手机 → 状态信息，获取设备的 IP 地址，也可以执行以下的命令：
-
-    ```bash
-    adb shell ip route | awk '{print $9}'
-    ```
-
-3. 启用设备的网络 adb 功能： `adb tcpip 5555`。
-4. 断开设备的 USB 连接。
-5. 连接到您的设备：`adb connect DEVICE_IP:5555` _(将 `DEVICE_IP` 替换为设备 IP)_。
-6. 正常运行 `scrcpy`。
-
-可能降低码率和分辨率会更好一些：
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # 简写
-```
-
-[连接]: 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
-```
-
-若要不使用远程端口转发，可以强制使用正向连接 (注意 `-L` 和 `-R` 的区别)：
-
-```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
-```
-
-#### 保持窗口在最前
-
-您可以通过如下命令保持窗口在最前面：
-
-```bash
-scrcpy --always-on-top
-```
-
-#### 全屏
-
-您可以通过如下命令直接全屏启动 scrcpy：
-
-```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_ 中有三类旋转方向：
- - <kbd>MOD</kbd>+<kbd>r</kbd> 请求设备在竖屏和横屏之间切换 (如果前台应用程序不支持请求的朝向，可能会拒绝该请求)。
- - [`--lock-video-orientation`](#锁定屏幕方向) 改变镜像的朝向 (设备传输到电脑的画面的朝向)。这会影响录制。
- - `--rotation` (或 <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) 只旋转窗口的内容。这只影响显示，不影响录制。
-
-
-### 其他镜像设置
-
-#### 只读
-
-禁用电脑对设备的控制 (任何可与设备交互的方式：如键盘输入、鼠标事件和文件拖放)：
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-#### 显示屏
-
-如果设备有多个显示屏，可以选择要镜像的显示屏：
-
-```bash
-scrcpy --display 1
-```
-
-可以通过如下命令列出所有显示屏的 id：
-
-```
-adb shell dumpsys display   # 在输出中搜索 “mDisplayId=”
-```
-
-控制第二显示屏需要设备运行 Android 10 或更高版本 (否则将在只读状态下镜像)。
-
-
-#### 保持常亮
-
-阻止设备在连接时一段时间后休眠：
-
-```bash
-scrcpy --stay-awake
-scrcpy -w
-```
-
-scrcpy 关闭时会恢复设备原来的设置。
-
-
-#### 关闭设备屏幕
-
-可以通过以下的命令行参数在关闭设备屏幕的状态下进行镜像：
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-或者在任何时候按 <kbd>MOD</kbd>+<kbd>o</kbd>。
-
-要重新打开屏幕，按下 <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>。
-
-在Android上，`电源` 按钮始终能把屏幕打开。为了方便，对于在 _scrcpy_ 中发出的 `电源` 事件 (通过鼠标右键或 <kbd>MOD</kbd>+<kbd>p</kbd>)，会 (尽最大的努力) 在短暂的延迟后将屏幕关闭。设备上的 `电源` 按钮仍然能打开设备屏幕。
-
-还可以同时阻止设备休眠：
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw
-```
-
-#### 退出时息屏
-
-scrcpy 退出时关闭设备屏幕：
-
-```bash
-scrcpy --power-off-on-close
-```
-
-#### 显示触摸
-
-在演示时，可能会需要显示 (在物理设备上的) 物理触摸点。
-
-Android 在 _开发者选项_ 中提供了这项功能。
-
-_Scrcpy_ 提供一个选项可以在启动时开启这项功能并在退出时恢复初始设置：
-
-```bash
-scrcpy --show-touches
-scrcpy -t
-```
-
-请注意这项功能只能显示 _物理_ 触摸 (用手指在屏幕上的触摸)。
-
-
-#### 关闭屏保
-
-_Scrcpy_ 默认不会阻止电脑上开启的屏幕保护。
-
-关闭屏幕保护：
-
-```bash
-scrcpy --disable-screensaver
-```
-
-
-### 输入控制
-
-#### 旋转设备屏幕
-
-使用 <kbd>MOD</kbd>+<kbd>r</kbd> 在竖屏和横屏模式之间切换。
-
-需要注意的是，只有在前台应用程序支持所要求的模式时，才会进行切换。
-
-#### 复制粘贴
-
-每次安卓的剪贴板变化时，其内容都会被自动同步到电脑的剪贴板上。
-
-所有的 <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>) 都会将内容复制到设备的剪贴板。如此，任何安卓应用程序都能读取到。您应避免将敏感内容 (如密码) 通过这种方式粘贴。
-
-一些设备不支持通过程序设置剪贴板。通过 `--legacy-paste` 选项可以修改 <kbd>Ctrl</kbd>+<kbd>v</kbd> 和 <kbd>MOD</kbd>+<kbd>v</kbd> 的工作方式，使它们通过按键事件 (同 <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>) 来注入电脑剪贴板内容。
-
-#### 双指缩放
-
-模拟“双指缩放”：<kbd>Ctrl</kbd>+_按住并移动鼠标_。
-
-更准确的说，在按住鼠标左键时按住 <kbd>Ctrl</kbd>。直到松开鼠标左键，所有鼠标移动将以屏幕中心为原点，缩放或旋转内容 (如果应用支持)。
-
-实际上，_scrcpy_ 会在关于屏幕中心对称的位置上用“虚拟手指”发出触摸事件。
-
-#### 物理键盘模拟 (HID)
-
-默认情况下，scrcpy 使用安卓按键或文本注入，这在任何情况都可以使用，但仅限于ASCII字符。
-
-在 Linux 上，scrcpy 可以模拟为 Android 上的物理 USB 键盘，以提供更好地输入体验 (使用 [USB HID over AOAv2][hid-aoav2])：禁用虚拟键盘，并适用于任何字符和输入法。
-
-[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
-
-不过，这种方法仅支持 USB 连接以及 Linux平台。
-
-启用 HID 模式：
-
-```bash
-scrcpy --hid-keyboard
-scrcpy -K  # 简写
-```
-
-如果失败了 (如设备未通过 USB 连接)，则自动回退至默认模式 (终端中会输出日志)。这即允许通过 USB 和 TCP/IP 连接时使用相同的命令行参数。
-
-在这种模式下，原始按键事件 (扫描码) 被发送给设备，而与宿主机按键映射无关。因此，若键盘布局不匹配，需要在 Android 设备上进行配置，具体为 设置 → 系统 → 语言和输入法 → [实体键盘]。
-
-[Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
-
-#### 文本注入偏好
-
-打字的时候，系统会产生两种[事件][textevents]：
- - _按键事件_ ，代表一个按键被按下或松开。
- - _文本事件_ ，代表一个字符被输入。
-
-程序默认使用按键事件来输入字母。只有这样，键盘才会在游戏中正常运作 (例如 WASD 键)。
-
-但这也有可能[造成一些问题][prefertext]。如果您遇到了问题，可以通过以下方式避免：
-
-```bash
-scrcpy --prefer-text
-```
-
-(这会导致键盘在游戏中工作不正常)
-
-该选项不影响 HID 键盘 (该模式下，所有按键都发送为扫描码)。
-
-[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
-```
-
-该选项不影响 HID 键盘 (该模式下，按键重复由 Android 直接管理)。
-
-#### 右键和中键
-
-默认状态下，右键会触发返回键 (或电源键开启)，中键会触发 HOME 键。要禁用这些快捷键并把所有点击转发到设备：
-
-```bash
-scrcpy --forward-all-clicks
-```
-
-
-### 文件拖放
-
-#### 安装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> 是快捷键的修饰键。
-默认是 (左) <kbd>Alt</kbd> 或 (左) <kbd>Super</kbd>。
-
-您可以使用 `--shortcut-mod` 来修改。可选的按键有 `lctrl`、`rctrl`、`lalt`、`ralt`、`lsuper` 和 `rsuper`。例如：
-
-```bash
-# 使用右 Ctrl 键
-scrcpy --shortcut-mod=rctrl
-
-# 使用左 Ctrl 键 + 左 Alt 键，或 Super 键
-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> \| _双击左键¹_
- | 点按 `主屏幕`                     | <kbd>MOD</kbd>+<kbd>h</kbd> \| _中键_
- | 点按 `返回`                       | <kbd>MOD</kbd>+<kbd>b</kbd> \| _右键²_
- | 点按 `切换应用`                   | <kbd>MOD</kbd>+<kbd>s</kbd> \| _第4键³_
- | 点按 `菜单` (解锁屏幕)            | <kbd>MOD</kbd>+<kbd>m</kbd>
- | 点按 `音量+`                      | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上箭头)_
- | 点按 `音量-`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下箭头)_
- | 点按 `电源`                       | <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>+_按住并移动鼠标_
- | 拖放 APK 文件                     | 从电脑安装 APK 文件
- | 拖放非 APK 文件                   | [将文件推送至设备](#push-file-to-device)
-
-_¹双击黑边可以去除黑边。_  
-_²点击鼠标右键将在屏幕熄灭时点亮屏幕，其余情况则视为按下返回键 。_  
-_³鼠标的第4键和第5键。_  
-_⁴需要安卓版本 Android >= 7。_
-
-有重复按键的快捷键通过松开再按下一个按键来进行，如“展开设置面板”：
-
- 1. 按下 <kbd>MOD</kbd> 不放。
- 2. 双击 <kbd>n</kbd>。
- 3. 松开 <kbd>MOD</kbd>。
-
-所有的 <kbd>Ctrl</kbd>+_按键_ 的快捷键都会被转发到设备，所以会由当前应用程序进行处理。
-
-
-## 自定义路径
-
-要使用指定的 _adb_ 二进制文件，可以设置环境变量 `ADB`：
-
-```bash
-ADB=/path/to/adb scrcpy
-```
-
-要覆盖 `scrcpy-server` 的路径，可以设置 `SCRCPY_SERVER_PATH`。
-
-要覆盖图标，可以设置其路径至 `SCRCPY_ICON_PATH`。
-
-
-## 为什么叫 _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]。
-
-
-## 常见问题
-
-请查看 [FAQ](FAQ.md)。
-
-
-## 开发者
-
-请查看[开发者页面]。
-
-[开发者页面]: DEVELOP.md
-
-
-## 许可协议
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2021 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## 相关文章
-
-- [Introducing scrcpy][article-intro]
-- [Scrcpy now works wirelessly][article-tcpip]
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/

README.zh-Hant.md

@@ -1,702 +0,0 @@
-_Only the original [README](README.md) is guaranteed to be up-to-date._
-
-_只有原版的 [README](README.md)是保證最新的。_
-
-
-本文件翻譯時點: [521f2fe](https://github.com/Genymobile/scrcpy/commit/521f2fe994019065e938aa1a54b56b4f10a4ac4a#diff-04c6e90faac2675aa89e2176d2eec7d8)
-
-
-# scrcpy (v1.15)
-
-Scrcpy 可以透過 USB、或是 [TCP/IP][article-tcpip] 來顯示或控制 Android 裝置。且 scrcpy 不需要 _root_ 權限。
-
-Scrcpy 目前支援 _GNU/Linux_、_Windows_ 和 _macOS_。
-
-![screenshot](assets/screenshot-debian-600.jpg)
-
-特色:
-
- - **輕量** (只顯示裝置螢幕)
- - **效能** (30~60fps)
- - **品質** (1920×1080 或更高)
- - **低延遲** ([35~70ms][lowlatency])
- - **快速啟動** (~1 秒就可以顯示第一個畫面)
- - **非侵入性** (不安裝、留下任何東西在裝置上)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-
-## 需求
-
-Android 裝置必須是 API 21+ (Android 5.0+)。
-
-請確認裝置上的 [adb 偵錯 (通常位於開發者模式內)][enable-adb] 已啟用。
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-
-在部分的裝置上，你也必須啟用[特定的額外選項][control]才能使用鍵盤和滑鼠控制。
-
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-## 下載/獲取軟體
-
-
-### 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
-
-你也可以自己[編譯 _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
-
-你也可以自己[編譯 _Scrcpy_][BUILD]。
-
-
-### macOS
-
-_Scrcpy_ 可以在 [Homebrew] 上直接安裝:
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-由於執行期間需要可以藉由 `PATH` 存取 `adb` 。如果還沒有安裝 `adb` 可以使用下列方式安裝:
-
-```bash
-brew cask install android-platform-tools
-```
-
-你也可以自己[編譯 _Scrcpy_][BUILD]。
-
-
-## 執行
-
-將電腦和你的 Android 裝置連線，然後執行:
-
-```bash
-scrcpy
-```
-
-_Scrcpy_ 可以接受命令列參數。輸入下列指令就可以瀏覽可以使用的命令列參數:
-
-```bash
-scrcpy --help
-```
-
-
-## 功能
-
-> 以下說明中，有關快捷鍵的說明可能會出現 <kbd>MOD</kbd> 按鈕。相關說明請參見[快捷鍵]內的說明。
-
-[快捷鍵]: #快捷鍵
-
-### 畫面擷取
-
-#### 縮小尺寸
-
-使用比較低的解析度來投放 Android 裝置在某些情況可以提升效能。
-
-限制寬和高的最大值(例如: 1024):
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # 縮短版本
-```
-
-比較小的參數會根據螢幕比例重新計算。
-根據上面的範例，1920x1080 會被縮小成 1024x576。
-
-
-#### 更改 bit-rate
-
-預設的 bit-rate 是 8 Mbps。如果要更改 bit-rate (例如: 2 Mbps):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # 縮短版本
-```
-
-#### 限制 FPS
-
-限制畫面最高的 FPS:
-
-```bash
-scrcpy --max-fps 15
-```
-
-僅在 Android 10 後正式支援，不過也有可能可以在 Android 10 以前的版本使用。
-
-#### 裁切
-
-裝置的螢幕可以裁切。如此一來，鏡像出來的螢幕就只會是原本的一部份。
-
-假如只要鏡像 Oculus Go 的其中一隻眼睛:
-
-```bash
-scrcpy --crop 1224:1440:0:0   # 位於 (0,0)，大小1224x1440
-```
-
-如果 `--max-size` 也有指定的話，裁切後才會縮放。
-
-
-#### 鎖定影像方向
-
-
-如果要鎖定鏡像影像方向:
-
-```bash
-scrcpy --lock-video-orientation 0   # 原本的方向
-scrcpy --lock-video-orientation 1   # 逆轉 90°
-scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation 3   # 順轉 90°
-```
-
-這會影響錄影結果的影像方向。
-
-
-### 錄影
-
-鏡像投放螢幕的同時也可以錄影:
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-如果只要錄影，不要投放螢幕鏡像的話:
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# 用 Ctrl+C 停止錄影
-```
-
-就算有些幀為了效能而被跳過，它們還是一樣會被錄製。
-
-裝置上的每一幀都有時間戳記，所以 [封包延遲 (Packet Delay Variation, PDV)][packet delay variation] 並不會影響錄影的檔案。
-
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-
-### 連線
-
-#### 無線
-
-_Scrcpy_ 利用 `adb` 和裝置通訊，而 `adb` 可以[透過 TCP/IP 連結][connect]:
-
-1. 讓電腦和裝置連到同一個 Wi-Fi。
-2. 獲取手機的 IP 位址(設定 → 關於手機 → 狀態).
-3. 啟用裝置上的 `adb over TCP/IP`: `adb tcpip 5555`.
-4. 拔掉裝置上的線。
-5. 透過 TCP/IP 連接裝置: `adb connect DEVICE_IP:5555` _(把 `DEVICE_IP` 換成裝置的IP位址)_.
-6. 和平常一樣執行 `scrcpy`。
-
-如果效能太差，可以降低 bit-rate 和解析度:
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # 縮短版本
-```
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-#### 多裝置
-
-如果 `adb devices` 內有多個裝置，則必須附上 _serial_:
-
-```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 tunnel
-
-本地的 `adb` 可以連接到遠端的 `adb` 伺服器(假設兩者使用相同版本的 _adb_ 通訊協定)，以連接到遠端裝置:
-
-```bash
-adb kill-server    # 停止在 Port 5037 的本地 adb 伺服
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# 保持開啟
-```
-
-從另外一個終端機:
-
-```bash
-scrcpy
-```
-
-如果要避免啟用 remote port forwarding，你可以強制它使用 forward connection (注意 `-L` 和 `-R` 的差別):
-
-```bash
-adb kill-server    # 停止在 Port 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> 要求裝置在垂直、水平之間旋轉 (目前運行中的 App 有可能會因為不支援而拒絕)。
- - `--lock-video-orientation` 修改鏡像的方向 (裝置傳給電腦的影像)。這會影響錄影結果的影像方向。
- - `--rotation` (或是 <kbd>MOD</kbd>+<kbd>←</kbd> / <kbd>MOD</kbd>+<kbd>→</kbd>) 只旋轉視窗的內容。這只會影響鏡像結果，不會影響錄影結果。
-
-
-### 其他鏡像選項
-
-#### 唯讀
-
-停用所有控制，包含鍵盤輸入、滑鼠事件、拖放檔案:
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-#### 顯示螢幕
-
-如果裝置有複數個螢幕，可以指定要鏡像哪個螢幕:
-
-```bash
-scrcpy --display 1
-```
-
-可以透過下列指令獲取螢幕 ID:
-
-```
-adb shell dumpsys display   # 找輸出結果中的 "mDisplayId="
-```
-
-第二螢幕只有在 Android 10+ 時可以控制。如果不是 Android 10+，螢幕就會在唯讀狀態下投放。
-
-
-#### 保持清醒
-
-如果要避免裝置在連接狀態下進入睡眠:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w
-```
-
-_scrcpy_ 關閉後就會回復成原本的設定。
-
-
-#### 關閉螢幕
-
-鏡像開始時，可以要求裝置關閉螢幕:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-或是在任何時候輸入 <kbd>MOD</kbd>+<kbd>o</kbd>。
-
-如果要開啟螢幕，輸入 <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>。
-
-在 Android 上，`POWER` 按鈕總是開啟螢幕。
-
-為了方便，如果 `POWER` 是透過 scrcpy 轉送 (右鍵 或 <kbd>MOD</kbd>+<kbd>p</kbd>)的話，螢幕將會在短暫的延遲後關閉。
-
-實際在手機上的 `POWER` 還是會開啟螢幕。
-
-防止裝置進入睡眠狀態:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw
-```
-
-
-#### 顯示過期的幀
-
-為了降低延遲， _scrcpy_ 預設只會顯示最後解碼的幀，並且拋棄所有在這之前的幀。
-
-如果要強制顯示所有的幀 (有可能會拉高延遲)，輸入:
-
-```bash
-scrcpy --render-expired-frames
-```
-
-#### 顯示觸控點
-
-對於要報告的人來說，顯示裝置上的實際觸控點有時候是有幫助的。
-
-Android 在_開發者選項_中有提供這個功能。
-
-_Scrcpy_ 可以在啟動時啟用這個功能，並且在停止後恢復成原本的設定:
-
-```bash
-scrcpy --show-touches
-scrcpy -t
-```
-
-這個選項只會顯示**實際觸碰在裝置上的觸碰點**。
-
-
-### 輸入控制
-
-
-#### 旋轉裝置螢幕
-
-輸入 <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> 注入 `複製`
- - <kbd>MOD</kbd>+<kbd>x</kbd> 注入 `剪下`
- - <kbd>MOD</kbd>+<kbd>v</kbd> 注入 `貼上` (在電腦的剪貼簿與裝置上的剪貼簿同步之後)
-
-另外，<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> 則是以一連串的按鍵事件貼上電腦剪貼簿中的內容。當元件不允許文字貼上 (例如 _Termux_) 時，這就很有用。不過，這在非 ASCII 內容上就無法使用。
-
-**警告:** 貼上電腦的剪貼簿內容 (無論是從 <kbd>Ctrl</kbd>+<kbd>v</kbd> 或 <kbd>MOD</kbd>+<kbd>v</kbd>) 時，會複製剪貼簿中的內容至裝置的剪貼簿上。這會讓所有 Android 程式讀取剪貼簿的內容。請避免貼上任何敏感內容 (像是密碼)。
-
-
-#### 文字輸入偏好
-
-輸入文字時，有兩種[事件][textevents]會被觸發:
- - _鍵盤事件 (key events)_，代表有一個按鍵被按下或放開
- - _文字事件 (text events)_，代表有一個文字被輸入
-
-預設上，文字是被以鍵盤事件 (key 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
-```
-
-
-### 檔案
-
-#### 安裝 APK
-
-如果要安裝 APK ，拖放一個 APK 檔案 (以 `.apk` 為副檔名) 到 _scrcpy_ 的視窗上。
-
-視窗上不會有任何反饋；結果會顯示在命令列中。
-
-
-#### 推送檔案至裝置
-
-如果要推送檔案到裝置上的 `/sdcard/` ，拖放一個非 APK 檔案 (**不**以 `.apk` 為副檔名) 到 _scrcpy_ 的視窗上。
-
-視窗上不會有任何反饋；結果會顯示在命令列中。
-
-推送檔案的目標路徑可以在啟動時指定:
-
-```bash
-scrcpy --push-target /sdcard/foo/bar/
-```
-
-
-### 音訊轉送
-
-_scrcpy_ **不**轉送音訊。請使用 [sndcpy]。另外，參見 [issue #14]。
-
-[sndcpy]: https://github.com/rom1v/sndcpy
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
-
-
-## 快捷鍵
-
-在以下的清單中，<kbd>MOD</kbd> 是快捷鍵的特殊按鍵。通常來說，這個按鍵是 (左) <kbd>Alt</kbd> 或是 (左) <kbd>Super</kbd>。
-
-這個是可以使用 `--shortcut-mod` 更改的。可以用的選項有:
-- `lctrl`: 左邊的 <kbd>Ctrl</kbd>
-- `rctrl`: 右邊的 <kbd>Ctrl</kbd>
-- `lalt`: 左邊的 <kbd>Alt</kbd>
-- `ralt`: 右邊的 <kbd>Alt</kbd>
-- `lsuper`: 左邊的 <kbd>Super</kbd>
-- `rsuper`: 右邊的 <kbd>Super</kbd>
-
-```bash
-# 以 右邊的 Ctrl 為快捷鍵特殊按鍵
-scrcpy --shortcut-mod=rctrl
-
-# 以 左邊的 Ctrl 和左邊的 Alt 或是 左邊的 Super 為快捷鍵特殊按鍵
-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)
-
- | Action                                            |   Shortcut
- | ------------------------------------------------- |:-----------------------------
- | 切換至全螢幕                                       | <kbd>MOD</kbd>+<kbd>f</kbd>
- | 左旋顯示螢幕                                       | <kbd>MOD</kbd>+<kbd>←</kbd> _(左)_
- | 右旋顯示螢幕                                       | <kbd>MOD</kbd>+<kbd>→</kbd> _(右)_
- | 縮放視窗成 1:1 (pixel-perfect)                     | <kbd>MOD</kbd>+<kbd>g</kbd>
- | 縮放視窗到沒有黑邊框為止                            | <kbd>MOD</kbd>+<kbd>w</kbd> \| _雙擊¹_
- | 按下 `首頁` 鍵                                     | <kbd>MOD</kbd>+<kbd>h</kbd> \| _中鍵_
- | 按下 `返回` 鍵                                     | <kbd>MOD</kbd>+<kbd>b</kbd> \| _右鍵²_
- | 按下 `切換 APP` 鍵                                 | <kbd>MOD</kbd>+<kbd>s</kbd>
- | 按下 `選單` 鍵 (或解鎖螢幕)                         | <kbd>MOD</kbd>+<kbd>m</kbd>
- | 按下 `音量+` 鍵                                    | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上)_
- | 按下 `音量-` 鍵                                    | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下)_
- | 按下 `電源` 鍵                                     | <kbd>MOD</kbd>+<kbd>p</kbd>
- | 開啟                                               | _右鍵²_
- | 關閉裝置螢幕(持續鏡像)                              | <kbd>MOD</kbd>+<kbd>o</kbd>
- | 開啟裝置螢幕                                        | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
- | 旋轉裝置螢幕                                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | 開啟通知列                                          | <kbd>MOD</kbd>+<kbd>n</kbd>
- | 關閉通知列                                          | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | 複製至剪貼簿³                                       | <kbd>MOD</kbd>+<kbd>c</kbd>
- | 剪下至剪貼簿³                                       | <kbd>MOD</kbd>+<kbd>x</kbd>
- | 同步剪貼簿並貼上³                                   | <kbd>MOD</kbd>+<kbd>v</kbd>
- | 複製電腦剪貼簿中的文字至裝置並貼上                    | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
- | 啟用/停用 FPS 計數器(顯示於 stdout - 通常是命令列)    | <kbd>MOD</kbd>+<kbd>i</kbd>
-
-_¹在黑邊框上雙擊以移除它們。_  
-_²右鍵會返回。如果螢幕是關閉狀態，則會打開螢幕。_  
-_³只支援 Android 7+。_
-
-所有 <kbd>Ctrl</kbd>+_按鍵_ 快捷鍵都會傳送到裝置上，所以它們是由目前運作的應用程式處理的。
-
-
-## 自訂路徑
-
-如果要使用特定的 _adb_ ，將它設定到環境變數中的 `ADB`:
-
-    ADB=/path/to/adb scrcpy
-
-如果要覆寫 `scrcpy-server` 檔案的路徑，則將路徑設定到環境變數中的 `SCRCPY_SERVER_PATH`。
-
-[相關連結][useful]
-
-[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]: FAQ.md
-
-
-## 開發者文件
-
-請看[這個頁面 (英文)][developers page].
-
-[developers page]: DEVELOP.md
-
-
-## Licence
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2021 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## 相關文章
-
-- [Scrcpy 簡介 (英文)][article-intro]
-- [Scrcpy 可以無線連線了 (英文)][article-tcpip]
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/

app/data/bash-completion/scrcpy

@@ -0,0 +1,161 @@
+_scrcpy() {
+    local cur prev words cword
+    local opts="
+        --always-on-top
+        --audio-bit-rate=
+        --audio-buffer=
+        --audio-codec=
+        --audio-codec-options=
+        --audio-encoder=
+        --audio-source=
+        --audio-output-buffer=
+        -b --video-bit-rate=
+        --crop=
+        -d --select-usb
+        --disable-screensaver
+        --display=
+        --display-buffer=
+        -e --select-tcpip
+        -f --fullscreen
+        --force-adb-forward
+        --forward-all-clicks
+        -h --help
+        --kill-adb-on-close
+        -K --hid-keyboard
+        --legacy-paste
+        --list-displays
+        --list-encoders
+        --lock-video-orientation
+        --lock-video-orientation=
+        -m --max-size=
+        -M --hid-mouse
+        --max-fps=
+        -n --no-control
+        -N --no-playback
+        --no-audio
+        --no-audio-playback
+        --no-cleanup
+        --no-clipboard-autosync
+        --no-downsize-on-error
+        --no-key-repeat
+        --no-mipmaps
+        --no-power-on
+        --no-video
+        --no-video-playback
+        --otg
+        -p --port=
+        --power-off-on-close
+        --prefer-text
+        --print-fps
+        --push-target=
+        -r --record=
+        --raw-key-events
+        --record-format=
+        --render-driver=
+        --require-audio
+        --rotation=
+        -s --serial=
+        -S --turn-screen-off
+        --shortcut-mod=
+        -t --show-touches
+        --tcpip
+        --tcpip=
+        --time-limit=
+        --tunnel-host=
+        --tunnel-port=
+        --v4l2-buffer=
+        --v4l2-sink=
+        -v --version
+        -V --verbosity=
+        --video-codec=
+        --video-codec-options=
+        --video-encoder=
+        -w --stay-awake
+        --window-borderless
+        --window-title=
+        --window-x=
+        --window-y=
+        --window-width=
+        --window-height="
+
+    _init_completion -s || return
+
+    case "$prev" in
+        --video-codec)
+            COMPREPLY=($(compgen -W 'h264 h265 av1' -- "$cur"))
+            return
+            ;;
+        --audio-codec)
+            COMPREPLY=($(compgen -W 'opus aac raw' -- "$cur"))
+            return
+            ;;
+        --audio-source)
+            COMPREPLY=($(compgen -W 'output mic' -- "$cur"))
+            return
+            ;;
+        --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
+            ;;
+        -s|--serial)
+            # Use 'adb devices' to list serial numbers
+            COMPREPLY=($(compgen -W "$("${ADB:-adb}" devices | awk '$2 == "device" {print $1}')" -- ${cur}))
+            return
+            ;;
+        --audio-bit-rate \
+        |--audio-buffer \
+        |-b|--video-bit-rate \
+        |--audio-codec-options \
+        |--audio-encoder \
+        |--audio-output-buffer \
+        |--crop \
+        |--display \
+        |--display-buffer \
+        |--max-fps \
+        |-m|--max-size \
+        |-p|--port \
+        |--push-target \
+        |--rotation \
+        |--tunnel-host \
+        |--tunnel-port \
+        |--v4l2-buffer \
+        |--v4l2-sink \
+        |--video-codec-options \
+        |--video-encoder \
+        |--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

app/data/open_a_terminal_here.bat

@@ -0,0 +1 @@
+@cmd

app/data/scrcpy-console.desktop

@@ -0,0 +1,13 @@
+[Desktop Entry]
+Name=scrcpy (console)
+GenericName=Android Remote Control
+Comment=Display and control your Android device
+# For some users, the PATH or ADB environment variables are set from the shell
+# startup file, like .bashrc or .zshrc… Run an interactive shell to get
+# environment correctly initialized.
+Exec=/bin/bash --norc --noprofile -i -c "\"\\$SHELL\" -i -c scrcpy || read -p 'Press Enter to quit...'"
+Icon=scrcpy
+Terminal=true
+Type=Application
+Categories=Utility;RemoteAccess;
+StartupNotify=false

app/data/scrcpy.desktop

@@ -0,0 +1,13 @@
+[Desktop Entry]
+Name=scrcpy
+GenericName=Android Remote Control
+Comment=Display and control your Android device
+# For some users, the PATH or ADB environment variables are set from the shell
+# startup file, like .bashrc or .zshrc… Run an interactive shell to get
+# environment correctly initialized.
+Exec=/bin/sh -c "\"\\$SHELL\" -i -c scrcpy"
+Icon=scrcpy
+Terminal=false
+Type=Application
+Categories=Utility;RemoteAccess;
+StartupNotify=false

app/data/zsh-completion/_scrcpy

@@ -0,0 +1,87 @@
+#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\)]'
+    '--audio-bit-rate=[Encode the audio at the given bit-rate]'
+    '--audio-buffer=[Configure the audio buffering delay (in milliseconds)]'
+    '--audio-codec=[Select the audio codec]:codec:(opus aac raw)'
+    '--audio-codec-options=[Set a list of comma-separated key\:type=value options for the device audio encoder]'
+    '--audio-encoder=[Use a specific MediaCodec audio encoder]'
+    '--audio-source=[Select the audio source]:source:(output mic)'
+    '--audio-output-buffer=[Configure the size of the SDL audio output buffer (in milliseconds)]'
+    {-b,--video-bit-rate=}'[Encode the video at the given bit-rate]'
+    '--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]'
+    {-f,--fullscreen}'[Start in fullscreen]'
+    '--force-adb-forward[Do not attempt to use \"adb reverse\" to connect to the device]'
+    '--forward-all-clicks[Forward clicks to device]'
+    {-h,--help}'[Print the help]'
+    '--kill-adb-on-close[Kill adb when scrcpy terminates]'
+    {-K,--hid-keyboard}'[Simulate a physical keyboard by using HID over AOAv2]'
+    '--legacy-paste[Inject computer clipboard text as a sequence of key events on Ctrl+v]'
+    '--list-displays[List displays available on the device]'
+    '--list-encoders[List video and audio encoders available on the device]'
+    '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 1 2 3)'
+    {-m,--max-size=}'[Limit both the width and height of the video to value]'
+    {-M,--hid-mouse}'[Simulate a physical mouse by using HID over AOAv2]'
+    '--max-fps=[Limit the frame rate of screen capture]'
+    {-n,--no-control}'[Disable device control \(mirror the device in read only\)]'
+    {-N,--no-playback}'[Disable video and audio playback]'
+    '--no-audio[Disable audio forwarding]'
+    '--no-audio-playback[Disable audio playback]'
+    '--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]'
+    '--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]'
+    '--no-video[Disable video forwarding]'
+    '--no-video-playback[Disable video playback]'
+    '--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]'
+    {-r,--record=}'[Record screen to file]:record file:_files'
+    '--raw-key-events[Inject key events for all input keys, and ignore text events]'
+    '--record-format=[Force recording format]:format:(mp4 mkv)'
+    '--render-driver=[Request SDL to use the given render driver]:driver name:(direct3d opengl opengles2 opengles metal software)'
+    '--require-audio=[Make scrcpy fail if audio is enabled but does not work]'
+    '--rotation=[Set the initial display rotation]:rotation values:(0 1 2 3)'
+    {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]:serial:($("${ADB-adb}" devices | awk '\''$2 == "device" {print $1}'\''))'
+    {-S,--turn-screen-off}'[Turn the device screen off immediately]'
+    '--shortcut-mod=[\[key1,key2+key3,...\] Specify the modifiers to use for scrcpy shortcuts]:shortcut mod:(lctrl rctrl lalt ralt lsuper rsuper)'
+    {-t,--show-touches}'[Show physical touches]'
+    '--tcpip[\(optional \[ip\:port\]\) Configure and connect the device over TCP/IP]'
+    '--time-limit=[Set the maximum mirroring time, in seconds]'
+    '--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,--version}'[Print the version of scrcpy]'
+    {-V,--verbosity=}'[Set the log level]:verbosity:(verbose debug info warn error)'
+    '--video-codec=[Select the video codec]:codec:(h264 h265 av1)'
+    '--video-codec-options=[Set a list of comma-separated key\:type=value options for the device video encoder]'
+    '--video-encoder=[Use a specific MediaCodec video encoder]'
+    {-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

app/meson.build

@@ -1,17 +1,22 @@
 src = [
     'src/main.c',
-    'src/adb.c',
-    'src/adb_parser.c',
-    'src/adb_tunnel.c',
+    'src/adb/adb.c',
+    'src/adb/adb_device.c',
+    'src/adb/adb_parser.c',
+    'src/adb/adb_tunnel.c',
+    'src/audio_player.c',
     'src/cli.c',
     'src/clock.c',
     'src/compat.c',
     'src/control_msg.c',
     'src/controller.c',
     'src/decoder.c',
+    'src/delay_buffer.c',
+    'src/demuxer.c',
     'src/device_msg.c',
+    'src/display.c',
     'src/icon.c',
-    'src/file_handler.c',
+    'src/file_pusher.c',
     'src/fps_counter.c',
     'src/frame_buffer.c',
     'src/input_manager.c',
@@ -19,27 +24,34 @@ src = [
     'src/mouse_inject.c',
     'src/opengl.c',
     'src/options.c',
+    'src/packet_merger.c',
     'src/receiver.c',
     'src/recorder.c',
     'src/scrcpy.c',
     'src/screen.c',
     'src/server.c',
-    'src/stream.c',
-    'src/video_buffer.c',
+    'src/version.c',
+    'src/trait/frame_source.c',
+    'src/trait/packet_source.c',
     'src/util/acksync.c',
+    'src/util/average.c',
+    'src/util/bytebuf.c',
     'src/util/file.c',
     'src/util/intmap.c',
     'src/util/intr.c',
     'src/util/log.c',
+    'src/util/memory.c',
     'src/util/net.c',
     'src/util/net_intr.c',
     'src/util/process.c',
     'src/util/process_intr.c',
+    'src/util/rand.c',
     'src/util/strbuf.c',
     'src/util/str.c',
     'src/util/term.c',
     'src/util/thread.c',
     'src/util/tick.c',
+    'src/util/timeout.c',
 ]
 
 conf = configuration_data()
@@ -67,16 +79,20 @@ else
     endif
 endif
 
-v4l2_support = host_machine.system() == 'linux'
+v4l2_support = get_option('v4l2') and host_machine.system() == 'linux'
 if v4l2_support
     src += [ 'src/v4l2_sink.c' ]
 endif
 
-aoa_hid_support = host_machine.system() == 'linux'
-if aoa_hid_support
+usb_support = get_option('usb')
+if usb_support
     src += [
-        'src/aoa_hid.c',
-        'src/hid_keyboard.c',
+        '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
 
@@ -91,6 +107,7 @@ if not crossbuild_windows
         dependency('libavformat', version: '>= 57.33'),
         dependency('libavcodec', version: '>= 57.37'),
         dependency('libavutil'),
+        dependency('libswresample'),
         dependency('sdl2', version: '>= 2.0.5'),
     ]
 
@@ -98,16 +115,16 @@ if not crossbuild_windows
         dependencies += dependency('libavdevice')
     endif
 
-    if aoa_hid_support
+    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/' + prebuilt_sdl2 + '/bin'
-    sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/lib'
-    sdl2_include_dir = '../prebuilt-deps/' + prebuilt_sdl2 + '/include'
+    sdl2_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_sdl2 + '/bin'
+    sdl2_lib_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_sdl2 + '/lib'
+    sdl2_include_dir = 'prebuilt-deps/data/' + prebuilt_sdl2 + '/include'
 
     sdl2 = declare_dependency(
         dependencies: [
@@ -117,22 +134,35 @@ else
         include_directories: include_directories(sdl2_include_dir)
     )
 
-    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'
+    prebuilt_ffmpeg = meson.get_cross_property('prebuilt_ffmpeg')
+    ffmpeg_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_ffmpeg + '/bin'
+    ffmpeg_include_dir = 'prebuilt-deps/data/' + prebuilt_ffmpeg + '/include'
+
     ffmpeg = declare_dependency(
         dependencies: [
-            cc.find_library('avcodec-58', dirs: ffmpeg_bin_dir),
-            cc.find_library('avformat-58', dirs: ffmpeg_bin_dir),
-            cc.find_library('avutil-56', dirs: ffmpeg_bin_dir),
+            cc.find_library('avcodec-60', dirs: ffmpeg_bin_dir),
+            cc.find_library('avformat-60', dirs: ffmpeg_bin_dir),
+            cc.find_library('avutil-58', dirs: ffmpeg_bin_dir),
+            cc.find_library('swresample-4', dirs: ffmpeg_bin_dir),
         ],
         include_directories: include_directories(ffmpeg_include_dir)
     )
 
+    prebuilt_libusb = meson.get_cross_property('prebuilt_libusb')
+    libusb_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_libusb + '/bin'
+    libusb_include_dir = 'prebuilt-deps/data/' + prebuilt_libusb + '/include'
+
+    libusb = declare_dependency(
+        dependencies: [
+            cc.find_library('msys-usb-1.0', dirs: libusb_bin_dir),
+        ],
+        include_directories: include_directories(libusb_include_dir)
+    )
+
     dependencies = [
         ffmpeg,
         sdl2,
+        libusb,
         cc.find_library('mingw32')
     ]
 
@@ -146,6 +176,9 @@ check_functions = [
     'strdup',
     'asprintf',
     'vasprintf',
+    'nrand48',
+    'jrand48',
+    'reallocarray',
 ]
 
 foreach f : check_functions
@@ -173,10 +206,6 @@ conf.set('PORTABLE', get_option('portable'))
 conf.set('DEFAULT_LOCAL_PORT_RANGE_FIRST', '27183')
 conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')
 
-# the default video bitrate, in bits/second
-# overridden by option --bit-rate
-conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
-
 # run a server debugger and wait for a client to be attached
 conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
 
@@ -187,7 +216,7 @@ conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == '
 conf.set('HAVE_V4L2', v4l2_support)
 
 # enable HID over AOA support (linux only)
-conf.set('HAVE_AOA_HID', aoa_hid_support)
+conf.set('HAVE_USB', usb_support)
 
 configure_file(configuration: conf, output: 'config.h')
 
@@ -199,10 +228,26 @@ executable('scrcpy', src,
            install: true,
            c_args: [])
 
+# <https://mesonbuild.com/Builtin-options.html#directories>
+datadir = get_option('datadir') # by default 'share'
+
 install_man('scrcpy.1')
-install_data('../data/icon.png',
+install_data('data/icon.png',
              rename: 'scrcpy.png',
-             install_dir: 'share/icons/hicolor/256x256/apps')
+             install_dir: join_paths(datadir, 'icons/hicolor/256x256/apps'))
+install_data('data/zsh-completion/_scrcpy',
+             install_dir: join_paths(datadir, 'zsh/site-functions'))
+install_data('data/bash-completion/scrcpy',
+             install_dir: join_paths(datadir, 'bash-completion/completions'))
+
+# Desktop entry file for application launchers
+if host_machine.system() == 'linux'
+    # Install a launcher (ex: /usr/local/share/applications/scrcpy.desktop)
+    install_data('data/scrcpy.desktop',
+                 install_dir: join_paths(datadir, 'applications'))
+    install_data('data/scrcpy-console.desktop',
+                 install_dir: join_paths(datadir, 'applications'))
+endif
 
 
 ### TESTS
@@ -212,29 +257,28 @@ if get_option('buildtype') == 'debug'
     tests = [
         ['test_adb_parser', [
             'tests/test_adb_parser.c',
-            'src/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',
+        ['test_binary', [
+            'tests/test_binary.c',
         ]],
-        ['test_cbuf', [
-            'tests/test_cbuf.c',
+        ['test_bytebuf', [
+            'tests/test_bytebuf.c',
+            'src/util/bytebuf.c',
         ]],
         ['test_cli', [
             'tests/test_cli.c',
             'src/cli.c',
             'src/options.c',
+            'src/util/log.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',
-        ]],
         ['test_control_msg_serialize', [
             'tests/test_control_msg_serialize.c',
             'src/control_msg.c',
@@ -245,9 +289,6 @@ if get_option('buildtype') == 'debug'
             'tests/test_device_msg_deserialize.c',
             'src/device_msg.c',
         ]],
-        ['test_queue', [
-            'tests/test_queue.c',
-        ]],
         ['test_strbuf', [
             'tests/test_strbuf.c',
             'src/util/strbuf.c',
@@ -257,10 +298,18 @@ if get_option('buildtype') == 'debug'
             'src/util/str.c',
             'src/util/strbuf.c',
         ]],
+        ['test_vecdeque', [
+            'tests/test_vecdeque.c',
+            'src/util/memory.c',
+        ]],
+        ['test_vector', [
+            'tests/test_vector.c',
+        ]],
     ]
 
     foreach t : tests
-        exe = executable(t[0], t[1],
+        sources = t[1] + ['src/compat.c']
+        exe = executable(t[0], sources,
                          include_directories: src_dir,
                          dependencies: dependencies,
                          c_args: ['-DSDL_MAIN_HANDLED', '-DSC_TEST'])

app/prebuilt-deps/.gitignore

@@ -0,0 +1 @@
+/data

app/prebuilt-deps/common

@@ -0,0 +1,22 @@
+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"
+}

app/prebuilt-deps/prepare-adb.sh

@@ -0,0 +1,32 @@
+#!/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-34.0.1
+
+FILENAME=platform-tools_r34.0.1-windows.zip
+SHA256SUM=5dd9c2be744c224fa3a7cbe30ba02d2cb378c763bd0f797a7e47e9f3156a5daa
+
+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"

app/prebuilt-deps/prepare-ffmpeg.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -e
+DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DIR"
+. common
+mkdir -p "$PREBUILT_DATA_DIR"
+cd "$PREBUILT_DATA_DIR"
+
+VERSION=6.0-scrcpy-4
+DEP_DIR="ffmpeg-$VERSION"
+
+FILENAME="$DEP_DIR".7z
+SHA256SUM=39274b321491ce83e76cab5d24e7cbe3f402d3ccf382f739b13be5651c146b60
+
+if [[ -d "$DEP_DIR" ]]
+then
+    echo "$DEP_DIR" found
+    exit 0
+fi
+
+get_file "https://github.com/rom1v/scrcpy-deps/releases/download/$VERSION/$FILENAME" \
+    "$FILENAME" "$SHA256SUM"
+
+mkdir "$DEP_DIR"
+cd "$DEP_DIR"
+
+ZIP_PREFIX=ffmpeg
+7z x "../$FILENAME"
+mv "$ZIP_PREFIX"/* .
+rmdir "$ZIP_PREFIX"

app/prebuilt-deps/prepare-libusb.sh

@@ -0,0 +1,33 @@
+#!/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"
+
+7z x "../$FILENAME" \
+    libusb-1.0.26-binaries/libusb-MinGW-Win32/bin/msys-usb-1.0.dll \
+    libusb-1.0.26-binaries/libusb-MinGW-Win32/include/ \
+    libusb-1.0.26-binaries/libusb-MinGW-x64/bin/msys-usb-1.0.dll \
+    libusb-1.0.26-binaries/libusb-MinGW-x64/include/
+
+mv libusb-1.0.26-binaries/libusb-MinGW-Win32 .
+mv libusb-1.0.26-binaries/libusb-MinGW-x64 .
+rm -rf libusb-1.0.26-binaries

app/prebuilt-deps/prepare-sdl.sh

@@ -0,0 +1,32 @@
+#!/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.26.4
+
+FILENAME=SDL2-devel-2.26.4-mingw.tar.gz
+SHA256SUM=fe899c8642caac2f180b1ee6f786857ddcaa0adc1fa82474312b09dd47d74712
+
+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/ \

app/scrcpy-windows.rc

@@ -1,6 +1,6 @@
 #include <winuser.h>
 
-0 ICON "../data/icon.ico"
+0 ICON "data/icon.ico"
 1 RT_MANIFEST "scrcpy-windows.manifest"
 2 VERSIONINFO
 BEGIN
@@ -13,7 +13,7 @@ BEGIN
       VALUE "LegalCopyright", "Romain Vimont, Genymobile"
       VALUE "OriginalFilename", "scrcpy.exe"
       VALUE "ProductName", "scrcpy"
-      VALUE "ProductVersion", "1.21"
+      VALUE "ProductVersion", "2.0"
     END
   END
   BLOCK "VarFileInfo"

app/scrcpy.1

@@ -20,14 +20,28 @@ provides display and control of Android devices connected on USB (or over TCP/IP
 Make scrcpy window always on top (above other windows).
 
 .TP
-.BI "\-b, \-\-bit\-rate " value
-Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
+.BI "\-\-audio\-bit\-rate " value
+Encode the audio at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
 
-Default is 8000000.
+Default is 128K (128000).
 
 .TP
-.BI "\-\-codec\-options " key[:type]=value[,...]
-Set a list of comma-separated key:type=value options for the device encoder.
+.BI "\-\-audio\-buffer ms
+Configure the audio buffering delay (in milliseconds).
+
+Lower values decrease the latency, but increase the likelyhood of buffer underrun (causing audio glitches).
+
+Default is 50.
+
+.TP
+.BI "\-\-audio\-codec " name
+Select an audio codec (opus, aac or raw).
+
+Default is opus.
+
+.TP
+.BI "\-\-audio\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
+Set a list of comma-separated key:type=value options for the device audio encoder.
 
 The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
 
@@ -35,6 +49,32 @@ The list of possible codec options is available in the Android documentation
 .UR https://d.android.com/reference/android/media/MediaFormat
 .UE .
 
+.TP
+.BI "\-\-audio\-encoder " name
+Use a specific MediaCodec audio encoder (depending on the codec provided by \fB\-\-audio\-codec\fR).
+
+The available encoders can be listed by \-\-list\-encoders.
+
+.TP
+.BI "\-\-audio\-source " source
+Select the audio source (output or mic).
+
+Default is output.
+
+.TP
+.BI "\-\-audio\-output\-buffer ms
+Configure the size of the SDL audio output buffer (in milliseconds).
+
+If you get "robotic" audio playback, you should test with a higher value (10). Do not change this setting otherwise.
+
+Default is 5.
+
+.TP
+.BI "\-b, \-\-video\-bit\-rate " value
+Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
+
+Default is 8M (8000000).
+
 .TP
 .BI "\-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
 Crop the device screen on the server.
@@ -43,16 +83,21 @@ 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.
 
 .TP
 .BI "\-\-display " id
-Specify the display id to mirror.
+Specify the device display id to mirror.
 
-The list of possible display ids can be listed by "adb shell dumpsys display"
-(search "mDisplayId=" in the output).
+The available display ids can be listed by \-\-list\-displays.
 
 Default is 0.
 
@@ -63,8 +108,14 @@ Add a buffering delay (in milliseconds) before displaying. This increases latenc
 Default is 0 (no buffering).
 
 .TP
-.BI "\-\-encoder " name
-Use a specific MediaCodec encoder (must be a H.264 encoder).
+.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
+.B \-f, \-\-fullscreen
+Start in fullscreen.
 
 .TP
 .B \-\-force\-adb\-forward
@@ -74,21 +125,21 @@ Do not attempt to use "adb reverse" to connect to the device.
 .B \-\-forward\-all\-clicks
 By default, right-click triggers BACK (or POWER on) and middle-click triggers HOME. This option disables these shortcuts and forward the clicks to the device instead.
 
-.TP
-.B \-f, \-\-fullscreen
-Start in fullscreen.
-
 .TP
 .B \-h, \-\-help
 Print this help.
 
+.TP
+.B \-\-kill\-adb\-on\-close
+Kill adb when scrcpy terminates.
+
 .TP
 .B \-K, \-\-hid\-keyboard
 Simulate a physical keyboard by using HID over AOAv2.
 
 This provides a better experience for IME users, and allows to generate non-ASCII characters, contrary to the default injection method.
 
-It may only work over USB, and is currently only supported on Linux.
+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:
 
@@ -96,6 +147,8 @@ The keyboard layout must be configured (once and for all) on the device, via Set
 
 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).
@@ -103,17 +156,21 @@ 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]
+.B \-\-list\-encoders
+List video and audio encoders available on the device.
+
+.TP
+.B \-\-list\-displays
+List displays available on the device.
+
+.TP
+\fB\-\-lock\-video\-orientation\fR[=\fIvalue\fR]
 Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees rotation counterclockwise.
 
 Default is "unlocked".
 
 Passing the option without argument is equivalent to passing "initial".
 
-.TP
-.BI "\-\-max\-fps " value
-Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
-
 .TP
 .BI "\-m, \-\-max\-size " value
 Limit both the width and height of the video to \fIvalue\fR. The other dimension is computed so that the device aspect\-ratio is preserved.
@@ -121,18 +178,54 @@ Limit both the width and height of the video to \fIvalue\fR. The other dimension
 Default is 0 (unlimited).
 
 .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.
+.B \-M, \-\-hid\-mouse
+Simulate a physical mouse by using HID over AOAv2.
 
-This option disables this automatic synchronization.
+In this mode, the computer mouse is captured to control the device directly (relative mouse mode).
+
+LAlt, LSuper or RSuper toggle the capture mode, to give control of the mouse back to the computer.
+
+It may only work over USB.
+
+Also see \fB\-\-hid\-keyboard\fR.
+
+.TP
+.BI "\-\-max\-fps " value
+Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
 
 .TP
 .B \-n, \-\-no\-control
 Disable device control (mirror the device in read\-only).
 
 .TP
-.B \-N, \-\-no\-display
-Do not display device (only when screen recording is enabled).
+.B \-N, \-\-no\-playback
+Disable video and audio playback on the computer (equivalent to --no-video-playback --no-audio-playback).
+
+.TP
+.B \-\-no\-audio
+Disable audio forwarding.
+
+.TP
+.B \-\-no\-audio\-playback
+Disable audio playback on the computer.
+
+.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 \-\-no\-key\-repeat
@@ -143,7 +236,33 @@ Do not forward repeated key events when a key is held down.
 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
-.BI "\-p, \-\-port " port[:port]
+.B \-\-no\-power\-on
+Do not power on the device on start.
+
+.TP
+.B \-\-no\-video
+Disable video forwarding.
+
+.TP
+.B \-\-no\-video\-playback
+Disable video playback on the computer.
+
+.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\fR[:\fIport\fR]
 Set the TCP port (range) used by the client to listen.
 
 Default is 27183:27199.
@@ -159,16 +278,16 @@ 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.
-
 .TP
 .BI "\-r, \-\-record " file
 Record screen to
@@ -178,6 +297,10 @@ The format is determined by the
 .B \-\-record\-format
 option if set, or by the file extension (.mp4 or .mkv).
 
+.TP
+.B \-\-raw\-key\-events
+Inject key events for all input keys, and ignore text events.
+
 .TP
 .BI "\-\-record\-format " format
 Force recording format (either mp4 or mkv).
@@ -191,6 +314,10 @@ Supported names are currently "direct3d", "opengl", "opengles2", "opengles", "me
 .UR https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER
 .UE
 
+.TP
+.B \-\-require\-audio
+By default, scrcpy mirrors only the video if audio capture fails on the device. This option makes scrcpy fail if audio is enabled but does not work.
+
 .TP
 .BI "\-\-rotation " value
 Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each increment adds a 90 degrees rotation counterclockwise.
@@ -200,7 +327,11 @@ Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each incre
 The device serial number. Mandatory only if several devices are connected to adb.
 
 .TP
-.BI "\-\-shortcut\-mod " key[+...]][,...]
+.B \-S, \-\-turn\-screen\-off
+Turn the device screen off immediately.
+
+.TP
+.BI "\-\-shortcut\-mod " key\fR[+...]][,...]
 Specify the modifiers to use for scrcpy shortcuts. Possible keys are "lctrl", "rctrl", "lalt", "ralt", "lsuper" and "rsuper".
 
 A shortcut can consist in several keys, separated by '+'. Several shortcuts can be specified, separated by ','.
@@ -209,24 +340,24 @@ 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.
-
 .TP
 .B \-t, \-\-show\-touches
 Enable "show touches" on start, restore the initial value on exit.
 
 It only shows physical touches (not clicks from scrcpy).
 
+.TP
+.BI "\-\-tcpip\fR[=\fIip\fR[:\fIport\fR]]
+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 and adb port of the current device (typically connected over USB), enables TCP/IP mode if necessary, then connects to this address before starting.
+
+.TP
+.BI "\-\-time\-limit " seconds
+Set the maximum mirroring time, in seconds.
+
 .TP
 .BI "\-\-tunnel\-host " ip
 Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
@@ -239,6 +370,16 @@ Set the TCP port of the adb tunnel to reach the scrcpy server. This option autom
 
 Default is 0 (not forced): the local port used for establishing the tunnel will be used.
 
+.TP
+.B \-v, \-\-version
+Print the version of scrcpy.
+
+.TP
+.BI "\-V, \-\-verbosity " value
+Set the log level ("verbose", "debug", "info", "warn" or "error").
+
+Default is "info" for release builds, "debug" for debug builds.
+
 .TP
 .BI "\-\-v4l2-sink " /dev/videoN
 Output to v4l2loopback device.
@@ -254,14 +395,26 @@ This option is similar to \fB\-\-display\-buffer\fR, but specific to V4L2 sink.
 Default is 0 (no buffering).
 
 .TP
-.BI "\-V, \-\-verbosity " value
-Set the log level ("verbose", "debug", "info", "warn" or "error").
+.BI "\-\-video\-codec " name
+Select a video codec (h264, h265 or av1).
 
-Default is "info" for release builds, "debug" for debug builds.
+Default is h264.
 
 .TP
-.B \-v, \-\-version
-Print the version of scrcpy.
+.BI "\-\-video\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
+Set a list of comma-separated key:type=value options for the device video encoder.
+
+The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
+
+The list of possible codec options is available in the Android documentation
+.UR https://d.android.com/reference/android/media/MediaFormat
+.UE .
+
+.TP
+.BI "\-\-video\-encoder " name
+Use a specific MediaCodec video encoder (depending on the codec provided by \fB\-\-video\-codec\fR).
+
+The available encoders can be listed by \-\-list\-encoders.
 
 .TP
 .B \-w, \-\-stay-awake
@@ -299,6 +452,12 @@ 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.
+
 .SH SHORTCUTS
 
 In the following list, MOD is the shortcut modifier. By default, it's (left)
@@ -415,6 +574,10 @@ Push file to device (see \fB\-\-push\-target\fR)
 .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.
@@ -446,7 +609,7 @@ Copyright \(co 2018 Genymobile
 Genymobile
 .UE
 
-Copyright \(co 2018\-2021
+Copyright \(co 2018\-2023
 .MT rom@rom1v.com
 Romain Vimont
 .ME

app/src/adb.c

@@ -1,471 +0,0 @@
-#include "adb.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "adb_parser.h"
-#include "util/file.h"
-#include "util/log.h"
-#include "util/process_intr.h"
-#include "util/str.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 (sc_file_executable_exists(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 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 (!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);
-
-    sc_intr_set_process(intr, SC_PROCESS_NONE);
-
-    // Close separately
-    sc_process_close(pid);
-
-    return ret;
-}
-
-static const char **
-adb_create_argv(const char *serial, const char *const adb_cmd[], size_t len) {
-    const char **argv = malloc((len + 4) * sizeof(*argv));
-    if (!argv) {
-        LOG_OOM();
-        return NULL;
-    }
-
-    argv[0] = get_adb_command();
-    int i;
-    if (serial) {
-        argv[1] = "-s";
-        argv[2] = serial;
-        i = 3;
-    } else {
-        i = 1;
-    }
-
-    memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
-    argv[len + i] = NULL;
-    return argv;
-}
-
-static sc_pid
-adb_execute_p(const char *serial, const char *const adb_cmd[], size_t len,
-              unsigned flags, sc_pipe *pout) {
-    const char **argv = adb_create_argv(serial, adb_cmd, len);
-    if (!argv) {
-        return SC_PROCESS_NONE;
-    }
-
-    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;
-    }
-
-    free(argv);
-    return pid;
-}
-
-sc_pid
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
-            unsigned flags) {
-    return adb_execute_p(serial, adb_cmd, len, flags, NULL);
-}
-
-bool
-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);
-    const char *const adb_cmd[] = {"forward", local, remote};
-
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-    return process_check_success_intr(intr, pid, "adb forward", flags);
-}
-
-bool
-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);
-    const char *const adb_cmd[] = {"forward", "--remove", local};
-
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-    return process_check_success_intr(intr, pid, "adb forward --remove", flags);
-}
-
-bool
-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);
-    const char *const adb_cmd[] = {"reverse", remote, local};
-
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-    return process_check_success_intr(intr, pid, "adb reverse", flags);
-}
-
-bool
-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);
-    const char *const adb_cmd[] = {"reverse", "--remove", remote};
-
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-    return process_check_success_intr(intr, pid, "adb reverse --remove", flags);
-}
-
-bool
-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
-
-    const char *const adb_cmd[] = {"push", local, remote};
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-
-#ifdef __WINDOWS__
-    free((void *) remote);
-    free((void *) local);
-#endif
-
-    return process_check_success_intr(intr, pid, "adb push", flags);
-}
-
-bool
-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
-
-    const char *const adb_cmd[] = {"install", "-r", local};
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-
-#ifdef __WINDOWS__
-    free((void *) local);
-#endif
-
-    return process_check_success_intr(intr, pid, "adb install", flags);
-}
-
-bool
-adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
-          unsigned flags) {
-    char port_string[5 + 1];
-    sprintf(port_string, "%" PRIu16, port);
-    const char *const adb_cmd[] = {"tcpip", port_string};
-
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-    return process_check_success_intr(intr, pid, "adb tcpip", flags);
-}
-
-bool
-adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
-    const char *const adb_cmd[] = {"connect", ip_port};
-
-    sc_pipe pout;
-    sc_pid pid = adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), 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));
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "adb connect", flags);
-    if (!ok) {
-        return false;
-    }
-
-    if (r == -1) {
-        return false;
-    }
-
-    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.
-        sc_str_truncate(buf, r, "\r\n");
-        fprintf(stderr, "%s\n", buf);
-    }
-    return ok;
-}
-
-bool
-adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
-    const char *const adb_cmd[] = {"disconnect", ip_port};
-    size_t len = ip_port ? ARRAY_LEN(adb_cmd)
-                         : ARRAY_LEN(adb_cmd) - 1;
-
-    sc_pid pid = adb_execute(NULL, adb_cmd, len, flags);
-    return process_check_success_intr(intr, pid, "adb disconnect", flags);
-}
-
-char *
-adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
-            unsigned flags) {
-    const char *const adb_cmd[] = {"shell", "getprop", prop};
-
-    sc_pipe pout;
-    sc_pid pid =
-        adb_execute_p(serial, adb_cmd, ARRAY_LEN(adb_cmd), 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));
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "adb getprop", flags);
-    if (!ok) {
-        return NULL;
-    }
-
-    if (r == -1) {
-        return NULL;
-    }
-
-    sc_str_truncate(buf, r, " \r\n");
-
-    return strdup(buf);
-}
-
-char *
-adb_get_serialno(struct sc_intr *intr, unsigned flags) {
-    const char *const adb_cmd[] = {"get-serialno"};
-
-    sc_pipe pout;
-    sc_pid pid = adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), flags, &pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGE("Could not execute \"adb get-serialno\"");
-        return NULL;
-    }
-
-    char buf[128];
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "adb get-serialno", flags);
-    if (!ok) {
-        return NULL;
-    }
-
-    if (r == -1) {
-        return false;
-    }
-
-    sc_str_truncate(buf, r, " \r\n");
-
-    return strdup(buf);
-}
-
-char *
-adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
-    const char *const cmd[] = {"shell", "ip", "route"};
-
-    sc_pipe pout;
-    sc_pid pid = adb_execute_p(serial, cmd, ARRAY_LEN(cmd), 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));
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "ip route", flags);
-    if (!ok) {
-        return NULL;
-    }
-
-    if (r == -1) {
-        return false;
-    }
-
-    assert((size_t) r <= sizeof(buf));
-    if (r == sizeof(buf) && buf[sizeof(buf) - 1] != '\0')  {
-        // 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.\n");
-        return NULL;
-    }
-
-    return sc_adb_parse_device_ip_from_output(buf, r);
-}

app/src/adb.h

@@ -1,94 +0,0 @@
-#ifndef SC_ADB_H
-#define SC_ADB_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <inttypes.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)
-
-sc_pid
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
-            unsigned flags);
-
-bool
-adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
-            const char *device_socket_name, unsigned flags);
-
-bool
-adb_forward_remove(struct sc_intr *intr, const char *serial,
-                   uint16_t local_port, unsigned flags);
-
-bool
-adb_reverse(struct sc_intr *intr, const char *serial,
-            const char *device_socket_name, uint16_t local_port,
-            unsigned flags);
-
-bool
-adb_reverse_remove(struct sc_intr *intr, const char *serial,
-                   const char *device_socket_name, unsigned flags);
-
-bool
-adb_push(struct sc_intr *intr, const char *serial, const char *local,
-         const char *remote, unsigned flags);
-
-bool
-adb_install(struct sc_intr *intr, const char *serial, const char *local,
-            unsigned flags);
-
-/**
- * Execute `adb tcpip <port>`
- */
-bool
-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
-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
-adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags);
-
-/**
- * Execute `adb getprop <prop>`
- */
-char *
-adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
-            unsigned flags);
-
-/**
- * Execute `adb get-serialno`
- *
- * Return the result, to be freed by the caller, or NULL on error.
- */
-char *
-adb_get_serialno(struct sc_intr *intr, 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 *
-adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags);
-
-#endif

app/src/adb/adb.c

@@ -0,0 +1,715 @@
+#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) {
+        LOG_OOM();
+        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);
+}

app/src/adb/adb.h

@@ -0,0 +1,117 @@
+#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)
+
+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);
+
+#endif

app/src/adb/adb_device.c

@@ -0,0 +1,43 @@
+#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;
+}

app/src/adb/adb_device.h

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

app/src/adb/adb_parser.c

@@ -0,0 +1,228 @@
+#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");
+        bool is_last_line = line[len] == '\0';
+
+        // 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;
+        }
+
+        if (is_last_line) {
+            break;
+        }
+
+        // The next line starts after the '\n'
+        idx_line += len + 1;
+    }
+
+    return NULL;
+}

app/src/adb/adb_parser.h

@@ -0,0 +1,30 @@
+#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);
+
+#endif

app/src/adb/adb_tunnel.c

@@ -7,8 +7,6 @@
 #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);
@@ -17,10 +15,11 @@ listen_on_port(struct sc_intr *intr, sc_socket socket, uint16_t port) {
 static bool
 enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
                                struct sc_intr *intr, const char *serial,
+                               const char *device_socket_name,
                                struct sc_port_range port_range) {
     uint16_t port = port_range.first;
     for (;;) {
-        if (!adb_reverse(intr, serial, SC_SOCKET_NAME, port,
+        if (!sc_adb_reverse(intr, serial, device_socket_name, port,
                             SC_ADB_NO_STDOUT)) {
             // the command itself failed, it will fail on any port
             return false;
@@ -52,7 +51,7 @@ enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
         }
 
         // failure, disable tunnel and try another port
-        if (!adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+        if (!sc_adb_reverse_remove(intr, serial, device_socket_name,
                                 SC_ADB_NO_STDOUT)) {
             LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
         }
@@ -78,12 +77,14 @@ enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
 static bool
 enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
                                struct sc_intr *intr, const char *serial,
+                               const char *device_socket_name,
                                struct sc_port_range port_range) {
     tunnel->forward = true;
 
     uint16_t port = port_range.first;
     for (;;) {
-        if (adb_forward(intr, serial, port, SC_SOCKET_NAME, SC_ADB_NO_STDOUT)) {
+        if (sc_adb_forward(intr, serial, port, device_socket_name,
+                           SC_ADB_NO_STDOUT)) {
             // success
             tunnel->local_port = port;
             tunnel->enabled = true;
@@ -122,13 +123,14 @@ sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel) {
 
 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) {
+                   const char *serial, const char *device_socket_name,
+                   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)) {
+        if (enable_tunnel_reverse_any_port(tunnel, intr, serial,
+                                           device_socket_name, port_range)) {
             return true;
         }
 
@@ -138,20 +140,21 @@ sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
         LOGW("'adb reverse' failed, fallback to 'adb forward'");
     }
 
-    return enable_tunnel_forward_any_port(tunnel, intr, serial, port_range);
+    return enable_tunnel_forward_any_port(tunnel, intr, serial,
+                                          device_socket_name, port_range);
 }
 
 bool
 sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                    const char *serial) {
+                    const char *serial, const char *device_socket_name) {
     assert(tunnel->enabled);
 
     bool ret;
     if (tunnel->forward) {
-        ret = adb_forward_remove(intr, serial, tunnel->local_port,
+        ret = sc_adb_forward_remove(intr, serial, tunnel->local_port,
                                     SC_ADB_NO_STDOUT);
     } else {
-        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+        ret = sc_adb_reverse_remove(intr, serial, device_socket_name,
                                     SC_ADB_NO_STDOUT);
 
         assert(tunnel->server_socket != SC_SOCKET_NONE);

app/src/adb/adb_tunnel.h

@@ -34,14 +34,14 @@ sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel);
  */
 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);
+                   const char *serial, const char *device_socket_name,
+                   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);
+                    const char *serial, const char *device_socket_name);
 
 #endif

app/src/adb_parser.c

@@ -1,65 +0,0 @@
-#include "adb_parser.h"
-
-#include <assert.h>
-#include <string.h>
-
-#include "util/log.h"
-#include "util/str.h"
-
-static char *
-sc_adb_parse_device_ip_from_line(char *line, size_t len) {
-    // One line from "ip route" looks lile:
-    // "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];
-    sc_str_truncate(dev_name, len - idx_dev_name + 1, " \t");
-
-    char *ip = &line[idx_ip];
-    sc_str_truncate(ip, len - idx_ip + 1, " \t");
-
-    // 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_from_output(char *buf, size_t buf_len) {
-    size_t idx_line = 0;
-    while (idx_line < buf_len && buf[idx_line] != '\0') {
-        char *line = &buf[idx_line];
-        size_t len = sc_str_truncate(line, buf_len - idx_line, "\n");
-
-        // The same, but without any trailing '\r'
-        size_t line_len = sc_str_remove_trailing_cr(line, len);
-
-        char *ip = sc_adb_parse_device_ip_from_line(line, line_len);
-        if (ip) {
-            // Found
-            return ip;
-        }
-
-        // The next line starts after the '\n' (replaced by `\0`)
-        idx_line += len + 1;
-    }
-
-    return NULL;
-}

app/src/adb_parser.h

@@ -1,14 +0,0 @@
-#ifndef SC_ADB_PARSER_H
-#define SC_ADB_PARSER_H
-
-#include "common.h"
-
-#include "stddef.h"
-
-/**
- * Parse the ip from the output of `adb shell ip route`
- */
-char *
-sc_adb_parse_device_ip_from_output(char *buf, size_t buf_len);
-
-#endif

app/src/audio_player.c

@@ -0,0 +1,476 @@
+#include "audio_player.h"
+
+#include <libavcodec/avcodec.h>
+#include <libavutil/opt.h>
+
+#include "util/log.h"
+
+#define SC_AUDIO_PLAYER_NDEBUG // comment to debug
+
+/**
+ * Real-time audio player with configurable latency
+ *
+ * As input, the player regularly receives AVFrames of decoded audio samples.
+ * As output, an SDL callback regularly requests audio samples to be played.
+ * In the middle, an audio buffer stores the samples produced but not consumed
+ * yet.
+ *
+ * The goal of the player is to feed the audio output with a latency as low as
+ * possible while avoiding buffer underrun (i.e. not being able to provide
+ * samples when requested).
+ *
+ * The player aims to feed the audio output with as little latency as possible
+ * while avoiding buffer underrun. To achieve this, it attempts to maintain the
+ * average buffering (the number of samples present in the buffer) around a
+ * target value. If this target buffering is too low, then buffer underrun will
+ * occur frequently. If it is too high, then latency will become unacceptable.
+ * This target value is configured using the scrcpy option --audio-buffer.
+ *
+ * The player cannot adjust the sample input rate (it receives samples produced
+ * in real-time) or the sample output rate (it must provide samples as
+ * requested by the audio output callback). Therefore, it may only apply
+ * compensation by resampling (converting _m_ input samples to _n_ output
+ * samples).
+ *
+ * The compensation itself is applied by libswresample (FFmpeg). It is
+ * configured using swr_set_compensation(). An important work for the player
+ * is to estimate the compensation value regularly and apply it.
+ *
+ * The estimated buffering level is the result of averaging the "natural"
+ * buffering (samples are produced and consumed by blocks, so it must be
+ * smoothed), and making instant adjustments resulting of its own actions
+ * (explicit compensation and silence insertion on underflow), which are not
+ * smoothed.
+ *
+ * Buffer underflow events can occur when packets arrive too late. In that case,
+ * the player inserts silence. Once the packets finally arrive (late), one
+ * strategy could be to drop the samples that were replaced by silence, in
+ * order to keep a minimal latency. However, dropping samples in case of buffer
+ * underflow is inadvisable, as it would temporarily increase the underflow
+ * even more and cause very noticeable audio glitches.
+ *
+ * Therefore, the player doesn't drop any sample on underflow. The compensation
+ * mechanism will absorb the delay introduced by the inserted silence.
+ */
+
+/** Downcast frame_sink to sc_audio_player */
+#define DOWNCAST(SINK) container_of(SINK, struct sc_audio_player, frame_sink)
+
+#define SC_AV_SAMPLE_FMT AV_SAMPLE_FMT_FLT
+#define SC_SDL_SAMPLE_FMT AUDIO_F32
+
+#define TO_BYTES(SAMPLES) sc_audiobuf_to_bytes(&ap->buf, (SAMPLES))
+#define TO_SAMPLES(BYTES) sc_audiobuf_to_samples(&ap->buf, (BYTES))
+
+static void SDLCALL
+sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
+    struct sc_audio_player *ap = userdata;
+
+    // This callback is called with the lock used by SDL_AudioDeviceLock(), so
+    // the audiobuf is protected
+
+    assert(len_int > 0);
+    size_t len = len_int;
+    uint32_t count = TO_SAMPLES(len);
+
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+    LOGD("[Audio] SDL callback requests %" PRIu32 " samples", count);
+#endif
+
+    uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
+    if (!ap->played) {
+        // Part of the buffering is handled by inserting initial silence. The
+        // remaining (margin) last samples will be handled by compensation.
+        uint32_t margin = 30 * ap->sample_rate / 1000; // 30ms
+        if (buffered_samples + margin < ap->target_buffering) {
+            LOGV("[Audio] Inserting initial buffering silence: %" PRIu32
+                 " samples", count);
+            // Delay playback starting to reach the target buffering. Fill the
+            // whole buffer with silence (len is small compared to the
+            // arbitrary margin value).
+            memset(stream, 0, len);
+            return;
+        }
+    }
+
+    uint32_t read = MIN(buffered_samples, count);
+    if (read) {
+        sc_audiobuf_read(&ap->buf, stream, read);
+    }
+
+    if (read < count) {
+        uint32_t silence = count - read;
+        // Insert silence. In theory, the inserted silent samples replace the
+        // missing real samples, which will arrive later, so they should be
+        // dropped to keep the latency minimal. However, this would cause very
+        // audible glitches, so let the clock compensation restore the target
+        // latency.
+        LOGD("[Audio] Buffer underflow, inserting silence: %" PRIu32 " samples",
+             silence);
+        memset(stream + TO_BYTES(read), 0, TO_BYTES(silence));
+
+        if (ap->received) {
+            // Inserting additional samples immediately increases buffering
+            ap->underflow += silence;
+        }
+    }
+
+    ap->played = true;
+}
+
+static uint8_t *
+sc_audio_player_get_swr_buf(struct sc_audio_player *ap, uint32_t min_samples) {
+    size_t min_buf_size = TO_BYTES(min_samples);
+    if (min_buf_size > ap->swr_buf_alloc_size) {
+        size_t new_size = min_buf_size + 4096;
+        uint8_t *buf = realloc(ap->swr_buf, new_size);
+        if (!buf) {
+            LOG_OOM();
+            // Could not realloc to the requested size
+            return NULL;
+        }
+        ap->swr_buf = buf;
+        ap->swr_buf_alloc_size = new_size;
+    }
+
+    return ap->swr_buf;
+}
+
+static bool
+sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
+                                const AVFrame *frame) {
+    struct sc_audio_player *ap = DOWNCAST(sink);
+
+    SwrContext *swr_ctx = ap->swr_ctx;
+
+    int64_t swr_delay = swr_get_delay(swr_ctx, ap->sample_rate);
+    // No need to av_rescale_rnd(), input and output sample rates are the same.
+    // Add more space (256) for clock compensation.
+    int dst_nb_samples = swr_delay + frame->nb_samples + 256;
+
+    uint8_t *swr_buf = sc_audio_player_get_swr_buf(ap, dst_nb_samples);
+    if (!swr_buf) {
+        return false;
+    }
+
+    int ret = swr_convert(swr_ctx, &swr_buf, dst_nb_samples,
+                          (const uint8_t **) frame->data, frame->nb_samples);
+    if (ret < 0) {
+        LOGE("Resampling failed: %d", ret);
+        return false;
+    }
+
+    // swr_convert() returns the number of samples which would have been
+    // written if the buffer was big enough.
+    uint32_t samples_written = MIN(ret, dst_nb_samples);
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+    LOGD("[Audio] %" PRIu32 " samples written to buffer", samples_written);
+#endif
+
+    // Since this function is the only writer, the current available space is
+    // at least the previous available space. In practice, it should almost
+    // always be possible to write without lock.
+    bool lockless_write = samples_written <= ap->previous_can_write;
+    if (lockless_write) {
+        sc_audiobuf_prepare_write(&ap->buf, swr_buf, samples_written);
+    }
+
+    SDL_LockAudioDevice(ap->device);
+
+    uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
+
+    if (lockless_write) {
+        sc_audiobuf_commit_write(&ap->buf, samples_written);
+    } else {
+        uint32_t can_write = sc_audiobuf_can_write(&ap->buf);
+        if (samples_written > can_write) {
+            // Entering this branch is very unlikely, the audio buffer is
+            // allocated with a size sufficient to store 1 second more than the
+            // target buffering. If this happens, though, we have to skip old
+            // samples.
+            uint32_t cap = sc_audiobuf_capacity(&ap->buf);
+            if (samples_written > cap) {
+                // Very very unlikely: a single resampled frame should never
+                // exceed the audio buffer size (or something is very wrong).
+                // Ignore the first bytes in swr_buf
+                swr_buf += TO_BYTES(samples_written - cap);
+                // This change in samples_written will impact the
+                // instant_compensation below
+                samples_written = cap;
+            }
+
+            assert(samples_written >= can_write);
+            if (samples_written > can_write) {
+                uint32_t skip_samples = samples_written - can_write;
+                assert(buffered_samples >= skip_samples);
+                sc_audiobuf_skip(&ap->buf, skip_samples);
+                buffered_samples -= skip_samples;
+                if (ap->played) {
+                    // Dropping input samples instantly decreases buffering
+                    ap->avg_buffering.avg -= skip_samples;
+                }
+            }
+
+            // It should remain exactly the expected size to write the new
+            // samples.
+            assert(sc_audiobuf_can_write(&ap->buf) == samples_written);
+        }
+
+        sc_audiobuf_write(&ap->buf, swr_buf, samples_written);
+    }
+
+    buffered_samples += samples_written;
+    assert(buffered_samples == sc_audiobuf_can_read(&ap->buf));
+
+    // Read with lock held, to be used after unlocking
+    bool played = ap->played;
+    uint32_t underflow = ap->underflow;
+
+    if (played) {
+        uint32_t max_buffered_samples = ap->target_buffering
+                                      + 12 * ap->output_buffer
+                                      + ap->target_buffering / 10;
+        if (buffered_samples > max_buffered_samples) {
+            uint32_t skip_samples = buffered_samples - max_buffered_samples;
+            sc_audiobuf_skip(&ap->buf, skip_samples);
+            LOGD("[Audio] Buffering threshold exceeded, skipping %" PRIu32
+                 " samples", skip_samples);
+        }
+
+        // reset (the current value was copied to a local variable)
+        ap->underflow = 0;
+    } else {
+        // SDL playback not started yet, do not accumulate more than
+        // max_initial_buffering samples, this would cause unnecessary delay
+        // (and glitches to compensate) on start.
+        uint32_t max_initial_buffering = ap->target_buffering
+                                       + 2 * ap->output_buffer;
+        if (buffered_samples > max_initial_buffering) {
+            uint32_t skip_samples = buffered_samples - max_initial_buffering;
+            sc_audiobuf_skip(&ap->buf, skip_samples);
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+            LOGD("[Audio] Playback not started, skipping %" PRIu32 " samples",
+                 skip_samples);
+#endif
+        }
+    }
+
+    ap->previous_can_write = sc_audiobuf_can_write(&ap->buf);
+    ap->received = true;
+
+    SDL_UnlockAudioDevice(ap->device);
+
+    if (played) {
+        // Number of samples added (or removed, if negative) for compensation
+        int32_t instant_compensation =
+            (int32_t) samples_written - frame->nb_samples;
+        int32_t inserted_silence = (int32_t) underflow;
+
+        // The compensation must apply instantly, it must not be smoothed
+        ap->avg_buffering.avg += instant_compensation + inserted_silence;
+
+
+        // However, the buffering level must be smoothed
+        sc_average_push(&ap->avg_buffering, buffered_samples);
+
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+        LOGD("[Audio] buffered_samples=%" PRIu32 " avg_buffering=%f",
+             buffered_samples, sc_average_get(&ap->avg_buffering));
+#endif
+
+        ap->samples_since_resync += samples_written;
+        if (ap->samples_since_resync >= ap->sample_rate) {
+            // Recompute compensation every second
+            ap->samples_since_resync = 0;
+
+            float avg = sc_average_get(&ap->avg_buffering);
+            int diff = ap->target_buffering - avg;
+            if (abs(diff) < (int) ap->sample_rate / 1000) {
+                // Do not compensate for less than 1ms, the error is just noise
+                diff = 0;
+            } else if (diff < 0 && buffered_samples < ap->target_buffering) {
+                // Do not accelerate if the instant buffering level is below
+                // the average, this would increase underflow
+                diff = 0;
+            }
+            // Compensate the diff over 4 seconds (but will be recomputed after
+            // 1 second)
+            int distance = 4 * ap->sample_rate;
+            // Limit compensation rate to 2%
+            int abs_max_diff = distance / 50;
+            diff = CLAMP(diff, -abs_max_diff, abs_max_diff);
+            LOGV("[Audio] Buffering: target=%" PRIu32 " avg=%f cur=%" PRIu32
+                 " compensation=%d", ap->target_buffering, avg,
+                 buffered_samples, diff);
+
+            if (diff != ap->compensation) {
+                int ret = swr_set_compensation(swr_ctx, diff, distance);
+                if (ret < 0) {
+                    LOGW("Resampling compensation failed: %d", ret);
+                    // not fatal
+                } else {
+                    ap->compensation = diff;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+static bool
+sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
+                                const AVCodecContext *ctx) {
+    struct sc_audio_player *ap = DOWNCAST(sink);
+#ifdef SCRCPY_LAVU_HAS_CHLAYOUT
+    assert(ctx->ch_layout.nb_channels > 0);
+    unsigned nb_channels = ctx->ch_layout.nb_channels;
+#else
+    int tmp = av_get_channel_layout_nb_channels(ctx->channel_layout);
+    assert(tmp > 0);
+    unsigned nb_channels = tmp;
+#endif
+
+    assert(ctx->sample_rate > 0);
+    assert(!av_sample_fmt_is_planar(SC_AV_SAMPLE_FMT));
+    int out_bytes_per_sample = av_get_bytes_per_sample(SC_AV_SAMPLE_FMT);
+    assert(out_bytes_per_sample > 0);
+
+    ap->sample_rate = ctx->sample_rate;
+    ap->nb_channels = nb_channels;
+    ap->out_bytes_per_sample = out_bytes_per_sample;
+
+    ap->target_buffering = ap->target_buffering_delay * ap->sample_rate
+                                                      / SC_TICK_FREQ;
+
+    uint64_t aout_samples = ap->output_buffer_duration * ap->sample_rate
+                                                       / SC_TICK_FREQ;
+    assert(aout_samples <= 0xFFFF);
+    ap->output_buffer = (uint16_t) aout_samples;
+
+    SDL_AudioSpec desired = {
+        .freq = ctx->sample_rate,
+        .format = SC_SDL_SAMPLE_FMT,
+        .channels = nb_channels,
+        .samples = aout_samples,
+        .callback = sc_audio_player_sdl_callback,
+        .userdata = ap,
+    };
+    SDL_AudioSpec obtained;
+
+    ap->device = SDL_OpenAudioDevice(NULL, 0, &desired, &obtained, 0);
+    if (!ap->device) {
+        LOGE("Could not open audio device: %s", SDL_GetError());
+        return false;
+    }
+
+    SwrContext *swr_ctx = swr_alloc();
+    if (!swr_ctx) {
+        LOG_OOM();
+        goto error_close_audio_device;
+    }
+    ap->swr_ctx = swr_ctx;
+
+#ifdef SCRCPY_LAVU_HAS_CHLAYOUT
+    av_opt_set_chlayout(swr_ctx, "in_chlayout", &ctx->ch_layout, 0);
+    av_opt_set_chlayout(swr_ctx, "out_chlayout", &ctx->ch_layout, 0);
+#else
+    av_opt_set_channel_layout(swr_ctx, "in_channel_layout",
+                              ctx->channel_layout, 0);
+    av_opt_set_channel_layout(swr_ctx, "out_channel_layout",
+                              ctx->channel_layout, 0);
+#endif
+
+    av_opt_set_int(swr_ctx, "in_sample_rate", ctx->sample_rate, 0);
+    av_opt_set_int(swr_ctx, "out_sample_rate", ctx->sample_rate, 0);
+
+    av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", ctx->sample_fmt, 0);
+    av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", SC_AV_SAMPLE_FMT, 0);
+
+    int ret = swr_init(swr_ctx);
+    if (ret) {
+        LOGE("Failed to initialize the resampling context");
+        goto error_free_swr_ctx;
+    }
+
+    // Use a ring-buffer of the target buffering size plus 1 second between the
+    // producer and the consumer. It's too big on purpose, to guarantee that
+    // the producer and the consumer will be able to access it in parallel
+    // without locking.
+    size_t audiobuf_samples = ap->target_buffering + ap->sample_rate;
+
+    size_t sample_size = ap->nb_channels * ap->out_bytes_per_sample;
+    bool ok = sc_audiobuf_init(&ap->buf, sample_size, audiobuf_samples);
+    if (!ok) {
+        goto error_free_swr_ctx;
+    }
+
+    size_t initial_swr_buf_size = TO_BYTES(4096);
+    ap->swr_buf = malloc(initial_swr_buf_size);
+    if (!ap->swr_buf) {
+        LOG_OOM();
+        goto error_destroy_audiobuf;
+    }
+    ap->swr_buf_alloc_size = initial_swr_buf_size;
+
+    ap->previous_can_write = sc_audiobuf_can_write(&ap->buf);
+
+    // Samples are produced and consumed by blocks, so the buffering must be
+    // smoothed to get a relatively stable value.
+    sc_average_init(&ap->avg_buffering, 32);
+    ap->samples_since_resync = 0;
+
+    ap->received = false;
+    ap->played = false;
+    ap->underflow = 0;
+    ap->compensation = 0;
+
+    // The thread calling open() is the thread calling push(), which fills the
+    // audio buffer consumed by the SDL audio thread.
+    ok = sc_thread_set_priority(SC_THREAD_PRIORITY_TIME_CRITICAL);
+    if (!ok) {
+        ok = sc_thread_set_priority(SC_THREAD_PRIORITY_HIGH);
+        (void) ok; // We don't care if it worked, at least we tried
+    }
+
+    SDL_PauseAudioDevice(ap->device, 0);
+
+    return true;
+
+error_destroy_audiobuf:
+    sc_audiobuf_destroy(&ap->buf);
+error_free_swr_ctx:
+    swr_free(&ap->swr_ctx);
+error_close_audio_device:
+    SDL_CloseAudioDevice(ap->device);
+
+    return false;
+}
+
+static void
+sc_audio_player_frame_sink_close(struct sc_frame_sink *sink) {
+    struct sc_audio_player *ap = DOWNCAST(sink);
+
+    assert(ap->device);
+    SDL_PauseAudioDevice(ap->device, 1);
+    SDL_CloseAudioDevice(ap->device);
+
+    free(ap->swr_buf);
+    sc_audiobuf_destroy(&ap->buf);
+    swr_free(&ap->swr_ctx);
+}
+
+void
+sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering,
+                     sc_tick output_buffer_duration) {
+    ap->target_buffering_delay = target_buffering;
+    ap->output_buffer_duration = output_buffer_duration;
+
+    static const struct sc_frame_sink_ops ops = {
+        .open = sc_audio_player_frame_sink_open,
+        .close = sc_audio_player_frame_sink_close,
+        .push = sc_audio_player_frame_sink_push,
+    };
+
+    ap->frame_sink.ops = &ops;
+}

app/src/audio_player.h

@@ -0,0 +1,90 @@
+#ifndef SC_AUDIO_PLAYER_H
+#define SC_AUDIO_PLAYER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include "trait/frame_sink.h"
+#include <util/audiobuf.h>
+#include <util/average.h>
+#include <util/thread.h>
+#include <util/tick.h>
+
+#include <libavformat/avformat.h>
+#include <libswresample/swresample.h>
+#include <SDL2/SDL.h>
+
+struct sc_audio_player {
+    struct sc_frame_sink frame_sink;
+
+    SDL_AudioDeviceID device;
+
+    // The target buffering between the producer and the consumer. This value
+    // is directly use for compensation.
+    // Since audio capture and/or encoding on the device typically produce
+    // blocks of 960 samples (20ms) or 1024 samples (~21.3ms), this target
+    // value should be higher.
+    sc_tick target_buffering_delay;
+    uint32_t target_buffering; // in samples
+
+    // SDL audio output buffer size.
+    sc_tick output_buffer_duration;
+    uint16_t output_buffer;
+
+    // Audio buffer to communicate between the receiver and the SDL audio
+    // callback (protected by SDL_AudioDeviceLock())
+    struct sc_audiobuf buf;
+
+    // The previous empty space in the buffer (only used by the receiver
+    // thread)
+    uint32_t previous_can_write;
+
+    // Resampler (only used from the receiver thread)
+    struct SwrContext *swr_ctx;
+
+    // The sample rate is the same for input and output
+    unsigned sample_rate;
+    // The number of channels is the same for input and output
+    unsigned nb_channels;
+    // The number of bytes per sample for a single channel
+    unsigned out_bytes_per_sample;
+
+    // Target buffer for resampling (only used by the receiver thread)
+    uint8_t *swr_buf;
+    size_t swr_buf_alloc_size;
+
+    // Number of buffered samples (may be negative on underflow) (only used by
+    // the receiver thread)
+    struct sc_average avg_buffering;
+    // Count the number of samples to trigger a compensation update regularly
+    // (only used by the receiver thread)
+    uint32_t samples_since_resync;
+
+    // Number of silence samples inserted since the last received packet
+    // (protected by SDL_AudioDeviceLock())
+    uint32_t underflow;
+
+    // Current applied compensation value (only used by the receiver thread)
+    int compensation;
+
+    // Set to true the first time a sample is received (protected by
+    // SDL_AudioDeviceLock())
+    bool received;
+
+    // Set to true the first time the SDL callback is called (protected by
+    // SDL_AudioDeviceLock())
+    bool played;
+
+    const struct sc_audio_player_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+struct sc_audio_player_callbacks {
+    void (*on_ended)(struct sc_audio_player *ap, bool success, void *userdata);
+};
+
+void
+sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering,
+                     sc_tick audio_output_buffer);
+
+#endif

app/src/clock.c

@@ -1,111 +1,36 @@
 #include "clock.h"
 
+#include <assert.h>
+
 #include "util/log.h"
 
 #define SC_CLOCK_NDEBUG // comment to debug
 
+#define SC_CLOCK_RANGE 32
+
 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;
+    clock->range = 0;
+    clock->offset = 0;
 }
 
 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;
+    if (clock->range < SC_CLOCK_RANGE) {
+        ++clock->range;
     }
 
-        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);
+    sc_tick offset = system - stream;
+    clock->offset = ((clock->range - 1) * clock->offset + offset)
+                  / clock->range;
 
 #ifndef SC_CLOCK_NDEBUG
-        LOGD("Clock estimation: %g * pts + %" PRItick,
-             clock->slope, clock->offset);
+    LOGD("Clock estimation: pts + %" PRItick, 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;
+    assert(clock->range); // sc_clock_update() must have been called
+    return stream + clock->offset;
 }

app/src/clock.h

@@ -3,13 +3,8 @@
 
 #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;
@@ -21,40 +16,18 @@ struct sc_clock_point {
  *
  *     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.
+ * Theoretically, the slope encodes the drift between the device clock and the
+ * computer clock. It is expected to be very close to 1.
  *
- * 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.
+ * Since the clock is used to estimate very close points in the future (which
+ * are reestimated on every clock update, see delay_buffer), the error caused
+ * by clock drift is totally negligible, so it is better to assume that the
+ * slope is 1 than to estimate it (the estimation error would be larger).
  *
- * 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.
+ * Therefore, only the offset is estimated.
  */
 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;
+    unsigned range;
     sc_tick offset;
 };
 

app/src/common.h

@@ -1,12 +1,13 @@
-#ifndef COMMON_H
-#define COMMON_H
+#ifndef SC_COMMON_H
+#define SC_COMMON_H
 
 #include "config.h"
 #include "compat.h"
 
 #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 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)))

app/src/compat.c

@@ -3,6 +3,9 @@
 #include "config.h"
 
 #include <assert.h>
+#ifndef HAVE_REALLOCARRAY
+# include <errno.h>
+#endif
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
@@ -51,3 +54,57 @@ int vasprintf(char **strp, const char *fmt, va_list ap) {
     return len;
 }
 #endif
+
+#if !defined(HAVE_NRAND48) || !defined(HAVE_JRAND48)
+#define SC_RAND48_MASK UINT64_C(0xFFFFFFFFFFFF) // 48 bits
+#define SC_RAND48_A UINT64_C(0x5DEECE66D)
+#define SC_RAND48_C 0xB
+static inline uint64_t rand_iter48(uint64_t x) {
+    assert((x & ~SC_RAND48_MASK) == 0);
+    return (x * SC_RAND48_A + SC_RAND48_C) & SC_RAND48_MASK;
+}
+
+static uint64_t rand_iter48_xsubi(unsigned short xsubi[3]) {
+    uint64_t x = ((uint64_t) xsubi[0] << 32)
+               | ((uint64_t) xsubi[1] << 16)
+               | xsubi[2];
+
+    x = rand_iter48(x);
+
+    xsubi[0] = (x >> 32) & 0XFFFF;
+    xsubi[1] = (x >> 16) & 0XFFFF;
+    xsubi[2] = x & 0XFFFF;
+
+    return x;
+}
+
+#ifndef HAVE_NRAND48
+long nrand48(unsigned short xsubi[3]) {
+    // range [0, 2^31)
+    return rand_iter48_xsubi(xsubi) >> 17;
+}
+#endif
+
+#ifndef HAVE_JRAND48
+long jrand48(unsigned short xsubi[3]) {
+    // range [-2^31, 2^31)
+    union {
+        uint32_t u;
+        int32_t i;
+    } v;
+    v.u = rand_iter48_xsubi(xsubi) >> 16;
+    return v.i;
+}
+#endif
+#endif
+
+#ifndef HAVE_REALLOCARRAY
+void *reallocarray(void *ptr, size_t nmemb, size_t size) {
+    size_t bytes;
+    if (__builtin_mul_overflow(nmemb, size, &bytes)) {
+      errno = ENOMEM;
+      return NULL;
+    }
+    return realloc(ptr, bytes);
+}
+#endif

app/src/compat.h

@@ -1,5 +1,5 @@
-#ifndef COMPAT_H
-#define COMPAT_H
+#ifndef SC_COMPAT_H
+#define SC_COMPAT_H
 
 #include "config.h"
 
@@ -8,8 +8,10 @@
 
 #ifndef __WIN32
 # define PRIu64_ PRIu64
+# define SC_PRIsizet "zu"
 #else
 # define PRIu64_ "I64u"  // Windows...
+# define SC_PRIsizet "Iu"
 #endif
 
 // In ffmpeg/doc/APIchanges:
@@ -23,6 +25,12 @@
 # define SCRCPY_LAVF_REQUIRES_REGISTER_ALL
 #endif
 
+// Not documented in ffmpeg/doc/APIchanges, but AV_CODEC_ID_AV1 has been added
+// by FFmpeg commit d42809f9835a4e9e5c7c63210abb09ad0ef19cfb (included in tag
+// n3.3).
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 89, 100)
+# define SCRCPY_LAVC_HAS_AV1
+#endif
 
 // In ffmpeg/doc/APIchanges:
 // 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
@@ -35,6 +43,13 @@
 # define SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
 #endif
 
+// Not documented in ffmpeg/doc/APIchanges, but the channel_layout API
+// has been replaced by chlayout in FFmpeg commit
+// f423497b455da06c1337846902c770028760e094.
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(57, 23, 100)
+# define SCRCPY_LAVU_HAS_CHLAYOUT
+#endif
+
 #if SDL_VERSION_ATLEAST(2, 0, 6)
 // <https://github.com/libsdl-org/SDL/commit/d7a318de563125e5bb465b1000d6bc9576fbc6fc>
 # define SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
@@ -45,6 +60,10 @@
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
 #endif
 
+#if SDL_VERSION_ATLEAST(2, 0, 16)
+# define SCRCPY_SDL_HAS_THREAD_PRIORITY_TIME_CRITICAL
+#endif
+
 #ifndef HAVE_STRDUP
 char *strdup(const char *s);
 #endif
@@ -57,4 +76,16 @@ int asprintf(char **strp, const char *fmt, ...);
 int vasprintf(char **strp, const char *fmt, va_list ap);
 #endif
 
+#ifndef HAVE_NRAND48
+long nrand48(unsigned short xsubi[3]);
+#endif
+
+#ifndef HAVE_JRAND48
+long jrand48(unsigned short xsubi[3]);
+#endif
+
+#ifndef HAVE_REALLOCARRAY
+void *reallocarray(void *ptr, size_t nmemb, size_t size);
+#endif
+
 #endif

app/src/control_msg.c

@@ -5,7 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "util/buffer_util.h"
+#include "util/binary.h"
 #include "util/log.h"
 #include "util/str.h"
 
@@ -37,7 +37,7 @@ static const char *const android_motionevent_action_labels[] = {
     "move",
     "cancel",
     "outside",
-    "ponter-down",
+    "pointer-down",
     "pointer-up",
     "hover-move",
     "scroll",
@@ -61,86 +61,95 @@ static const char *const copy_key_labels[] = {
     "cut",
 };
 
+static inline const char *
+get_well_known_pointer_id_name(uint64_t pointer_id) {
+    switch (pointer_id) {
+        case POINTER_ID_MOUSE:
+            return "mouse";
+        case POINTER_ID_GENERIC_FINGER:
+            return "finger";
+        case POINTER_ID_VIRTUAL_MOUSE:
+            return "vmouse";
+        case POINTER_ID_VIRTUAL_FINGER:
+            return "vfinger";
+        default:
+            return NULL;
+    }
+}
+
 static void
 write_position(uint8_t *buf, const struct sc_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);
+    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 length (4 bytes) + string (non null-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);
-    buffer_write32be(buf, len);
+    sc_write32be(buf, len);
     memcpy(&buf[4], utf8, len);
     return 4 + len;
 }
 
-static uint16_t
-to_fixed_point_16(float f) {
-    assert(f >= 0.0f && f <= 1.0f);
-    uint32_t u = f * 0x1p16f; // 2^16
-    if (u >= 0xffff) {
-        u = 0xffff;
-    }
-    return (uint16_t) u;
-}
-
 size_t
-control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
+sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
     buf[0] = msg->type;
     switch (msg->type) {
-        case CONTROL_MSG_TYPE_INJECT_KEYCODE:
+        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
             buf[1] = msg->inject_keycode.action;
-            buffer_write32be(&buf[2], msg->inject_keycode.keycode);
-            buffer_write32be(&buf[6], msg->inject_keycode.repeat);
-            buffer_write32be(&buf[10], msg->inject_keycode.metastate);
+            sc_write32be(&buf[2], msg->inject_keycode.keycode);
+            sc_write32be(&buf[6], msg->inject_keycode.repeat);
+            sc_write32be(&buf[10], msg->inject_keycode.metastate);
             return 14;
-        case CONTROL_MSG_TYPE_INJECT_TEXT: {
+        case SC_CONTROL_MSG_TYPE_INJECT_TEXT: {
             size_t len =
                 write_string(msg->inject_text.text,
-                             CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
+                             SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
             return 1 + len;
         }
-        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
+        case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
             buf[1] = msg->inject_touch_event.action;
-            buffer_write64be(&buf[2], msg->inject_touch_event.pointer_id);
+            sc_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);
-            buffer_write16be(&buf[22], pressure);
-            buffer_write32be(&buf[24], msg->inject_touch_event.buttons);
-            return 28;
-        case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
+                sc_float_to_u16fp(msg->inject_touch_event.pressure);
+            sc_write16be(&buf[22], pressure);
+            sc_write32be(&buf[24], msg->inject_touch_event.action_button);
+            sc_write32be(&buf[28], msg->inject_touch_event.buttons);
+            return 32;
+        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
             write_position(&buf[1], &msg->inject_scroll_event.position);
-            buffer_write32be(&buf[13],
-                             (uint32_t) msg->inject_scroll_event.hscroll);
-            buffer_write32be(&buf[17],
-                             (uint32_t) msg->inject_scroll_event.vscroll);
+            int16_t hscroll =
+                sc_float_to_i16fp(msg->inject_scroll_event.hscroll);
+            int16_t vscroll =
+                sc_float_to_i16fp(msg->inject_scroll_event.vscroll);
+            sc_write16be(&buf[13], (uint16_t) hscroll);
+            sc_write16be(&buf[15], (uint16_t) vscroll);
+            sc_write32be(&buf[17], msg->inject_scroll_event.buttons);
             return 21;
-        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
+        case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
             buf[1] = msg->inject_keycode.action;
             return 2;
-        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
+        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
             buf[1] = msg->get_clipboard.copy_key;
             return 2;
-        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
-            buffer_write64be(&buf[1], msg->set_clipboard.sequence);
+        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
+            sc_write64be(&buf[1], msg->set_clipboard.sequence);
             buf[9] = !!msg->set_clipboard.paste;
             size_t len = write_string(msg->set_clipboard.text,
-                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
+                                      SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
                                       &buf[10]);
             return 10 + len;
-        }
-        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
+        case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
             buf[1] = msg->set_screen_power_mode.mode;
             return 2;
-        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
-        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
-        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
+        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:
             // no additional data
             return 1;
         default:
@@ -150,82 +159,87 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
 }
 
 void
-control_msg_log(const struct control_msg *msg) {
+sc_control_msg_log(const struct sc_control_msg *msg) {
 #define LOG_CMSG(fmt, ...) LOGV("input: " fmt, ## __VA_ARGS__)
     switch (msg->type) {
-        case CONTROL_MSG_TYPE_INJECT_KEYCODE:
+        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 CONTROL_MSG_TYPE_INJECT_TEXT:
+        case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
             LOG_CMSG("text \"%s\"", msg->inject_text.text);
             break;
-        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: {
+        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) {
+            const char *pointer_name = get_well_known_pointer_id_name(id);
+            if (pointer_name) {
                 // string pointer id
                 LOG_CMSG("touch [id=%s] %-4s position=%" PRIi32 ",%" PRIi32
-                             " pressure=%g buttons=%06lx",
-                         id == POINTER_ID_MOUSE ? "mouse" : "vfinger",
+                             " pressure=%f action_button=%06lx buttons=%06lx",
+                         pointer_name,
                          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.action_button,
                          (long) msg->inject_touch_event.buttons);
             } else {
                 // numeric pointer id
                 LOG_CMSG("touch [id=%" PRIu64_ "] %-4s position=%" PRIi32 ",%"
-                             PRIi32 " pressure=%g buttons=%06lx",
+                             PRIi32 " pressure=%f action_button=%06lx"
+                             " 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.action_button,
                          (long) msg->inject_touch_event.buttons);
             }
             break;
         }
-        case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
-            LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%" PRIi32
-                         " vscroll=%" PRIi32,
+        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
+            LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%f"
+                         " vscroll=%f 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);
+                     msg->inject_scroll_event.vscroll,
+                     (long) msg->inject_scroll_event.buttons);
             break;
-        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
+        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 CONTROL_MSG_TYPE_GET_CLIPBOARD:
+        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
             LOG_CMSG("get clipboard copy_key=%s",
                      copy_key_labels[msg->get_clipboard.copy_key]);
             break;
-        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
+        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 CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
+        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 CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
+        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
             LOG_CMSG("expand notification panel");
             break;
-        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
+        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
             LOG_CMSG("expand settings panel");
             break;
-        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
+        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
             LOG_CMSG("collapse panels");
             break;
-        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
+        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
             LOG_CMSG("rotate device");
             break;
         default:
@@ -235,12 +249,12 @@ control_msg_log(const struct control_msg *msg) {
 }
 
 void
-control_msg_destroy(struct control_msg *msg) {
+sc_control_msg_destroy(struct sc_control_msg *msg) {
     switch (msg->type) {
-        case CONTROL_MSG_TYPE_INJECT_TEXT:
+        case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
             free(msg->inject_text.text);
             break;
-        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
+        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
             free(msg->set_clipboard.text);
             break;
         default:

app/src/control_msg.h

@@ -1,5 +1,5 @@
-#ifndef CONTROLMSG_H
-#define CONTROLMSG_H
+#ifndef SC_CONTROLMSG_H
+#define SC_CONTROLMSG_H
 
 #include "common.h"
 
@@ -11,44 +11,48 @@
 #include "android/keycodes.h"
 #include "coords.h"
 
-#define CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
+#define SC_CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
 
-#define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
+#define SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
 // type: 1 byte; sequence: 8 bytes; paste flag: 1 byte; length: 4 bytes
-#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (CONTROL_MSG_MAX_SIZE - 14)
+#define SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (SC_CONTROL_MSG_MAX_SIZE - 14)
 
 #define POINTER_ID_MOUSE UINT64_C(-1)
-#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2)
+#define POINTER_ID_GENERIC_FINGER UINT64_C(-2)
 
-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_EXPAND_SETTINGS_PANEL,
-    CONTROL_MSG_TYPE_COLLAPSE_PANELS,
-    CONTROL_MSG_TYPE_GET_CLIPBOARD,
-    CONTROL_MSG_TYPE_SET_CLIPBOARD,
-    CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
-    CONTROL_MSG_TYPE_ROTATE_DEVICE,
+// Used for injecting an additional virtual pointer for pinch-to-zoom
+#define POINTER_ID_VIRTUAL_MOUSE UINT64_C(-3)
+#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-4)
+
+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 screen_power_mode {
+enum sc_screen_power_mode {
     // see <https://android.googlesource.com/platform/frameworks/base.git/+/pie-release-2/core/java/android/view/SurfaceControl.java#305>
-    SCREEN_POWER_MODE_OFF = 0,
-    SCREEN_POWER_MODE_NORMAL = 2,
+    SC_SCREEN_POWER_MODE_OFF = 0,
+    SC_SCREEN_POWER_MODE_NORMAL = 2,
 };
 
-enum get_clipboard_copy_key {
-    GET_CLIPBOARD_COPY_KEY_NONE,
-    GET_CLIPBOARD_COPY_KEY_COPY,
-    GET_CLIPBOARD_COPY_KEY_CUT,
+enum sc_copy_key {
+    SC_COPY_KEY_NONE,
+    SC_COPY_KEY_COPY,
+    SC_COPY_KEY_CUT,
 };
 
-struct control_msg {
-    enum control_msg_type type;
+struct sc_control_msg {
+    enum sc_control_msg_type type;
     union {
         struct {
             enum android_keyevent_action action;
@@ -61,6 +65,7 @@ struct control_msg {
         } inject_text;
         struct {
             enum android_motionevent_action action;
+            enum android_motionevent_buttons action_button;
             enum android_motionevent_buttons buttons;
             uint64_t pointer_id;
             struct sc_position position;
@@ -68,15 +73,16 @@ struct control_msg {
         } inject_touch_event;
         struct {
             struct sc_position position;
-            int32_t hscroll;
-            int32_t vscroll;
+            float hscroll;
+            float 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 get_clipboard_copy_key copy_key;
+            enum sc_copy_key copy_key;
         } get_clipboard;
         struct {
             uint64_t sequence;
@@ -84,7 +90,7 @@ struct control_msg {
             bool paste;
         } set_clipboard;
         struct {
-            enum screen_power_mode mode;
+            enum sc_screen_power_mode mode;
         } set_screen_power_mode;
     };
 };
@@ -92,12 +98,12 @@ struct control_msg {
 // buf size must be at least CONTROL_MSG_MAX_SIZE
 // return the number of bytes written
 size_t
-control_msg_serialize(const struct control_msg *msg, unsigned char *buf);
+sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf);
 
 void
-control_msg_log(const struct control_msg *msg);
+sc_control_msg_log(const struct sc_control_msg *msg);
 
 void
-control_msg_destroy(struct control_msg *msg);
+sc_control_msg_destroy(struct sc_control_msg *msg);
 
 #endif

app/src/controller.c

@@ -4,26 +4,36 @@
 
 #include "util/log.h"
 
-bool
-controller_init(struct controller *controller, sc_socket control_socket,
-                struct sc_acksync *acksync) {
-    cbuf_init(&controller->queue);
+#define SC_CONTROL_MSG_QUEUE_MAX 64
 
-    bool ok = receiver_init(&controller->receiver, control_socket, acksync);
+bool
+sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
+                   struct sc_acksync *acksync) {
+    sc_vecdeque_init(&controller->queue);
+
+    bool ok = sc_vecdeque_reserve(&controller->queue, SC_CONTROL_MSG_QUEUE_MAX);
     if (!ok) {
         return false;
     }
 
+    ok = sc_receiver_init(&controller->receiver, control_socket, acksync);
+    if (!ok) {
+        sc_vecdeque_destroy(&controller->queue);
+        return false;
+    }
+
     ok = sc_mutex_init(&controller->mutex);
     if (!ok) {
-        receiver_destroy(&controller->receiver);
+        sc_receiver_destroy(&controller->receiver);
+        sc_vecdeque_destroy(&controller->queue);
         return false;
     }
 
     ok = sc_cond_init(&controller->msg_cond);
     if (!ok) {
-        receiver_destroy(&controller->receiver);
+        sc_receiver_destroy(&controller->receiver);
         sc_mutex_destroy(&controller->mutex);
+        sc_vecdeque_destroy(&controller->queue);
         return false;
     }
 
@@ -34,39 +44,48 @@ controller_init(struct controller *controller, sc_socket control_socket,
 }
 
 void
-controller_destroy(struct controller *controller) {
+sc_controller_destroy(struct sc_controller *controller) {
     sc_cond_destroy(&controller->msg_cond);
     sc_mutex_destroy(&controller->mutex);
 
-    struct control_msg msg;
-    while (cbuf_take(&controller->queue, &msg)) {
-        control_msg_destroy(&msg);
+    while (!sc_vecdeque_is_empty(&controller->queue)) {
+        struct sc_control_msg *msg = sc_vecdeque_popref(&controller->queue);
+        assert(msg);
+        sc_control_msg_destroy(msg);
     }
+    sc_vecdeque_destroy(&controller->queue);
 
-    receiver_destroy(&controller->receiver);
+    sc_receiver_destroy(&controller->receiver);
 }
 
 bool
-controller_push_msg(struct controller *controller,
-                    const struct control_msg *msg) {
+sc_controller_push_msg(struct sc_controller *controller,
+                       const struct sc_control_msg *msg) {
     if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
-        control_msg_log(msg);
+        sc_control_msg_log(msg);
     }
 
     sc_mutex_lock(&controller->mutex);
-    bool was_empty = cbuf_is_empty(&controller->queue);
-    bool res = cbuf_push(&controller->queue, *msg);
+    bool full = sc_vecdeque_is_full(&controller->queue);
+    if (!full) {
+        bool was_empty = sc_vecdeque_is_empty(&controller->queue);
+        sc_vecdeque_push_noresize(&controller->queue, *msg);
         if (was_empty) {
             sc_cond_signal(&controller->msg_cond);
         }
+    }
+    // Otherwise (if the queue is full), the msg is discarded
+
     sc_mutex_unlock(&controller->mutex);
-    return res;
+
+    return !full;
 }
 
 static bool
-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);
+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);
     if (!length) {
         return false;
     }
@@ -77,11 +96,12 @@ process_msg(struct controller *controller, const struct control_msg *msg) {
 
 static int
 run_controller(void *data) {
-    struct controller *controller = data;
+    struct sc_controller *controller = data;
 
     for (;;) {
         sc_mutex_lock(&controller->mutex);
-        while (!controller->stopped && cbuf_is_empty(&controller->queue)) {
+        while (!controller->stopped
+                && sc_vecdeque_is_empty(&controller->queue)) {
             sc_cond_wait(&controller->msg_cond, &controller->mutex);
         }
         if (controller->stopped) {
@@ -89,14 +109,13 @@ run_controller(void *data) {
             sc_mutex_unlock(&controller->mutex);
             break;
         }
-        struct control_msg msg;
-        bool non_empty = cbuf_take(&controller->queue, &msg);
-        assert(non_empty);
-        (void) non_empty;
+
+        assert(!sc_vecdeque_is_empty(&controller->queue));
+        struct sc_control_msg msg = sc_vecdeque_pop(&controller->queue);
         sc_mutex_unlock(&controller->mutex);
 
         bool ok = process_msg(controller, &msg);
-        control_msg_destroy(&msg);
+        sc_control_msg_destroy(&msg);
         if (!ok) {
             LOGD("Could not write msg to socket");
             break;
@@ -106,18 +125,18 @@ run_controller(void *data) {
 }
 
 bool
-controller_start(struct controller *controller) {
+sc_controller_start(struct sc_controller *controller) {
     LOGD("Starting controller thread");
 
     bool ok = sc_thread_create(&controller->thread, run_controller,
                                "scrcpy-ctl", controller);
     if (!ok) {
-        LOGC("Could not start controller thread");
+        LOGE("Could not start controller thread");
         return false;
     }
 
-    if (!receiver_start(&controller->receiver)) {
-        controller_stop(controller);
+    if (!sc_receiver_start(&controller->receiver)) {
+        sc_controller_stop(controller);
         sc_thread_join(&controller->thread, NULL);
         return false;
     }
@@ -126,7 +145,7 @@ controller_start(struct controller *controller) {
 }
 
 void
-controller_stop(struct controller *controller) {
+sc_controller_stop(struct sc_controller *controller) {
     sc_mutex_lock(&controller->mutex);
     controller->stopped = true;
     sc_cond_signal(&controller->msg_cond);
@@ -134,7 +153,7 @@ controller_stop(struct controller *controller) {
 }
 
 void
-controller_join(struct controller *controller) {
+sc_controller_join(struct sc_controller *controller) {
     sc_thread_join(&controller->thread, NULL);
-    receiver_join(&controller->receiver);
+    sc_receiver_join(&controller->receiver);
 }

app/src/controller.h

@@ -1,5 +1,5 @@
-#ifndef CONTROLLER_H
-#define CONTROLLER_H
+#ifndef SC_CONTROLLER_H
+#define SC_CONTROLLER_H
 
 #include "common.h"
 
@@ -8,40 +8,40 @@
 #include "control_msg.h"
 #include "receiver.h"
 #include "util/acksync.h"
-#include "util/cbuf.h"
 #include "util/net.h"
 #include "util/thread.h"
+#include "util/vecdeque.h"
 
-struct control_msg_queue CBUF(struct control_msg, 64);
+struct sc_control_msg_queue SC_VECDEQUE(struct sc_control_msg);
 
-struct controller {
+struct sc_controller {
     sc_socket control_socket;
     sc_thread thread;
     sc_mutex mutex;
     sc_cond msg_cond;
     bool stopped;
-    struct control_msg_queue queue;
-    struct receiver receiver;
+    struct sc_control_msg_queue queue;
+    struct sc_receiver receiver;
 };
 
 bool
-controller_init(struct controller *controller, sc_socket control_socket,
+sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
                    struct sc_acksync *acksync);
 
 void
-controller_destroy(struct controller *controller);
+sc_controller_destroy(struct sc_controller *controller);
 
 bool
-controller_start(struct controller *controller);
+sc_controller_start(struct sc_controller *controller);
 
 void
-controller_stop(struct controller *controller);
+sc_controller_stop(struct sc_controller *controller);
 
 void
-controller_join(struct controller *controller);
+sc_controller_join(struct sc_controller *controller);
 
 bool
-controller_push_msg(struct controller *controller,
-                    const struct control_msg *msg);
+sc_controller_push_msg(struct sc_controller *controller,
+                       const struct sc_control_msg *msg);
 
 #endif

app/src/decoder.c

@@ -2,162 +2,108 @@
 
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
+#include <libavutil/channel_layout.h>
 
 #include "events.h"
-#include "video_buffer.h"
 #include "trait/frame_sink.h"
 #include "util/log.h"
 
 /** Downcast packet_sink to decoder */
-#define DOWNCAST(SINK) container_of(SINK, struct decoder, packet_sink)
-
-static void
-decoder_close_first_sinks(struct decoder *decoder, unsigned count) {
-    while (count) {
-        struct sc_frame_sink *sink = decoder->sinks[--count];
-        sink->ops->close(sink);
-    }
-}
-
-static inline void
-decoder_close_sinks(struct decoder *decoder) {
-    decoder_close_first_sinks(decoder, decoder->sink_count);
-}
+#define DOWNCAST(SINK) container_of(SINK, struct sc_decoder, packet_sink)
 
 static bool
-decoder_open_sinks(struct 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);
-            decoder_close_first_sinks(decoder, i);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static bool
-decoder_open(struct decoder *decoder, const AVCodec *codec) {
-    decoder->codec_ctx = avcodec_alloc_context3(codec);
-    if (!decoder->codec_ctx) {
-        LOG_OOM();
-        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;
-    }
-
+sc_decoder_open(struct sc_decoder *decoder, AVCodecContext *ctx) {
     decoder->frame = av_frame_alloc();
     if (!decoder->frame) {
         LOG_OOM();
-        avcodec_close(decoder->codec_ctx);
-        avcodec_free_context(&decoder->codec_ctx);
         return false;
     }
 
-    if (!decoder_open_sinks(decoder)) {
-        LOGE("Could not open decoder sinks");
+    if (!sc_frame_source_sinks_open(&decoder->frame_source, ctx)) {
         av_frame_free(&decoder->frame);
-        avcodec_close(decoder->codec_ctx);
-        avcodec_free_context(&decoder->codec_ctx);
         return false;
     }
 
+    decoder->ctx = ctx;
+
     return true;
 }
 
 static void
-decoder_close(struct decoder *decoder) {
-    decoder_close_sinks(decoder);
+sc_decoder_close(struct sc_decoder *decoder) {
+    sc_frame_source_sinks_close(&decoder->frame_source);
     av_frame_free(&decoder->frame);
-    avcodec_close(decoder->codec_ctx);
-    avcodec_free_context(&decoder->codec_ctx);
 }
 
 static bool
-push_frame_to_sinks(struct 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
-decoder_push(struct decoder *decoder, const AVPacket *packet) {
+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);
+    int ret = avcodec_send_packet(decoder->ctx, packet);
     if (ret < 0 && ret != AVERROR(EAGAIN)) {
-        LOGE("Could not send video packet: %d", ret);
+        LOGE("Decoder '%s': could not send video packet: %d",
+             decoder->name, ret);
         return false;
     }
-    ret = avcodec_receive_frame(decoder->codec_ctx, decoder->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);
-    } else if (ret != AVERROR(EAGAIN)) {
-        LOGE("Could not receive video frame: %d", ret);
+    for (;;) {
+        ret = avcodec_receive_frame(decoder->ctx, decoder->frame);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
+            break;
+        }
+
+        if (ret) {
+            LOGE("Decoder '%s', could not receive video frame: %d",
+                 decoder->name, ret);
             return false;
         }
+
+        // a frame was received
+        bool ok = sc_frame_source_sinks_push(&decoder->frame_source,
+                                             decoder->frame);
+        av_frame_unref(decoder->frame);
+        if (!ok) {
+            // Error already logged
+            return false;
+        }
+    }
+
     return true;
 }
 
 static bool
-decoder_packet_sink_open(struct sc_packet_sink *sink, const AVCodec *codec) {
-    struct decoder *decoder = DOWNCAST(sink);
-    return decoder_open(decoder, codec);
+sc_decoder_packet_sink_open(struct sc_packet_sink *sink, AVCodecContext *ctx) {
+    struct sc_decoder *decoder = DOWNCAST(sink);
+    return sc_decoder_open(decoder, ctx);
 }
 
 static void
-decoder_packet_sink_close(struct sc_packet_sink *sink) {
-    struct decoder *decoder = DOWNCAST(sink);
-    decoder_close(decoder);
+sc_decoder_packet_sink_close(struct sc_packet_sink *sink) {
+    struct sc_decoder *decoder = DOWNCAST(sink);
+    sc_decoder_close(decoder);
 }
 
 static bool
-decoder_packet_sink_push(struct sc_packet_sink *sink, const AVPacket *packet) {
-    struct decoder *decoder = DOWNCAST(sink);
-    return decoder_push(decoder, packet);
+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
-decoder_init(struct decoder *decoder) {
-    decoder->sink_count = 0;
+sc_decoder_init(struct sc_decoder *decoder, const char *name) {
+    decoder->name = name; // statically allocated
+    sc_frame_source_init(&decoder->frame_source);
 
     static const struct sc_packet_sink_ops ops = {
-        .open = decoder_packet_sink_open,
-        .close = decoder_packet_sink_close,
-        .push = decoder_packet_sink_push,
+        .open = sc_decoder_packet_sink_open,
+        .close = sc_decoder_packet_sink_close,
+        .push = sc_decoder_packet_sink_push,
     };
 
     decoder->packet_sink.ops = &ops;
 }
-
-void
-decoder_add_sink(struct decoder *decoder, struct sc_frame_sink *sink) {
-    assert(decoder->sink_count < DECODER_MAX_SINKS);
-    assert(sink);
-    assert(sink->ops);
-    decoder->sinks[decoder->sink_count++] = sink;
-}

app/src/decoder.h

@@ -1,29 +1,27 @@
-#ifndef DECODER_H
-#define DECODER_H
+#ifndef SC_DECODER_H
+#define SC_DECODER_H
 
 #include "common.h"
 
+#include "trait/frame_source.h"
 #include "trait/packet_sink.h"
 
 #include <stdbool.h>
+#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 
-#define DECODER_MAX_SINKS 2
-
-struct decoder {
+struct sc_decoder {
     struct sc_packet_sink packet_sink; // packet sink trait
+    struct sc_frame_source frame_source; // frame source trait
 
-    struct sc_frame_sink *sinks[DECODER_MAX_SINKS];
-    unsigned sink_count;
+    const char *name; // must be statically allocated (e.g. a string literal)
 
-    AVCodecContext *codec_ctx;
+    AVCodecContext *ctx;
     AVFrame *frame;
 };
 
+// The name must be statically allocated (e.g. a string literal)
 void
-decoder_init(struct decoder *decoder);
-
-void
-decoder_add_sink(struct decoder *decoder, struct sc_frame_sink *sink);
+sc_decoder_init(struct sc_decoder *decoder, const char *name);
 
 #endif

app/src/delay_buffer.c

@@ -0,0 +1,244 @@
+#include "delay_buffer.h"
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include <libavutil/avutil.h>
+#include <libavformat/avformat.h>
+
+#include "util/log.h"
+
+#define SC_BUFFERING_NDEBUG // comment to debug
+
+/** Downcast frame_sink to sc_delay_buffer */
+#define DOWNCAST(SINK) container_of(SINK, struct sc_delay_buffer, frame_sink)
+
+static bool
+sc_delayed_frame_init(struct sc_delayed_frame *dframe, const AVFrame *frame) {
+    dframe->frame = av_frame_alloc();
+    if (!dframe->frame) {
+        LOG_OOM();
+        return false;
+    }
+
+    if (av_frame_ref(dframe->frame, frame)) {
+        LOG_OOM();
+        av_frame_free(&dframe->frame);
+        return false;
+    }
+
+    return true;
+}
+
+static void
+sc_delayed_frame_destroy(struct sc_delayed_frame *dframe) {
+    av_frame_unref(dframe->frame);
+    av_frame_free(&dframe->frame);
+}
+
+static int
+run_buffering(void *data) {
+    struct sc_delay_buffer *db = data;
+
+    assert(db->delay > 0);
+
+    for (;;) {
+        sc_mutex_lock(&db->mutex);
+
+        while (!db->stopped && sc_vecdeque_is_empty(&db->queue)) {
+            sc_cond_wait(&db->queue_cond, &db->mutex);
+        }
+
+        if (db->stopped) {
+            sc_mutex_unlock(&db->mutex);
+            goto stopped;
+        }
+
+        struct sc_delayed_frame dframe = sc_vecdeque_pop(&db->queue);
+
+        sc_tick max_deadline = sc_tick_now() + db->delay;
+        // PTS (written by the server) are expressed in microseconds
+        sc_tick pts = SC_TICK_FROM_US(dframe.frame->pts);
+
+        bool timed_out = false;
+        while (!db->stopped && !timed_out) {
+            sc_tick deadline = sc_clock_to_system_time(&db->clock, pts)
+                             + db->delay;
+            if (deadline > max_deadline) {
+                deadline = max_deadline;
+            }
+
+            timed_out =
+                !sc_cond_timedwait(&db->wait_cond, &db->mutex, deadline);
+        }
+
+        bool stopped = db->stopped;
+        sc_mutex_unlock(&db->mutex);
+
+        if (stopped) {
+            sc_delayed_frame_destroy(&dframe);
+            goto stopped;
+        }
+
+#ifndef SC_BUFFERING_NDEBUG
+        LOGD("Buffering: %" PRItick ";%" PRItick ";%" PRItick,
+             pts, dframe.push_date, sc_tick_now());
+#endif
+
+        bool ok = sc_frame_source_sinks_push(&db->frame_source, dframe.frame);
+        sc_delayed_frame_destroy(&dframe);
+        if (!ok) {
+            LOGE("Delayed frame could not be pushed, stopping");
+            sc_mutex_lock(&db->mutex);
+            // Prevent to push any new frame
+            db->stopped = true;
+            sc_mutex_unlock(&db->mutex);
+            goto stopped;
+        }
+    }
+
+stopped:
+    assert(db->stopped);
+
+    // Flush queue
+    while (!sc_vecdeque_is_empty(&db->queue)) {
+        struct sc_delayed_frame *dframe = sc_vecdeque_popref(&db->queue);
+        sc_delayed_frame_destroy(dframe);
+    }
+
+    LOGD("Buffering thread ended");
+
+    return 0;
+}
+
+static bool
+sc_delay_buffer_frame_sink_open(struct sc_frame_sink *sink,
+                                const AVCodecContext *ctx) {
+    struct sc_delay_buffer *db = DOWNCAST(sink);
+    (void) ctx;
+
+    bool ok = sc_mutex_init(&db->mutex);
+    if (!ok) {
+        return false;
+    }
+
+    ok = sc_cond_init(&db->queue_cond);
+    if (!ok) {
+        goto error_destroy_mutex;
+    }
+
+    ok = sc_cond_init(&db->wait_cond);
+    if (!ok) {
+        goto error_destroy_queue_cond;
+    }
+
+    sc_clock_init(&db->clock);
+    sc_vecdeque_init(&db->queue);
+
+    if (!sc_frame_source_sinks_open(&db->frame_source, ctx)) {
+        goto error_destroy_wait_cond;
+    }
+
+    ok = sc_thread_create(&db->thread, run_buffering, "scrcpy-dbuf", db);
+    if (!ok) {
+        LOGE("Could not start buffering thread");
+        goto error_close_sinks;
+    }
+
+    return true;
+
+error_close_sinks:
+    sc_frame_source_sinks_close(&db->frame_source);
+error_destroy_wait_cond:
+    sc_cond_destroy(&db->wait_cond);
+error_destroy_queue_cond:
+    sc_cond_destroy(&db->queue_cond);
+error_destroy_mutex:
+    sc_mutex_destroy(&db->mutex);
+
+    return false;
+}
+
+static void
+sc_delay_buffer_frame_sink_close(struct sc_frame_sink *sink) {
+    struct sc_delay_buffer *db = DOWNCAST(sink);
+
+    sc_mutex_lock(&db->mutex);
+    db->stopped = true;
+    sc_cond_signal(&db->queue_cond);
+    sc_cond_signal(&db->wait_cond);
+    sc_mutex_unlock(&db->mutex);
+
+    sc_thread_join(&db->thread, NULL);
+
+    sc_frame_source_sinks_close(&db->frame_source);
+
+    sc_cond_destroy(&db->wait_cond);
+    sc_cond_destroy(&db->queue_cond);
+    sc_mutex_destroy(&db->mutex);
+}
+
+static bool
+sc_delay_buffer_frame_sink_push(struct sc_frame_sink *sink,
+                                const AVFrame *frame) {
+    struct sc_delay_buffer *db = DOWNCAST(sink);
+
+    sc_mutex_lock(&db->mutex);
+
+    if (db->stopped) {
+        sc_mutex_unlock(&db->mutex);
+        return false;
+    }
+
+    sc_tick pts = SC_TICK_FROM_US(frame->pts);
+    sc_clock_update(&db->clock, sc_tick_now(), pts);
+    sc_cond_signal(&db->wait_cond);
+
+    if (db->first_frame_asap && db->clock.range == 1) {
+        sc_mutex_unlock(&db->mutex);
+        return sc_frame_source_sinks_push(&db->frame_source, frame);
+    }
+
+    struct sc_delayed_frame dframe;
+    bool ok = sc_delayed_frame_init(&dframe, frame);
+    if (!ok) {
+        sc_mutex_unlock(&db->mutex);
+        return false;
+    }
+
+#ifndef SC_BUFFERING_NDEBUG
+    dframe.push_date = sc_tick_now();
+#endif
+
+    ok = sc_vecdeque_push(&db->queue, dframe);
+    if (!ok) {
+        sc_mutex_unlock(&db->mutex);
+        LOG_OOM();
+        return false;
+    }
+
+    sc_cond_signal(&db->queue_cond);
+
+    sc_mutex_unlock(&db->mutex);
+
+    return true;
+}
+
+void
+sc_delay_buffer_init(struct sc_delay_buffer *db, sc_tick delay,
+                     bool first_frame_asap) {
+    assert(delay > 0);
+
+    db->delay = delay;
+    db->first_frame_asap = first_frame_asap;
+
+    sc_frame_source_init(&db->frame_source);
+
+    static const struct sc_frame_sink_ops ops = {
+        .open = sc_delay_buffer_frame_sink_open,
+        .close = sc_delay_buffer_frame_sink_close,
+        .push = sc_delay_buffer_frame_sink_push,
+    };
+
+    db->frame_sink.ops = &ops;
+}

app/src/delay_buffer.h

@@ -0,0 +1,60 @@
+#ifndef SC_DELAY_BUFFER_H
+#define SC_DELAY_BUFFER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "clock.h"
+#include "trait/frame_source.h"
+#include "trait/frame_sink.h"
+#include "util/thread.h"
+#include "util/tick.h"
+#include "util/vecdeque.h"
+
+// forward declarations
+typedef struct AVFrame AVFrame;
+
+struct sc_delayed_frame {
+    AVFrame *frame;
+#ifndef NDEBUG
+    sc_tick push_date;
+#endif
+};
+
+struct sc_delayed_frame_queue SC_VECDEQUE(struct sc_delayed_frame);
+
+struct sc_delay_buffer {
+    struct sc_frame_source frame_source; // frame source trait
+    struct sc_frame_sink frame_sink; // frame sink trait
+
+    sc_tick delay;
+    bool first_frame_asap;
+
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond queue_cond;
+    sc_cond wait_cond;
+
+    struct sc_clock clock;
+    struct sc_delayed_frame_queue queue;
+    bool stopped;
+};
+
+struct sc_delay_buffer_callbacks {
+    bool (*on_new_frame)(struct sc_delay_buffer *db, const AVFrame *frame,
+                         void *userdata);
+};
+
+/**
+ * Initialize a delay buffer.
+ *
+ * \param delay a (strictly) positive delay
+ * \param first_frame_asap if true, do not delay the first frame (useful for
+                           a video stream).
+ */
+void
+sc_delay_buffer_init(struct sc_delay_buffer *db, sc_tick delay,
+                     bool first_frame_asap);
+
+#endif

app/src/demuxer.c

@@ -0,0 +1,311 @@
+#include "demuxer.h"
+
+#include <assert.h>
+#include <libavutil/channel_layout.h>
+#include <libavutil/time.h>
+#include <unistd.h>
+
+#include "decoder.h"
+#include "events.h"
+#include "packet_merger.h"
+#include "recorder.h"
+#include "util/binary.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 enum AVCodecID
+sc_demuxer_to_avcodec_id(uint32_t codec_id) {
+#define SC_CODEC_ID_H264 UINT32_C(0x68323634) // "h264" in ASCII
+#define SC_CODEC_ID_H265 UINT32_C(0x68323635) // "h265" in ASCII
+#define SC_CODEC_ID_AV1 UINT32_C(0x00617631) // "av1" in ASCII
+#define SC_CODEC_ID_OPUS UINT32_C(0x6f707573) // "opus" in ASCII
+#define SC_CODEC_ID_AAC UINT32_C(0x00616163) // "aac in ASCII"
+#define SC_CODEC_ID_RAW UINT32_C(0x00726177) // "raw" in ASCII
+    switch (codec_id) {
+        case SC_CODEC_ID_H264:
+            return AV_CODEC_ID_H264;
+        case SC_CODEC_ID_H265:
+            return AV_CODEC_ID_HEVC;
+        case SC_CODEC_ID_AV1:
+#ifdef SCRCPY_LAVC_HAS_AV1
+            return AV_CODEC_ID_AV1;
+#else
+            LOGE("AV1 not supported by this FFmpeg version");
+            return AV_CODEC_ID_NONE;
+#endif
+        case SC_CODEC_ID_OPUS:
+            return AV_CODEC_ID_OPUS;
+        case SC_CODEC_ID_AAC:
+            return AV_CODEC_ID_AAC;
+        case SC_CODEC_ID_RAW:
+            return AV_CODEC_ID_PCM_S16LE;
+        default:
+            LOGE("Unknown codec id 0x%08" PRIx32, codec_id);
+            return AV_CODEC_ID_NONE;
+    }
+}
+
+static bool
+sc_demuxer_recv_codec_id(struct sc_demuxer *demuxer, uint32_t *codec_id) {
+    uint8_t data[4];
+    ssize_t r = net_recv_all(demuxer->socket, data, 4);
+    if (r < 4) {
+        return false;
+    }
+
+    *codec_id = sc_read32be(data);
+    return true;
+}
+
+static bool
+sc_demuxer_recv_video_size(struct sc_demuxer *demuxer, uint32_t *width,
+                           uint32_t *height) {
+    uint8_t data[8];
+    ssize_t r = net_recv_all(demuxer->socket, data, 8);
+    if (r < 8) {
+        return false;
+    }
+
+    *width = sc_read32be(data);
+    *height = sc_read32be(data + 4);
+    return true;
+}
+
+static bool
+sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
+    // The video and audio streams contain a sequence of raw packets (as
+    // provided by MediaCodec), each prefixed with a "meta" header.
+    //
+    // 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
+    // | `- key frame
+    //  `-- config packet
+
+    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 int
+run_demuxer(void *data) {
+    struct sc_demuxer *demuxer = data;
+
+    // Flag to report end-of-stream (i.e. device disconnected)
+    enum sc_demuxer_status status = SC_DEMUXER_STATUS_ERROR;
+
+    uint32_t raw_codec_id;
+    bool ok = sc_demuxer_recv_codec_id(demuxer, &raw_codec_id);
+    if (!ok) {
+        LOGE("Demuxer '%s': stream disabled due to connection error",
+             demuxer->name);
+        goto end;
+    }
+
+    if (raw_codec_id == 0) {
+        LOGW("Demuxer '%s': stream explicitly disabled by the device",
+             demuxer->name);
+        sc_packet_source_sinks_disable(&demuxer->packet_source);
+        status = SC_DEMUXER_STATUS_DISABLED;
+        goto end;
+    }
+
+    if (raw_codec_id == 1) {
+        LOGE("Demuxer '%s': stream configuration error on the device",
+             demuxer->name);
+        goto end;
+    }
+
+    enum AVCodecID codec_id = sc_demuxer_to_avcodec_id(raw_codec_id);
+    if (codec_id == AV_CODEC_ID_NONE) {
+        LOGE("Demuxer '%s': stream disabled due to unsupported codec",
+             demuxer->name);
+        sc_packet_source_sinks_disable(&demuxer->packet_source);
+        goto end;
+    }
+
+    const AVCodec *codec = avcodec_find_decoder(codec_id);
+    if (!codec) {
+        LOGE("Demuxer '%s': stream disabled due to missing decoder",
+             demuxer->name);
+        sc_packet_source_sinks_disable(&demuxer->packet_source);
+        goto end;
+    }
+
+    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
+    if (!codec_ctx) {
+        LOG_OOM();
+        goto end;
+    }
+
+    codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;
+
+    if (codec->type == AVMEDIA_TYPE_VIDEO) {
+        uint32_t width;
+        uint32_t height;
+        ok = sc_demuxer_recv_video_size(demuxer, &width, &height);
+        if (!ok) {
+            goto finally_free_context;
+        }
+
+        codec_ctx->width = width;
+        codec_ctx->height = height;
+        codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
+    } else {
+        // Hardcoded audio properties
+#ifdef SCRCPY_LAVU_HAS_CHLAYOUT
+        codec_ctx->ch_layout = (AVChannelLayout) AV_CHANNEL_LAYOUT_STEREO;
+#else
+        codec_ctx->channel_layout = AV_CH_LAYOUT_STEREO;
+        codec_ctx->channels = 2;
+#endif
+        codec_ctx->sample_rate = 48000;
+    }
+
+    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
+        LOGE("Demuxer '%s': could not open codec", demuxer->name);
+        goto finally_free_context;
+    }
+
+    if (!sc_packet_source_sinks_open(&demuxer->packet_source, codec_ctx)) {
+        goto finally_free_context;
+    }
+
+    // Config packets must be merged with the next non-config packet only for
+    // video streams
+    bool must_merge_config_packet = codec->type == AVMEDIA_TYPE_VIDEO;
+
+    struct sc_packet_merger merger;
+
+    if (must_merge_config_packet) {
+        sc_packet_merger_init(&merger);
+    }
+
+    AVPacket *packet = av_packet_alloc();
+    if (!packet) {
+        LOG_OOM();
+        goto finally_close_sinks;
+    }
+
+    for (;;) {
+        bool ok = sc_demuxer_recv_packet(demuxer, packet);
+        if (!ok) {
+            // end of stream
+            status = SC_DEMUXER_STATUS_EOS;
+            break;
+        }
+
+        if (must_merge_config_packet) {
+            // Prepend any config packet to the next media packet
+            ok = sc_packet_merger_merge(&merger, packet);
+            if (!ok) {
+                av_packet_unref(packet);
+                break;
+            }
+        }
+
+        ok = sc_packet_source_sinks_push(&demuxer->packet_source, packet);
+        av_packet_unref(packet);
+        if (!ok) {
+            // The sink already logged its concrete error
+            break;
+        }
+    }
+
+    LOGD("Demuxer '%s': end of frames", demuxer->name);
+
+    if (must_merge_config_packet) {
+        sc_packet_merger_destroy(&merger);
+    }
+
+    av_packet_free(&packet);
+finally_close_sinks:
+    sc_packet_source_sinks_close(&demuxer->packet_source);
+finally_free_context:
+    // This also calls avcodec_close() internally
+    avcodec_free_context(&codec_ctx);
+end:
+    demuxer->cbs->on_ended(demuxer, status, demuxer->cbs_userdata);
+
+    return 0;
+}
+
+void
+sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
+                const struct sc_demuxer_callbacks *cbs, void *cbs_userdata) {
+    assert(socket != SC_SOCKET_NONE);
+
+    demuxer->name = name; // statically allocated
+    demuxer->socket = socket;
+    sc_packet_source_init(&demuxer->packet_source);
+
+    assert(cbs && cbs->on_ended);
+
+    demuxer->cbs = cbs;
+    demuxer->cbs_userdata = cbs_userdata;
+}
+
+bool
+sc_demuxer_start(struct sc_demuxer *demuxer) {
+    LOGD("Demuxer '%s': starting thread", demuxer->name);
+
+    bool ok = sc_thread_create(&demuxer->thread, run_demuxer, "scrcpy-demuxer",
+                               demuxer);
+    if (!ok) {
+        LOGE("Demuxer '%s': could not start thread", demuxer->name);
+        return false;
+    }
+    return true;
+}
+
+void
+sc_demuxer_join(struct sc_demuxer *demuxer) {
+    sc_thread_join(&demuxer->thread, NULL);
+}

app/src/demuxer.h

@@ -0,0 +1,50 @@
+#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_source.h"
+#include "trait/packet_sink.h"
+#include "util/net.h"
+#include "util/thread.h"
+
+struct sc_demuxer {
+    struct sc_packet_source packet_source; // packet source trait
+
+    const char *name; // must be statically allocated (e.g. a string literal)
+
+    sc_socket socket;
+    sc_thread thread;
+
+    const struct sc_demuxer_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+enum sc_demuxer_status {
+    SC_DEMUXER_STATUS_EOS,
+    SC_DEMUXER_STATUS_DISABLED,
+    SC_DEMUXER_STATUS_ERROR,
+};
+
+struct sc_demuxer_callbacks {
+    void (*on_ended)(struct sc_demuxer *demuxer, enum sc_demuxer_status,
+                     void *userdata);
+};
+
+// The name must be statically allocated (e.g. a string literal)
+void
+sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
+                const struct sc_demuxer_callbacks *cbs, void *cbs_userdata);
+
+bool
+sc_demuxer_start(struct sc_demuxer *demuxer);
+
+void
+sc_demuxer_join(struct sc_demuxer *demuxer);
+
+#endif

app/src/device_msg.c

@@ -4,7 +4,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "util/buffer_util.h"
+#include "util/binary.h"
 #include "util/log.h"
 
 ssize_t
@@ -18,7 +18,7 @@ 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 = buffer_read32be(&buf[1]);
+            size_t clipboard_len = sc_read32be(&buf[1]);
             if (clipboard_len > len - 5) {
                 return 0; // not available
             }
@@ -36,7 +36,7 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
             return 5 + clipboard_len;
         }
         case DEVICE_MSG_TYPE_ACK_CLIPBOARD: {
-            uint64_t sequence = buffer_read64be(&buf[1]);
+            uint64_t sequence = sc_read64be(&buf[1]);
             msg->ack_clipboard.sequence = sequence;
             return 9;
         }

app/src/device_msg.h

@@ -1,5 +1,5 @@
-#ifndef DEVICEMSG_H
-#define DEVICEMSG_H
+#ifndef SC_DEVICEMSG_H
+#define SC_DEVICEMSG_H
 
 #include "common.h"
 

app/src/display.c

@@ -0,0 +1,285 @@
+#include "display.h"
+
+#include <assert.h>
+
+#include "util/log.h"
+
+bool
+sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps) {
+    display->renderer =
+        SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+    if (!display->renderer) {
+        LOGE("Could not create renderer: %s", SDL_GetError());
+        return false;
+    }
+
+    SDL_RendererInfo renderer_info;
+    int r = SDL_GetRendererInfo(display->renderer, &renderer_info);
+    const char *renderer_name = r ? NULL : renderer_info.name;
+    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
+
+    display->mipmaps = false;
+
+    // starts with "opengl"
+    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
+    if (use_opengl) {
+
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+        // Persuade macOS to give us something better than OpenGL 2.1.
+        // If we create a Core Profile context, we get the best OpenGL version.
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
+                            SDL_GL_CONTEXT_PROFILE_CORE);
+
+        LOGD("Creating OpenGL Core Profile context");
+        display->gl_context = SDL_GL_CreateContext(window);
+        if (!display->gl_context) {
+            LOGE("Could not create OpenGL context: %s", SDL_GetError());
+            SDL_DestroyRenderer(display->renderer);
+            return false;
+        }
+#endif
+
+        struct sc_opengl *gl = &display->gl;
+        sc_opengl_init(gl);
+
+        LOGI("OpenGL version: %s", gl->version);
+
+        if (mipmaps) {
+            bool supports_mipmaps =
+                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
+                                               2, 0  /* OpenGL ES 2.0+ */);
+            if (supports_mipmaps) {
+                LOGI("Trilinear filtering enabled");
+                display->mipmaps = true;
+            } else {
+                LOGW("Trilinear filtering disabled "
+                     "(OpenGL 3.0+ or ES 2.0+ required");
+            }
+        } else {
+            LOGI("Trilinear filtering disabled");
+        }
+    } else if (mipmaps) {
+        LOGD("Trilinear filtering disabled (not an OpenGL renderer");
+    }
+
+    display->pending.flags = 0;
+    display->pending.frame = NULL;
+
+    return true;
+}
+
+void
+sc_display_destroy(struct sc_display *display) {
+    if (display->pending.frame) {
+        av_frame_free(&display->pending.frame);
+    }
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+    SDL_GL_DeleteContext(display->gl_context);
+#endif
+    if (display->texture) {
+        SDL_DestroyTexture(display->texture);
+    }
+    SDL_DestroyRenderer(display->renderer);
+}
+
+static SDL_Texture *
+sc_display_create_texture(struct sc_display *display,
+                          struct sc_size size) {
+    SDL_Renderer *renderer = display->renderer;
+    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
+                                             SDL_TEXTUREACCESS_STREAMING,
+                                             size.width, size.height);
+    if (!texture) {
+        LOGD("Could not create texture: %s", SDL_GetError());
+        return NULL;
+    }
+
+    if (display->mipmaps) {
+        struct sc_opengl *gl = &display->gl;
+
+        SDL_GL_BindTexture(texture, NULL, NULL);
+
+        // Enable trilinear filtering for downscaling
+        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                          GL_LINEAR_MIPMAP_LINEAR);
+        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
+
+        SDL_GL_UnbindTexture(texture);
+    }
+
+    return texture;
+}
+
+static inline void
+sc_display_set_pending_size(struct sc_display *display, struct sc_size size) {
+    assert(!display->texture);
+    display->pending.size = size;
+    display->pending.flags |= SC_DISPLAY_PENDING_FLAG_SIZE;
+}
+
+static bool
+sc_display_set_pending_frame(struct sc_display *display, const AVFrame *frame) {
+    if (!display->pending.frame) {
+        display->pending.frame = av_frame_alloc();
+        if (!display->pending.frame) {
+            LOG_OOM();
+            return false;
+        }
+    }
+
+    int r = av_frame_ref(display->pending.frame, frame);
+    if (r) {
+        LOGE("Could not ref frame: %d", r);
+        return false;
+    }
+
+    display->pending.flags |= SC_DISPLAY_PENDING_FLAG_FRAME;
+
+    return true;
+}
+
+static bool
+sc_display_apply_pending(struct sc_display *display) {
+    if (display->pending.flags & SC_DISPLAY_PENDING_FLAG_SIZE) {
+        assert(!display->texture);
+        display->texture =
+            sc_display_create_texture(display, display->pending.size);
+        if (!display->texture) {
+            return false;
+        }
+
+        display->pending.flags &= ~SC_DISPLAY_PENDING_FLAG_SIZE;
+    }
+
+    if (display->pending.flags & SC_DISPLAY_PENDING_FLAG_FRAME) {
+        assert(display->pending.frame);
+        bool ok = sc_display_update_texture(display, display->pending.frame);
+        if (!ok) {
+            return false;
+        }
+
+        av_frame_unref(display->pending.frame);
+        display->pending.flags &= ~SC_DISPLAY_PENDING_FLAG_FRAME;
+    }
+
+    return true;
+}
+
+static bool
+sc_display_set_texture_size_internal(struct sc_display *display,
+                                     struct sc_size size) {
+    assert(size.width && size.height);
+
+    if (display->texture) {
+        SDL_DestroyTexture(display->texture);
+    }
+
+    display->texture = sc_display_create_texture(display, size);
+    if (!display->texture) {
+        return false;
+    }
+
+    LOGI("Texture: %" PRIu16 "x%" PRIu16, size.width, size.height);
+    return true;
+}
+
+enum sc_display_result
+sc_display_set_texture_size(struct sc_display *display, struct sc_size size) {
+    bool ok = sc_display_set_texture_size_internal(display, size);
+    if (!ok) {
+        sc_display_set_pending_size(display, size);
+        return SC_DISPLAY_RESULT_PENDING;
+
+    }
+
+    return SC_DISPLAY_RESULT_OK;
+}
+
+static bool
+sc_display_update_texture_internal(struct sc_display *display,
+                                   const AVFrame *frame) {
+    int ret = SDL_UpdateYUVTexture(display->texture, NULL,
+                                   frame->data[0], frame->linesize[0],
+                                   frame->data[1], frame->linesize[1],
+                                   frame->data[2], frame->linesize[2]);
+    if (ret) {
+        LOGD("Could not update texture: %s", SDL_GetError());
+        return false;
+    }
+
+    if (display->mipmaps) {
+        SDL_GL_BindTexture(display->texture, NULL, NULL);
+        display->gl.GenerateMipmap(GL_TEXTURE_2D);
+        SDL_GL_UnbindTexture(display->texture);
+    }
+
+    return true;
+}
+
+enum sc_display_result
+sc_display_update_texture(struct sc_display *display, const AVFrame *frame) {
+    bool ok = sc_display_update_texture_internal(display, frame);
+    if (!ok) {
+        ok = sc_display_set_pending_frame(display, frame);
+        if (!ok) {
+            LOGE("Could not set pending frame");
+            return SC_DISPLAY_RESULT_ERROR;
+        }
+
+        return SC_DISPLAY_RESULT_PENDING;
+    }
+
+    return SC_DISPLAY_RESULT_OK;
+}
+
+enum sc_display_result
+sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
+                  unsigned rotation) {
+    SDL_RenderClear(display->renderer);
+
+    if (display->pending.flags) {
+        bool ok = sc_display_apply_pending(display);
+        if (!ok) {
+            return SC_DISPLAY_RESULT_PENDING;
+        }
+    }
+
+    SDL_Renderer *renderer = display->renderer;
+    SDL_Texture *texture = display->texture;
+
+    if (rotation == 0) {
+        int ret = SDL_RenderCopy(renderer, texture, NULL, geometry);
+        if (ret) {
+            LOGE("Could not render texture: %s", SDL_GetError());
+            return SC_DISPLAY_RESULT_ERROR;
+        }
+    } else {
+        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
+        // counterclockwise (to be consistent with --lock-video-orientation)
+        int cw_rotation = (4 - rotation) % 4;
+        double angle = 90 * cw_rotation;
+
+        const SDL_Rect *dstrect = NULL;
+        SDL_Rect rect;
+        if (rotation & 1) {
+            rect.x = geometry->x + (geometry->w - geometry->h) / 2;
+            rect.y = geometry->y + (geometry->h - geometry->w) / 2;
+            rect.w = geometry->h;
+            rect.h = geometry->w;
+            dstrect = &rect;
+        } else {
+            assert(rotation == 2);
+            dstrect = geometry;
+        }
+
+        int ret = SDL_RenderCopyEx(renderer, texture, NULL, dstrect, angle,
+                                   NULL, 0);
+        if (ret) {
+            LOGE("Could not render texture: %s", SDL_GetError());
+            return SC_DISPLAY_RESULT_ERROR;
+        }
+    }
+
+    SDL_RenderPresent(display->renderer);
+    return SC_DISPLAY_RESULT_OK;
+}

app/src/display.h

@@ -0,0 +1,59 @@
+#ifndef SC_DISPLAY_H
+#define SC_DISPLAY_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <libavformat/avformat.h>
+#include <SDL2/SDL.h>
+
+#include "coords.h"
+#include "opengl.h"
+
+#ifdef __APPLE__
+# define SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+#endif
+
+struct sc_display {
+    SDL_Renderer *renderer;
+    SDL_Texture *texture;
+
+    struct sc_opengl gl;
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+    SDL_GLContext *gl_context;
+#endif
+
+    bool mipmaps;
+
+    struct {
+#define SC_DISPLAY_PENDING_FLAG_SIZE 1
+#define SC_DISPLAY_PENDING_FLAG_FRAME 2
+        int8_t flags;
+        struct sc_size size;
+        AVFrame *frame;
+    } pending;
+};
+
+enum sc_display_result {
+    SC_DISPLAY_RESULT_OK,
+    SC_DISPLAY_RESULT_PENDING,
+    SC_DISPLAY_RESULT_ERROR,
+};
+
+bool
+sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps);
+
+void
+sc_display_destroy(struct sc_display *display);
+
+enum sc_display_result
+sc_display_set_texture_size(struct sc_display *display, struct sc_size size);
+
+enum sc_display_result
+sc_display_update_texture(struct sc_display *display, const AVFrame *frame);
+
+enum sc_display_result
+sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
+                  unsigned rotation);
+
+#endif

app/src/events.h

@@ -1,4 +1,9 @@
-#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 SC_EVENT_NEW_FRAME                 SDL_USEREVENT
+#define SC_EVENT_DEVICE_DISCONNECTED      (SDL_USEREVENT + 1)
+#define SC_EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
+#define SC_EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
+#define SC_EVENT_USB_DEVICE_DISCONNECTED  (SDL_USEREVENT + 4)
+#define SC_EVENT_DEMUXER_ERROR            (SDL_USEREVENT + 5)
+#define SC_EVENT_RECORDER_ERROR           (SDL_USEREVENT + 6)
+#define SC_EVENT_SCREEN_INIT_SIZE         (SDL_USEREVENT + 7)
+#define SC_EVENT_TIME_LIMIT_REACHED       (SDL_USEREVENT + 8)

app/src/file_handler.c

@@ -1,178 +0,0 @@
-#include "file_handler.h"
-
-#include <assert.h>
-#include <string.h>
-
-#include "adb.h"
-#include "util/log.h"
-#include "util/process_intr.h"
-
-#define DEFAULT_PUSH_TARGET "/sdcard/Download/"
-
-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) {
-    assert(serial);
-
-    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;
-    }
-
-    ok = sc_intr_init(&file_handler->intr);
-    if (!ok) {
-        sc_cond_destroy(&file_handler->event_cond);
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
-    }
-
-    file_handler->serial = strdup(serial);
-    if (!file_handler->serial) {
-        LOG_OOM();
-        sc_intr_destroy(&file_handler->intr);
-        sc_cond_destroy(&file_handler->event_cond);
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
-    }
-
-    // lazy initialization
-    file_handler->initialized = false;
-
-    file_handler->stopped = false;
-
-    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);
-    sc_intr_destroy(&file_handler->intr);
-    free(file_handler->serial);
-
-    struct file_handler_request req;
-    while (cbuf_take(&file_handler->queue, &req)) {
-        file_handler_request_destroy(&req);
-    }
-}
-
-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;
-    struct sc_intr *intr = &file_handler->intr;
-
-    const char *serial = file_handler->serial;
-    assert(serial);
-
-    const char *push_target = file_handler->push_target;
-    assert(push_target);
-
-    for (;;) {
-        sc_mutex_lock(&file_handler->mutex);
-        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;
-        sc_mutex_unlock(&file_handler->mutex);
-
-        if (req.action == ACTION_INSTALL_APK) {
-            LOGI("Installing %s...", req.file);
-            bool ok = 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 = 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);
-            }
-        }
-
-        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,
-                               "scrcpy-file", 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);
-    sc_intr_interrupt(&file_handler->intr);
-    sc_mutex_unlock(&file_handler->mutex);
-}
-
-void
-file_handler_join(struct file_handler *file_handler) {
-    sc_thread_join(&file_handler->thread, NULL);
-}

app/src/file_handler.h

@@ -1,60 +0,0 @@
-#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"
-#include "util/intr.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;
-    struct file_handler_request_queue queue;
-
-    struct sc_intr intr;
-};
-
-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

app/src/file_pusher.c

@@ -0,0 +1,189 @@
+#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);
+
+    sc_vecdeque_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);
+
+    while (!sc_vecdeque_is_empty(&fp->queue)) {
+        struct sc_file_pusher_request *req = sc_vecdeque_popref(&fp->queue);
+        assert(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 = sc_vecdeque_is_empty(&fp->queue);
+    bool res = sc_vecdeque_push(&fp->queue, req);
+    if (!res) {
+        LOG_OOM();
+        sc_mutex_unlock(&fp->mutex);
+        return false;
+    }
+
+    if (was_empty) {
+        sc_cond_signal(&fp->event_cond);
+    }
+    sc_mutex_unlock(&fp->mutex);
+
+    return true;
+}
+
+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 && sc_vecdeque_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;
+        }
+
+        assert(!sc_vecdeque_is_empty(&fp->queue));
+        struct sc_file_pusher_request req = sc_vecdeque_pop(&fp->queue);
+        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) {
+    if (fp->initialized) {
+        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) {
+    if (fp->initialized) {
+        sc_thread_join(&fp->thread, NULL);
+    }
+}

app/src/file_pusher.h

@@ -0,0 +1,58 @@
+#ifndef SC_FILE_PUSHER_H
+#define SC_FILE_PUSHER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "util/intr.h"
+#include "util/thread.h"
+#include "util/vecdeque.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 SC_VECDEQUE(struct sc_file_pusher_request);
+
+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

app/src/fps_counter.c

@@ -4,10 +4,10 @@
 
 #include "util/log.h"
 
-#define FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1)
+#define SC_FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1)
 
 bool
-fps_counter_init(struct fps_counter *counter) {
+sc_fps_counter_init(struct sc_fps_counter *counter) {
     bool ok = sc_mutex_init(&counter->mutex);
     if (!ok) {
         return false;
@@ -27,26 +27,26 @@ fps_counter_init(struct fps_counter *counter) {
 }
 
 void
-fps_counter_destroy(struct fps_counter *counter) {
+sc_fps_counter_destroy(struct sc_fps_counter *counter) {
     sc_cond_destroy(&counter->state_cond);
     sc_mutex_destroy(&counter->mutex);
 }
 
 static inline bool
-is_started(struct fps_counter *counter) {
+is_started(struct sc_fps_counter *counter) {
     return atomic_load_explicit(&counter->started, memory_order_acquire);
 }
 
 static inline void
-set_started(struct fps_counter *counter, bool started) {
+set_started(struct sc_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 fps_counter *counter) {
+display_fps(struct sc_fps_counter *counter) {
     unsigned rendered_per_second =
-        counter->nr_rendered * SC_TICK_FREQ / FPS_COUNTER_INTERVAL;
+        counter->nr_rendered * SC_TICK_FREQ / SC_FPS_COUNTER_INTERVAL;
     if (counter->nr_skipped) {
         LOGI("%u fps (+%u frames skipped)", rendered_per_second,
                                             counter->nr_skipped);
@@ -57,7 +57,7 @@ display_fps(struct fps_counter *counter) {
 
 // must be called with mutex locked
 static void
-check_interval_expired(struct fps_counter *counter, uint32_t now) {
+check_interval_expired(struct sc_fps_counter *counter, sc_tick now) {
     if (now < counter->next_timestamp) {
         return;
     }
@@ -67,13 +67,13 @@ check_interval_expired(struct fps_counter *counter, uint32_t now) {
     counter->nr_skipped = 0;
     // add a multiple of the interval
     uint32_t elapsed_slices =
-        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL + 1;
-    counter->next_timestamp += FPS_COUNTER_INTERVAL * elapsed_slices;
+        (now - counter->next_timestamp) / SC_FPS_COUNTER_INTERVAL + 1;
+    counter->next_timestamp += SC_FPS_COUNTER_INTERVAL * elapsed_slices;
 }
 
 static int
 run_fps_counter(void *data) {
-    struct fps_counter *counter = data;
+    struct sc_fps_counter *counter = data;
 
     sc_mutex_lock(&counter->mutex);
     while (!counter->interrupted) {
@@ -94,9 +94,10 @@ run_fps_counter(void *data) {
 }
 
 bool
-fps_counter_start(struct fps_counter *counter) {
+sc_fps_counter_start(struct sc_fps_counter *counter) {
     sc_mutex_lock(&counter->mutex);
-    counter->next_timestamp = sc_tick_now() + FPS_COUNTER_INTERVAL;
+    counter->interrupted = false;
+    counter->next_timestamp = sc_tick_now() + SC_FPS_COUNTER_INTERVAL;
     counter->nr_rendered = 0;
     counter->nr_skipped = 0;
     sc_mutex_unlock(&counter->mutex);
@@ -117,22 +118,24 @@ fps_counter_start(struct fps_counter *counter) {
         counter->thread_started = true;
     }
 
+    LOGI("FPS counter started");
     return true;
 }
 
 void
-fps_counter_stop(struct fps_counter *counter) {
+sc_fps_counter_stop(struct sc_fps_counter *counter) {
     set_started(counter, false);
     sc_cond_signal(&counter->state_cond);
+    LOGI("FPS counter stopped");
 }
 
 bool
-fps_counter_is_started(struct fps_counter *counter) {
+sc_fps_counter_is_started(struct sc_fps_counter *counter) {
     return is_started(counter);
 }
 
 void
-fps_counter_interrupt(struct fps_counter *counter) {
+sc_fps_counter_interrupt(struct sc_fps_counter *counter) {
     if (!counter->thread_started) {
         return;
     }
@@ -145,7 +148,7 @@ fps_counter_interrupt(struct fps_counter *counter) {
 }
 
 void
-fps_counter_join(struct fps_counter *counter) {
+sc_fps_counter_join(struct sc_fps_counter *counter) {
     if (counter->thread_started) {
         // interrupted must be set by the thread calling join(), so no need to
         // lock for the assertion
@@ -156,7 +159,7 @@ fps_counter_join(struct fps_counter *counter) {
 }
 
 void
-fps_counter_add_rendered_frame(struct fps_counter *counter) {
+sc_fps_counter_add_rendered_frame(struct sc_fps_counter *counter) {
     if (!is_started(counter)) {
         return;
     }
@@ -169,7 +172,7 @@ fps_counter_add_rendered_frame(struct fps_counter *counter) {
 }
 
 void
-fps_counter_add_skipped_frame(struct fps_counter *counter) {
+sc_fps_counter_add_skipped_frame(struct sc_fps_counter *counter) {
     if (!is_started(counter)) {
         return;
     }

app/src/fps_counter.h

@@ -1,5 +1,5 @@
-#ifndef FPSCOUNTER_H
-#define FPSCOUNTER_H
+#ifndef SC_FPSCOUNTER_H
+#define SC_FPSCOUNTER_H
 
 #include "common.h"
 
@@ -9,7 +9,7 @@
 
 #include "util/thread.h"
 
-struct fps_counter {
+struct sc_fps_counter {
     sc_thread thread;
     sc_mutex mutex;
     sc_cond state_cond;
@@ -28,32 +28,32 @@ struct fps_counter {
 };
 
 bool
-fps_counter_init(struct fps_counter *counter);
+sc_fps_counter_init(struct sc_fps_counter *counter);
 
 void
-fps_counter_destroy(struct fps_counter *counter);
+sc_fps_counter_destroy(struct sc_fps_counter *counter);
 
 bool
-fps_counter_start(struct fps_counter *counter);
+sc_fps_counter_start(struct sc_fps_counter *counter);
 
 void
-fps_counter_stop(struct fps_counter *counter);
+sc_fps_counter_stop(struct sc_fps_counter *counter);
 
 bool
-fps_counter_is_started(struct fps_counter *counter);
+sc_fps_counter_is_started(struct sc_fps_counter *counter);
 
 // request to stop the thread (on quit)
-// must be called before fps_counter_join()
+// must be called before sc_fps_counter_join()
 void
-fps_counter_interrupt(struct fps_counter *counter);
+sc_fps_counter_interrupt(struct sc_fps_counter *counter);
 
 void
-fps_counter_join(struct fps_counter *counter);
+sc_fps_counter_join(struct sc_fps_counter *counter);
 
 void
-fps_counter_add_rendered_frame(struct fps_counter *counter);
+sc_fps_counter_add_rendered_frame(struct sc_fps_counter *counter);
 
 void
-fps_counter_add_skipped_frame(struct fps_counter *counter);
+sc_fps_counter_add_skipped_frame(struct sc_fps_counter *counter);
 
 #endif

app/src/frame_buffer.c

@@ -51,8 +51,6 @@ swap_frames(AVFrame **lhs, AVFrame **rhs) {
 bool
 sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
                      bool *previous_frame_skipped) {
-    sc_mutex_lock(&fb->mutex);
-
     // Use a temporary frame to preserve pending_frame in case of error.
     // tmp_frame is an empty frame, no need to call av_frame_unref() beforehand.
     int r = av_frame_ref(fb->tmp_frame, frame);
@@ -61,6 +59,8 @@ sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
         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);

app/src/icon.c

@@ -2,6 +2,7 @@
 
 #include <assert.h>
 #include <stdbool.h>
+#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include <libavutil/pixdesc.h>
 #include <libavutil/pixfmt.h>
@@ -68,7 +69,7 @@ decode_image(const char *path) {
     }
 
     if (avformat_open_input(&ctx, path, NULL, NULL) < 0) {
-        LOGE("Could not open image codec: %s", path);
+        LOGE("Could not open icon image: %s", path);
         goto free_ctx;
     }
 
@@ -85,7 +86,7 @@ decode_image(const char *path) {
 
     AVCodecParameters *params = ctx->streams[stream]->codecpar;
 
-    AVCodec *codec = avcodec_find_decoder(params->codec_id);
+    const AVCodec *codec = avcodec_find_decoder(params->codec_id);
     if (!codec) {
         LOGE("Could not find image decoder");
         goto close_input;

app/src/icon.h

@@ -1,5 +1,5 @@
-#ifndef ICON_H
-#define ICON_H
+#ifndef SC_ICON_H
+#define SC_ICON_H
 
 #include "common.h"
 

app/src/input_events.h

@@ -0,0 +1,454 @@
+#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;
+    uint64_t pointer_id;
+    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
+};
+
+struct sc_mouse_scroll_event {
+    struct sc_position position;
+    float hscroll;
+    float vscroll;
+    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
+};
+
+struct sc_mouse_motion_event {
+    struct sc_position position;
+    uint64_t pointer_id;
+    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

app/src/input_manager.c

@@ -3,39 +3,38 @@
 #include <assert.h>
 #include <SDL2/SDL_keycode.h>
 
+#include "input_events.h"
+#include "screen.h"
 #include "util/log.h"
 
-static const int ACTION_DOWN = 1;
-static const int ACTION_UP = 1 << 1;
-
 #define SC_SDL_SHORTCUT_MODS_MASK (KMOD_CTRL | KMOD_ALT | KMOD_GUI)
 
 static inline uint16_t
-to_sdl_mod(unsigned mod) {
+to_sdl_mod(unsigned shortcut_mod) {
     uint16_t sdl_mod = 0;
-    if (mod & SC_MOD_LCTRL) {
+    if (shortcut_mod & SC_SHORTCUT_MOD_LCTRL) {
         sdl_mod |= KMOD_LCTRL;
     }
-    if (mod & SC_MOD_RCTRL) {
+    if (shortcut_mod & SC_SHORTCUT_MOD_RCTRL) {
         sdl_mod |= KMOD_RCTRL;
     }
-    if (mod & SC_MOD_LALT) {
+    if (shortcut_mod & SC_SHORTCUT_MOD_LALT) {
         sdl_mod |= KMOD_LALT;
     }
-    if (mod & SC_MOD_RALT) {
+    if (shortcut_mod & SC_SHORTCUT_MOD_RALT) {
         sdl_mod |= KMOD_RALT;
     }
-    if (mod & SC_MOD_LSUPER) {
+    if (shortcut_mod & SC_SHORTCUT_MOD_LSUPER) {
         sdl_mod |= KMOD_LGUI;
     }
-    if (mod & SC_MOD_RSUPER) {
+    if (shortcut_mod & SC_SHORTCUT_MOD_RSUPER) {
         sdl_mod |= KMOD_RGUI;
     }
     return sdl_mod;
 }
 
 static bool
-is_shortcut_mod(struct input_manager *im, uint16_t sdl_mod) {
+is_shortcut_mod(struct sc_input_manager *im, uint16_t sdl_mod) {
     // keep only the relevant modifier keys
     sdl_mod &= SC_SDL_SHORTCUT_MODS_MASK;
 
@@ -51,24 +50,22 @@ is_shortcut_mod(struct input_manager *im, uint16_t sdl_mod) {
 }
 
 void
-input_manager_init(struct input_manager *im, struct controller *controller,
-                   struct screen *screen, struct sc_key_processor *kp,
-                   struct sc_mouse_processor *mp,
-                   const struct scrcpy_options *options) {
-    assert(!options->control || (kp && kp->ops));
-    assert(!options->control || (mp && mp->ops));
+sc_input_manager_init(struct sc_input_manager *im,
+                      const struct sc_input_manager_params *params) {
+    assert(!params->controller || (params->kp && params->kp->ops));
+    assert(!params->controller || (params->mp && params->mp->ops));
 
-    im->controller = controller;
-    im->screen = screen;
-    im->kp = kp;
-    im->mp = mp;
+    im->controller = params->controller;
+    im->fp = params->fp;
+    im->screen = params->screen;
+    im->kp = params->kp;
+    im->mp = params->mp;
 
-    im->control = options->control;
-    im->forward_all_clicks = options->forward_all_clicks;
-    im->legacy_paste = options->legacy_paste;
-    im->clipboard_autosync = options->clipboard_autosync;
+    im->forward_all_clicks = params->forward_all_clicks;
+    im->legacy_paste = params->legacy_paste;
+    im->clipboard_autosync = params->clipboard_autosync;
 
-    const struct sc_shortcut_mods *shortcut_mods = &options->shortcut_mods;
+    const struct sc_shortcut_mods *shortcut_mods = params->shortcut_mods;
     assert(shortcut_mods->count);
     assert(shortcut_mods->count < SC_MAX_SHORTCUT_MODS);
     for (unsigned i = 0; i < shortcut_mods->count; ++i) {
@@ -88,127 +85,112 @@ input_manager_init(struct input_manager *im, struct controller *controller,
 }
 
 static void
-send_keycode(struct controller *controller, enum android_keycode keycode,
-             int actions, const char *name) {
+send_keycode(struct sc_controller *controller, enum android_keycode keycode,
+             enum sc_action action, const char *name) {
     // send DOWN event
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
+    msg.inject_keycode.action = action == SC_ACTION_DOWN
+                              ? AKEY_EVENT_ACTION_DOWN
+                              : AKEY_EVENT_ACTION_UP;
     msg.inject_keycode.keycode = keycode;
     msg.inject_keycode.metastate = 0;
     msg.inject_keycode.repeat = 0;
 
-    if (actions & ACTION_DOWN) {
-        msg.inject_keycode.action = AKEY_EVENT_ACTION_DOWN;
-        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'inject %s (DOWN)'", name);
-            return;
-        }
-    }
-
-    if (actions & ACTION_UP) {
-        msg.inject_keycode.action = AKEY_EVENT_ACTION_UP;
-        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'inject %s (UP)'", name);
-        }
+    if (!sc_controller_push_msg(controller, &msg)) {
+        LOGW("Could not request 'inject %s'", name);
     }
 }
 
 static inline void
-action_home(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_HOME, actions, "HOME");
+action_home(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_HOME, action, "HOME");
 }
 
 static inline void
-action_back(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_BACK, actions, "BACK");
+action_back(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_BACK, action, "BACK");
 }
 
 static inline void
-action_app_switch(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_APP_SWITCH, actions, "APP_SWITCH");
+action_app_switch(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_APP_SWITCH, action, "APP_SWITCH");
 }
 
 static inline void
-action_power(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_POWER, actions, "POWER");
+action_power(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_POWER, action, "POWER");
 }
 
 static inline void
-action_volume_up(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_VOLUME_UP, actions, "VOLUME_UP");
+action_volume_up(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_VOLUME_UP, action, "VOLUME_UP");
 }
 
 static inline void
-action_volume_down(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_VOLUME_DOWN, actions, "VOLUME_DOWN");
+action_volume_down(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_VOLUME_DOWN, action, "VOLUME_DOWN");
 }
 
 static inline void
-action_menu(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_MENU, actions, "MENU");
+action_menu(struct sc_controller *controller, enum sc_action action) {
+    send_keycode(controller, AKEYCODE_MENU, action, "MENU");
 }
 
 // turn the screen on if it was off, press BACK otherwise
 // If the screen is off, it is turned on only on ACTION_DOWN
 static void
-press_back_or_turn_screen_on(struct controller *controller, int actions) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
+press_back_or_turn_screen_on(struct sc_controller *controller,
+                             enum sc_action action) {
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
+    msg.back_or_screen_on.action = action == SC_ACTION_DOWN
+                                 ? AKEY_EVENT_ACTION_DOWN
+                                 : AKEY_EVENT_ACTION_UP;
 
-    if (actions & ACTION_DOWN) {
-        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_DOWN;
-        if (!controller_push_msg(controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'press back or turn screen on'");
-            return;
-        }
-    }
-
-    if (actions & ACTION_UP) {
-        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_UP;
-        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'press back or turn screen on'");
-        }
     }
 }
 
 static void
-expand_notification_panel(struct controller *controller) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
+expand_notification_panel(struct sc_controller *controller) {
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
 
-    if (!controller_push_msg(controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'expand notification panel'");
     }
 }
 
 static void
-expand_settings_panel(struct controller *controller) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
+expand_settings_panel(struct sc_controller *controller) {
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
 
-    if (!controller_push_msg(controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'expand settings panel'");
     }
 }
 
 static void
-collapse_panels(struct controller *controller) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_COLLAPSE_PANELS;
+collapse_panels(struct sc_controller *controller) {
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS;
 
-    if (!controller_push_msg(controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'collapse notification panel'");
     }
 }
 
 static bool
-get_device_clipboard(struct controller *controller,
-                     enum get_clipboard_copy_key copy_key) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_GET_CLIPBOARD;
+get_device_clipboard(struct sc_controller *controller,
+                     enum sc_copy_key copy_key) {
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD;
     msg.get_clipboard.copy_key = copy_key;
 
-    if (!controller_push_msg(controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'get device clipboard'");
         return false;
     }
@@ -217,7 +199,7 @@ get_device_clipboard(struct controller *controller,
 }
 
 static bool
-set_device_clipboard(struct controller *controller, bool paste,
+set_device_clipboard(struct sc_controller *controller, bool paste,
                      uint64_t sequence) {
     char *text = SDL_GetClipboardText();
     if (!text) {
@@ -232,13 +214,13 @@ set_device_clipboard(struct controller *controller, bool paste,
         return false;
     }
 
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD;
     msg.set_clipboard.sequence = sequence;
     msg.set_clipboard.text = text_dup;
     msg.set_clipboard.paste = paste;
 
-    if (!controller_push_msg(controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         free(text_dup);
         LOGW("Could not request 'set device clipboard'");
         return false;
@@ -248,35 +230,31 @@ set_device_clipboard(struct controller *controller, bool paste,
 }
 
 static void
-set_screen_power_mode(struct controller *controller,
-                      enum screen_power_mode mode) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
+set_screen_power_mode(struct sc_controller *controller,
+                      enum sc_screen_power_mode mode) {
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
     msg.set_screen_power_mode.mode = mode;
 
-    if (!controller_push_msg(controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'set screen power mode'");
     }
 }
 
 static void
-switch_fps_counter_state(struct fps_counter *fps_counter) {
+switch_fps_counter_state(struct sc_fps_counter *fps_counter) {
     // the started state can only be written from the current thread, so there
     // is no ToCToU issue
-    if (fps_counter_is_started(fps_counter)) {
-        fps_counter_stop(fps_counter);
-        LOGI("FPS counter stopped");
+    if (sc_fps_counter_is_started(fps_counter)) {
+        sc_fps_counter_stop(fps_counter);
     } else {
-        if (fps_counter_start(fps_counter)) {
-            LOGI("FPS counter started");
-        } else {
-            LOGE("FPS counter starting failed");
-        }
+        sc_fps_counter_start(fps_counter);
+        // Any error is already logged
     }
 }
 
 static void
-clipboard_paste(struct controller *controller) {
+clipboard_paste(struct sc_controller *controller) {
     char *text = SDL_GetClipboardText();
     if (!text) {
         LOGW("Could not get clipboard text: %s", SDL_GetError());
@@ -295,64 +273,76 @@ clipboard_paste(struct controller *controller) {
         return;
     }
 
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
     msg.inject_text.text = text_dup;
-    if (!controller_push_msg(controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         free(text_dup);
         LOGW("Could not request 'paste clipboard'");
     }
 }
 
 static void
-rotate_device(struct controller *controller) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_ROTATE_DEVICE;
+rotate_device(struct sc_controller *controller) {
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE;
 
-    if (!controller_push_msg(controller, &msg)) {
+    if (!sc_controller_push_msg(controller, &msg)) {
         LOGW("Could not request device rotation");
     }
 }
 
 static void
-rotate_client_left(struct screen *screen) {
+rotate_client_left(struct sc_screen *screen) {
     unsigned new_rotation = (screen->rotation + 1) % 4;
-    screen_set_rotation(screen, new_rotation);
+    sc_screen_set_rotation(screen, new_rotation);
 }
 
 static void
-rotate_client_right(struct screen *screen) {
+rotate_client_right(struct sc_screen *screen) {
     unsigned new_rotation = (screen->rotation + 3) % 4;
-    screen_set_rotation(screen, new_rotation);
+    sc_screen_set_rotation(screen, new_rotation);
 }
 
 static void
-input_manager_process_text_input(struct input_manager *im,
+sc_input_manager_process_text_input(struct sc_input_manager *im,
                                     const SDL_TextInputEvent *event) {
+    if (!im->kp->ops->process_text) {
+        // The key processor does not support text input
+        return;
+    }
+
     if (is_shortcut_mod(im, SDL_GetModState())) {
         // A shortcut must never generate text events
         return;
     }
 
-    im->kp->ops->process_text(im->kp, event);
+    struct sc_text_event evt = {
+        .text = event->text,
+    };
+
+    im->kp->ops->process_text(im->kp, &evt);
 }
 
 static bool
-simulate_virtual_finger(struct input_manager *im,
+simulate_virtual_finger(struct sc_input_manager *im,
                         enum android_motionevent_action action,
                         struct sc_point point) {
     bool up = action == AMOTION_EVENT_ACTION_UP;
 
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
+    struct sc_control_msg msg;
+    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
     msg.inject_touch_event.action = action;
     msg.inject_touch_event.position.screen_size = im->screen->frame_size;
     msg.inject_touch_event.position.point = point;
-    msg.inject_touch_event.pointer_id = POINTER_ID_VIRTUAL_FINGER;
+    msg.inject_touch_event.pointer_id =
+        im->forward_all_clicks ? POINTER_ID_VIRTUAL_MOUSE
+                               : POINTER_ID_VIRTUAL_FINGER;
     msg.inject_touch_event.pressure = up ? 0.0f : 1.0f;
+    msg.inject_touch_event.action_button = 0;
     msg.inject_touch_event.buttons = 0;
 
-    if (!controller_push_msg(im->controller, &msg)) {
+    if (!sc_controller_push_msg(im->controller, &msg)) {
         LOGW("Could not request 'inject virtual finger event'");
         return false;
     }
@@ -368,12 +358,10 @@ inverse_point(struct sc_point point, struct sc_size size) {
 }
 
 static void
-input_manager_process_key(struct input_manager *im,
+sc_input_manager_process_key(struct sc_input_manager *im,
                              const SDL_KeyboardEvent *event) {
-    // control: indicates the state of the command-line option --no-control
-    bool control = im->control;
-
-    struct controller *controller = im->controller;
+    // controller is NULL if --no-control is requested
+    struct sc_controller *controller = im->controller;
 
     SDL_Keycode keycode = event->keysym.sym;
     uint16_t mod = event->keysym.mod;
@@ -396,50 +384,50 @@ input_manager_process_key(struct input_manager *im,
 
     // The shortcut modifier is pressed
     if (smod) {
-        int action = down ? ACTION_DOWN : ACTION_UP;
+        enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
         switch (keycode) {
             case SDLK_h:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_home(controller, action);
                 }
                 return;
             case SDLK_b: // fall-through
             case SDLK_BACKSPACE:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_back(controller, action);
                 }
                 return;
             case SDLK_s:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_app_switch(controller, action);
                 }
                 return;
             case SDLK_m:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_menu(controller, action);
                 }
                 return;
             case SDLK_p:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_power(controller, action);
                 }
                 return;
             case SDLK_o:
-                if (control && !repeat && down) {
-                    enum screen_power_mode mode = shift
-                                                ? SCREEN_POWER_MODE_NORMAL
-                                                : SCREEN_POWER_MODE_OFF;
+                if (controller && !repeat && down) {
+                    enum sc_screen_power_mode mode = shift
+                                                   ? SC_SCREEN_POWER_MODE_NORMAL
+                                                   : SC_SCREEN_POWER_MODE_OFF;
                     set_screen_power_mode(controller, mode);
                 }
                 return;
             case SDLK_DOWN:
-                if (control && !shift) {
+                if (controller && !shift) {
                     // forward repeated events
                     action_volume_down(controller, action);
                 }
                 return;
             case SDLK_UP:
-                if (control && !shift) {
+                if (controller && !shift) {
                     // forward repeated events
                     action_volume_up(controller, action);
                 }
@@ -455,19 +443,17 @@ input_manager_process_key(struct input_manager *im,
                 }
                 return;
             case SDLK_c:
-                if (control && !shift && !repeat && down) {
-                    get_device_clipboard(controller,
-                                         GET_CLIPBOARD_COPY_KEY_COPY);
+                if (controller && !shift && !repeat && down) {
+                    get_device_clipboard(controller, SC_COPY_KEY_COPY);
                 }
                 return;
             case SDLK_x:
-                if (control && !shift && !repeat && down) {
-                    get_device_clipboard(controller,
-                                         GET_CLIPBOARD_COPY_KEY_CUT);
+                if (controller && !shift && !repeat && down) {
+                    get_device_clipboard(controller, SC_COPY_KEY_CUT);
                 }
                 return;
             case SDLK_v:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                     if (shift || im->legacy_paste) {
                         // inject the text as input events
                         clipboard_paste(controller);
@@ -481,17 +467,17 @@ input_manager_process_key(struct input_manager *im,
                 return;
             case SDLK_f:
                 if (!shift && !repeat && down) {
-                    screen_switch_fullscreen(im->screen);
+                    sc_screen_switch_fullscreen(im->screen);
                 }
                 return;
             case SDLK_w:
                 if (!shift && !repeat && down) {
-                    screen_resize_to_fit(im->screen);
+                    sc_screen_resize_to_fit(im->screen);
                 }
                 return;
             case SDLK_g:
                 if (!shift && !repeat && down) {
-                    screen_resize_to_pixel_perfect(im->screen);
+                    sc_screen_resize_to_pixel_perfect(im->screen);
                 }
                 return;
             case SDLK_i:
@@ -500,7 +486,7 @@ input_manager_process_key(struct input_manager *im,
                 }
                 return;
             case SDLK_n:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                     if (shift) {
                         collapse_panels(controller);
                     } else if (im->key_repeat == 0) {
@@ -511,7 +497,7 @@ input_manager_process_key(struct input_manager *im,
                 }
                 return;
             case SDLK_r:
-                if (control && !shift && !repeat && down) {
+                if (controller && !shift && !repeat && down) {
                     rotate_device(controller);
                 }
                 return;
@@ -520,7 +506,7 @@ input_manager_process_key(struct input_manager *im,
         return;
     }
 
-    if (!control) {
+    if (!controller) {
         return;
     }
 
@@ -553,30 +539,53 @@ input_manager_process_key(struct input_manager *im,
         }
     }
 
-    im->kp->ops->process_key(im->kp, event, ack_to_wait);
+    struct sc_key_event evt = {
+        .action = sc_action_from_sdl_keyboard_type(event->type),
+        .keycode = sc_keycode_from_sdl(event->keysym.sym),
+        .scancode = sc_scancode_from_sdl(event->keysym.scancode),
+        .repeat = event->repeat,
+        .mods_state = sc_mods_state_from_sdl(event->keysym.mod),
+    };
+
+    assert(im->kp->ops->process_key);
+    im->kp->ops->process_key(im->kp, &evt, ack_to_wait);
 }
 
 static void
-input_manager_process_mouse_motion(struct input_manager *im,
+sc_input_manager_process_mouse_motion(struct sc_input_manager *im,
                                       const SDL_MouseMotionEvent *event) {
-    uint32_t mask = SDL_BUTTON_LMASK;
-    if (im->forward_all_clicks) {
-        mask |= SDL_BUTTON_MMASK | SDL_BUTTON_RMASK;
-    }
-    if (!(event->state & mask)) {
-        // do not send motion events when no click is pressed
-        return;
-    }
+
     if (event->which == SDL_TOUCH_MOUSEID) {
         // simulated from touch events, so it's a duplicate
         return;
     }
 
-    im->mp->ops->process_mouse_motion(im->mp, event);
+    struct sc_mouse_motion_event evt = {
+        .position = {
+            .screen_size = im->screen->frame_size,
+            .point = sc_screen_convert_window_to_frame_coords(im->screen,
+                                                              event->x,
+                                                              event->y),
+        },
+        .pointer_id = im->forward_all_clicks ? POINTER_ID_MOUSE
+                                             : POINTER_ID_GENERIC_FINGER,
+        .xrel = event->xrel,
+        .yrel = event->yrel,
+        .buttons_state =
+            sc_mouse_buttons_state_from_sdl(event->state,
+                                            im->forward_all_clicks),
+    };
+
+    assert(im->mp->ops->process_mouse_motion);
+    im->mp->ops->process_mouse_motion(im->mp, &evt);
+
+    // vfinger must never be used in relative mode
+    assert(!im->mp->relative_mode || !im->vfinger_down);
 
     if (im->vfinger_down) {
+        assert(!im->mp->relative_mode); // assert one more time
         struct sc_point mouse =
-            screen_convert_window_to_frame_coords(im->screen, event->x,
+           sc_screen_convert_window_to_frame_coords(im->screen, event->x,
                                                     event->y);
         struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
         simulate_virtual_finger(im, AMOTION_EVENT_ACTION_MOVE, vfinger);
@@ -584,15 +593,39 @@ input_manager_process_mouse_motion(struct input_manager *im,
 }
 
 static void
-input_manager_process_touch(struct input_manager *im,
+sc_input_manager_process_touch(struct sc_input_manager *im,
                                const SDL_TouchFingerEvent *event) {
-    im->mp->ops->process_touch(im->mp, event);
+    if (!im->mp->ops->process_touch) {
+        // The mouse processor does not support touch events
+        return;
+    }
+
+    int dw;
+    int dh;
+    SDL_GL_GetDrawableSize(im->screen->window, &dw, &dh);
+
+    // SDL touch event coordinates are normalized in the range [0; 1]
+    int32_t x = event->x * dw;
+    int32_t y = event->y * dh;
+
+    struct sc_touch_event evt = {
+        .position = {
+            .screen_size = im->screen->frame_size,
+            .point =
+                sc_screen_convert_drawable_to_frame_coords(im->screen, x, y),
+        },
+        .action = sc_touch_action_from_sdl(event->type),
+        .pointer_id = event->fingerId,
+        .pressure = event->pressure,
+    };
+
+    im->mp->ops->process_touch(im->mp, &evt);
 }
 
 static void
-input_manager_process_mouse_button(struct input_manager *im,
+sc_input_manager_process_mouse_button(struct sc_input_manager *im,
                                       const SDL_MouseButtonEvent *event) {
-    bool control = im->control;
+    struct sc_controller *controller = im->controller;
 
     if (event->which == SDL_TOUCH_MOUSEID) {
         // simulated from touch events, so it's a duplicate
@@ -601,40 +634,42 @@ input_manager_process_mouse_button(struct input_manager *im,
 
     bool down = event->type == SDL_MOUSEBUTTONDOWN;
     if (!im->forward_all_clicks) {
-        int action = down ? ACTION_DOWN : ACTION_UP;
+        if (controller) {
+            enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
 
-        if (control && event->button == SDL_BUTTON_X1) {
-            action_app_switch(im->controller, action);
+            if (event->button == SDL_BUTTON_X1) {
+                action_app_switch(controller, action);
                 return;
             }
-        if (control && event->button == SDL_BUTTON_X2 && down) {
+            if (event->button == SDL_BUTTON_X2 && down) {
                 if (event->clicks < 2) {
-                expand_notification_panel(im->controller);
+                    expand_notification_panel(controller);
                 } else {
-                expand_settings_panel(im->controller);
+                    expand_settings_panel(controller);
                 }
                 return;
             }
-        if (control && event->button == SDL_BUTTON_RIGHT) {
-            press_back_or_turn_screen_on(im->controller, action);
+            if (event->button == SDL_BUTTON_RIGHT) {
+                press_back_or_turn_screen_on(controller, action);
                 return;
             }
-        if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, action);
+            if (event->button == SDL_BUTTON_MIDDLE) {
+                action_home(controller, action);
                 return;
             }
+        }
 
         // double-click on black borders resize to fit the device screen
         if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
             int32_t x = event->x;
             int32_t y = event->y;
-            screen_hidpi_scale_coords(im->screen, &x, &y);
+            sc_screen_hidpi_scale_coords(im->screen, &x, &y);
             SDL_Rect *r = &im->screen->rect;
             bool outside = x < r->x || x >= r->x + r->w
                         || y < r->y || y >= r->y + r->h;
             if (outside) {
                 if (down) {
-                    screen_resize_to_fit(im->screen);
+                    sc_screen_resize_to_fit(im->screen);
                 }
                 return;
             }
@@ -642,11 +677,36 @@ input_manager_process_mouse_button(struct input_manager *im,
         // otherwise, send the click event to the device
     }
 
-    if (!control) {
+    if (!controller) {
         return;
     }
 
-    im->mp->ops->process_mouse_button(im->mp, event);
+    uint32_t sdl_buttons_state = SDL_GetMouseState(NULL, NULL);
+
+    struct sc_mouse_click_event evt = {
+        .position = {
+            .screen_size = im->screen->frame_size,
+            .point = sc_screen_convert_window_to_frame_coords(im->screen,
+                                                              event->x,
+                                                              event->y),
+        },
+        .action = sc_action_from_sdl_mousebutton_type(event->type),
+        .button = sc_mouse_button_from_sdl(event->button),
+        .pointer_id = im->forward_all_clicks ? POINTER_ID_MOUSE
+                                             : POINTER_ID_GENERIC_FINGER,
+        .buttons_state =
+            sc_mouse_buttons_state_from_sdl(sdl_buttons_state,
+                                            im->forward_all_clicks),
+    };
+
+    assert(im->mp->ops->process_mouse_click);
+    im->mp->ops->process_mouse_click(im->mp, &evt);
+
+    if (im->mp->relative_mode) {
+        assert(!im->vfinger_down); // vfinger must not be used in relative mode
+        // No pinch-to-zoom simulation
+        return;
+    }
 
     // Pinch-to-zoom simulation.
     //
@@ -658,10 +718,11 @@ input_manager_process_mouse_button(struct input_manager *im,
     // In other words, the center of the rotation/scaling is the center of the
     // screen.
 #define CTRL_PRESSED (SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL))
-    if ((down && !im->vfinger_down && CTRL_PRESSED)
-            || (!down && im->vfinger_down)) {
+    if (event->button == SDL_BUTTON_LEFT &&
+            ((down && !im->vfinger_down && CTRL_PRESSED) ||
+             (!down && im->vfinger_down))) {
         struct sc_point mouse =
-            screen_convert_window_to_frame_coords(im->screen, event->x,
+            sc_screen_convert_window_to_frame_coords(im->screen, event->x,
                                                                  event->y);
         struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
         enum android_motionevent_action action = down
@@ -675,50 +736,114 @@ input_manager_process_mouse_button(struct input_manager *im,
 }
 
 static void
-input_manager_process_mouse_wheel(struct input_manager *im,
+sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,
                                      const SDL_MouseWheelEvent *event) {
-    im->mp->ops->process_mouse_wheel(im->mp, event);
+    if (!im->mp->ops->process_mouse_scroll) {
+        // The mouse processor does not support scroll events
+        return;
+    }
+
+    // mouse_x and mouse_y are expressed in pixels relative to the window
+    int mouse_x;
+    int mouse_y;
+    uint32_t buttons = SDL_GetMouseState(&mouse_x, &mouse_y);
+
+    struct sc_mouse_scroll_event evt = {
+        .position = {
+            .screen_size = im->screen->frame_size,
+            .point = sc_screen_convert_window_to_frame_coords(im->screen,
+                                                              mouse_x, mouse_y),
+        },
+#if SDL_VERSION_ATLEAST(2, 0, 18)
+        .hscroll = CLAMP(event->preciseX, -1.0f, 1.0f),
+        .vscroll = CLAMP(event->preciseY, -1.0f, 1.0f),
+#else
+        .hscroll = CLAMP(event->x, -1, 1),
+        .vscroll = CLAMP(event->y, -1, 1),
+#endif
+        .buttons_state =
+            sc_mouse_buttons_state_from_sdl(buttons, im->forward_all_clicks),
+    };
+
+    im->mp->ops->process_mouse_scroll(im->mp, &evt);
 }
 
-bool
-input_manager_handle_event(struct input_manager *im, SDL_Event *event) {
+static bool
+is_apk(const char *file) {
+    const char *ext = strrchr(file, '.');
+    return ext && !strcmp(ext, ".apk");
+}
+
+static void
+sc_input_manager_process_file(struct sc_input_manager *im,
+                              const SDL_DropEvent *event) {
+    char *file = strdup(event->file);
+    SDL_free(event->file);
+    if (!file) {
+        LOG_OOM();
+        return;
+    }
+
+    enum sc_file_pusher_action action;
+    if (is_apk(file)) {
+        action = SC_FILE_PUSHER_ACTION_INSTALL_APK;
+    } else {
+        action = SC_FILE_PUSHER_ACTION_PUSH_FILE;
+    }
+    bool ok = sc_file_pusher_request(im->fp, action, file);
+    if (!ok) {
+        free(file);
+    }
+}
+
+void
+sc_input_manager_handle_event(struct sc_input_manager *im,
+                              const SDL_Event *event) {
+    bool control = im->controller;
     switch (event->type) {
         case SDL_TEXTINPUT:
-            if (!im->control) {
-                return true;
+            if (!control) {
+                break;
             }
-            input_manager_process_text_input(im, &event->text);
-            return true;
+            sc_input_manager_process_text_input(im, &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(im, &event->key);
-            return true;
+            sc_input_manager_process_key(im, &event->key);
+            break;
         case SDL_MOUSEMOTION:
-            if (!im->control) {
+            if (!control) {
                 break;
             }
-            input_manager_process_mouse_motion(im, &event->motion);
-            return true;
+            sc_input_manager_process_mouse_motion(im, &event->motion);
+            break;
         case SDL_MOUSEWHEEL:
-            if (!im->control) {
+            if (!control) {
                 break;
             }
-            input_manager_process_mouse_wheel(im, &event->wheel);
-            return true;
+            sc_input_manager_process_mouse_wheel(im, &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(im, &event->button);
-            return true;
+            sc_input_manager_process_mouse_button(im, &event->button);
+            break;
         case SDL_FINGERMOTION:
         case SDL_FINGERDOWN:
         case SDL_FINGERUP:
-            input_manager_process_touch(im, &event->tfinger);
-            return true;
+            if (!control) {
+                break;
+            }
+            sc_input_manager_process_touch(im, &event->tfinger);
+            break;
+        case SDL_DROPFILE: {
+            if (!control) {
+                break;
+            }
+            sc_input_manager_process_file(im, &event->drop);
+        }
     }
-
-    return false;
 }

app/src/input_manager.h

@@ -1,5 +1,5 @@
-#ifndef INPUTMANAGER_H
-#define INPUTMANAGER_H
+#ifndef SC_INPUTMANAGER_H
+#define SC_INPUTMANAGER_H
 
 #include "common.h"
 
@@ -8,20 +8,20 @@
 #include <SDL2/SDL.h>
 
 #include "controller.h"
+#include "file_pusher.h"
 #include "fps_counter.h"
 #include "options.h"
-#include "screen.h"
 #include "trait/key_processor.h"
 #include "trait/mouse_processor.h"
 
-struct input_manager {
-    struct controller *controller;
-    struct screen *screen;
+struct sc_input_manager {
+    struct sc_controller *controller;
+    struct sc_file_pusher *fp;
+    struct sc_screen *screen;
 
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
 
-    bool control;
     bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
@@ -43,13 +43,25 @@ struct input_manager {
     uint64_t next_sequence; // used for request acknowledgements
 };
 
-void
-input_manager_init(struct input_manager *im, struct controller *controller,
-                   struct screen *screen, struct sc_key_processor *kp,
-                   struct sc_mouse_processor *mp,
-                   const struct scrcpy_options *options);
+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
-input_manager_handle_event(struct input_manager *im, SDL_Event *event);
+    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);
+
+void
+sc_input_manager_handle_event(struct sc_input_manager *im,
+                              const SDL_Event *event);
 
 #endif

app/src/keyboard_inject.c

@@ -1,153 +1,146 @@
 #include "keyboard_inject.h"
 
 #include <assert.h>
-#include <SDL2/SDL_events.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 bool
-convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
-    static const struct sc_intmap_entry actions[] = {
-        {SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN},
-        {SDL_KEYUP,   AKEY_EVENT_ACTION_UP},
-    };
-
-    const struct sc_intmap_entry *entry = SC_INTMAP_FIND_ENTRY(actions, from);
-    if (entry) {
-        *to = entry->value;
-        return true;
+static enum android_keyevent_action
+convert_keycode_action(enum sc_action action) {
+    if (action == SC_ACTION_DOWN) {
+        return AKEY_EVENT_ACTION_DOWN;
     }
-
-    return false;
+    assert(action == SC_ACTION_UP);
+    return AKEY_EVENT_ACTION_UP;
 }
 
 static bool
-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
+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[] = {
-        {SDLK_RETURN,    AKEYCODE_ENTER},
-        {SDLK_KP_ENTER,  AKEYCODE_NUMPAD_ENTER},
-        {SDLK_ESCAPE,    AKEYCODE_ESCAPE},
-        {SDLK_BACKSPACE, AKEYCODE_DEL},
-        {SDLK_TAB,       AKEYCODE_TAB},
-        {SDLK_PAGEUP,    AKEYCODE_PAGE_UP},
-        {SDLK_DELETE,    AKEYCODE_FORWARD_DEL},
-        {SDLK_HOME,      AKEYCODE_MOVE_HOME},
-        {SDLK_END,       AKEYCODE_MOVE_END},
-        {SDLK_PAGEDOWN,  AKEYCODE_PAGE_DOWN},
-        {SDLK_RIGHT,     AKEYCODE_DPAD_RIGHT},
-        {SDLK_LEFT,      AKEYCODE_DPAD_LEFT},
-        {SDLK_DOWN,      AKEYCODE_DPAD_DOWN},
-        {SDLK_UP,        AKEYCODE_DPAD_UP},
-        {SDLK_LCTRL,     AKEYCODE_CTRL_LEFT},
-        {SDLK_RCTRL,     AKEYCODE_CTRL_RIGHT},
-        {SDLK_LSHIFT,    AKEYCODE_SHIFT_LEFT},
-        {SDLK_RSHIFT,    AKEYCODE_SHIFT_RIGHT},
+        {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[] = {
-        {SDLK_KP_0,      AKEYCODE_INSERT},
-        {SDLK_KP_1,      AKEYCODE_MOVE_END},
-        {SDLK_KP_2,      AKEYCODE_DPAD_DOWN},
-        {SDLK_KP_3,      AKEYCODE_PAGE_DOWN},
-        {SDLK_KP_4,      AKEYCODE_DPAD_LEFT},
-        {SDLK_KP_6,      AKEYCODE_DPAD_RIGHT},
-        {SDLK_KP_7,      AKEYCODE_MOVE_HOME},
-        {SDLK_KP_8,      AKEYCODE_DPAD_UP},
-        {SDLK_KP_9,      AKEYCODE_PAGE_UP},
-        {SDLK_KP_PERIOD, AKEYCODE_FORWARD_DEL},
+        {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[] = {
-        {SDLK_a,         AKEYCODE_A},
-        {SDLK_b,         AKEYCODE_B},
-        {SDLK_c,         AKEYCODE_C},
-        {SDLK_d,         AKEYCODE_D},
-        {SDLK_e,         AKEYCODE_E},
-        {SDLK_f,         AKEYCODE_F},
-        {SDLK_g,         AKEYCODE_G},
-        {SDLK_h,         AKEYCODE_H},
-        {SDLK_i,         AKEYCODE_I},
-        {SDLK_j,         AKEYCODE_J},
-        {SDLK_k,         AKEYCODE_K},
-        {SDLK_l,         AKEYCODE_L},
-        {SDLK_m,         AKEYCODE_M},
-        {SDLK_n,         AKEYCODE_N},
-        {SDLK_o,         AKEYCODE_O},
-        {SDLK_p,         AKEYCODE_P},
-        {SDLK_q,         AKEYCODE_Q},
-        {SDLK_r,         AKEYCODE_R},
-        {SDLK_s,         AKEYCODE_S},
-        {SDLK_t,         AKEYCODE_T},
-        {SDLK_u,         AKEYCODE_U},
-        {SDLK_v,         AKEYCODE_V},
-        {SDLK_w,         AKEYCODE_W},
-        {SDLK_x,         AKEYCODE_X},
-        {SDLK_y,         AKEYCODE_Y},
-        {SDLK_z,         AKEYCODE_Z},
-        {SDLK_SPACE,     AKEYCODE_SPACE},
+        {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[] = {
-        {SDLK_HASH,          AKEYCODE_POUND},
-        {SDLK_PERCENT,       AKEYCODE_PERIOD},
-        {SDLK_QUOTE,         AKEYCODE_APOSTROPHE},
-        {SDLK_ASTERISK,      AKEYCODE_STAR},
-        {SDLK_PLUS,          AKEYCODE_PLUS},
-        {SDLK_COMMA,         AKEYCODE_COMMA},
-        {SDLK_MINUS,         AKEYCODE_MINUS},
-        {SDLK_PERIOD,        AKEYCODE_PERIOD},
-        {SDLK_SLASH,         AKEYCODE_SLASH},
-        {SDLK_0,             AKEYCODE_0},
-        {SDLK_1,             AKEYCODE_1},
-        {SDLK_2,             AKEYCODE_2},
-        {SDLK_3,             AKEYCODE_3},
-        {SDLK_4,             AKEYCODE_4},
-        {SDLK_5,             AKEYCODE_5},
-        {SDLK_6,             AKEYCODE_6},
-        {SDLK_7,             AKEYCODE_7},
-        {SDLK_8,             AKEYCODE_8},
-        {SDLK_9,             AKEYCODE_9},
-        {SDLK_SEMICOLON,     AKEYCODE_SEMICOLON},
-        {SDLK_EQUALS,        AKEYCODE_EQUALS},
-        {SDLK_AT,            AKEYCODE_AT},
-        {SDLK_LEFTBRACKET,   AKEYCODE_LEFT_BRACKET},
-        {SDLK_BACKSLASH,     AKEYCODE_BACKSLASH},
-        {SDLK_RIGHTBRACKET,  AKEYCODE_RIGHT_BRACKET},
-        {SDLK_BACKQUOTE,     AKEYCODE_GRAVE},
-        {SDLK_KP_1,          AKEYCODE_NUMPAD_1},
-        {SDLK_KP_2,          AKEYCODE_NUMPAD_2},
-        {SDLK_KP_3,          AKEYCODE_NUMPAD_3},
-        {SDLK_KP_4,          AKEYCODE_NUMPAD_4},
-        {SDLK_KP_5,          AKEYCODE_NUMPAD_5},
-        {SDLK_KP_6,          AKEYCODE_NUMPAD_6},
-        {SDLK_KP_7,          AKEYCODE_NUMPAD_7},
-        {SDLK_KP_8,          AKEYCODE_NUMPAD_8},
-        {SDLK_KP_9,          AKEYCODE_NUMPAD_9},
-        {SDLK_KP_0,          AKEYCODE_NUMPAD_0},
-        {SDLK_KP_DIVIDE,     AKEYCODE_NUMPAD_DIVIDE},
-        {SDLK_KP_MULTIPLY,   AKEYCODE_NUMPAD_MULTIPLY},
-        {SDLK_KP_MINUS,      AKEYCODE_NUMPAD_SUBTRACT},
-        {SDLK_KP_PLUS,       AKEYCODE_NUMPAD_ADD},
-        {SDLK_KP_PERIOD,     AKEYCODE_NUMPAD_DOT},
-        {SDLK_KP_EQUALS,     AKEYCODE_NUMPAD_EQUALS},
-        {SDLK_KP_LEFTPAREN,  AKEYCODE_NUMPAD_LEFT_PAREN},
-        {SDLK_KP_RIGHTPAREN, AKEYCODE_NUMPAD_RIGHT_PAREN},
+        {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 =
@@ -157,7 +150,7 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
         return true;
     }
 
-    if (!(mod & (KMOD_NUM | KMOD_SHIFT))) {
+    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);
@@ -167,12 +160,13 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
         }
     }
 
-    if (key_inject_mode == SC_KEY_INJECT_MODE_TEXT && !(mod & KMOD_CTRL)) {
+    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 & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
+    if (mod & (SC_MOD_LALT | SC_MOD_RALT | SC_MOD_LGUI | SC_MOD_RGUI)) {
         return false;
     }
 
@@ -214,70 +208,63 @@ autocomplete_metastate(enum android_metastate metastate) {
 }
 
 static enum android_metastate
-convert_meta_state(SDL_Keymod mod) {
+convert_meta_state(uint16_t mod) {
     enum android_metastate metastate = 0;
-    if (mod & KMOD_LSHIFT) {
+    if (mod & SC_MOD_LSHIFT) {
         metastate |= AMETA_SHIFT_LEFT_ON;
     }
-    if (mod & KMOD_RSHIFT) {
+    if (mod & SC_MOD_RSHIFT) {
         metastate |= AMETA_SHIFT_RIGHT_ON;
     }
-    if (mod & KMOD_LCTRL) {
+    if (mod & SC_MOD_LCTRL) {
         metastate |= AMETA_CTRL_LEFT_ON;
     }
-    if (mod & KMOD_RCTRL) {
+    if (mod & SC_MOD_RCTRL) {
         metastate |= AMETA_CTRL_RIGHT_ON;
     }
-    if (mod & KMOD_LALT) {
+    if (mod & SC_MOD_LALT) {
         metastate |= AMETA_ALT_LEFT_ON;
     }
-    if (mod & KMOD_RALT) {
+    if (mod & SC_MOD_RALT) {
         metastate |= AMETA_ALT_RIGHT_ON;
     }
-    if (mod & KMOD_LGUI) { // Windows key
+    if (mod & SC_MOD_LGUI) { // Windows key
         metastate |= AMETA_META_LEFT_ON;
     }
-    if (mod & KMOD_RGUI) { // Windows key
+    if (mod & SC_MOD_RGUI) { // Windows key
         metastate |= AMETA_META_RIGHT_ON;
     }
-    if (mod & KMOD_NUM) {
+    if (mod & SC_MOD_NUM) {
         metastate |= AMETA_NUM_LOCK_ON;
     }
-    if (mod & KMOD_CAPS) {
+    if (mod & SC_MOD_CAPS) {
         metastate |= AMETA_CAPS_LOCK_ON;
     }
-    if (mod & KMOD_MODE) { // Alt Gr
-        // no mapping?
-    }
 
     // fill the dependent fields
     return autocomplete_metastate(metastate);
 }
 
 static bool
-convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
+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) {
-    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
+    msg->type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
 
-    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
+    if (!convert_keycode(event->keycode, &msg->inject_keycode.keycode,
+                         event->mods_state, key_inject_mode)) {
         return false;
     }
 
-    uint16_t mod = from->keysym.mod;
-    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod,
-                         key_inject_mode)) {
-        return false;
-    }
-
-    to->inject_keycode.repeat = repeat;
-    to->inject_keycode.metastate = convert_meta_state(mod);
+    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 SDL_KeyboardEvent *event,
+                             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
@@ -295,9 +282,9 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
         ki->repeat = 0;
     }
 
-    struct control_msg msg;
+    struct sc_control_msg msg;
     if (convert_input_key(event, &msg, ki->key_inject_mode, ki->repeat)) {
-        if (!controller_push_msg(ki->controller, &msg)) {
+        if (!sc_controller_push_msg(ki->controller, &msg)) {
             LOGW("Could not request 'inject keycode'");
         }
     }
@@ -305,7 +292,7 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
 
 static void
 sc_key_processor_process_text(struct sc_key_processor *kp,
-                              const SDL_TextInputEvent *event) {
+                              const struct sc_text_event *event) {
     struct sc_keyboard_inject *ki = DOWNCAST(kp);
 
     if (ki->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
@@ -322,14 +309,14 @@ sc_key_processor_process_text(struct sc_key_processor *kp,
         }
     }
 
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
+    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 (!controller_push_msg(ki->controller, &msg)) {
+    if (!sc_controller_push_msg(ki->controller, &msg)) {
         free(msg.inject_text.text);
         LOGW("Could not request 'inject text'");
     }
@@ -337,11 +324,12 @@ sc_key_processor_process_text(struct sc_key_processor *kp,
 
 void
 sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
-                        struct controller *controller,
-                        const struct scrcpy_options *options) {
+                        struct sc_controller *controller,
+                        enum sc_key_inject_mode key_inject_mode,
+                        bool forward_key_repeat) {
     ki->controller = controller;
-    ki->key_inject_mode = options->key_inject_mode;
-    ki->forward_key_repeat = options->forward_key_repeat;
+    ki->key_inject_mode = key_inject_mode;
+    ki->forward_key_repeat = forward_key_repeat;
 
     ki->repeat = 0;
 

app/src/keyboard_inject.h

@@ -12,7 +12,7 @@
 struct sc_keyboard_inject {
     struct sc_key_processor key_processor; // key processor trait
 
-    struct controller *controller;
+    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.
@@ -24,7 +24,8 @@ struct sc_keyboard_inject {
 
 void
 sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
-                        struct controller *controller,
-                        const struct scrcpy_options *options);
+                        struct sc_controller *controller,
+                        enum sc_key_inject_mode key_inject_mode,
+                        bool forward_key_repeat);
 
 #endif

app/src/main.c

@@ -13,34 +13,19 @@
 #include "cli.h"
 #include "options.h"
 #include "scrcpy.h"
+#include "usb/scrcpy_otg.h"
 #include "util/log.h"
+#include "util/net.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);
-#ifdef HAVE_V4L2
-    fprintf(stderr, " - libavdevice %d.%d.%d\n", LIBAVDEVICE_VERSION_MAJOR,
-                                                 LIBAVDEVICE_VERSION_MINOR,
-                                                 LIBAVDEVICE_VERSION_MICRO);
+#ifdef _WIN32
+#include <windows.h>
+#include "util/str.h"
 #endif
-}
 
 int
-main(int argc, char *argv[]) {
-#ifdef __WINDOWS__
+main_scrcpy(int argc, char *argv[]) {
+#ifdef _WIN32
     // disable buffering, we want logs immediately
     // even line buffering (setvbuf() with mode _IOLBF) is not sufficient
     setbuf(stdout, NULL);
@@ -61,19 +46,19 @@ main(int argc, char *argv[]) {
 #endif
 
     if (!scrcpy_parse_args(&args, argc, argv)) {
-        return 1;
+        return SCRCPY_EXIT_FAILURE;
     }
 
     sc_set_log_level(args.opts.log_level);
 
     if (args.help) {
         scrcpy_print_usage(argv[0]);
-        return 0;
+        return SCRCPY_EXIT_SUCCESS;
     }
 
     if (args.version) {
-        print_version();
-        return 0;
+        scrcpy_print_version();
+        return SCRCPY_EXIT_SUCCESS;
     }
 
 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
@@ -86,13 +71,67 @@ main(int argc, char *argv[]) {
     }
 #endif
 
-    if (avformat_network_init()) {
-        return 1;
+    if (!net_init()) {
+        return SCRCPY_EXIT_FAILURE;
     }
 
-    int res = scrcpy(&args.opts) ? 0 : 1;
+    sc_log_configure();
 
-    avformat_network_deinit(); // ignore failure
+#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
 
-    return res;
+    return ret;
+}
+
+int
+main(int argc, char *argv[]) {
+#ifndef _WIN32
+    return main_scrcpy(argc, argv);
+#else
+    (void) argc;
+    (void) argv;
+    int wargc;
+    wchar_t **wargv = CommandLineToArgvW(GetCommandLineW(), &wargc);
+    if (!wargv) {
+        LOG_OOM();
+        return SCRCPY_EXIT_FAILURE;
+    }
+
+    char **argv_utf8 = malloc((wargc + 1) * sizeof(*argv_utf8));
+    if (!argv_utf8) {
+        LOG_OOM();
+        LocalFree(wargv);
+        return SCRCPY_EXIT_FAILURE;
+    }
+
+    argv_utf8[wargc] = NULL;
+
+    for (int i = 0; i < wargc; ++i) {
+        argv_utf8[i] = sc_str_from_wchars(wargv[i]);
+        if (!argv_utf8[i]) {
+            LOG_OOM();
+            for (int j = 0; j < i; ++j) {
+                free(argv_utf8[j]);
+            }
+            LocalFree(wargv);
+            free(argv_utf8);
+            return SCRCPY_EXIT_FAILURE;
+        }
+    }
+
+    LocalFree(wargv);
+
+    int ret = main_scrcpy(wargc, argv_utf8);
+
+    for (int i = 0; i < wargc; ++i) {
+        free(argv_utf8[i]);
+    }
+    free(argv_utf8);
+
+    return ret;
+#endif
 }

app/src/mouse_inject.c

@@ -1,11 +1,11 @@
 #include "mouse_inject.h"
 
 #include <assert.h>
-#include <SDL2/SDL_events.h>
 
 #include "android/input.h"
 #include "control_msg.h"
 #include "controller.h"
+#include "input_events.h"
 #include "util/intmap.h"
 #include "util/log.h"
 
@@ -15,210 +15,148 @@
 static enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state) {
     enum android_motionevent_buttons buttons = 0;
-    if (state & SDL_BUTTON_LMASK) {
+    if (state & SC_MOUSE_BUTTON_LEFT) {
         buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
     }
-    if (state & SDL_BUTTON_RMASK) {
+    if (state & SC_MOUSE_BUTTON_RIGHT) {
         buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
     }
-    if (state & SDL_BUTTON_MMASK) {
+    if (state & SC_MOUSE_BUTTON_MIDDLE) {
         buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
     }
-    if (state & SDL_BUTTON_X1MASK) {
+    if (state & SC_MOUSE_BUTTON_X1) {
         buttons |= AMOTION_EVENT_BUTTON_BACK;
     }
-    if (state & SDL_BUTTON_X2MASK) {
+    if (state & SC_MOUSE_BUTTON_X2) {
         buttons |= AMOTION_EVENT_BUTTON_FORWARD;
     }
     return buttons;
 }
 
-static bool
-convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
-    static const struct sc_intmap_entry actions[] = {
-        {SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN},
-        {SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP},
-    };
-
-    const struct sc_intmap_entry *entry = SC_INTMAP_FIND_ENTRY(actions, from);
-    if (entry) {
-        *to = entry->value;
-        return true;
+static enum android_motionevent_action
+convert_mouse_action(enum sc_action action) {
+    if (action == SC_ACTION_DOWN) {
+        return AMOTION_EVENT_ACTION_DOWN;
     }
-
-    return false;
+    assert(action == SC_ACTION_UP);
+    return AMOTION_EVENT_ACTION_UP;
 }
 
-static bool
-convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
-    static const struct sc_intmap_entry actions[] = {
-        {SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE},
-        {SDL_FINGERDOWN,   AMOTION_EVENT_ACTION_DOWN},
-        {SDL_FINGERUP,     AMOTION_EVENT_ACTION_UP},
-    };
-
-    const struct sc_intmap_entry *entry = SC_INTMAP_FIND_ENTRY(actions, from);
-    if (entry) {
-        *to = entry->value;
-        return true;
+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;
     }
-
-    return false;
-}
-
-static bool
-convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
-                     struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
-        screen_convert_window_to_frame_coords(screen, from->x, from->y);
-    to->inject_touch_event.pressure = 1.f;
-    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
-
-    return true;
-}
-
-static bool
-convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
-              struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-
-    if (!convert_touch_action(from->type, &to->inject_touch_event.action)) {
-        return false;
-    }
-
-    to->inject_touch_event.pointer_id = from->fingerId;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-
-    int dw;
-    int dh;
-    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
-
-    // SDL touch event coordinates are normalized in the range [0; 1]
-    int32_t x = from->x * dw;
-    int32_t y = from->y * dh;
-    to->inject_touch_event.position.point =
-        screen_convert_drawable_to_frame_coords(screen, x, y);
-
-    to->inject_touch_event.pressure = from->pressure;
-    to->inject_touch_event.buttons = 0;
-    return true;
-}
-
-static bool
-convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
-                     struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-
-    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
-        return false;
-    }
-
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
-        screen_convert_window_to_frame_coords(screen, from->x, from->y);
-    to->inject_touch_event.pressure =
-        from->type == SDL_MOUSEBUTTONDOWN ? 1.f : 0.f;
-    to->inject_touch_event.buttons =
-        convert_mouse_buttons(SDL_BUTTON(from->button));
-
-    return true;
-}
-
-static bool
-convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
-                    struct control_msg *to) {
-
-    // mouse_x and mouse_y are expressed in pixels relative to the window
-    int mouse_x;
-    int mouse_y;
-    SDL_GetMouseState(&mouse_x, &mouse_y);
-
-    struct sc_position position = {
-        .screen_size = screen->frame_size,
-        .point = screen_convert_window_to_frame_coords(screen,
-                                                       mouse_x, mouse_y),
-    };
-
-    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
-
-    to->inject_scroll_event.position = position;
-    to->inject_scroll_event.hscroll = from->x;
-    to->inject_scroll_event.vscroll = from->y;
-
-    return true;
 }
 
 static void
 sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
-                                        const SDL_MouseMotionEvent *event) {
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct control_msg msg;
-    if (!convert_mouse_motion(event, mi->screen, &msg)) {
+                                    const struct sc_mouse_motion_event *event) {
+    if (!event->buttons_state) {
+        // Do not send motion events when no click is pressed
         return;
     }
 
-    if (!controller_push_msg(mi->controller, &msg)) {
+    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 = event->pointer_id,
+            .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 = event->pointer_id,
+            .position = event->position,
+            .pressure = event->action == SC_ACTION_DOWN ? 1.f : 0.f,
+            .action_button = convert_mouse_buttons(event->button),
+            .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 SDL_TouchFingerEvent *event) {
+                                 const struct sc_touch_event *event) {
     struct sc_mouse_inject *mi = DOWNCAST(mp);
 
-    struct control_msg msg;
-    if (convert_touch(event, mi->screen, &msg)) {
-        if (!controller_push_msg(mi->controller, &msg)) {
+    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'");
     }
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_button(struct sc_mouse_processor *mp,
-                                        const SDL_MouseButtonEvent *event) {
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct control_msg msg;
-    if (convert_mouse_button(event, mi->screen, &msg)) {
-        if (!controller_push_msg(mi->controller, &msg)) {
-            LOGW("Could not request 'inject mouse button event'");
-        }
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_wheel(struct sc_mouse_processor *mp,
-                                       const SDL_MouseWheelEvent *event) {
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct control_msg msg;
-    if (convert_mouse_wheel(event, mi->screen, &msg)) {
-        if (!controller_push_msg(mi->controller, &msg)) {
-            LOGW("Could not request 'inject mouse wheel event'");
-        }
-    }
 }
 
 void
-sc_mouse_inject_init(struct sc_mouse_inject *mi, struct controller *controller,
-                     struct screen *screen) {
+sc_mouse_inject_init(struct sc_mouse_inject *mi,
+                     struct sc_controller *controller) {
     mi->controller = controller;
-    mi->screen = screen;
 
     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,
-        .process_mouse_button = sc_mouse_processor_process_mouse_button,
-        .process_mouse_wheel = sc_mouse_processor_process_mouse_wheel,
     };
 
     mi->mouse_processor.ops = &ops;
+
+    mi->mouse_processor.relative_mode = false;
 }

app/src/mouse_inject.h

@@ -12,12 +12,11 @@
 struct sc_mouse_inject {
     struct sc_mouse_processor mouse_processor; // mouse processor trait
 
-    struct controller *controller;
-    struct screen *screen;
+    struct sc_controller *controller;
 };
 
 void
-sc_mouse_inject_init(struct sc_mouse_inject *mi, struct controller *controller,
-                     struct screen *screen);
+sc_mouse_inject_init(struct sc_mouse_inject *mi,
+                     struct sc_controller *controller);
 
 #endif

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(PREFIX) - 1;
+        version += sizeof(OPENGL_ES_PREFIX) - 1;
     }
 
     int r = sscanf(version, "%d.%d", &gl->version_major, &gl->version_minor);

app/src/options.c

@@ -7,14 +7,17 @@ const struct scrcpy_options scrcpy_options_default = {
     .window_title = NULL,
     .push_target = NULL,
     .render_driver = NULL,
-    .codec_options = NULL,
-    .encoder_name = NULL,
-#ifdef HAVE_V4L2
-    .v4l2_device = NULL,
-#endif
+    .video_codec_options = NULL,
+    .audio_codec_options = NULL,
+    .video_encoder = NULL,
+    .audio_encoder = NULL,
     .log_level = SC_LOG_LEVEL_INFO,
+    .video_codec = SC_CODEC_H264,
+    .audio_codec = SC_CODEC_OPUS,
+    .audio_source = SC_AUDIO_SOURCE_OUTPUT,
     .record_format = SC_RECORD_FORMAT_AUTO,
     .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
+    .mouse_input_mode = SC_MOUSE_INPUT_MODE_INJECT,
     .port_range = {
         .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
         .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
@@ -22,11 +25,12 @@ const struct scrcpy_options scrcpy_options_default = {
     .tunnel_host = 0,
     .tunnel_port = 0,
     .shortcut_mods = {
-        .data = {SC_MOD_LALT, SC_MOD_LSUPER},
+        .data = {SC_SHORTCUT_MOD_LALT, SC_SHORTCUT_MOD_LSUPER},
         .count = 2,
     },
     .max_size = 0,
-    .bit_rate = DEFAULT_BIT_RATE,
+    .video_bit_rate = 0,
+    .audio_bit_rate = 0,
     .max_fps = 0,
     .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
     .rotation = 0,
@@ -36,12 +40,22 @@ const struct scrcpy_options scrcpy_options_default = {
     .window_height = 0,
     .display_id = 0,
     .display_buffer = 0,
+    .audio_buffer = SC_TICK_FROM_MS(50),
+    .audio_output_buffer = SC_TICK_FROM_MS(5),
+    .time_limit = 0,
+#ifdef HAVE_V4L2
+    .v4l2_device = NULL,
     .v4l2_buffer = 0,
+#endif
+#ifdef HAVE_USB
+    .otg = false,
+#endif
     .show_touches = false,
     .fullscreen = false,
     .always_on_top = false,
     .control = true,
-    .display = true,
+    .video_playback = true,
+    .audio_playback = true,
     .turn_screen_off = false,
     .key_inject_mode = SC_KEY_INJECT_MODE_MIXED,
     .window_borderless = false,
@@ -54,6 +68,18 @@ const struct scrcpy_options scrcpy_options_default = {
     .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,
+    .video = true,
+    .audio = true,
+    .require_audio = false,
+    .list_encoders = false,
+    .list_displays = false,
+    .kill_adb_on_close = false,
 };

app/src/options.h

@@ -21,6 +21,32 @@ enum sc_record_format {
     SC_RECORD_FORMAT_AUTO,
     SC_RECORD_FORMAT_MP4,
     SC_RECORD_FORMAT_MKV,
+    SC_RECORD_FORMAT_M4A,
+    SC_RECORD_FORMAT_MKA,
+    SC_RECORD_FORMAT_OPUS,
+    SC_RECORD_FORMAT_AAC,
+};
+
+static inline bool
+sc_record_format_is_audio_only(enum sc_record_format fmt) {
+    return fmt == SC_RECORD_FORMAT_M4A
+        || fmt == SC_RECORD_FORMAT_MKA
+        || fmt == SC_RECORD_FORMAT_OPUS
+        || fmt == SC_RECORD_FORMAT_AAC;
+}
+
+enum sc_codec {
+    SC_CODEC_H264,
+    SC_CODEC_H265,
+    SC_CODEC_AV1,
+    SC_CODEC_OPUS,
+    SC_CODEC_AAC,
+    SC_CODEC_RAW,
+};
+
+enum sc_audio_source {
+    SC_AUDIO_SOURCE_OUTPUT,
+    SC_AUDIO_SOURCE_MIC,
 };
 
 enum sc_lock_video_orientation {
@@ -38,6 +64,11 @@ enum sc_keyboard_input_mode {
     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.
@@ -55,12 +86,12 @@ enum sc_key_inject_mode {
 #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,
+    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 {
@@ -82,20 +113,24 @@ struct scrcpy_options {
     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
+    const char *video_codec_options;
+    const char *audio_codec_options;
+    const char *video_encoder;
+    const char *audio_encoder;
     enum sc_log_level log_level;
+    enum sc_codec video_codec;
+    enum sc_codec audio_codec;
+    enum sc_audio_source audio_source;
     enum sc_record_format record_format;
     enum sc_keyboard_input_mode keyboard_input_mode;
+    enum sc_mouse_input_mode mouse_input_mode;
     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;
+    uint32_t video_bit_rate;
+    uint32_t audio_bit_rate;
     uint16_t max_fps;
     enum sc_lock_video_orientation lock_video_orientation;
     uint8_t rotation;
@@ -105,12 +140,22 @@ struct scrcpy_options {
     uint16_t window_height;
     uint32_t display_id;
     sc_tick display_buffer;
+    sc_tick audio_buffer;
+    sc_tick audio_output_buffer;
+    sc_tick time_limit;
+#ifdef HAVE_V4L2
+    const char *v4l2_device;
     sc_tick v4l2_buffer;
+#endif
+#ifdef HAVE_USB
+    bool otg;
+#endif
     bool show_touches;
     bool fullscreen;
     bool always_on_top;
     bool control;
-    bool display;
+    bool video_playback;
+    bool audio_playback;
     bool turn_screen_off;
     enum sc_key_inject_mode key_inject_mode;
     bool window_borderless;
@@ -123,8 +168,20 @@ struct scrcpy_options {
     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;
+    bool video;
+    bool audio;
+    bool require_audio;
+    bool list_encoders;
+    bool list_displays;
+    bool kill_adb_on_close;
 };
 
 extern const struct scrcpy_options scrcpy_options_default;

app/src/packet_merger.c

@@ -0,0 +1,48 @@
+#include "packet_merger.h"
+
+#include "util/log.h"
+
+void
+sc_packet_merger_init(struct sc_packet_merger *merger) {
+    merger->config = NULL;
+}
+
+void
+sc_packet_merger_destroy(struct sc_packet_merger *merger) {
+    free(merger->config);
+}
+
+bool
+sc_packet_merger_merge(struct sc_packet_merger *merger, AVPacket *packet) {
+    bool is_config = packet->pts == AV_NOPTS_VALUE;
+
+    if (is_config) {
+        free(merger->config);
+
+        merger->config = malloc(packet->size);
+        if (!merger->config) {
+            LOG_OOM();
+            return false;
+        }
+
+        memcpy(merger->config, packet->data, packet->size);
+        merger->config_size = packet->size;
+    } else if (merger->config) {
+        size_t config_size = merger->config_size;
+        size_t media_size = packet->size;
+
+        if (av_grow_packet(packet, config_size)) {
+            LOG_OOM();
+            return false;
+        }
+
+        memmove(packet->data + config_size, packet->data, media_size);
+        memcpy(packet->data, merger->config, config_size);
+
+        free(merger->config);
+        merger->config = NULL;
+        // merger->size is meaningless when merger->config is NULL
+    }
+
+    return true;
+}

app/src/packet_merger.h

@@ -0,0 +1,43 @@
+#ifndef SC_PACKET_MERGER_H
+#define SC_PACKET_MERGER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <libavcodec/avcodec.h>
+
+/**
+ * Config packets (containing the SPS/PPS) are sent in-band. A new config
+ * packet is sent whenever a new encoding session is started (on start and on
+ * device orientation change).
+ *
+ * Every time a config packet is received, it must be sent alone (for recorder
+ * extradata), then concatenated to the next media packet (for correct decoding
+ * and recording).
+ *
+ * This helper reads every input packet and modifies each media packet which
+ * immediately follows a config packet to prepend the config packet payload.
+ */
+
+struct sc_packet_merger {
+    uint8_t *config;
+    size_t config_size;
+};
+
+void
+sc_packet_merger_init(struct sc_packet_merger *merger);
+
+void
+sc_packet_merger_destroy(struct sc_packet_merger *merger);
+
+/**
+ * If the packet is a config packet, then keep its data for later.
+ * Otherwise (if the packet is a media packet), then if a config packet is
+ * pending, prepend the config packet to this packet (so the packet is
+ * modified!).
+ */
+bool
+sc_packet_merger_merge(struct sc_packet_merger *merger, AVPacket *packet);
+
+#endif

app/src/receiver.c

@@ -7,7 +7,7 @@
 #include "util/log.h"
 
 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
+sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
               struct sc_acksync *acksync) {
     bool ok = sc_mutex_init(&receiver->mutex);
     if (!ok) {
@@ -21,12 +21,12 @@ receiver_init(struct receiver *receiver, sc_socket control_socket,
 }
 
 void
-receiver_destroy(struct receiver *receiver) {
+sc_receiver_destroy(struct sc_receiver *receiver) {
     sc_mutex_destroy(&receiver->mutex);
 }
 
 static void
-process_msg(struct receiver *receiver, struct device_msg *msg) {
+process_msg(struct sc_receiver *receiver, struct device_msg *msg) {
     switch (msg->type) {
         case DEVICE_MSG_TYPE_CLIPBOARD: {
             char *current = SDL_GetClipboardText();
@@ -51,7 +51,7 @@ process_msg(struct receiver *receiver, struct device_msg *msg) {
 }
 
 static ssize_t
-process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
+process_msgs(struct sc_receiver *receiver, const unsigned char *buf, size_t len) {
     size_t head = 0;
     for (;;) {
         struct device_msg msg;
@@ -76,7 +76,7 @@ process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
 
 static int
 run_receiver(void *data) {
-    struct receiver *receiver = data;
+    struct sc_receiver *receiver = data;
 
     static unsigned char buf[DEVICE_MSG_MAX_SIZE];
     size_t head = 0;
@@ -108,13 +108,13 @@ run_receiver(void *data) {
 }
 
 bool
-receiver_start(struct receiver *receiver) {
+sc_receiver_start(struct sc_receiver *receiver) {
     LOGD("Starting receiver thread");
 
     bool ok = sc_thread_create(&receiver->thread, run_receiver,
                                "scrcpy-receiver", receiver);
     if (!ok) {
-        LOGC("Could not start receiver thread");
+        LOGE("Could not start receiver thread");
         return false;
     }
 
@@ -122,6 +122,6 @@ receiver_start(struct receiver *receiver) {
 }
 
 void
-receiver_join(struct receiver *receiver) {
+sc_receiver_join(struct sc_receiver *receiver) {
     sc_thread_join(&receiver->thread, NULL);
 }

app/src/receiver.h

@@ -1,5 +1,5 @@
-#ifndef RECEIVER_H
-#define RECEIVER_H
+#ifndef SC_RECEIVER_H
+#define SC_RECEIVER_H
 
 #include "common.h"
 
@@ -11,7 +11,7 @@
 
 // receive events from the device
 // managed by the controller
-struct receiver {
+struct sc_receiver {
     sc_socket control_socket;
     sc_thread thread;
     sc_mutex mutex;
@@ -20,18 +20,18 @@ struct receiver {
 };
 
 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
+sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
                  struct sc_acksync *acksync);
 
 void
-receiver_destroy(struct receiver *receiver);
+sc_receiver_destroy(struct sc_receiver *receiver);
 
 bool
-receiver_start(struct receiver *receiver);
+sc_receiver_start(struct sc_receiver *receiver);
 
-// no receiver_stop(), it will automatically stop on control_socket shutdown
+// no sc_receiver_stop(), it will automatically stop on control_socket shutdown
 
 void
-receiver_join(struct receiver *receiver);
+sc_receiver_join(struct sc_receiver *receiver);
 
 #endif

app/src/recorder.h

@@ -1,5 +1,5 @@
-#ifndef RECORDER_H
-#define RECORDER_H
+#ifndef SC_RECORDER_H
+#define SC_RECORDER_H
 
 #include "common.h"
 
@@ -9,44 +9,74 @@
 #include "coords.h"
 #include "options.h"
 #include "trait/packet_sink.h"
-#include "util/queue.h"
 #include "util/thread.h"
+#include "util/vecdeque.h"
 
-struct record_packet {
-    AVPacket *packet;
-    struct record_packet *next;
+struct sc_recorder_queue SC_VECDEQUE(AVPacket *);
+
+struct sc_recorder_stream {
+    int index;
+    int64_t last_pts;
 };
 
-struct recorder_queue SC_QUEUE(struct record_packet);
+struct sc_recorder {
+    struct sc_packet_sink video_packet_sink;
+    struct sc_packet_sink audio_packet_sink;
 
-struct recorder {
-    struct sc_packet_sink packet_sink; // packet sink trait
+    /* The audio flag is unprotected:
+     *  - it is initialized from sc_recorder_init() from the main thread;
+     *  - it may be reset once from the recorder thread if the audio is
+     *    disabled dynamically.
+     *
+     * Therefore, once the recorder thread is started, only the recorder thread
+     * may access it without data races.
+     */
+    bool audio;
+    bool video;
 
     char *filename;
     enum sc_record_format format;
     AVFormatContext *ctx;
-    struct sc_size declared_frame_size;
-    bool header_written;
 
     sc_thread thread;
     sc_mutex mutex;
-    sc_cond queue_cond;
-    bool stopped; // set on recorder_close()
-    bool failed; // set on packet write failure
-    struct recorder_queue queue;
+    sc_cond cond;
+    // set on sc_recorder_stop(), packet_sink close or recording failure
+    bool stopped;
+    struct sc_recorder_queue video_queue;
+    struct sc_recorder_queue audio_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 record_packet *previous;
+    // wake up the recorder thread once the video or audio codec is known
+    bool video_init;
+    bool audio_init;
+
+    struct sc_recorder_stream video_stream;
+    struct sc_recorder_stream audio_stream;
+
+    const struct sc_recorder_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+struct sc_recorder_callbacks {
+    void (*on_ended)(struct sc_recorder *recorder, bool success,
+                     void *userdata);
 };
 
 bool
-recorder_init(struct recorder *recorder, const char *filename,
-              enum sc_record_format format, struct sc_size declared_frame_size);
+sc_recorder_init(struct sc_recorder *recorder, const char *filename,
+                 enum sc_record_format format, bool video, bool audio,
+                 const struct sc_recorder_callbacks *cbs, void *cbs_userdata);
+
+bool
+sc_recorder_start(struct sc_recorder *recorder);
 
 void
-recorder_destroy(struct recorder *recorder);
+sc_recorder_stop(struct sc_recorder *recorder);
+
+void
+sc_recorder_join(struct sc_recorder *recorder);
+
+void
+sc_recorder_destroy(struct sc_recorder *recorder);
 
 #endif

app/src/scrcpy.h

@@ -6,7 +6,18 @@
 #include <stdbool.h>
 #include "options.h"
 
-bool
+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 scrcpy_exit_code
 scrcpy(struct scrcpy_options *options);
 
 #endif

app/src/screen.c

@@ -7,12 +7,11 @@
 #include "events.h"
 #include "icon.h"
 #include "options.h"
-#include "video_buffer.h"
 #include "util/log.h"
 
 #define DISPLAY_MARGINS 96
 
-#define DOWNCAST(SINK) container_of(SINK, struct screen, frame_sink)
+#define DOWNCAST(SINK) container_of(SINK, struct sc_screen, frame_sink)
 
 static inline struct sc_size
 get_rotated_size(struct sc_size size, int rotation) {
@@ -29,7 +28,7 @@ get_rotated_size(struct sc_size size, int rotation) {
 
 // get the window size in a struct sc_size
 static struct sc_size
-get_window_size(const struct screen *screen) {
+get_window_size(const struct sc_screen *screen) {
     int width;
     int height;
     SDL_GetWindowSize(screen->window, &width, &height);
@@ -41,7 +40,7 @@ get_window_size(const struct screen *screen) {
 }
 
 static struct sc_point
-get_window_position(const struct screen *screen) {
+get_window_position(const struct sc_screen *screen) {
     int x;
     int y;
     SDL_GetWindowPosition(screen->window, &x, &y);
@@ -54,9 +53,10 @@ get_window_position(const struct screen *screen) {
 
 // set the window size to be applied when fullscreen is disabled
 static void
-set_window_size(struct screen *screen, struct sc_size new_size) {
+set_window_size(struct sc_screen *screen, struct sc_size new_size) {
     assert(!screen->fullscreen);
     assert(!screen->maximized);
+    assert(!screen->minimized);
     SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
 }
 
@@ -156,8 +156,55 @@ get_initial_optimal_size(struct sc_size content_size, uint16_t req_width,
     return window_size;
 }
 
+static inline bool
+sc_screen_is_relative_mode(struct sc_screen *screen) {
+    // screen->im.mp may be NULL if --no-control
+    return screen->im.mp && screen->im.mp->relative_mode;
+}
+
 static void
-screen_update_content_rect(struct screen *screen) {
+sc_screen_set_mouse_capture(struct sc_screen *screen, bool capture) {
+#ifdef __APPLE__
+    // Workaround for SDL bug on macOS:
+    // <https://github.com/libsdl-org/SDL/issues/5340>
+    if (capture) {
+        int mouse_x, mouse_y;
+        SDL_GetGlobalMouseState(&mouse_x, &mouse_y);
+
+        int x, y, w, h;
+        SDL_GetWindowPosition(screen->window, &x, &y);
+        SDL_GetWindowSize(screen->window, &w, &h);
+
+        bool outside_window = mouse_x < x || mouse_x >= x + w
+                           || mouse_y < y || mouse_y >= y + h;
+        if (outside_window) {
+            SDL_WarpMouseInWindow(screen->window, w / 2, h / 2);
+        }
+    }
+#else
+    (void) screen;
+#endif
+    if (SDL_SetRelativeMouseMode(capture)) {
+        LOGE("Could not set relative mouse mode to %s: %s",
+             capture ? "true" : "false", SDL_GetError());
+    }
+}
+
+static inline bool
+sc_screen_get_mouse_capture(struct sc_screen *screen) {
+    (void) screen;
+    return SDL_GetRelativeMouseMode();
+}
+
+static inline void
+sc_screen_toggle_mouse_capture(struct sc_screen *screen) {
+    (void) screen;
+    bool new_value = !sc_screen_get_mouse_capture(screen);
+    sc_screen_set_mouse_capture(screen, new_value);
+}
+
+static void
+sc_screen_update_content_rect(struct sc_screen *screen) {
     int dw;
     int dh;
     SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
@@ -193,72 +240,21 @@ screen_update_content_rect(struct screen *screen) {
     }
 }
 
-static inline SDL_Texture *
-create_texture(struct screen *screen) {
-    SDL_Renderer *renderer = screen->renderer;
-    struct sc_size size = screen->frame_size;
-    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
-                                             SDL_TEXTUREACCESS_STREAMING,
-                                             size.width, size.height);
-    if (!texture) {
-        return NULL;
-    }
-
-    if (screen->mipmaps) {
-        struct sc_opengl *gl = &screen->gl;
-
-        SDL_GL_BindTexture(texture, NULL, NULL);
-
-        // Enable trilinear filtering for downscaling
-        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
-
-        SDL_GL_UnbindTexture(texture);
-    }
-
-    return texture;
-}
-
 // render the texture to the renderer
 //
 // Set the update_content_rect flag if the window or content size may have
 // changed, so that the content rectangle is recomputed
 static void
-screen_render(struct screen *screen, bool update_content_rect) {
+sc_screen_render(struct sc_screen *screen, bool update_content_rect) {
     if (update_content_rect) {
-        screen_update_content_rect(screen);
+        sc_screen_update_content_rect(screen);
     }
 
-    SDL_RenderClear(screen->renderer);
-    if (screen->rotation == 0) {
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
-    } else {
-        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
-        // counterclockwise (to be consistent with --lock-video-orientation)
-        int cw_rotation = (4 - screen->rotation) % 4;
-        double angle = 90 * cw_rotation;
-
-        SDL_Rect *dstrect = NULL;
-        SDL_Rect rect;
-        if (screen->rotation & 1) {
-            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
-            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
-            rect.w = screen->rect.h;
-            rect.h = screen->rect.w;
-            dstrect = &rect;
-        } else {
-            assert(screen->rotation == 2);
-            dstrect = &screen->rect;
-        }
-
-        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
-                         angle, NULL, 0);
-    }
-    SDL_RenderPresent(screen->renderer);
+    enum sc_display_result res =
+        sc_display_render(&screen->display, &screen->rect, screen->rotation);
+    (void) res; // any error already logged
 }
 
-
 #if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif
@@ -271,21 +267,43 @@ screen_render(struct screen *screen, bool update_content_rect) {
 // <https://stackoverflow.com/a/40693139/1987178>
 static int
 event_watcher(void *data, SDL_Event *event) {
-    struct screen *screen = data;
+    struct sc_screen *screen = data;
     if (event->type == SDL_WINDOWEVENT
             && event->window.event == SDL_WINDOWEVENT_RESIZED) {
         // In practice, it seems to always be called from the same thread in
         // that specific case. Anyway, it's just a workaround.
-        screen_render(screen, true);
+        sc_screen_render(screen, true);
     }
     return 0;
 }
 #endif
 
 static bool
-screen_frame_sink_open(struct sc_frame_sink *sink) {
-    struct screen *screen = DOWNCAST(sink);
-    (void) screen;
+sc_screen_frame_sink_open(struct sc_frame_sink *sink,
+                          const AVCodecContext *ctx) {
+    assert(ctx->pix_fmt == AV_PIX_FMT_YUV420P);
+    (void) ctx;
+
+    struct sc_screen *screen = DOWNCAST(sink);
+
+    assert(ctx->width > 0 && ctx->width <= 0xFFFF);
+    assert(ctx->height > 0 && ctx->height <= 0xFFFF);
+    // screen->frame_size is never used before the event is pushed, and the
+    // event acts as a memory barrier so it is safe without mutex
+    screen->frame_size.width = ctx->width;
+    screen->frame_size.height = ctx->height;
+
+    static SDL_Event event = {
+        .type = SC_EVENT_SCREEN_INIT_SIZE,
+    };
+
+    // Post the event on the UI thread (the texture must be created from there)
+    int ret = SDL_PushEvent(&event);
+    if (ret < 0) {
+        LOGW("Could not post init size event: %s", SDL_GetError());
+        return false;
+    }
+
 #ifndef NDEBUG
     screen->open = true;
 #endif
@@ -295,8 +313,8 @@ screen_frame_sink_open(struct sc_frame_sink *sink) {
 }
 
 static void
-screen_frame_sink_close(struct sc_frame_sink *sink) {
-    struct screen *screen = DOWNCAST(sink);
+sc_screen_frame_sink_close(struct sc_frame_sink *sink) {
+    struct sc_screen *screen = DOWNCAST(sink);
     (void) screen;
 #ifndef NDEBUG
     screen->open = false;
@@ -306,86 +324,66 @@ screen_frame_sink_close(struct sc_frame_sink *sink) {
 }
 
 static bool
-screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
-    struct screen *screen = DOWNCAST(sink);
-    return sc_video_buffer_push(&screen->vb, frame);
-}
+sc_screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
+    struct sc_screen *screen = DOWNCAST(sink);
 
-static void
-sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
-                             void *userdata) {
-    (void) vb;
-    struct screen *screen = userdata;
-
-    // event_failed implies previous_skipped (the previous frame may not have
-    // been consumed if the event was not sent)
-    assert(!screen->event_failed || previous_skipped);
-
-    bool need_new_event;
-    if (previous_skipped) {
-        fps_counter_add_skipped_frame(&screen->fps_counter);
-        // The EVENT_NEW_FRAME triggered for the previous frame will consume
-        // this new frame instead, unless the previous event failed
-        need_new_event = screen->event_failed;
-    } else {
-        need_new_event = true;
+    bool previous_skipped;
+    bool ok = sc_frame_buffer_push(&screen->fb, frame, &previous_skipped);
+    if (!ok) {
+        return false;
     }
 
-    if (need_new_event) {
+    if (previous_skipped) {
+        sc_fps_counter_add_skipped_frame(&screen->fps_counter);
+        // The SC_EVENT_NEW_FRAME triggered for the previous frame will consume
+        // this new frame instead
+    } else {
         static SDL_Event new_frame_event = {
-            .type = EVENT_NEW_FRAME,
+            .type = SC_EVENT_NEW_FRAME,
         };
 
         // Post the event on the UI thread
         int ret = SDL_PushEvent(&new_frame_event);
         if (ret < 0) {
             LOGW("Could not post new frame event: %s", SDL_GetError());
-            screen->event_failed = true;
-        } else {
-            screen->event_failed = false;
+            return false;
         }
     }
+
+    return true;
 }
 
 bool
-screen_init(struct screen *screen, const struct screen_params *params) {
+sc_screen_init(struct sc_screen *screen,
+               const struct sc_screen_params *params) {
     screen->resize_pending = false;
     screen->has_frame = false;
     screen->fullscreen = false;
     screen->maximized = false;
-    screen->event_failed = false;
+    screen->minimized = false;
+    screen->mouse_capture_key_pressed = 0;
 
-    static const struct sc_video_buffer_callbacks cbs = {
-        .on_new_frame = sc_video_buffer_on_new_frame,
-    };
+    screen->req.x = params->window_x;
+    screen->req.y = params->window_y;
+    screen->req.width = params->window_width;
+    screen->req.height = params->window_height;
+    screen->req.fullscreen = params->fullscreen;
+    screen->req.start_fps_counter = params->start_fps_counter;
 
-    bool ok = sc_video_buffer_init(&screen->vb, params->buffering_time, &cbs,
-                                   screen);
+    bool ok = sc_frame_buffer_init(&screen->fb);
     if (!ok) {
         return false;
     }
 
-    ok = sc_video_buffer_start(&screen->vb);
-    if (!ok) {
-        goto error_destroy_video_buffer;
+    if (!sc_fps_counter_init(&screen->fps_counter)) {
+        goto error_destroy_frame_buffer;
     }
 
-    if (!fps_counter_init(&screen->fps_counter)) {
-        goto error_stop_and_join_video_buffer;
-    }
-
-    screen->frame_size = params->frame_size;
     screen->rotation = params->rotation;
     if (screen->rotation) {
         LOGI("Initial display rotation set to %u", screen->rotation);
     }
-    struct sc_size content_size =
-        get_rotated_size(screen->frame_size, screen->rotation);
-    screen->content_size = content_size;
 
-    struct sc_size window_size =
-        get_initial_optimal_size(content_size,params->window_width,
-                                 params->window_height);
     uint32_t window_flags = SDL_WINDOW_HIDDEN
                           | SDL_WINDOW_RESIZABLE
                           | SDL_WINDOW_ALLOW_HIGHDPI;
@@ -396,58 +394,19 @@ screen_init(struct screen *screen, const struct screen_params *params) {
         window_flags |= SDL_WINDOW_BORDERLESS;
     }
 
-    int x = params->window_x != SC_WINDOW_POSITION_UNDEFINED
-          ? params->window_x : (int) SDL_WINDOWPOS_UNDEFINED;
-    int y = params->window_y != SC_WINDOW_POSITION_UNDEFINED
-          ? params->window_y : (int) SDL_WINDOWPOS_UNDEFINED;
-    screen->window = SDL_CreateWindow(params->window_title, x, y,
-                                      window_size.width, window_size.height,
-                                      window_flags);
+    // The window will be positioned and sized on first video frame
+    screen->window =
+        SDL_CreateWindow(params->window_title, 0, 0, 0, 0, window_flags);
     if (!screen->window) {
-        LOGC("Could not create window: %s", SDL_GetError());
+        LOGE("Could not create window: %s", SDL_GetError());
         goto error_destroy_fps_counter;
     }
 
-    screen->renderer = SDL_CreateRenderer(screen->window, -1,
-                                          SDL_RENDERER_ACCELERATED);
-    if (!screen->renderer) {
-        LOGC("Could not create renderer: %s", SDL_GetError());
+    ok = sc_display_init(&screen->display, screen->window, params->mipmaps);
+    if (!ok) {
         goto error_destroy_window;
     }
 
-    SDL_RendererInfo renderer_info;
-    int r = SDL_GetRendererInfo(screen->renderer, &renderer_info);
-    const char *renderer_name = r ? NULL : renderer_info.name;
-    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
-
-    screen->mipmaps = false;
-
-    // starts with "opengl"
-    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (use_opengl) {
-        struct sc_opengl *gl = &screen->gl;
-        sc_opengl_init(gl);
-
-        LOGI("OpenGL version: %s", gl->version);
-
-        if (params->mipmaps) {
-            bool supports_mipmaps =
-                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
-                                               2, 0  /* OpenGL ES 2.0+ */);
-            if (supports_mipmaps) {
-                LOGI("Trilinear filtering enabled");
-                screen->mipmaps = true;
-            } else {
-                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required)");
-            }
-        } else {
-            LOGI("Trilinear filtering disabled");
-        }
-    } else if (params->mipmaps) {
-        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
-    }
-
     SDL_Surface *icon = scrcpy_icon_load();
     if (icon) {
         SDL_SetWindowIcon(screen->window, icon);
@@ -456,39 +415,34 @@ screen_init(struct screen *screen, const struct screen_params *params) {
         LOGW("Could not load icon");
     }
 
-    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, params->frame_size.width,
-                                                  params->frame_size.height);
-    screen->texture = create_texture(screen);
-    if (!screen->texture) {
-        LOGC("Could not create texture: %s", SDL_GetError());
-        goto error_destroy_renderer;
-    }
-
     screen->frame = av_frame_alloc();
     if (!screen->frame) {
         LOG_OOM();
-        goto error_destroy_texture;
+        goto error_destroy_display;
     }
 
-    // Reset the window size to trigger a SIZE_CHANGED event, to workaround
-    // HiDPI issues with some SDL renderers when several displays having
-    // different HiDPI scaling are connected
-    SDL_SetWindowSize(screen->window, window_size.width, window_size.height);
+    struct sc_input_manager_params im_params = {
+        .controller = params->controller,
+        .fp = params->fp,
+        .screen = screen,
+        .kp = params->kp,
+        .mp = params->mp,
+        .forward_all_clicks = params->forward_all_clicks,
+        .legacy_paste = params->legacy_paste,
+        .clipboard_autosync = params->clipboard_autosync,
+        .shortcut_mods = params->shortcut_mods,
+    };
 
-    screen_update_content_rect(screen);
-
-    if (params->fullscreen) {
-        screen_switch_fullscreen(screen);
-    }
+    sc_input_manager_init(&screen->im, &im_params);
 
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
     SDL_AddEventWatch(event_watcher, screen);
 #endif
 
     static const struct sc_frame_sink_ops ops = {
-        .open = screen_frame_sink_open,
-        .close = screen_frame_sink_close,
-        .push = screen_frame_sink_push,
+        .open = sc_screen_frame_sink_open,
+        .close = sc_screen_frame_sink_close,
+        .push = sc_screen_frame_sink_push,
     };
 
     screen->frame_sink.ops = &ops;
@@ -499,60 +453,72 @@ screen_init(struct screen *screen, const struct screen_params *params) {
 
     return true;
 
-error_destroy_texture:
-    SDL_DestroyTexture(screen->texture);
-error_destroy_renderer:
-    SDL_DestroyRenderer(screen->renderer);
+error_destroy_display:
+    sc_display_destroy(&screen->display);
 error_destroy_window:
     SDL_DestroyWindow(screen->window);
 error_destroy_fps_counter:
-    fps_counter_destroy(&screen->fps_counter);
-error_stop_and_join_video_buffer:
-    sc_video_buffer_stop(&screen->vb);
-    sc_video_buffer_join(&screen->vb);
-error_destroy_video_buffer:
-    sc_video_buffer_destroy(&screen->vb);
+    sc_fps_counter_destroy(&screen->fps_counter);
+error_destroy_frame_buffer:
+    sc_frame_buffer_destroy(&screen->fb);
 
     return false;
 }
 
 static void
-screen_show_window(struct screen *screen) {
+sc_screen_show_initial_window(struct sc_screen *screen) {
+    int x = screen->req.x != SC_WINDOW_POSITION_UNDEFINED
+          ? screen->req.x : (int) SDL_WINDOWPOS_CENTERED;
+    int y = screen->req.y != SC_WINDOW_POSITION_UNDEFINED
+          ? screen->req.y : (int) SDL_WINDOWPOS_CENTERED;
+
+    struct sc_size window_size =
+        get_initial_optimal_size(screen->content_size, screen->req.width,
+                                                       screen->req.height);
+
+    set_window_size(screen, window_size);
+    SDL_SetWindowPosition(screen->window, x, y);
+
+    if (screen->req.fullscreen) {
+        sc_screen_switch_fullscreen(screen);
+    }
+
+    if (screen->req.start_fps_counter) {
+        sc_fps_counter_start(&screen->fps_counter);
+    }
+
     SDL_ShowWindow(screen->window);
 }
 
 void
-screen_hide_window(struct screen *screen) {
+sc_screen_hide_window(struct sc_screen *screen) {
     SDL_HideWindow(screen->window);
 }
 
 void
-screen_interrupt(struct screen *screen) {
-    sc_video_buffer_stop(&screen->vb);
-    fps_counter_interrupt(&screen->fps_counter);
+sc_screen_interrupt(struct sc_screen *screen) {
+    sc_fps_counter_interrupt(&screen->fps_counter);
 }
 
 void
-screen_join(struct screen *screen) {
-    sc_video_buffer_join(&screen->vb);
-    fps_counter_join(&screen->fps_counter);
+sc_screen_join(struct sc_screen *screen) {
+    sc_fps_counter_join(&screen->fps_counter);
 }
 
 void
-screen_destroy(struct screen *screen) {
+sc_screen_destroy(struct sc_screen *screen) {
 #ifndef NDEBUG
     assert(!screen->open);
 #endif
+    sc_display_destroy(&screen->display);
     av_frame_free(&screen->frame);
-    SDL_DestroyTexture(screen->texture);
-    SDL_DestroyRenderer(screen->renderer);
     SDL_DestroyWindow(screen->window);
-    fps_counter_destroy(&screen->fps_counter);
-    sc_video_buffer_destroy(&screen->vb);
+    sc_fps_counter_destroy(&screen->fps_counter);
+    sc_frame_buffer_destroy(&screen->fb);
 }
 
 static void
-resize_for_content(struct screen *screen, struct sc_size old_content_size,
+resize_for_content(struct sc_screen *screen, struct sc_size old_content_size,
                    struct sc_size new_content_size) {
     struct sc_size window_size = get_window_size(screen);
     struct sc_size target_size = {
@@ -566,12 +532,12 @@ resize_for_content(struct screen *screen, struct sc_size old_content_size,
 }
 
 static void
-set_content_size(struct screen *screen, struct sc_size new_content_size) {
-    if (!screen->fullscreen && !screen->maximized) {
+set_content_size(struct sc_screen *screen, struct sc_size new_content_size) {
+    if (!screen->fullscreen && !screen->maximized && !screen->minimized) {
         resize_for_content(screen, screen->content_size, new_content_size);
     } else if (!screen->resize_pending) {
         // Store the windowed size to be able to compute the optimal size once
-        // fullscreen and maximized are disabled
+        // fullscreen/maximized/minimized are disabled
         screen->windowed_content_size = screen->content_size;
         screen->resize_pending = true;
     }
@@ -580,9 +546,10 @@ set_content_size(struct screen *screen, struct sc_size new_content_size) {
 }
 
 static void
-apply_pending_resize(struct screen *screen) {
+apply_pending_resize(struct sc_screen *screen) {
     assert(!screen->fullscreen);
     assert(!screen->maximized);
+    assert(!screen->minimized);
     if (screen->resize_pending) {
         resize_for_content(screen, screen->windowed_content_size,
                                    screen->content_size);
@@ -591,7 +558,7 @@ apply_pending_resize(struct screen *screen) {
 }
 
 void
-screen_set_rotation(struct screen *screen, unsigned rotation) {
+sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation) {
     assert(rotation < 4);
     if (rotation == screen->rotation) {
         return;
@@ -605,72 +572,89 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
     screen->rotation = rotation;
     LOGI("Display rotation set to %u", rotation);
 
-    screen_render(screen, true);
+    sc_screen_render(screen, true);
+}
+
+static bool
+sc_screen_init_size(struct sc_screen *screen) {
+    // Before first frame
+    assert(!screen->has_frame);
+
+    // The requested size is passed via screen->frame_size
+
+    struct sc_size content_size =
+        get_rotated_size(screen->frame_size, screen->rotation);
+    screen->content_size = content_size;
+
+    enum sc_display_result res =
+        sc_display_set_texture_size(&screen->display, screen->frame_size);
+    return res != SC_DISPLAY_RESULT_ERROR;
 }
 
 // recreate the texture and resize the window if the frame size has changed
-static bool
-prepare_for_frame(struct screen *screen, struct sc_size new_frame_size) {
-    if (screen->frame_size.width != new_frame_size.width
-            || screen->frame_size.height != new_frame_size.height) {
-        // frame dimension changed, destroy texture
-        SDL_DestroyTexture(screen->texture);
+static enum sc_display_result
+prepare_for_frame(struct sc_screen *screen, struct sc_size new_frame_size) {
+    if (screen->frame_size.width == new_frame_size.width
+            && screen->frame_size.height == new_frame_size.height) {
+        return SC_DISPLAY_RESULT_OK;
+    }
 
+    // frame dimension changed
     screen->frame_size = new_frame_size;
 
     struct sc_size new_content_size =
         get_rotated_size(new_frame_size, screen->rotation);
     set_content_size(screen, new_content_size);
 
-        screen_update_content_rect(screen);
+    sc_screen_update_content_rect(screen);
 
-        LOGI("New texture: %" PRIu16 "x%" PRIu16,
-                     screen->frame_size.width, screen->frame_size.height);
-        screen->texture = create_texture(screen);
-        if (!screen->texture) {
-            LOGC("Could not create texture: %s", SDL_GetError());
-            return false;
-        }
-    }
-
-    return true;
-}
-
-// write the frame into the texture
-static void
-update_texture(struct screen *screen, const AVFrame *frame) {
-    SDL_UpdateYUVTexture(screen->texture, NULL,
-            frame->data[0], frame->linesize[0],
-            frame->data[1], frame->linesize[1],
-            frame->data[2], frame->linesize[2]);
-
-    if (screen->mipmaps) {
-        SDL_GL_BindTexture(screen->texture, NULL, NULL);
-        screen->gl.GenerateMipmap(GL_TEXTURE_2D);
-        SDL_GL_UnbindTexture(screen->texture);
-    }
+    return sc_display_set_texture_size(&screen->display, screen->frame_size);
 }
 
 static bool
-screen_update_frame(struct screen *screen) {
+sc_screen_update_frame(struct sc_screen *screen) {
     av_frame_unref(screen->frame);
-    sc_video_buffer_consume(&screen->vb, screen->frame);
+    sc_frame_buffer_consume(&screen->fb, screen->frame);
     AVFrame *frame = screen->frame;
 
-    fps_counter_add_rendered_frame(&screen->fps_counter);
+    sc_fps_counter_add_rendered_frame(&screen->fps_counter);
 
     struct sc_size new_frame_size = {frame->width, frame->height};
-    if (!prepare_for_frame(screen, new_frame_size)) {
+    enum sc_display_result res = prepare_for_frame(screen, new_frame_size);
+    if (res == SC_DISPLAY_RESULT_ERROR) {
         return false;
     }
-    update_texture(screen, frame);
+    if (res == SC_DISPLAY_RESULT_PENDING) {
+        // Not an error, but do not continue
+        return true;
+    }
 
-    screen_render(screen, false);
+    res = sc_display_update_texture(&screen->display, frame);
+    if (res == SC_DISPLAY_RESULT_ERROR) {
+        return false;
+    }
+    if (res == SC_DISPLAY_RESULT_PENDING) {
+        // Not an error, but do not continue
+        return true;
+    }
+
+    if (!screen->has_frame) {
+        screen->has_frame = true;
+        // this is the very first frame, show the window
+        sc_screen_show_initial_window(screen);
+
+        if (sc_screen_is_relative_mode(screen)) {
+            // Capture mouse on start
+            sc_screen_set_mouse_capture(screen, true);
+        }
+    }
+
+    sc_screen_render(screen, false);
     return true;
 }
 
 void
-screen_switch_fullscreen(struct screen *screen) {
+sc_screen_switch_fullscreen(struct sc_screen *screen) {
     uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
     if (SDL_SetWindowFullscreen(screen->window, new_mode)) {
         LOGW("Could not switch fullscreen mode: %s", SDL_GetError());
@@ -678,17 +662,17 @@ screen_switch_fullscreen(struct screen *screen) {
     }
 
     screen->fullscreen = !screen->fullscreen;
-    if (!screen->fullscreen && !screen->maximized) {
+    if (!screen->fullscreen && !screen->maximized && !screen->minimized) {
         apply_pending_resize(screen);
     }
 
     LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
-    screen_render(screen, true);
+    sc_screen_render(screen, true);
 }
 
 void
-screen_resize_to_fit(struct screen *screen) {
-    if (screen->fullscreen || screen->maximized) {
+sc_screen_resize_to_fit(struct sc_screen *screen) {
+    if (screen->fullscreen || screen->maximized || screen->minimized) {
         return;
     }
 
@@ -711,8 +695,8 @@ screen_resize_to_fit(struct screen *screen) {
 }
 
 void
-screen_resize_to_pixel_perfect(struct screen *screen) {
-    if (screen->fullscreen) {
+sc_screen_resize_to_pixel_perfect(struct sc_screen *screen) {
+    if (screen->fullscreen || screen->minimized) {
         return;
     }
 
@@ -727,20 +711,33 @@ screen_resize_to_pixel_perfect(struct screen *screen) {
                                             content_size.height);
 }
 
+static inline bool
+sc_screen_is_mouse_capture_key(SDL_Keycode key) {
+    return key == SDLK_LALT || key == SDLK_LGUI || key == SDLK_RGUI;
+}
+
 bool
-screen_handle_event(struct screen *screen, SDL_Event *event) {
+sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
+    bool relative_mode = sc_screen_is_relative_mode(screen);
+
     switch (event->type) {
-        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);
-            }
-            bool ok = screen_update_frame(screen);
+        case SC_EVENT_SCREEN_INIT_SIZE: {
+            // The initial size is passed via screen->frame_size
+            bool ok = sc_screen_init_size(screen);
             if (!ok) {
-                LOGW("Frame update failed\n");
+                LOGE("Could not initialize screen size");
+                return false;
             }
             return true;
+        }
+        case SC_EVENT_NEW_FRAME: {
+            bool ok = sc_screen_update_frame(screen);
+            if (!ok) {
+                LOGE("Frame update failed\n");
+                return false;
+            }
+            return true;
+        }
         case SDL_WINDOWEVENT:
             if (!screen->has_frame) {
                 // Do nothing
@@ -748,14 +745,17 @@ screen_handle_event(struct screen *screen, SDL_Event *event) {
             }
             switch (event->window.event) {
                 case SDL_WINDOWEVENT_EXPOSED:
-                    screen_render(screen, true);
+                    sc_screen_render(screen, true);
                     break;
                 case SDL_WINDOWEVENT_SIZE_CHANGED:
-                    screen_render(screen, true);
+                    sc_screen_render(screen, true);
                     break;
                 case SDL_WINDOWEVENT_MAXIMIZED:
                     screen->maximized = true;
                     break;
+                case SDL_WINDOWEVENT_MINIMIZED:
+                    screen->minimized = true;
+                    break;
                 case SDL_WINDOWEVENT_RESTORED:
                     if (screen->fullscreen) {
                         // On Windows, in maximized+fullscreen, disabling
@@ -766,18 +766,81 @@ screen_handle_event(struct screen *screen, SDL_Event *event) {
                         break;
                     }
                     screen->maximized = false;
+                    screen->minimized = false;
                     apply_pending_resize(screen);
-                    screen_render(screen, true);
+                    sc_screen_render(screen, true);
+                    break;
+                case SDL_WINDOWEVENT_FOCUS_LOST:
+                    if (relative_mode) {
+                        sc_screen_set_mouse_capture(screen, false);
+                    }
                     break;
             }
             return true;
+        case SDL_KEYDOWN:
+            if (relative_mode) {
+                SDL_Keycode key = event->key.keysym.sym;
+                if (sc_screen_is_mouse_capture_key(key)) {
+                    if (!screen->mouse_capture_key_pressed) {
+                        screen->mouse_capture_key_pressed = key;
+                    } else {
+                        // Another mouse capture key has been pressed, cancel
+                        // mouse (un)capture
+                        screen->mouse_capture_key_pressed = 0;
+                    }
+                    // Mouse capture keys are never forwarded to the device
+                    return true;
+                }
+            }
+            break;
+        case SDL_KEYUP:
+            if (relative_mode) {
+                SDL_Keycode key = event->key.keysym.sym;
+                SDL_Keycode cap = screen->mouse_capture_key_pressed;
+                screen->mouse_capture_key_pressed = 0;
+                if (sc_screen_is_mouse_capture_key(key)) {
+                    if (key == cap) {
+                        // A mouse capture key has been pressed then released:
+                        // toggle the capture mouse mode
+                        sc_screen_toggle_mouse_capture(screen);
+                    }
+                    // Mouse capture keys are never forwarded to the device
+                    return true;
+                }
+            }
+            break;
+        case SDL_MOUSEWHEEL:
+        case SDL_MOUSEMOTION:
+        case SDL_MOUSEBUTTONDOWN:
+            if (relative_mode && !sc_screen_get_mouse_capture(screen)) {
+                // Do not forward to input manager, the mouse will be captured
+                // on SDL_MOUSEBUTTONUP
+                return true;
+            }
+            break;
+        case SDL_FINGERMOTION:
+        case SDL_FINGERDOWN:
+        case SDL_FINGERUP:
+            if (relative_mode) {
+                // Touch events are not compatible with relative mode
+                // (coordinates are not relative)
+                return true;
+            }
+            break;
+        case SDL_MOUSEBUTTONUP:
+            if (relative_mode && !sc_screen_get_mouse_capture(screen)) {
+                sc_screen_set_mouse_capture(screen, true);
+                return true;
+            }
+            break;
     }
 
-    return false;
+    sc_input_manager_handle_event(&screen->im, event);
+    return true;
 }
 
 struct sc_point
-screen_convert_drawable_to_frame_coords(struct screen *screen,
+sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen,
                                            int32_t x, int32_t y) {
     unsigned rotation = screen->rotation;
     assert(rotation < 4);
@@ -814,14 +877,14 @@ screen_convert_drawable_to_frame_coords(struct screen *screen,
 }
 
 struct sc_point
-screen_convert_window_to_frame_coords(struct screen *screen,
+sc_screen_convert_window_to_frame_coords(struct sc_screen *screen,
                                          int32_t x, int32_t y) {
-    screen_hidpi_scale_coords(screen, &x, &y);
-    return screen_convert_drawable_to_frame_coords(screen, x, y);
+    sc_screen_hidpi_scale_coords(screen, &x, &y);
+    return sc_screen_convert_drawable_to_frame_coords(screen, x, y);
 }
 
 void
-screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y) {
+sc_screen_hidpi_scale_coords(struct sc_screen *screen, int32_t *x, int32_t *y) {
     // take the HiDPI scaling (dw/ww and dh/wh) into account
     int ww, wh, dw, dh;
     SDL_GetWindowSize(screen->window, &ww, &wh);

app/src/screen.h

@@ -7,26 +7,40 @@
 #include <SDL2/SDL.h>
 #include <libavformat/avformat.h>
 
+#include "controller.h"
 #include "coords.h"
+#include "display.h"
 #include "fps_counter.h"
+#include "frame_buffer.h"
+#include "input_manager.h"
 #include "opengl.h"
+#include "trait/key_processor.h"
 #include "trait/frame_sink.h"
-#include "video_buffer.h"
+#include "trait/mouse_processor.h"
 
-struct screen {
+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_video_buffer vb;
-    struct fps_counter fps_counter;
+    struct sc_display display;
+    struct sc_input_manager im;
+    struct sc_frame_buffer fb;
+    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;
 
     SDL_Window *window;
-    SDL_Renderer *renderer;
-    SDL_Texture *texture;
-    struct sc_opengl gl;
     struct sc_size frame_size;
     struct sc_size content_size; // rotated frame_size
 
@@ -42,22 +56,33 @@ struct screen {
     bool has_frame;
     bool fullscreen;
     bool maximized;
-    bool mipmaps;
+    bool minimized;
 
-    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 screen_params {
+struct sc_screen_params {
+    struct sc_controller *controller;
+    struct sc_file_pusher *fp;
+    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;
+
     const char *window_title;
-    struct sc_size frame_size;
     bool always_on_top;
 
-    int16_t window_x;
-    int16_t window_y;
-    uint16_t window_width;  // accepts SC_WINDOW_POSITION_UNDEFINED
-    uint16_t window_height; // accepts SC_WINDOW_POSITION_UNDEFINED
+    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;
 
@@ -65,64 +90,64 @@ struct screen_params {
     bool mipmaps;
 
     bool fullscreen;
-
-    sc_tick buffering_time;
+    bool start_fps_counter;
 };
 
 // initialize screen, create window, renderer and texture (window is hidden)
 bool
-screen_init(struct screen *screen, const struct screen_params *params);
+sc_screen_init(struct sc_screen *screen, const struct sc_screen_params *params);
 
 // request to interrupt any inner thread
 // must be called before screen_join()
 void
-screen_interrupt(struct screen *screen);
+sc_screen_interrupt(struct sc_screen *screen);
 
 // join any inner thread
 void
-screen_join(struct screen *screen);
+sc_screen_join(struct sc_screen *screen);
 
 // destroy window, renderer and texture (if any)
 void
-screen_destroy(struct screen *screen);
+sc_screen_destroy(struct sc_screen *screen);
 
 // hide the window
 //
 // It is used to hide the window immediately on closing without waiting for
 // screen_destroy()
 void
-screen_hide_window(struct screen *screen);
+sc_screen_hide_window(struct sc_screen *screen);
 
 // switch the fullscreen mode
 void
-screen_switch_fullscreen(struct screen *screen);
+sc_screen_switch_fullscreen(struct sc_screen *screen);
 
 // resize window to optimal size (remove black borders)
 void
-screen_resize_to_fit(struct screen *screen);
+sc_screen_resize_to_fit(struct sc_screen *screen);
 
 // resize window to 1:1 (pixel-perfect)
 void
-screen_resize_to_pixel_perfect(struct screen *screen);
+sc_screen_resize_to_pixel_perfect(struct sc_screen *screen);
 
 // set the display rotation (0, 1, 2 or 3, x90 degrees counterclockwise)
 void
-screen_set_rotation(struct screen *screen, unsigned rotation);
+sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation);
 
 // react to SDL events
+// If this function returns false, scrcpy must exit with an error.
 bool
-screen_handle_event(struct screen *screen, SDL_Event *event);
+sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event);
 
 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels
 struct sc_point
-screen_convert_window_to_frame_coords(struct screen *screen,
+sc_screen_convert_window_to_frame_coords(struct sc_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
-screen_convert_drawable_to_frame_coords(struct screen *screen,
+sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen,
                                           int32_t x, int32_t y);
 
 // Convert coordinates from window to drawable.
@@ -130,6 +155,6 @@ screen_convert_drawable_to_frame_coords(struct screen *screen,
 // drawable coordinates. They are the same if HiDPI scaling is 1, but differ
 // otherwise.
 void
-screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y);
+sc_screen_hidpi_scale_coords(struct sc_screen *screen, int32_t *x, int32_t *y);
 
 #endif

app/src/server.c

@@ -7,7 +7,8 @@
 #include <SDL2/SDL_timer.h>
 #include <SDL2/SDL_platform.h>
 
-#include "adb.h"
+#include "adb/adb.h"
+#include "util/binary.h"
 #include "util/file.h"
 #include "util/log.h"
 #include "util/net_intr.h"
@@ -19,6 +20,9 @@
 #define SC_SERVER_PATH_DEFAULT PREFIX "/share/scrcpy/" SC_SERVER_FILENAME
 #define SC_DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"
 
+#define SC_ADB_PORT_DEFAULT 5555
+#define SC_SOCKET_NAME_PREFIX "scrcpy_"
+
 static char *
 get_server_path(void) {
 #ifdef __WINDOWS__
@@ -65,10 +69,12 @@ get_server_path(void) {
 static void
 sc_server_params_destroy(struct sc_server_params *params) {
     // The server stores a copy of the params provided by the user
-    free((char *) params->serial);
+    free((char *) params->req_serial);
     free((char *) params->crop);
-    free((char *) params->codec_options);
-    free((char *) params->encoder_name);
+    free((char *) params->video_codec_options);
+    free((char *) params->audio_codec_options);
+    free((char *) params->video_encoder);
+    free((char *) params->audio_encoder);
     free((char *) params->tcpip_dst);
 }
 
@@ -89,10 +95,12 @@ sc_server_params_copy(struct sc_server_params *dst,
         } \
     }
 
-    COPY(serial);
+    COPY(req_serial);
     COPY(crop);
-    COPY(codec_options);
-    COPY(encoder_name);
+    COPY(video_codec_options);
+    COPY(audio_codec_options);
+    COPY(video_encoder);
+    COPY(audio_encoder);
     COPY(tcpip_dst);
 #undef COPY
 
@@ -114,7 +122,7 @@ push_server(struct sc_intr *intr, const char *serial) {
         free(server_path);
         return false;
     }
-    bool ok = adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH, 0);
+    bool ok = sc_adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH, 0);
     free(server_path);
     return ok;
 }
@@ -152,13 +160,39 @@ sc_server_sleep(struct sc_server *server, sc_tick deadline) {
     return !stopped;
 }
 
+static const char *
+sc_server_get_codec_name(enum sc_codec codec) {
+    switch (codec) {
+        case SC_CODEC_H264:
+            return "h264";
+        case SC_CODEC_H265:
+            return "h265";
+        case SC_CODEC_AV1:
+            return "av1";
+        case SC_CODEC_OPUS:
+            return "opus";
+        case SC_CODEC_AAC:
+            return "aac";
+        case SC_CODEC_RAW:
+            return "raw";
+        default:
+            return NULL;
+    }
+}
+
 static sc_pid
 execute_server(struct sc_server *server,
                const struct sc_server_params *params) {
     sc_pid pid = SC_PROCESS_NONE;
 
+    const char *serial = server->serial;
+    assert(serial);
+
     const char *cmd[128];
     unsigned count = 0;
+    cmd[count++] = sc_adb_get_executable();
+    cmd[count++] = "-s";
+    cmd[count++] = serial;
     cmd[count++] = "shell";
     cmd[count++] = "CLASSPATH=" SC_DEVICE_SERVER_PATH;
     cmd[count++] = "app_process";
@@ -182,17 +216,40 @@ execute_server(struct sc_server *server,
 
     unsigned dyn_idx = count; // from there, the strings are allocated
 #define ADD_PARAM(fmt, ...) { \
-        char *p = (char *) &cmd[count]; \
+        char *p; \
         if (asprintf(&p, fmt, ## __VA_ARGS__) == -1) { \
             goto end; \
         } \
         cmd[count++] = p; \
     }
-#define STRBOOL(v) (v ? "true" : "false")
 
+    ADD_PARAM("scid=%08x", params->scid);
     ADD_PARAM("log_level=%s", log_level_to_server_string(params->log_level));
-    ADD_PARAM("bit_rate=%" PRIu32, params->bit_rate);
 
+    if (!params->video) {
+        ADD_PARAM("video=false");
+    }
+    if (params->video_bit_rate) {
+        ADD_PARAM("video_bit_rate=%" PRIu32, params->video_bit_rate);
+    }
+    if (!params->audio) {
+        ADD_PARAM("audio=false");
+    }
+    if (params->audio_bit_rate) {
+        ADD_PARAM("audio_bit_rate=%" PRIu32, params->audio_bit_rate);
+    }
+    if (params->video_codec != SC_CODEC_H264) {
+        ADD_PARAM("video_codec=%s",
+                  sc_server_get_codec_name(params->video_codec));
+    }
+    if (params->audio_codec != SC_CODEC_OPUS) {
+        ADD_PARAM("audio_codec=%s",
+            sc_server_get_codec_name(params->audio_codec));
+    }
+    if (params->audio_source != SC_AUDIO_SOURCE_OUTPUT) {
+        assert(params->audio_source == SC_AUDIO_SOURCE_MIC);
+        ADD_PARAM("audio_source=mic");
+    }
     if (params->max_size) {
         ADD_PARAM("max_size=%" PRIu16, params->max_size);
     }
@@ -204,40 +261,65 @@ execute_server(struct sc_server *server,
                   params->lock_video_orientation);
     }
     if (server->tunnel.forward) {
-        ADD_PARAM("tunnel_forward=%s", STRBOOL(server->tunnel.forward));
+        ADD_PARAM("tunnel_forward=true");
     }
     if (params->crop) {
         ADD_PARAM("crop=%s", params->crop);
     }
     if (!params->control) {
         // By default, control is true
-        ADD_PARAM("control=%s", STRBOOL(params->control));
+        ADD_PARAM("control=false");
     }
     if (params->display_id) {
         ADD_PARAM("display_id=%" PRIu32, params->display_id);
     }
     if (params->show_touches) {
-        ADD_PARAM("show_touches=%s", STRBOOL(params->show_touches));
+        ADD_PARAM("show_touches=true");
     }
     if (params->stay_awake) {
-        ADD_PARAM("stay_awake=%s", STRBOOL(params->stay_awake));
+        ADD_PARAM("stay_awake=true");
     }
-    if (params->codec_options) {
-        ADD_PARAM("codec_options=%s", params->codec_options);
+    if (params->video_codec_options) {
+        ADD_PARAM("video_codec_options=%s", params->video_codec_options);
     }
-    if (params->encoder_name) {
-        ADD_PARAM("encoder_name=%s", params->encoder_name);
+    if (params->audio_codec_options) {
+        ADD_PARAM("audio_codec_options=%s", params->audio_codec_options);
+    }
+    if (params->video_encoder) {
+        ADD_PARAM("video_encoder=%s", params->video_encoder);
+    }
+    if (params->audio_encoder) {
+        ADD_PARAM("audio_encoder=%s", params->audio_encoder);
     }
     if (params->power_off_on_close) {
-        ADD_PARAM("power_off_on_close=%s", STRBOOL(params->power_off_on_close));
+        ADD_PARAM("power_off_on_close=true");
     }
     if (!params->clipboard_autosync) {
         // By default, clipboard_autosync is true
-        ADD_PARAM("clipboard_autosync=%s", STRBOOL(params->clipboard_autosync));
+        ADD_PARAM("clipboard_autosync=false");
+    }
+    if (!params->downsize_on_error) {
+        // By default, downsize_on_error is true
+        ADD_PARAM("downsize_on_error=false");
+    }
+    if (!params->cleanup) {
+        // By default, cleanup is true
+        ADD_PARAM("cleanup=false");
+    }
+    if (!params->power_on) {
+        // By default, power_on is true
+        ADD_PARAM("power_on=false");
+    }
+    if (params->list_encoders) {
+        ADD_PARAM("list_encoders=true");
+    }
+    if (params->list_displays) {
+        ADD_PARAM("list_displays=true");
     }
 
 #undef ADD_PARAM
-#undef STRBOOL
+
+    cmd[count++] = NULL;
 
 #ifdef SERVER_DEBUGGER
     LOGI("Server debugger waiting for a client on device port "
@@ -251,7 +333,7 @@ execute_server(struct sc_server *server,
     // Then click on "Debug"
 #endif
     // Inherit both stdout and stderr (all server logs are printed to stdout)
-    pid = adb_execute(params->serial, cmd, count, 0);
+    pid = sc_adb_execute(cmd, 0);
 
 end:
     for (unsigned i = dyn_idx; i < count; ++i) {
@@ -343,9 +425,12 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
         return false;
     }
 
+    server->serial = NULL;
+    server->device_socket_name = NULL;
     server->stopped = false;
 
     server->video_socket = SC_SOCKET_NONE;
+    server->audio_socket = SC_SOCKET_NONE;
     server->control_socket = SC_SOCKET_NONE;
 
     sc_adb_tunnel_init(&server->tunnel);
@@ -364,9 +449,9 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
 static bool
 device_read_info(struct sc_intr *intr, sc_socket device_socket,
                  struct sc_server_info *info) {
-    unsigned char buf[SC_DEVICE_NAME_FIELD_LENGTH + 4];
+    unsigned char buf[SC_DEVICE_NAME_FIELD_LENGTH];
     ssize_t r = net_recv_all_intr(intr, device_socket, buf, sizeof(buf));
-    if (r < SC_DEVICE_NAME_FIELD_LENGTH + 4) {
+    if (r < SC_DEVICE_NAME_FIELD_LENGTH) {
         LOGE("Could not retrieve device information");
         return false;
     }
@@ -374,10 +459,6 @@ device_read_info(struct sc_intr *intr, sc_socket device_socket,
     buf[SC_DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
     memcpy(info->device_name, (char *) buf, sizeof(info->device_name));
 
-    info->frame_size.width = (buf[SC_DEVICE_NAME_FIELD_LENGTH] << 8)
-                           | buf[SC_DEVICE_NAME_FIELD_LENGTH + 1];
-    info->frame_size.height = (buf[SC_DEVICE_NAME_FIELD_LENGTH + 2] << 8)
-                            | buf[SC_DEVICE_NAME_FIELD_LENGTH + 3];
     return true;
 }
 
@@ -387,16 +468,32 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
 
     assert(tunnel->enabled);
 
-    const char *serial = server->params.serial;
+    const char *serial = server->serial;
+    assert(serial);
+
+    bool video = server->params.video;
+    bool audio = server->params.audio;
     bool control = server->params.control;
 
     sc_socket video_socket = SC_SOCKET_NONE;
+    sc_socket audio_socket = SC_SOCKET_NONE;
     sc_socket control_socket = SC_SOCKET_NONE;
     if (!tunnel->forward) {
-        video_socket = net_accept_intr(&server->intr, tunnel->server_socket);
+        if (video) {
+            video_socket =
+                net_accept_intr(&server->intr, tunnel->server_socket);
             if (video_socket == SC_SOCKET_NONE) {
                 goto fail;
             }
+        }
+
+        if (audio) {
+            audio_socket =
+                net_accept_intr(&server->intr, tunnel->server_socket);
+            if (audio_socket == SC_SOCKET_NONE) {
+                goto fail;
+            }
+        }
 
         if (control) {
             control_socket =
@@ -418,15 +515,36 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
 
         unsigned attempts = 100;
         sc_tick delay = SC_TICK_FROM_MS(100);
-        video_socket = connect_to_server(server, attempts, delay, tunnel_host,
-                                         tunnel_port);
-        if (video_socket == SC_SOCKET_NONE) {
+        sc_socket first_socket = connect_to_server(server, attempts, delay,
+                                                   tunnel_host, tunnel_port);
+        if (first_socket == SC_SOCKET_NONE) {
             goto fail;
         }
 
+        if (video) {
+            video_socket = first_socket;
+        }
+
+        if (audio) {
+            if (!video) {
+                audio_socket = first_socket;
+            } else {
+                audio_socket = net_socket();
+                if (audio_socket == SC_SOCKET_NONE) {
+                    goto fail;
+                }
+                bool ok = net_connect_intr(&server->intr, audio_socket, tunnel_host,
+                                           tunnel_port);
+                if (!ok) {
+                    goto fail;
+                }
+            }
+        }
+
         if (control) {
-            // we know that the device is listening, we don't need several
-            // attempts
+            if (!video && !audio) {
+                control_socket = first_socket;
+            } else {
                 control_socket = net_socket();
                 if (control_socket == SC_SOCKET_NONE) {
                     goto fail;
@@ -438,20 +556,28 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
                 }
             }
         }
+    }
 
     // we don't need the adb tunnel anymore
-    sc_adb_tunnel_close(tunnel, &server->intr, serial);
+    sc_adb_tunnel_close(tunnel, &server->intr, serial,
+                        server->device_socket_name);
+
+    sc_socket first_socket = video ? video_socket
+                           : audio ? audio_socket
+                                   : control_socket;
 
     // The sockets will be closed on stop if device_read_info() fails
-    bool ok = device_read_info(&server->intr, video_socket, info);
+    bool ok = device_read_info(&server->intr, first_socket, info);
     if (!ok) {
         goto fail;
     }
 
-    assert(video_socket != SC_SOCKET_NONE);
+    assert(!video || video_socket != SC_SOCKET_NONE);
+    assert(!audio || audio_socket != SC_SOCKET_NONE);
     assert(!control || control_socket != SC_SOCKET_NONE);
 
     server->video_socket = video_socket;
+    server->audio_socket = audio_socket;
     server->control_socket = control_socket;
 
     return true;
@@ -463,14 +589,23 @@ fail:
         }
     }
 
+    if (audio_socket != SC_SOCKET_NONE) {
+        if (!net_close(audio_socket)) {
+            LOGW("Could not close audio socket");
+        }
+    }
+
     if (control_socket != SC_SOCKET_NONE) {
         if (!net_close(control_socket)) {
             LOGW("Could not close control socket");
         }
     }
 
+    if (tunnel->enabled) {
         // Always leave this function with tunnel disabled
-    sc_adb_tunnel_close(tunnel, &server->intr, serial);
+        sc_adb_tunnel_close(tunnel, &server->intr, serial,
+                            server->device_socket_name);
+    }
 
     return false;
 }
@@ -490,48 +625,36 @@ sc_server_on_terminated(void *userdata) {
     LOGD("Server terminated");
 }
 
-static bool
-sc_server_fill_serial(struct sc_server *server) {
-    // Retrieve the actual device immediately if not provided, so that all
-    // future adb commands are executed for this specific device, even if other
-    // devices are connected afterwards (without "more than one
-    // device/emulator" error)
-    if (!server->params.serial) {
-        // The serial is owned by sc_server_params, and will be freed on destroy
-        server->params.serial = adb_get_serialno(&server->intr, 0);
-        if (!server->params.serial) {
-            LOGE("Could not get device serial");
-            return false;
-        }
-
-        LOGD("Device serial: %s", server->params.serial);
-    }
-
-    return true;
-}
-
-static bool
-is_tcpip_mode_enabled(struct sc_server *server) {
+static uint16_t
+get_adb_tcp_port(struct sc_server *server, const char *serial) {
     struct sc_intr *intr = &server->intr;
-    const char *serial = server->params.serial;
 
     char *current_port =
-        adb_getprop(intr, serial, "service.adb.tcp.port", SC_ADB_SILENT);
+        sc_adb_getprop(intr, serial, "service.adb.tcp.port", SC_ADB_SILENT);
     if (!current_port) {
-        return false;
+        return 0;
     }
 
-    // Is the device is listening on TCP on port 5555?
-    bool enabled = !strcmp("5555", current_port);
+    long value;
+    bool ok = sc_str_parse_integer(current_port, &value);
     free(current_port);
-    return enabled;
+    if (!ok) {
+        return 0;
+    }
+
+    if (value < 0 || value > 0xFFFF) {
+        return 0;
+    }
+
+    return value;
 }
 
 static bool
-wait_tcpip_mode_enabled(struct sc_server *server, unsigned attempts,
+wait_tcpip_mode_enabled(struct sc_server *server, const char *serial,
+                        uint16_t expected_port, unsigned attempts,
                         sc_tick delay) {
-    if (is_tcpip_mode_enabled(server)) {
-        LOGI("TCP/IP mode enabled");
+    uint16_t adb_port = get_adb_tcp_port(server, serial);
+    if (adb_port == expected_port) {
         return true;
     }
 
@@ -545,74 +668,70 @@ wait_tcpip_mode_enabled(struct sc_server *server, unsigned attempts,
             return false;
         }
 
-        if (is_tcpip_mode_enabled(server)) {
-            LOGI("TCP/IP mode enabled");
+        adb_port = get_adb_tcp_port(server, serial);
+        if (adb_port == expected_port) {
             return true;
         }
     } while (--attempts);
     return false;
 }
 
-char *
-append_port_5555(const char *ip) {
-    size_t len = strlen(ip);
-
-    // sizeof counts the final '\0'
-    char *ip_port = malloc(len + sizeof(":5555"));
-    if (!ip_port) {
+static char *
+append_port(const char *ip, uint16_t port) {
+    char *ip_port;
+    int ret = asprintf(&ip_port, "%s:%" PRIu16, ip, port);
+    if (ret == -1) {
         LOG_OOM();
         return NULL;
     }
 
-    memcpy(ip_port, ip, len);
-    memcpy(ip_port + len, ":5555", sizeof(":5555"));
-
     return ip_port;
 }
 
-static bool
-sc_server_switch_to_tcpip(struct sc_server *server, char **out_ip_port) {
-    const char *serial = server->params.serial;
+static char *
+sc_server_switch_to_tcpip(struct sc_server *server, const char *serial) {
     assert(serial);
 
     struct sc_intr *intr = &server->intr;
 
-    char *ip = adb_get_device_ip(intr, serial, 0);
+    LOGI("Switching device %s to TCP/IP...", serial);
+
+    char *ip = sc_adb_get_device_ip(intr, serial, 0);
     if (!ip) {
         LOGE("Device IP not found");
-        return false;
+        return NULL;
     }
 
-    char *ip_port = append_port_5555(ip);
-    free(ip);
-    if (!ip_port) {
-        return false;
-    }
+    uint16_t adb_port = get_adb_tcp_port(server, serial);
+    if (adb_port) {
+        LOGI("TCP/IP mode already enabled on port %" PRIu16, adb_port);
+    } else {
+        LOGI("Enabling TCP/IP mode on port " SC_STR(SC_ADB_PORT_DEFAULT) "...");
 
-    bool tcp_mode = is_tcpip_mode_enabled(server);
-
-    if (!tcp_mode) {
-        bool ok = adb_tcpip(intr, serial, 5555, SC_ADB_NO_STDOUT);
+        bool ok = sc_adb_tcpip(intr, serial, SC_ADB_PORT_DEFAULT,
+                               SC_ADB_NO_STDOUT);
         if (!ok) {
             LOGE("Could not restart adbd in TCP/IP mode");
-            goto error;
+            free(ip);
+            return NULL;
         }
 
         unsigned attempts = 40;
         sc_tick delay = SC_TICK_FROM_MS(250);
-        ok = wait_tcpip_mode_enabled(server, attempts, delay);
+        ok = wait_tcpip_mode_enabled(server, serial, SC_ADB_PORT_DEFAULT,
+                                     attempts, delay);
         if (!ok) {
-            goto error;
-        }
+            free(ip);
+            return NULL;
         }
 
-    *out_ip_port = ip_port;
+        adb_port = SC_ADB_PORT_DEFAULT;
+        LOGI("TCP/IP mode enabled on port " SC_STR(SC_ADB_PORT_DEFAULT));
+    }
 
-    return true;
-
-error:
-    free(ip_port);
-    return false;
+    char *ip_port = append_port(ip, adb_port);
+    free(ip);
+    return ip_port;
 }
 
 static bool
@@ -620,73 +739,68 @@ sc_server_connect_to_tcpip(struct sc_server *server, const char *ip_port) {
     struct sc_intr *intr = &server->intr;
 
     // Error expected if not connected, do not report any error
-    adb_disconnect(intr, ip_port, SC_ADB_SILENT);
+    sc_adb_disconnect(intr, ip_port, SC_ADB_SILENT);
 
-    bool ok = adb_connect(intr, ip_port, 0);
+    LOGI("Connecting to %s...", ip_port);
+
+    bool ok = sc_adb_connect(intr, ip_port, 0);
     if (!ok) {
         LOGE("Could not connect to %s", ip_port);
         return false;
     }
 
-    // Override the serial, owned by the sc_server_params
-    free((void *) server->params.serial);
-    server->params.serial = strdup(ip_port);
-    if (!server->params.serial) {
-        LOG_OOM();
-        return false;
-    }
-
     LOGI("Connected to %s", ip_port);
     return true;
 }
 
-
 static bool
-sc_server_configure_tcpip(struct sc_server *server) {
-    char *ip_port;
-
-    const struct sc_server_params *params = &server->params;
-
-    // If tcpip parameter is given, then it must connect to this address.
-    // Therefore, the device is unknown, so serial is meaningless at this point.
-    assert(!params->serial || !params->tcpip_dst);
-
-    if (params->tcpip_dst) {
+sc_server_configure_tcpip_known_address(struct sc_server *server,
+                                        const char *addr) {
     // Append ":5555" if no port is present
-        bool contains_port = strchr(params->tcpip_dst, ':');
-        ip_port = contains_port ? strdup(params->tcpip_dst)
-                                : append_port_5555(params->tcpip_dst);
+    bool contains_port = strchr(addr, ':');
+    char *ip_port = contains_port ? strdup(addr)
+                                  : append_port(addr, SC_ADB_PORT_DEFAULT);
     if (!ip_port) {
         LOG_OOM();
         return false;
     }
-    } else {
-        // The device IP address must be retrieved from the current
-        // connected device
-        if (!sc_server_fill_serial(server)) {
-            return false;
-        }
 
-        // The serial is either the real serial when connected via USB, or
-        // the IP:PORT when connected over TCP/IP. Only the latter contains
-        // a colon.
-        bool is_already_tcpip = strchr(params->serial, ':');
+    server->serial = ip_port;
+    return sc_server_connect_to_tcpip(server, ip_port);
+}
+
+static bool
+sc_server_configure_tcpip_unknown_address(struct sc_server *server,
+                                          const char *serial) {
+    bool is_already_tcpip =
+        sc_adb_device_get_type(serial) == SC_ADB_DEVICE_TYPE_TCPIP;
     if (is_already_tcpip) {
         // Nothing to do
-            LOGI("Device already connected via TCP/IP: %s", params->serial);
+        LOGI("Device already connected via TCP/IP: %s", serial);
+        server->serial = strdup(serial);
+        if (!server->serial) {
+            LOG_OOM();
+            return false;
+        }
         return true;
     }
 
-        bool ok = sc_server_switch_to_tcpip(server, &ip_port);
-        if (!ok) {
+    char *ip_port = sc_server_switch_to_tcpip(server, serial);
+    if (!ip_port) {
         return false;
     }
-    }
 
-    // On success, this call changes params->serial
-    bool ok = sc_server_connect_to_tcpip(server, ip_port);
-    free(ip_port);
-    return ok;
+    server->serial = ip_port;
+    return sc_server_connect_to_tcpip(server, ip_port);
+}
+
+static void
+sc_server_kill_adb_if_requested(struct sc_server *server) {
+    if (server->params.kill_adb_on_close) {
+        LOGI("Killing adb server...");
+        unsigned flags = SC_ADB_NO_STDOUT | SC_ADB_NO_STDERR | SC_ADB_NO_LOGERR;
+        sc_adb_kill_server(&server->intr, flags);
+    }
 }
 
 static int
@@ -695,31 +809,116 @@ run_server(void *data) {
 
     const struct sc_server_params *params = &server->params;
 
-    if (params->serial) {
-        LOGD("Device serial: %s", params->serial);
+    // Execute "adb start-server" before "adb devices" so that daemon starting
+    // output/errors is correctly printed in the console ("adb devices" output
+    // is parsed, so it is not output)
+    bool ok = sc_adb_start_server(&server->intr, 0);
+    if (!ok) {
+        LOGE("Could not start adb server");
+        goto error_connection_failed;
+    }
+
+    // params->tcpip_dst implies params->tcpip
+    assert(!params->tcpip_dst || params->tcpip);
+
+    // If tcpip_dst parameter is given, then it must connect to this address.
+    // Therefore, the device is unknown, so serial is meaningless at this point.
+    assert(!params->req_serial || !params->tcpip_dst);
+
+    // A device must be selected via a serial in all cases except when --tcpip=
+    // is called with a parameter (in that case, the device may initially not
+    // exist, and scrcpy will execute "adb connect").
+    bool need_initial_serial = !params->tcpip_dst;
+
+    if (need_initial_serial) {
+        // At most one of the 3 following parameters may be set
+        assert(!!params->req_serial
+               + params->select_usb
+               + params->select_tcpip <= 1);
+
+        struct sc_adb_device_selector selector;
+        if (params->req_serial) {
+            selector.type = SC_ADB_DEVICE_SELECT_SERIAL;
+            selector.serial = params->req_serial;
+        } else if (params->select_usb) {
+            selector.type = SC_ADB_DEVICE_SELECT_USB;
+        } else if (params->select_tcpip) {
+            selector.type = SC_ADB_DEVICE_SELECT_TCPIP;
+        } else {
+            // No explicit selection, check $ANDROID_SERIAL
+            const char *env_serial = getenv("ANDROID_SERIAL");
+            if (env_serial) {
+                LOGI("Using ANDROID_SERIAL: %s", env_serial);
+                selector.type = SC_ADB_DEVICE_SELECT_SERIAL;
+                selector.serial = env_serial;
+            } else {
+                selector.type = SC_ADB_DEVICE_SELECT_ALL;
+            }
+        }
+        struct sc_adb_device device;
+        ok = sc_adb_select_device(&server->intr, &selector, 0, &device);
+        if (!ok) {
+            goto error_connection_failed;
         }
 
         if (params->tcpip) {
-        // params->serial may be changed after this call
-        bool ok = sc_server_configure_tcpip(server);
+            assert(!params->tcpip_dst);
+            ok = sc_server_configure_tcpip_unknown_address(server,
+                                                           device.serial);
+            sc_adb_device_destroy(&device);
+            if (!ok) {
+                goto error_connection_failed;
+            }
+            assert(server->serial);
+        } else {
+            // "move" the device.serial without copy
+            server->serial = device.serial;
+            // the serial must not be freed by the destructor
+            device.serial = NULL;
+            sc_adb_device_destroy(&device);
+        }
+    } else {
+        ok = sc_server_configure_tcpip_known_address(server, params->tcpip_dst);
         if (!ok) {
             goto error_connection_failed;
         }
     }
 
-    // It is ok to call this function even if the device serial has been
-    // changed by switching over TCP/IP
-    if (!sc_server_fill_serial(server)) {
-        goto error_connection_failed;
-    }
+    const char *serial = server->serial;
+    assert(serial);
+    LOGD("Device serial: %s", serial);
 
-    bool ok = push_server(&server->intr, params->serial);
+    ok = push_server(&server->intr, serial);
     if (!ok) {
         goto error_connection_failed;
     }
 
-    ok = sc_adb_tunnel_open(&server->tunnel, &server->intr, params->serial,
-                            params->port_range, params->force_adb_forward);
+    // If --list-* is passed, then the server just prints the requested data
+    // then exits.
+    if (params->list_encoders || params->list_displays) {
+        sc_pid pid = execute_server(server, params);
+        if (pid == SC_PROCESS_NONE) {
+            goto error_connection_failed;
+        }
+        sc_process_wait(pid, NULL); // ignore exit code
+        sc_process_close(pid);
+        // Wake up await_for_server()
+        server->cbs->on_connected(server, server->cbs_userdata);
+        return 0;
+    }
+
+    int r = asprintf(&server->device_socket_name, SC_SOCKET_NAME_PREFIX "%08x",
+                     params->scid);
+    if (r == -1) {
+        LOG_OOM();
+        goto error_connection_failed;
+    }
+    assert(r == sizeof(SC_SOCKET_NAME_PREFIX) - 1 + 8);
+    assert(server->device_socket_name);
+
+    ok = sc_adb_tunnel_open(&server->tunnel, &server->intr, serial,
+                            server->device_socket_name, params->port_range,
+                            params->force_adb_forward);
     if (!ok) {
         goto error_connection_failed;
     }
@@ -727,7 +926,8 @@ run_server(void *data) {
     // server will connect to our server socket
     sc_pid pid = execute_server(server, params);
     if (pid == SC_PROCESS_NONE) {
-        sc_adb_tunnel_close(&server->tunnel, &server->intr, params->serial);
+        sc_adb_tunnel_close(&server->tunnel, &server->intr, serial,
+                            server->device_socket_name);
         goto error_connection_failed;
     }
 
@@ -739,7 +939,8 @@ run_server(void *data) {
     if (!ok) {
         sc_process_terminate(pid);
         sc_process_wait(pid, true); // ignore exit code
-        sc_adb_tunnel_close(&server->tunnel, &server->intr, params->serial);
+        sc_adb_tunnel_close(&server->tunnel, &server->intr, serial,
+                            server->device_socket_name);
         goto error_connection_failed;
     }
 
@@ -764,14 +965,20 @@ run_server(void *data) {
     sc_mutex_unlock(&server->mutex);
 
     // Interrupt sockets to wake up socket blocking calls on the server
-    assert(server->video_socket != SC_SOCKET_NONE);
+
+    if (server->video_socket != SC_SOCKET_NONE) {
+        // There is no video_socket if --no-video is set
         net_interrupt(server->video_socket);
-    net_close(server->video_socket);
+    }
+
+    if (server->audio_socket != SC_SOCKET_NONE) {
+        // There is no audio_socket if --no-audio is set
+        net_interrupt(server->audio_socket);
+    }
 
     if (server->control_socket != SC_SOCKET_NONE) {
         // There is no control_socket if --no-control is set
         net_interrupt(server->control_socket);
-        net_close(server->control_socket);
     }
 
     // Give some delay for the server to terminate properly
@@ -795,9 +1002,12 @@ run_server(void *data) {
 
     sc_process_close(pid);
 
+    sc_server_kill_adb_if_requested(server);
+
     return 0;
 
 error_connection_failed:
+    sc_server_kill_adb_if_requested(server);
     server->cbs->on_connection_failed(server, server->cbs_userdata);
     return -1;
 }
@@ -821,12 +1031,27 @@ sc_server_stop(struct sc_server *server) {
     sc_cond_signal(&server->cond_stopped);
     sc_intr_interrupt(&server->intr);
     sc_mutex_unlock(&server->mutex);
+}
 
+void
+sc_server_join(struct sc_server *server) {
     sc_thread_join(&server->thread, NULL);
 }
 
 void
 sc_server_destroy(struct sc_server *server) {
+    if (server->video_socket != SC_SOCKET_NONE) {
+        net_close(server->video_socket);
+    }
+    if (server->audio_socket != SC_SOCKET_NONE) {
+        net_close(server->audio_socket);
+    }
+    if (server->control_socket != SC_SOCKET_NONE) {
+        net_close(server->control_socket);
+    }
+
+    free(server->serial);
+    free(server->device_socket_name);
     sc_server_params_destroy(&server->params);
     sc_intr_destroy(&server->intr);
     sc_cond_destroy(&server->cond_stopped);