Add support for AV1

Add option --codec=av1. PR #3713 <https://github.com/Genymobile/scrcpy/pull/3713>
Add support for H265
2023-02-06 11:00:49 +01:00 · 2023-02-06 11:00:49 +01:00 · 2023-02-06 10:58:45 +01:00 · 2023-02-03 12:31:28 +01:00 · 2023-02-03 12:31:28 +01:00 · 2023-02-03 12:31:28 +01:00
74 changed files with 1148 additions and 9438 deletions
--- a/BUILD.md
+++ b/BUILD.md
@ -260,7 +260,7 @@ set ANDROID_SDK_ROOT=%LOCALAPPDATA%\Android\sdk
 Then, build:
 ```bash
-meson x --buildtype=release --strip -Db_lto=true
+meson setup x --buildtype=release --strip -Db_lto=true
 ninja -Cx  # DO NOT RUN AS ROOT
 ```
@ -272,16 +272,16 @@ install` must be run as root)._
 #### Option 2: Use prebuilt server
- - [`scrcpy-server-v1.24`][direct-scrcpy-server]  
+ - [`scrcpy-server-v1.25`][direct-scrcpy-server]  
-   <sub>SHA-256: `ae74a81ea79c0dc7250e586627c278c0a9a8c5de46c9fb5c38c167fb1a36f056`</sub>
+   <sub>SHA-256: `ce0306c7bbd06ae72f6d06f7ec0ee33774995a65de71e0a83813ecb67aec9bdb`</sub>
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-server-v1.24
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.25/scrcpy-server-v1.25
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
 ```bash
-meson x --buildtype=release --strip -Db_lto=true \
+meson setup x --buildtype=release --strip -Db_lto=true \
    -Dprebuilt_server=/path/to/scrcpy-server
 ninja -Cx  # DO NOT RUN AS ROOT
 ```
--- a/DEVELOP.md
+++ b/DEVELOP.md
@ -277,7 +277,7 @@ The server is pushed to the device by the client on startup.
 To debug it, enable the server debugger during configuration:
 ```bash
-meson x -Dserver_debugger=true
+meson setup x -Dserver_debugger=true
 # or, if x is already configured
 meson configure x -Dserver_debugger=true
 ```
@ -286,7 +286,7 @@ If your device runs Android 8 or below, set the `server_debugger_method` to
 `old` in addition:
 ```bash
-meson x -Dserver_debugger=true -Dserver_debugger_method=old
+meson setup x -Dserver_debugger=true -Dserver_debugger_method=old
 # or, if x is already configured
 meson configure x -Dserver_debugger=true -Dserver_debugger_method=old
 ```
--- a/FAQ.it.md
+++ b/FAQ.it.md
@ -1,235 +0,0 @@
 _Apri le [FAQ](FAQ.md) originali e sempre aggiornate._
 # Domande Frequenti (FAQ)
 Questi sono i problemi più comuni riportati e i loro stati.
 ## Problemi di `adb`
 `scrcpy` esegue comandi `adb` per inizializzare la connessione con il dispositivo. Se `adb` fallisce, scrcpy non funzionerà.
 In questo caso sarà stampato questo errore:
 >     ERROR: "adb push" returned with value 1
 Questo solitamente non è un bug di _scrcpy_, ma un problema del tuo ambiente.
 Per trovare la causa, esegui:
 ```bash
 adb devices
 ```
 ### `adb` not found (`adb` non trovato)
 È necessario che `adb` sia accessibile dal tuo `PATH`.
 In Windows, la cartella corrente è nel tuo `PATH` e `adb.exe` è incluso nella release, perciò dovrebbe già essere pronto all'uso.
 ### Device unauthorized (Dispositivo non autorizzato)
 Controlla [stackoverflow][device-unauthorized] (in inglese).
 [device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
 ### Device not detected (Dispositivo non rilevato)
 >     adb: error: failed to get feature set: no devices/emulators found
 Controlla di aver abilitato correttamente il [debug con adb][enable-adb] (link in inglese).
 Se il tuo dispositivo non è rilevato, potresti avere bisogno dei [driver][drivers] (link in inglese) (in Windows).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
 ### Più dispositivi connessi
 Se più dispositivi sono connessi, riscontrerai questo errore:
 >     adb: error: failed to get feature set: more than one device/emulator
 l'identificatore del tuo dispositivo deve essere fornito:
 ```bash
 scrcpy -s 01234567890abcdef
 ```
 Notare che se il tuo dispositivo è connesso mediante TCP/IP, riscontrerai questo messaggio:
 >     adb: error: more than one device/emulator
 >     ERROR: "adb reverse" returned with value 1
 >     WARN: 'adb reverse' failed, fallback to 'adb forward'
 Questo è un problema atteso (a causa di un bug di una vecchia versione di Android, vedi [#5] (link in inglese)), ma in quel caso scrcpy ripiega su un metodo differente, il quale dovrebbe funzionare.
 [#5]: https://github.com/Genymobile/scrcpy/issues/5
 ### Conflitti tra versioni di adb
 >     adb server version (41) doesn't match this client (39); killing...
 L'errore compare quando usi più versioni di `adb` simultaneamente. Devi trovare il programma che sta utilizzando una versione differente di `adb` e utilizzare la stessa versione dappertutto.
 Puoi sovrascrivere i binari di `adb` nell'altro programma, oppure chiedere a _scrcpy_ di usare un binario specifico di `adb`, impostando la variabile d'ambiente `ADB`:
 ```bash
 set ADB=/path/to/your/adb
 scrcpy
 ```
 ### Device disconnected (Dispositivo disconnesso)
 Se _scrcpy_ si interrompe con l'avviso "Device disconnected", allora la connessione `adb` è stata chiusa.
 Prova con un altro cavo USB o inseriscilo in un'altra porta USB. Vedi [#281] (in inglese) e [#283] (in inglese).
 [#281]: https://github.com/Genymobile/scrcpy/issues/281
 [#283]: https://github.com/Genymobile/scrcpy/issues/283
 ## Problemi di controllo
 ### Mouse e tastiera non funzionano
 Su alcuni dispositivi potresti dover abilitare un opzione che permette l'[input simulato][simulating input] (link in inglese). Nelle opzioni sviluppatore, abilita:
 > **Debug USB (Impostazioni di sicurezza)**
 > _Permetti la concessione dei permessi e la simulazione degli input mediante il debug USB_
 <!--- Ho tradotto personalmente il testo sopra, non conosco esattamente il testo reale --->
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ### I caratteri speciali non funzionano
 Iniettare del testo in input è [limitato ai caratteri ASCII][text-input] (link in inglese). Un trucco permette di iniettare dei [caratteri accentati][accented-characters] (link in inglese), ma questo è tutto. Vedi [#37] (link in inglese).
 [text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
 [accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
 [#37]: https://github.com/Genymobile/scrcpy/issues/37
 ## Problemi del client
 ### La qualità è bassa
 Se la definizione della finestra del tuo client è minore di quella del tuo dispositivo, allora potresti avere una bassa qualità di visualizzazione, specialmente individuabile nei testi (vedi [#40] (link in inglese)).
 [#40]: https://github.com/Genymobile/scrcpy/issues/40
 Per migliorare la qualità di ridimensionamento (downscaling), il filtro trilineare è applicato automaticamente se il renderizzatore è OpenGL e se supporta la creazione di mipmap.
 In Windows, potresti voler forzare OpenGL:
 ```
 scrcpy --render-driver=opengl
 ```
 Potresti anche dover configurare il [comportamento di ridimensionamento][scaling behavior] (link in inglese):
 > `scrcpy.exe` > Propietà > Compatibilità > Modifica impostazioni DPI elevati > Esegui l'override del comportamento di ridimensionamento DPI elevati >  Ridimensionamento eseguito per:  _Applicazione_.
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 ### Problema con Wayland
 Per impostazione predefinita, SDL utilizza x11 su Linux. Il [video driver] può essere cambiato attraversio la variabile d'ambiente `SDL_VIDEODRIVER`:
 [video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
 ```bash
 export SDL_VIDEODRIVER=wayland
 scrcpy
 ```
 Su alcune distribuzioni (almeno Fedora), il pacchetto `libdecor` deve essere installato manualmente.
 Vedi le issues [#2554] e [#2559].
 [#2554]: https://github.com/Genymobile/scrcpy/issues/2554
 [#2559]: https://github.com/Genymobile/scrcpy/issues/2559
 ### Crash del compositore KWin
 In Plasma Desktop, il compositore è disabilitato mentre _scrcpy_ è in esecuzione.
 Come soluzione alternativa, [disattiva la "composizione dei blocchi"][kwin] (link in inglese).
 <!--- Non sono sicuro di aver tradotto correttamente la stringa di testo del pulsante --->
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
 ## Crash
 ### Eccezione
 Ci potrebbero essere molte ragioni. Una causa comune è che il codificatore hardware del tuo dispositivo non riesce a codificare alla definizione selezionata:
 > ```
 > ERROR: Exception on thread Thread[main,5,main]
 > android.media.MediaCodec$CodecException: Error 0xfffffc0e
 > ...
 > Exit due to uncaughtException in main thread:
 > ERROR: Could not open video stream
 > INFO: Initial texture: 1080x2336
 > ```
 o
 > ```
 > ERROR: Exception on thread Thread[main,5,main]
 > java.lang.IllegalStateException
 >         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
 > ```
 Prova con una definizione inferiore:
 ```
 scrcpy -m 1920
 scrcpy -m 1024
 scrcpy -m 800
 ```
 Potresti anche provare un altro [codificatore](README.it.md#codificatore).
 ## Linea di comando in Windows
 Alcuni utenti Windows non sono familiari con la riga di comando. Qui è descritto come aprire un terminale ed eseguire `scrcpy` con gli argomenti:
 1. Premi <kbd>Windows</kbd>+<kbd>r</kbd>, questo apre una finestra di dialogo.
 2. Scrivi `cmd` e premi <kbd>Enter</kbd>, questo apre un terminale.
 3. Vai nella tua cartella di _scrcpy_ scrivendo (adatta il percorso):
    ```bat
    cd C:\Users\user\Downloads\scrcpy-win64-xxx
    ```
    e premi <kbd>Enter</kbd>
 4. Scrivi il tuo comando. Per esempio:
    ```bat
    scrcpy --record file.mkv
    ```
 Se pianifichi di utilizzare sempre gli stessi argomenti, crea un file `myscrcpy.bat` (abilita mostra [estensioni nomi file][show file extensions] per evitare di far confusione) contenente il tuo comando nella cartella di `scrcpy`. Per esempio:
 ```bat
 scrcpy --prefer-text --turn-screen-off --stay-awake
 ```
 Poi fai doppio click su quel file.
 Potresti anche modificare (una copia di) `scrcpy-console.bat` o `scrcpy-noconsole.vbs` per aggiungere alcuni argomenti.
 [show file extensions]: https://www.techpedia.it/14-windows/windows-10/171-visualizzare-le-estensioni-nomi-file-con-windows-10
--- a/FAQ.ko.md
+++ b/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
 ```
--- a/FAQ.md
+++ b/FAQ.md
@ -60,10 +60,10 @@ If it does not open, check [stackoverflow][device-unauthorized].
 If several devices are connected, you will encounter this error:
-ERROR: Multiple (2) ADB devices:
+>     ERROR: Multiple (2) ADB devices:
-ERROR:     -->   (usb)  0123456789abcdef                device  Nexus_5
+>     ERROR:     -->   (usb)  0123456789abcdef                device  Nexus_5
-ERROR:     --> (tcpip)  192.168.1.5:5555                device  GM1913
+>     ERROR:     --> (tcpip)  192.168.1.5:5555                device  GM1913
-ERROR: Select a device via -s (--serial), -d (--select-usb) or -e (--select-tcpip)
+>     ERROR: Select a device via -s (--serial), -d (--select-usb) or -e (--select-tcpip)
 In that case, you can either provide the identifier of the device you want to
 mirror:
@ -103,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
 ```
@ -311,8 +324,8 @@ to add some arguments.
 ## 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)
+[wiki]: https://github.com/Genymobile/scrcpy/wiki
- - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md)
+
- - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.22](FAQ.zh-Hans.md)
+Only this README file is guaranteed to be up-to-date.
--- a/FAQ.zh-Hans.md
+++ b/FAQ.zh-Hans.md
@ -1,284 +0,0 @@
 _Only the original [FAQ.md](FAQ.md) is guaranteed to be up-to-date._
 _只有原版的 [FAQ.md](FAQ.md)是保证最新的。_
 Current version is based on [28054cd]
 本文根据[28054cd]进行翻译。
 [28054cd]: https://github.com/Genymobile/scrcpy/blob/28054cd471f848733e11372c9d745cd5d71e6ce7/FAQ.md
 # 常见问题
 这里是一些常见的问题以及他们的状态。
 ## `adb` 相关问题
 `scrcpy` 执行 `adb` 命令来初始化和设备之间的连接。如果 `adb` 执行失败了， scrcpy 就无法工作。
 在这种情况中，将会输出这个错误:
 >     ERROR: "adb get-serialno" returned with value 1
 这通常不是 _scrcpy_ 的bug，而是你的环境的问题。
 要找出原因，请执行以下操作：
 ```bash
 adb devices
 ```
 ### 找不到`adb`
 你的`PATH`中需要能访问到`adb`。
 在Windows上，当前目录会包含在`PATH`中，并且`adb.exe`也包含在发行版中，因此它应该是开箱即用（直接解压就可以）的。
 ### 设备未授权
 >     error: device unauthorized.
 >     This adb server's $ADB_VENDOR_KEYS is not set
 >     Try 'adb kill-server' if that seems wrong.
 >     Otherwise check for a confirmation dialog on your device.
 连接时，在设备上应该会打开一个弹出窗口。 您必须授权 USB 调试。
 如果没有打开，参见[stackoverflow][device-unauthorized].
 [device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
 ### 未检测到设备
 >     error: no devices/emulators found
 确认已经正确启用 [adb debugging][enable-adb].
 如果你的设备没有被检测到，你可能需要一些[驱动][drivers] (在 Windows上)。这里有一个单独的 [适用于Google设备的USB驱动][google-usb-driver].
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
 [google-usb-driver]: https://developer.android.com/studio/run/win-usb
 ### 已连接多个设备
 如果连接了多个设备，您将遇到以下错误：
 >     error: more than one device/emulator
 必须提供要镜像的设备的标识符：
 ```bash
 scrcpy -s 01234567890abcdef
 ```
 注意，如果你的设备是通过 TCP/IP 连接的， 你将会收到以下消息：
 >     adb: error: more than one device/emulator
 >     ERROR: "adb reverse" returned with value 1
 >     WARN: 'adb reverse' failed, fallback to 'adb forward'
 这是意料之中的 (由于旧版安卓的一个bug, 请参见 [#5])，但是在这种情况下，scrcpy会退回到另一种方法，这种方法应该可以起作用。
 [#5]: https://github.com/Genymobile/scrcpy/issues/5
 ### adb版本之间冲突
 >     adb server version (41) doesn't match this client (39); killing...
 同时使用多个版本的`adb`时会发生此错误。你必须查找使用不同`adb`版本的程序，并在所有地方使用相同版本的`adb`。
 你可以覆盖另一个程序中的`adb`二进制文件，或者通过设置`ADB`环境变量来让 _scrcpy_ 使用特定的`adb`二进制文件。
 ```bash
 set ADB=/path/to/your/adb
 scrcpy
 ```
 ### 设备断开连接
 如果 _scrcpy_ 在警告“设备连接断开”的情况下自动中止，那就意味着`adb`连接已经断开了。
 请尝试使用另一条USB线或者电脑上的另一个USB接口。请参看 [#281] 和 [#283]。
 [#281]: https://github.com/Genymobile/scrcpy/issues/281
 [#283]: https://github.com/Genymobile/scrcpy/issues/283
 ## 控制相关问题
 ### 鼠标和键盘不起作用
 在某些设备上，您可能需要启用一个选项以允许 [模拟输入][simulating input]。
 在开发者选项中，打开：
 > **USB调试 (安全设置)**  
 > _允许通过USB调试修改权限或模拟点击_
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ### 特殊字符不起作用
 可输入的文本[被限制为ASCII字符][text-input]。也可以用一些小技巧输入一些[带重音符号的字符][accented-characters]，但是仅此而已。参见[#37]。
 自 Linux 上的 scrcpy v1.20 之后，可以模拟[物理键盘][hid] (HID)。
 [text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
 [accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
 [#37]: https://github.com/Genymobile/scrcpy/issues/37
 [hid]: README.md#physical-keyboard-simulation-hid
 ## 客户端相关问题
 ### 效果很差
 如果你的客户端窗口分辨率比你的设备屏幕小，则可能出现效果差的问题，尤其是在文本上（参见 [#40]）。
 [#40]: https://github.com/Genymobile/scrcpy/issues/40
 为了提升降尺度的质量，如果渲染器是OpenGL并且支持mip映射，就会自动开启三线性过滤。
 在Windows上，你可能希望强制使用OpenGL：
 ```
 scrcpy --render-driver=opengl
 ```
 你可能还需要配置[缩放行为][scaling behavior]：
 > `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
 > Override high DPI scaling behavior > Scaling performed by: _Application_.
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 ### Wayland相关的问题
 在Linux上，SDL默认使用x11。可以通过`SDL_VIDEODRIVER`环境变量来更改[视频驱动][video driver]：
 [video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
 ```bash
 export SDL_VIDEODRIVER=wayland
 scrcpy
 ```
 在一些发行版上 (至少包括 Fedora)， `libdecor` 包必须手动安装。
 参见 [#2554] 和 [#2559]。
 [#2554]: https://github.com/Genymobile/scrcpy/issues/2554
 [#2559]: https://github.com/Genymobile/scrcpy/issues/2559
 ### KWin compositor 崩溃
 在Plasma桌面中，当 _scrcpy_ 运行时，会禁用compositor。
 一种解决方法是， [禁用 "Block compositing"][kwin].
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
 ## 崩溃
 ### 异常
 可能有很多原因。一个常见的原因是您的设备无法按给定清晰度进行编码：
 > ```
 > ERROR: Exception on thread Thread[main,5,main]
 > android.media.MediaCodec$CodecException: Error 0xfffffc0e
 > ...
 > Exit due to uncaughtException in main thread:
 > ERROR: Could not open video stream
 > INFO: Initial texture: 1080x2336
 > ```
 或者
 > ```
 > ERROR: Exception on thread Thread[main,5,main]
 > java.lang.IllegalStateException
 >         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
 > ```
 请尝试使用更低的清晰度：
 ```
 scrcpy -m 1920
 scrcpy -m 1024
 scrcpy -m 800
 ```
 自 scrcpy v1.22以来，scrcpy 会自动在失败前以更低的分辨率重试。这种行为可以用`--no-downsize-on-error`关闭。
 你也可以尝试另一种 [编码器](README.md#encoder)。
 如果您在 Android 12 上遇到此异常，则只需升级到 scrcpy >= 1.18 (见 [#2129])：
 ```
 > ERROR: Exception on thread Thread[main,5,main]
 java.lang.AssertionError: java.lang.reflect.InvocationTargetException
    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:75)
    ...
 Caused by: java.lang.reflect.InvocationTargetException
    at java.lang.reflect.Method.invoke(Native Method)
    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:73)
    ... 7 more
 Caused by: java.lang.IllegalArgumentException: displayToken must not be null
    at android.view.SurfaceControl$Transaction.setDisplaySurface(SurfaceControl.java:3067)
    at android.view.SurfaceControl.setDisplaySurface(SurfaceControl.java:2147)
    ... 9 more
 ```
 [#2129]: https://github.com/Genymobile/scrcpy/issues/2129
 ## Windows命令行
 从 v1.22 开始，增加了一个“快捷方式”，可以直接在 scrcpy 目录打开一个终端。双击`open_a_terminal_here.bat`，然后输入你的命令。 例如：
 ```
 scrcpy --record file.mkv
 ```
 您也可以打开终端并手动转到 scrcpy 文件夹：
 1. 按下 <kbd>Windows</kbd>+<kbd>r</kbd>，打开一个对话框。
 2. 输入 `cmd` 并按 <kbd>Enter</kbd>，这样就打开了一个终端。
 3. 通过输入以下命令，切换到你的 _scrcpy_ 所在的目录 （根据你的实际位置修改路径）:
    ```bat
    cd C:\Users\user\Downloads\scrcpy-win64-xxx
    ```
    然后按 <kbd>Enter</kbd>
 4. 输入你的命令。比如:
    ```bat
    scrcpy --record file.mkv
    ```
 如果你打算总是使用相同的参数，在`scrcpy`目录创建一个文件 `myscrcpy.bat`
 （启用 [显示文件拓展名][show file extensions] 避免混淆），文件中包含你的命令。例如：
 ```bat
 scrcpy --prefer-text --turn-screen-off --stay-awake
 ```
 然后只需双击刚刚创建的文件。
 你也可以编辑 `scrcpy-console.bat` 或者 `scrcpy-noconsole.vbs`（的副本）来添加参数。
 [show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/
--- a/README.de.md
+++ b/README.de.md
--- a/README.id.md
+++ b/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-2022 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## 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/
--- a/README.it.md
+++ b/README.it.md
--- a/README.jp.md
+++ b/README.jp.md
@ -1,799 +0,0 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._
 # scrcpy (v1.19)
 このアプリケーションはUSB(もしくは[TCP/IP経由][article-tcpip])で接続されたAndroidデバイスの表示と制御を提供します。このアプリケーションは _root_ でのアクセスを必要としません。このアプリケーションは _GNU/Linux_ 、 _Windows_ そして _macOS_ 上で動作します。
 ![screenshot](assets/screenshot-debian-600.jpg)
 以下に焦点を当てています:
 - **軽量** (ネイティブ、デバイス画面表示のみ)
 - **パフォーマンス**　(30~60fps)
 - **クオリティ**　(1920x1080以上)
 - **低遅延**　([35~70ms][lowlatency])
 - **短い起動時間**　(初回画像を1秒以内に表示)
 - **非侵入型**　(デバイスに何もインストールされていない状態になる)
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 ## 必要要件
 AndroidデバイスはAPI21(Android 5.0)以上。
 Androidデバイスで[adbデバッグが有効][enable-adb]であること。
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 一部のAndroidデバイスでは、キーボードとマウスを使用して制御する[追加オプション][control]を有効にする必要がある。
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ## アプリの取得
 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
 ### Linux
 Debian (_testing_ と _sid_) とUbuntu(20.04):
 ```
 apt install scrcpy
 ```
 [Snap]パッケージが利用可能: [`scrcpy`][snap-link]
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
 Fedora用[COPR]パッケージが利用可能: [`scrcpy`][copr-link]
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 Arch Linux用[AUR]パッケージが利用可能: [`scrcpy`][aur-link]
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 [aur-link]: https://aur.archlinux.org/packages/scrcpy/
 Gentoo用[Ebuild]が利用可能: [`scrcpy`][ebuild-link]
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 [自分でビルド][BUILD]も可能（心配しないでください、それほど難しくはありません。）
 ### Windows
 Windowsでは簡単に、（`adb`を含む）すべての依存関係を構築済みのアーカイブを利用可能です。
 - [README](README.md#windows)
 [Chocolatey]でも利用可能です:
 [Chocolatey]: https://chocolatey.org/
 ```bash
 choco install scrcpy
 choco install adb    # まだ入手していない場合
 ```
 [Scoop]でも利用可能です:
 ```bash
 scoop install scrcpy
 scoop install adb    # まだ入手していない場合
 ```
 [Scoop]: https://scoop.sh
 また、[アプリケーションをビルド][BUILD]することも可能です。
 ### macOS
 アプリケーションは[Homebrew]で利用可能です。ただインストールするだけです。
 [Homebrew]: https://brew.sh/
 ```bash
 brew install scrcpy
 ```
 `PATH`からアクセス可能な`adb`が必要です。もし持っていない場合はインストールしてください。
 ```bash
 brew install android-platform-tools
 ```
 `adb`は[MacPorts]からでもインストールできます。
 ```bash
 sudo port install scrcpy
 ```
 [MacPorts]: https://www.macports.org/
 また、[アプリケーションをビルド][BUILD]することも可能です。
 ## 実行
 Androidデバイスを接続し、実行:
 ```bash
 scrcpy
 ```
 次のコマンドでリストされるコマンドライン引数も受け付けます:
 ```bash
 scrcpy --help
 ```
 ## 機能
 ### キャプチャ構成
 #### サイズ削減
 Androidデバイスを低解像度でミラーリングする場合、パフォーマンス向上に便利な場合があります。
 幅と高さをある値(例：1024)に制限するには:
 ```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # 短縮版
 ```
 一方のサイズはデバイスのアスペクト比が維持されるように計算されます。この方法では、1920x1080のデバイスでは1024x576にミラーリングされます。
 #### ビットレート変更
 ビットレートの初期値は8Mbpsです。ビットレートを変更するには(例:2Mbpsに変更):
 ```bash
 scrcpy --bit-rate 2M
 scrcpy -b 2M  # 短縮版
 ```
 #### フレームレート制限
 キャプチャするフレームレートを制限できます:
 ```bash
 scrcpy --max-fps 15
 ```
 この機能はAndroid 10からオフィシャルサポートとなっていますが、以前のバージョンでも動作する可能性があります。
 #### トリミング
 デバイスの画面は、画面の一部のみをミラーリングするようにトリミングできます。
 これは、例えばOculus Goの片方の目をミラーリングする場合に便利です。:
 ```bash
 scrcpy --crop 1224:1440:0:0   # オフセット位置(0,0)で1224x1440
 ```
 もし`--max-size`も指定されている場合、トリミング後にサイズ変更が適用されます。
 #### ビデオの向きをロックする
 ミラーリングの向きをロックするには:
 ```bash
 scrcpy --lock-video-orientation     # 現在の向き
 scrcpy --lock-video-orientation=0   # 自然な向き
 scrcpy --lock-video-orientation=1   # 90°反時計回り
 scrcpy --lock-video-orientation=2   # 180°
 scrcpy --lock-video-orientation=3   # 90°時計回り
 ```
 この設定は録画の向きに影響します。
 [ウィンドウは独立して回転することもできます](#回転)。
 #### エンコーダ
 いくつかのデバイスでは一つ以上のエンコーダを持ちます。それらのいくつかは、問題やクラッシュを引き起こします。別のエンコーダを選択することが可能です:
 ```bash
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```
 利用可能なエンコーダをリストするために、無効なエンコーダ名を渡すことができます。エラー表示で利用可能なエンコーダを提供します。
 ```bash
 scrcpy --encoder _
 ```
 ### キャプチャ
 #### 録画
 ミラーリング中に画面の録画をすることが可能です:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 録画中にミラーリングを無効にするには:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # Ctrl+Cで録画を中断する
 ```
 "スキップされたフレーム"は(パフォーマンス上の理由で)リアルタイムで表示されなくても録画されます。
 フレームはデバイス上で _タイムスタンプされる_ ため [パケット遅延のバリエーション] は録画されたファイルに影響を与えません。
 [パケット遅延のバリエーション]: https://en.wikipedia.org/wiki/Packet_delay_variation
 #### v4l2loopback
 Linuxでは、ビデオストリームをv4l2ループバックデバイスに送信することができます。
 v4l2loopbackのデバイスにビデオストリームを送信することで、Androidデバイスをウェブカメラのようにv4l2対応ツールで開くこともできます。
 `v4l2loopback` モジュールのインストールが必要です。
 ```bash
 sudo apt install v4l2loopback-dkms
 ```
 v4l2デバイスを作成する。
 ```bash
 sudo modprobe v4l2loopback
 ```
 これにより、新しいビデオデバイスが `/dev/videoN` に作成されます。（`N` は整数）
 (複数のデバイスや特定のIDのデバイスを作成するために、より多くの[オプション](https://github.com/umlaeute/v4l2loopback#options)が利用可能です。
 多くの[オプション]()が利用可能で複数のデバイスや特定のIDのデバイスを作成できます。
 有効なデバイスを一覧表示する:
 ```bash
 # v4l-utilsパッケージが必要
 v4l2-ctl --list-devices
 # シンプルですが十分これで確認できます
 ls /dev/video*
 ```
 v4l2シンクを使用してscrcpyを起動する。
 ```bash
 scrcpy --v4l2-sink=/dev/videoN
 scrcpy --v4l2-sink=/dev/videoN --no-display  # ミラーリングウィンドウを無効化する
 scrcpy --v4l2-sink=/dev/videoN -N            # 短縮版
 ```
 (`N` をデバイス ID に置き換えて、`ls /dev/video*` で確認してください)
 有効にすると、v4l2対応のツールでビデオストリームを開けます。
 ```bash
 ffplay -i /dev/videoN
 vlc v4l2:///dev/videoN   # VLCではバッファリングの遅延が発生する場合があります
 ```
 例えばですが [OBS]の中にこの映像を取り込めことができます。
 [OBS]: https://obsproject.com/
 #### Buffering
 バッファリングを追加することも可能です。これによりレイテンシーは増加しますが、ジッターは減少します。（参照
 [#2464])
 [#2464]: https://github.com/Genymobile/scrcpy/issues/2464
 このオプションでディスプレイバッファリングを設定できます。
 ```bash
 scrcpy --display-buffer=50  # ディスプレイに50msのバッファリングを追加する
 ```
 V4L2の場合はこちらのオプションで設定できます。
 ```bash
 scrcpy --v4l2-buffer=500    # add 500 ms buffering for v4l2 sink
 ```
 ### 接続
 #### ワイヤレス
 _Scrcpy_ はデバイスとの通信に`adb`を使用します。そして`adb`はTCP/IPを介しデバイスに[接続]することができます:
 1. あなたのコンピュータと同じWi-Fiに接続します。
 2. あなたのIPアドレスを取得します。設定 → 端末情報 → ステータス情報、もしくは、このコマンドを実行します:
    ```bash
    adb shell ip route | awk '{print $9}'
    ```
 3. あなたのデバイスでTCP/IPを介したadbを有効にします: `adb tcpip 5555`
 4. あなたのデバイスの接続を外します。
 5. あなたのデバイスに接続します:
 `adb connect DEVICE_IP:5555` _(`DEVICE_IP`は置き換える)_
 6. 通常通り`scrcpy`を実行します。
 この方法はビットレートと解像度を減らすのにおそらく有用です:
 ```bash
 scrcpy --bit-rate 2M --max-size 800
 scrcpy -b2M -m800  # 短縮版
 ```
 [接続]: https://developer.android.com/studio/command-line/adb.html#wireless
 #### マルチデバイス
 もし`adb devices`でいくつかのデバイスがリストされる場合、 _シリアルナンバー_ を指定する必要があります:
 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # 短縮版
 ```
 デバイスがTCP/IPを介して接続されている場合:
 ```bash
 scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # 短縮版
 ```
 複数のデバイスに対して、複数の _scrcpy_ インスタンスを開始することができます。
 #### デバイス接続での自動起動
 [AutoAdb]を使用可能です:
 ```bash
 autoadb scrcpy -s '{}'
 ```
 [AutoAdb]: https://github.com/rom1v/autoadb
 #### SSHトンネル
 リモートデバイスに接続するため、ローカル`adb`クライアントからリモート`adb`サーバーへ接続することが可能です(同じバージョンの _adb_ プロトコルを使用している場合):
 ```bash
 adb kill-server    # 5037ポートのローカルadbサーバーを終了する
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # オープンしたままにする
 ```
 他の端末から:
 ```bash
 scrcpy
 ```
 リモートポート転送の有効化を回避するためには、代わりに転送接続を強制することができます(`-R`の代わりに`-L`を使用することに注意):
 ```bash
 adb kill-server    # 5037ポートのローカルadbサーバーを終了する
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # オープンしたままにする
 ```
 他の端末から:
 ```bash
 scrcpy --force-adb-forward
 ```
 ワイヤレス接続と同様に、クオリティを下げると便利な場合があります:
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### ウィンドウ構成
 #### タイトル
 ウィンドウのタイトルはデバイスモデルが初期値です。これは変更できます:
 ```bash
 scrcpy --window-title 'My device'
 ```
 #### 位置とサイズ
 ウィンドウの位置とサイズの初期値を指定できます:
 ```bash
 scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 ```
 #### ボーダーレス
 ウィンドウの装飾を無効化するには:
 ```bash
 scrcpy --window-borderless
 ```
 #### 常に画面のトップ
 scrcpyの画面を常にトップにするには:
 ```bash
 scrcpy --always-on-top
 ```
 #### フルスクリーン
 アプリケーションを直接フルスクリーンで開始できます:
 ```bash
 scrcpy --fullscreen
 scrcpy -f  # 短縮版
 ```
 フルスクリーンは、次のコマンドで動的に切り替えることができます <kbd>MOD</kbd>+<kbd>f</kbd>
 #### 回転
 ウィンドウは回転することができます:
 ```bash
 scrcpy --rotation 1
 ```
 設定可能な値:
 - `0`: 回転なし
 - `1`: 90° 反時計回り
 - `2`: 180°
 - `3`: 90° 時計回り
 回転は次のコマンドで動的に変更することができます。 <kbd>MOD</kbd>+<kbd>←</kbd>_(左)_ 、 <kbd>MOD</kbd>+<kbd>→</kbd>_(右)_
 _scrcpy_ は3つの回転を管理することに注意:
 - <kbd>MOD</kbd>+<kbd>r</kbd>はデバイスに縦向きと横向きの切り替えを要求する(現在実行中のアプリで要求している向きをサポートしていない場合、拒否することがある)
 - [`--lock-video-orientation`](#ビデオの向きをロックする)は、ミラーリングする向きを変更する(デバイスからPCへ送信される向き)。録画に影響します。
 - `--rotation` (もしくは<kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)は、ウィンドウのコンテンツのみを回転します。これは表示にのみに影響し、録画には影響しません。
 ### 他のミラーリングオプション
 #### Read-only　リードオンリー
 制御を無効にするには(デバイスと対話する全てのもの:入力キー、マウスイベント、ファイルのドラッグ&ドロップ):
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
 #### ディスプレイ
 いくつか利用可能なディスプレイがある場合、ミラーリングするディスプレイを選択できます:
 ```bash
 scrcpy --display 1
 ```
 ディスプレイIDのリストは次の方法で取得できます:
 ```
 adb shell dumpsys display   # search "mDisplayId=" in the output
 ```
 セカンダリディスプレイは、デバイスが少なくともAndroid 10の場合にコントロール可能です。(それ以外ではリードオンリーでミラーリングされます)
 #### 起動状態にする
 デバイス接続時、少し遅れてからデバイスのスリープを防ぐには:
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
 scrcpyが閉じられた時、初期状態に復元されます。
 #### 画面OFF
 コマンドラインオプションを使用することで、ミラーリングの開始時にデバイスの画面をOFFにすることができます:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
 もしくは、<kbd>MOD</kbd>+<kbd>o</kbd>を押すことでいつでもできます。
 元に戻すには、<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>を押します。
 Androidでは、`POWER`ボタンはいつでも画面を表示します。便宜上、`POWER`がscrcpyを介して(右クリックもしくは<kbd>MOD</kbd>+<kbd>p</kbd>を介して)送信される場合、(ベストエフォートベースで)少し遅れて、強制的に画面を非表示にします。ただし、物理的な`POWER`ボタンを押した場合は、画面は表示されます。
 このオプションはデバイスがスリープしないようにすることにも役立ちます:
 ```bash
 scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
 #### タッチを表示
 プレゼンテーションの場合(物理デバイス上で)物理的なタッチを表示すると便利な場合があります。
 Androidはこの機能を _開発者オプション_ で提供します。
 _Scrcpy_　は開始時にこの機能を有効にし、終了時に初期値を復元するオプションを提供します:
 ```bash
 scrcpy --show-touches
 scrcpy -t
 ```
 (デバイス上で指を使った) _物理的な_ タッチのみ表示されることに注意してください。
 #### スクリーンセーバー無効
 初期状態では、scrcpyはコンピュータ上でスクリーンセーバーが実行される事を妨げません。
 これを無効にするには:
 ```bash
 scrcpy --disable-screensaver
 ```
 ### 入力制御
 #### デバイス画面の回転
 <kbd>MOD</kbd>+<kbd>r</kbd>を押すことで、縦向きと横向きを切り替えます。
 フォアグラウンドのアプリケーションが要求された向きをサポートしている場合のみ回転することに注意してください。
 #### コピー-ペースト
 Androidのクリップボードが変更される度に、コンピュータのクリップボードに自動的に同期されます。
 <kbd>Ctrl</kbd>のショートカットは全てデバイスに転送されます。特に:
 - <kbd>Ctrl</kbd>+<kbd>c</kbd> 通常はコピーします
 - <kbd>Ctrl</kbd>+<kbd>x</kbd> 通常はカットします
 - <kbd>Ctrl</kbd>+<kbd>v</kbd> 通常はペーストします(コンピュータとデバイスのクリップボードが同期された後)
 通常は期待通りに動作します。
 しかしながら、実際の動作はアクティブなアプリケーションに依存します。例えば、_Termux_ は代わりに<kbd>Ctrl</kbd>+<kbd>c</kbd>でSIGINTを送信します、そして、_K-9 Mail_ は新しいメッセージを作成します。
 このようなケースでコピー、カットそしてペーストをするには(Android 7以上でのサポートのみですが):
 - <kbd>MOD</kbd>+<kbd>c</kbd> `COPY`を挿入
 - <kbd>MOD</kbd>+<kbd>x</kbd> `CUT`を挿入
 - <kbd>MOD</kbd>+<kbd>v</kbd> `PASTE`を挿入(コンピュータとデバイスのクリップボードが同期された後)
 加えて、<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>はコンピュータのクリップボードテキストにキーイベントのシーケンスとして挿入することを許可します。これはコンポーネントがテキストのペーストを許可しない場合(例えば _Termux_)に有用ですが、非ASCIIコンテンツを壊す可能性があります。
 **警告:** デバイスにコンピュータのクリップボードを(<kbd>Ctrl</kbd>+<kbd>v</kbd>または<kbd>MOD</kbd>+<kbd>v</kbd>を介して)ペーストすることは、デバイスのクリップボードにコンテンツをコピーします。結果としてどのAndoridアプリケーションもそのコンテンツを読み取ることができます。機密性の高いコンテンツ(例えばパスワードなど)をこの方法でペーストすることは避けてください。
 プログラムでデバイスのクリップボードを設定した場合、一部のデバイスは期待どおりに動作しません。`--legacy-paste`オプションは、コンピュータのクリップボードテキストをキーイベントのシーケンスとして挿入するため(<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>と同じ方法)、<kbd>Ctrl</kbd>+<kbd>v</kbd>と<kbd>MOD</kbd>+<kbd>v</kbd>の動作の変更を提供します。
 #### ピンチしてズームする
 "ピンチしてズームする"をシミュレートするには: <kbd>Ctrl</kbd>+_クリック&移動_
 より正確にするには、左クリックボタンを押している間、<kbd>Ctrl</kbd>を押したままにします。左クリックボタンを離すまで、全てのマウスの動きは、(アプリでサポートされている場合)画面の中心を基準として、コンテンツを拡大縮小および回転します。
 具体的には、scrcpyは画面の中央を反転した位置にある"バーチャルフィンガー"から追加のタッチイベントを生成します。
 #### テキストインジェクション環境設定
 テキストをタイプした時に生成される2種類の[イベント][textevents]があります:
 - _key events_　はキーを押したときと離したことを通知します。
 - _text events_　はテキストが入力されたことを通知します。
 初期状態で、文字はキーイベントで挿入されるため、キーボードはゲームで期待通りに動作します(通常はWASDキー)。
 しかし、これは[問題を引き起こす][prefertext]かもしれません。もしこのような問題が発生した場合は、この方法で回避できます:
 ```bash
 scrcpy --prefer-text
 ```
 (しかしこの方法はゲームのキーボードの動作を壊します)
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 #### キーの繰り返し
 初期状態では、キーの押しっぱなしは繰り返しのキーイベントを生成します。これらのイベントが使われない場合でも、この方法は一部のゲームでパフォーマンスの問題を引き起す可能性があります。
 繰り返しのキーイベントの転送を回避するためには:
 ```bash
 scrcpy --no-key-repeat
 ```
 #### 右クリックと真ん中クリック
 初期状態では、右クリックはバックの動作(もしくはパワーオン)を起こし、真ん中クリックではホーム画面へ戻ります。このショートカットを無効にし、代わりにデバイスへクリックを転送するには:
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### ファイルのドロップ
 #### APKのインストール
 APKをインストールするには、(`.apk`で終わる)APKファイルを _scrcpy_ の画面にドラッグ&ドロップします。
 見た目のフィードバックはありません。コンソールにログが出力されます。
 #### デバイスにファイルを送る
 デバイスの`/sdcard/Download`ディレクトリにファイルを送るには、(APKではない)ファイルを _scrcpy_ の画面にドラッグ&ドロップします。
 見た目のフィードバックはありません。コンソールにログが出力されます。
 転送先ディレクトリを起動時に変更することができます:
 ```bash
 scrcpy --push-target=/sdcard/Movies/
 ```
 ### 音声転送
 音声は _scrcpy_ では転送されません。[sndcpy]を使用します。
 [issue #14]も参照ください。
 [sndcpy]: https://github.com/rom1v/sndcpy
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## ショートカット
 次のリストでは、<kbd>MOD</kbd>でショートカット変更します。初期状態では、(left)<kbd>Alt</kbd>または(left)<kbd>Super</kbd>です。
 これは`--shortcut-mod`で変更することができます。可能なキーは`lctrl`、`rctrl`、`lalt`、 `ralt`、 `lsuper`そして`rsuper`です。例えば:
 ```bash
 # RCtrlをショートカットとして使用します
 scrcpy --shortcut-mod=rctrl
 # ショートカットにLCtrl+LAltまたはLSuperのいずれかを使用します
 scrcpy --shortcut-mod=lctrl+lalt,lsuper
 ```
 _<kbd>[Super]</kbd>は通常<kbd>Windows</kbd>もしくは<kbd>Cmd</kbd>キーです。_
 [Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
 | アクション                                   |   ショートカット
 | ------------------------------------------- |:-----------------------------
 | フルスクリーンモードへの切り替え               | <kbd>MOD</kbd>+<kbd>f</kbd>
 | ディスプレイを左に回転                        | <kbd>MOD</kbd>+<kbd>←</kbd> _(左)_
 | ディスプレイを右に回転                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(右)_
 | ウィンドウサイズを変更して1:1に変更(ピクセルパーフェクト)  | <kbd>MOD</kbd>+<kbd>g</kbd>
 | ウィンドウサイズを変更して黒い境界線を削除      | <kbd>MOD</kbd>+<kbd>w</kbd> \| _ダブルクリック¹_
 | `HOME`をクリック                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _真ん中クリック_
 | `BACK`をクリック                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _右クリック²_
 | `APP_SWITCH`をクリック                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4クリック³_
 | `MENU` (画面のアンロック)をクリック            | <kbd>MOD</kbd>+<kbd>m</kbd>
 | `VOLUME_UP`をクリック                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上)_
 | `VOLUME_DOWN`をクリック                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下)_
 | `POWER`をクリック                            | <kbd>MOD</kbd>+<kbd>p</kbd>
 | 電源オン                                     | _右クリック²_
 | デバイス画面をオフにする(ミラーリングしたまま)  | <kbd>MOD</kbd>+<kbd>o</kbd>
 | デバイス画面をオンにする                      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | デバイス画面を回転する                        | <kbd>MOD</kbd>+<kbd>r</kbd>
 | 通知パネルを展開する                          | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5ボタンクリック³_
 | 設定パネルを展開する                          | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _5ダブルクリック³_
 | 通知パネルを折りたたむ                        | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | クリップボードへのコピー³                     | <kbd>MOD</kbd>+<kbd>c</kbd>
 | クリップボードへのカット³                     | <kbd>MOD</kbd>+<kbd>x</kbd>
 | クリップボードの同期とペースト³                | <kbd>MOD</kbd>+<kbd>v</kbd>
 | コンピュータのクリップボードテキストの挿入      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | FPSカウンタ有効/無効(標準入出力上)             | <kbd>MOD</kbd>+<kbd>i</kbd>
 | ピンチしてズームする                          | <kbd>Ctrl</kbd>+_クリック&移動_
 _¹黒い境界線を削除するため、境界線上でダブルクリック_  
 _²もしスクリーンがオフの場合、右クリックでスクリーンをオンする。それ以外の場合はBackを押します._  
 _³4と5はマウスのボタンです、もしあなたのマウスにボタンがあれば使えます._  
 _⁴Android 7以上のみ._
 キーを繰り返すショートカットはキーを離して2回目を押したら実行されます。例えば「設定パネルを展開する」を実行する場合は以下のように操作する。
 1. <kbd>MOD</kbd> キーを押し、押したままにする.
 2. その後に <kbd>n</kbd>キーを2回押す.
 3. 最後に <kbd>MOD</kbd>キーを離す.
 全ての<kbd>Ctrl</kbd>+_キー_ ショートカットはデバイスに転送されます、そのためアクティブなアプリケーションによって処理されます。
 ## カスタムパス
 特定の _adb_ バイナリを使用する場合、そのパスを環境変数`ADB`で構成します:
    ADB=/path/to/adb scrcpy
 `scrcpy-server`ファイルのパスを上書きするには、`SCRCPY_SERVER_PATH`でそのパスを構成します。
 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## なぜ _scrcpy_?
 同僚が私に、[gnirehtet]のように発音できない名前を見つけるように要求しました。
 [`strcpy`]は**str**ingをコピーします。`scrcpy`は**scr**eenをコピーします。
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## ビルド方法は?
 [BUILD]を参照してください。
 [BUILD]: BUILD.md
 ## よくある質問
 [FAQ](FAQ.md)を参照してください。
 ## 開発者
 [開発者のページ]を読んでください。
 [開発者のページ]: DEVELOP.md
 ## ライセンス
    Copyright (C) 2018 Genymobile
    Copyright (C) 2018-2022 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## 記事
 - [Introducing scrcpy][article-intro]
 - [Scrcpy now works wirelessly][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.ko.md
+++ b/README.ko.md
@ -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-2022 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## 관련 글 (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/
--- a/README.md
+++ b/README.md
@ -1,4 +1,4 @@
-# scrcpy (v1.24)
+# scrcpy (v1.25)
 <img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
@ -106,10 +106,10 @@ process][BUILD_simple]).
 For Windows, a prebuilt archive with all the dependencies (including `adb`) is
 available:
- - [`scrcpy-win64-v1.24.zip`][direct-win64]  
+ - [`scrcpy-win64-v1.25.zip`][direct-win64]  
-   <sub>SHA-256: `6ccb64cba0a3e75715e85a188daeb4f306a1985f8ce123eba92ba74fc9b27367`</sub>
+   <sub>SHA-256: `db65125e9c65acd00359efb7cea9c05f63cc7ccd5833000cd243cc92f5053028`</sub>
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-win64-v1.24.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.25/scrcpy-win64-v1.25.zip
 It is also available in [Chocolatey]:
@ -186,7 +186,7 @@ increase performance.
 To limit both the width and height to some value (e.g. 1024):
 ```bash
-scrcpy --max-size 1024
+scrcpy --max-size=1024
 scrcpy -m 1024  # short version
 ```
@ -199,7 +199,7 @@ preserved. That way, a device in 1920×1080 will be mirrored at 1024×576.
 The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):
 ```bash
-scrcpy --bit-rate 2M
+scrcpy --bit-rate=2M
 scrcpy -b 2M  # short version
 ```
@ -208,7 +208,7 @@ scrcpy -b 2M  # short version
 The capture frame rate can be limited:
 ```bash
-scrcpy --max-fps 15
+scrcpy --max-fps=15
 ```
 This is officially supported since Android 10, but may work on earlier versions.
@ -229,7 +229,7 @@ The device screen may be cropped to mirror only part of the screen.
 This is useful, for example, to mirror only one eye of the Oculus Go:
 ```bash
-scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
+scrcpy --crop=1224:1440:0:0   # 1224x1440 at offset (0,0)
 ```
 If `--max-size` is also specified, resizing is applied after cropping.
@ -252,20 +252,33 @@ This affects recording orientation.
 The [window may also be rotated](#rotation) independently.
-#### Encoder
+#### Codec
-Some devices have more than one encoder, and some of them may cause issues or
+The video codec can be selected. The possible values are `h264` (default),
-crash. It is possible to select a different encoder:
+`h265` and `av1`:
 ```bash
-scrcpy --encoder OMX.qcom.video.encoder.avc
+scrcpy --codec=h264  # default
 scrcpy --codec=h265
 scrcpy --codec=av1
 ```
 ##### Encoder
 Some devices have more than one encoder for a specific codec, and some of them
 may cause issues or crash. It is possible to select a different encoder:
 ```bash
 scrcpy --encoder=OMX.qcom.video.encoder.avc
 ```
 To list the available encoders, you can pass an invalid encoder name; the
 error will give the available encoders:
 ```bash
-scrcpy --encoder _
+scrcpy --encoder=_               # for the default codec
 scrcpy --codec=h265 --encoder=_  # for a specific codec
 ```
 ### Capture
@ -275,14 +288,14 @@ scrcpy --encoder _
 It is possible to record the screen while mirroring:
 ```bash
-scrcpy --record file.mp4
+scrcpy --record=file.mp4
 scrcpy -r file.mkv
 ```
 To disable mirroring while recording:
 ```bash
-scrcpy --no-display --record file.mp4
+scrcpy --no-display --record=file.mp4
 scrcpy -Nr file.mkv
 # interrupt recording with Ctrl+C
 ```
@ -395,8 +408,8 @@ address), connect the device over USB, then run:
 scrcpy --tcpip    # without arguments
 ```
-It will automatically find the device IP address, enable TCP/IP mode, then
+It will automatically find the device IP address and adb port, enable TCP/IP
-connect to the device before starting.
+mode if necessary, then connect to the device before starting.
 ##### Manual
@ -431,7 +444,7 @@ none found, try running `adb disconnect`, and then run those two commands again.
 It may be useful to decrease the bit-rate and the resolution:
 ```bash
-scrcpy --bit-rate 2M --max-size 800
+scrcpy --bit-rate=2M --max-size=800
 scrcpy -b2M -m800  # short version
 ```
@ -443,7 +456,7 @@ scrcpy -b2M -m800  # short version
 If several devices are listed in `adb devices`, you can specify the _serial_:
 ```bash
-scrcpy --serial 0123456789abcdef
+scrcpy --serial=0123456789abcdef
 scrcpy -s 0123456789abcdef  # short version
 ```
@ -453,7 +466,7 @@ The serial may also be provided via the environment variable `ANDROID_SERIAL`
 If the device is connected over TCP/IP:
 ```bash
-scrcpy --serial 192.168.0.1:5555
+scrcpy --serial=192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # short version
 ```
@ -505,10 +518,23 @@ Suppose that this server is accessible at 192.168.1.2. Then, from another
 terminal, run `scrcpy`:
 ```bash
 # in bash
 export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
 scrcpy --tunnel-host=192.168.1.2
 ```
 ```cmd
 :: in cmd
 set ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
 scrcpy --tunnel-host=192.168.1.2
 ```
 ```powershell
 # in PowerShell
 $env:ADB_SERVER_SOCKET = 'tcp:192.168.1.2:5037'
 scrcpy --tunnel-host=192.168.1.2
 ```
 By default, `scrcpy` uses the local port used for `adb forward` tunnel
 establishment (typically `27183`, see `--port`). It is also possible to force a
 different tunnel port (it may be useful in more complex situations, when more
@ -542,10 +568,23 @@ ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
 From another terminal, run `scrcpy`:
 ```bash
 # in bash
 export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
 ```cmd
 :: in cmd
 set ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
 ```powershell
 # in PowerShell
 $env:ADB_SERVER_SOCKET = 'tcp:localhost:5038'
 scrcpy
 ```
 To avoid enabling remote port forwarding, you could force a forward connection
 instead (notice the `-L` instead of `-R`):
@ -559,15 +598,28 @@ ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
 From another terminal, run `scrcpy`:
 ```bash
 # in bash
 export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
 ```cmd
 :: in cmd
 set ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
 ```powershell
 # in PowerShell
 $env:ADB_SERVER_SOCKET = 'tcp:localhost:5038'
 scrcpy --force-adb-forward
 ```
 Like for wireless connections, it may be useful to reduce quality:
 ```
-scrcpy -b2M -m800 --max-fps 15
+scrcpy -b2M -m800 --max-fps=15
 ```
 ### Window configuration
@ -577,7 +629,7 @@ scrcpy -b2M -m800 --max-fps 15
 By default, the window title is the device model. It can be changed:
 ```bash
-scrcpy --window-title 'My device'
+scrcpy --window-title='My device'
 ```
 #### Position and size
@ -585,7 +637,7 @@ scrcpy --window-title 'My device'
 The initial window position and size may be specified:
 ```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
+scrcpy --window-x=100 --window-y=100 --window-width=800 --window-height=600
 ```
 #### Borderless
@ -620,7 +672,7 @@ Fullscreen can then be toggled dynamically with <kbd>MOD</kbd>+<kbd>f</kbd>.
 The window may be rotated:
 ```bash
-scrcpy --rotation 1
+scrcpy --rotation=1
 ```
 Possible values:
@ -662,7 +714,7 @@ If several displays are available, it is possible to select the display to
 mirror:
 ```bash
-scrcpy --display 1
+scrcpy --display=1
 ```
 The list of display ids can be retrieved by:
@ -1170,17 +1222,8 @@ For general questions or discussions, you can also use:
 ## Translations
-This README is available in other languages:
+Translations of this README in other languages are available in the [wiki].
- [Deutsch (German, `de`) - v1.22](README.de.md)
+[wiki]: https://github.com/Genymobile/scrcpy/wiki
 - [Indonesian (Indonesia, `id`) - v1.16](README.id.md)
 - [Italiano (Italiano, `it`) - v1.23](README.it.md)
 - [日本語 (Japanese, `jp`) - v1.19](README.jp.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
 - [Português Brasileiro (Brazilian Portuguese, `pt-BR`) - v1.19](README.pt-br.md)
 - [Español (Spanish, `sp`) - v1.21](README.sp.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.22](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
 - [Turkish (Turkish, `tr`) - v1.18](README.tr.md)
 Only this README file is guaranteed to be up-to-date.
--- a/README.pt-br.md
+++ b/README.pt-br.md
@ -1,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-2022 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## 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/
--- a/README.sp.md
+++ b/README.sp.md
@ -1,974 +0,0 @@
 Solo se garantiza que el archivo [README](README.md) original esté actualizado.
 # scrcpy (v1.21)
 <img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
 Esta aplicación proporciona control e imagen de un dispositivo Android conectado
 por USB (o [por TCP/IP](#conexión)). No requiere acceso _root_.
 Compatible con _GNU/Linux_, _Windows_ y _macOS_.
 ![screenshot](assets/screenshot-debian-600.jpg)
 Se enfoca en:
 - **ser ligera**: aplicación nativa, solo muestra la imagen del dispositivo
 - **rendimiento**: 30~120fps, dependiendo del dispositivo
 - **calidad**: 1920×1080 o superior
 - **baja latencia**: [35~70ms][lowlatency]
 - **inicio rápido**: ~1 segundo para mostrar la primera imagen
 - **no intrusivo**: no deja nada instalado en el dispositivo
 - **beneficios**: sin cuentas, sin anuncios, no requiere acceso a internet
 - **libertad**: software gratis y de código abierto
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 Con la aplicación puede:
 - [grabar la pantalla](#capturas-y-grabaciones)
 - duplicar la imagen con [la pantalla apagada](#apagar-la-pantalla)
 - [copiar y pegar](#copiar-y-pegar) en ambos sentidos
 - [configurar la calidad](#configuración-de-captura)
 - usar la pantalla del dispositivo [como webcam (V4L2)](#v4l2loopback) (solo en Linux)
 - [emular un teclado físico (HID)](#emular-teclado-físico-hid)
   (solo en Linux)
 - y mucho más…
 ## Requisitos
 El dispositivo Android requiere como mínimo API 21 (Android 5.0).
 Asegurate de [habilitar el adb debugging][enable-adb] en tu(s) dispositivo(s).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 En algunos dispositivos, también necesitas habilitar [una opción adicional][control] para controlarlo con el teclado y ratón.
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ## Consigue la app
 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
 ### Resumen
 - Linux: `apt install scrcpy`
 - Windows: [download](README.md#windows)
 - macOS: `brew install scrcpy`
 Construir desde la fuente: [BUILD] ([proceso simplificado][BUILD_simple])
 [BUILD]: BUILD.md
 [BUILD_simple]: BUILD.md#simple
 ### Linux
 En Debian y Ubuntu:
 ```
 apt install scrcpy
 ```
 Hay un paquete [Snap]: [`scrcpy`][snap-link].
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
 Para Fedora, hay un paquete [COPR]: [`scrcpy`][copr-link].
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 Para Arch Linux, hay un paquete [AUR]: [`scrcpy`][aur-link].
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 [aur-link]: https://aur.archlinux.org/packages/scrcpy/
 Para Gentoo, hay un paquete [Ebuild]: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 También puedes [construir la aplicación manualmente][BUILD] ([proceso simplificado][BUILD_simple]).
 ### Windows
 Para Windows, por simplicidad, hay un pre-compilado con todas las dependencias
 (incluyendo `adb`):
 - [README](README.md#windows)
 También está disponible en [Chocolatey]:
 [Chocolatey]: https://chocolatey.org/
 ```bash
 choco install scrcpy
 choco install adb    # si aún no está instalado
 ```
 Y en [Scoop]:
 ```bash
 scoop install scrcpy
 scoop install adb    # si aún no está instalado
 ```
 [Scoop]: https://scoop.sh
 También puedes [construir la aplicación manualmente][BUILD].
 ### macOS
 La aplicación está disponible en [Homebrew]. Solo instalala:
 [Homebrew]: https://brew.sh/
 ```bash
 brew install scrcpy
 ```
 Necesitarás `adb`, accesible desde `PATH`. Si aún no lo tienes:
 ```bash
 brew install android-platform-tools
 ```
 También está disponible en [MacPorts], que configura el adb automáticamente:
 ```bash
 sudo port install scrcpy
 ```
 [MacPorts]: https://www.macports.org/
 También puedes [construir la aplicación manualmente][BUILD].
 ## Ejecutar
 Enchufa el dispositivo Android, y ejecuta:
 ```bash
 scrcpy
 ```
 Acepta argumentos desde la línea de comandos, listados en:
 ```bash
 scrcpy --help
 ```
 ## Características
 ### Configuración de captura
 #### Reducir la definición
 A veces es útil reducir la definición de la imagen del dispositivo Android para aumentar el desempeño.
 Para limitar el ancho y la altura a un valor específico (ej. 1024):
 ```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # versión breve
 ```
 La otra dimensión es calculada para conservar el aspect ratio del dispositivo.
 De esta forma, un dispositivo en 1920×1080 será transmitido a 1024×576.
 #### Cambiar el bit-rate
 El bit-rate por defecto es 8 Mbps. Para cambiar el bit-rate del video (ej. a 2 Mbps):
 ```bash
 scrcpy --bit-rate 2M
 scrcpy -b 2M  # versión breve
 ```
 #### Limitar los fps
 El fps puede ser limitado:
 ```bash
 scrcpy --max-fps 15
 ```
 Es oficialmente soportado desde Android 10, pero puede funcionar en versiones anteriores.
 #### Recortar
 La imagen del dispositivo puede ser recortada para transmitir solo una parte de la pantalla.
 Por ejemplo, puede ser útil para transmitir la imagen de un solo ojo del Oculus Go:
 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 con coordenadas de origen en (0,0)
 ```
 Si `--max-size` también está especificado, el cambio de tamaño es aplicado después de cortar.
 #### Fijar la rotación del video
 Para fijar la rotación de la transmisión:
 ```bash
 scrcpy --lock-video-orientation     # orientación inicial
 scrcpy --lock-video-orientation=0   # orientación normal
 scrcpy --lock-video-orientation=1   # 90° contrarreloj
 scrcpy --lock-video-orientation=2   # 180°
 scrcpy --lock-video-orientation=3   # 90° sentido de las agujas del reloj
 ```
 Esto afecta la rotación de la grabación.
 La [ventana también puede ser rotada](#rotación) independientemente.
 #### Codificador
 Algunos dispositivos pueden tener más de una rotación, y algunos pueden causar problemas o errores. Es posible seleccionar un codificador diferente:
 ```bash
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```
 Para listar los codificadores disponibles, puedes pasar un nombre de codificador inválido, el error te dará los codificadores disponibles:
 ```bash
 scrcpy --encoder _
 ```
 ### Capturas y grabaciones
 #### Grabación
 Es posible grabar la pantalla mientras se transmite:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 Para grabar sin transmitir la pantalla:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrumpe la grabación con Ctrl+C
 ```
 Los "skipped frames" son grabados, incluso si no se mostrados en tiempo real (por razones de desempeño). Los frames tienen _marcas de tiempo_ en el dispositivo, por lo que el "[packet delay
 variation]" no impacta el archivo grabado.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 #### v4l2loopback
 En Linux se puede mandar el stream del video a un dispositivo loopback v4l2, por
 lo que se puede abrir el dispositivo Android como una webcam con cualquier
 programa compatible con v4l2.
 Se debe instalar el modulo `v4l2loopback`:
 ```bash
 sudo apt install v4l2loopback-dkms
 ```
 Para crear un dispositivo v4l2:
 ```bash
 sudo modprobe v4l2loopback
 ```
 Esto va a crear un nuevo dispositivo de video en `/dev/videoN`, donde `N` es un número
 (hay más [opciones](https://github.com/umlaeute/v4l2loopback#options) disponibles
 para crear múltiples dispositivos o usar un ID en específico).
 Para ver los dispositivos disponibles:
 ```bash
 # requiere el paquete v4l-utils
 v4l2-ctl --list-devices
 # simple pero generalmente suficiente
 ls /dev/video*
 ```
 Para iniciar scrcpy usando una fuente v4l2:
 ```bash
 scrcpy --v4l2-sink=/dev/videoN
 scrcpy --v4l2-sink=/dev/videoN --no-display  # deshabilita la transmisión de imagen
 scrcpy --v4l2-sink=/dev/videoN -N            # más corto
 ```
 (reemplace `N` con el ID del dispositivo, compruebe con `ls /dev/video*`)
 Una vez habilitado, podés abrir el stream del video con una herramienta compatible con v4l2:
 ```bash
 ffplay -i /dev/videoN
 vlc v4l2:///dev/videoN   # VLC puede agregar un delay por buffering
 ```
 Por ejemplo, podrías capturar el video usando [OBS].
 [OBS]: https://obsproject.com/
 #### Buffering
 Es posible agregar buffering al video. Esto reduce el ruido en la imagen ("jitter")
 pero aumenta la latencia (vea [#2464]).
 [#2464]: https://github.com/Genymobile/scrcpy/issues/2464
 La opción de buffering está disponible para la transmisión de imagen:
 ```bash
 scrcpy --display-buffer=50  # agrega 50 ms de buffering a la imagen
 ```
 y las fuentes V4L2:
 ```bash
 scrcpy --v4l2-buffer=500    # agrega 500 ms de buffering a la fuente v4l2
 ```
 ### Conexión
 #### TCP/IP (Inalámbrica)
 _Scrcpy_ usa `adb` para comunicarse con el dispositivo, y `adb` puede [conectarse] vía TCP/IP.
 El dispositivo debe estar conectado a la misma red que la computadora:
 ##### Automático
 La opción `--tcpip` permite configurar la conexión automáticamente. Hay 2 variables.
 Si el dispositivo (accesible en 192.168.1.1 para este ejemplo) ya está escuchando
 en un puerto (generalmente 5555) esperando una conexión adb entrante, entonces corré:
 ```bash
 scrcpy --tcpip=192.168.1.1       # el puerto default es 5555
 scrcpy --tcpip=192.168.1.1:5555
 ```
 Si el dispositivo no tiene habilitado el modo adb TCP/IP (o si no sabés la dirección IP),
 entonces conectá el dispositivo por USB y corré:
 ```bash
 scrcpy --tcpip    # sin argumentos
 ```
 El programa buscará automáticamente la IP del dispositivo, habilitará el modo TCP/IP, y
 se conectará al dispositivo antes de comenzar a transmitir la imagen.
 ##### Manual
 Como alternativa, se puede habilitar la conexión TCP/IP manualmente usando `adb`:
 1. Conecta el dispositivo al mismo Wi-Fi que tu computadora.
 2. Obtén la dirección IP del dispositivo, en Ajustes → Acerca del dispositivo → Estado, o ejecutando este comando:
    ```bash
    adb shell ip route | awk '{print $9}'
    ```
 3. Habilita adb vía TCP/IP en el dispositivo: `adb tcpip 5555`.
 4. Desenchufa el dispositivo.
 5. Conéctate a tu dispositivo: `adb connect IP_DEL_DISPOSITIVO:5555` _(reemplaza `IP_DEL_DISPOSITIVO`)_.
 6. Ejecuta `scrcpy` con normalidad.
 Podría resultar útil reducir el bit-rate y la definición:
 ```bash
 scrcpy --bit-rate 2M --max-size 800
 scrcpy -b2M -m800  # versión breve
 ```
 [conectarse]: https://developer.android.com/studio/command-line/adb.html#wireless
 #### Múltiples dispositivos
 Si hay muchos dispositivos listados en `adb devices`, será necesario especificar el _número de serie_:
 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # versión breve
 ```
 Si el dispositivo está conectado por TCP/IP:
 ```bash
 scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # versión breve
 ```
 Puedes iniciar múltiples instancias de _scrcpy_ para múltiples dispositivos.
 #### Iniciar automáticamente al detectar dispositivo
 Puedes utilizar [AutoAdb]:
 ```bash
 autoadb scrcpy -s '{}'
 ```
 [AutoAdb]: https://github.com/rom1v/autoadb
 #### Túneles
 Para conectarse a un dispositivo remoto, es posible conectar un cliente local `adb` a un servidor remoto `adb` (siempre y cuando utilicen la misma versión de protocolos _adb_).
 ##### Servidor ADB remoto
 Para conectarse a un servidor ADB remoto, haz que el servidor escuche en todas las interfaces:
 ```bash
 adb kill-server
 adb -a nodaemon server start
 # conserva este servidor abierto
 ```
 **Advertencia: todas las comunicaciones entre los clientes y el servidor ADB están desencriptadas.**
 Supondremos que este servidor se puede acceder desde 192.168.1.2. Entonces, desde otra
 terminal, corré scrcpy:
 ```bash
 export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
 scrcpy --tunnel-host=192.168.1.2
 ```
 Por default, scrcpy usa el puerto local que se usó para establecer el tunel
 `adb forward` (típicamente `27183`, vea `--port`). También es posible forzar un
 puerto diferente (puede resultar útil en situaciones más complejas, donde haya
 múltiples redirecciones):
 ```
 scrcpy --tunnel-port=1234
 ```
 ##### Túnel SSH
 Para comunicarse con un servidor ADB remoto de forma segura, es preferible usar un túnel SSH.
 Primero, asegurate que el servidor ADB está corriendo en la computadora remota:
 ```bash
 adb start-server
 ```
 Después, establecé el túnel SSH:
 ```bash
 # local  5038 --> remoto  5037
 # local 27183 <-- remoto 27183
 ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # conserva este servidor abierto
 ```
 Desde otra terminal, corré scrcpy:
 ```bash
 export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
 Para evitar habilitar "remote port forwarding", puedes forzar una "forward connection" (nótese el argumento `-L` en vez de `-R`):
 ```bash
 # local  5038 --> remoto  5037
 # local 27183 --> remoto 27183
 ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # conserva este servidor abierto
 ```
 Desde otra terminal, corré scrcpy:
 ```bash
 export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
 Al igual que las conexiones inalámbricas, puede resultar útil reducir la calidad:
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### Configuración de la ventana
 #### Título
 Por defecto, el título de la ventana es el modelo del dispositivo. Puede ser modificado:
 ```bash
 scrcpy --window-title 'My device'
 ```
 #### Posición y tamaño
 La posición y tamaño inicial de la ventana puede ser especificado:
 ```bash
 scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 ```
 #### Sin bordes
 Para deshabilitar el diseño de la ventana:
 ```bash
 scrcpy --window-borderless
 ```
 #### Siempre adelante
 Para mantener la ventana de scrcpy siempre adelante:
 ```bash
 scrcpy --always-on-top
 ```
 #### Pantalla completa
 La aplicación puede ser iniciada en pantalla completa:
 ```bash
 scrcpy --fullscreen
 scrcpy -f  # versión breve
 ```
 Puede entrar y salir de la pantalla completa con la combinación <kbd>MOD</kbd>+<kbd>f</kbd>.
 #### Rotación
 Se puede rotar la ventana:
 ```bash
 scrcpy --rotation 1
 ```
 Los posibles valores son:
 - `0`: sin rotación
 - `1`: 90 grados contrarreloj
 - `2`: 180 grados
 - `3`: 90 grados en sentido de las agujas del reloj
 La rotación también puede ser modificada con la combinación de teclas <kbd>MOD</kbd>+<kbd>←</kbd> _(izquierda)_ y <kbd>MOD</kbd>+<kbd>→</kbd> _(derecha)_.
 Nótese que _scrcpy_ maneja 3 diferentes rotaciones:
 - <kbd>MOD</kbd>+<kbd>r</kbd> solicita al dispositivo cambiar entre vertical y horizontal (la aplicación en uso puede rechazarlo si no soporta la orientación solicitada).
 - [`--lock-video-orientation`](#fijar-la-rotación-del-video) cambia la rotación de la transmisión (la orientación del video enviado a la PC). Esto afecta a la grabación.
 - `--rotation` (o <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) rota solo el contenido de la imagen. Esto solo afecta a la imagen mostrada, no a la grabación.
 ### Otras opciones
 #### Solo lectura ("Read-only")
 Para deshabilitar los controles (todo lo que interactúe con el dispositivo: eventos del teclado, eventos del mouse, arrastrar y soltar archivos):
 ```bash
 scrcpy --no-control
 scrcpy -n  # versión breve
 ```
 #### Pantalla
 Si múltiples pantallas están disponibles, es posible elegir cual transmitir:
 ```bash
 scrcpy --display 1
 ```
 Los ids de las pantallas se pueden obtener con el siguiente comando:
 ```bash
 adb shell dumpsys display   # busque "mDisplayId=" en la respuesta
 ```
 La segunda pantalla solo puede ser manejada si el dispositivo cuenta con Android 10 (en caso contrario será transmitida en el modo solo lectura).
 #### Permanecer activo
 Para evitar que el dispositivo descanse después de un tiempo mientras está conectado:
 ```bash
 scrcpy --stay-awake
 scrcpy -w  # versión breve
 ```
 La configuración original se restaura al cerrar scrcpy.
 #### Apagar la pantalla
 Es posible apagar la pantalla mientras se transmite al iniciar con el siguiente comando:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S  # versión breve
 ```
 O presionando <kbd>MOD</kbd>+<kbd>o</kbd> en cualquier momento.
 Para volver a prenderla, presione <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
 En Android, el botón de `POWER` siempre prende la pantalla. Por conveniencia, si `POWER` es enviado vía scrcpy (con click-derecho o <kbd>MOD</kbd>+<kbd>p</kbd>), esto forzará a apagar la pantalla con un poco de atraso (en la mejor de las situaciones). El botón físico `POWER` seguirá prendiendo la pantalla.
 También puede resultar útil para evitar que el dispositivo entre en inactividad:
 ```bash
 scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw  # versión breve
 ```
 #### Apagar al cerrar la aplicación
 Para apagar la pantalla del dispositivo al cerrar scrcpy:
 ```bash
 scrcpy --power-off-on-close
 ```
 #### Mostrar clicks
 Para presentaciones, puede resultar útil mostrar los clicks físicos (en el dispositivo físicamente).
 Android provee esta opción en _Opciones para desarrolladores_.
 _Scrcpy_ provee una opción para habilitar esta función al iniciar la aplicación y restaurar el valor original al salir:
 ```bash
 scrcpy --show-touches
 scrcpy -t  # versión breve
 ```
 Nótese que solo muestra los clicks _físicos_ (con el dedo en el dispositivo).
 #### Desactivar protector de pantalla
 Por defecto, scrcpy no evita que el protector de pantalla se active en la computadora.
 Para deshabilitarlo:
 ```bash
 scrcpy --disable-screensaver
 ```
 ### Control
 #### Rotar pantalla del dispositivo
 Presione <kbd>MOD</kbd>+<kbd>r</kbd> para cambiar entre posición vertical y horizontal.
 Nótese que solo rotará si la aplicación activa soporta la orientación solicitada.
 #### Copiar y pegar
 Cuando que el portapapeles de Android cambia, automáticamente se sincroniza al portapapeles de la computadora.
 Cualquier shortcut con <kbd>Ctrl</kbd> es enviado al dispositivo. En particular:
 - <kbd>Ctrl</kbd>+<kbd>c</kbd> normalmente copia
 - <kbd>Ctrl</kbd>+<kbd>x</kbd> normalmente corta
 - <kbd>Ctrl</kbd>+<kbd>v</kbd> normalmente pega (después de la sincronización de portapapeles entre la computadora y el dispositivo)
 Esto normalmente funciona como es esperado.
 Sin embargo, este comportamiento depende de la aplicación en uso. Por ejemplo, _Termux_ envía SIGINT con <kbd>Ctrl</kbd>+<kbd>c</kbd>, y _K-9 Mail_ crea un nuevo mensaje.
 Para copiar, cortar y pegar, en tales casos (solo soportado en Android >= 7):
 - <kbd>MOD</kbd>+<kbd>c</kbd> inyecta `COPY`
 - <kbd>MOD</kbd>+<kbd>x</kbd> inyecta `CUT`
 - <kbd>MOD</kbd>+<kbd>v</kbd> inyecta `PASTE` (después de la sincronización de portapapeles entre la computadora y el dispositivo)
 Además, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permite inyectar el texto en el portapapeles de la computadora como una secuencia de teclas. Esto es útil cuando el componente no acepta pegado de texto (por ejemplo en _Termux_), pero puede romper caracteres no pertenecientes a ASCII.
 **AVISO:** Pegar de la computadora al dispositivo (tanto con <kbd>Ctrl</kbd>+<kbd>v</kbd> o <kbd>MOD</kbd>+<kbd>v</kbd>) copia el contenido al portapapeles del dispositivo. Como consecuencia, cualquier aplicación de Android puede leer su contenido. Debería evitar pegar contenido sensible (como contraseñas) de esta forma.
 Algunos dispositivos no se comportan como es esperado al establecer el portapapeles programáticamente. La opción `--legacy-paste` está disponible para cambiar el comportamiento de <kbd>Ctrl</kbd>+<kbd>v</kbd> y <kbd>MOD</kbd>+<kbd>v</kbd> para que también inyecten el texto del portapapeles de la computadora como una secuencia de teclas (de la misma forma que <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
 Para deshabilitar la auto-sincronización del portapapeles, use `--no-clipboard-autosync`.
 #### Pellizcar para zoom
 Para simular "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-y-mover_.
 Más precisamente, mantén <kbd>Ctrl</kbd> mientras presionas botón izquierdo. Hasta que no se suelte el botón, todos los movimientos del mouse cambiarán el tamaño y rotación del contenido (si es soportado por la app en uso) respecto al centro de la pantalla.
 Concretamente, scrcpy genera clicks adicionales con un "dedo virtual" en la posición invertida respecto al centro de la pantalla.
 #### Emular teclado físico (HID)
 Por default, scrcpy usa el sistema de Android para la injección de teclas o texto:
 funciona en todas partes, pero está limitado a ASCII.
 En Linux, scrcpy puede emular un teclado USB físico en Android para proveer
 una mejor experiencia al enviar _inputs_ (usando [USB HID vía AOAv2][hid-aoav2]):
 deshabilita el teclado virtual y funciona para todos los caracteres y IME.
 [hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
 Sin embargo, solo funciona si el dispositivo está conectado por USB, y por ahora
 solo funciona en Linux.
 Para habilitar este modo:
 ```bash
 scrcpy --hid-keyboard
 scrcpy -K  # más corto
 ```
 Si por alguna razón falla (por ejemplo si el dispositivo no está conectado vía
 USB), automáticamente vuelve al modo default (un mensaje se escribirá en la consola).
 Se puede usar los mismos argumentos en la línea de comandos tanto si se conecta con
 USB o vía TCP/IP.
 En este modo, los _raw key events_ (_scancodes_) se envían al dispositivo, independientemente
 del mapeo del teclado en el host. Por eso, si el diseño de tu teclado no concuerda, debe ser
 configurado en el dispositivo Android, en Ajustes → Sistema → Idioma y Entrada de Texto
 → [Teclado Físico].
 Se puede iniciar automáticamente en esta página de ajustes:
 ```bash
 adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
 ```
 Sin embargo, la opción solo está disponible cuando el teclado HID está activo
 (o cuando se conecta un teclado físico).
 [Teclado Físico]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
 #### Preferencias de inyección de texto
 Existen dos tipos de [eventos][textevents] generados al escribir texto:
 - _key events_, marcando si la tecla es presionada o soltada;
 - _text events_, marcando si un texto fue introducido.
 Por defecto, las letras son inyectadas usando _key events_, para que el teclado funcione como es esperado en juegos (típicamente las teclas WASD).
 Pero esto puede [causar problemas][prefertext]. Si encuentras tales problemas, los puedes evitar con:
 ```bash
 scrcpy --prefer-text
 ```
 (Pero esto romperá el comportamiento del teclado en los juegos)
 Por el contrario, se puede forzar scrcpy para siempre injectar _raw key events_:
 ```bash
 scrcpy --raw-key-events
 ```
 Estas opciones no tienen efecto en los teclados HID (todos los _key events_ son enviados como
 _scancodes_ en este modo).
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 #### Repetir tecla
 Por defecto, mantener una tecla presionada genera múltiples _key events_. Esto puede
 causar problemas de desempeño en algunos juegos, donde estos eventos no tienen sentido de todos modos.
 Para evitar enviar _key events_ repetidos:
 ```bash
 scrcpy --no-key-repeat
 ```
 Estas opciones no tienen efecto en los teclados HID (Android maneja directamente
 las repeticiones de teclas en este modo)
 #### Botón derecho y botón del medio
 Por defecto, botón derecho ejecuta RETROCEDER (o ENCENDIDO) y botón del medio INICIO. Para inhabilitar estos atajos y enviar los clicks al dispositivo:
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### Arrastrar y soltar archivos
 #### Instalar APKs
 Para instalar un APK, arrastre y suelte el archivo APK (terminado en `.apk`) a la ventana de _scrcpy_.
 No hay respuesta visual, un mensaje se escribirá en la consola.
 #### Enviar archivos al dispositivo
 Para enviar un archivo a `/sdcard/Download/` en el dispositivo, arrastre y suelte
 un archivo (no APK) a la ventana de _scrcpy_.
 No hay ninguna respuesta visual, un mensaje se escribirá en la consola.
 El directorio de destino puede ser modificado al iniciar:
 ```bash
 scrcpy --push-target=/sdcard/Movies/
 ```
 ### Envío de Audio
 _Scrcpy_ no envía el audio. Use [sndcpy].
 También lea [issue #14].
 [sndcpy]: https://github.com/rom1v/sndcpy
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## Atajos
 En la siguiente lista, <kbd>MOD</kbd> es el atajo modificador. Por defecto es <kbd>Alt</kbd> (izquierdo) o <kbd>Super</kbd> (izquierdo).
 Se puede modificar usando `--shortcut-mod`. Las posibles teclas son `lctrl` (izquierdo), `rctrl` (derecho), `lalt` (izquierdo), `ralt` (derecho), `lsuper` (izquierdo) y `rsuper` (derecho). Por ejemplo:
 ```bash
 # use RCtrl para los atajos
 scrcpy --shortcut-mod=rctrl
 # use tanto LCtrl+LAlt o LSuper para los atajos
 scrcpy --shortcut-mod=lctrl+lalt,lsuper
 ```
 _<kbd>[Super]</kbd> es generalmente la tecla <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
 [Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
 | Acción                                       |   Atajo
 | -------------------------------------------  |:-----------------------------
 | Alterne entre pantalla compelta              | <kbd>MOD</kbd>+<kbd>f</kbd>
 | Rotar pantalla hacia la izquierda            | <kbd>MOD</kbd>+<kbd>←</kbd> _(izquierda)_
 | Rotar pantalla hacia la derecha              | <kbd>MOD</kbd>+<kbd>→</kbd> _(derecha)_
 | Ajustar ventana a 1:1 ("pixel-perfect")      | <kbd>MOD</kbd>+<kbd>g</kbd>
 | Ajustar ventana para quitar los bordes negros| <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doble click izquierdo¹_
 | Click en `INICIO`                            | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Click medio_
 | Click en `RETROCEDER`                        | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Click derecho²_
 | Click en `CAMBIAR APLICACIÓN`                | <kbd>MOD</kbd>+<kbd>s</kbd> \| _Cuarto botón³_
 | Click en `MENÚ` (desbloquear pantalla)⁴      | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Click en `SUBIR VOLUMEN`                     | <kbd>MOD</kbd>+<kbd>↑</kbd> _(arriba)_
 | Click en `BAJAR VOLUME`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(abajo)_
 | Click en `ENCENDIDO`                         | <kbd>MOD</kbd>+<kbd>p</kbd>
 | Encendido                                    | _Botón derecho²_
 | Apagar pantalla (manteniendo la transmisión) | <kbd>MOD</kbd>+<kbd>o</kbd>
 | Encender pantalla                            | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Rotar pantalla del dispositivo               | <kbd>MOD</kbd>+<kbd>r</kbd>
 | Abrir panel de notificaciones                | <kbd>MOD</kbd>+<kbd>n</kbd> \| _Quinto botón³_
 | Abrir panel de configuración                 | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Doble quinto botón³_
 | Cerrar paneles                               | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | Copiar al portapapeles⁵                      | <kbd>MOD</kbd>+<kbd>c</kbd>
 | Cortar al portapapeles⁵                      | <kbd>MOD</kbd>+<kbd>x</kbd>
 | Synchronizar portapapeles y pegar⁵           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Inyectar texto del portapapeles de la PC     | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Habilitar/Deshabilitar contador de FPS (en stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
 | Pellizcar para zoom                          | <kbd>Ctrl</kbd>+_click-y-mover_
 | Arrastrar y soltar un archivo (APK)          | Instalar APK desde la computadora
 | Arrastrar y soltar un archivo (no APK)       | [Mover archivo al dispositivo](#enviar-archivos-al-dispositivo)
 _¹Doble click en los bordes negros para eliminarlos._  
 _²Botón derecho enciende la pantalla si estaba apagada, sino ejecuta RETROCEDER._  
 _³Cuarto y quinto botón del mouse, si tu mouse los tiene._  
 _⁴Para las apps react-native en desarrollo, `MENU` activa el menú de desarrollo._  
 _⁵Solo en Android >= 7._
 Los shortcuts con teclas repetidas se ejecutan soltando y volviendo a apretar la tecla
 por segunda vez. Por ejemplo, para ejecutar "Abrir panel de configuración":
 1. Apretá y mantené apretado <kbd>MOD</kbd>.
 2. Después apretá dos veces la tecla <kbd>n</kbd>.
 3. Por último, soltá la tecla <kbd>MOD</kbd>.
 Todos los atajos <kbd>Ctrl</kbd>+_tecla_ son enviados al dispositivo para que sean manejados por la aplicación activa.
 ## Path personalizado
 Para usar un binario de _adb_ en particular, configure el path `ADB` en las variables de entorno:
 ```bash
 ADB=/path/to/adb scrcpy
 ```
 Para sobreescribir el path del archivo `scrcpy-server`, configure el path en `SCRCPY_SERVER_PATH`.
 Para sobreescribir el ícono, configure el path en `SCRCPY_ICON_PATH`.
 ## ¿Por qué _scrcpy_?
 Un colega me retó a encontrar un nombre tan impronunciable como [gnirehtet].
 [`strcpy`] copia un **str**ing; `scrcpy` copia un **scr**een.
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## ¿Cómo construir (BUILD)?
 Véase [BUILD] (en inglés).
 ## Problemas generales
 Vea las [preguntas frecuentes (en inglés)](FAQ.md).
 ## Desarrolladores
 Lea la [hoja de desarrolladores (en inglés)](DEVELOP.md).
 ## Licencia
    Copyright (C) 2018 Genymobile
    Copyright (C) 2018-2022 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## Artículos
 - [Introducing scrcpy][article-intro] (en inglés)
 - [Scrcpy now works wirelessly][article-tcpip] (en inglés)
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.tr.md
+++ b/README.tr.md
@ -1,824 +0,0 @@
 # scrcpy (v1.18)
 Bu uygulama Android cihazların USB (ya da [TCP/IP][article-tcpip]) üzerinden
 görüntülenmesini ve kontrol edilmesini sağlar. _root_ erişimine ihtiyaç duymaz.
 _GNU/Linux_, _Windows_ ve _macOS_ sistemlerinde çalışabilir.
 ![screenshot](assets/screenshot-debian-600.jpg)
 Öne çıkan özellikler:
 - **hafiflik** (doğal, sadece cihazın ekranını gösterir)
 - **performans** (30~60fps)
 - **kalite** (1920×1080 ya da üzeri)
 - **düşük gecikme süresi** ([35~70ms][lowlatency])
 - **düşük başlangıç süresi** (~1 saniye ilk kareyi gösterme süresi)
 - **müdaheleci olmama** (cihazda kurulu yazılım kalmaz)
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 ## Gereksinimler
 Android cihaz en düşük API 21 (Android 5.0) olmalıdır.
 [Adb hata ayıklamasının][enable-adb] cihazınızda aktif olduğundan emin olun.
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 Bazı cihazlarda klavye ve fare ile kontrol için [ilave bir seçenek][control] daha
 etkinleştirmeniz gerekebilir.
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ## Uygulamayı indirin
 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
 ### Özet
 - Linux: `apt install scrcpy`
 - Windows: [indir][direct-win64]
 - macOS: `brew install scrcpy`
 Kaynak kodu derle: [BUILD] ([basitleştirilmiş süreç][build_simple])
 [build]: BUILD.md
 [build_simple]: BUILD.md#simple
 ### Linux
 Debian (şimdilik _testing_ ve _sid_) ve Ubuntu (20.04) için:
 ```
 apt install scrcpy
 ```
 [Snap] paketi: [`scrcpy`][snap-link].
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
 Fedora için, [COPR] paketi: [`scrcpy`][copr-link].
 [copr]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 Arch Linux için, [AUR] paketi: [`scrcpy`][aur-link].
 [aur]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 [aur-link]: https://aur.archlinux.org/packages/scrcpy/
 Gentoo için, [Ebuild] mevcut: [`scrcpy/`][ebuild-link].
 [ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 Ayrıca [uygulamayı el ile de derleyebilirsiniz][build] ([basitleştirilmiş süreç][build_simple]).
 ### Windows
 Windows için (`adb` dahil) tüm gereksinimleri ile derlenmiş bir arşiv mevcut:
 - [README](README.md#windows)
 [Chocolatey] ile kurulum:
 [chocolatey]: https://chocolatey.org/
 ```bash
 choco install scrcpy
 choco install adb    # if you don't have it yet
 ```
 [Scoop] ile kurulum:
 ```bash
 scoop install scrcpy
 scoop install adb    # if you don't have it yet
 ```
 [scoop]: https://scoop.sh
 Ayrıca [uygulamayı el ile de derleyebilirsiniz][build].
 ### macOS
 Uygulama [Homebrew] içerisinde mevcut. Sadece kurun:
 [homebrew]: https://brew.sh/
 ```bash
 brew install scrcpy
 ```
 `adb`, `PATH` içerisinden erişilebilir olmalıdır. Eğer değilse:
 ```bash
 brew install android-platform-tools
 ```
 [MacPorts] kullanılarak adb ve uygulamanın birlikte kurulumu yapılabilir:
 ```bash
 sudo port install scrcpy
 ```
 [macports]: https://www.macports.org/
 Ayrıca [uygulamayı el ile de derleyebilirsiniz][build].
 ## Çalıştırma
 Android cihazınızı bağlayın ve aşağıdaki komutu çalıştırın:
 ```bash
 scrcpy
 ```
 Komut satırı argümanları aşağıdaki komut ile listelenebilir:
 ```bash
 scrcpy --help
 ```
 ## Özellikler
 ### Ekran yakalama ayarları
 #### Boyut azaltma
 Bazen, Android cihaz ekranını daha düşük seviyede göstermek performansı artırabilir.
 Hem genişliği hem de yüksekliği bir değere sabitlemek için (ör. 1024):
 ```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # kısa versiyon
 ```
 Diğer boyut en-boy oranı korunacak şekilde hesaplanır.
 Bu şekilde ekran boyutu 1920x1080 olan bir cihaz 1024x576 olarak görünür.
 #### Bit-oranı değiştirme
 Varsayılan bit-oranı 8 Mbps'dir. Değiştirmek için (ör. 2 Mbps):
 ```bash
 scrcpy --bit-rate 2M
 scrcpy -b 2M  # kısa versiyon
 ```
 #### Çerçeve oranı sınırlama
 Ekran yakalama için maksimum çerçeve oranı için sınır koyulabilir:
 ```bash
 scrcpy --max-fps 15
 ```
 Bu özellik Android 10 ve sonrası sürümlerde resmi olarak desteklenmektedir,
 ancak daha önceki sürümlerde çalışmayabilir.
 #### Kesme
 Cihaz ekranının sadece bir kısmı görünecek şekilde kesilebilir.
 Bu özellik Oculus Go'nun bir gözünü yakalamak gibi durumlarda kullanışlı olur:
 ```bash
 scrcpy --crop 1224:1440:0:0   # (0,0) noktasından 1224x1440
 ```
 Eğer `--max-size` belirtilmişse yeniden boyutlandırma kesme işleminden sonra yapılır.
 #### Video yönünü kilitleme
 Videonun yönünü kilitlemek için:
 ```bash
 scrcpy --lock-video-orientation     # başlangıç yönü
 scrcpy --lock-video-orientation=0   # doğal yön
 scrcpy --lock-video-orientation=1   # 90° saatin tersi yönü
 scrcpy --lock-video-orientation=2   # 180°
 scrcpy --lock-video-orientation=3   # 90° saat yönü
 ```
 Bu özellik kaydetme yönünü de etkiler.
 [Pencere ayrı olarak döndürülmüş](#rotation) olabilir.
 #### Kodlayıcı
 Bazı cihazlar birden fazla kodlayıcıya sahiptir, ve bunların bazıları programın
 kapanmasına sebep olabilir. Bu durumda farklı bir kodlayıcı seçilebilir:
 ```bash
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```
 Mevcut kodlayıcıları listelemek için geçerli olmayan bir kodlayıcı ismi girebilirsiniz,
 hata mesajı mevcut kodlayıcıları listeleyecektir:
 ```bash
 scrcpy --encoder _
 ```
 ### Yakalama
 #### Kaydetme
 Ekran yakalama sırasında kaydedilebilir:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 Yakalama olmadan kayıt için:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # Ctrl+C ile kayıt kesilebilir
 ```
 "Atlanan kareler" gerçek zamanlı olarak gösterilmese (performans sebeplerinden ötürü) dahi kaydedilir.
 Kareler cihazda _zamandamgası_ ile saklanır, bu sayede [paket gecikme varyasyonu]
 kayıt edilen dosyayı etkilemez.
 [paket gecikme varyasyonu]: https://en.wikipedia.org/wiki/Packet_delay_variation
 #### v4l2loopback
 Linux'ta video akışı bir v4l2 loopback cihazına gönderilebilir. Bu sayede Android
 cihaz bir web kamerası gibi davranabilir.
 Bu işlem için `v4l2loopback` modülü kurulu olmalıdır:
 ```bash
 sudo apt install v4l2loopback-dkms
 ```
 v4l2 cihazı oluşturmak için:
 ```bash
 sudo modprobe v4l2loopback
 ```
 Bu komut `/dev/videoN` adresinde `N` yerine bir tamsayı koyarak yeni bir video
 cihazı oluşturacaktır.
 (birden fazla cihaz oluşturmak veya spesifik ID'ye sahip cihazlar için
 diğer [seçenekleri](https://github.com/umlaeute/v4l2loopback#options) inceleyebilirsiniz.)
 Aktif cihazları listelemek için:
 ```bash
 # v4l-utils paketi ile
 v4l2-ctl --list-devices
 # daha basit ama yeterli olabilecek şekilde
 ls /dev/video*
 ```
 v4l2 kullanarak scrpy kullanmaya başlamak için:
 ```bash
 scrcpy --v4l2-sink=/dev/videoN
 scrcpy --v4l2-sink=/dev/videoN --no-display  # ayna penceresini kapatarak
 scrcpy --v4l2-sink=/dev/videoN -N            # kısa versiyon
 ```
 (`N` harfini oluşturulan cihaz ID numarası ile değiştirin. `ls /dev/video*` cihaz ID'lerini görebilirsiniz.)
 Aktifleştirildikten sonra video akışını herhangi bir v4l2 özellikli araçla açabilirsiniz:
 ```bash
 ffplay -i /dev/videoN
 vlc v4l2:///dev/videoN   # VLC kullanırken yükleme gecikmesi olabilir
 ```
 Örneğin, [OBS] ile video akışını kullanabilirsiniz.
 [obs]: https://obsproject.com/
 ### Bağlantı
 #### Kablosuz
 _Scrcpy_ cihazla iletişim kurmak için `adb`'yi kullanır, Ve `adb`
 bir cihaza TCP/IP kullanarak [bağlanabilir].
 1. Cihazınızı bilgisayarınızla aynı Wi-Fi ağına bağlayın.
 2. Cihazınızın IP adresini bulun. Ayarlar → Telefon Hakkında → Durum sekmesinden veya
   aşağıdaki komutu çalıştırarak öğrenebilirsiniz:
   ```bash
   adb shell ip route | awk '{print $9}'
   ```
 3. Cihazınızda TCP/IP üzerinden adb kullanımını etkinleştirin: `adb tcpip 5555`.
 4. Cihazınızı bilgisayarınızdan sökün.
 5. Cihazınıza bağlanın: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` değerini değiştirin)_.
 6. `scrcpy` komutunu normal olarak çalıştırın.
 Bit-oranını ve büyüklüğü azaltmak yararlı olabilir:
 ```bash
 scrcpy --bit-rate 2M --max-size 800
 scrcpy -b2M -m800  # kısa version
 ```
 [bağlanabilir]: https://developer.android.com/studio/command-line/adb.html#wireless
 #### Birden fazla cihaz
 Eğer `adb devices` komutu birden fazla cihaz listeliyorsa _serial_ değerini belirtmeniz gerekir:
 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # kısa versiyon
 ```
 Eğer cihaz TCP/IP üzerinden bağlanmışsa:
 ```bash
 scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # kısa version
 ```
 Birden fazla cihaz için birden fazla _scrcpy_ uygulaması çalıştırabilirsiniz.
 #### Cihaz bağlantısı ile otomatik başlatma
 [AutoAdb] ile yapılabilir:
 ```bash
 autoadb scrcpy -s '{}'
 ```
 [autoadb]: https://github.com/rom1v/autoadb
 #### SSH Tünel
 Uzaktaki bir cihaza erişmek için lokal `adb` istemcisi, uzaktaki bir `adb` sunucusuna
 (aynı _adb_ sürümünü kullanmak şartı ile) bağlanabilir :
 ```bash
 adb kill-server    # 5037 portunda çalışan lokal adb sunucusunu kapat
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # bunu açık tutun
 ```
 Başka bir terminalde:
 ```bash
 scrcpy
 ```
 Uzaktan port yönlendirme ileri yönlü bağlantı kullanabilirsiniz
 (`-R` yerine `-L` olduğuna dikkat edin):
 ```bash
 adb kill-server    # 5037 portunda çalışan lokal adb sunucusunu kapat
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # bunu açık tutun
 ```
 Başka bir terminalde:
 ```bash
 scrcpy --force-adb-forward
 ```
 Kablosuz bağlantı gibi burada da kalite düşürmek faydalı olabilir:
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### Pencere ayarları
 #### İsim
 Cihaz modeli varsayılan pencere ismidir. Değiştirmek için:
 ```bash
 scrcpy --window-title 'Benim cihazım'
 ```
 #### Konum ve
 Pencerenin başlangıç konumu ve boyutu belirtilebilir:
 ```bash
 scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 ```
 #### Kenarlıklar
 Pencere dekorasyonunu kapatmak için:
 ```bash
 scrcpy --window-borderless
 ```
 #### Her zaman üstte
 Scrcpy penceresini her zaman üstte tutmak için:
 ```bash
 scrcpy --always-on-top
 ```
 #### Tam ekran
 Uygulamayı tam ekran başlatmak için:
 ```bash
 scrcpy --fullscreen
 scrcpy -f  # kısa versiyon
 ```
 Tam ekran <kbd>MOD</kbd>+<kbd>f</kbd> ile dinamik olarak değiştirilebilir.
 #### Döndürme
 Pencere döndürülebilir:
 ```bash
 scrcpy --rotation 1
 ```
 Seçilebilecek değerler:
 - `0`: döndürme yok
 - `1`: 90 derece saat yönünün tersi
 - `2`: 180 derece
 - `3`: 90 derece saat yönü
 Döndürme <kbd>MOD</kbd>+<kbd>←</kbd>_(sol)_ ve
 <kbd>MOD</kbd>+<kbd>→</kbd> _(sağ)_ ile dinamik olarak değiştirilebilir.
 _scrcpy_'de 3 farklı döndürme olduğuna dikkat edin:
 - <kbd>MOD</kbd>+<kbd>r</kbd> cihazın yatay veya dikey modda çalışmasını sağlar.
  (çalışan uygulama istenilen oryantasyonda çalışmayı desteklemiyorsa döndürme
  işlemini reddedebilir.)
 - [`--lock-video-orientation`](#lock-video-orientation) görüntü yakalama oryantasyonunu
  (cihazdan bilgisayara gelen video akışının oryantasyonu) değiştirir. Bu kayıt işlemini
  etkiler.
 - `--rotation` (or <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
  pencere içeriğini dönderir. Bu sadece canlı görüntüyü etkiler, kayıt işlemini etkilemez.
 ### Diğer ekran yakalama seçenekleri
 #### Yazma korumalı
 Kontrolleri devre dışı bırakmak için (cihazla etkileşime geçebilecek her şey: klavye ve
 fare girdileri, dosya sürükleyip bırakma):
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
 #### Ekran
 Eğer cihazın birden fazla ekranı varsa hangi ekranın kullanılacağını seçebilirsiniz:
 ```bash
 scrcpy --display 1
 ```
 Kullanılabilecek ekranları listelemek için:
 ```bash
 adb shell dumpsys display   # çıktı içerisinde "mDisplayId=" terimini arayın
 ```
 İkinci ekran ancak cihaz Android sürümü 10 veya üzeri olmalıdır (değilse yazma korumalı
 olarak görüntülenir).
 #### Uyanık kalma
 Cihazın uyku moduna girmesini engellemek için:
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
 scrcpy kapandığında cihaz başlangıç durumuna geri döner.
 #### Ekranı kapatma
 Ekran yakalama sırasında cihazın ekranı kapatılabilir:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
 Ya da <kbd>MOD</kbd>+<kbd>o</kbd> kısayolunu kullanabilirsiniz.
 Tekrar açmak için ise <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd> tuşlarına basın.
 Android'de, `GÜÇ` tuşu her zaman ekranı açar. Eğer `GÜÇ` sinyali scrcpy ile
 gönderilsiyse (sağ tık veya <kbd>MOD</kbd>+<kbd>p</kbd>), ekran kısa bir gecikme
 ile kapanacaktır. Fiziksel `GÜÇ` tuşuna basmak hala ekranın açılmasına sebep olacaktır.
 Bu cihazın uykuya geçmesini engellemek için kullanılabilir:
 ```bash
 scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
 #### Dokunuşları gösterme
 Sunumlar sırasında fiziksel dokunuşları (fiziksel cihazdaki) göstermek
 faydalı olabilir.
 Android'de bu özellik _Geliştici seçenekleri_ içerisinde bulunur.
 _Scrcpy_ bu özelliği çalışırken etkinleştirebilir ve kapanırken eski
 haline geri getirebilir:
 ```bash
 scrcpy --show-touches
 scrcpy -t
 ```
 Bu opsiyon sadece _fiziksel_ dokunuşları (cihaz ekranındaki) gösterir.
 #### Ekran koruyucuyu devre dışı bırakma
 Scrcpy varsayılan ayarlarında ekran koruyucuyu devre dışı bırakmaz.
 Bırakmak için:
 ```bash
 scrcpy --disable-screensaver
 ```
 ### Girdi kontrolü
 #### Cihaz ekranını dönderme
 <kbd>MOD</kbd>+<kbd>r</kbd> tuşları ile yatay ve dikey modlar arasında
 geçiş yapabilirsiniz.
 Bu kısayol ancak çalışan uygulama desteklediği takdirde ekranı döndürecektir.
 #### Kopyala yapıştır
 Ne zaman Android cihazdaki pano değişse bilgisayardaki pano otomatik olarak
 senkronize edilir.
 Tüm <kbd>Ctrl</kbd> kısayolları cihaza iletilir:
 - <kbd>Ctrl</kbd>+<kbd>c</kbd> genelde kopyalar
 - <kbd>Ctrl</kbd>+<kbd>x</kbd> genelde keser
 - <kbd>Ctrl</kbd>+<kbd>v</kbd> genelde yapıştırır (bilgisayar ve cihaz arasındaki
  pano senkronizasyonundan sonra)
 Bu kısayollar genelde beklediğiniz gibi çalışır.
 Ancak kısayolun gerçekten yaptığı eylemi açık olan uygulama belirler.
 Örneğin, _Termux_ <kbd>Ctrl</kbd>+<kbd>c</kbd> ile kopyalama yerine
 SIGINT sinyali gönderir, _K-9 Mail_ ise yeni mesaj oluşturur.
 Bu tip durumlarda kopyalama, kesme ve yapıştırma için (Android versiyon 7 ve
 üstü):
 - <kbd>MOD</kbd>+<kbd>c</kbd> `KOPYALA`
 - <kbd>MOD</kbd>+<kbd>x</kbd> `KES`
 - <kbd>MOD</kbd>+<kbd>v</kbd> `YAPIŞTIR` (bilgisayar ve cihaz arasındaki
  pano senkronizasyonundan sonra)
 Bunlara ek olarak, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> tuşları
 bilgisayar pano içeriğini tuş basma eylemleri şeklinde gönderir. Bu metin
 yapıştırmayı desteklemeyen (_Termux_ gibi) uygulamar için kullanışlıdır,
 ancak ASCII olmayan içerikleri bozabilir.
 **UYARI:** Bilgisayar pano içeriğini cihaza yapıştırmak
 (<kbd>Ctrl</kbd>+<kbd>v</kbd> ya da <kbd>MOD</kbd>+<kbd>v</kbd> tuşları ile)
 içeriği cihaz panosuna kopyalar. Sonuç olarak, herhangi bir Android uygulaması
 içeriğe erişebilir. Hassas içerikler (parolalar gibi) için bu özelliği kullanmaktan
 kaçının.
 Bazı cihazlar pano değişikleri konusunda beklenilen şekilde çalışmayabilir.
 Bu durumlarda `--legacy-paste` argümanı kullanılabilir. Bu sayede
 <kbd>Ctrl</kbd>+<kbd>v</kbd> ve <kbd>MOD</kbd>+<kbd>v</kbd> tuşları da
 pano içeriğini tuş basma eylemleri şeklinde gönderir
 (<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> ile aynı şekilde).
 #### İki parmak ile yakınlaştırma
 "İki parmak ile yakınlaştırma" için: <kbd>Ctrl</kbd>+_tıkla-ve-sürükle_.
 Daha açıklayıcı şekilde, <kbd>Ctrl</kbd> tuşuna sol-tık ile birlikte basılı
 tutun. Sol-tık serbest bırakılıncaya kadar yapılan tüm fare hareketleri
 ekran içeriğini ekranın merkezini baz alarak dönderir, büyütür veya küçültür
 (eğer uygulama destekliyorsa).
 Scrcpy ekranın merkezinde bir "sanal parmak" varmış gibi davranır.
 #### Metin gönderme tercihi
 Metin girilirken ili çeşit [eylem][textevents] gerçekleştirilir:
 - _tuş eylemleri_, bir tuşa basıldığı sinyalini verir;
 - _metin eylemleri_, bir metin girildiği sinyalini verir.
 Varsayılan olarak, harfler tuş eylemleri kullanılarak gönderilir. Bu sayede
 klavye oyunlarda beklenilene uygun olarak çalışır (Genelde WASD tuşları).
 Ancak bu [bazı problemlere][prefertext] yol açabilir. Eğer bu problemler ile
 karşılaşırsanız metin eylemlerini tercih edebilirsiniz:
 ```bash
 scrcpy --prefer-text
 ```
 (Ama bu oyunlardaki klavye davranışlarını bozacaktır)
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 #### Tuş tekrarı
 Varsayılan olarak, bir tuşa basılı tutmak tuş eylemini tekrarlar. Bu durum
 bazı oyunlarda problemlere yol açabilir.
 Tuş eylemlerinin tekrarını kapatmak için:
 ```bash
 scrcpy --no-key-repeat
 ```
 #### Sağ-tık ve Orta-tık
 Varsayılan olarak, sağ-tık GERİ (ya da GÜÇ açma) eylemlerini, orta-tık ise
 ANA EKRAN eylemini tetikler. Bu kısayolları devre dışı bırakmak için:
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### Dosya bırakma
 #### APK kurulumu
 APK kurmak için, bilgisayarınızdaki APK dosyasını (`.apk` ile biten) _scrcpy_
 penceresine sürükleyip bırakın.
 Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır.
 #### Dosyayı cihaza gönderme
 Bir dosyayı cihazdaki `/sdcard/Download/` dizinine atmak için, (APK olmayan)
 bir dosyayı _scrcpy_ penceresine sürükleyip bırakın.
 Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır.
 Hedef dizin uygulama başlatılırken değiştirilebilir:
 ```bash
 scrcpy --push-target=/sdcard/Movies/
 ```
 ### Ses iletimi
 _Scrcpy_ ses iletimi yapmaz. Yerine [sndcpy] kullanabilirsiniz.
 Ayrıca bakınız [issue #14].
 [sndcpy]: https://github.com/rom1v/sndcpy
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## Kısayollar
 Aşağıdaki listede, <kbd>MOD</kbd> kısayol tamamlayıcısıdır. Varsayılan olarak
 (sol) <kbd>Alt</kbd> veya (sol) <kbd>Super</kbd> tuşudur.
 Bu tuş `--shortcut-mod` argümanı kullanılarak `lctrl`, `rctrl`,
 `lalt`, `ralt`, `lsuper` ve `rsuper` tuşlarından biri ile değiştirilebilir.
 Örneğin:
 ```bash
 # Sağ Ctrl kullanmak için
 scrcpy --shortcut-mod=rctrl
 # Sol Ctrl, Sol Alt veya Sol Super tuşlarından birini kullanmak için
 scrcpy --shortcut-mod=lctrl+lalt,lsuper
 ```
 _<kbd>[Super]</kbd> tuşu genelde <kbd>Windows</kbd> veya <kbd>Cmd</kbd> tuşudur._
 [super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
 | Action                                           | Shortcut                                                  |
 | ------------------------------------------------ | :-------------------------------------------------------- |
 | Tam ekran modunu değiştirme                      | <kbd>MOD</kbd>+<kbd>f</kbd>                               |
 | Ekranı sola çevirme                              | <kbd>MOD</kbd>+<kbd>←</kbd> _(sol)_                       |
 | Ekranı sağa çevirme                              | <kbd>MOD</kbd>+<kbd>→</kbd> _(sağ)_                       |
 | Pencereyi 1:1 oranına çevirme (pixel-perfect)    | <kbd>MOD</kbd>+<kbd>g</kbd>                               |
 | Penceredeki siyah kenarlıkları kaldırma          | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Çift-sol-tık¹_            |
 | `ANA EKRAN` tuşu                                 | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Orta-tık_                 |
 | `GERİ` tuşu                                      | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Sağ-tık²_                 |
 | `UYGULAMA_DEĞİŞTİR` tuşu                         | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4.tık³_                   |
 | `MENÜ` tuşu (ekran kilidini açma)                | <kbd>MOD</kbd>+<kbd>m</kbd>                               |
 | `SES_AÇ` tuşu                                    | <kbd>MOD</kbd>+<kbd>↑</kbd> _(yukarı)_                    |
 | `SES_KIS` tuşu                                   | <kbd>MOD</kbd>+<kbd>↓</kbd> _(aşağı)_                     |
 | `GÜÇ` tuşu                                       | <kbd>MOD</kbd>+<kbd>p</kbd>                               |
 | Gücü açma                                        | _Sağ-tık²_                                                |
 | Cihaz ekranını kapatma (ekran yakalama durmadan) | <kbd>MOD</kbd>+<kbd>o</kbd>                               |
 | Cihaz ekranını açma                              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>              |
 | Cihaz ekranını dönderme                          | <kbd>MOD</kbd>+<kbd>r</kbd>                               |
 | Bildirim panelini genişletme                     | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5.tık³_                   |
 | Ayarlar panelini genişletme                      | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Çift-5.tık³_ |
 | Panelleri kapatma                                | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>              |
 | Panoya kopyalama⁴                                | <kbd>MOD</kbd>+<kbd>c</kbd>                               |
 | Panoya kesme⁴                                    | <kbd>MOD</kbd>+<kbd>x</kbd>                               |
 | Panoları senkronize ederek yapıştırma⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>                               |
 | Bilgisayar panosundaki metini girme              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>              |
 | FPS sayacını açma/kapatma (terminalde)           | <kbd>MOD</kbd>+<kbd>i</kbd>                               |
 | İki parmakla yakınlaştırma                       | <kbd>Ctrl</kbd>+_tıkla-ve-sürükle_                        |
 _¹Siyah kenarlıkları silmek için üzerine çift tıklayın._  
 _²Sağ-tık ekran kapalıysa açar, değilse GERİ sinyali gönderir._  
 _³4. ve 5. fare tuşları (eğer varsa)._  
 _⁴Sadece Android 7 ve üzeri versiyonlarda._
 Tekrarlı tuşu olan kısayollar tuş bırakılıp tekrar basılarak tekrar çalıştırılır.
 Örneğin, "Ayarlar panelini genişletmek" için:
 1.  <kbd>MOD</kbd> tuşuna basın ve basılı tutun.
 2.  <kbd>n</kbd> tuşuna iki defa basın.
 3.  <kbd>MOD</kbd> tuşuna basmayı bırakın.
 Tüm <kbd>Ctrl</kbd>+_tuş_ kısayolları cihaza gönderilir. Bu sayede istenilen komut
 uygulama tarafından çalıştırılır.
 ## Özel dizinler
 Varsayılandan farklı bir _adb_ programı çalıştırmak için `ADB` ortam değişkenini
 ayarlayın:
 ```bash
 ADB=/path/to/adb scrcpy
 ```
 `scrcpy-server` programının dizinini değiştirmek için `SCRCPY_SERVER_PATH`
 değişkenini ayarlayın.
 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## Neden _scrcpy_?
 Bir meslektaşım [gnirehtet] gibi söylenmesi zor bir isim bulmam için bana meydan okudu.
 [`strcpy`] **str**ing kopyalıyor; `scrcpy` **scr**een kopyalıyor.
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## Nasıl derlenir?
 Bakınız [BUILD].
 ## Yaygın problemler
 Bakınız [FAQ](FAQ.md).
 ## Geliştiriciler
 [Geliştiriciler sayfası]nı okuyun.
 [geliştiriciler sayfası]: DEVELOP.md
 ## Lisans
    Copyright (C) 2018 Genymobile
    Copyright (C) 2018-2022 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## Makaleler
 - [Introducing scrcpy][article-intro]
 - [Scrcpy now works wirelessly][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.zh-Hans.md
+++ b/README.zh-Hans.md
@ -1,993 +0,0 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._
 _只有原版的 [README](README.md)是保证最新的。_
 Current version is based on [f4c7044]
 本文根据[f4c7044]进行翻译。
 [f4c7044]: https://github.com/Genymobile/scrcpy/blob/f4c7044b46ae28eb64cb5e1a15c9649a44023c70/README.md
 # scrcpy (v1.22)
 <img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
 _发音为 "**scr**een **c**o**py**"_
 本应用程序可以显示并控制通过 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)
 - [物理鼠标模拟 (HID)](#物理鼠标模拟-hid) (仅限 Linux)
 - [OTG模式](#otg) (仅限 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 和 Ubuntu 上：
 ```
 apt install scrcpy
 ```
 在 Arch Linux 上:
 ```
 pacman -S 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/
 对 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 毫秒的缓冲
 ```
 ### 连接
 #### TCP/IP （无线）
 _Scrcpy_ 使用 `adb` 与设备通信，并且 `adb` 支持通过 TCP/IP [连接]到设备（设备必须连接与电脑相同的网络）。
 ##### 自动配置
 参数 `--tcpip` 允许自动配置连接。这里有两种方式。
 对于传入的 adb 连接，如果设备（在这个例子中以192.168.1.1为可用地址）已经监听了一个端口（通常是5555），运行：
 ```bash
 scrcpy --tcpip=192.168.1.1       # 默认端口是5555
 scrcpy --tcpip=192.168.1.1:5555
 ```
 如果adb TCP/IP（无线） 模式在某些设备上不被启用（或者你不知道IP地址），用USB连接设备，然后运行：
 ```bash
 scrcpy --tcpip    # 无需其他参数
 ```
 这将会自动寻找设备IP地址，启用TCP/IP模式，然后在启动之前连接到设备。
 ##### 手动配置
 或者，可以通过 `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
 #### 隧道
 要远程连接到设备，可以将本地的 adb 客户端连接到远程的 adb 服务端 (需要两端的 _adb_ 协议版本相同)。
 ##### 远程ADB服务器
 要连接到一个远程ADB服务器，让服务器在所有接口上监听：
 ```bash
 adb kill-server
 adb -a nodaemon server start
 # 保持该窗口开启
 ```
 **警告：所有客户端与ADB服务器的交流都是未加密的。**
 假设此服务器可在 192.168.1.2 访问。 然后，从另一个终端，运行 scrcpy：
 ```bash
 export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
 scrcpy --tunnel-host=192.168.1.2
 ```
 默认情况下，scrcpy使用用于 `adb forward` 隧道建立的本地端口（通常是 `27183`，见 `--port` ）。它也可以强制使用一个不同的隧道端口（当涉及更多的重定向时，这在更复杂的情况下可能很有用）:
 ```
 scrcpy --tunnel-port=1234
 ```
 ##### SSH 隧道
 为了安全地与远程ADB服务器通信，最好使用SSH隧道。
 首先，确保ADB服务器正在远程计算机上运行：
 ```bash
 adb start-server
 ```
 然后，建立一个SSH隧道：
 ```bash
 # 本地  5038 --> 远程  5037
 # 本地 27183 <-- 远程 27183
 ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # 保持该窗口开启
 ```
 在另一个终端上，运行scrcpy：
 ```bash
 export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
 若要不使用远程端口转发，可以强制使用正向连接（注意是 `-L` 而不是 `-R` ）：
 ```bash
 # 本地  5038 --> 远程  5037
 # 本地 27183 <-- 远程 27183
 ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # 保持该窗口开启
 ```
 在另一个终端上，运行scrcpy：
 ```bash
 export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
 类似地，对于无线连接，可能需要降低画面质量：
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### 窗口设置
 #### 标题
 窗口的标题默认为设备型号。可以通过如下命令修改：
 ```bash
 scrcpy --window-title "我的设备"
 ```
 #### 位置和大小
 您可以指定初始的窗口位置和大小：
 ```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>) 来注入电脑剪贴板内容。
 要禁用自动剪贴板同步功能，使用`--no-clipboard-autosync`。
 #### 双指缩放
 模拟“双指缩放”：<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 设备上进行配置，具体为 设置 → 系统 → 语言和输入法 → [实体键盘]。
 [实体键盘]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
 #### 物理鼠标模拟 (HID)
 与物理键盘模拟类似，可以模拟一个物理鼠标。 同样，它仅在设备通过 USB 连接时才有效，并且目前仅在 Linux 上受支持。
 默认情况下，scrcpy 使用 Android 鼠标事件注入，使用绝对坐标。 通过模拟物理鼠标，在Android设备上出现鼠标指针，并注入鼠标相对运动、点击和滚动。
 启用此模式:
 ```bash
 scrcpy --hid-mouse
 scrcpy -M  # 简写
 ```
 您还可以将 `--forward-all-clicks` 添加到 [转发所有点击][forward_all_clicks].
 [forward_all_clicks]: #右键和中键
 启用此模式后，计算机鼠标将被“捕获”（鼠标指针从计算机上消失并出现在 Android 设备上）。
 特殊的捕获键，<kbd>Alt</kbd> 或 <kbd>Super</kbd>，切换（禁用或启用）鼠标捕获。 使用其中之一将鼠标的控制权交还给计算机。
 #### OTG
 可以仅使用物理键盘和鼠标模拟 (HID) 运行 _scrcpy_，就好像计算机键盘和鼠标通过 OTG 线直接插入设备一样。
 在这个模式下，_adb_ (USB 调试)是不必要的，且镜像被禁用。
 启用 OTG 模式:
 ```bash
 scrcpy --otg
 # 如果有多个 USB 设备可用，则通过序列号选择
 scrcpy --otg -s 0123456789abcdef
 ```
 只开启 HID 键盘 或 HID 鼠标 是可行的：
 ```bash
 scrcpy --otg --hid-keyboard              # 只开启 HID 键盘
 scrcpy --otg --hid-mouse                 # 只开启 HID 鼠标
 scrcpy --otg --hid-keyboard --hid-mouse  # 开启 HID 键盘 和 HID 鼠标
 # 为了方便，默认两者都开启
 scrcpy --otg                             # 开启 HID 键盘 和 HID 鼠标
 ```
 像 `--hid-keyboard` 和 `--hid-mouse` 一样，它只在设备通过 USB 连接时才有效，且目前仅在 Linux 上支持。
 #### 文本注入偏好
 输入文字的时候，系统会产生两种[事件][textevents]：
 - _按键事件_ ，代表一个按键被按下或松开。
 - _文本事件_ ，代表一个字符被输入。
 程序默认使用按键事件来输入字母。只有这样，键盘才会在游戏中正常运作 (例如 WASD 键)。
 但这也有可能[造成一些问题][prefertext]。如果您遇到了问题，可以通过以下方式避免：
 ```bash
 scrcpy --prefer-text
 ```
 (但这会导致键盘在游戏中工作不正常)
 相反，您可以强制始终注入原始按键事件：
 ```bash
 scrcpy --raw-key-events
 ```
 该选项不影响 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键。_  
 _⁴对于开发中的 react-native 应用程序，`MENU` 触发开发菜单。_  
 _⁵需要安卓版本 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-2022 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## 相关文章
 - [Introducing scrcpy][article-intro]
 - [Scrcpy now works wirelessly][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.zh-Hant.md
+++ b/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-2022 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## 相關文章
 - [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/
--- a/app/data/bash-completion/scrcpy
+++ b/app/data/bash-completion/scrcpy
@ -93,6 +93,11 @@ _scrcpy() {
            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
            ;;
        -b|--bitrate \
        |--codec-options \
        |--crop \
@ -103,7 +108,6 @@ _scrcpy() {
        |-m|--max-size \
        |-p|--port \
        |--push-target \
        |-s|--serial \
        |--tunnel-host \
        |--tunnel-port \
        |--v4l2-buffer \
--- a/app/data/zsh-completion/_scrcpy
+++ b/app/data/zsh-completion/_scrcpy
@ -47,7 +47,7 @@ arguments=(
    '--record-format=[Force recording format]:format:(mp4 mkv)'
    '--render-driver=[Request SDL to use the given render driver]:driver name:(direct3d opengl opengles2 opengles metal software)'
    '--rotation=[Set the initial display rotation]:rotation values:(0 1 2 3)'
-    {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]'
+    {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]:serial:($("${ADB-adb}" devices | awk '\''$2 == "device" {print $1}'\''))'
    '--shortcut-mod=[\[key1,key2+key3,...\] Specify the modifiers to use for scrcpy shortcuts]:shortcut mod:(lctrl rctrl lalt ralt lsuper rsuper)'
    {-S,--turn-screen-off}'[Turn the device screen off immediately]'
    {-t,--show-touches}'[Show physical touches]'
--- a/app/meson.build
+++ b/app/meson.build
@ -37,6 +37,7 @@ src = [
    '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',
@ -170,6 +171,8 @@ check_functions = [
    'strdup',
    'asprintf',
    'vasprintf',
    'nrand48',
    'jrand48',
 ]
 foreach f : check_functions
@ -267,6 +270,7 @@ if get_option('buildtype') == 'debug'
            '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',
--- a/app/prebuilt-deps/prepare-adb.sh
+++ b/app/prebuilt-deps/prepare-adb.sh
@ -6,10 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
-DEP_DIR=platform-tools-33.0.1
+DEP_DIR=platform-tools-33.0.3
-FILENAME=platform-tools_r33.0.1-windows.zip
+FILENAME=platform-tools_r33.0.3-windows.zip
-SHA256SUM=c1f02d42ea24ef4ff2a405ae7370e764ef4546f9b3e4520f5571a00ed5012c42
+SHA256SUM=1e59afd40a74c5c0eab0a9fad3f0faf8a674267106e0b19921be9f67081808c2
 if [[ -d "$DEP_DIR" ]]
 then
--- a/app/prebuilt-deps/prepare-ffmpeg-win64.sh
+++ b/app/prebuilt-deps/prepare-ffmpeg-win64.sh
@ -6,11 +6,11 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
-VERSION=5.0.1
+VERSION=5.1.2
 DEP_DIR=ffmpeg-win64-$VERSION
 FILENAME=ffmpeg-$VERSION-full_build-shared.7z
-SHA256SUM=ded28435b6f04b74f5ef5a6a13761233bce9e8e9f8ecb0eabe936fd36a778b0c
+SHA256SUM=d9eb97b72d7cfdae4d0f7eaea59ccffb8c364d67d88018ea715d5e2e193f00e9
 if [[ -d "$DEP_DIR" ]]
 then
--- a/app/prebuilt-deps/prepare-sdl.sh
+++ b/app/prebuilt-deps/prepare-sdl.sh
@ -6,10 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
-DEP_DIR=SDL2-2.0.22
+DEP_DIR=SDL2-2.26.1
-FILENAME=SDL2-devel-2.0.22-mingw.tar.gz
+FILENAME=SDL2-devel-2.26.1-mingw.tar.gz
-SHA256SUM=0e91e35973366aa1e6f81ee368924d9b4f93f9da4d2f2a89ec80b06eadcf23d1
+SHA256SUM=aa43e1531a89551f9f9e14b27953a81d4ac946a9e574b5813cd0f2b36e83cc1c
 if [[ -d "$DEP_DIR" ]]
 then
--- a/app/scrcpy-windows.rc
+++ b/app/scrcpy-windows.rc
@ -13,7 +13,7 @@ BEGIN
      VALUE "LegalCopyright", "Romain Vimont, Genymobile"
      VALUE "OriginalFilename", "scrcpy.exe"
      VALUE "ProductName", "scrcpy"
-      VALUE "ProductVersion", "1.24"
+      VALUE "ProductVersion", "1.25"
    END
  END
  BLOCK "VarFileInfo"
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -26,7 +26,11 @@ Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are
 Default is 8000000.
 .TP
-.BI "\-\-codec\-options " key[:type]=value[,...]
+.BI "\-\-codec " name
 Select a video codec (h264, h265 or av1).
 .TP
 .BI "\-\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
 Set a list of comma-separated key:type=value options for the device encoder.
 The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
@ -117,7 +121,7 @@ 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]
+\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".
@ -199,7 +203,7 @@ It may only work over USB.
 See \fB\-\-hid\-keyboard\fR and \fB\-\-hid\-mouse\fR.
 .TP
-.BI "\-p, \-\-port " port[:port]
+.BI "\-p, \-\-port " port\fR[:\fIport\fR]
 Set the TCP port (range) used by the client to listen.
 Default is 27183:27199.
@ -260,7 +264,7 @@ 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[+...]][,...]
+.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 ','.
@ -270,12 +274,12 @@ 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]]
+.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 of the current device (typically connected over USB), enables TCP/IP mode, then connects to this address before starting.
+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
 .B \-S, \-\-turn\-screen\-off
--- a/app/src/adb/adb_tunnel.c
+++ b/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 (!sc_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 (!sc_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,13 @@ 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 (sc_adb_forward(intr, serial, port, SC_SOCKET_NAME,
+        if (sc_adb_forward(intr, serial, port, device_socket_name,
                           SC_ADB_NO_STDOUT)) {
            // success
            tunnel->local_port = port;
@ -123,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,
+                   const char *serial, const char *device_socket_name,
-                   bool force_adb_forward) {
+                   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;
        }
@ -139,12 +140,13 @@ 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;
@ -152,7 +154,7 @@ sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
        ret = sc_adb_forward_remove(intr, serial, tunnel->local_port,
                                    SC_ADB_NO_STDOUT);
    } else {
-        ret = sc_adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+        ret = sc_adb_reverse_remove(intr, serial, device_socket_name,
                                    SC_ADB_NO_STDOUT);
        assert(tunnel->server_socket != SC_SOCKET_NONE);
--- a/app/src/adb/adb_tunnel.h
+++ b/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,
+                   const char *serial, const char *device_socket_name,
-                   bool force_adb_forward);
+                   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
--- a/app/src/cli.c
+++ b/app/src/cli.c
@ -57,6 +57,7 @@
 #define OPT_NO_CLEANUP             1037
 #define OPT_PRINT_FPS              1038
 #define OPT_NO_POWER_ON            1039
 #define OPT_CODEC                  1040
 struct sc_option {
    char shortopt;
@ -105,6 +106,12 @@ static const struct sc_option options[] = {
                "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
                "Default is " STR(DEFAULT_BIT_RATE) ".",
    },
    {
        .longopt_id = OPT_CODEC,
        .longopt = "codec",
        .argdesc = "name",
        .text = "Select a video codec (h264, h265 or av1).",
    },
    {
        .longopt_id = OPT_CODEC_OPTIONS,
        .longopt = "codec-options",
@ -1377,6 +1384,24 @@ guess_record_format(const char *filename) {
    return 0;
 }
 static bool
 parse_codec(const char *optarg, enum sc_codec *codec) {
    if (!strcmp(optarg, "h264")) {
        *codec = SC_CODEC_H264;
        return true;
    }
    if (!strcmp(optarg, "h265")) {
        *codec = SC_CODEC_H265;
        return true;
    }
    if (!strcmp(optarg, "av1")) {
        *codec = SC_CODEC_AV1;
        return true;
    }
    LOGE("Unsupported codec: %s (expected h264, h265 or av1)", optarg);
    return false;
 }
 static bool
 parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                       const char *optstring, const struct option *longopts) {
@ -1610,6 +1635,11 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
            case OPT_PRINT_FPS:
                opts->start_fps_counter = true;
                break;
            case OPT_CODEC:
                if (!parse_codec(optarg, &opts->codec)) {
                    return false;
                }
                break;
            case OPT_OTG:
 #ifdef HAVE_USB
                opts->otg = true;
@ -1718,6 +1748,13 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
        }
    }
    if (opts->record_format == SC_RECORD_FORMAT_MP4
            && opts->codec == SC_CODEC_AV1) {
        LOGE("Could not mux AV1 stream into MP4 container "
             "(record to mkv or select another video codec)");
        return false;
    }
    if (!opts->control) {
        if (opts->turn_screen_off) {
            LOGE("Could not request to turn screen off if control is disabled");
--- a/app/src/compat.c
+++ b/app/src/compat.c
@ -51,3 +51,47 @@ 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
--- a/app/src/compat.h
+++ b/app/src/compat.h
@ -59,4 +59,12 @@ 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
 #endif
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@ -61,6 +61,22 @@ 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) {
    sc_write32be(&buf[0], position->point.x);
@ -101,8 +117,9 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
            uint16_t pressure =
                sc_float_to_u16fp(msg->inject_touch_event.pressure);
            sc_write16be(&buf[22], pressure);
-            sc_write32be(&buf[24], msg->inject_touch_event.buttons);
+            sc_write32be(&buf[24], msg->inject_touch_event.action_button);
-            return 28;
+            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);
            int16_t hscroll =
@ -159,25 +176,29 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
            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=%f buttons=%06lx",
+                             " pressure=%f action_button=%06lx buttons=%06lx",
-                         id == POINTER_ID_MOUSE ? "mouse" : "vfinger",
+                         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=%f 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;
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@ -18,7 +18,11 @@
 #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)
 // 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,
@ -61,6 +65,7 @@ struct sc_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;
--- a/app/src/demuxer.c
+++ b/app/src/demuxer.c
@ -17,6 +17,31 @@
 #define SC_PACKET_PTS_MASK (SC_PACKET_FLAG_KEY_FRAME - 1)
 static enum AVCodecID
 sc_demuxer_recv_codec_id(struct sc_demuxer *demuxer) {
    uint8_t data[4];
    ssize_t r = net_recv_all(demuxer->socket, data, 4);
    if (r < 4) {
        return false;
    }
 #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
    uint32_t codec_id = sc_read32be(data);
    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:
            return AV_CODEC_ID_AV1;
        default:
            LOGE("Unknown codec id 0x%08" PRIx32, codec_id);
            return AV_CODEC_ID_NONE;
    }
 }
 static bool
 sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
    // The video stream contains raw packets, without time information. When we
@ -95,29 +120,27 @@ sc_demuxer_push_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
    // A config packet must not be decoded immediately (it contains no
    // frame); instead, it must be concatenated with the future data packet.
    if (demuxer->pending || is_config) {
        size_t offset;
        if (demuxer->pending) {
-            offset = demuxer->pending->size;
+            size_t offset = demuxer->pending->size;
            if (av_grow_packet(demuxer->pending, packet->size)) {
                LOG_OOM();
                return false;
            }
            memcpy(demuxer->pending->data + offset, packet->data, packet->size);
        } else {
            offset = 0;
            demuxer->pending = av_packet_alloc();
            if (!demuxer->pending) {
                LOG_OOM();
                return false;
            }
-            if (av_new_packet(demuxer->pending, packet->size)) {
+            if (av_packet_ref(demuxer->pending, packet)) {
                LOG_OOM();
                av_packet_free(&demuxer->pending);
                return false;
            }
        }
        memcpy(demuxer->pending->data + offset, packet->data, packet->size);
        if (!is_config) {
            // prepare the concat packet to send to the decoder
            demuxer->pending->pts = packet->pts;
@ -173,7 +196,13 @@ static int
 run_demuxer(void *data) {
    struct sc_demuxer *demuxer = data;
-    const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
+    enum AVCodecID codec_id = sc_demuxer_recv_codec_id(demuxer);
    if (codec_id == AV_CODEC_ID_NONE) {
        // Error already logged
        goto end;
    }
    const AVCodec *codec = avcodec_find_decoder(codec_id);
    if (!codec) {
        LOGE("H.264 decoder not found");
        goto end;
@ -190,7 +219,7 @@ run_demuxer(void *data) {
        goto finally_free_codec_ctx;
    }
-    demuxer->parser = av_parser_init(AV_CODEC_ID_H264);
+    demuxer->parser = av_parser_init(codec_id);
    if (!demuxer->parser) {
        LOGE("Could not initialize parser");
        goto finally_close_sinks;
--- a/app/src/input_events.h
+++ b/app/src/input_events.h
@ -353,6 +353,7 @@ 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
 };
@ -365,6 +366,7 @@ struct sc_mouse_scroll_event {
 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
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -335,8 +335,11 @@ simulate_virtual_finger(struct sc_input_manager *im,
    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 (!sc_controller_push_msg(im->controller, &msg)) {
@ -564,6 +567,8 @@ sc_input_manager_process_mouse_motion(struct sc_input_manager *im,
                                                              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 =
@ -687,6 +692,8 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
        },
        .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),
--- a/app/src/main.c
+++ b/app/src/main.c
@ -4,6 +4,10 @@
 #include <stdbool.h>
 #include <unistd.h>
 #include <libavformat/avformat.h>
 #ifdef _WIN32
 #include <windows.h>
 #include "util/str.h"
 #endif
 #ifdef HAVE_V4L2
 # include <libavdevice/avdevice.h>
 #endif
@ -18,8 +22,8 @@
 #include "version.h"
 int
-main(int argc, char *argv[]) {
+main_scrcpy(int argc, char *argv[]) {
-#ifdef __WINDOWS__
+#ifdef _WIN32
    // disable buffering, we want logs immediately
    // even line buffering (setvbuf() with mode _IOLBF) is not sufficient
    setbuf(stdout, NULL);
@ -80,3 +84,52 @@ main(int argc, char *argv[]) {
    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
 }
--- a/app/src/mouse_inject.c
+++ b/app/src/mouse_inject.c
@ -69,7 +69,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
        .inject_touch_event = {
            .action = AMOTION_EVENT_ACTION_MOVE,
-            .pointer_id = POINTER_ID_MOUSE,
+            .pointer_id = event->pointer_id,
            .position = event->position,
            .pressure = 1.f,
            .buttons = convert_mouse_buttons(event->buttons_state),
@ -90,9 +90,10 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
        .inject_touch_event = {
            .action = convert_mouse_action(event->action),
-            .pointer_id = POINTER_ID_MOUSE,
+            .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),
        },
    };
--- a/app/src/options.c
+++ b/app/src/options.c
@ -13,6 +13,7 @@ const struct scrcpy_options scrcpy_options_default = {
    .v4l2_device = NULL,
 #endif
    .log_level = SC_LOG_LEVEL_INFO,
    .codec = SC_CODEC_H264,
    .record_format = SC_RECORD_FORMAT_AUTO,
    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
    .port_range = {
--- a/app/src/options.h
+++ b/app/src/options.h
@ -23,6 +23,12 @@ enum sc_record_format {
    SC_RECORD_FORMAT_MKV,
 };
 enum sc_codec {
    SC_CODEC_H264,
    SC_CODEC_H265,
    SC_CODEC_AV1,
 };
 enum sc_lock_video_orientation {
    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
    // lock the current orientation when scrcpy starts
@ -93,6 +99,7 @@ struct scrcpy_options {
    const char *v4l2_device;
 #endif
    enum sc_log_level log_level;
    enum sc_codec codec;
    enum sc_record_format record_format;
    enum sc_keyboard_input_mode keyboard_input_mode;
    enum sc_mouse_input_mode mouse_input_mode;
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@ -11,6 +11,8 @@
 /** Downcast packet_sink to recorder */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_recorder, packet_sink)
 #define SC_PTS_ORIGIN_NONE UINT64_C(-1)
 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
 static const AVOutputFormat *
@ -169,6 +171,18 @@ run_recorder(void *data) {
        sc_mutex_unlock(&recorder->mutex);
        if (recorder->pts_origin == SC_PTS_ORIGIN_NONE
                && rec->packet->pts != AV_NOPTS_VALUE) {
            // First PTS received
            recorder->pts_origin = rec->packet->pts;
        }
        if (rec->packet->pts != AV_NOPTS_VALUE) {
            // Set PTS relatve to the origin
            rec->packet->pts -= recorder->pts_origin;
            rec->packet->dts = rec->packet->pts;
        }
        // recorder->previous is only written from this thread, no need to lock
        struct sc_record_packet *previous = recorder->previous;
        recorder->previous = rec;
@ -243,6 +257,7 @@ sc_recorder_open(struct sc_recorder *recorder, const AVCodec *input_codec) {
    recorder->failed = false;
    recorder->header_written = false;
    recorder->previous = NULL;
    recorder->pts_origin = SC_PTS_ORIGIN_NONE;
    const char *format_name = sc_recorder_get_format_name(recorder->format);
    assert(format_name);
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@ -28,6 +28,8 @@ struct sc_recorder {
    struct sc_size declared_frame_size;
    bool header_written;
    uint64_t pts_origin;
    sc_thread thread;
    sc_mutex mutex;
    sc_cond queue_cond;
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -32,6 +32,7 @@
 #include "util/acksync.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/rand.h"
 #ifdef HAVE_V4L2
 # include "v4l2_sink.h"
 #endif
@ -265,6 +266,14 @@ sc_server_on_disconnected(struct sc_server *server, void *userdata) {
    // event
 }
 static uint32_t
 scrcpy_generate_uid() {
    struct sc_rand rand;
    sc_rand_init(&rand);
    // Only use 31 bits to avoid issues with signed values on the Java-side
    return sc_rand_u32(&rand) & 0x7FFFFFFF;
 }
 enum scrcpy_exit_code
 scrcpy(struct scrcpy_options *options) {
    static struct scrcpy scrcpy;
@ -298,11 +307,15 @@ scrcpy(struct scrcpy_options *options) {
    struct sc_acksync *acksync = NULL;
    uint32_t uid = scrcpy_generate_uid();
    struct sc_server_params params = {
        .uid = uid,
        .req_serial = options->serial,
        .select_usb = options->select_usb,
        .select_tcpip = options->select_tcpip,
        .log_level = options->log_level,
        .codec = options->codec,
        .crop = options->crop,
        .port_range = options->port_range,
        .tunnel_host = options->tunnel_host,
--- a/app/src/server.c
+++ b/app/src/server.c
@ -8,6 +8,7 @@
 #include <SDL2/SDL_platform.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__
@ -152,6 +156,20 @@ 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";
        default:
            return NULL;
    }
 }
 static sc_pid
 execute_server(struct sc_server *server,
               const struct sc_server_params *params) {
@ -195,9 +213,13 @@ execute_server(struct sc_server *server,
        cmd[count++] = p; \
    }
    ADD_PARAM("uid=%08x", params->uid);
    ADD_PARAM("log_level=%s", log_level_to_server_string(params->log_level));
    ADD_PARAM("bit_rate=%" PRIu32, params->bit_rate);
    if (params->codec != SC_CODEC_H264) {
        ADD_PARAM("codec=%s", sc_server_get_codec_name(params->codec));
    }
    if (params->max_size) {
        ADD_PARAM("max_size=%" PRIu16, params->max_size);
    }
@ -362,6 +384,7 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
    }
    server->serial = NULL;
    server->device_socket_name = NULL;
    server->stopped = false;
    server->video_socket = SC_SOCKET_NONE;
@ -393,10 +416,9 @@ 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)
+    unsigned char *fields = &buf[SC_DEVICE_NAME_FIELD_LENGTH];
-                           | buf[SC_DEVICE_NAME_FIELD_LENGTH + 1];
+    info->frame_size.width = sc_read16be(fields);
-    info->frame_size.height = (buf[SC_DEVICE_NAME_FIELD_LENGTH + 2] << 8)
+    info->frame_size.height = sc_read16be(&fields[2]);
                            | buf[SC_DEVICE_NAME_FIELD_LENGTH + 3];
    return true;
 }
@ -461,7 +483,8 @@ 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);
    // The sockets will be closed on stop if device_read_info() fails
    bool ok = device_read_info(&server->intr, video_socket, info);
@ -492,7 +515,8 @@ fail:
    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;
@ -513,27 +537,36 @@ sc_server_on_terminated(void *userdata) {
    LOGD("Server terminated");
 }
-static bool
+static uint16_t
-is_tcpip_mode_enabled(struct sc_server *server, const char *serial) {
+get_adb_tcp_port(struct sc_server *server, const char *serial) {
    struct sc_intr *intr = &server->intr;
    char *current_port =
        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?
+    long value;
-    bool enabled = !strcmp("5555", current_port);
+    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, const char *serial,
-                        unsigned attempts, sc_tick delay) {
+                        uint16_t expected_port, unsigned attempts,
-    if (is_tcpip_mode_enabled(server, serial)) {
+                        sc_tick delay) {
-        LOGI("TCP/IP mode enabled");
+    uint16_t adb_port = get_adb_tcp_port(server, serial);
    if (adb_port == expected_port) {
        return true;
    }
@ -547,28 +580,23 @@ wait_tcpip_mode_enabled(struct sc_server *server, const char *serial,
            return false;
        }
-        if (is_tcpip_mode_enabled(server, serial)) {
+        adb_port = get_adb_tcp_port(server, serial);
-            LOGI("TCP/IP mode enabled");
+        if (adb_port == expected_port) {
            return true;
        }
    } while (--attempts);
    return false;
 }
-char *
+static char *
-append_port_5555(const char *ip) {
+append_port(const char *ip, uint16_t port) {
-    size_t len = strlen(ip);
+    char *ip_port;
-
+    int ret = asprintf(&ip_port, "%s:%" PRIu16, ip, port);
-    // sizeof counts the final '\0'
+    if (ret == -1) {
    char *ip_port = malloc(len + sizeof(":5555"));
    if (!ip_port) {
        LOG_OOM();
        return NULL;
    }
    memcpy(ip_port, ip, len);
    memcpy(ip_port + len, ":5555", sizeof(":5555"));
    return ip_port;
 }
@ -586,34 +614,36 @@ sc_server_switch_to_tcpip(struct sc_server *server, const char *serial) {
        return NULL;
    }
-    char *ip_port = append_port_5555(ip);
+    uint16_t adb_port = get_adb_tcp_port(server, serial);
-    free(ip);
+    if (adb_port) {
-    if (!ip_port) {
+        LOGI("TCP/IP mode already enabled on port %" PRIu16, adb_port);
-        return NULL;
+    } else {
-    }
+        LOGI("Enabling TCP/IP mode on port " SC_STR(SC_ADB_PORT_DEFAULT) "...");
-    bool tcp_mode = is_tcpip_mode_enabled(server, serial);
+        bool ok = sc_adb_tcpip(intr, serial, SC_ADB_PORT_DEFAULT,
-
+                               SC_ADB_NO_STDOUT);
    if (!tcp_mode) {
        bool ok = sc_adb_tcpip(intr, serial, 5555, 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, serial, attempts, delay);
+        ok = wait_tcpip_mode_enabled(server, serial, SC_ADB_PORT_DEFAULT,
                                     attempts, delay);
        if (!ok) {
-            goto error;
+            free(ip);
        }
    }
    return ip_port;
 error:
    free(ip_port);
            return NULL;
        }
        adb_port = SC_ADB_PORT_DEFAULT;
        LOGI("TCP/IP mode enabled on port " SC_STR(SC_ADB_PORT_DEFAULT));
    }
    char *ip_port = append_port(ip, adb_port);
    free(ip);
    return ip_port;
 }
 static bool
@ -640,7 +670,8 @@ sc_server_configure_tcpip_known_address(struct sc_server *server,
                                        const char *addr) {
    // Append ":5555" if no port is present
    bool contains_port = strchr(addr, ':');
-    char *ip_port = contains_port ? strdup(addr) : append_port_5555(addr);
+    char *ip_port = contains_port ? strdup(addr)
                                  : append_port(addr, SC_ADB_PORT_DEFAULT);
    if (!ip_port) {
        LOG_OOM();
        return false;
@ -755,13 +786,23 @@ run_server(void *data) {
    assert(serial);
    LOGD("Device serial: %s", serial);
    int r = asprintf(&server->device_socket_name, SC_SOCKET_NAME_PREFIX "%08x",
                     params->uid);
    if (r == -1) {
        LOG_OOM();
        goto error_connection_failed;
    }
    assert(r == sizeof(SC_SOCKET_NAME_PREFIX) - 1 + 8);
    assert(server->device_socket_name);
    ok = push_server(&server->intr, serial);
    if (!ok) {
        goto error_connection_failed;
    }
    ok = sc_adb_tunnel_open(&server->tunnel, &server->intr, serial,
-                            params->port_range, params->force_adb_forward);
+                            server->device_socket_name, params->port_range,
                            params->force_adb_forward);
    if (!ok) {
        goto error_connection_failed;
    }
@ -769,7 +810,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, serial);
+        sc_adb_tunnel_close(&server->tunnel, &server->intr, serial,
                            server->device_socket_name);
        goto error_connection_failed;
    }
@ -781,7 +823,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, serial);
+        sc_adb_tunnel_close(&server->tunnel, &server->intr, serial,
                            server->device_socket_name);
        goto error_connection_failed;
    }
@ -875,6 +918,7 @@ sc_server_destroy(struct sc_server *server) {
    }
    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);
--- a/app/src/server.h
+++ b/app/src/server.h
@ -22,8 +22,10 @@ struct sc_server_info {
 };
 struct sc_server_params {
    uint32_t uid;
    const char *req_serial;
    enum sc_log_level log_level;
    enum sc_codec codec;
    const char *crop;
    const char *codec_options;
    const char *encoder_name;
@ -54,6 +56,7 @@ struct sc_server {
    // The internal allocated strings are copies owned by the server
    struct sc_server_params params;
    char *serial;
    char *device_socket_name;
    sc_thread thread;
    struct sc_server_info info; // initialized once connected
--- a/app/src/util/rand.c
+++ b/app/src/util/rand.c
@ -0,0 +1,24 @@
 #include "rand.h"
 #include <stdlib.h>
 #include "tick.h"
 void sc_rand_init(struct sc_rand *rand) {
    sc_tick seed = sc_tick_now(); // microsecond precision
    rand->xsubi[0] = (seed >> 32) & 0xFFFF;
    rand->xsubi[1] = (seed >> 16) & 0xFFFF;
    rand->xsubi[2] = seed & 0xFFFF;
 }
 uint32_t sc_rand_u32(struct sc_rand *rand) {
    // jrand returns a value in range [-2^31, 2^31]
    // conversion from signed to unsigned is well-defined to wrap-around
    return jrand48(rand->xsubi);
 }
 uint64_t sc_rand_u64(struct sc_rand *rand) {
    uint32_t msb = sc_rand_u32(rand);
    uint32_t lsb = sc_rand_u32(rand);
    return ((uint64_t) msb << 32) | lsb;
 }
--- a/app/src/util/rand.h
+++ b/app/src/util/rand.h
@ -0,0 +1,16 @@
 #ifndef SC_RAND_H
 #define SC_RAND_H
 #include "common.h"
 #include <inttypes.h>
 struct sc_rand {
    unsigned short xsubi[3];
 };
 void sc_rand_init(struct sc_rand *rand);
 uint32_t sc_rand_u32(struct sc_rand *rand);
 uint64_t sc_rand_u64(struct sc_rand *rand);
 #endif
--- a/app/src/util/str.h
+++ b/app/src/util/str.h
@ -6,6 +6,10 @@
 #include <stdbool.h>
 #include <stddef.h>
 /* Stringify a numeric value  */
 #define SC_STR(s) SC_XSTR(s)
 #define SC_XSTR(s) #s
 /**
 * Like strncpy(), except:
 *  - it copies at most n-1 chars
--- a/app/src/util/thread.c
+++ b/app/src/util/thread.c
@ -1,6 +1,7 @@
 #include "thread.h"
 #include <assert.h>
 #include <string.h>
 #include <SDL2/SDL_thread.h>
 #include "log.h"
--- a/app/src/util/vector.h
+++ b/app/src/util/vector.h
@ -6,6 +6,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 // Adapted from vlc_vector:
 // <https://code.videolan.org/videolan/vlc/-/blob/0857947abaed9c89810cd96353aaa1b7e6ba3b0d/include/vlc_vector.h>
--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@ -90,13 +90,14 @@ static void test_serialize_inject_touch_event(void) {
                },
            },
            .pressure = 1.0f,
            .action_button = AMOTION_EVENT_BUTTON_PRIMARY,
            .buttons = AMOTION_EVENT_BUTTON_PRIMARY,
        },
    };
    unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
    size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 28);
+    assert(size == 32);
    const unsigned char expected[] = {
        SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
@ -105,7 +106,8 @@ static void test_serialize_inject_touch_event(void) {
        0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0xc8, // 100 200
        0x04, 0x38, 0x07, 0x80, // 1080 1920
        0xff, 0xff, // pressure
-        0x00, 0x00, 0x00, 0x01 // AMOTION_EVENT_BUTTON_PRIMARY
+        0x00, 0x00, 0x00, 0x01, // AMOTION_EVENT_BUTTON_PRIMARY (action button)
        0x00, 0x00, 0x00, 0x01, // AMOTION_EVENT_BUTTON_PRIMARY (buttons)
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
--- a/cross_win32.txt
+++ b/cross_win32.txt
@ -20,6 +20,6 @@ ffmpeg_avcodec = 'avcodec-58'
 ffmpeg_avformat = 'avformat-58'
 ffmpeg_avutil = 'avutil-56'
 prebuilt_ffmpeg = 'ffmpeg-win32-4.3.1'
-prebuilt_sdl2 = 'SDL2-2.0.22/i686-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.26.1/i686-w64-mingw32'
 prebuilt_libusb_root = 'libusb-1.0.26'
-prebuilt_libusb = prebuilt_libusb_root + '/MinGW-Win32'
+prebuilt_libusb = 'libusb-1.0.26/MinGW-Win32'
--- a/cross_win64.txt
+++ b/cross_win64.txt
@ -19,7 +19,7 @@ endian = 'little'
 ffmpeg_avcodec = 'avcodec-59'
 ffmpeg_avformat = 'avformat-59'
 ffmpeg_avutil = 'avutil-57'
-prebuilt_ffmpeg = 'ffmpeg-win64-5.0.1'
+prebuilt_ffmpeg = 'ffmpeg-win64-5.1.2'
-prebuilt_sdl2 = 'SDL2-2.0.22/x86_64-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.26.1/x86_64-w64-mingw32'
 prebuilt_libusb_root = 'libusb-1.0.26'
-prebuilt_libusb = prebuilt_libusb_root + '/MinGW-x64'
+prebuilt_libusb = 'libusb-1.0.26/MinGW-x64'
--- a/install_release.sh
+++ b/install_release.sh
@ -2,8 +2,8 @@
 set -e
 BUILDDIR=build-auto
-PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-server-v1.24
+PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.25/scrcpy-server-v1.25
-PREBUILT_SERVER_SHA256=ae74a81ea79c0dc7250e586627c278c0a9a8c5de46c9fb5c38c167fb1a36f056
+PREBUILT_SERVER_SHA256=ce0306c7bbd06ae72f6d06f7ec0ee33774995a65de71e0a83813ecb67aec9bdb
 echo "[scrcpy] Downloading prebuilt server..."
 wget "$PREBUILT_SERVER_URL" -O scrcpy-server
@ -12,7 +12,7 @@ echo "$PREBUILT_SERVER_SHA256  scrcpy-server" | sha256sum --check
 echo "[scrcpy] Building client..."
 rm -rf "$BUILDDIR"
-meson "$BUILDDIR" --buildtype=release --strip -Db_lto=true \
+meson setup "$BUILDDIR" --buildtype=release --strip -Db_lto=true \
    -Dprebuilt_server=scrcpy-server
 cd "$BUILDDIR"
 ninja
--- a/meson.build
+++ b/meson.build
@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '1.24',
+        version: '1.25',
        meson_version: '>= 0.48',
        default_options: [
            'c_std=c11',
--- a/release.mk
+++ b/release.mk
@ -24,13 +24,13 @@ SERVER_BUILD_DIR := build-server
 WIN32_BUILD_DIR := build-win32
 WIN64_BUILD_DIR := build-win64
 DIST := dist
 WIN32_TARGET_DIR := scrcpy-win32
 WIN64_TARGET_DIR := scrcpy-win64
 VERSION := $(shell git describe --tags --always)
-WIN32_TARGET := $(WIN32_TARGET_DIR)-$(VERSION).zip
+
-WIN64_TARGET := $(WIN64_TARGET_DIR)-$(VERSION).zip
+DIST := dist
 WIN32_TARGET_DIR := scrcpy-win32-$(VERSION)
 WIN64_TARGET_DIR := scrcpy-win64-$(VERSION)
 WIN32_TARGET := $(WIN32_TARGET_DIR).zip
 WIN64_TARGET := $(WIN64_TARGET_DIR).zip
 RELEASE_DIR := release-$(VERSION)
@ -53,13 +53,13 @@ clean:
 test:
 	[ -d "$(TEST_BUILD_DIR)" ] || ( mkdir "$(TEST_BUILD_DIR)" && \
-		meson "$(TEST_BUILD_DIR)" -Db_sanitize=address )
+		meson setup "$(TEST_BUILD_DIR)" -Db_sanitize=address )
 	ninja -C "$(TEST_BUILD_DIR)"
 	$(GRADLE) -p server check
 build-server:
 	[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
-		meson "$(SERVER_BUILD_DIR)" --buildtype release -Dcompile_app=false )
+		meson setup "$(SERVER_BUILD_DIR)" --buildtype release -Dcompile_app=false )
 	ninja -C "$(SERVER_BUILD_DIR)"
 prepare-deps-win32:
@ -76,7 +76,7 @@ prepare-deps-win64:
 build-win32: prepare-deps-win32
 	[ -d "$(WIN32_BUILD_DIR)" ] || ( mkdir "$(WIN32_BUILD_DIR)" && \
-		meson "$(WIN32_BUILD_DIR)" \
+		meson setup "$(WIN32_BUILD_DIR)" \
 			--cross-file cross_win32.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcompile_server=false \
@ -85,7 +85,7 @@ build-win32: prepare-deps-win32
 build-win64: prepare-deps-win64
 	[ -d "$(WIN64_BUILD_DIR)" ] || ( mkdir "$(WIN64_BUILD_DIR)" && \
-		meson "$(WIN64_BUILD_DIR)" \
+		meson setup "$(WIN64_BUILD_DIR)" \
 			--cross-file cross_win64.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcompile_server=false \
@ -105,10 +105,10 @@ dist-win32: build-server build-win32
 	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/SDL2-2.0.22/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/SDL2-2.26.1/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/libusb-1.0.26/MinGW-Win32/msys-usb-1.0.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 dist-win64: build-server build-win64
@ -119,21 +119,21 @@ dist-win64: build-server build-win64
 	cp app/data/scrcpy-noconsole.vbs "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp app/data/icon.png "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp app/data/open_a_terminal_here.bat "$(DIST)/$(WIN64_TARGET_DIR)"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/avutil-57.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/avutil-57.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/avcodec-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/avcodec-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/avformat-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/avformat-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/swscale-6.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/swscale-6.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/SDL2-2.0.22/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/SDL2-2.26.1/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/libusb-1.0.26/MinGW-x64/msys-usb-1.0.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 zip-win32: dist-win32
-	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
+	cd "$(DIST)"; \
-		zip -r "../$(WIN32_TARGET)" .
+		zip -r "$(WIN32_TARGET)" "$(WIN32_TARGET_DIR)"
 zip-win64: dist-win64
-	cd "$(DIST)/$(WIN64_TARGET_DIR)"; \
+	cd "$(DIST)"; \
-		zip -r "../$(WIN64_TARGET)" .
+		zip -r "$(WIN64_TARGET)" "$(WIN64_TARGET_DIR)"
--- a/server/build.gradle
+++ b/server/build.gradle
@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 33
-        versionCode 12400
+        versionCode 12500
-        versionName "1.24"
+        versionName "1.25"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
@ -19,7 +19,7 @@ android {
 }
 dependencies {
-    testImplementation 'junit:junit:4.13.1'
+    testImplementation 'junit:junit:4.13.2'
 }
 apply from: "$project.rootDir/config/android-checkstyle.gradle"
--- a/server/build_without_gradle.sh
+++ b/server/build_without_gradle.sh
@ -12,7 +12,7 @@
 set -e
 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.24
+SCRCPY_VERSION_NAME=1.25
 PLATFORM=${ANDROID_PLATFORM:-33}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-33.0.0}
@ -20,18 +20,21 @@ BUILD_TOOLS_DIR="$ANDROID_HOME/build-tools/$BUILD_TOOLS"
 BUILD_DIR="$(realpath ${BUILD_DIR:-build_manual})"
 CLASSES_DIR="$BUILD_DIR/classes"
 GEN_DIR="$BUILD_DIR/gen"
 SERVER_DIR=$(dirname "$0")
 SERVER_BINARY=scrcpy-server
 ANDROID_JAR="$ANDROID_HOME/platforms/android-$PLATFORM/android.jar"
 LAMBDA_JAR="$BUILD_TOOLS_DIR/core-lambda-stubs.jar"
 echo "Platform: android-$PLATFORM"
 echo "Build-tools: $BUILD_TOOLS"
 echo "Build dir: $BUILD_DIR"
-rm -rf "$CLASSES_DIR" "$BUILD_DIR/$SERVER_BINARY" classes.dex
+rm -rf "$CLASSES_DIR" "$GEN_DIR" "$BUILD_DIR/$SERVER_BINARY" classes.dex
-mkdir -p "$CLASSES_DIR/com/genymobile/scrcpy"
+mkdir -p "$CLASSES_DIR"
 mkdir -p "$GEN_DIR/com/genymobile/scrcpy"
-<< EOF cat > "$CLASSES_DIR/com/genymobile/scrcpy/BuildConfig.java"
+<< EOF cat > "$GEN_DIR/com/genymobile/scrcpy/BuildConfig.java"
 package com.genymobile.scrcpy;
 public final class BuildConfig {
@ -42,13 +45,15 @@ EOF
 echo "Generating java from aidl..."
 cd "$SERVER_DIR/src/main/aidl"
-"$BUILD_TOOLS_DIR/aidl" -o"$CLASSES_DIR" android/view/IRotationWatcher.aidl
+"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" android/view/IRotationWatcher.aidl
-"$BUILD_TOOLS_DIR/aidl" -o"$CLASSES_DIR" \
+"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" \
    android/content/IOnPrimaryClipChangedListener.aidl
 echo "Compiling java sources..."
 cd ../java
-javac -bootclasspath "$ANDROID_JAR" -cp "$CLASSES_DIR" -d "$CLASSES_DIR" \
+javac -bootclasspath "$ANDROID_JAR" \
    -cp "$LAMBDA_JAR:$GEN_DIR" \
    -d "$CLASSES_DIR" \
    -source 1.8 -target 1.8 \
    com/genymobile/scrcpy/*.java \
    com/genymobile/scrcpy/wrappers/*.java
@ -68,7 +73,7 @@ then
    echo "Archiving..."
    cd "$BUILD_DIR"
    jar cvf "$SERVER_BINARY" classes.dex
-    rm -rf classes.dex classes
+    rm -rf classes.dex
 else
    # use d8
    "$BUILD_TOOLS_DIR/d8" --classpath "$ANDROID_JAR" \
@ -80,7 +85,8 @@ else
    cd "$BUILD_DIR"
    mv classes.zip "$SERVER_BINARY"
    rm -rf classes
 fi
 rm -rf "$GEN_DIR" "$CLASSES_DIR"
 echo "Server generated in $BUILD_DIR/$SERVER_BINARY"
--- a/server/src/main/java/com/genymobile/scrcpy/CodecOption.java
+++ b/server/src/main/java/com/genymobile/scrcpy/CodecOption.java
@ -4,8 +4,8 @@ import java.util.ArrayList;
 import java.util.List;
 public class CodecOption {
-    private String key;
+    private final String key;
-    private Object value;
+    private final Object value;
    public CodecOption(String key, Object value) {
        this.key = key;
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
@ -29,6 +29,7 @@ public final class ControlMessage {
    private int metaState; // KeyEvent.META_*
    private int action; // KeyEvent.ACTION_* or MotionEvent.ACTION_* or POWER_MODE_*
    private int keycode; // KeyEvent.KEYCODE_*
    private int actionButton; // MotionEvent.BUTTON_*
    private int buttons; // MotionEvent.BUTTON_*
    private long pointerId;
    private float pressure;
@ -60,13 +61,15 @@ public final class ControlMessage {
        return msg;
    }
-    public static ControlMessage createInjectTouchEvent(int action, long pointerId, Position position, float pressure, int buttons) {
+    public static ControlMessage createInjectTouchEvent(int action, long pointerId, Position position, float pressure, int actionButton,
            int buttons) {
        ControlMessage msg = new ControlMessage();
        msg.type = TYPE_INJECT_TOUCH_EVENT;
        msg.action = action;
        msg.pointerId = pointerId;
        msg.pressure = pressure;
        msg.position = position;
        msg.actionButton = actionButton;
        msg.buttons = buttons;
        return msg;
    }
@ -140,6 +143,10 @@ public final class ControlMessage {
        return keycode;
    }
    public int getActionButton() {
        return actionButton;
    }
    public int getButtons() {
        return buttons;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
@ -9,7 +9,7 @@ import java.nio.charset.StandardCharsets;
 public class ControlMessageReader {
    static final int INJECT_KEYCODE_PAYLOAD_LENGTH = 13;
-    static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 27;
+    static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 31;
    static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
    static final int BACK_OR_SCREEN_ON_LENGTH = 1;
    static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
@ -140,8 +140,9 @@ public class ControlMessageReader {
        long pointerId = buffer.getLong();
        Position position = readPosition(buffer);
        float pressure = Binary.u16FixedPointToFloat(buffer.getShort());
        int actionButton = buffer.getInt();
        int buttons = buffer.getInt();
-        return ControlMessage.createInjectTouchEvent(action, pointerId, position, pressure, buttons);
+        return ControlMessage.createInjectTouchEvent(action, pointerId, position, pressure, actionButton, buttons);
    }
    private ControlMessage parseInjectScrollEvent() {
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@ -1,5 +1,7 @@
 package com.genymobile.scrcpy;
 import com.genymobile.scrcpy.wrappers.InputManager;
 import android.os.Build;
 import android.os.SystemClock;
 import android.view.InputDevice;
@ -16,8 +18,14 @@ public class Controller {
    private static final int DEFAULT_DEVICE_ID = 0;
    // control_msg.h values of the pointerId field in inject_touch_event message
    private static final int POINTER_ID_MOUSE = -1;
    private static final int POINTER_ID_VIRTUAL_MOUSE = -3;
    private static final ScheduledExecutorService EXECUTOR = Executors.newSingleThreadScheduledExecutor();
    private Thread thread;
    private final Device device;
    private final DesktopConnection connection;
    private final DeviceMessageSender sender;
@ -56,7 +64,7 @@ public class Controller {
        }
    }
-    public void control() throws IOException {
+    private void control() throws IOException {
        // on start, power on the device
        if (powerOn && !Device.isScreenOn()) {
            device.pressReleaseKeycode(KeyEvent.KEYCODE_POWER, Device.INJECT_MODE_ASYNC);
@ -71,11 +79,32 @@ public class Controller {
            SystemClock.sleep(500);
        }
-        while (true) {
+        while (!Thread.currentThread().isInterrupted()) {
            handleEvent();
        }
    }
    public void start() {
        thread = new Thread(() -> {
            try {
                control();
            } catch (IOException e) {
                // this is expected on close
                Ln.d("Controller stopped");
            }
        });
        thread.start();
        sender.start();
    }
    public void stop() {
        if (thread != null) {
            thread.interrupt();
            thread = null;
        }
        sender.stop();
    }
    public DeviceMessageSender getSender() {
        return sender;
    }
@ -95,7 +124,7 @@ public class Controller {
                break;
            case ControlMessage.TYPE_INJECT_TOUCH_EVENT:
                if (device.supportsInputEvents()) {
-                    injectTouch(msg.getAction(), msg.getPointerId(), msg.getPosition(), msg.getPressure(), msg.getButtons());
+                    injectTouch(msg.getAction(), msg.getPointerId(), msg.getPosition(), msg.getPressure(), msg.getActionButton(), msg.getButtons());
                }
                break;
            case ControlMessage.TYPE_INJECT_SCROLL_EVENT:
@ -175,7 +204,7 @@ public class Controller {
        return successCount;
    }
-    private boolean injectTouch(int action, long pointerId, Position position, float pressure, int buttons) {
+    private boolean injectTouch(int action, long pointerId, Position position, float pressure, int actionButton, int buttons) {
        long now = SystemClock.uptimeMillis();
        Point point = device.getPhysicalPoint(position);
@ -192,10 +221,23 @@ public class Controller {
        Pointer pointer = pointersState.get(pointerIndex);
        pointer.setPoint(point);
        pointer.setPressure(pressure);
        int source;
        if (pointerId == POINTER_ID_MOUSE || pointerId == POINTER_ID_VIRTUAL_MOUSE) {
            // real mouse event (forced by the client when --forward-on-click)
            pointerProperties[pointerIndex].toolType = MotionEvent.TOOL_TYPE_MOUSE;
            source = InputDevice.SOURCE_MOUSE;
            pointer.setUp(buttons == 0);
        } else {
            // POINTER_ID_GENERIC_FINGER, POINTER_ID_VIRTUAL_FINGER or real touch from device
            pointerProperties[pointerIndex].toolType = MotionEvent.TOOL_TYPE_FINGER;
            source = InputDevice.SOURCE_TOUCHSCREEN;
            // Buttons must not be set for touch events
            buttons = 0;
            pointer.setUp(action == MotionEvent.ACTION_UP);
        }
        int pointerCount = pointersState.update(pointerProperties, pointerCoords);
        if (pointerCount == 1) {
            if (action == MotionEvent.ACTION_DOWN) {
                lastTouchDown = now;
@ -209,12 +251,60 @@ public class Controller {
            }
        }
-        // Right-click and middle-click only work if the source is a mouse
+        /* If the input device is a mouse (on API >= 23):
-        boolean nonPrimaryButtonPressed = (buttons & ~MotionEvent.BUTTON_PRIMARY) != 0;
+         *   - the first button pressed must first generate ACTION_DOWN;
-        int source = nonPrimaryButtonPressed ? InputDevice.SOURCE_MOUSE : InputDevice.SOURCE_TOUCHSCREEN;
+         *   - all button pressed (including the first one) must generate ACTION_BUTTON_PRESS;
-        if (source != InputDevice.SOURCE_MOUSE) {
+         *   - all button released (including the last one) must generate ACTION_BUTTON_RELEASE;
-            // Buttons must not be set for touch events
+         *   - the last button released must in addition generate ACTION_UP.
-            buttons = 0;
+         *
         * Otherwise, Chrome does not work properly: <https://github.com/Genymobile/scrcpy/issues/3635>
         */
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && source == InputDevice.SOURCE_MOUSE) {
            if (action == MotionEvent.ACTION_DOWN) {
                if (actionButton == buttons) {
                    // First button pressed: ACTION_DOWN
                    MotionEvent downEvent = MotionEvent.obtain(lastTouchDown, now, MotionEvent.ACTION_DOWN, pointerCount, pointerProperties,
                            pointerCoords, 0, buttons, 1f, 1f, DEFAULT_DEVICE_ID, 0, source, 0);
                    if (!device.injectEvent(downEvent, Device.INJECT_MODE_ASYNC)) {
                        return false;
                    }
                }
                // Any button pressed: ACTION_BUTTON_PRESS
                MotionEvent pressEvent = MotionEvent.obtain(lastTouchDown, now, MotionEvent.ACTION_BUTTON_PRESS, pointerCount, pointerProperties,
                        pointerCoords, 0, buttons, 1f, 1f, DEFAULT_DEVICE_ID, 0, source, 0);
                if (!InputManager.setActionButton(pressEvent, actionButton)) {
                    return false;
                }
                if (!device.injectEvent(pressEvent, Device.INJECT_MODE_ASYNC)) {
                    return false;
                }
                return true;
            }
            if (action == MotionEvent.ACTION_UP) {
                // Any button released: ACTION_BUTTON_RELEASE
                MotionEvent releaseEvent = MotionEvent.obtain(lastTouchDown, now, MotionEvent.ACTION_BUTTON_RELEASE, pointerCount, pointerProperties,
                        pointerCoords, 0, buttons, 1f, 1f, DEFAULT_DEVICE_ID, 0, source, 0);
                if (!InputManager.setActionButton(releaseEvent, actionButton)) {
                    return false;
                }
                if (!device.injectEvent(releaseEvent, Device.INJECT_MODE_ASYNC)) {
                    return false;
                }
                if (buttons == 0) {
                    // Last button released: ACTION_UP
                    MotionEvent upEvent = MotionEvent.obtain(lastTouchDown, now, MotionEvent.ACTION_UP, pointerCount, pointerProperties,
                            pointerCoords, 0, buttons, 1f, 1f, DEFAULT_DEVICE_ID, 0, source, 0);
                    if (!device.injectEvent(upEvent, Device.INJECT_MODE_ASYNC)) {
                        return false;
                    }
                }
                return true;
            }
        }
        MotionEvent event = MotionEvent
@ -250,12 +340,9 @@ public class Controller {
     * Schedule a call to set power mode to off after a small delay.
     */
    private static void schedulePowerModeOff() {
-        EXECUTOR.schedule(new Runnable() {
+        EXECUTOR.schedule(() -> {
            @Override
            public void run() {
            Ln.i("Forcing screen off");
            Device.setScreenPowerMode(Device.POWER_MODE_OFF);
            }
        }, 200, TimeUnit.MILLISECONDS);
    }
--- a/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
@ -15,7 +15,7 @@ public final class DesktopConnection implements Closeable {
    private static final int DEVICE_NAME_FIELD_LENGTH = 64;
-    private static final String SOCKET_NAME = "scrcpy";
+    private static final String SOCKET_NAME_PREFIX = "scrcpy";
    private final LocalSocket videoSocket;
    private final FileDescriptor videoFd;
@ -46,12 +46,22 @@ public final class DesktopConnection implements Closeable {
        return localSocket;
    }
-    public static DesktopConnection open(boolean tunnelForward, boolean control, boolean sendDummyByte) throws IOException {
+    private static String getSocketName(int uid) {
        if (uid == -1) {
            // If no UID is set, use "scrcpy" to simplify using scrcpy-server alone
            return SOCKET_NAME_PREFIX;
        }
        return SOCKET_NAME_PREFIX + String.format("_%08x", uid);
    }
    public static DesktopConnection open(int uid, boolean tunnelForward, boolean control, boolean sendDummyByte) throws IOException {
        String socketName = getSocketName(uid);
        LocalSocket videoSocket;
        LocalSocket controlSocket = null;
        if (tunnelForward) {
-            LocalServerSocket localServerSocket = new LocalServerSocket(SOCKET_NAME);
+            try (LocalServerSocket localServerSocket = new LocalServerSocket(socketName)) {
            try {
                videoSocket = localServerSocket.accept();
                if (sendDummyByte) {
                    // send one byte so the client may read() to detect a connection error
@ -65,14 +75,12 @@ public final class DesktopConnection implements Closeable {
                        throw e;
                    }
                }
            } finally {
                localServerSocket.close();
            }
        } else {
-            videoSocket = connect(SOCKET_NAME);
+            videoSocket = connect(socketName);
            if (control) {
                try {
-                    controlSocket = connect(SOCKET_NAME);
+                    controlSocket = connect(socketName);
                } catch (IOException | RuntimeException e) {
                    videoSocket.close();
                    throw e;
--- a/server/src/main/java/com/genymobile/scrcpy/DeviceMessageSender.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DeviceMessageSender.java
@ -6,6 +6,8 @@ public final class DeviceMessageSender {
    private final DesktopConnection connection;
    private Thread thread;
    private String clipboardText;
    private long ack;
@ -24,8 +26,8 @@ public final class DeviceMessageSender {
        notify();
    }
-    public void loop() throws IOException, InterruptedException {
+    private void loop() throws IOException, InterruptedException {
-        while (true) {
+        while (!Thread.currentThread().isInterrupted()) {
            String text;
            long sequence;
            synchronized (this) {
@ -49,4 +51,22 @@ public final class DeviceMessageSender {
            }
        }
    }
    public void start() {
        thread = new Thread(() -> {
            try {
                loop();
            } catch (IOException | InterruptedException e) {
                // this is expected on close
                Ln.d("Device message sender stopped");
            }
        });
        thread.start();
    }
    public void stop() {
        if (thread != null) {
            thread.interrupt();
            thread = null;
        }
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@ -5,8 +5,12 @@ import android.graphics.Rect;
 import java.util.List;
 public class Options {
    private static final String VIDEO_CODEC_H264 = "h264";
    private Ln.Level logLevel = Ln.Level.DEBUG;
    private int uid = -1; // 31-bit non-negative value, or -1
    private int maxSize;
    private VideoCodec codec = VideoCodec.H264;
    private int bitRate = 8000000;
    private int maxFps;
    private int lockVideoOrientation = -1;
@ -28,6 +32,7 @@ public class Options {
    private boolean sendDeviceMeta = true; // send device name and size
    private boolean sendFrameMeta = true; // send PTS so that the client may record properly
    private boolean sendDummyByte = true; // write a byte on start to detect connection issues
    private boolean sendCodecId = true; // write the codec ID (4 bytes) before the stream
    public Ln.Level getLogLevel() {
        return logLevel;
@ -37,6 +42,14 @@ public class Options {
        this.logLevel = logLevel;
    }
    public int getUid() {
        return uid;
    }
    public void setUid(int uid) {
        this.uid = uid;
    }
    public int getMaxSize() {
        return maxSize;
    }
@ -45,6 +58,14 @@ public class Options {
        this.maxSize = maxSize;
    }
    public VideoCodec getCodec() {
        return codec;
    }
    public void setCodec(VideoCodec codec) {
        this.codec = codec;
    }
    public int getBitRate() {
        return bitRate;
    }
@ -196,4 +217,12 @@ public class Options {
    public void setSendDummyByte(boolean sendDummyByte) {
        this.sendDummyByte = sendDummyByte;
    }
    public boolean getSendCodecId() {
        return sendCodecId;
    }
    public void setSendCodecId(boolean sendCodecId) {
        this.sendCodecId = sendCodecId;
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Position.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Position.java
@ -3,8 +3,8 @@ package com.genymobile.scrcpy;
 import java.util.Objects;
 public class Position {
-    private Point point;
+    private final Point point;
-    private Size screenSize;
+    private final Size screenSize;
    public Position(Point point, Size screenSize) {
        this.point = point;
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@ -9,9 +9,9 @@ import android.media.MediaCodecList;
 import android.media.MediaFormat;
 import android.os.Build;
 import android.os.IBinder;
 import android.os.SystemClock;
 import android.view.Surface;
 import java.io.FileDescriptor;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
@ -21,32 +21,32 @@ import java.util.concurrent.atomic.AtomicBoolean;
 public class ScreenEncoder implements Device.RotationListener {
    public interface Callbacks {
        void onPacket(ByteBuffer codecBuffer, MediaCodec.BufferInfo bufferInfo) throws IOException;
    }
    private static final int DEFAULT_I_FRAME_INTERVAL = 10; // seconds
    private static final int REPEAT_FRAME_DELAY_US = 100_000; // repeat after 100ms
    private static final String KEY_MAX_FPS_TO_ENCODER = "max-fps-to-encoder";
    // Keep the values in descending order
    private static final int[] MAX_SIZE_FALLBACK = {2560, 1920, 1600, 1280, 1024, 800};
-
+    private static final int MAX_CONSECUTIVE_ERRORS = 3;
    private static final long PACKET_FLAG_CONFIG = 1L << 63;
    private static final long PACKET_FLAG_KEY_FRAME = 1L << 62;
    private final AtomicBoolean rotationChanged = new AtomicBoolean();
    private final ByteBuffer headerBuffer = ByteBuffer.allocate(12);
    private final String videoMimeType;
    private final String encoderName;
    private final List<CodecOption> codecOptions;
    private final int bitRate;
    private final int maxFps;
    private final boolean sendFrameMeta;
    private final boolean downsizeOnError;
    private long ptsOrigin;
    private boolean firstFrameSent;
    private int consecutiveErrors;
-    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
+    public ScreenEncoder(String videoMimeType, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName, boolean downsizeOnError) {
-            boolean downsizeOnError) {
+        this.videoMimeType = videoMimeType;
        this.sendFrameMeta = sendFrameMeta;
        this.bitRate = bitRate;
        this.maxFps = maxFps;
        this.codecOptions = codecOptions;
@ -63,75 +63,92 @@ public class ScreenEncoder implements Device.RotationListener {
        return rotationChanged.getAndSet(false);
    }
-    public void streamScreen(Device device, FileDescriptor fd) throws IOException {
+    public void streamScreen(Device device, Callbacks callbacks) throws IOException {
-        Workarounds.prepareMainLooper();
+        MediaCodec codec = createCodec(videoMimeType, encoderName);
-        if (Build.BRAND.equalsIgnoreCase("meizu")) {
+        MediaFormat format = createFormat(videoMimeType, bitRate, maxFps, codecOptions);
-            // <https://github.com/Genymobile/scrcpy/issues/240>
+        IBinder display = createDisplay();
            // <https://github.com/Genymobile/scrcpy/issues/2656>
            Workarounds.fillAppInfo();
        }
        internalStreamScreen(device, fd);
    }
    private void internalStreamScreen(Device device, FileDescriptor fd) throws IOException {
        MediaFormat format = createFormat(bitRate, maxFps, codecOptions);
        device.setRotationListener(this);
        boolean alive;
        try {
            do {
                MediaCodec codec = createCodec(encoderName);
                IBinder display = createDisplay();
                ScreenInfo screenInfo = device.getScreenInfo();
                Rect contentRect = screenInfo.getContentRect();
                // include the locked video orientation
                Rect videoRect = screenInfo.getVideoSize().toRect();
                format.setInteger(MediaFormat.KEY_WIDTH, videoRect.width());
                format.setInteger(MediaFormat.KEY_HEIGHT, videoRect.height());
                Surface surface = null;
                try {
                    codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
                    surface = codec.createInputSurface();
                    // does not include the locked video orientation
                    Rect unlockedVideoRect = screenInfo.getUnlockedVideoSize().toRect();
                    int videoRotation = screenInfo.getVideoRotation();
                    int layerStack = device.getLayerStack();
                setSize(format, videoRect.width(), videoRect.height());
                Surface surface = null;
                try {
                    configure(codec, format);
                    surface = codec.createInputSurface();
                    setDisplaySurface(display, surface, videoRotation, contentRect, unlockedVideoRect, layerStack);
                    codec.start();
-                    alive = encode(codec, fd);
+                    alive = encode(codec, callbacks);
                    // do not call stop() on exception, it would trigger an IllegalStateException
                    codec.stop();
                } catch (IllegalStateException | IllegalArgumentException e) {
                    Ln.e("Encoding error: " + e.getClass().getName() + ": " + e.getMessage());
-                    if (!downsizeOnError || firstFrameSent) {
+                    if (!prepareRetry(device, screenInfo)) {
                        // Fail immediately
                        throw e;
                    }
-
+                    Ln.i("Retrying...");
                    int newMaxSize = chooseMaxSizeFallback(screenInfo.getVideoSize());
                    if (newMaxSize == 0) {
                        // Definitively fail
                        throw e;
                    }
                    // Retry with a smaller device size
                    Ln.i("Retrying with -m" + newMaxSize + "...");
                    device.setMaxSize(newMaxSize);
                    alive = true;
                } finally {
-                    destroyDisplay(display);
+                    codec.reset();
                    codec.release();
                    if (surface != null) {
                        surface.release();
                    }
                }
            } while (alive);
        } finally {
            codec.release();
            device.setRotationListener(null);
            SurfaceControl.destroyDisplay(display);
        }
    }
    private boolean prepareRetry(Device device, ScreenInfo screenInfo) {
        if (firstFrameSent) {
            ++consecutiveErrors;
            if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
                // Definitively fail
                return false;
            }
            // Wait a bit to increase the probability that retrying will fix the problem
            SystemClock.sleep(50);
            return true;
        }
        if (!downsizeOnError) {
            // Must fail immediately
            return false;
        }
        // Downsizing on error is only enabled if an encoding failure occurs before the first frame (downsizing later could be surprising)
        int newMaxSize = chooseMaxSizeFallback(screenInfo.getVideoSize());
        Ln.i("newMaxSize = " + newMaxSize);
        if (newMaxSize == 0) {
            // Must definitively fail
            return false;
        }
        // Retry with a smaller device size
        Ln.i("Retrying with -m" + newMaxSize + "...");
        device.setMaxSize(newMaxSize);
        return true;
    }
    private static int chooseMaxSizeFallback(Size failedSize) {
        int currentMaxSize = Math.max(failedSize.getWidth(), failedSize.getHeight());
        for (int value : MAX_SIZE_FALLBACK) {
@ -144,30 +161,30 @@ public class ScreenEncoder implements Device.RotationListener {
        return 0;
    }
-    private boolean encode(MediaCodec codec, FileDescriptor fd) throws IOException {
+    private boolean encode(MediaCodec codec, Callbacks callbacks) throws IOException {
        boolean eof = false;
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
        while (!consumeRotationChange() && !eof) {
            int outputBufferId = codec.dequeueOutputBuffer(bufferInfo, -1);
            eof = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
            try {
                if (consumeRotationChange()) {
                    // must restart encoding with new size
                    break;
                }
                eof = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
                if (outputBufferId >= 0) {
                    ByteBuffer codecBuffer = codec.getOutputBuffer(outputBufferId);
-                    if (sendFrameMeta) {
+                    boolean isConfig = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0;
-                        writeFrameMeta(fd, bufferInfo, codecBuffer.remaining());
+                    if (!isConfig) {
                    }
                    IO.writeFully(fd, codecBuffer);
                    if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
                        // If this is not a config packet, then it contains a frame
                        firstFrameSent = true;
                        consecutiveErrors = 0;
                    }
                    callbacks.onPacket(codecBuffer, bufferInfo);
                }
            } finally {
                if (outputBufferId >= 0) {
@ -179,50 +196,28 @@ public class ScreenEncoder implements Device.RotationListener {
        return !eof;
    }
-    private void writeFrameMeta(FileDescriptor fd, MediaCodec.BufferInfo bufferInfo, int packetSize) throws IOException {
+    private static MediaCodecInfo[] listEncoders(String videoMimeType) {
        headerBuffer.clear();
        long pts;
        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
            pts = PACKET_FLAG_CONFIG; // non-media data packet
        } else {
            if (ptsOrigin == 0) {
                ptsOrigin = bufferInfo.presentationTimeUs;
            }
            pts = bufferInfo.presentationTimeUs - ptsOrigin;
            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) != 0) {
                pts |= PACKET_FLAG_KEY_FRAME;
            }
        }
        headerBuffer.putLong(pts);
        headerBuffer.putInt(packetSize);
        headerBuffer.flip();
        IO.writeFully(fd, headerBuffer);
    }
    private static MediaCodecInfo[] listEncoders() {
        List<MediaCodecInfo> result = new ArrayList<>();
        MediaCodecList list = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
        for (MediaCodecInfo codecInfo : list.getCodecInfos()) {
-            if (codecInfo.isEncoder() && Arrays.asList(codecInfo.getSupportedTypes()).contains(MediaFormat.MIMETYPE_VIDEO_AVC)) {
+            if (codecInfo.isEncoder() && Arrays.asList(codecInfo.getSupportedTypes()).contains(videoMimeType)) {
                result.add(codecInfo);
            }
        }
        return result.toArray(new MediaCodecInfo[result.size()]);
    }
-    private static MediaCodec createCodec(String encoderName) throws IOException {
+    private static MediaCodec createCodec(String videoMimeType, String encoderName) throws IOException {
        if (encoderName != null) {
            Ln.d("Creating encoder by name: '" + encoderName + "'");
            try {
                return MediaCodec.createByCodecName(encoderName);
            } catch (IllegalArgumentException e) {
-                MediaCodecInfo[] encoders = listEncoders();
+                MediaCodecInfo[] encoders = listEncoders(videoMimeType);
                throw new InvalidEncoderException(encoderName, encoders);
            }
        }
-        MediaCodec codec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
+        MediaCodec codec = MediaCodec.createEncoderByType(videoMimeType);
        Ln.d("Using encoder: '" + codec.getName() + "'");
        return codec;
    }
@ -244,9 +239,9 @@ public class ScreenEncoder implements Device.RotationListener {
        Ln.d("Codec option set: " + key + " (" + value.getClass().getSimpleName() + ") = " + value);
    }
-    private static MediaFormat createFormat(int bitRate, int maxFps, List<CodecOption> codecOptions) {
+    private static MediaFormat createFormat(String videoMimeType, int bitRate, int maxFps, List<CodecOption> codecOptions) {
        MediaFormat format = new MediaFormat();
-        format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_AVC);
+        format.setString(MediaFormat.KEY_MIME, videoMimeType);
        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
        // must be present to configure the encoder, but does not impact the actual frame rate, which is variable
        format.setInteger(MediaFormat.KEY_FRAME_RATE, 60);
@ -278,15 +273,6 @@ public class ScreenEncoder implements Device.RotationListener {
        return SurfaceControl.createDisplay("scrcpy", secure);
    }
    private static void configure(MediaCodec codec, MediaFormat format) {
        codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
    }
    private static void setSize(MediaFormat format, int width, int height) {
        format.setInteger(MediaFormat.KEY_WIDTH, width);
        format.setInteger(MediaFormat.KEY_HEIGHT, height);
    }
    private static void setDisplaySurface(IBinder display, Surface surface, int orientation, Rect deviceRect, Rect displayRect, int layerStack) {
        SurfaceControl.openTransaction();
        try {
@ -297,8 +283,4 @@ public class ScreenEncoder implements Device.RotationListener {
            SurfaceControl.closeTransaction();
        }
    }
    private static void destroyDisplay(IBinder display) {
        SurfaceControl.destroyDisplay(display);
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -66,92 +66,63 @@ public final class Server {
        Thread initThread = startInitThread(options);
        int uid = options.getUid();
        boolean tunnelForward = options.isTunnelForward();
        boolean control = options.getControl();
        boolean sendDummyByte = options.getSendDummyByte();
-        try (DesktopConnection connection = DesktopConnection.open(tunnelForward, control, sendDummyByte)) {
+        Workarounds.prepareMainLooper();
        if (Build.BRAND.equalsIgnoreCase("meizu")) {
            // Workarounds must be applied for Meizu phones:
            //  - <https://github.com/Genymobile/scrcpy/issues/240>
            //  - <https://github.com/Genymobile/scrcpy/issues/365>
            //  - <https://github.com/Genymobile/scrcpy/issues/2656>
            //
            // But only apply when strictly necessary, since workarounds can cause other issues:
            //  - <https://github.com/Genymobile/scrcpy/issues/940>
            //  - <https://github.com/Genymobile/scrcpy/issues/994>
            Workarounds.fillAppInfo();
        }
        try (DesktopConnection connection = DesktopConnection.open(uid, tunnelForward, control, sendDummyByte)) {
            VideoCodec codec = options.getCodec();
            if (options.getSendDeviceMeta()) {
                Size videoSize = device.getScreenInfo().getVideoSize();
                connection.sendDeviceMeta(Device.getDeviceName(), videoSize.getWidth(), videoSize.getHeight());
            }
-            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(), codecOptions,
+            ScreenEncoder screenEncoder = new ScreenEncoder(codec.getMimeType(), options.getBitRate(), options.getMaxFps(), codecOptions,
                    options.getEncoderName(), options.getDownsizeOnError());
-            Thread controllerThread = null;
+            Controller controller = null;
            Thread deviceMessageSenderThread = null;
            if (control) {
-                final Controller controller = new Controller(device, connection, options.getClipboardAutosync(), options.getPowerOn());
+                controller = new Controller(device, connection, options.getClipboardAutosync(), options.getPowerOn());
                controller.start();
-                // asynchronous
+                final Controller controllerRef = controller;
-                controllerThread = startController(controller);
+                device.setClipboardListener(text -> controllerRef.getSender().pushClipboardText(text));
                deviceMessageSenderThread = startDeviceMessageSender(controller.getSender());
                device.setClipboardListener(new Device.ClipboardListener() {
                    @Override
                    public void onClipboardTextChanged(String text) {
                        controller.getSender().pushClipboardText(text);
                    }
                });
            }
            try {
                // synchronous
-                screenEncoder.streamScreen(device, connection.getVideoFd());
+                VideoStreamer videoStreamer = new VideoStreamer(connection.getVideoFd(), options.getSendFrameMeta());
                if (options.getSendCodecId()) {
                    videoStreamer.writeHeader(codec.getId());
                }
                screenEncoder.streamScreen(device, videoStreamer);
            } catch (IOException e) {
                // this is expected on close
                Ln.d("Screen streaming stopped");
            } finally {
                initThread.interrupt();
-                if (controllerThread != null) {
+                if (controller != null) {
-                    controllerThread.interrupt();
+                    controller.stop();
                }
                if (deviceMessageSenderThread != null) {
                    deviceMessageSenderThread.interrupt();
                }
            }
        }
    }
    private static Thread startInitThread(final Options options) {
-        Thread thread = new Thread(new Runnable() {
+        Thread thread = new Thread(() -> initAndCleanUp(options));
            @Override
            public void run() {
                initAndCleanUp(options);
            }
        });
        thread.start();
        return thread;
    }
    private static Thread startController(final Controller controller) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    controller.control();
                } catch (IOException e) {
                    // this is expected on close
                    Ln.d("Controller stopped");
                }
            }
        });
        thread.start();
        return thread;
    }
    private static Thread startDeviceMessageSender(final DeviceMessageSender sender) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    sender.loop();
                } catch (IOException | InterruptedException e) {
                    // this is expected on close
                    Ln.d("Device message sender stopped");
                }
            }
        });
        thread.start();
        return thread;
    }
@ -178,10 +149,24 @@ public final class Server {
            String key = arg.substring(0, equalIndex);
            String value = arg.substring(equalIndex + 1);
            switch (key) {
                case "uid":
                    int uid = Integer.parseInt(value, 0x10);
                    if (uid < -1) {
                        throw new IllegalArgumentException("uid may not be negative (except -1 for 'none'): " + uid);
                    }
                    options.setUid(uid);
                    break;
                case "log_level":
                    Ln.Level level = Ln.Level.valueOf(value.toUpperCase(Locale.ENGLISH));
                    options.setLogLevel(level);
                    break;
                case "codec":
                    VideoCodec codec = VideoCodec.findByName(value);
                    if (codec == null) {
                        throw new IllegalArgumentException("Video codec " + value + " not supported");
                    }
                    options.setCodec(codec);
                    break;
                case "max_size":
                    int maxSize = Integer.parseInt(value) & ~7; // multiple of 8
                    options.setMaxSize(maxSize);
@ -263,12 +248,17 @@ public final class Server {
                    boolean sendDummyByte = Boolean.parseBoolean(value);
                    options.setSendDummyByte(sendDummyByte);
                    break;
                case "send_codec_id":
                    boolean sendCodecId = Boolean.parseBoolean(value);
                    options.setSendCodecId(sendCodecId);
                    break;
                case "raw_video_stream":
                    boolean rawVideoStream = Boolean.parseBoolean(value);
                    if (rawVideoStream) {
                        options.setSendDeviceMeta(false);
                        options.setSendFrameMeta(false);
                        options.setSendDummyByte(false);
                        options.setSendCodecId(false);
                    }
                    break;
                default:
@ -319,12 +309,9 @@ public final class Server {
    }
    public static void main(String... args) throws Exception {
-        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+        Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
            Ln.e("Exception on thread " + t, e);
            suggestFix(e);
            }
        });
        Options options = createOptions(args);
--- a/server/src/main/java/com/genymobile/scrcpy/VideoCodec.java
+++ b/server/src/main/java/com/genymobile/scrcpy/VideoCodec.java
@ -0,0 +1,36 @@
 package com.genymobile.scrcpy;
 import android.media.MediaFormat;
 public enum VideoCodec {
    H264(0x68_32_36_34, "h264", MediaFormat.MIMETYPE_VIDEO_AVC),
    H265(0x68_32_36_35, "h265", MediaFormat.MIMETYPE_VIDEO_HEVC),
    AV1(0x00_61_76_31, "av1", MediaFormat.MIMETYPE_VIDEO_AV1);
    private final int id; // 4-byte ASCII representation of the name
    private final String name;
    private final String mimeType;
    VideoCodec(int id, String name, String mimeType) {
        this.id = id;
        this.name = name;
        this.mimeType = mimeType;
    }
    public int getId() {
        return id;
    }
    public String getMimeType() {
        return mimeType;
    }
    public static VideoCodec findByName(String name) {
        for (VideoCodec codec : values()) {
            if (codec.name.equals(name)) {
                return codec;
            }
        }
        return null;
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/VideoStreamer.java
+++ b/server/src/main/java/com/genymobile/scrcpy/VideoStreamer.java
@ -0,0 +1,58 @@
 package com.genymobile.scrcpy;
 import android.media.MediaCodec;
 import java.io.FileDescriptor;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 public final class VideoStreamer implements ScreenEncoder.Callbacks {
    private static final long PACKET_FLAG_CONFIG = 1L << 63;
    private static final long PACKET_FLAG_KEY_FRAME = 1L << 62;
    private final FileDescriptor fd;
    private final boolean sendFrameMeta;
    private final ByteBuffer headerBuffer = ByteBuffer.allocate(12);
    public VideoStreamer(FileDescriptor fd, boolean sendFrameMeta) {
        this.fd = fd;
        this.sendFrameMeta = sendFrameMeta;
    }
    public void writeHeader(int codecId) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.putInt(codecId);
        buffer.flip();
        IO.writeFully(fd, buffer);
    }
    @Override
    public void onPacket(ByteBuffer codecBuffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
        if (sendFrameMeta) {
            writeFrameMeta(fd, bufferInfo, codecBuffer.remaining());
        }
        IO.writeFully(fd, codecBuffer);
    }
    private void writeFrameMeta(FileDescriptor fd, MediaCodec.BufferInfo bufferInfo, int packetSize) throws IOException {
        headerBuffer.clear();
        long ptsAndFlags;
        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
            ptsAndFlags = PACKET_FLAG_CONFIG; // non-media data packet
        } else {
            ptsAndFlags = bufferInfo.presentationTimeUs;
            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) != 0) {
                ptsAndFlags |= PACKET_FLAG_KEY_FRAME;
            }
        }
        headerBuffer.putLong(ptsAndFlags);
        headerBuffer.putInt(packetSize);
        headerBuffer.flip();
        IO.writeFully(fd, headerBuffer);
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
@ -15,6 +15,9 @@ public class ClipboardManager {
    private Method getPrimaryClipMethod;
    private Method setPrimaryClipMethod;
    private Method addPrimaryClipChangedListener;
    private boolean alternativeGetMethod;
    private boolean alternativeSetMethod;
    private boolean alternativeAddListenerMethod;
    public ClipboardManager(IInterface manager) {
        this.manager = manager;
@ -25,7 +28,12 @@ public class ClipboardManager {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class);
            } else {
                try {
                    getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, int.class);
                } catch (NoSuchMethodException e) {
                    getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, String.class, int.class);
                    alternativeGetMethod = true;
                }
            }
        }
        return getPrimaryClipMethod;
@ -36,23 +44,34 @@ public class ClipboardManager {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class);
            } else {
                try {
                    setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class, int.class);
                } catch (NoSuchMethodException e) {
                    setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class, String.class, int.class);
                    alternativeSetMethod = true;
                }
            }
        }
        return setPrimaryClipMethod;
    }
-    private static ClipData getPrimaryClip(Method method, IInterface manager) throws InvocationTargetException, IllegalAccessException {
+    private static ClipData getPrimaryClip(Method method, boolean alternativeMethod, IInterface manager)
            throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
            return (ClipData) method.invoke(manager, ServiceManager.PACKAGE_NAME);
        }
        if (alternativeMethod) {
            return (ClipData) method.invoke(manager, ServiceManager.PACKAGE_NAME, null, ServiceManager.USER_ID);
        }
        return (ClipData) method.invoke(manager, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
    }
-    private static void setPrimaryClip(Method method, IInterface manager, ClipData clipData)
+    private static void setPrimaryClip(Method method, boolean alternativeMethod, IInterface manager, ClipData clipData)
            throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
            method.invoke(manager, clipData, ServiceManager.PACKAGE_NAME);
        } else if (alternativeMethod) {
            method.invoke(manager, clipData, ServiceManager.PACKAGE_NAME, null, ServiceManager.USER_ID);
        } else {
            method.invoke(manager, clipData, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
        }
@ -61,7 +80,7 @@ public class ClipboardManager {
    public CharSequence getText() {
        try {
            Method method = getGetPrimaryClipMethod();
-            ClipData clipData = getPrimaryClip(method, manager);
+            ClipData clipData = getPrimaryClip(method, alternativeGetMethod, manager);
            if (clipData == null || clipData.getItemCount() == 0) {
                return null;
            }
@ -76,7 +95,7 @@ public class ClipboardManager {
        try {
            Method method = getSetPrimaryClipMethod();
            ClipData clipData = ClipData.newPlainText(null, text);
-            setPrimaryClip(method, manager, clipData);
+            setPrimaryClip(method, alternativeSetMethod, manager, clipData);
            return true;
        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
@ -84,10 +103,12 @@ public class ClipboardManager {
        }
    }
-    private static void addPrimaryClipChangedListener(Method method, IInterface manager, IOnPrimaryClipChangedListener listener)
+    private static void addPrimaryClipChangedListener(Method method, boolean alternativeMethod, IInterface manager,
-            throws InvocationTargetException, IllegalAccessException {
+            IOnPrimaryClipChangedListener listener) throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME);
        } else if (alternativeMethod) {
            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME, null, ServiceManager.USER_ID);
        } else {
            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
        }
@ -99,8 +120,14 @@ public class ClipboardManager {
                addPrimaryClipChangedListener = manager.getClass()
                        .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class);
            } else {
                try {
                    addPrimaryClipChangedListener = manager.getClass()
                            .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class, int.class);
                } catch (NoSuchMethodException e) {
                    addPrimaryClipChangedListener = manager.getClass()
                            .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class, String.class, int.class);
                    alternativeAddListenerMethod = true;
                }
            }
        }
        return addPrimaryClipChangedListener;
@ -109,7 +136,7 @@ public class ClipboardManager {
    public boolean addPrimaryClipChangedListener(IOnPrimaryClipChangedListener listener) {
        try {
            Method method = getAddPrimaryClipChangedListener();
-            addPrimaryClipChangedListener(method, manager, listener);
+            addPrimaryClipChangedListener(method, alternativeAddListenerMethod, manager, listener);
            return true;
        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayManager.java
@ -21,7 +21,7 @@ public final class DisplayManager {
    // public to call it from unit tests
    public static DisplayInfo parseDisplayInfo(String dumpsysDisplayOutput, int displayId) {
        Pattern regex = Pattern.compile(
-                "^    mOverrideDisplayInfo=DisplayInfo\\{\".*?\", displayId " + displayId + ".*?(, FLAG_.*)?, real ([0-9]+) x ([0-9]+).*?, "
+                "^    mOverrideDisplayInfo=DisplayInfo\\{\".*?, displayId " + displayId + ".*?(, FLAG_.*)?, real ([0-9]+) x ([0-9]+).*?, "
                        + "rotation ([0-9]+).*?, layerStack ([0-9]+)",
                Pattern.MULTILINE);
        Matcher m = regex.matcher(dumpsysDisplayOutput);
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
@ -3,6 +3,7 @@ package com.genymobile.scrcpy.wrappers;
 import com.genymobile.scrcpy.Ln;
 import android.view.InputEvent;
 import android.view.MotionEvent;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@ -17,6 +18,7 @@ public final class InputManager {
    private Method injectInputEventMethod;
    private static Method setDisplayIdMethod;
    private static Method setActionButtonMethod;
    public InputManager(android.hardware.input.InputManager manager) {
        this.manager = manager;
@ -56,4 +58,22 @@ public final class InputManager {
            return false;
        }
    }
    private static Method getSetActionButtonMethod() throws NoSuchMethodException {
        if (setActionButtonMethod == null) {
            setActionButtonMethod = MotionEvent.class.getMethod("setActionButton", int.class);
        }
        return setActionButtonMethod;
    }
    public static boolean setActionButton(MotionEvent motionEvent, int actionButton) {
        try {
            Method method = getSetActionButtonMethod();
            method.invoke(motionEvent, actionButton);
            return true;
        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Cannot set action button on MotionEvent", e);
            return false;
        }
    }
 }
--- a/server/src/test/java/com/genymobile/scrcpy/CommandParserTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/CommandParserTest.java
@ -183,4 +183,60 @@ public class CommandParserTest {
        Assert.assertEquals(1080, displayInfo.getSize().getWidth());
        Assert.assertEquals(2280, displayInfo.getSize().getHeight());
    }
    @Test
    public void testParseDisplayInfoFromDumpsysDisplayAPI29WithNoFlags() {
        /* @formatter:off */
        String partialOutput = "Logical Displays: size=2\n"
                + "  Display 0:\n"
                + "    mDisplayId=0\n"
                + "    mLayerStack=0\n"
                + "    mHasContent=true\n"
                + "    mAllowedDisplayModes=[1]\n"
                + "    mRequestedColorMode=0\n"
                + "    mDisplayOffset=(0, 0)\n"
                + "    mDisplayScalingDisabled=false\n"
                + "    mPrimaryDisplayDevice=Built-in Screen\n"
                + "    mBaseDisplayInfo=DisplayInfo{\"Built-in Screen, displayId 0\", uniqueId \"local:0\", app 3664 x 1920, "
                + "real 3664 x 1920, largest app 3664 x 1920, smallest app 3664 x 1920, mode 61, defaultMode 61, modes ["
                + "{id=1, width=3664, height=1920, fps=60.000004}, {id=2, width=3664, height=1920, fps=61.000004}, "
                + "{id=61, width=3664, height=1920, fps=120.00001}], colorMode 0, supportedColorModes [0], "
                + "hdrCapabilities android.view.Display$HdrCapabilities@4a41fe79, rotation 0, density 290 (320.842 x 319.813) dpi, "
                + "layerStack 0, appVsyncOff 1000000, presDeadline 8333333, type BUILT_IN, address {port=129, model=0}, "
                + "state ON, FLAG_SECURE, FLAG_SUPPORTS_PROTECTED_BUFFERS, removeMode 0}\n"
                + "    mOverrideDisplayInfo=DisplayInfo{\"Built-in Screen, displayId 0\", uniqueId \"local:0\", app 3664 x 1920, "
                + "real 3664 x 1920, largest app 3664 x 3620, smallest app 1920 x 1876, mode 61, defaultMode 61, modes ["
                + "{id=1, width=3664, height=1920, fps=60.000004}, {id=2, width=3664, height=1920, fps=61.000004}, "
                + "{id=61, width=3664, height=1920, fps=120.00001}], colorMode 0, supportedColorModes [0], "
                + "hdrCapabilities android.view.Display$HdrCapabilities@4a41fe79, rotation 0, density 290 (320.842 x 319.813) dpi, "
                + "layerStack 0, appVsyncOff 1000000, presDeadline 8333333, type BUILT_IN, address {port=129, model=0}, "
                + "state ON, FLAG_SECURE, FLAG_SUPPORTS_PROTECTED_BUFFERS, removeMode 0}\n"
                + "  Display 31:\n"
                + "    mDisplayId=31\n"
                + "    mLayerStack=31\n"
                + "    mHasContent=true\n"
                + "    mAllowedDisplayModes=[92]\n"
                + "    mRequestedColorMode=0\n"
                + "    mDisplayOffset=(0, 0)\n"
                + "    mDisplayScalingDisabled=false\n"
                + "    mPrimaryDisplayDevice=PanelLayer-#main\n"
                + "    mBaseDisplayInfo=DisplayInfo{\"PanelLayer-#main, displayId 31\", uniqueId "
                + "\"virtual:com.test.system,10040,PanelLayer-#main,0\", app 800 x 110, real 800 x 110, largest app 800 x 110, smallest app 800 x "
                + "110, mode 92, defaultMode 92, modes [{id=92, width=800, height=110, fps=60.0}], colorMode 0, supportedColorModes [0], "
                + "hdrCapabilities null, rotation 0, density 200 (200.0 x 200.0) dpi, layerStack 31, appVsyncOff 0, presDeadline 16666666, "
                + "type VIRTUAL, state ON, owner com.test.system (uid 10040), FLAG_PRIVATE, removeMode 1}\n"
                + "    mOverrideDisplayInfo=DisplayInfo{\"PanelLayer-#main, displayId 31\", uniqueId "
                + "\"virtual:com.test.system,10040,PanelLayer-#main,0\", app 800 x 110, real 800 x 110, largest app 800 x 800, smallest app 110 x "
                + "110, mode 92, defaultMode 92, modes [{id=92, width=800, height=110, fps=60.0}], colorMode 0, supportedColorModes [0], "
                + "hdrCapabilities null, rotation 0, density 200 (200.0 x 200.0) dpi, layerStack 31, appVsyncOff 0, presDeadline 16666666, "
                + "type VIRTUAL, state OFF, owner com.test.system (uid 10040), FLAG_PRIVATE, removeMode 1}\n";
        DisplayInfo displayInfo = DisplayManager.parseDisplayInfo(partialOutput, 31);
        Assert.assertNotNull(displayInfo);
        Assert.assertEquals(31, displayInfo.getDisplayId());
        Assert.assertEquals(0, displayInfo.getRotation());
        Assert.assertEquals(31, displayInfo.getLayerStack());
        Assert.assertEquals(0, displayInfo.getFlags());
        Assert.assertEquals(800, displayInfo.getSize().getWidth());
        Assert.assertEquals(110, displayInfo.getSize().getHeight());
    }
 }
--- a/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
@ -94,7 +94,8 @@ public class ControlMessageReaderTest {
        dos.writeShort(1080);
        dos.writeShort(1920);
        dos.writeShort(0xffff); // pressure
-        dos.writeInt(MotionEvent.BUTTON_PRIMARY);
+        dos.writeInt(MotionEvent.BUTTON_PRIMARY); // action button
        dos.writeInt(MotionEvent.BUTTON_PRIMARY); // buttons
        byte[] packet = bos.toByteArray();
@ -112,6 +113,7 @@ public class ControlMessageReaderTest {
        Assert.assertEquals(1080, event.getPosition().getScreenSize().getWidth());
        Assert.assertEquals(1920, event.getPosition().getScreenSize().getHeight());
        Assert.assertEquals(1f, event.getPressure(), 0f); // must be exact
        Assert.assertEquals(MotionEvent.BUTTON_PRIMARY, event.getActionButton());
        Assert.assertEquals(MotionEvent.BUTTON_PRIMARY, event.getButtons());
    }
Author	SHA1	Message	Date
Romain Vimont	d2dce51038	Add support for AV1 Add option --codec=av1. PR #3713 <https://github.com/Genymobile/scrcpy/pull/3713>	2023-02-06 11:00:49 +01:00
Romain Vimont	4342c5637d	Add support for H265 Add option --codec=h265. PR #3713 <https://github.com/Genymobile/scrcpy/pull/3713> Fixes #3092 <https://github.com/Genymobile/scrcpy/issues/3092>	2023-02-06 11:00:49 +01:00
Romain Vimont	3e517cd40e	Add option to select video codec Introduce the selection mechanism. Alternative codecs will be added in further commits. PR #3713 <https://github.com/Genymobile/scrcpy/pull/3713>	2023-02-06 10:58:45 +01:00
Romain Vimont	f70f6cdd3e	Simplify server info initialization Use sc_read16be() to read 16-bit integer fields.	2023-02-03 12:31:28 +01:00
Romain Vimont	87972e2022	Extract video streaming to a separate class ScreenEncoder handled both capture/encoding and sending over the network. Move the streaming part to a separate VideoStreamer.	2023-02-03 12:31:28 +01:00
Romain Vimont	3aac74e9e9	Move variable assignment Computing eof flag is not necessary if rotation changed.	2023-02-03 12:31:28 +01:00
Romain Vimont	1c82c3923d	Compute relative PTS on the client-side The PTS received from MediaCodec are expressed relative to an arbitrary clock origin. We consider the PTS of the first frame to be 0, and the PTS of every other frame is relative to this first PTS (note that the PTS is only used for recording, it is ignored for mirroring). For simplicity, this relative PTS was computed on the server-side. To prepare support for multiple stream (video and audio), send the packet with its original PTS, and handle the PTS offset on the client-side (by the recorder). Since we can't know in advance which stream will produce the first packet with the lowest PTS (a packet received later on one stream may have a PTS lower than a packet received earlier on another stream), computing the PTS on the server-side would require unnecessary waiting.	2023-02-03 12:31:28 +01:00
Romain Vimont	36d656e91f	Improve workarounds call comments	2023-02-03 12:31:28 +01:00
Romain Vimont	bdbf1f4eb7	Move Workarounds call Workarounds are not specific to the screen encoder. Co-authored-by: Simon Chan <1330321+yume-chan@users.noreply.github.com>	2023-02-03 12:31:28 +01:00
Romain Vimont	4177de5880	Do not expose controller threads The way the controller executes its events asynchronously is an implementation detail.	2023-02-03 12:31:28 +01:00
Romain Vimont	6a07e3d470	Fix manpage formatting Only the option arguments must be underlined.	2023-02-03 12:31:28 +01:00
Simon Chan	9b286ec8a7	Inject additional ACTION_BUTTON_* events for mouse On mouse click events: - the first button pressed must first generate ACTION_DOWN; - all button pressed (including the first one) must generate ACTION_BUTTON_PRESS; - all button released (including the last one) must generate ACTION_BUTTON_RELEASE; - the last button released must in addition generate ACTION_UP. Otherwise, Chrome does not work properly. Fixes #3635 <https://github.com/Genymobile/scrcpy/issues/3635> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-01-30 20:57:54 +01:00
Simon Chan	8c5c55f9e1	Fix mouse pointer state update If the pointer is a mouse, the pointer is UP only when no buttons are pressed (not when a button is released, because there might be other buttons still pressed). Refs #3635 <https://github.com/Genymobile/scrcpy/issues/3635> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-01-30 20:57:54 +01:00
Simon Chan	0afef0c634	Forward action button to device On click event, only the whole buttons state was passed to the device. In addition, on ACTION_DOWN and ACTION_UP, pass the button associated to the action. Refs #3635 <https://github.com/Genymobile/scrcpy/issues/3635> Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-01-30 20:57:54 +01:00
Romain Vimont	07806ba915	Retry on spurious error MediaCodec may fail spuriously, typically when stopping an encoding and starting a new one immediately (for example on device rotation). In that case, retry a few times, in many cases it should work. Refs #3693 <https://github.com/Genymobile/scrcpy/issues/3693>	2023-01-30 20:55:51 +01:00
Romain Vimont	a52053421a	Extract retry handling Move the code to downscale and retry on error out of the catch-block. Refs `26b4104844`	2023-01-29 14:49:36 +01:00
Romain Vimont	a9b2697f3e	Move local variables declarations This makes it clear that these local variables are only passed to setDisplaySurface().	2023-01-27 22:43:16 +01:00
Romain Vimont	b53d2c66e0	Remove useless setSize() method Inline its content. It makes the logic of internalStreamScreen() more readable (it reduces the number of indirections).	2023-01-27 22:39:28 +01:00
Romain Vimont	6cccf3ab2a	Remove useless configure() method Inline its single call.	2023-01-27 22:38:37 +01:00
Romain Vimont	52f85fd6f1	Keep the same MediaCodec instance across sessions Calling codec.reset() is sufficient.	2023-01-27 22:31:09 +01:00
Romain Vimont	91c69ad95c	Remove useless destroyDisplay() method The method made exactly one simple call. Just make the call directly.	2023-01-27 22:28:11 +01:00
Romain Vimont	75d7c01a0c	Keep the same display binder across sessions Do not destroy/recreate the display when starting a new encoding session (on device rotation for example).	2023-01-27 22:26:01 +01:00
Romain Vimont	74d32e612d	Terminate loop explicitly on interrupted Make explicit that the loop terminates when the current thread is interrupted.	2023-01-27 22:20:35 +01:00
Romain Vimont	bdba554118	Use Java lambdas where possible	2023-01-27 22:16:36 +01:00
Romain Vimont	234ad7ee78	Support Java lambdas in build_without_gradle.sh Building Java source code using lambdas requires core-lambda-stubs.jar. Refs #3657 <https://github.com/Genymobile/scrcpy/issues/3657>	2023-01-27 22:08:25 +01:00
Romain Vimont	8cbbcc939f	Add missing final modifiers	2023-01-27 22:08:17 +01:00
Romain Vimont	b22810b17c	Use try-with-resources Replace an explicit try-finally by a try-with-resources block.	2023-01-27 21:59:26 +01:00
Romain Vimont	4315be1648	Use random name for device socket For the initial connection between the device and the computer, an adb tunnel is established (with "adb reverse" or "adb forward"). The device-side of the tunnel is a local socket having the hard-coded name "scrcpy". This may cause issues when several scrcpy instances are started in a few seconds for the same device, since they will try to bind the same name. To avoid conflicts, make the client generate a random UID, and append this UID to the local socket name ("scrcpy_01234567").	2023-01-27 21:51:59 +01:00
Romain Vimont	74e3f8b253	Add random util Add a user-friendly tool to generate random numbers.	2023-01-27 19:26:19 +01:00
Romain Vimont	059ec45f82	Add jrand48()/nrand48() compat functions These functions are not available on all platforms.	2023-01-26 18:11:23 +01:00
Romain Vimont	e6cd42355b	Use separate gen dir to build without gradle The generated source files were written to the classes dir. Use a separate gen dir instead.	2023-01-26 10:44:31 +01:00
Romain Vimont	bf8696d02e	Avoid unnecessary copy on config packets demuxing Use av_packet_ref() to reference the packet without copy. This also simplifies the logic, by making the "offset" variable and the memcpy() call local to the if-block.	2023-01-02 16:18:23 +01:00
Romain Vimont	d8c2fe6ef2	Revert "Remove continuous resizing workaround for Windows" This reverts commit `18082f6069`. I can't reproduce, but it seems the workaround improves the behavior on some Windows versions. Fixes #3640 <https://github.com/Genymobile/scrcpy/issues/3640> Refs #3458 <https://github.com/Genymobile/scrcpy/issues/3458>	2022-12-26 12:42:59 +01:00
Romain Vimont	54c7baceac	Use "meson setup" from install_release.sh Refs `64821466a1`	2022-12-22 13:07:07 +01:00
Romain Vimont	4c43784fd1	Update links to v1.25	2022-12-22 12:44:01 +01:00
Romain Vimont	fe21158c20	Bump version to 1.25	2022-12-22 12:33:29 +01:00
Romain Vimont	8e0c899218	Upgrade FFmpeg (5.1.2) for Windows 64-bit Use the latest version of FFmpeg in Windows 64-bit releases.	2022-12-22 12:33:08 +01:00
Romain Vimont	725a922271	Upgrade SDL (2.26.1) for Windows Include the latest version of SDL in Windows releases.	2022-12-22 12:29:08 +01:00
Romain Vimont	b5773a6fe8	Upgrade platform-tools (33.0.3) for Windows Include the latest version of adb in Windows releases.	2022-12-22 12:29:08 +01:00
Romain Vimont	67fb457dcb	Merge branch 'master' into dev	2022-12-22 12:29:00 +01:00
Pawel Jasinski	c7b1d0ea9a	Force mouse source when --forward-all-clicks Right click and middle click require the source device to be a mouse, not a touchscreen. Therefore, the source device was changed only when a button other than the primary button was pressed (see `adc547fa6e`). However, this led to inconsistencies between the ACTION_DOWN when a secondary button is pressed (with a mouse as source device) and the matching ACTION_UP when the secondary button is released (with a touchscreen as source device, because then there is no button pressed). To avoid the problem in all cases, force a mouse as source device when --forward-all-clicks is set. Concretely, for mouse events in --forward-all-clicks mode: - device source is set to InputDevice.SOURCE_MOUSE; - motion event toolType is set to MotionEvent.TOOL_TYPE_MOUSE; Otherwise (when --forward-all-clicks is unset, or for real touch events), finger events are injected: - device source is set to InputDevice.SOURCE_TOUCHSCREEN; - motion event toolType is set to MotionEvent.TOOL_TYPE_FINGER. Fixes #3568 <https://github.com/Genymobile/scrcpy/issues/3568> PR #3579 <https://github.com/Genymobile/scrcpy/pull/3579> Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2022-12-22 11:26:26 +01:00
Romain Vimont	18082f6069	Remove continuous resizing workaround for Windows It turns out that the workaround only worked for MacOS. Refs #3458 <https://github.com/Genymobile/scrcpy/issues/3458> Refs SDL/#1059 <https://github.com/libsdl-org/SDL/issues/1059>	2022-12-21 22:06:43 +01:00
Romain Vimont	8b38b11875	Add parent directory in release zipfile This avoids to mistakenly extract all the files in the current directory.	2022-12-21 13:31:18 +01:00
Romain Vimont	64821466a1	Use "meson setup" This fixes the following warning: > WARNING: Running the setup command as `meson [options]` instead of > `meson setup [options]` is ambiguous and deprecated.	2022-12-21 13:29:27 +01:00
Romain Vimont	82cb8ab870	Adapt ClipboardManager for Android 13 A new "attributionTag" parameter has been added to the methods getPrimaryClip(), setPrimaryClip() and addPrimaryClipChangedListener() of IClipboard.aidl. Refs <`0e3e509b3b`%5E%21/> Fixes #3497 <https://github.com/Genymobile/scrcpy/issues/3497>	2022-12-21 13:28:22 +01:00
Romain Vimont	b51841e85d	Upgrade junit to 4.13.2	2022-12-21 13:28:22 +01:00
Romain Vimont	bd1deffa70	Use current adb port (if any) for --tcpip If the current adb port is not 5555 (typically 0 because it is not in TCP/IP mode), --tcpip automatically executes (among other commands): adb tcpip 5555 In case adb was already listening on another port, this command forced to listen on 5555, and the connection should still succeed. But this reconfiguration might be inconvenient for the user. If adb is already in TCP/IP mode, use the current enabled port without reconfiguration. Fixes #3591 <https://github.com/Genymobile/scrcpy/issues/3591>	2022-12-02 19:09:53 +01:00
Romain Vimont	6469b55861	Fix CommandParserTest code style Make checkstyle happy.	2022-11-24 09:27:10 +01:00
Romain Vimont	c00a9ead5e	Always use --key=value in README Mandatory arguments may be passed in either of these two forms: 1. --key value 2. --key=value Optional argument may only be passed in the second form. For consistency, always document using --key=value. Refs `f76fe2c0d4`	2022-11-17 09:27:05 +01:00
SeungHoon Han	597703b62e	Fix DisplayInfo parsing for Android Q The DisplayInfo dump format has slightly changed in AOSP: <`1039ea50f3`> PR #3573 <https://github.com/Genymobile/scrcpy/pull/3573> Ref #3416 <https://github.com/Genymobile/scrcpy/pull/3416> Signed-off-by: Romain Vimont <rom@rom1v.com>	2022-11-12 18:15:45 +01:00
Yu-Chen Lin	48bb6f2ea8	Support wchar_t in argv for Windows PR #3547 <https://github.com/Genymobile/scrcpy/pull/3547> Fixes #2932 <https://github.com/Genymobile/scrcpy/issues/2932> Signed-off-by: Yu-Chen Lin <npes87184@gmail.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2022-10-23 23:45:00 +02:00
Yu-Chen Lin	d71587e39b	Avoid string concatenation in crossfiles This feature is not supported on older meson versions: ERROR: Malformed value in cross file variable prebuilt_libusb. Refs <https://github.com/mesonbuild/meson/issues/3878> PR #3546 <https://github.com/Genymobile/scrcpy/pull/3546> Signed-off-by: Yu-Chen Lin <npes87184@gmail.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2022-10-23 12:31:44 +02:00
Romain Vimont	b62424a98a	Build log.c for test_cli On Windows, sc_log_windows_error() is called from net.c, so log.c must also be compiled. Fixes #3542 <https://github.com/Genymobile/scrcpy/issues/3542>	2022-10-19 15:17:43 +02:00
Romain Vimont	ffc7b91693	Add missing include <string.h> for strlen()	2022-10-19 15:14:56 +02:00
Romain Vimont	cb46e4a64a	Add missing include <string.h> for memmove()	2022-10-19 15:13:55 +02:00
Anima C13	16e2c1ce26	Add -s auto-completion for zsh Fixes #3522 <https://github.com/Genymobile/scrcpy/pull/3522> PR #3523 <https://github.com/Genymobile/scrcpy/pull/3523> Signed-off-by: Romain Vimont <rom@rom1v.com>	2022-10-12 13:24:43 +02:00
Anima C13	1bfbadef96	Add -s auto-completion for bash Fixes #3522 <https://github.com/Genymobile/scrcpy/pull/3522> PR #3523 <https://github.com/Genymobile/scrcpy/pull/3523> Signed-off-by: Romain Vimont <rom@rom1v.com>	2022-10-12 13:24:43 +02:00
Romain Vimont	72ba913324	Move README and FAQ translations to the wiki This lowers the barrier to contribute to translations, and frees up my maintenance time used to review and merge translations and their updates in many languages.	2022-08-28 15:13:03 +02:00
Romain Vimont	77ebe786ea	Fix FAQ formatting	2022-08-21 13:52:51 +02:00
Romain Vimont	ed84e18b1a	Document envvars for all platforms Document how to set environment variables from the terminal for bash, cmd and PowerShell.	2022-06-17 08:44:17 +02:00
Romain Vimont	a83c3e30f3	Fix environment variable configuration in FAQ In bash, the variable is set using "export".	2022-06-17 08:36:58 +02:00