fix timestamp

wip
localId
2019-09-30 21:30:36 +02:00 · 2019-09-30 21:30:36 +02:00 · 2019-09-30 21:30:36 +02:00 · 2019-09-30 21:30:36 +02:00 · 2019-09-30 21:30:36 +02:00 · 2019-09-30 21:30:36 +02:00
140 changed files with 2386 additions and 11552 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,29 +0,0 @@
 ---
 name: Bug report
 about: Create a report to help us improve
 title: ''
 labels: ''
 assignees: ''
 ---
 - [ ] I have read the [FAQ](https://github.com/Genymobile/scrcpy/blob/master/FAQ.md).
 - [ ] I have searched in existing [issues](https://github.com/Genymobile/scrcpy/issues).
 **Environment**
 - OS: [e.g. Debian, Windows, macOS...]
 - scrcpy version: [e.g. 1.12.1]
 - installation method: [e.g. manual build, apt, snap, brew, Windows release...]
 - device model:
 - Android version: [e.g. 10]
 **Describe the bug**
 A clear and concise description of what the bug is.
 On errors, please provide the output of the console (and `adb logcat` if relevant).
 ```
 Please paste terminal output in a code block.
 ```
 Please do not post screenshots of your terminal, just post the content as text instead.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,22 +0,0 @@
 ---
 name: Feature request
 about: Suggest an idea for this project
 title: ''
 labels: ''
 assignees: ''
 ---
 - [ ] I have checked that a similar [feature request](https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3A%22feature+request%22) does not already exist.
 **Is your feature request related to a problem? Please describe.**
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 **Describe the solution you'd like**
 A clear and concise description of what you want to happen.
 **Describe alternatives you've considered**
 A clear and concise description of any alternative solutions or features you've considered.
 **Additional context**
 Add any other context or screenshots about the feature request here.
--- a/.gitignore
+++ b/.gitignore
@@ -1,9 +1,4 @@
 build/
 /dist/
 /build-*/
 /build_*/
 /release-*/
 .idea/
 .gradle/
 /x/
 local.properties
--- a/BUILD.md
+++ b/BUILD.md
@@ -2,59 +2,11 @@
 Here are the instructions to build _scrcpy_ (client and server).
 You may want to build only the client: the server binary, which will be pushed
 to the Android device, does not depend on your system and architecture. In that
 case, use the [prebuilt server] (so you will not need Java or the Android SDK).
-## Simple
+[prebuilt server]: #prebuilt-server
 If you just want to install the latest release from `master`, follow this
 simplified process.
 First, you need to install the required packages:
 ```bash
 # for Debian/Ubuntu
 sudo apt install ffmpeg libsdl2-2.0-0 adb wget \
                 gcc git pkg-config meson ninja-build \
                 libavcodec-dev libavformat-dev libavutil-dev libsdl2-dev
 ```
 Then clone the repo and execute the installation script
 ([source](install_release.sh)):
 ```bash
 git clone https://github.com/Genymobile/scrcpy
 cd scrcpy
 ./install_release.sh
 ```
 When a new release is out, update the repo and reinstall:
 ```bash
 git pull
 ./install_release.sh
 ```
 To uninstall:
 ```bash
 sudo ninja -Cbuild-auto uninstall
 ```
 ## Branches
 ### `master`
 The `master` branch concerns the latest release, and is the home page of the
 project on Github.
 ### `dev`
 `dev` is the current development branch. Every commit present in `dev` will be
 in the next release.
 If you want to contribute code, please base your commits on the latest `dev`
 branch.
 ## Requirements
@@ -88,14 +40,15 @@ Install the required packages from your package manager.
 ```bash
 # runtime dependencies
-sudo apt install ffmpeg libsdl2-2.0-0 adb
+sudo apt install ffmpeg libsdl2-2.0-0
 # client build dependencies
 sudo apt install gcc git pkg-config meson ninja-build \
-                 libavcodec-dev libavformat-dev libavutil-dev libsdl2-dev
+                 libavcodec-dev libavformat-dev libavutil-dev \
                 libsdl2-dev
 # server build dependencies
-sudo apt install openjdk-11-jdk
+sudo apt install openjdk-8-jdk
 ```
 On old versions (like Ubuntu 16.04), `meson` is too old. In that case, install
@@ -137,13 +90,13 @@ sudo apt install mingw-w64 mingw-w64-tools
 You also need the JDK to build the server:
 ```bash
-sudo apt install openjdk-11-jdk
+sudo apt install openjdk-8-jdk
 ```
 Then generate the releases:
 ```bash
-./release.sh
+make -f Makefile.CrossWindows
 ```
 It will generate win32 and win64 releases into `dist/`.
@@ -204,12 +157,12 @@ brew install pkg-config meson
 ```
 Additionally, if you want to build the server, install Java 8 from Caskroom, and
-make it available from the `PATH`:
+make it avaliable from the `PATH`:
 ```bash
-brew tap homebrew/cask-versions
+brew tap caskroom/versions
-brew install adoptopenjdk/openjdk/adoptopenjdk11
+brew cask install java8
-export JAVA_HOME="$(/usr/libexec/java_home --version 1.11)"
+export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
 export PATH="$JAVA_HOME/bin:$PATH"
 ```
@@ -220,44 +173,30 @@ See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).
 ## Common steps
-**As a non-root user**, clone the project:
+If you want to build the server, install the [Android SDK] (_Android Studio_),
 and set `ANDROID_HOME` to its directory. For example:
 [Android SDK]: https://developer.android.com/studio/index.html
 ```bash
 export ANDROID_HOME=~/android/sdk
 ```
 If you don't want to build the server, use the [prebuilt server].
 Clone the project:
 ```bash
 git clone https://github.com/Genymobile/scrcpy
 cd scrcpy
 ```
 ### Build
 You may want to build only the client: the server binary, which will be pushed
 to the Android device, does not depend on your system and architecture. In that
 case, use the [prebuilt server] (so you will not need Java or the Android SDK).
 [prebuilt server]: #option-2-use-prebuilt-server
 #### Option 1: Build everything from sources
 Install the [Android SDK] (_Android Studio_), and set `ANDROID_SDK_ROOT` to its
 directory. For example:
 [Android SDK]: https://developer.android.com/studio/index.html
 ```bash
 # Linux
 export ANDROID_SDK_ROOT=~/Android/Sdk
 # Mac
 export ANDROID_SDK_ROOT=~/Library/Android/sdk
 # Windows
 set ANDROID_SDK_ROOT=%LOCALAPPDATA%\Android\sdk
 ```
 Then, build:
 ```bash
 meson x --buildtype release --strip -Db_lto=true
-ninja -Cx  # DO NOT RUN AS ROOT
+cd x
 ninja
 ```
 _Note: `ninja` [must][ninja-user] be run as a non-root user (only `ninja
@@ -266,27 +205,9 @@ install` must be run as root)._
 [ninja-user]: https://github.com/Genymobile/scrcpy/commit/4c49b27e9f6be02b8e63b508b60535426bd0291a
-#### Option 2: Use prebuilt server
+### Run
- - [`scrcpy-server-v1.17`][direct-scrcpy-server]  
+To run without installing:
   _(SHA-256: 11b5ad2d1bc9b9730fb7254a78efd71a8ff46b1938ff468e47a21b653a1b6725)_
 [direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-server-v1.17
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
 ```bash
 meson x --buildtype release --strip -Db_lto=true \
    -Dprebuilt_server=/path/to/scrcpy-server
 ninja -Cx  # DO NOT RUN AS ROOT
 ```
 The server only works with a matching client version (this server works with the
 `master` branch).
 ### Run without installing:
 ```bash
 ./run x [options]
@@ -298,19 +219,33 @@ The server only works with a matching client version (this server works with the
 After a successful build, you can install _scrcpy_ on the system:
 ```bash
-sudo ninja -Cx install    # without sudo on Windows
+sudo ninja install    # without sudo on Windows
 ```
-This installs three files:
+This installs two files:
 - `/usr/local/bin/scrcpy`
- - `/usr/local/share/scrcpy/scrcpy-server`
+ - `/usr/local/share/scrcpy/scrcpy-server.jar`
- - `/usr/local/share/man/man1/scrcpy.1`
+
 Just remove them to "uninstall" the application.
 You can then [run](README.md#run) _scrcpy_.
-### Uninstall
+
 ## Prebuilt server
 - [`scrcpy-server-v1.10.jar`][direct-scrcpy-server]  
   _(SHA-256: cbeb1a4e046f1392c1dc73c3ccffd7f86dec4636b505556ea20929687a119390)_
 [direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.10/scrcpy-server-v1.10.jar
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
 ```bash
-sudo ninja -Cx uninstall  # without sudo on Windows
+meson x --buildtype release --strip -Db_lto=true \
    -Dprebuilt_server=/path/to/scrcpy-server.jar
 cd x
 ninja
 sudo ninja install
 ```
--- a/DEVELOP.md
+++ b/DEVELOP.md
@@ -3,7 +3,7 @@
 ## Overview
 This application is composed of two parts:
- - the server (`scrcpy-server`), to be executed on the device,
+ - the server (`scrcpy-server.jar`), to be executed on the device,
 - the client (the `scrcpy` binary), executed on the host computer.
 The client is responsible to push the server to the device and start its
@@ -49,7 +49,7 @@ application may not replace the server just before the client executes it._
 Instead of a raw _dex_ file, `app_process` accepts a _jar_ containing
 `classes.dex` (e.g. an [APK]). For simplicity, and to benefit from the gradle
 build system, the server is built to an (unsigned) APK (renamed to
-`scrcpy-server`).
+`scrcpy-server.jar`).
 [dex]: https://en.wikipedia.org/wiki/Dalvik_(software)
 [apk]: https://en.wikipedia.org/wiki/Android_application_package
@@ -189,7 +189,7 @@ The client uses 4 threads:
   recording,
 - the **controller** thread, sending _control messages_ to the server,
 - the **receiver** thread (managed by the controller), receiving _device
-   messages_ from the server.
+   messages_ from the client.
 In addition, another thread can be started if necessary to handle APK
 installation or file push requests (via drag&drop on the main window) or to
@@ -211,10 +211,10 @@ There are two [frames][video_buffer] simultaneously in memory:
 - the **rendering** frame, rendered in a texture from the main thread.
 When a new decoded frame is available, the decoder _swaps_ the decoding and
-rendering frame (with proper synchronization). Thus, it immediately starts
+rendering frame (with proper synchronization). Thus, it immediatly starts
 to decode a new frame while the main thread renders the last one.
-If a [recorder] is present (i.e. `--record` is enabled), then it muxes the raw
+If a [recorder] is present (i.e. `--record` is enabled), then its muxes the raw
 H.264 packet to the output video file.
 [stream]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/stream.h
@@ -268,42 +268,3 @@ For more details, go read the code!
 If you find a bug, or have an awesome idea to implement, please discuss and
 contribute ;-)
 ### Debug the server
 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
 # or, if x is already configured
 meson configure x -Dserver_debugger=true
 ```
 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
 # or, if x is already configured
 meson configure x -Dserver_debugger=true -Dserver_debugger_method=old
 ```
 Then recompile.
 When you start scrcpy, it will start a debugger on port 5005 on the device.
 Redirect that port to the computer:
 ```bash
 adb forward tcp:5005 tcp:5005
 ```
 In Android Studio, _Run_ > _Debug_ > _Edit configurations..._ On the left, click on
 `+`, _Remote_, and fill the form:
 - Host: `localhost`
 - Port: `5005`
 Then click on _Debug_.
--- 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
@@ -3,107 +3,19 @@
 Here are the common reported problems and their status.
-## `adb` issues
+### On Windows, my device is not detected
-`scrcpy` execute `adb` commands to initialize the connection with the device. If
+The most common is your device not being detected by `adb`, or is unauthorized.
-`adb` fails, then scrcpy will not work.
+Check everything is ok by calling:
-In that case, it will print this error:
+    adb devices
->     ERROR: "adb push" returned with value 1
+Windows may need some [drivers] to detect your device.
 This is typically not a bug in _scrcpy_, but a problem in your environment.
 To find out the cause, execute:
 ```bash
 adb devices
 ```
 ### `adb` not found
 You need `adb` accessible from your `PATH`.
 On Windows, the current directory is in your `PATH`, and `adb.exe` is included
 in the release, so it should work out-of-the-box.
 ### Device unauthorized
 Check [stackoverflow][device-unauthorized].
 [device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
 ### Device not detected
 >     adb: error: failed to get feature set: no devices/emulators found
 Check that you correctly enabled [adb debugging][enable-adb].
 If your device is not detected, you may need some [drivers] (on Windows).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
-### Several devices connected
+### I can only mirror, I cannot interact with the device
 If several devices are connected, you will encounter this error:
 >     adb: error: failed to get feature set: more than one device/emulator
 the identifier of the device you want to mirror must be provided:
 ```bash
 scrcpy -s 01234567890abcdef
 ```
 Note that if your device is connected over TCP/IP, you'll get this message:
 >     adb: error: more than one device/emulator
 >     ERROR: "adb reverse" returned with value 1
 >     WARN: 'adb reverse' failed, fallback to 'adb forward'
 This is expected (due to a bug on old Android versions, see [#5]), but in that
 case, scrcpy fallbacks to a different method, which should work.
 [#5]: https://github.com/Genymobile/scrcpy/issues/5
 ### Conflicts between adb versions
 >     adb server version (41) doesn't match this client (39); killing...
 This error occurs when you use several `adb` versions simultaneously. You must
 find the program using a different `adb` version, and use the same `adb` version
 everywhere.
 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
 scrcpy
 ```
 ### Device disconnected
 If _scrcpy_ stops itself with the warning "Device disconnected", then the
 `adb` connection has been closed.
 Try with another USB cable or plug it into another USB port. See [#281] and
 [#283].
 [#281]: https://github.com/Genymobile/scrcpy/issues/281
 [#283]: https://github.com/Genymobile/scrcpy/issues/283
 ## Control issues
 ### Mouse and keyboard do not work
 On some devices, you may need to enable an option to allow [simulating input].
 In developer options, enable:
@@ -114,36 +26,25 @@ In developer options, enable:
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-### Special characters do not work
+### Mouse clicks at wrong location
-Injecting text input is [limited to ASCII characters][text-input]. A trick
+On MacOS, with HiDPI support and multiple screens, input location are wrongly
-allows to also inject some [accented characters][accented-characters], but
+scaled. See [issue 15].
 that's all. See [#37].
-[text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
+[issue 15]: https://github.com/Genymobile/scrcpy/issues/15
 [accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
 [#37]: https://github.com/Genymobile/scrcpy/issues/37
 A workaround is to build with HiDPI support disabled:
-## Client issues
+```bash
-
+meson x --buildtype release -Dhidpi_support=false
 ### The quality is low
 If the definition of your client window is smaller than that of your device
 screen, then you might get poor quality, especially visible on text (see [#40]).
 [#40]: https://github.com/Genymobile/scrcpy/issues/40
 To improve downscaling quality, trilinear filtering is enabled automatically
 if the renderer is OpenGL and if it supports mipmapping.
 On Windows, you might want to force OpenGL:
 ```
 scrcpy --render-driver=opengl
 ```
-You may also need to configure the [scaling behavior]:
+However, the video will be displayed at lower resolution.
 ### The quality is low on HiDPI display
 On Windows, you may need to configure the [scaling behavior].
 > `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
 > Override high DPI scaling behavior > Scaling performed by: _Application_.
@@ -151,7 +52,6 @@ You may also need to configure the [scaling behavior]:
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 ### KWin compositor crashes
 On Plasma Desktop, compositor is disabled while _scrcpy_ is running.
@@ -161,29 +61,19 @@ As a workaround, [disable "Block compositing"][kwin].
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
-## Crashes
+### I get an error "Could not open video stream"
 ### Exception
 There may be many reasons. One common cause is that the hardware encoder of your
 device is not able to encode at the given definition:
-> ```
+```
-> ERROR: Exception on thread Thread[main,5,main]
+ERROR: Exception on thread Thread[main,5,main]
-> android.media.MediaCodec$CodecException: Error 0xfffffc0e
+android.media.MediaCodec$CodecException: Error 0xfffffc0e
-> ...
+...
-> Exit due to uncaughtException in main thread:
+Exit due to uncaughtException in main thread:
-> ERROR: Could not open video stream
+ERROR: Could not open video stream
-> INFO: Initial texture: 1080x2336
+INFO: Initial texture: 1080x2336
-> ```
+```
 or
 > ```
 > ERROR: Exception on thread Thread[main,5,main]
 > java.lang.IllegalStateException
 >         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
 > ```
 Just try with a lower definition:
@@ -192,41 +82,3 @@ scrcpy -m 1920
 scrcpy -m 1024
 scrcpy -m 800
 ```
 You could also try another [encoder](README.md#encoder).
 ## Command line on Windows
 Some Windows users are not familiar with the command line. Here is how to open a
 terminal and run `scrcpy` with arguments:
 1. Press <kbd>Windows</kbd>+<kbd>r</kbd>, this opens a dialog box.
 2. Type `cmd` and press <kbd>Enter</kbd>, this opens a terminal.
 3. Go to your _scrcpy_ directory, by typing (adapt the path):
    ```bat
    cd C:\Users\user\Downloads\scrcpy-win64-xxx
    ```
    and press <kbd>Enter</kbd>
 4. Type your command. For example:
    ```bat
    scrcpy --record file.mkv
    ```
 If you plan to always use the same arguments, create a file `myscrcpy.bat`
 (enable [show file extensions] to avoid confusion) in the `scrcpy` directory,
 containing your command. For example:
 ```bat
 scrcpy --prefer-text --turn-screen-off --stay-awake
 ```
 Then just double-click on that file.
 You could also edit (a copy of) `scrcpy-console.bat` or `scrcpy-noconsole.vbs`
 to add some arguments.
 [show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/
--- a/2
+++ b/2
@@ -188,7 +188,7 @@
      identification within third-party archives.
   Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2021 Romain Vimont
+   Copyright (C) 2018-2019 Romain Vimont
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
--- a/Makefile.CrossWindows
+++ b/Makefile.CrossWindows
@@ -3,26 +3,27 @@
 #
 # Here, "portable" means that the client and server binaries are expected to be
 # anywhere, but in the same directory, instead of well-defined separate
-# locations (e.g. /usr/bin/scrcpy and /usr/share/scrcpy/scrcpy-server).
+# locations (e.g. /usr/bin/scrcpy and /usr/share/scrcpy/scrcpy-server.jar).
 #
 # In particular, this implies to change the location from where the client push
 # the server to the device.
 .PHONY: default clean \
 	test \
 	build-server \
 	prepare-deps-win32 prepare-deps-win64 \
-	build-win32 build-win64 \
+	build-win32 build-win32-noconsole \
 	build-win64 build-win64-noconsole \
 	dist-win32 dist-win64 \
 	zip-win32 zip-win64 \
-	release
+	sums release
 GRADLE ?= ./gradlew
 TEST_BUILD_DIR := build-test
 SERVER_BUILD_DIR := build-server
 WIN32_BUILD_DIR := build-win32
 WIN32_NOCONSOLE_BUILD_DIR := build-win32-noconsole
 WIN64_BUILD_DIR := build-win64
 WIN64_NOCONSOLE_BUILD_DIR := build-win64-noconsole
 DIST := dist
 WIN32_TARGET_DIR := scrcpy-win32
@@ -32,35 +33,19 @@ VERSION := $(shell git describe --tags --always)
 WIN32_TARGET := $(WIN32_TARGET_DIR)-$(VERSION).zip
 WIN64_TARGET := $(WIN64_TARGET_DIR)-$(VERSION).zip
-RELEASE_DIR := release-$(VERSION)
+release: clean zip-win32 zip-win64 sums
-
+	@echo "Windows archives generated in $(DIST)/"
 release: clean test build-server zip-win32 zip-win64
 	mkdir -p "$(RELEASE_DIR)"
 	cp "$(SERVER_BUILD_DIR)/server/scrcpy-server" \
 		"$(RELEASE_DIR)/scrcpy-server-$(VERSION)"
 	cp "$(DIST)/$(WIN32_TARGET)" "$(RELEASE_DIR)"
 	cp "$(DIST)/$(WIN64_TARGET)" "$(RELEASE_DIR)"
 	cd "$(RELEASE_DIR)" && \
 		sha256sum "scrcpy-server-$(VERSION)" \
 			"scrcpy-win32-$(VERSION).zip" \
 			"scrcpy-win64-$(VERSION).zip" > SHA256SUMS.txt
 	@echo "Release generated in $(RELEASE_DIR)/"
 clean:
 	$(GRADLE) clean
-	rm -rf "$(DIST)" "$(TEST_BUILD_DIR)" "$(SERVER_BUILD_DIR)" \
+	rm -rf "$(SERVER_BUILD_DIR)" "$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)" \
-		"$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)"
+		   "$(WIN32_NOCONSOLE_BUILD_DIR)" "$(WIN64_NOCONSOLE_BUILD_DIR)" "$(DIST)"
 test:
 	[ -d "$(TEST_BUILD_DIR)" ] || ( mkdir "$(TEST_BUILD_DIR)" && \
 		meson "$(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 "$(SERVER_BUILD_DIR)" \
-	ninja -C "$(SERVER_BUILD_DIR)"
+			--buildtype release -Dcompile_app=false )
 		ninja -C "$(SERVER_BUILD_DIR)"
 prepare-deps-win32:
 	-$(MAKE) -C prebuilt-deps prepare-win32
@@ -75,6 +60,17 @@ build-win32: prepare-deps-win32
 			-Dportable=true )
 	ninja -C "$(WIN32_BUILD_DIR)"
 build-win32-noconsole: prepare-deps-win32
 	[ -d "$(WIN32_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN32_NOCONSOLE_BUILD_DIR)" && \
 		meson "$(WIN32_NOCONSOLE_BUILD_DIR)" \
 			--cross-file cross_win32.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
 			-Dcompile_server=false \
 			-Dwindows_noconsole=true \
 			-Dportable=true )
 	ninja -C "$(WIN32_NOCONSOLE_BUILD_DIR)"
 prepare-deps-win64:
 	-$(MAKE) -C prebuilt-deps prepare-win64
@@ -88,37 +84,46 @@ build-win64: prepare-deps-win64
 			-Dportable=true )
 	ninja -C "$(WIN64_BUILD_DIR)"
-dist-win32: build-server build-win32
+build-win64-noconsole: prepare-deps-win64
 	[ -d "$(WIN64_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN64_NOCONSOLE_BUILD_DIR)" && \
 		meson "$(WIN64_NOCONSOLE_BUILD_DIR)" \
 			--cross-file cross_win64.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
 			-Dcompile_server=false \
 			-Dwindows_noconsole=true \
 			-Dportable=true )
 	ninja -C "$(WIN64_NOCONSOLE_BUILD_DIR)"
 dist-win32: build-server build-win32 build-win32-noconsole
 	mkdir -p "$(DIST)/$(WIN32_TARGET_DIR)"
-	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp data/scrcpy-console.bat "$(DIST)/$(WIN32_TARGET_DIR)"
+	cp "$(WIN32_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp data/scrcpy-noconsole.vbs "$(DIST)/$(WIN32_TARGET_DIR)"
+	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.14/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.10/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-dist-win64: build-server build-win64
+dist-win64: build-server build-win64 build-win64-noconsole
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
-	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp data/scrcpy-console.bat "$(DIST)/$(WIN64_TARGET_DIR)"
+	cp "$(WIN64_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp data/scrcpy-noconsole.vbs "$(DIST)/$(WIN64_TARGET_DIR)"
+	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.14/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.10/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 zip-win32: dist-win32
 	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
@@ -127,3 +132,7 @@ zip-win32: dist-win32
 zip-win64: dist-win64
 	cd "$(DIST)/$(WIN64_TARGET_DIR)"; \
 		zip -r "../$(WIN64_TARGET)" .
 sums:
 	cd "$(DIST)"; \
 		sha256sum *.zip > SHA256SUMS.txt
--- 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-2021 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## Artikel
 - [Introducing scrcpy][article-intro]
 - [Scrcpy now works wirelessly][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.jp.md
+++ b/README.jp.md
@@ -1,725 +0,0 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._
 # scrcpy (v1.17)
 このアプリケーションは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
 # Homebrew >= 2.6.0
 brew install --cask android-platform-tools
 # Homebrew < 2.6.0
 brew cask install android-platform-tools
 ```
 また、[アプリケーションをビルド][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 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
 ### 接続
 #### ワイヤレス
 _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
 ```
 #### 期限切れフレームをレンダリングする
 初期状態では、待ち時間を最小限にするために、_scrcpy_ は最後にデコードされたフレームをレンダリングし、前のフレームを削除します。
 全フレームのレンダリングを強制するには(待ち時間が長くなる可能性があります):
 ```bash
 scrcpy --render-expired-frames
 ```
 #### タッチを表示
 プレゼンテーションの場合(物理デバイス上で)物理的なタッチを表示すると便利な場合があります。
 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/`ディレクトリにファイルを送るには、(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>でショートカット変更します。初期状態では、(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>
 | `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>
 | 通知パネルを折りたたむ                        | <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を押します._  
 _³Android 7以上のみ._
 全ての<kbd>Ctrl</kbd>+_キー_ ショートカットはデバイスに転送されます、そのためアクティブなアプリケーションによって処理されます。
 ## カスタムパス
 特定の _adb_ バイナリを使用する場合、そのパスを環境変数`ADB`で構成します:
    ADB=/path/to/adb scrcpy
 `scrcpy-server`ファイルのパスを上書きするには、`SCRCPY_SERVER_PATH`でそのパスを構成します。
 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## なぜ _scrcpy_?
 同僚が私に、[gnirehtet]のように発音できない名前を見つけるように要求しました。
 [`strcpy`]は**str**ingをコピーします。`scrcpy`は**scr**eenをコピーします。
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## ビルド方法は?
 [BUILD]を参照してください。
 [BUILD]: BUILD.md
 ## よくある質問
 [FAQ](FAQ.md)を参照してください。
 ## 開発者
 [開発者のページ]を読んでください。
 [開発者のページ]: DEVELOP.md
 ## ライセンス
    Copyright (C) 2018 Genymobile
    Copyright (C) 2018-2021 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## 記事
 - [Introducing scrcpy][article-intro]
 - [Scrcpy now works wirelessly][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- 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-2021 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## 관련 글 (articles)
 - [scrcpy 소개][article-intro]
 - [무선으로 연결하는 Scrcpy][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.md
+++ b/README.md
@@ -1,6 +1,4 @@
-# scrcpy (v1.17)
+# scrcpy (v1.10)
 [Read in another language](#translations)
 This application provides display and control of Android devices connected on
 USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
@@ -36,27 +34,11 @@ control it using keyboard and mouse.
 ## Get the 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>
 ### Summary
 - Linux: `apt install scrcpy`
 - Windows: [download][direct-win64]
 - macOS: `brew install scrcpy`
 Build from sources: [BUILD] ([simplified process][BUILD_simple])
 [BUILD]: BUILD.md
 [BUILD_simple]: BUILD.md#simple
 ### Linux
-On Debian (_testing_ and _sid_ for now) and Ubuntu (20.04):
+On Linux, you typically need to [build the app manually][BUILD]. Don't worry,
-
+it's not that hard.
 ```
 apt install scrcpy
 ```
 A [Snap] package is available: [`scrcpy`][snap-link].
@@ -64,11 +46,6 @@ A [Snap] package is available: [`scrcpy`][snap-link].
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
 For Fedora, a [COPR] package is available: [`scrcpy`][copr-link].
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 For Arch Linux, an [AUR] package is available: [`scrcpy`][aur-link].
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
@@ -79,37 +56,19 @@ For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 You could also [build the app manually][BUILD] ([simplified
 process][BUILD_simple]).
 ### Windows
-For Windows, for simplicity, a prebuilt archive with all the dependencies
+For Windows, for simplicity, prebuilt archives with all the dependencies
-(including `adb`) is available:
+(including `adb`) are available:
- - [`scrcpy-win64-v1.17.zip`][direct-win64]  
+ - [`scrcpy-win32-v1.10.zip`][direct-win32]  
-   _(SHA-256: 8b9e57993c707367ed10ebfe0e1ef563c7a29d9af4a355cd8b6a52a317c73eea)_
+   _(SHA-256: f98b400b3764404b33b212e9762dd6f1593ddb766c1480fc2609c94768e4a8e1)_
 - [`scrcpy-win64-v1.10.zip`][direct-win64]  
   _(SHA-256: 95de34575d873c7e95dfcfb5e74d0f6af4f70b2a5bc6fde0f48d1a05480e3a44)_
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-win64-v1.17.zip
+[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.10/scrcpy-win32-v1.10.zip
-
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.10/scrcpy-win64-v1.10.zip
 It is also available in [Chocolatey]:
 [Chocolatey]: https://chocolatey.org/
 ```bash
 choco install scrcpy
 choco install adb    # if you don't have it yet
 ```
 And in [Scoop]:
 ```bash
 scoop install scrcpy
 scoop install adb    # if you don't have it yet
 ```
 [Scoop]: https://scoop.sh
 You can also [build the app manually][BUILD].
@@ -127,18 +86,9 @@ brew install scrcpy
 You need `adb`, accessible from your `PATH`. If you don't have it yet:
 ```bash
-brew install android-platform-tools
+brew cask install android-platform-tools
 ```
 It's also available in [MacPorts], which sets up adb for you:
 ```bash
 sudo port install scrcpy
 ```
 [MacPorts]: https://www.macports.org/
 You can also [build the app manually][BUILD].
@@ -158,9 +108,8 @@ scrcpy --help
 ## Features
 ### Capture configuration
-#### Reduce size
+### Reduce size
 Sometimes, it is useful to mirror an Android device at a lower definition to
 increase performance.
@@ -176,7 +125,7 @@ The other dimension is computed to that the device aspect ratio is preserved.
 That way, a device in 1920×1080 will be mirrored at 1024×576.
-#### Change bit-rate
+### Change bit-rate
 The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):
@@ -185,17 +134,8 @@ scrcpy --bit-rate 2M
 scrcpy -b 2M  # short version
 ```
 #### Limit frame rate
-The capture frame rate can be limited:
+### Crop
 ```bash
 scrcpy --max-fps 15
 ```
 This is officially supported since Android 10, but may work on earlier versions.
 #### Crop
 The device screen may be cropped to mirror only part of the screen.
@@ -203,83 +143,19 @@ 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 -c 1224:1440:0:0       # short version
 ```
 If `--max-size` is also specified, resizing is applied after cropping.
-#### Lock video orientation
+### Wireless
 To lock the orientation of the mirroring:
 ```bash
 scrcpy --lock-video-orientation 0   # natural orientation
 scrcpy --lock-video-orientation 1   # 90° counterclockwise
 scrcpy --lock-video-orientation 2   # 180°
 scrcpy --lock-video-orientation 3   # 90° clockwise
 ```
 This affects recording orientation.
 The [window may also be rotated](#rotation) independently.
 #### Encoder
 Some devices have more than one encoder, 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 could pass an invalid encoder name, the
 error will give the available encoders:
 ```bash
 scrcpy --encoder _
 ```
 ### Recording
 It is possible to record the screen while mirroring:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 To disable mirroring while recording:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrupt recording with 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.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 ### Connection
 #### Wireless
 _Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
 device over TCP/IP:
 1. Connect the device to the same Wi-Fi as your computer.
-2. Get your device IP address, in Settings → About phone → Status, or by
+2. Get your device IP address (in Settings → About phone → Status).
   executing this command:
    ```bash
    adb shell ip route | awk '{print $9}'
    ```
 3. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
 4. Unplug your device.
 5. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`)_.
@@ -295,7 +171,32 @@ scrcpy -b2M -m800  # short version
 [connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-#### Multi-devices
+### Record screen
 It is possible to record the screen while mirroring:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 To disable mirroring while recording:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrupt recording with Ctrl+C
 # Ctrl+C does not terminate properly on Windows, so disconnect the device
 ```
 "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.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 ### Multi-devices
 If several devices are listed in `adb devices`, you must specify the _serial_:
@@ -304,100 +205,10 @@ scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # short version
 ```
 If the device is connected over TCP/IP:
 ```bash
 scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # short version
 ```
 You can start several instances of _scrcpy_ for several devices.
 #### Autostart on device connection
-You could use [AutoAdb]:
+### Fullscreen
 ```bash
 autoadb scrcpy -s '{}'
 ```
 [AutoAdb]: https://github.com/rom1v/autoadb
 #### SSH tunnel
 To connect to a remote device, it is possible to connect a local `adb` client to
 a remote `adb` server (provided they use the same version of the _adb_
 protocol):
 ```bash
 adb kill-server    # kill the local adb server on 5037
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 From another terminal:
 ```bash
 scrcpy
 ```
 To avoid enabling remote port forwarding, you could force a forward connection
 instead (notice the `-L` instead of `-R`):
 ```bash
 adb kill-server    # kill the local adb server on 5037
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 From another terminal:
 ```bash
 scrcpy --force-adb-forward
 ```
 Like for wireless connections, it may be useful to reduce quality:
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### Window configuration
 #### Title
 By default, the window title is the device model. It can be changed:
 ```bash
 scrcpy --window-title 'My device'
 ```
 #### Position and size
 The initial window position and size may be specified:
 ```bash
 scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 ```
 #### Borderless
 To disable window decorations:
 ```bash
 scrcpy --window-borderless
 ```
 #### Always on top
 To keep the scrcpy window always on top:
 ```bash
 scrcpy --always-on-top
 ```
 #### Fullscreen
 The app may be started directly in fullscreen:
@@ -406,40 +217,58 @@ scrcpy --fullscreen
 scrcpy -f  # short version
 ```
-Fullscreen can then be toggled dynamically with <kbd>MOD</kbd>+<kbd>f</kbd>.
+Fullscreen can then be toggled dynamically with `Ctrl`+`f`.
 #### Rotation
-The window may be rotated:
+### Always on top
 The window of app can always be above others by:
 ```bash
-scrcpy --rotation 1
+scrcpy --always-on-top
 scrcpy -T  # short version
 ```
 Possibles values are:
 - `0`: no rotation
 - `1`: 90 degrees counterclockwise
 - `2`: 180 degrees
 - `3`: 90 degrees clockwise
-The rotation can also be changed dynamically with <kbd>MOD</kbd>+<kbd>←</kbd>
+### Show touches
 _(left)_ and <kbd>MOD</kbd>+<kbd>→</kbd> _(right)_.
-Note that _scrcpy_ manages 3 different rotations:
+For presentations, it may be useful to show physical touches (on the physical
- - <kbd>MOD</kbd>+<kbd>r</kbd> requests the device to switch between portrait
+device).
-   and landscape (the current running app may refuse, if it does not support the
+
-   requested orientation).
+Android provides this feature in _Developers options_.
- - [`--lock-video-orientation`](#lock-video-orientation) changes the mirroring
+
-   orientation (the orientation of the video sent from the device to the
+_Scrcpy_ provides an option to enable this feature on start and disable on exit:
-   computer). This affects the recording.
+
- - `--rotation` (or <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
+```bash
-   rotates only the window content. This affects only the display, not the
+scrcpy --show-touches
-   recording.
+scrcpy -t
 ```
 Note that it only shows _physical_ touches (with the finger on the device).
-### Other mirroring options
+### Install APK
-#### Read-only
+To install an APK, drag & drop an APK file (ending with `.apk`) to the _scrcpy_
 window.
 There is no visual feedback, a log is printed to the console.
 ### Push file to device
 To push a file to `/sdcard/` on the device, drag & drop a (non-APK) file to the
 _scrcpy_ window.
 There is no visual feedback, a log is printed to the console.
 The target directory can be changed on start:
 ```bash
 scrcpy --push-target /sdcard/foo/bar/
 ```
 ### Read-only
 To disable controls (everything which can interact with the device: input keys,
 mouse events, drag&drop files):
@@ -449,38 +278,7 @@ scrcpy --no-control
 scrcpy -n
 ```
-#### Display
+### Turn screen off
 If several displays are available, it is possible to select the display to
 mirror:
 ```bash
 scrcpy --display 1
 ```
 The list of display ids can be retrieved by:
 ```
 adb shell dumpsys display   # search "mDisplayId=" in the output
 ```
 The secondary display may only be controlled if the device runs at least Android
 10 (otherwise it is mirrored in read-only).
 #### Stay awake
 To prevent the device to sleep after some delay when the device is plugged in:
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
 The initial state is restored when scrcpy is closed.
 #### Turn screen off
 It is possible to turn the device screen off while mirroring on start with a
 command-line option:
@@ -490,24 +288,12 @@ scrcpy --turn-screen-off
 scrcpy -S
 ```
-Or by pressing <kbd>MOD</kbd>+<kbd>o</kbd> at any time.
+Or by pressing `Ctrl`+`o` at any time.
-To turn it back on, press <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
+To turn it back on, press `POWER` (or `Ctrl`+`p`).
 On Android, the `POWER` button always turns the screen on. For convenience, if
 `POWER` is sent via scrcpy (via right-click or <kbd>MOD</kbd>+<kbd>p</kbd>), it
 will force to turn the screen off after a small delay (on a best effort basis).
 The physical `POWER` button will still cause the screen to be turned on.
 It can also be useful to prevent the device from sleeping:
 ```bash
 scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
-#### Render expired frames
+### Render expired frames
 By default, to minimize latency, _scrcpy_ always renders the last decoded frame
 available, and drops any previous one.
@@ -519,228 +305,50 @@ latency), use:
 scrcpy --render-expired-frames
 ```
-#### Show touches
+### Custom window title
-For presentations, it may be useful to show physical touches (on the physical
+By default, the window title is the device model. It can be changed:
 device).
 Android provides this feature in _Developers options_.
 _Scrcpy_ provides an option to enable this feature on start and restore the
 initial value on exit:
 ```bash
-scrcpy --show-touches
+scrcpy --window-title 'My device'
 scrcpy -t
 ```
 Note that it only shows _physical_ touches (with the finger on the device).
 #### Disable screensaver
 By default, scrcpy does not prevent the screensaver to run on the computer.
 To disable it:
 ```bash
 scrcpy --disable-screensaver
 ```
-### Input control
+### Forward audio
-#### Rotate device screen
+Audio is not forwarded by _scrcpy_. Use [USBaudio] (Linux-only).
 Press <kbd>MOD</kbd>+<kbd>r</kbd> to switch between portrait and landscape
 modes.
 Note that it rotates only if the application in foreground supports the
 requested orientation.
 #### Copy-paste
 Any time the Android clipboard changes, it is automatically synchronized to the
 computer clipboard.
 Any <kbd>Ctrl</kbd> shortcut is forwarded to the device. In particular:
 - <kbd>Ctrl</kbd>+<kbd>c</kbd> typically copies
 - <kbd>Ctrl</kbd>+<kbd>x</kbd> typically cuts
 - <kbd>Ctrl</kbd>+<kbd>v</kbd> typically pastes (after computer-to-device
   clipboard synchronization)
 This typically works as you expect.
 The actual behavior depends on the active application though. For example,
 _Termux_ sends SIGINT on <kbd>Ctrl</kbd>+<kbd>c</kbd> instead, and _K-9 Mail_
 composes a new message.
 To copy, cut and paste in such cases (but only supported on Android >= 7):
 - <kbd>MOD</kbd>+<kbd>c</kbd> injects `COPY`
 - <kbd>MOD</kbd>+<kbd>x</kbd> injects `CUT`
 - <kbd>MOD</kbd>+<kbd>v</kbd> injects `PASTE` (after computer-to-device
   clipboard synchronization)
 In addition, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> allows to inject the
 computer clipboard text as a sequence of key events. This is useful when the
 component does not accept text pasting (for example in _Termux_), but it can
 break non-ASCII content.
 **WARNING:** Pasting the computer clipboard to the device (either via
 <kbd>Ctrl</kbd>+<kbd>v</kbd> or <kbd>MOD</kbd>+<kbd>v</kbd>) copies the content
 into the device clipboard. As a consequence, any Android application could read
 its content. You should avoid to paste sensitive content (like passwords) that
 way.
 Some devices do not behave as expected when setting the device clipboard
 programmatically. An option `--legacy-paste` is provided to change the behavior
 of <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> so that they
 also inject the computer clipboard text as a sequence of key events (the same
 way as <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
 #### Pinch-to-zoom
 To simulate "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-and-move_.
 More precisely, hold <kbd>Ctrl</kbd> while pressing the left-click button. Until
 the left-click button is released, all mouse movements scale and rotate the
 content (if supported by the app) relative to the center of the screen.
 Concretely, scrcpy generates additional touch events from a "virtual finger" at
 a location inverted through the center of the screen.
 #### Text injection preference
 There are two kinds of [events][textevents] generated when typing text:
 - _key events_, signaling that a key is pressed or released;
 - _text events_, signaling that a text has been entered.
 By default, letters are injected using key events, so that the keyboard behaves
 as expected in games (typically for WASD keys).
 But this may [cause issues][prefertext]. If you encounter such a problem, you
 can avoid it by:
 ```bash
 scrcpy --prefer-text
 ```
 (but this will break keyboard behavior in games)
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 #### Key repeat
 By default, holding a key down generates repeated key events. This can cause
 performance problems in some games, where these events are useless anyway.
 To avoid forwarding repeated key events:
 ```bash
 scrcpy --no-key-repeat
 ```
 #### Right-click and middle-click
 By default, right-click triggers BACK (or POWER on) and middle-click triggers
 HOME. To disable these shortcuts and forward the clicks to the device instead:
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### File drop
 #### Install APK
 To install an APK, drag & drop an APK file (ending with `.apk`) to the _scrcpy_
 window.
 There is no visual feedback, a log is printed to the console.
 #### Push file to device
 To push a file to `/sdcard/` on the device, drag & drop a (non-APK) file to the
 _scrcpy_ window.
 There is no visual feedback, a log is printed to the console.
 The target directory can be changed on start:
 ```bash
 scrcpy --push-target=/sdcard/Download/
 ```
 ### Audio forwarding
 Audio is not forwarded by _scrcpy_. Use [sndcpy].
 Also see [issue #14].
-[sndcpy]: https://github.com/rom1v/sndcpy
+[USBaudio]: https://github.com/rom1v/usbaudio
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## Shortcuts
-In the following list, <kbd>MOD</kbd> is the shortcut modifier. By default, it's
+ | Action                                 |   Shortcut                    |   Shortcut (macOS)
-(left) <kbd>Alt</kbd> or (left) <kbd>Super</kbd>.
+ | -------------------------------------- |:----------------------------- |:-----------------------------
-
+ | Switch fullscreen mode                 | `Ctrl`+`f`                    | `Cmd`+`f`
-It can be changed using `--shortcut-mod`. Possible keys are `lctrl`, `rctrl`,
+ | Resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`                    | `Cmd`+`g`
-`lalt`, `ralt`, `lsuper` and `rsuper`. For example:
+ | Resize window to remove black borders  | `Ctrl`+`x` \| _Double-click¹_ | `Cmd`+`x`  \| _Double-click¹_
-
+ | Click on `HOME`                        | `Ctrl`+`h` \| _Middle-click_  | `Ctrl`+`h` \| _Middle-click_
-```bash
+ | Click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  | `Cmd`+`b`  \| _Right-click²_
-# use RCtrl for shortcuts
+ | Click on `APP_SWITCH`                  | `Ctrl`+`s`                    | `Cmd`+`s`
-scrcpy --shortcut-mod=rctrl
+ | Click on `MENU`                        | `Ctrl`+`m`                    | `Ctrl`+`m`
-
+ | Click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_             | `Cmd`+`↑` _(up)_
-# use either LCtrl+LAlt or LSuper for shortcuts
+ | Click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_           | `Cmd`+`↓` _(down)_
-scrcpy --shortcut-mod=lctrl+lalt,lsuper
+ | Click on `POWER`                       | `Ctrl`+`p`                    | `Cmd`+`p`
-```
+ | Power on                               | _Right-click²_                | _Right-click²_
-
+ | Turn device screen off (keep mirroring)| `Ctrl`+`o`                    | `Cmd`+`o`
-_<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
+ | Expand notification panel              | `Ctrl`+`n`                    | `Cmd`+`n`
-
+ | Collapse notification panel            | `Ctrl`+`Shift`+`n`            | `Cmd`+`Shift`+`n`
-[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
+ | Copy device clipboard to computer      | `Ctrl`+`c`                    | `Cmd`+`c`
-
+ | Paste computer clipboard to device     | `Ctrl`+`v`                    | `Cmd`+`v`
- | Action                                      |   Shortcut
+ | Copy computer clipboard to device      | `Ctrl`+`Shift`+`v`            | `Cmd`+`Shift`+`v`
- | ------------------------------------------- |:-----------------------------
+ | Enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    | `Cmd`+`i`
 | Switch fullscreen mode                      | <kbd>MOD</kbd>+<kbd>f</kbd>
 | Rotate display left                         | <kbd>MOD</kbd>+<kbd>←</kbd> _(left)_
 | Rotate display right                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(right)_
 | Resize window to 1:1 (pixel-perfect)        | <kbd>MOD</kbd>+<kbd>g</kbd>
 | Resize window to remove black borders       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Double-click¹_
 | Click on `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Middle-click_
 | Click on `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Right-click²_
 | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd>
 | Click on `MENU` (unlock screen)             | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Click on `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(up)_
 | Click on `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(down)_
 | Click on `POWER`                            | <kbd>MOD</kbd>+<kbd>p</kbd>
 | Power on                                    | _Right-click²_
 | Turn device screen off (keep mirroring)     | <kbd>MOD</kbd>+<kbd>o</kbd>
 | Turn device screen on                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Rotate device screen                        | <kbd>MOD</kbd>+<kbd>r</kbd>
 | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd>
 | Collapse notification panel                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | Copy to clipboard³                          | <kbd>MOD</kbd>+<kbd>c</kbd>
 | Cut to clipboard³                           | <kbd>MOD</kbd>+<kbd>x</kbd>
 | Synchronize clipboards and paste³           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Inject computer clipboard text              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Enable/disable FPS counter (on stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
 | Pinch-to-zoom                               | <kbd>Ctrl</kbd>+_click-and-move_
 _¹Double-click on black borders to remove them._  
-_²Right-click turns the screen on if it was off, presses BACK otherwise._  
+_²Right-click turns the screen on if it was off, presses BACK otherwise._
 _³Only on Android >= 7._
 All <kbd>Ctrl</kbd>+_key_ shortcuts are forwarded to the device, so they are
 handled by the active application.
 ## Custom paths
@@ -750,7 +358,7 @@ To use a specific _adb_ binary, configure its path in the environment variable
    ADB=/path/to/adb scrcpy
-To override the path of the `scrcpy-server` file, configure its path in
+To override the path of the `scrcpy-server.jar` file, configure its path in
 `SCRCPY_SERVER_PATH`.
 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
@@ -770,6 +378,8 @@ A colleague challenged me to find a name as unpronounceable as [gnirehtet].
 See [BUILD].
 [BUILD]: BUILD.md
 ## Common issues
@@ -786,7 +396,7 @@ Read the [developers page].
 ## Licence
    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2021 Romain Vimont
+    Copyright (C) 2018-2019 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -807,16 +417,3 @@ Read the [developers page].
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
 ## Translations
 This README is available in other languages:
 - [Indonesian (Indonesia, `id`) - v1.16](README.id.md)
 - [日本語 (Japanese, `jp`) - v1.17](README.jp.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
 - [português brasileiro (Brazilian Portuguese, `pt-BR`) - v1.17](README.pt-br.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.17](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
 Only this README file is guaranteed to be up-to-date.
--- a/README.pt-br.md
+++ b/README.pt-br.md
@@ -1,792 +0,0 @@
 _Apenas o [README](README.md) original é garantido estar atualizado._
 # scrcpy (v1.17)
 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>
 ### 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] (não se preocupe, não é tão
 difícil).
 ### 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
 # Homebrew >= 2.6.0
 brew install --cask android-platform-tools
 # Homebrew < 2.6.0
 brew cask install android-platform-tools
 ```
 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 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 _
 ```
 ### 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
 ### 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
 ```
 #### Renderizar frames expirados
 Por padrão, para minimizar a latência, _scrcpy_ sempre renderiza o último frame decodificado
 disponível, e descarta o anterior.
 Para forçar a renderização de todos os frames (com o custo de um possível aumento de
 latência), use:
 ```bash
 scrcpy --render-expired-frames
 ```
 #### 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/` 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-perfect) | <kbd>MOD</kbd>+<kbd>g</kbd>
 | Redimensionar janela para remover bordas pretas | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Clique-duplo¹_
 | 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>
 | 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>
 | Colapsar painel de notificação              | <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 em bordas pretas para removê-las._  
 _²Clique-direito liga a tela se ela estiver desligada, pressiona BACK caso contrário._
 _³Apenas em Android >= 7._
 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`:
    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].
 [BUILD]: BUILD.md
 ## Problemas comuns
 Veja o [FAQ](FAQ.md).
 ## Desenvolvedores
 Leia a [página dos desenvolvedores][developers page].
 [developers page]: DEVELOP.md
 ## Licença
    Copyright (C) 2018 Genymobile
    Copyright (C) 2018-2021 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## Artigos
 - [Introducing scrcpy][article-intro]
 - [Scrcpy now works wirelessly][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.zh-Hans.md
+++ b/README.zh-Hans.md
@@ -1,732 +0,0 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._
 只有原版的[README](README.md)会保持最新。
 本文根据[ed130e05]进行翻译。
 [ed130e05]: https://github.com/Genymobile/scrcpy/blob/ed130e05d55615d6014d93f15cfcb92ad62b01d8/README.md
 # scrcpy (v1.17)
 本应用程序可以显示并控制通过 USB (或 [TCP/IP][article-tcpip]) 连接的安卓设备，且不需要任何 _root_ 权限。本程序支持 _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
 ## 系统要求
 安卓设备最低需要支持 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
 在 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    # 如果还没有 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
 # Homebrew >= 2.6.0
 brew install --cask android-platform-tools
 # Homebrew < 2.6.0
 brew cask install android-platform-tools
 ```
 您也可以[自行构建][BUILD]。
 ## 运行
 连接安卓设备，然后执行：
 ```bash
 scrcpy
 ```
 本程序支持命令行参数，查看参数列表：
 ```bash
 scrcpy --help
 ```
 ## 功能介绍
 ### 捕获设置
 #### 降低分辨率
 有时候，可以通过降低镜像的分辨率来提高性能。
 要同时限制宽度和高度到某个值 (例如 1024)：
 ```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # 简写
 ```
 另一边会被按比例缩小以保持设备的显示比例。这样，1920×1080 分辨率的设备会以 1024×576 的分辨率进行镜像。
 #### 修改码率
 默认码率是 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 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
 ### 连接
 #### 无线
 _Scrcpy_ 使用 `adb` 与设备通信，并且 `adb` 支持通过 TCP/IP [连接]到设备:
 1. 将设备和电脑连接至同一 Wi-Fi。
 2. 打开 设置 → 关于手机 → 状态信息，获取设备的 IP 地址，也可以执行以下的命令：
    ```bash
    adb shell ip route | awk '{print $9}'
    ```
 3. 启用设备的网络 adb 功能 `adb tcpip 5555`。
 4. 断开设备的 USB 连接。
 5. 连接到您的设备：`adb connect DEVICE_IP:5555` _(将 `DEVICE_IP` 替换为设备 IP)_.
 6. 正常运行 `scrcpy`。
 可能需要降低码率和分辨率：
 ```bash
 scrcpy --bit-rate 2M --max-size 800
 scrcpy -b2M -m800  # 简写
 ```
 [连接]: https://developer.android.com/studio/command-line/adb.html#wireless
 #### 多设备
 如果 `adb devices` 列出了多个设备，您必须指定设备的 _序列号_ ：
 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # 简写
 ```
 如果设备通过 TCP/IP 连接：
 ```bash
 scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # 简写
 ```
 您可以同时启动多个 _scrcpy_ 实例以同时显示多个设备的画面。
 #### 在设备连接时自动启动
 您可以使用 [AutoAdb]:
 ```bash
 autoadb scrcpy -s '{}'
 ```
 [AutoAdb]: https://github.com/rom1v/autoadb
 #### SSH 隧道
 要远程连接到设备，可以将本地的 adb 客户端连接到远程的 adb 服务端 (需要两端的 _adb_ 协议版本相同)：
 ```bash
 adb kill-server    # 关闭本地 5037 端口上的 adb 服务端
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # 保持该窗口开启
 ```
 在另一个终端：
 ```bash
 scrcpy
 ```
 若要不使用远程端口转发，可以强制使用正向连接 (注意 `-L` 和 `-R` 的区别)：
 ```bash
 adb kill-server    # 关闭本地 5037 端口上的 adb 服务端
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # 保持该窗口开启
 ```
 在另一个终端:
 ```bash
 scrcpy --force-adb-forward
 ```
 类似无线网络连接，可能需要降低画面质量：
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### 窗口设置
 #### 标题
 窗口的标题默认为设备型号。可以通过如下命令修改：
 ```bash
 scrcpy --window-title 'My device'
 ```
 #### 位置和大小
 您可以指定初始的窗口位置和大小：
 ```bash
 scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 ```
 #### 无边框
 关闭边框：
 ```bash
 scrcpy --window-borderless
 ```
 #### 保持窗口在最前
 您可以通过如下命令保持窗口在最前面：
 ```bash
 scrcpy --always-on-top
 ```
 #### 全屏
 您可以通过如下命令直接全屏启动scrcpy：
 ```bash
 scrcpy --fullscreen
 scrcpy -f  # 简写
 ```
 全屏状态可以通过 <kbd>MOD</kbd>+<kbd>f</kbd> 随时切换。
 #### 旋转
 可以通过以下命令旋转窗口：
 ```bash
 scrcpy --rotation 1
 ```
 可选的值有：
 - `0`: 无旋转
 - `1`: 逆时针旋转 90°
 - `2`: 旋转 180°
 - `3`: 顺时针旋转 90°
 也可以使用 <kbd>MOD</kbd>+<kbd>←</kbd> _(左箭头)_ 和 <kbd>MOD</kbd>+<kbd>→</kbd> _(右箭头)_ 随时更改。
 需要注意的是， _scrcpy_ 有三个不同的方向：
 - <kbd>MOD</kbd>+<kbd>r</kbd> 请求设备在竖屏和横屏之间切换 (如果前台应用程序不支持请求的朝向，可能会拒绝该请求)。
 - [`--lock-video-orientation`](#锁定屏幕方向) 改变镜像的朝向 (设备传输到电脑的画面的朝向)。这会影响录制。
 - `--rotation` (或 <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) 只旋转窗口的内容。这只影响显示，不影响录制。
 ### 其他镜像设置
 #### 只读
 禁用电脑对设备的控制 (如键盘输入、鼠标事件和文件拖放)：
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
 #### 显示屏
 如果设备有多个显示屏，可以选择要镜像的显示屏：
 ```bash
 scrcpy --display 1
 ```
 可以通过如下命令列出所有显示屏的 id：
 ```
 adb shell dumpsys display   # 在输出中搜索 “mDisplayId=”
 ```
 控制第二显示屏需要设备运行 Android 10 或更高版本 (否则将在只读状态下镜像)。
 #### 保持常亮
 阻止设备在连接时休眠：
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
 程序关闭时会恢复设备原来的设置。
 #### 关闭设备屏幕
 可以通过以下的命令行参数在关闭设备屏幕的状态下进行镜像：
 ```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 --render-expired-frames
 ```
 #### 显示触摸
 在演示时，可能会需要显示物理触摸点 (在物理设备上的触摸点)。
 Android 在 _开发者选项_ 中提供了这项功能。
 _Scrcpy_ 提供一个选项可以在启动时开启这项功能并在退出时恢复初始设置：
 ```bash
 scrcpy --show-touches
 scrcpy -t
 ```
 请注意这项功能只能显示 _物理_ 触摸 (用手指在屏幕上的触摸)。
 #### 关闭屏保
 _Scrcpy_ 默认不会阻止电脑上开启的屏幕保护。
 关闭屏幕保护：
 ```bash
 scrcpy --disable-screensaver
 ```
 ### 输入控制
 #### 旋转设备屏幕
 使用 <kbd>MOD</kbd>+<kbd>r</kbd> 在竖屏和横屏模式之间切换。
 需要注意的是，只有在前台应用程序支持所要求的模式时，才会进行切换。
 #### 复制粘贴
 每次安卓的剪贴板变化时，其内容都会被自动同步到电脑的剪贴板上。
 所有的 <kbd>Ctrl</kbd> 快捷键都会被转发至设备。其中：
 - <kbd>Ctrl</kbd>+<kbd>c</kbd> 通常执行复制
 - <kbd>Ctrl</kbd>+<kbd>x</kbd> 通常执行剪切
 - <kbd>Ctrl</kbd>+<kbd>v</kbd> 通常执行粘贴 (在电脑到设备的剪贴板同步完成之后)
 大多数时候这些按键都会执行以上的功能。
 但实际的行为取决于设备上的前台程序。例如，_Termux_ 会在按下 <kbd>Ctrl</kbd>+<kbd>c</kbd> 时发送 SIGINT，又如 _K-9 Mail_ 会新建一封邮件。
 要在这种情况下进行剪切，复制和粘贴 (仅支持 Android >= 7)：
 - <kbd>MOD</kbd>+<kbd>c</kbd> 注入 `COPY` (复制)
 - <kbd>MOD</kbd>+<kbd>x</kbd> 注入 `CUT` (剪切)
 - <kbd>MOD</kbd>+<kbd>v</kbd> 注入 `PASTE` (粘贴) (在电脑到设备的剪贴板同步完成之后)
 另外，<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> 会将电脑的剪贴板内容转换为一串按键事件输入到设备。在应用程序不接受粘贴时 (比如 _Termux_)，这项功能可以派上一定的用场。不过这项功能可能会导致非 ASCII 编码的内容出现错误。
 **警告：** 将电脑剪贴板的内容粘贴至设备 (无论是通过 <kbd>Ctrl</kbd>+<kbd>v</kbd> 还是 <kbd>MOD</kbd>+<kbd>v</kbd>) 都会将内容复制到设备的剪贴板。如此，任何安卓应用程序都能读取到。您应避免将敏感内容 (如密码) 通过这种方式粘贴。
 一些设备不支持通过程序设置剪贴板。通过 `--legacy-paste` 选项可以修改 <kbd>Ctrl</kbd>+<kbd>v</kbd> 和 <kbd>MOD</kbd>+<kbd>v</kbd> 的工作方式，使它们通过按键事件 (同 <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>) 来注入电脑剪贴板内容。
 #### 双指缩放
 模拟“双指缩放”：<kbd>Ctrl</kbd>+_按住并移动鼠标_。
 更准确的说，在按住鼠标左键时按住 <kbd>Ctrl</kbd>。直到松开鼠标左键，所有鼠标移动将以屏幕中心为原点，缩放或旋转内容 (如果应用支持)。
 实际上，_scrcpy_ 会在以屏幕中心对称的位置上生成由“虚拟手指”发出的额外触摸事件。
 #### 文字注入偏好
 打字的时候，系统会产生两种[事件][textevents]：
 - _按键事件_ ，代表一个按键被按下或松开。
 - _文本事件_ ，代表一个字符被输入。
 程序默认使用按键事件来输入字母。只有这样，键盘才会在游戏中正常运作 (例如 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
 ```
 #### 右键和中键
 默认状态下，右键会触发返回键 (或电源键)，中键会触发 HOME 键。要禁用这些快捷键并把所有点击转发到设备：
 ```bash
 scrcpy --forward-all-clicks
 ```
 ### 文件拖放
 #### 安装APK
 将 APK 文件 (文件名以 `.apk` 结尾) 拖放到 _scrcpy_ 窗口来安装。
 该操作在屏幕上不会出现任何变化，而会在控制台输出一条日志。
 #### 将文件推送至设备
 要推送文件到设备的 `/sdcard/`，将 (非 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`、`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>                  |
 | 点按 `菜单` (解锁屏幕)            | <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>                  |
 | 捏拉缩放                          | <kbd>Ctrl</kbd>+_按住并移动鼠标_             |
 _¹双击黑边可以去除黑边_
 _²点击鼠标右键将在屏幕熄灭时点亮屏幕，其余情况则视为按下返回键 。_
 _³需要安卓版本 Android >= 7。_
 所有的 <kbd>Ctrl</kbd>+_按键_ 的快捷键都会被转发到设备，所以会由当前应用程序进行处理。
 ## 自定义路径
 要使用指定的 _adb_ 二进制文件，可以设置环境变量 `ADB`：
    ADB=/path/to/adb scrcpy
 要覆盖 `scrcpy-server` 的路径，可以设置 `SCRCPY_SERVER_PATH`。
 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## 为什么叫 _scrcpy_ ？
 一个同事让我找出一个和 [gnirehtet] 一样难以发音的名字。
 [`strcpy`] 复制一个 **str**ing； `scrcpy` 复制一个 **scr**een。
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## 如何构建？
 请查看[BUILD]。
 [BUILD]: BUILD.md
 ## 常见问题
 请查看[FAQ](FAQ.md)。
 ## 开发者
 请查看[开发者页面]。
 [开发者页面]: DEVELOP.md
 ## 许可协议
    Copyright (C) 2018 Genymobile
    Copyright (C) 2018-2021 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## 相关文章
 - [Introducing scrcpy][article-intro]
 - [Scrcpy now works wirelessly][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- 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-2021 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
        http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## 相關文章
 - [Scrcpy 簡介 (英文)][article-intro]
 - [Scrcpy 可以無線連線了 (英文)][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/app/meson.build
+++ b/app/meson.build
@@ -1,6 +1,5 @@
 src = [
    'src/main.c',
    'src/cli.c',
    'src/command.c',
    'src/control_msg.c',
    'src/controller.c',
@@ -11,17 +10,16 @@ src = [
    'src/file_handler.c',
    'src/fps_counter.c',
    'src/input_manager.c',
-    'src/opengl.c',
+    'src/net.c',
    'src/receiver.c',
    'src/recorder.c',
    'src/scrcpy.c',
    'src/screen.c',
    'src/server.c',
-    'src/stream.c',
+    'src/str_util.c',
    'src/tiny_xpm.c',
    'src/stream.c',
    'src/video_buffer.c',
    'src/util/net.c',
    'src/util/str_util.c'
 ]
 if not get_option('crossbuild_windows')
@@ -77,15 +75,17 @@ cc = meson.get_compiler('c')
 if host_machine.system() == 'windows'
    src += [ 'src/sys/win/command.c' ]
    src += [ 'src/sys/win/net.c' ]
    dependencies += cc.find_library('ws2_32')
 else
    src += [ 'src/sys/unix/command.c' ]
    src += [ 'src/sys/unix/net.c' ]
 endif
 conf = configuration_data()
 # expose the build type
-conf.set('NDEBUG', get_option('buildtype') != 'debug')
+conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')
 # the version, updated on release
 conf.set_quoted('SCRCPY_VERSION', meson.project_version())
@@ -93,25 +93,18 @@ conf.set_quoted('SCRCPY_VERSION', meson.project_version())
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))
-# build a "portable" version (with scrcpy-server accessible from the same
+# build a "portable" version (with scrcpy-server.jar accessible from the same
 # directory as the executable)
 conf.set('PORTABLE', get_option('portable'))
-# the default client TCP port range for the "adb reverse" tunnel
+# the default client TCP port for the "adb reverse" tunnel
 # overridden by option --port
-conf.set('DEFAULT_LOCAL_PORT_RANGE_FIRST', '27183')
+conf.set('DEFAULT_LOCAL_PORT', '27183')
 conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')
 # the default max video size for both dimensions, in pixels
 # overridden by option --max-size
 conf.set('DEFAULT_MAX_SIZE', '0')  # 0: unlimited
 # the default video orientation
 # natural device orientation is 0 and each increment adds 90 degrees
 # counterclockwise
 # overridden by option --lock-video-orientation
 conf.set('DEFAULT_LOCK_VIDEO_ORIENTATION', '-1')  # -1: unlocked
 # the default video bitrate, in bits/second
 # overridden by option --bit-rate
 conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
@@ -119,64 +112,56 @@ conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
 # enable High DPI support
 conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
-# run a server debugger and wait for a client to be attached
+# disable console on Windows
-conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
+conf.set('WINDOWS_NOCONSOLE', get_option('windows_noconsole'))
 # select the debugger method ('old' for Android < 9, 'new' for Android >= 9)
 conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == 'new')
 configure_file(configuration: conf, output: 'config.h')
 src_dir = include_directories('src')
 if get_option('windows_noconsole')
    c_args = [ '-mwindows' ]
    link_args = [ '-mwindows' ]
 else
    c_args = []
    link_args = []
 endif
 executable('scrcpy', src,
           dependencies: dependencies,
           include_directories: src_dir,
           install: true,
-           c_args: [])
+           c_args: c_args,
-
+           link_args: link_args)
 install_man('scrcpy.1')
 ### TESTS
-# do not build tests in release (assertions would not be executed at all)
+tests = [
-if get_option('buildtype') == 'debug'
+    ['test_cbuf', [
-    tests = [
+        'tests/test_cbuf.c',
-        ['test_buffer_util', [
+    ]],
-            'tests/test_buffer_util.c'
+    ['test_control_event_serialize', [
-        ]],
+        'tests/test_control_msg_serialize.c',
-        ['test_cbuf', [
+        'src/control_msg.c',
-            'tests/test_cbuf.c',
+        'src/str_util.c'
-        ]],
+    ]],
-        ['test_cli', [
+    ['test_device_event_deserialize', [
-            'tests/test_cli.c',
+        'tests/test_device_msg_deserialize.c',
-            'src/cli.c',
+        'src/device_msg.c'
-            'src/util/str_util.c',
+    ]],
-        ]],
+    ['test_queue', [
-        ['test_control_msg_serialize', [
+        'tests/test_queue.c',
-            'tests/test_control_msg_serialize.c',
+    ]],
-            'src/control_msg.c',
+    ['test_strutil', [
-            'src/util/str_util.c',
+        'tests/test_strutil.c',
-        ]],
+        'src/str_util.c'
-        ['test_device_msg_deserialize', [
+    ]],
-            'tests/test_device_msg_deserialize.c',
+]
            'src/device_msg.c',
        ]],
        ['test_queue', [
            'tests/test_queue.c',
        ]],
        ['test_strutil', [
            'tests/test_strutil.c',
            'src/util/str_util.c',
        ]],
    ]
-    foreach t : tests
+foreach t : tests
-        exe = executable(t[0], t[1],
+    exe = executable(t[0], t[1],
-                         include_directories: src_dir,
+                     include_directories: src_dir,
-                         dependencies: dependencies,
+                     dependencies: dependencies)
-                         c_args: ['-DSDL_MAIN_HANDLED', '-DSC_TEST'])
+    test(t[0], exe)
-        test(t[0], exe)
+endforeach
    endforeach
 endif
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -1,384 +0,0 @@
 .TH "scrcpy" "1"
 .SH NAME
 scrcpy \- Display and control your Android device
 .SH SYNOPSIS
 .B scrcpy
 .RI [ options ]
 .SH DESCRIPTION
 .B scrcpy
 provides display and control of Android devices connected on USB (or over TCP/IP). It does not require any root access.
 .SH OPTIONS
 .TP
 .B \-\-always\-on\-top
 Make scrcpy window always on top (above other windows).
 .TP
 .BI "\-b, \-\-bit\-rate " value
 Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
 Default is 8000000.
 .TP
 .BI "\-\-codec\-options " key[:type]=value[,...]
 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'.
 The list of possible codec options is available in the Android documentation
 .UR https://d.android.com/reference/android/media/MediaFormat
 .UE .
 .TP
 .BI "\-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
 Crop the device screen on the server.
 The values are expressed in the device natural orientation (typically, portrait for a phone, landscape for a tablet). Any
 .B \-\-max\-size
 value is computed on the cropped size.
 .TP
 .BI "\-\-disable-screensaver"
 Disable screensaver while scrcpy is running.
 .TP
 .BI "\-\-display " id
 Specify the display id to mirror.
 The list of possible display ids can be listed by "adb shell dumpsys display"
 (search "mDisplayId=" in the output).
 Default is 0.
 .TP
 .BI "\-\-encoder " name
 Use a specific MediaCodec encoder (must be a H.264 encoder).
 .TP
 .B \-\-force\-adb\-forward
 Do not attempt to use "adb reverse" to connect to the device.
 .TP
 .B \-\-forward\-all\-clicks
 By default, right-click triggers BACK (or POWER on) and middle-click triggers HOME. This option disables these shortcuts and forward the clicks to the device instead.
 .TP
 .B \-f, \-\-fullscreen
 Start in fullscreen.
 .TP
 .B \-h, \-\-help
 Print this help.
 .TP
 .B \-\-legacy\-paste
 Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+Shift+v).
 This is a workaround for some devices not behaving as expected when setting the device clipboard programmatically.
 .TP
 .BI "\-\-lock\-video\-orientation " value
 Lock video orientation to \fIvalue\fR. Possible values are -1 (unlocked), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
 Default is -1 (unlocked).
 .TP
 .BI "\-\-max\-fps " value
 Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
 .TP
 .BI "\-m, \-\-max\-size " value
 Limit both the width and height of the video to \fIvalue\fR. The other dimension is computed so that the device aspect\-ratio is preserved.
 Default is 0 (unlimited).
 .TP
 .B \-n, \-\-no\-control
 Disable device control (mirror the device in read\-only).
 .TP
 .B \-N, \-\-no\-display
 Do not display device (only when screen recording is enabled).
 .TP
 .B \-\-no\-key\-repeat
 Do not forward repeated key events when a key is held down.
 .TP
 .B \-\-no\-mipmaps
 If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then mipmaps are automatically generated to improve downscaling quality. This option disables the generation of mipmaps.
 .TP
 .BI "\-p, \-\-port " port[:port]
 Set the TCP port (range) used by the client to listen.
 Default is 27183:27199.
 .TP
 .B \-\-prefer\-text
 Inject alpha characters and space as text events instead of key events.
 This avoids issues when combining multiple keys to enter special characters,
 but breaks the expected behavior of alpha keys in games (typically WASD).
 .TP
 .BI "\-\-push\-target " path
 Set the target directory for pushing files to the device by drag & drop. It is passed as\-is to "adb push".
 Default is "/sdcard/".
 .TP
 .BI "\-r, \-\-record " file
 Record screen to
 .IR file .
 The format is determined by the
 .B \-\-record\-format
 option if set, or by the file extension (.mp4 or .mkv).
 .TP
 .BI "\-\-record\-format " format
 Force recording format (either mp4 or mkv).
 .TP
 .BI "\-\-render\-driver " name
 Request SDL to use the given render driver (this is just a hint).
 Supported names are currently "direct3d", "opengl", "opengles2", "opengles", "metal" and "software".
 .UR https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER
 .UE
 .TP
 .B \-\-render\-expired\-frames
 By default, to minimize latency, scrcpy always renders the last available decoded frame, and drops any previous ones. This flag forces to render all frames, at a cost of a possible increased latency.
 .TP
 .BI "\-\-rotation " value
 Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each increment adds a 90 degrees rotation counterclockwise.
 .TP
 .BI "\-s, \-\-serial " number
 The device serial number. Mandatory only if several devices are connected to adb.
 .TP
 .BI "\-\-shortcut\-mod " key[+...]][,...]
 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 ','.
 For example, to use either LCtrl+LAlt or LSuper for scrcpy shortcuts, pass "lctrl+lalt,lsuper".
 Default is "lalt,lsuper" (left-Alt or left-Super).
 .TP
 .B \-S, \-\-turn\-screen\-off
 Turn the device screen off immediately.
 .TP
 .B \-t, \-\-show\-touches
 Enable "show touches" on start, restore the initial value on exit.
 It only shows physical touches (not clicks from scrcpy).
 .TP
 .B \-v, \-\-version
 Print the version of scrcpy.
 .TP
 .BI "\-V, \-\-verbosity " value
 Set the log level ("debug", "info", "warn" or "error").
 Default is "info" for release builds, "debug" for debug builds.
 .TP
 .B \-w, \-\-stay-awake
 Keep the device on while scrcpy is running, when the device is plugged in.
 .TP
 .B \-\-window\-borderless
 Disable window decorations (display borderless window).
 .TP
 .BI "\-\-window\-title " text
 Set a custom window title.
 .TP
 .BI "\-\-window\-x " value
 Set the initial window horizontal position.
 Default is "auto".
 .TP
 .BI "\-\-window\-y " value
 Set the initial window vertical position.
 Default is "auto".
 .TP
 .BI "\-\-window\-width " value
 Set the initial window width.
 Default is 0 (automatic).
 .TP
 .BI "\-\-window\-height " value
 Set the initial window height.
 Default is 0 (automatic).
 .SH SHORTCUTS
 In the following list, MOD is the shortcut modifier. By default, it's (left)
 Alt or (left) Super, but it can be configured by \-\-shortcut-mod (see above).
 .TP
 .B MOD+f
 Switch fullscreen mode
 .TP
 .B MOD+Left
 Rotate display left
 .TP
 .B MOD+Right
 Rotate display right
 .TP
 .B MOD+g
 Resize window to 1:1 (pixel\-perfect)
 .TP
 .B MOD+w, Double\-click on black borders
 Resize window to remove black borders
 .TP
 .B MOD+h, Home, Middle\-click
 Click on HOME
 .TP
 .B MOD+b, MOD+Backspace, Right\-click (when screen is on)
 Click on BACK
 .TP
 .B MOD+s
 Click on APP_SWITCH
 .TP
 .B MOD+m
 Click on MENU
 .TP
 .B MOD+Up
 Click on VOLUME_UP
 .TP
 .B MOD+Down
 Click on VOLUME_DOWN
 .TP
 .B MOD+p
 Click on POWER (turn screen on/off)
 .TP
 .B Right\-click (when screen is off)
 Turn screen on
 .TP
 .B MOD+o
 Turn device screen off (keep mirroring)
 .TP
 .B MOD+Shift+o
 Turn device screen on
 .TP
 .B MOD+r
 Rotate device screen
 .TP
 .B MOD+n
 Expand notification panel
 .TP
 .B MOD+Shift+n
 Collapse notification panel
 .TP
 .B Mod+c
 Copy to clipboard (inject COPY keycode, Android >= 7 only)
 .TP
 .B Mod+x
 Cut to clipboard (inject CUT keycode, Android >= 7 only)
 .TP
 .B MOD+v
 Copy computer clipboard to device, then paste (inject PASTE keycode, Android >= 7 only)
 .TP
 .B MOD+Shift+v
 Inject computer clipboard text as a sequence of key events
 .TP
 .B MOD+i
 Enable/disable FPS counter (print frames/second in logs)
 .TP
 .B Ctrl+click-and-move
 Pinch-to-zoom from the center of the screen
 .TP
 .B Drag & drop APK file
 Install APK from computer
 .SH Environment variables
 .TP
 .B ADB
 Specify the path to adb.
 .TP
 .B SCRCPY_SERVER_PATH
 Specify the path to server binary.
 .SH AUTHORS
 .B scrcpy
 is written by Romain Vimont.
 This manual page was written by
 .MT mmyangfl@gmail.com
 Yangfl
 .ME
 for the Debian Project (and may be used by others).
 .SH "REPORTING BUGS"
 Report bugs to
 .UR https://github.com/Genymobile/scrcpy/issues
 .UE .
 .SH COPYRIGHT
 Copyright \(co 2018 Genymobile
 .UR https://www.genymobile.com
 Genymobile
 .UE
 Copyright \(co 2018\-2020
 .MT rom@rom1v.com
 Romain Vimont
 .ME
 Licensed under the Apache License, Version 2.0.
 .SH WWW
 .UR https://github.com/Genymobile/scrcpy
 .UE
--- a/app/src/android/input.h
+++ b/app/src/android/input.h
@@ -21,7 +21,7 @@
 #define _ANDROID_INPUT_H
 /**
- * Meta key / modifier state.
+ * Meta key / modifer state.
 */
 enum android_metastate {
    /** No meta keys are pressed. */
--- a/app/src/util/buffer_util.h
+++ b/app/src/util/buffer_util.h
@@ -36,8 +36,8 @@ buffer_read32be(const uint8_t *buf) {
    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 }
-static inline uint64_t
+static inline
-buffer_read64be(const uint8_t *buf) {
+uint64_t buffer_read64be(const uint8_t *buf) {
    uint32_t msb = buffer_read32be(buf);
    uint32_t lsb = buffer_read32be(&buf[4]);
    return ((uint64_t) msb << 32) | lsb;
--- a/app/src/util/cbuf.h
+++ b/app/src/util/cbuf.h
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -1,931 +0,0 @@
 #include "cli.h"
 #include <assert.h>
 #include <getopt.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <unistd.h>
 #include "config.h"
 #include "scrcpy.h"
 #include "util/log.h"
 #include "util/str_util.h"
 void
 scrcpy_print_usage(const char *arg0) {
    fprintf(stderr,
        "Usage: %s [options]\n"
        "\n"
        "Options:\n"
        "\n"
        "    --always-on-top\n"
        "        Make scrcpy window always on top (above other windows).\n"
        "\n"
        "    -b, --bit-rate value\n"
        "        Encode the video at the given bit-rate, expressed in bits/s.\n"
        "        Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
        "        Default is %d.\n"
        "\n"
        "    --codec-options key[:type]=value[,...]\n"
        "        Set a list of comma-separated key:type=value options for the\n"
        "        device encoder.\n"
        "        The possible values for 'type' are 'int' (default), 'long',\n"
        "        'float' and 'string'.\n"
        "        The list of possible codec options is available in the\n"
        "        Android documentation:\n"
        "        <https://d.android.com/reference/android/media/MediaFormat>\n"
        "\n"
        "    --crop width:height:x:y\n"
        "        Crop the device screen on the server.\n"
        "        The values are expressed in the device natural orientation\n"
        "        (typically, portrait for a phone, landscape for a tablet).\n"
        "        Any --max-size value is computed on the cropped size.\n"
        "\n"
        "    --disable-screensaver\n"
        "        Disable screensaver while scrcpy is running.\n"
        "\n"
        "    --display id\n"
        "        Specify the display id to mirror.\n"
        "\n"
        "        The list of possible display ids can be listed by:\n"
        "            adb shell dumpsys display\n"
        "        (search \"mDisplayId=\" in the output)\n"
        "\n"
        "        Default is 0.\n"
        "\n"
        "    --encoder name\n"
        "        Use a specific MediaCodec encoder (must be a H.264 encoder).\n"
        "\n"
        "    --force-adb-forward\n"
        "        Do not attempt to use \"adb reverse\" to connect to the\n"
        "        the device.\n"
        "\n"
        "    --forward-all-clicks\n"
        "        By default, right-click triggers BACK (or POWER on) and\n"
        "        middle-click triggers HOME. This option disables these\n"
        "        shortcuts and forward the clicks to the device instead.\n"
        "\n"
        "    -f, --fullscreen\n"
        "        Start in fullscreen.\n"
        "\n"
        "    -h, --help\n"
        "        Print this help.\n"
        "\n"
        "    --legacy-paste\n"
        "        Inject computer clipboard text as a sequence of key events\n"
        "        on Ctrl+v (like MOD+Shift+v).\n"
        "        This is a workaround for some devices not behaving as\n"
        "        expected when setting the device clipboard programmatically.\n"
        "\n"
        "    --lock-video-orientation value\n"
        "        Lock video orientation to value.\n"
        "        Possible values are -1 (unlocked), 0, 1, 2 and 3.\n"
        "        Natural device orientation is 0, and each increment adds a\n"
        "        90 degrees rotation counterclockwise.\n"
        "        Default is %d%s.\n"
        "\n"
        "    --max-fps value\n"
        "        Limit the frame rate of screen capture (officially supported\n"
        "        since Android 10, but may work on earlier versions).\n"
        "\n"
        "    -m, --max-size value\n"
        "        Limit both the width and height of the video to value. The\n"
        "        other dimension is computed so that the device aspect-ratio\n"
        "        is preserved.\n"
        "        Default is %d%s.\n"
        "\n"
        "    -n, --no-control\n"
        "        Disable device control (mirror the device in read-only).\n"
        "\n"
        "    -N, --no-display\n"
        "        Do not display device (only when screen recording is\n"
        "        enabled).\n"
        "\n"
        "    --no-key-repeat\n"
        "        Do not forward repeated key events when a key is held down.\n"
        "\n"
        "    --no-mipmaps\n"
        "        If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then\n"
        "        mipmaps are automatically generated to improve downscaling\n"
        "        quality. This option disables the generation of mipmaps.\n"
        "\n"
        "    -p, --port port[:port]\n"
        "        Set the TCP port (range) used by the client to listen.\n"
        "        Default is %d:%d.\n"
        "\n"
        "    --prefer-text\n"
        "        Inject alpha characters and space as text events instead of\n"
        "        key events.\n"
        "        This avoids issues when combining multiple keys to enter a\n"
        "        special character, but breaks the expected behavior of alpha\n"
        "        keys in games (typically WASD).\n"
        "\n"
        "    --push-target path\n"
        "        Set the target directory for pushing files to the device by\n"
        "        drag & drop. It is passed as-is to \"adb push\".\n"
        "        Default is \"/sdcard/\".\n"
        "\n"
        "    -r, --record file.mp4\n"
        "        Record screen to file.\n"
        "        The format is determined by the --record-format option if\n"
        "        set, or by the file extension (.mp4 or .mkv).\n"
        "\n"
        "    --record-format format\n"
        "        Force recording format (either mp4 or mkv).\n"
        "\n"
        "    --render-driver name\n"
        "        Request SDL to use the given render driver (this is just a\n"
        "        hint).\n"
        "        Supported names are currently \"direct3d\", \"opengl\",\n"
        "        \"opengles2\", \"opengles\", \"metal\" and \"software\".\n"
        "        <https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER>\n"
        "\n"
        "    --render-expired-frames\n"
        "        By default, to minimize latency, scrcpy always renders the\n"
        "        last available decoded frame, and drops any previous ones.\n"
        "        This flag forces to render all frames, at a cost of a\n"
        "        possible increased latency.\n"
        "\n"
        "    --rotation value\n"
        "        Set the initial display rotation.\n"
        "        Possibles values are 0, 1, 2 and 3. Each increment adds a 90\n"
        "        degrees rotation counterclockwise.\n"
        "\n"
        "    -s, --serial serial\n"
        "        The device serial number. Mandatory only if several devices\n"
        "        are connected to adb.\n"
        "\n"
        "    --shortcut-mod key[+...]][,...]\n"
        "        Specify the modifiers to use for scrcpy shortcuts.\n"
        "        Possible keys are \"lctrl\", \"rctrl\", \"lalt\", \"ralt\",\n"
        "        \"lsuper\" and \"rsuper\".\n"
        "\n"
        "        A shortcut can consist in several keys, separated by '+'.\n"
        "        Several shortcuts can be specified, separated by ','.\n"
        "\n"
        "        For example, to use either LCtrl+LAlt or LSuper for scrcpy\n"
        "        shortcuts, pass \"lctrl+lalt,lsuper\".\n"
        "\n"
        "        Default is \"lalt,lsuper\" (left-Alt or left-Super).\n"
        "\n"
        "    -S, --turn-screen-off\n"
        "        Turn the device screen off immediately.\n"
        "\n"
        "    -t, --show-touches\n"
        "        Enable \"show touches\" on start, restore the initial value\n"
        "        on exit.\n"
        "        It only shows physical touches (not clicks from scrcpy).\n"
        "\n"
        "    -v, --version\n"
        "        Print the version of scrcpy.\n"
        "\n"
        "    -V, --verbosity value\n"
        "        Set the log level (debug, info, warn or error).\n"
 #ifndef NDEBUG
        "        Default is debug.\n"
 #else
        "        Default is info.\n"
 #endif
        "\n"
        "    -w, --stay-awake\n"
        "        Keep the device on while scrcpy is running, when the device\n"
        "        is plugged in.\n"
        "\n"
        "    --window-borderless\n"
        "        Disable window decorations (display borderless window).\n"
        "\n"
        "    --window-title text\n"
        "        Set a custom window title.\n"
        "\n"
        "    --window-x value\n"
        "        Set the initial window horizontal position.\n"
        "        Default is \"auto\".\n"
        "\n"
        "    --window-y value\n"
        "        Set the initial window vertical position.\n"
        "        Default is \"auto\".\n"
        "\n"
        "    --window-width value\n"
        "        Set the initial window width.\n"
        "        Default is 0 (automatic).\n"
        "\n"
        "    --window-height value\n"
        "        Set the initial window height.\n"
        "        Default is 0 (automatic).\n"
        "\n"
        "Shortcuts:\n"
        "\n"
        "    In the following list, MOD is the shortcut modifier. By default,\n"
        "    it's (left) Alt or (left) Super, but it can be configured by\n"
        "    --shortcut-mod (see above).\n"
        "\n"
        "    MOD+f\n"
        "        Switch fullscreen mode\n"
        "\n"
        "    MOD+Left\n"
        "        Rotate display left\n"
        "\n"
        "    MOD+Right\n"
        "        Rotate display right\n"
        "\n"
        "    MOD+g\n"
        "        Resize window to 1:1 (pixel-perfect)\n"
        "\n"
        "    MOD+w\n"
        "    Double-click on black borders\n"
        "        Resize window to remove black borders\n"
        "\n"
        "    MOD+h\n"
        "    Middle-click\n"
        "        Click on HOME\n"
        "\n"
        "    MOD+b\n"
        "    MOD+Backspace\n"
        "    Right-click (when screen is on)\n"
        "        Click on BACK\n"
        "\n"
        "    MOD+s\n"
        "        Click on APP_SWITCH\n"
        "\n"
        "    MOD+m\n"
        "        Click on MENU\n"
        "\n"
        "    MOD+Up\n"
        "        Click on VOLUME_UP\n"
        "\n"
        "    MOD+Down\n"
        "        Click on VOLUME_DOWN\n"
        "\n"
        "    MOD+p\n"
        "        Click on POWER (turn screen on/off)\n"
        "\n"
        "    Right-click (when screen is off)\n"
        "        Power on\n"
        "\n"
        "    MOD+o\n"
        "        Turn device screen off (keep mirroring)\n"
        "\n"
        "    MOD+Shift+o\n"
        "        Turn device screen on\n"
        "\n"
        "    MOD+r\n"
        "        Rotate device screen\n"
        "\n"
        "    MOD+n\n"
        "        Expand notification panel\n"
        "\n"
        "    MOD+Shift+n\n"
        "        Collapse notification panel\n"
        "\n"
        "    MOD+c\n"
        "        Copy to clipboard (inject COPY keycode, Android >= 7 only)\n"
        "\n"
        "    MOD+x\n"
        "        Cut to clipboard (inject CUT keycode, Android >= 7 only)\n"
        "\n"
        "    MOD+v\n"
        "        Copy computer clipboard to device, then paste (inject PASTE\n"
        "        keycode, Android >= 7 only)\n"
        "\n"
        "    MOD+Shift+v\n"
        "        Inject computer clipboard text as a sequence of key events\n"
        "\n"
        "    MOD+i\n"
        "        Enable/disable FPS counter (print frames/second in logs)\n"
        "\n"
        "    Ctrl+click-and-move\n"
        "        Pinch-to-zoom from the center of the screen\n"
        "\n"
        "    Drag & drop APK file\n"
        "        Install APK from computer\n"
        "\n",
        arg0,
        DEFAULT_BIT_RATE,
        DEFAULT_LOCK_VIDEO_ORIENTATION, DEFAULT_LOCK_VIDEO_ORIENTATION >= 0 ? "" : " (unlocked)",
        DEFAULT_MAX_SIZE, DEFAULT_MAX_SIZE ? "" : " (unlimited)",
        DEFAULT_LOCAL_PORT_RANGE_FIRST, DEFAULT_LOCAL_PORT_RANGE_LAST);
 }
 static bool
 parse_integer_arg(const char *s, long *out, bool accept_suffix, long min,
                  long max, const char *name) {
    long value;
    bool ok;
    if (accept_suffix) {
        ok = parse_integer_with_suffix(s, &value);
    } else {
        ok = parse_integer(s, &value);
    }
    if (!ok) {
        LOGE("Could not parse %s: %s", name, s);
        return false;
    }
    if (value < min || value > max) {
        LOGE("Could not parse %s: value (%ld) out-of-range (%ld; %ld)",
             name, value, min, max);
        return false;
    }
    *out = value;
    return true;
 }
 static size_t
 parse_integers_arg(const char *s, size_t max_items, long *out, long min,
                   long max, const char *name) {
    size_t count = parse_integers(s, ':', max_items, out);
    if (!count) {
        LOGE("Could not parse %s: %s", name, s);
        return 0;
    }
    for (size_t i = 0; i < count; ++i) {
        long value = out[i];
        if (value < min || value > max) {
            LOGE("Could not parse %s: value (%ld) out-of-range (%ld; %ld)",
                 name, value, min, max);
            return 0;
        }
    }
    return count;
 }
 static bool
 parse_bit_rate(const char *s, uint32_t *bit_rate) {
    long value;
    // long may be 32 bits (it is the case on mingw), so do not use more than
    // 31 bits (long is signed)
    bool ok = parse_integer_arg(s, &value, true, 0, 0x7FFFFFFF, "bit-rate");
    if (!ok) {
        return false;
    }
    *bit_rate = (uint32_t) value;
    return true;
 }
 static bool
 parse_max_size(const char *s, uint16_t *max_size) {
    long value;
    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF, "max size");
    if (!ok) {
        return false;
    }
    *max_size = (uint16_t) value;
    return true;
 }
 static bool
 parse_max_fps(const char *s, uint16_t *max_fps) {
    long value;
    bool ok = parse_integer_arg(s, &value, false, 0, 1000, "max fps");
    if (!ok) {
        return false;
    }
    *max_fps = (uint16_t) value;
    return true;
 }
 static bool
 parse_lock_video_orientation(const char *s, int8_t *lock_video_orientation) {
    long value;
    bool ok = parse_integer_arg(s, &value, false, -1, 3,
                                "lock video orientation");
    if (!ok) {
        return false;
    }
    *lock_video_orientation = (int8_t) value;
    return true;
 }
 static bool
 parse_rotation(const char *s, uint8_t *rotation) {
    long value;
    bool ok = parse_integer_arg(s, &value, false, 0, 3, "rotation");
    if (!ok) {
        return false;
    }
    *rotation = (uint8_t) value;
    return true;
 }
 static bool
 parse_window_position(const char *s, int16_t *position) {
    // special value for "auto"
    static_assert(SC_WINDOW_POSITION_UNDEFINED == -0x8000, "unexpected value");
    if (!strcmp(s, "auto")) {
        *position = SC_WINDOW_POSITION_UNDEFINED;
        return true;
    }
    long value;
    bool ok = parse_integer_arg(s, &value, false, -0x7FFF, 0x7FFF,
                                "window position");
    if (!ok) {
        return false;
    }
    *position = (int16_t) value;
    return true;
 }
 static bool
 parse_window_dimension(const char *s, uint16_t *dimension) {
    long value;
    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF,
                                "window dimension");
    if (!ok) {
        return false;
    }
    *dimension = (uint16_t) value;
    return true;
 }
 static bool
 parse_port_range(const char *s, struct sc_port_range *port_range) {
    long values[2];
    size_t count = parse_integers_arg(s, 2, values, 0, 0xFFFF, "port");
    if (!count) {
        return false;
    }
    uint16_t v0 = (uint16_t) values[0];
    if (count == 1) {
        port_range->first = v0;
        port_range->last = v0;
        return true;
    }
    assert(count == 2);
    uint16_t v1 = (uint16_t) values[1];
    if (v0 < v1) {
        port_range->first = v0;
        port_range->last = v1;
    } else {
        port_range->first = v1;
        port_range->last = v0;
    }
    return true;
 }
 static bool
 parse_display_id(const char *s, uint16_t *display_id) {
    long value;
    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF, "display id");
    if (!ok) {
        return false;
    }
    *display_id = (uint16_t) value;
    return true;
 }
 static bool
 parse_log_level(const char *s, enum sc_log_level *log_level) {
    if (!strcmp(s, "debug")) {
        *log_level = SC_LOG_LEVEL_DEBUG;
        return true;
    }
    if (!strcmp(s, "info")) {
        *log_level = SC_LOG_LEVEL_INFO;
        return true;
    }
    if (!strcmp(s, "warn")) {
        *log_level = SC_LOG_LEVEL_WARN;
        return true;
    }
    if (!strcmp(s, "error")) {
        *log_level = SC_LOG_LEVEL_ERROR;
        return true;
    }
    LOGE("Could not parse log level: %s", s);
    return false;
 }
 // item is a list of mod keys separated by '+' (e.g. "lctrl+lalt")
 // returns a bitwise-or of SC_MOD_* constants (or 0 on error)
 static unsigned
 parse_shortcut_mods_item(const char *item, size_t len) {
    unsigned mod = 0;
    for (;;) {
        char *plus = strchr(item, '+');
        // strchr() does not consider the "len" parameter, to it could find an
        // occurrence too far in the string (there is no strnchr())
        bool has_plus = plus && plus < item + len;
        assert(!has_plus || plus > item);
        size_t key_len = has_plus ? (size_t) (plus - item) : len;
 #define STREQ(literal, s, len) \
    ((sizeof(literal)-1 == len) && !memcmp(literal, s, len))
        if (STREQ("lctrl", item, key_len)) {
            mod |= SC_MOD_LCTRL;
        } else if (STREQ("rctrl", item, key_len)) {
            mod |= SC_MOD_RCTRL;
        } else if (STREQ("lalt", item, key_len)) {
            mod |= SC_MOD_LALT;
        } else if (STREQ("ralt", item, key_len)) {
            mod |= SC_MOD_RALT;
        } else if (STREQ("lsuper", item, key_len)) {
            mod |= SC_MOD_LSUPER;
        } else if (STREQ("rsuper", item, key_len)) {
            mod |= SC_MOD_RSUPER;
        } else {
            LOGE("Unknown modifier key: %.*s "
                 "(must be one of: lctrl, rctrl, lalt, ralt, lsuper, rsuper)",
                 (int) key_len, item);
            return 0;
        }
 #undef STREQ
        if (!has_plus) {
            break;
        }
        item = plus + 1;
        assert(len >= key_len + 1);
        len -= key_len + 1;
    }
    return mod;
 }
 static bool
 parse_shortcut_mods(const char *s, struct sc_shortcut_mods *mods) {
    unsigned count = 0;
    unsigned current = 0;
    // LCtrl+LAlt or RCtrl or LCtrl+RSuper: "lctrl+lalt,rctrl,lctrl+rsuper"
    for (;;) {
        char *comma = strchr(s, ',');
        if (comma && count == SC_MAX_SHORTCUT_MODS - 1) {
            assert(count < SC_MAX_SHORTCUT_MODS);
            LOGW("Too many shortcut modifiers alternatives");
            return false;
        }
        assert(!comma || comma > s);
        size_t limit = comma ? (size_t) (comma - s) : strlen(s);
        unsigned mod = parse_shortcut_mods_item(s, limit);
        if (!mod) {
            LOGE("Invalid modifier keys: %.*s", (int) limit, s);
            return false;
        }
        mods->data[current++] = mod;
        ++count;
        if (!comma) {
            break;
        }
        s = comma + 1;
    }
    mods->count = count;
    return true;
 }
 #ifdef SC_TEST
 // expose the function to unit-tests
 bool
 sc_parse_shortcut_mods(const char *s, struct sc_shortcut_mods *mods) {
    return parse_shortcut_mods(s, mods);
 }
 #endif
 static bool
 parse_record_format(const char *optarg, enum sc_record_format *format) {
    if (!strcmp(optarg, "mp4")) {
        *format = SC_RECORD_FORMAT_MP4;
        return true;
    }
    if (!strcmp(optarg, "mkv")) {
        *format = SC_RECORD_FORMAT_MKV;
        return true;
    }
    LOGE("Unsupported format: %s (expected mp4 or mkv)", optarg);
    return false;
 }
 static enum sc_record_format
 guess_record_format(const char *filename) {
    size_t len = strlen(filename);
    if (len < 4) {
        return 0;
    }
    const char *ext = &filename[len - 4];
    if (!strcmp(ext, ".mp4")) {
        return SC_RECORD_FORMAT_MP4;
    }
    if (!strcmp(ext, ".mkv")) {
        return SC_RECORD_FORMAT_MKV;
    }
    return 0;
 }
 #define OPT_RENDER_EXPIRED_FRAMES  1000
 #define OPT_WINDOW_TITLE           1001
 #define OPT_PUSH_TARGET            1002
 #define OPT_ALWAYS_ON_TOP          1003
 #define OPT_CROP                   1004
 #define OPT_RECORD_FORMAT          1005
 #define OPT_PREFER_TEXT            1006
 #define OPT_WINDOW_X               1007
 #define OPT_WINDOW_Y               1008
 #define OPT_WINDOW_WIDTH           1009
 #define OPT_WINDOW_HEIGHT          1010
 #define OPT_WINDOW_BORDERLESS      1011
 #define OPT_MAX_FPS                1012
 #define OPT_LOCK_VIDEO_ORIENTATION 1013
 #define OPT_DISPLAY_ID             1014
 #define OPT_ROTATION               1015
 #define OPT_RENDER_DRIVER          1016
 #define OPT_NO_MIPMAPS             1017
 #define OPT_CODEC_OPTIONS          1018
 #define OPT_FORCE_ADB_FORWARD      1019
 #define OPT_DISABLE_SCREENSAVER    1020
 #define OPT_SHORTCUT_MOD           1021
 #define OPT_NO_KEY_REPEAT          1022
 #define OPT_FORWARD_ALL_CLICKS     1023
 #define OPT_LEGACY_PASTE           1024
 #define OPT_ENCODER_NAME           1025
 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
    static const struct option long_options[] = {
        {"always-on-top",          no_argument,       NULL, OPT_ALWAYS_ON_TOP},
        {"bit-rate",               required_argument, NULL, 'b'},
        {"codec-options",          required_argument, NULL, OPT_CODEC_OPTIONS},
        {"crop",                   required_argument, NULL, OPT_CROP},
        {"disable-screensaver",    no_argument,       NULL,
                                                  OPT_DISABLE_SCREENSAVER},
        {"display",                required_argument, NULL, OPT_DISPLAY_ID},
        {"encoder",                required_argument, NULL, OPT_ENCODER_NAME},
        {"force-adb-forward",      no_argument,       NULL,
                                                  OPT_FORCE_ADB_FORWARD},
        {"forward-all-clicks",     no_argument,       NULL,
                                                  OPT_FORWARD_ALL_CLICKS},
        {"fullscreen",             no_argument,       NULL, 'f'},
        {"help",                   no_argument,       NULL, 'h'},
        {"legacy-paste",           no_argument,       NULL, OPT_LEGACY_PASTE},
        {"lock-video-orientation", required_argument, NULL,
                                                  OPT_LOCK_VIDEO_ORIENTATION},
        {"max-fps",                required_argument, NULL, OPT_MAX_FPS},
        {"max-size",               required_argument, NULL, 'm'},
        {"no-control",             no_argument,       NULL, 'n'},
        {"no-display",             no_argument,       NULL, 'N'},
        {"no-key-repeat",          no_argument,       NULL, OPT_NO_KEY_REPEAT},
        {"no-mipmaps",             no_argument,       NULL, OPT_NO_MIPMAPS},
        {"port",                   required_argument, NULL, 'p'},
        {"prefer-text",            no_argument,       NULL, OPT_PREFER_TEXT},
        {"push-target",            required_argument, NULL, OPT_PUSH_TARGET},
        {"record",                 required_argument, NULL, 'r'},
        {"record-format",          required_argument, NULL, OPT_RECORD_FORMAT},
        {"render-driver",          required_argument, NULL, OPT_RENDER_DRIVER},
        {"render-expired-frames",  no_argument,       NULL,
                                                  OPT_RENDER_EXPIRED_FRAMES},
        {"rotation",               required_argument, NULL, OPT_ROTATION},
        {"serial",                 required_argument, NULL, 's'},
        {"shortcut-mod",           required_argument, NULL, OPT_SHORTCUT_MOD},
        {"show-touches",           no_argument,       NULL, 't'},
        {"stay-awake",             no_argument,       NULL, 'w'},
        {"turn-screen-off",        no_argument,       NULL, 'S'},
        {"verbosity",              required_argument, NULL, 'V'},
        {"version",                no_argument,       NULL, 'v'},
        {"window-title",           required_argument, NULL, OPT_WINDOW_TITLE},
        {"window-x",               required_argument, NULL, OPT_WINDOW_X},
        {"window-y",               required_argument, NULL, OPT_WINDOW_Y},
        {"window-width",           required_argument, NULL, OPT_WINDOW_WIDTH},
        {"window-height",          required_argument, NULL, OPT_WINDOW_HEIGHT},
        {"window-borderless",      no_argument,       NULL,
                                                  OPT_WINDOW_BORDERLESS},
        {NULL,                     0,                 NULL, 0  },
    };
    struct scrcpy_options *opts = &args->opts;
    optind = 0; // reset to start from the first argument in tests
    int c;
    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTvV:w",
                            long_options, NULL)) != -1) {
        switch (c) {
            case 'b':
                if (!parse_bit_rate(optarg, &opts->bit_rate)) {
                    return false;
                }
                break;
            case 'c':
                LOGW("Deprecated option -c. Use --crop instead.");
                // fall through
            case OPT_CROP:
                opts->crop = optarg;
                break;
            case OPT_DISPLAY_ID:
                if (!parse_display_id(optarg, &opts->display_id)) {
                    return false;
                }
                break;
            case 'f':
                opts->fullscreen = true;
                break;
            case 'F':
                LOGW("Deprecated option -F. Use --record-format instead.");
                // fall through
            case OPT_RECORD_FORMAT:
                if (!parse_record_format(optarg, &opts->record_format)) {
                    return false;
                }
                break;
            case 'h':
                args->help = true;
                break;
            case OPT_MAX_FPS:
                if (!parse_max_fps(optarg, &opts->max_fps)) {
                    return false;
                }
                break;
            case 'm':
                if (!parse_max_size(optarg, &opts->max_size)) {
                    return false;
                }
                break;
            case OPT_LOCK_VIDEO_ORIENTATION:
                if (!parse_lock_video_orientation(optarg, &opts->lock_video_orientation)) {
                    return false;
                }
                break;
            case 'n':
                opts->control = false;
                break;
            case 'N':
                opts->display = false;
                break;
            case 'p':
                if (!parse_port_range(optarg, &opts->port_range)) {
                    return false;
                }
                break;
            case 'r':
                opts->record_filename = optarg;
                break;
            case 's':
                opts->serial = optarg;
                break;
            case 'S':
                opts->turn_screen_off = true;
                break;
            case 't':
                opts->show_touches = true;
                break;
            case 'T':
                LOGW("Deprecated option -T. Use --always-on-top instead.");
                // fall through
            case OPT_ALWAYS_ON_TOP:
                opts->always_on_top = true;
                break;
            case 'v':
                args->version = true;
                break;
            case 'V':
                if (!parse_log_level(optarg, &opts->log_level)) {
                    return false;
                }
                break;
            case 'w':
                opts->stay_awake = true;
                break;
            case OPT_RENDER_EXPIRED_FRAMES:
                opts->render_expired_frames = true;
                break;
            case OPT_WINDOW_TITLE:
                opts->window_title = optarg;
                break;
            case OPT_WINDOW_X:
                if (!parse_window_position(optarg, &opts->window_x)) {
                    return false;
                }
                break;
            case OPT_WINDOW_Y:
                if (!parse_window_position(optarg, &opts->window_y)) {
                    return false;
                }
                break;
            case OPT_WINDOW_WIDTH:
                if (!parse_window_dimension(optarg, &opts->window_width)) {
                    return false;
                }
                break;
            case OPT_WINDOW_HEIGHT:
                if (!parse_window_dimension(optarg, &opts->window_height)) {
                    return false;
                }
                break;
            case OPT_WINDOW_BORDERLESS:
                opts->window_borderless = true;
                break;
            case OPT_PUSH_TARGET:
                opts->push_target = optarg;
                break;
            case OPT_PREFER_TEXT:
                opts->prefer_text = true;
                break;
            case OPT_ROTATION:
                if (!parse_rotation(optarg, &opts->rotation)) {
                    return false;
                }
                break;
            case OPT_RENDER_DRIVER:
                opts->render_driver = optarg;
                break;
            case OPT_NO_MIPMAPS:
                opts->mipmaps = false;
                break;
            case OPT_NO_KEY_REPEAT:
                opts->forward_key_repeat = false;
                break;
            case OPT_CODEC_OPTIONS:
                opts->codec_options = optarg;
                break;
            case OPT_ENCODER_NAME:
                opts->encoder_name = optarg;
                break;
            case OPT_FORCE_ADB_FORWARD:
                opts->force_adb_forward = true;
                break;
            case OPT_DISABLE_SCREENSAVER:
                opts->disable_screensaver = true;
                break;
            case OPT_SHORTCUT_MOD:
                if (!parse_shortcut_mods(optarg, &opts->shortcut_mods)) {
                    return false;
                }
                break;
            case OPT_FORWARD_ALL_CLICKS:
                opts->forward_all_clicks = true;
                break;
            case OPT_LEGACY_PASTE:
                opts->legacy_paste = true;
                break;
            default:
                // getopt prints the error message on stderr
                return false;
        }
    }
    if (!opts->display && !opts->record_filename) {
        LOGE("-N/--no-display requires screen recording (-r/--record)");
        return false;
    }
    int index = optind;
    if (index < argc) {
        LOGE("Unexpected additional argument: %s", argv[index]);
        return false;
    }
    if (opts->record_format && !opts->record_filename) {
        LOGE("Record format specified without recording");
        return false;
    }
    if (opts->record_filename && !opts->record_format) {
        opts->record_format = guess_record_format(opts->record_filename);
        if (!opts->record_format) {
            LOGE("No format specified for \"%s\" (try with -F mkv)",
                 opts->record_filename);
            return false;
        }
    }
    if (!opts->control && opts->turn_screen_off) {
        LOGE("Could not request to turn screen off if control is disabled");
        return false;
    }
    if (!opts->control && opts->stay_awake) {
        LOGE("Could not request to stay awake if control is disabled");
        return false;
    }
    return true;
 }
--- a/app/src/cli.h
+++ b/app/src/cli.h
@@ -1,26 +0,0 @@
 #ifndef SCRCPY_CLI_H
 #define SCRCPY_CLI_H
 #include <stdbool.h>
 #include "config.h"
 #include "scrcpy.h"
 struct scrcpy_cli_args {
    struct scrcpy_options opts;
    bool help;
    bool version;
 };
 void
 scrcpy_print_usage(const char *arg0);
 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]);
 #ifdef SC_TEST
 bool
 sc_parse_shortcut_mods(const char *s, struct sc_shortcut_mods *mods);
 #endif
 #endif
--- a/app/src/command.c
+++ b/app/src/command.c
@@ -7,8 +7,8 @@
 #include "config.h"
 #include "common.h"
-#include "util/log.h"
+#include "log.h"
-#include "util/str_util.h"
+#include "str_util.h"
 static const char *adb_command;
@@ -55,32 +55,6 @@ argv_to_string(const char *const *argv, char *buf, size_t bufsize) {
    return idx;
 }
 static void
 show_adb_installation_msg() {
 #ifndef __WINDOWS__
    static const struct {
        const char *binary;
        const char *command;
    } pkg_managers[] = {
        {"apt", "apt install adb"},
        {"apt-get", "apt-get install adb"},
        {"brew", "brew cask install android-platform-tools"},
        {"dnf", "dnf install android-tools"},
        {"emerge", "emerge dev-util/android-tools"},
        {"pacman", "pacman -S android-tools"},
    };
    for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
        if (cmd_search(pkg_managers[i].binary)) {
            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
            return;
        }
    }
 #endif
    LOGI("You may download and install 'adb' from "
         "https://developer.android.com/studio/releases/platform-tools");
 }
 static void
 show_adb_err_msg(enum process_result err, const char *const argv[]) {
    char buf[512];
@@ -94,7 +68,6 @@ show_adb_err_msg(enum process_result err, const char *const argv[]) {
            LOGE("Command not found: %s", buf);
            LOGE("(make 'adb' accessible from your PATH or define its full"
                 "path in the ADB environment variable)");
            show_adb_installation_msg();
            break;
        case PROCESS_SUCCESS:
            // do nothing
@@ -118,7 +91,7 @@ adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
    memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
    cmd[len + i] = NULL;
-    enum process_result r = cmd_execute(cmd, &process);
+    enum process_result r = cmd_execute(cmd[0], cmd, &process);
    if (r != PROCESS_SUCCESS) {
        show_adb_err_msg(r, cmd);
        return PROCESS_NONE;
--- a/app/src/command.h
+++ b/app/src/command.h
@@ -12,9 +12,12 @@
 # define PATH_SEPARATOR '\\'
 # define PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
-# define PRIsizet "Iu"
+# ifdef _WIN64
 #   define PRIsizet PRIu64
 # else
 #   define PRIsizet PRIu32
 # endif
 # define PROCESS_NONE NULL
 # define NO_EXIT_CODE -1u // max value as unsigned
  typedef HANDLE process_t;
  typedef DWORD exit_code_t;
@@ -25,7 +28,6 @@
 # define PRIsizet "zu"
 # define PRIexitcode "d"
 # define PROCESS_NONE -1
 # define NO_EXIT_CODE -1
  typedef pid_t process_t;
  typedef int exit_code_t;
@@ -33,19 +35,16 @@
 #include "config.h"
 # define NO_EXIT_CODE -1
 enum process_result {
    PROCESS_SUCCESS,
    PROCESS_ERROR_GENERIC,
    PROCESS_ERROR_MISSING_BINARY,
 };
 #ifndef __WINDOWS__
 bool
 cmd_search(const char *file);
 #endif
 enum process_result
-cmd_execute(const char *const argv[], process_t *process);
+cmd_execute(const char *path, const char *const argv[], process_t *process);
 bool
 cmd_terminate(process_t pid);
@@ -86,8 +85,4 @@ process_check_success(process_t proc, const char *name);
 char *
 get_executable_path(void);
 // returns true if the file exists and is not a directory
 bool
 is_regular_file(const char *path);
 #endif
--- a/app/src/common.h
+++ b/app/src/common.h
@@ -27,9 +27,4 @@ struct position {
    struct point point;
 };
 struct port_range {
    uint16_t first;
    uint16_t last;
 };
 #endif
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@@ -1,12 +1,12 @@
 #include "control_msg.h"
 #include <assert.h>
 #include <string.h>
 #include <SDL2/SDL_assert.h>
 #include "config.h"
-#include "util/buffer_util.h"
+#include "buffer_util.h"
-#include "util/log.h"
+#include "log.h"
-#include "util/str_util.h"
+#include "str_util.h"
 static void
 write_position(uint8_t *buf, const struct position *position) {
@@ -20,14 +20,14 @@ write_position(uint8_t *buf, const struct position *position) {
 static size_t
 write_string(const char *utf8, size_t max_len, unsigned char *buf) {
    size_t len = utf8_truncation_index(utf8, max_len);
-    buffer_write32be(buf, len);
+    buffer_write16be(buf, (uint16_t) len);
-    memcpy(&buf[4], utf8, len);
+    memcpy(&buf[2], utf8, len);
-    return 4 + len;
+    return 2 + len;
 }
 static uint16_t
 to_fixed_point_16(float f) {
-    assert(f >= 0.0f && f <= 1.0f);
+    SDL_assert(f >= 0.0f && f <= 1.0f);
    uint32_t u = f * 0x1p16f; // 2^16
    if (u >= 0xffff) {
        u = 0xffff;
@@ -42,24 +42,26 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
        case CONTROL_MSG_TYPE_INJECT_KEYCODE:
            buf[1] = msg->inject_keycode.action;
            buffer_write32be(&buf[2], msg->inject_keycode.keycode);
-            buffer_write32be(&buf[6], msg->inject_keycode.repeat);
+            buffer_write32be(&buf[6], msg->inject_keycode.metastate);
-            buffer_write32be(&buf[10], msg->inject_keycode.metastate);
+            return 10;
            return 14;
        case CONTROL_MSG_TYPE_INJECT_TEXT: {
-            size_t len =
+            size_t len = write_string(msg->inject_text.text,
-                write_string(msg->inject_text.text,
+                                      CONTROL_MSG_TEXT_MAX_LENGTH, &buf[1]);
                             CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
            return 1 + len;
        }
        case CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT:
            buf[1] = msg->inject_mouse_event.action;
            buffer_write32be(&buf[2], msg->inject_mouse_event.buttons);
            write_position(&buf[6], &msg->inject_mouse_event.position);
            return 18;
        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
            buf[1] = msg->inject_touch_event.action;
-            buffer_write64be(&buf[2], msg->inject_touch_event.pointer_id);
+            buffer_write64be(&buf[2], msg->inject_touch_event.finger_id);
            write_position(&buf[10], &msg->inject_touch_event.position);
            uint16_t pressure =
                to_fixed_point_16(msg->inject_touch_event.pressure);
            buffer_write16be(&buf[22], pressure);
-            buffer_write32be(&buf[24], msg->inject_touch_event.buttons);
+            return 24;
            return 28;
        case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
            write_position(&buf[1], &msg->inject_scroll_event.position);
            buffer_write32be(&buf[13],
@@ -68,11 +70,10 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
                             (uint32_t) msg->inject_scroll_event.vscroll);
            return 21;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
-            buf[1] = !!msg->set_clipboard.paste;
+            size_t len = write_string(msg->inject_text.text,
            size_t len = write_string(msg->set_clipboard.text,
                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-                                      &buf[2]);
+                                      &buf[1]);
-            return 2 + len;
+            return 1 + len;
        }
        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
            buf[1] = msg->set_screen_power_mode.mode;
@@ -81,7 +82,6 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
        case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
            // no additional data
            return 1;
        default:
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@@ -10,18 +10,15 @@
 #include "android/keycodes.h"
 #include "common.h"
-#define CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
+#define CONTROL_MSG_TEXT_MAX_LENGTH 300
-
+#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH 4093
-#define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
+#define CONTROL_MSG_SERIALIZED_MAX_SIZE \
-// type: 1 byte; paste flag: 1 byte; length: 4 bytes
+    (3 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)
 #define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (CONTROL_MSG_MAX_SIZE - 6)
 #define POINTER_ID_MOUSE UINT64_C(-1);
 #define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2);
 enum control_msg_type {
    CONTROL_MSG_TYPE_INJECT_KEYCODE,
    CONTROL_MSG_TYPE_INJECT_TEXT,
    CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT,
    CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
    CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
    CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
@@ -30,7 +27,6 @@ enum control_msg_type {
    CONTROL_MSG_TYPE_GET_CLIPBOARD,
    CONTROL_MSG_TYPE_SET_CLIPBOARD,
    CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
    CONTROL_MSG_TYPE_ROTATE_DEVICE,
 };
 enum screen_power_mode {
@@ -45,7 +41,6 @@ struct control_msg {
        struct {
            enum android_keyevent_action action;
            enum android_keycode keycode;
            uint32_t repeat;
            enum android_metastate metastate;
        } inject_keycode;
        struct {
@@ -54,7 +49,11 @@ struct control_msg {
        struct {
            enum android_motionevent_action action;
            enum android_motionevent_buttons buttons;
-            uint64_t pointer_id;
+            struct position position;
        } inject_mouse_event;
        struct {
            enum android_motionevent_action action;
            uint64_t finger_id;
            struct position position;
            float pressure;
        } inject_touch_event;
@@ -65,7 +64,6 @@ struct control_msg {
        } inject_scroll_event;
        struct {
            char *text; // owned, to be freed by SDL_free()
            bool paste;
        } set_clipboard;
        struct {
            enum screen_power_mode mode;
@@ -73,7 +71,7 @@ struct control_msg {
    };
 };
-// buf size must be at least CONTROL_MSG_MAX_SIZE
+// buf size must be at least CONTROL_MSG_SERIALIZED_MAX_SIZE
 // return the number of bytes written
 size_t
 control_msg_serialize(const struct control_msg *msg, unsigned char *buf);
--- a/app/src/controller.c
+++ b/app/src/controller.c
@@ -1,10 +1,10 @@
 #include "controller.h"
-#include <assert.h>
+#include <SDL2/SDL_assert.h>
 #include "config.h"
-#include "util/lock.h"
+#include "lock_util.h"
-#include "util/log.h"
+#include "log.h"
 bool
 controller_init(struct controller *controller, socket_t control_socket) {
@@ -60,7 +60,7 @@ controller_push_msg(struct controller *controller,
 static bool
 process_msg(struct controller *controller,
              const struct control_msg *msg) {
-    static unsigned char serialized_msg[CONTROL_MSG_MAX_SIZE];
+    unsigned char serialized_msg[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int length = control_msg_serialize(msg, serialized_msg);
    if (!length) {
        return false;
@@ -85,8 +85,7 @@ run_controller(void *data) {
        }
        struct control_msg msg;
        bool non_empty = cbuf_take(&controller->queue, &msg);
-        assert(non_empty);
+        SDL_assert(non_empty);
        (void) non_empty;
        mutex_unlock(controller->mutex);
        bool ok = process_msg(controller, &msg);
--- a/app/src/controller.h
+++ b/app/src/controller.h
@@ -6,10 +6,10 @@
 #include <SDL2/SDL_thread.h>
 #include "config.h"
 #include "cbuf.h"
 #include "control_msg.h"
 #include "net.h"
 #include "receiver.h"
 #include "util/cbuf.h"
 #include "util/net.h"
 struct control_msg_queue CBUF(struct control_msg, 64);
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@@ -2,6 +2,7 @@
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
 #include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
@@ -9,11 +10,12 @@
 #include "config.h"
 #include "compat.h"
 #include "buffer_util.h"
 #include "events.h"
 #include "lock_util.h"
 #include "log.h"
 #include "recorder.h"
 #include "video_buffer.h"
 #include "util/buffer_util.h"
 #include "util/log.h"
 // set the decoded frame as ready for rendering, and notify
 static void
--- a/app/src/device.c
+++ b/app/src/device.c
@@ -1,7 +1,7 @@
 #include "device.h"
 #include "config.h"
-#include "util/log.h"
+#include "log.h"
 bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size) {
--- a/app/src/device.h
+++ b/app/src/device.h
@@ -5,7 +5,7 @@
 #include "config.h"
 #include "common.h"
-#include "util/net.h"
+#include "net.h"
 #define DEVICE_NAME_FIELD_LENGTH 64
--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@@ -1,15 +1,16 @@
 #include "device_msg.h"
 #include <string.h>
 #include <SDL2/SDL_assert.h>
 #include "config.h"
-#include "util/buffer_util.h"
+#include "buffer_util.h"
-#include "util/log.h"
+#include "log.h"
 ssize_t
 device_msg_deserialize(const unsigned char *buf, size_t len,
                       struct device_msg *msg) {
-    if (len < 5) {
+    if (len < 3) {
        // at least type + empty string length
        return 0; // not available
    }
@@ -17,8 +18,8 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
    msg->type = buf[0];
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
-            size_t clipboard_len = buffer_read32be(&buf[1]);
+            uint16_t clipboard_len = buffer_read16be(&buf[1]);
-            if (clipboard_len > len - 5) {
+            if (clipboard_len > len - 3) {
                return 0; // not available
            }
            char *text = SDL_malloc(clipboard_len + 1);
@@ -27,12 +28,12 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
                return -1;
            }
            if (clipboard_len) {
-                memcpy(text, &buf[5], clipboard_len);
+                memcpy(text, &buf[3], clipboard_len);
            }
            text[clipboard_len] = '\0';
            msg->clipboard.text = text;
-            return 5 + clipboard_len;
+            return 3 + clipboard_len;
        }
        default:
            LOGW("Unknown device message type: %d", (int) msg->type);
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@@ -7,9 +7,8 @@
 #include "config.h"
-#define DEVICE_MSG_MAX_SIZE (1 << 18) // 256k
+#define DEVICE_MSG_TEXT_MAX_LENGTH 4093
-// type: 1 byte; length: 4 bytes
+#define DEVICE_MSG_SERIALIZED_MAX_SIZE (3 + DEVICE_MSG_TEXT_MAX_LENGTH)
 #define DEVICE_MSG_TEXT_MAX_LENGTH (DEVICE_MSG_MAX_SIZE - 5)
 enum device_msg_type {
    DEVICE_MSG_TYPE_CLIPBOARD,
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@@ -5,7 +5,7 @@
 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false
-bool
+static bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
    switch (from) {
        MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
@@ -16,7 +16,7 @@ convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
 static enum android_metastate
 autocomplete_metastate(enum android_metastate metastate) {
-    // fill dependent flags
+    // fill dependant flags
    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
        metastate |= AMETA_SHIFT_ON;
    }
@@ -33,7 +33,7 @@ autocomplete_metastate(enum android_metastate metastate) {
    return metastate;
 }
-enum android_metastate
+static enum android_metastate
 convert_meta_state(SDL_Keymod mod) {
    enum android_metastate metastate = 0;
    if (mod & KMOD_LSHIFT) {
@@ -74,9 +74,8 @@ convert_meta_state(SDL_Keymod mod) {
    return autocomplete_metastate(metastate);
 }
-bool
+static bool
-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
+convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod) {
                bool prefer_text) {
    switch (from) {
        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
@@ -92,34 +91,7 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
        MAP(SDLK_LEFT,         AKEYCODE_DPAD_LEFT);
        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
        MAP(SDLK_LCTRL,        AKEYCODE_CTRL_LEFT);
        MAP(SDLK_RCTRL,        AKEYCODE_CTRL_RIGHT);
        MAP(SDLK_LSHIFT,       AKEYCODE_SHIFT_LEFT);
        MAP(SDLK_RSHIFT,       AKEYCODE_SHIFT_RIGHT);
    }
    if (!(mod & (KMOD_NUM | KMOD_SHIFT))) {
        // Handle Numpad events when Num Lock is disabled
        // If SHIFT is pressed, a text event will be sent instead
        switch(from) {
            MAP(SDLK_KP_0,            AKEYCODE_INSERT);
            MAP(SDLK_KP_1,            AKEYCODE_MOVE_END);
            MAP(SDLK_KP_2,            AKEYCODE_DPAD_DOWN);
            MAP(SDLK_KP_3,            AKEYCODE_PAGE_DOWN);
            MAP(SDLK_KP_4,            AKEYCODE_DPAD_LEFT);
            MAP(SDLK_KP_6,            AKEYCODE_DPAD_RIGHT);
            MAP(SDLK_KP_7,            AKEYCODE_MOVE_HOME);
            MAP(SDLK_KP_8,            AKEYCODE_DPAD_UP);
            MAP(SDLK_KP_9,            AKEYCODE_PAGE_UP);
            MAP(SDLK_KP_PERIOD,       AKEYCODE_FORWARD_DEL);
        }
    }
    if (prefer_text && !(mod & KMOD_CTRL)) {
        // do not forward alpha and space key events (unless Ctrl is pressed)
        return false;
    }
    if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
        return false;
    }
@@ -156,7 +128,16 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
    }
 }
-enum android_motionevent_buttons
+static bool
 convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
    switch (from) {
        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
        FAIL;
    }
 }
 static enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state) {
    enum android_motionevent_buttons buttons = 0;
    if (state & SDL_BUTTON_LMASK) {
@@ -168,25 +149,65 @@ convert_mouse_buttons(uint32_t state) {
    if (state & SDL_BUTTON_MMASK) {
        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
    }
-    if (state & SDL_BUTTON_X1MASK) {
+    if (state & SDL_BUTTON_X1) {
        buttons |= AMOTION_EVENT_BUTTON_BACK;
    }
-    if (state & SDL_BUTTON_X2MASK) {
+    if (state & SDL_BUTTON_X2) {
        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
    }
    return buttons;
 }
 bool
-convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
+convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to) {
-    switch (from) {
+    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
-        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
+
-        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
+    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
-        FAIL;
+        return false;
    }
    uint16_t mod = from->keysym.mod;
    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod)) {
        return false;
    }
    to->inject_keycode.metastate = convert_meta_state(mod);
    return true;
 }
 bool
 convert_mouse_button(const SDL_MouseButtonEvent *from, struct size screen_size,
                     struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT;
    if (!convert_mouse_action(from->type, &to->inject_mouse_event.action)) {
        return false;
    }
    to->inject_mouse_event.buttons =
        convert_mouse_buttons(SDL_BUTTON(from->button));
    to->inject_mouse_event.position.screen_size = screen_size;
    to->inject_mouse_event.position.point.x = from->x;
    to->inject_mouse_event.position.point.y = from->y;
    return true;
 }
 bool
 convert_mouse_motion(const SDL_MouseMotionEvent *from, struct size screen_size,
                     struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT;
    to->inject_mouse_event.action = AMOTION_EVENT_ACTION_MOVE;
    to->inject_mouse_event.buttons = convert_mouse_buttons(from->state);
    to->inject_mouse_event.position.screen_size = screen_size;
    to->inject_mouse_event.position.point.x = from->x;
    to->inject_mouse_event.position.point.y = from->y;
    return true;
 }
 static bool
 convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
    switch (from) {
        MAP(SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE);
@@ -195,3 +216,38 @@ convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
        FAIL;
    }
 }
 bool
 convert_touch(const SDL_TouchFingerEvent *from, struct size screen_size,
              struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
    if (!convert_touch_action(from->type, &to->inject_touch_event.action)) {
        return false;
    }
    to->inject_touch_event.finger_id = from->fingerId;
    to->inject_touch_event.position.screen_size = screen_size;
    // SDL touch event coordinates are normalized in the range [0; 1]
    to->inject_touch_event.position.point.x = from->x * screen_size.width;
    to->inject_touch_event.position.point.y = from->y * screen_size.height;
    to->inject_touch_event.pressure = from->pressure;
    return true;
 }
 bool
 convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct position position,
                    struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
    to->inject_scroll_event.position = position;
    int mul = from->direction == SDL_MOUSEWHEEL_NORMAL ? 1 : -1;
    // SDL behavior seems inconsistent between horizontal and vertical scrolling
    // so reverse the horizontal
    // <https://wiki.libsdl.org/SDL_MouseWheelEvent#Remarks>
    to->inject_scroll_event.hscroll = -mul * from->x;
    to->inject_scroll_event.vscroll = mul * from->y;
    return true;
 }
--- a/app/src/event_converter.h
+++ b/app/src/event_converter.h
@@ -7,23 +7,36 @@
 #include "config.h"
 #include "control_msg.h"
-bool
+struct complete_mouse_motion_event {
-convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to);
+    SDL_MouseMotionEvent *mouse_motion_event;
    struct size screen_size;
 };
-enum android_metastate
+struct complete_mouse_wheel_event {
-convert_meta_state(SDL_Keymod mod);
+    SDL_MouseWheelEvent *mouse_wheel_event;
    struct point position;
 };
 bool
-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
+convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to);
                bool prefer_text);
 enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state);
 bool
-convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to);
+convert_mouse_button(const SDL_MouseButtonEvent *from, struct size screen_size,
                     struct control_msg *to);
 // the video size may be different from the real device size, so we need the
 // size to which the absolute position apply, to scale it accordingly
 bool
 convert_mouse_motion(const SDL_MouseMotionEvent *from, struct size screen_size,
                     struct control_msg *to);
 bool
-convert_touch_action(SDL_EventType from, enum android_motionevent_action *to);
+convert_touch(const SDL_TouchFingerEvent *from, struct size screen_size,
              struct control_msg *to);
 // on Android, a scroll event requires the current mouse position
 bool
 convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct position position,
                    struct control_msg *to);
 #endif
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@@ -1,12 +1,12 @@
 #include "file_handler.h"
 #include <assert.h>
 #include <string.h>
 #include <SDL2/SDL_assert.h>
 #include "config.h"
 #include "command.h"
-#include "util/lock.h"
+#include "lock_util.h"
-#include "util/log.h"
+#include "log.h"
 #define DEFAULT_PUSH_TARGET "/sdcard/"
@@ -120,8 +120,7 @@ run_file_handler(void *data) {
        }
        struct file_handler_request req;
        bool non_empty = cbuf_take(&file_handler->queue, &req);
-        assert(non_empty);
+        SDL_assert(non_empty);
        (void) non_empty;
        process_t process;
        if (req.action == ACTION_INSTALL_APK) {
--- a/app/src/file_handler.h
+++ b/app/src/file_handler.h
@@ -6,8 +6,8 @@
 #include <SDL2/SDL_thread.h>
 #include "config.h"
 #include "cbuf.h"
 #include "command.h"
 #include "util/cbuf.h"
 typedef enum {
    ACTION_INSTALL_APK,
--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@@ -1,11 +1,11 @@
 #include "fps_counter.h"
-#include <assert.h>
+#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>
 #include "config.h"
-#include "util/lock.h"
+#include "lock_util.h"
-#include "util/log.h"
+#include "log.h"
 #define FPS_COUNTER_INTERVAL_MS 1000
@@ -23,7 +23,7 @@ fps_counter_init(struct fps_counter *counter) {
    }
    counter->thread = NULL;
-    atomic_init(&counter->started, 0);
+    SDL_AtomicSet(&counter->started, 0);
    // no need to initialize the other fields, they are unused until started
    return true;
@@ -35,16 +35,6 @@ fps_counter_destroy(struct fps_counter *counter) {
    SDL_DestroyMutex(counter->mutex);
 }
 static inline bool
 is_started(struct fps_counter *counter) {
    return atomic_load_explicit(&counter->started, memory_order_acquire);
 }
 static inline void
 set_started(struct fps_counter *counter, bool started) {
    atomic_store_explicit(&counter->started, started, memory_order_release);
 }
 // must be called with mutex locked
 static void
 display_fps(struct fps_counter *counter) {
@@ -80,14 +70,14 @@ run_fps_counter(void *data) {
    mutex_lock(counter->mutex);
    while (!counter->interrupted) {
-        while (!counter->interrupted && !is_started(counter)) {
+        while (!counter->interrupted && !SDL_AtomicGet(&counter->started)) {
            cond_wait(counter->state_cond, counter->mutex);
        }
-        while (!counter->interrupted && is_started(counter)) {
+        while (!counter->interrupted && SDL_AtomicGet(&counter->started)) {
            uint32_t now = SDL_GetTicks();
            check_interval_expired(counter, now);
-            assert(counter->next_timestamp > now);
+            SDL_assert(counter->next_timestamp > now);
            uint32_t remaining = counter->next_timestamp - now;
            // ignore the reason (timeout or signaled), we just loop anyway
@@ -106,7 +96,7 @@ fps_counter_start(struct fps_counter *counter) {
    counter->nr_skipped = 0;
    mutex_unlock(counter->mutex);
-    set_started(counter, true);
+    SDL_AtomicSet(&counter->started, 1);
    cond_signal(counter->state_cond);
    // counter->thread is always accessed from the same thread, no need to lock
@@ -124,13 +114,13 @@ fps_counter_start(struct fps_counter *counter) {
 void
 fps_counter_stop(struct fps_counter *counter) {
-    set_started(counter, false);
+    SDL_AtomicSet(&counter->started, 0);
    cond_signal(counter->state_cond);
 }
 bool
 fps_counter_is_started(struct fps_counter *counter) {
-    return is_started(counter);
+    return SDL_AtomicGet(&counter->started);
 }
 void
@@ -155,7 +145,7 @@ fps_counter_join(struct fps_counter *counter) {
 void
 fps_counter_add_rendered_frame(struct fps_counter *counter) {
-    if (!is_started(counter)) {
+    if (!SDL_AtomicGet(&counter->started)) {
        return;
    }
@@ -168,7 +158,7 @@ fps_counter_add_rendered_frame(struct fps_counter *counter) {
 void
 fps_counter_add_skipped_frame(struct fps_counter *counter) {
-    if (!is_started(counter)) {
+    if (!SDL_AtomicGet(&counter->started)) {
        return;
    }
--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@@ -1,9 +1,9 @@
 #ifndef FPSCOUNTER_H
 #define FPSCOUNTER_H
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <SDL2/SDL_atomic.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
@@ -16,7 +16,7 @@ struct fps_counter {
    // atomic so that we can check without locking the mutex
    // if the FPS counter is disabled, we don't want to lock unnecessarily
-    atomic_bool started;
+    SDL_atomic_t started;
    // the following fields are protected by the mutex
    bool interrupted;
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@@ -1,81 +1,42 @@
 #include "input_manager.h"
-#include <assert.h>
+#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_keycode.h>
 #include "config.h"
 #include "event_converter.h"
-#include "util/lock.h"
+#include "lock_util.h"
-#include "util/log.h"
+#include "log.h"
 // Convert window coordinates (as provided by SDL_GetMouseState() to renderer
 // coordinates (as provided in SDL mouse events)
 //
 // See my question:
 // <https://stackoverflow.com/questions/49111054/how-to-get-mouse-position-on-mouse-wheel-event>
 static void
 convert_to_renderer_coordinates(SDL_Renderer *renderer, int *x, int *y) {
    SDL_Rect viewport;
    float scale_x, scale_y;
    SDL_RenderGetViewport(renderer, &viewport);
    SDL_RenderGetScale(renderer, &scale_x, &scale_y);
    *x = (int) (*x / scale_x) - viewport.x;
    *y = (int) (*y / scale_y) - viewport.y;
 }
 static struct point
 get_mouse_point(struct screen *screen) {
    int x;
    int y;
    SDL_GetMouseState(&x, &y);
    convert_to_renderer_coordinates(screen->renderer, &x, &y);
    return (struct point) {
        .x = x,
        .y = y,
    };
 }
 static const int ACTION_DOWN = 1;
 static const int ACTION_UP = 1 << 1;
 #define SC_SDL_SHORTCUT_MODS_MASK (KMOD_CTRL | KMOD_ALT | KMOD_GUI)
 static inline uint16_t
 to_sdl_mod(unsigned mod) {
    uint16_t sdl_mod = 0;
    if (mod & SC_MOD_LCTRL) {
        sdl_mod |= KMOD_LCTRL;
    }
    if (mod & SC_MOD_RCTRL) {
        sdl_mod |= KMOD_RCTRL;
    }
    if (mod & SC_MOD_LALT) {
        sdl_mod |= KMOD_LALT;
    }
    if (mod & SC_MOD_RALT) {
        sdl_mod |= KMOD_RALT;
    }
    if (mod & SC_MOD_LSUPER) {
        sdl_mod |= KMOD_LGUI;
    }
    if (mod & SC_MOD_RSUPER) {
        sdl_mod |= KMOD_RGUI;
    }
    return sdl_mod;
 }
 static bool
 is_shortcut_mod(struct input_manager *im, uint16_t sdl_mod) {
    // keep only the relevant modifier keys
    sdl_mod &= SC_SDL_SHORTCUT_MODS_MASK;
    assert(im->sdl_shortcut_mods.count);
    assert(im->sdl_shortcut_mods.count < SC_MAX_SHORTCUT_MODS);
    for (unsigned i = 0; i < im->sdl_shortcut_mods.count; ++i) {
        if (im->sdl_shortcut_mods.data[i] == sdl_mod) {
            return true;
        }
    }
    return false;
 }
 void
 input_manager_init(struct input_manager *im,
                   const struct scrcpy_options *options)
 {
    im->control = options->control;
    im->forward_key_repeat = options->forward_key_repeat;
    im->prefer_text = options->prefer_text;
    im->forward_all_clicks = options->forward_all_clicks;
    im->legacy_paste = options->legacy_paste;
    const struct sc_shortcut_mods *shortcut_mods = &options->shortcut_mods;
    assert(shortcut_mods->count);
    assert(shortcut_mods->count < SC_MAX_SHORTCUT_MODS);
    for (unsigned i = 0; i < shortcut_mods->count; ++i) {
        uint16_t sdl_mod = to_sdl_mod(shortcut_mods->data[i]);
        assert(sdl_mod);
        im->sdl_shortcut_mods.data[i] = sdl_mod;
    }
    im->sdl_shortcut_mods.count = shortcut_mods->count;
    im->vfinger_down = false;
 }
 static void
 send_keycode(struct controller *controller, enum android_keycode keycode,
             int actions, const char *name) {
@@ -84,7 +45,6 @@ send_keycode(struct controller *controller, enum android_keycode keycode,
    msg.type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
    msg.inject_keycode.keycode = keycode;
    msg.inject_keycode.metastate = 0;
    msg.inject_keycode.repeat = 0;
    if (actions & ACTION_DOWN) {
        msg.inject_keycode.action = AKEY_EVENT_ACTION_DOWN;
@@ -137,16 +97,6 @@ action_menu(struct controller *controller, int actions) {
    send_keycode(controller, AKEYCODE_MENU, actions, "MENU");
 }
 static inline void
 action_copy(struct controller *controller, int actions) {
    send_keycode(controller, AKEYCODE_COPY, actions, "COPY");
 }
 static inline void
 action_cut(struct controller *controller, int actions) {
    send_keycode(controller, AKEYCODE_CUT, actions, "CUT");
 }
 // turn the screen on if it was off, press BACK otherwise
 static void
 press_back_or_turn_screen_on(struct controller *controller) {
@@ -179,7 +129,17 @@ collapse_notification_panel(struct controller *controller) {
 }
 static void
-set_device_clipboard(struct controller *controller, bool paste) {
+request_device_clipboard(struct controller *controller) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_GET_CLIPBOARD;
    if (!controller_push_msg(controller, &msg)) {
        LOGW("Could not request device clipboard");
    }
 }
 static void
 set_device_clipboard(struct controller *controller) {
    char *text = SDL_GetClipboardText();
    if (!text) {
        LOGW("Could not get clipboard text: %s", SDL_GetError());
@@ -194,7 +154,6 @@ set_device_clipboard(struct controller *controller, bool paste) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
    msg.set_clipboard.text = text;
    msg.set_clipboard.paste = paste;
    if (!controller_push_msg(controller, &msg)) {
        SDL_free(text);
@@ -252,44 +211,15 @@ clipboard_paste(struct controller *controller) {
    }
 }
 static void
 rotate_device(struct controller *controller) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_ROTATE_DEVICE;
    if (!controller_push_msg(controller, &msg)) {
        LOGW("Could not request device rotation");
    }
 }
 static void
 rotate_client_left(struct screen *screen) {
    unsigned new_rotation = (screen->rotation + 1) % 4;
    screen_set_rotation(screen, new_rotation);
 }
 static void
 rotate_client_right(struct screen *screen) {
    unsigned new_rotation = (screen->rotation + 3) % 4;
    screen_set_rotation(screen, new_rotation);
 }
 void
-input_manager_process_text_input(struct input_manager *im,
+input_manager_process_text_input(struct input_manager *input_manager,
                                 const SDL_TextInputEvent *event) {
-    if (is_shortcut_mod(im, SDL_GetModState())) {
+    char c = event->text[0];
-        // A shortcut must never generate text events
+    if (isalpha(c) || c == ' ') {
        SDL_assert(event->text[1] == '\0');
        // letters and space are handled as raw key event
        return;
    }
    if (!im->prefer_text) {
        char c = event->text[0];
        if (isalpha(c) || c == ' ') {
            assert(event->text[1] == '\0');
            // letters and space are handled as raw key event
            return;
        }
    }
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
    msg.inject_text.text = SDL_strdup(event->text);
@@ -297,184 +227,137 @@ input_manager_process_text_input(struct input_manager *im,
        LOGW("Could not strdup input text");
        return;
    }
-    if (!controller_push_msg(im->controller, &msg)) {
+    if (!controller_push_msg(input_manager->controller, &msg)) {
        SDL_free(msg.inject_text.text);
        LOGW("Could not request 'inject text'");
    }
 }
 static bool
 simulate_virtual_finger(struct input_manager *im,
                        enum android_motionevent_action action,
                        struct point point) {
    bool up = action == AMOTION_EVENT_ACTION_UP;
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
    msg.inject_touch_event.action = action;
    msg.inject_touch_event.position.screen_size = im->screen->frame_size;
    msg.inject_touch_event.position.point = point;
    msg.inject_touch_event.pointer_id = POINTER_ID_VIRTUAL_FINGER;
    msg.inject_touch_event.pressure = up ? 0.0f : 1.0f;
    msg.inject_touch_event.buttons = 0;
    if (!controller_push_msg(im->controller, &msg)) {
        LOGW("Could not request 'inject virtual finger event'");
        return false;
    }
    return true;
 }
 static struct point
 inverse_point(struct point point, struct size size) {
    point.x = size.width - point.x;
    point.y = size.height - point.y;
    return point;
 }
 static bool
 convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
                  bool prefer_text, uint32_t repeat) {
    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
        return false;
    }
    uint16_t mod = from->keysym.mod;
    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod,
                         prefer_text)) {
        return false;
    }
    to->inject_keycode.repeat = repeat;
    to->inject_keycode.metastate = convert_meta_state(mod);
    return true;
 }
 void
-input_manager_process_key(struct input_manager *im,
+input_manager_process_key(struct input_manager *input_manager,
-                          const SDL_KeyboardEvent *event) {
+                          const SDL_KeyboardEvent *event,
                          bool control) {
    // control: indicates the state of the command-line option --no-control
-    bool control = im->control;
+    // ctrl: the Ctrl key
-    bool smod = is_shortcut_mod(im, event->keysym.mod);
+    bool ctrl = event->keysym.mod & (KMOD_LCTRL | KMOD_RCTRL);
    bool alt = event->keysym.mod & (KMOD_LALT | KMOD_RALT);
    bool meta = event->keysym.mod & (KMOD_LGUI | KMOD_RGUI);
-    struct controller *controller = im->controller;
+    // use Cmd on macOS, Ctrl on other platforms
 #ifdef __APPLE__
    bool cmd = !ctrl && meta;
 #else
    if (meta) {
        // no shortcuts involve Meta on platforms other than macOS, and it must
        // not be forwarded to the device
        return;
    }
    bool cmd = ctrl; // && !meta, already guaranteed
 #endif
-    SDL_Keycode keycode = event->keysym.sym;
+    if (alt) {
-    bool down = event->type == SDL_KEYDOWN;
+        // no shortcuts involve Alt, and it must not be forwarded to the device
-    bool ctrl = event->keysym.mod & KMOD_CTRL;
+        return;
-    bool shift = event->keysym.mod & KMOD_SHIFT;
+    }
    bool repeat = event->repeat;
-    // The shortcut modifier is pressed
+    struct controller *controller = input_manager->controller;
-    if (smod) {
+
    // capture all Ctrl events
    if (ctrl || cmd) {
        SDL_Keycode keycode = event->keysym.sym;
        bool down = event->type == SDL_KEYDOWN;
        int action = down ? ACTION_DOWN : ACTION_UP;
        bool repeat = event->repeat;
        bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
        switch (keycode) {
            case SDLK_h:
-                if (control && !shift && !repeat) {
+                // Ctrl+h on all platform, since Cmd+h is already captured by
                // the system on macOS to hide the window
                if (control && ctrl && !meta && !shift && !repeat) {
                    action_home(controller, action);
                }
                return;
            case SDLK_b: // fall-through
            case SDLK_BACKSPACE:
-                if (control && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_back(controller, action);
                }
                return;
            case SDLK_s:
-                if (control && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_app_switch(controller, action);
                }
                return;
            case SDLK_m:
-                if (control && !shift && !repeat) {
+                // Ctrl+m on all platform, since Cmd+m is already captured by
                // the system on macOS to minimize the window
                if (control && ctrl && !meta && !shift && !repeat) {
                    action_menu(controller, action);
                }
                return;
            case SDLK_p:
-                if (control && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_power(controller, action);
                }
                return;
            case SDLK_o:
-                if (control && !repeat && down) {
+                if (control && cmd && !shift && down) {
-                    enum screen_power_mode mode = shift
+                    set_screen_power_mode(controller, SCREEN_POWER_MODE_OFF);
                                                ? SCREEN_POWER_MODE_NORMAL
                                                : SCREEN_POWER_MODE_OFF;
                    set_screen_power_mode(controller, mode);
                }
                return;
            case SDLK_DOWN:
-                if (control && !shift) {
+                if (control && cmd && !shift) {
                    // forward repeated events
                    action_volume_down(controller, action);
                }
                return;
            case SDLK_UP:
-                if (control && !shift) {
+                if (control && cmd && !shift) {
                    // forward repeated events
                    action_volume_up(controller, action);
                }
                return;
            case SDLK_LEFT:
                if (!shift && !repeat && down) {
                    rotate_client_left(im->screen);
                }
                return;
            case SDLK_RIGHT:
                if (!shift && !repeat && down) {
                    rotate_client_right(im->screen);
                }
                return;
            case SDLK_c:
-                if (control && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat && down) {
-                    action_copy(controller, action);
+                    request_device_clipboard(controller);
                }
                return;
            case SDLK_x:
                if (control && !shift && !repeat) {
                    action_cut(controller, action);
                }
                return;
            case SDLK_v:
-                if (control && !repeat && down) {
+                if (control && cmd && !repeat && down) {
-                    if (shift || im->legacy_paste) {
+                    if (shift) {
                        // store the text in the device clipboard
                        set_device_clipboard(controller);
                    } else {
                        // inject the text as input events
                        clipboard_paste(controller);
                    } else {
                        // store the text in the device clipboard and paste
                        set_device_clipboard(controller, true);
                    }
                }
                return;
            case SDLK_f:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
-                    screen_switch_fullscreen(im->screen);
+                    screen_switch_fullscreen(input_manager->screen);
                }
                return;
-            case SDLK_w:
+            case SDLK_x:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
-                    screen_resize_to_fit(im->screen);
+                    screen_resize_to_fit(input_manager->screen);
                }
                return;
            case SDLK_g:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
-                    screen_resize_to_pixel_perfect(im->screen);
+                    screen_resize_to_pixel_perfect(input_manager->screen);
                }
                return;
            case SDLK_i:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    struct fps_counter *fps_counter =
-                        im->video_buffer->fps_counter;
+                        input_manager->video_buffer->fps_counter;
                    switch_fps_counter_state(fps_counter);
                }
                return;
            case SDLK_n:
-                if (control && !repeat && down) {
+                if (control && cmd && !repeat && down) {
                    if (shift) {
                        collapse_notification_panel(controller);
                    } else {
@@ -482,11 +365,6 @@ input_manager_process_key(struct input_manager *im,
                    }
                }
                return;
            case SDLK_r:
                if (control && !shift && !repeat && down) {
                    rotate_device(controller);
                }
                return;
        }
        return;
@@ -496,51 +374,16 @@ input_manager_process_key(struct input_manager *im,
        return;
    }
    if (event->repeat) {
        if (!im->forward_key_repeat) {
            return;
        }
        ++im->repeat;
    } else {
        im->repeat = 0;
    }
    if (ctrl && !shift && keycode == SDLK_v && down && !repeat) {
        if (im->legacy_paste) {
            // inject the text as input events
            clipboard_paste(controller);
            return;
        }
        // Synchronize the computer clipboard to the device clipboard before
        // sending Ctrl+v, to allow seamless copy-paste.
        set_device_clipboard(controller, false);
    }
    struct control_msg msg;
-    if (convert_input_key(event, &msg, im->prefer_text, im->repeat)) {
+    if (convert_input_key(event, &msg)) {
        if (!controller_push_msg(controller, &msg)) {
            LOGW("Could not request 'inject keycode'");
        }
    }
 }
 static bool
 convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
                     struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
    to->inject_touch_event.position.screen_size = screen->frame_size;
    to->inject_touch_event.position.point =
        screen_convert_window_to_frame_coords(screen, from->x, from->y);
    to->inject_touch_event.pressure = 1.f;
    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
    return true;
 }
 void
-input_manager_process_mouse_motion(struct input_manager *im,
+input_manager_process_mouse_motion(struct input_manager *input_manager,
                                   const SDL_MouseMotionEvent *event) {
    if (!event->state) {
        // do not send motion events when no button is pressed
@@ -551,111 +394,50 @@ input_manager_process_mouse_motion(struct input_manager *im,
        return;
    }
    struct control_msg msg;
-    if (!convert_mouse_motion(event, im->screen, &msg)) {
+    if (convert_mouse_motion(event, input_manager->screen->frame_size, &msg)) {
-        return;
+        if (!controller_push_msg(input_manager->controller, &msg)) {
            LOGW("Could not request 'inject mouse motion event'");
        }
    }
    if (!controller_push_msg(im->controller, &msg)) {
        LOGW("Could not request 'inject mouse motion event'");
    }
    if (im->vfinger_down) {
        struct point mouse = msg.inject_touch_event.position.point;
        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
        simulate_virtual_finger(im, AMOTION_EVENT_ACTION_MOVE, vfinger);
    }
 }
 static bool
 convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
              struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
    if (!convert_touch_action(from->type, &to->inject_touch_event.action)) {
        return false;
    }
    to->inject_touch_event.pointer_id = from->fingerId;
    to->inject_touch_event.position.screen_size = screen->frame_size;
    int dw;
    int dh;
    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
    // SDL touch event coordinates are normalized in the range [0; 1]
    int32_t x = from->x * dw;
    int32_t y = from->y * dh;
    to->inject_touch_event.position.point =
        screen_convert_drawable_to_frame_coords(screen, x, y);
    to->inject_touch_event.pressure = from->pressure;
    to->inject_touch_event.buttons = 0;
    return true;
 }
 void
-input_manager_process_touch(struct input_manager *im,
+input_manager_process_touch(struct input_manager *input_manager,
                            const SDL_TouchFingerEvent *event) {
    struct control_msg msg;
-    if (convert_touch(event, im->screen, &msg)) {
+    if (convert_touch(event, input_manager->screen->frame_size, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
+        if (!controller_push_msg(input_manager->controller, &msg)) {
            LOGW("Could not request 'inject touch event'");
        }
    }
 }
 static bool
-convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
+is_outside_device_screen(struct input_manager *input_manager, int x, int y)
-                     struct control_msg *to) {
+{
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
+    return x < 0 || x >= input_manager->screen->frame_size.width ||
-
+           y < 0 || y >= input_manager->screen->frame_size.height;
    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
        return false;
    }
    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
    to->inject_touch_event.position.screen_size = screen->frame_size;
    to->inject_touch_event.position.point =
        screen_convert_window_to_frame_coords(screen, from->x, from->y);
    to->inject_touch_event.pressure =
        from->type == SDL_MOUSEBUTTONDOWN ? 1.f : 0.f;
    to->inject_touch_event.buttons =
        convert_mouse_buttons(SDL_BUTTON(from->button));
    return true;
 }
 void
-input_manager_process_mouse_button(struct input_manager *im,
+input_manager_process_mouse_button(struct input_manager *input_manager,
-                                   const SDL_MouseButtonEvent *event) {
+                                   const SDL_MouseButtonEvent *event,
-    bool control = im->control;
+                                   bool control) {
-
+    if (event->type == SDL_MOUSEBUTTONDOWN) {
    if (event->which == SDL_TOUCH_MOUSEID) {
        // simulated from touch events, so it's a duplicate
        return;
    }
    bool down = event->type == SDL_MOUSEBUTTONDOWN;
    if (!im->forward_all_clicks && down) {
        if (control && event->button == SDL_BUTTON_RIGHT) {
-            press_back_or_turn_screen_on(im->controller);
+            press_back_or_turn_screen_on(input_manager->controller);
            return;
        }
        if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, ACTION_DOWN | ACTION_UP);
+            action_home(input_manager->controller, ACTION_DOWN | ACTION_UP);
            return;
        }
        // double-click on black borders resize to fit the device screen
        if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
-            int32_t x = event->x;
+            bool outside =
-            int32_t y = event->y;
+                is_outside_device_screen(input_manager, event->x, event->y);
            screen_hidpi_scale_coords(im->screen, &x, &y);
            SDL_Rect *r = &im->screen->rect;
            bool outside = x < r->x || x >= r->x + r->w
                        || y < r->y || y >= r->y + r->h;
            if (outside) {
-                screen_resize_to_fit(im->screen);
+                screen_resize_to_fit(input_manager->screen);
                return;
            }
        }
@@ -667,69 +449,23 @@ input_manager_process_mouse_button(struct input_manager *im,
    }
    struct control_msg msg;
-    if (!convert_mouse_button(event, im->screen, &msg)) {
+    if (convert_mouse_button(event, input_manager->screen->frame_size, &msg)) {
-        return;
+        if (!controller_push_msg(input_manager->controller, &msg)) {
-    }
+            LOGW("Could not request 'inject mouse button event'");
    if (!controller_push_msg(im->controller, &msg)) {
        LOGW("Could not request 'inject mouse button event'");
        return;
    }
    // Pinch-to-zoom simulation.
    //
    // If Ctrl is hold when the left-click button is pressed, then
    // pinch-to-zoom mode is enabled: on every mouse event until the left-click
    // button is released, an additional "virtual finger" event is generated,
    // having a position inverted through the center of the screen.
    //
    // In other words, the center of the rotation/scaling is the center of the
    // screen.
 #define CTRL_PRESSED (SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL))
    if ((down && !im->vfinger_down && CTRL_PRESSED)
            || (!down && im->vfinger_down)) {
        struct point mouse = msg.inject_touch_event.position.point;
        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
        enum android_motionevent_action action = down
                                               ? AMOTION_EVENT_ACTION_DOWN
                                               : AMOTION_EVENT_ACTION_UP;
        if (!simulate_virtual_finger(im, action, vfinger)) {
            return;
        }
        im->vfinger_down = down;
    }
 }
 static bool
 convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
                    struct control_msg *to) {
    // mouse_x and mouse_y are expressed in pixels relative to the window
    int mouse_x;
    int mouse_y;
    SDL_GetMouseState(&mouse_x, &mouse_y);
    struct position position = {
        .screen_size = screen->frame_size,
        .point = screen_convert_window_to_frame_coords(screen,
                                                       mouse_x, mouse_y),
    };
    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
    to->inject_scroll_event.position = position;
    to->inject_scroll_event.hscroll = from->x;
    to->inject_scroll_event.vscroll = from->y;
    return true;
 }
 void
-input_manager_process_mouse_wheel(struct input_manager *im,
+input_manager_process_mouse_wheel(struct input_manager *input_manager,
                                  const SDL_MouseWheelEvent *event) {
    struct position position = {
        .screen_size = input_manager->screen->frame_size,
        .point = get_mouse_point(input_manager->screen),
    };
    struct control_msg msg;
-    if (convert_mouse_wheel(event, im->screen, &msg)) {
+    if (convert_mouse_wheel(event, position, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
+        if (!controller_push_msg(input_manager->controller, &msg)) {
            LOGW("Could not request 'inject mouse wheel event'");
        }
    }
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@@ -3,65 +3,43 @@
 #include <stdbool.h>
 #include <SDL2/SDL.h>
 #include "config.h"
 #include "common.h"
 #include "controller.h"
 #include "fps_counter.h"
 #include "scrcpy.h"
 #include "screen.h"
 #include "video_buffer.h"
 #include "screen.h"
 struct input_manager {
    struct controller *controller;
    struct video_buffer *video_buffer;
    struct screen *screen;
    // SDL reports repeated events as a boolean, but Android expects the actual
    // number of repetitions. This variable keeps track of the count.
    unsigned repeat;
    bool control;
    bool forward_key_repeat;
    bool prefer_text;
    bool forward_all_clicks;
    bool legacy_paste;
    struct {
        unsigned data[SC_MAX_SHORTCUT_MODS];
        unsigned count;
    } sdl_shortcut_mods;
    bool vfinger_down;
 };
 void
-input_manager_init(struct input_manager *im,
+input_manager_process_text_input(struct input_manager *input_manager,
                   const struct scrcpy_options *options);
 void
 input_manager_process_text_input(struct input_manager *im,
                                 const SDL_TextInputEvent *event);
 void
-input_manager_process_key(struct input_manager *im,
+input_manager_process_key(struct input_manager *input_manager,
-                          const SDL_KeyboardEvent *event);
+                          const SDL_KeyboardEvent *event,
                          bool control);
 void
-input_manager_process_mouse_motion(struct input_manager *im,
+input_manager_process_mouse_motion(struct input_manager *input_manager,
                                   const SDL_MouseMotionEvent *event);
 void
-input_manager_process_touch(struct input_manager *im,
+input_manager_process_touch(struct input_manager *input_manager,
                            const SDL_TouchFingerEvent *event);
 void
-input_manager_process_mouse_button(struct input_manager *im,
+input_manager_process_mouse_button(struct input_manager *input_manager,
-                                   const SDL_MouseButtonEvent *event);
+                                   const SDL_MouseButtonEvent *event,
                                   bool control);
 void
-input_manager_process_mouse_wheel(struct input_manager *im,
+input_manager_process_mouse_wheel(struct input_manager *input_manager,
                                  const SDL_MouseWheelEvent *event);
 #endif
--- a/app/src/lock_util.h
+++ b/app/src/lock_util.h
@@ -0,0 +1,52 @@
 #ifndef LOCKUTIL_H
 #define LOCKUTIL_H
 #include <stdint.h>
 #include <SDL2/SDL_mutex.h>
 #include "config.h"
 #include "log.h"
 static inline void
 mutex_lock(SDL_mutex *mutex) {
    if (SDL_LockMutex(mutex)) {
        LOGC("Could not lock mutex");
        abort();
    }
 }
 static inline void
 mutex_unlock(SDL_mutex *mutex) {
    if (SDL_UnlockMutex(mutex)) {
        LOGC("Could not unlock mutex");
        abort();
    }
 }
 static inline void
 cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
    if (SDL_CondWait(cond, mutex)) {
        LOGC("Could not wait on condition");
        abort();
    }
 }
 static inline int
 cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
    int r = SDL_CondWaitTimeout(cond, mutex, ms);
    if (r < 0) {
        LOGC("Could not wait on condition with timeout");
        abort();
    }
    return r;
 }
 static inline void
 cond_signal(SDL_cond *cond) {
    if (SDL_CondSignal(cond)) {
        LOGC("Could not signal a condition");
        abort();
    }
 }
 #endif
--- a/app/src/util/log.h
+++ b/app/src/util/log.h
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -1,16 +1,191 @@
 #include "scrcpy.h"
-#include <assert.h>
+#include <getopt.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <unistd.h>
 #include <libavformat/avformat.h>
 #define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
 #include <SDL2/SDL.h>
 #include "config.h"
 #include "cli.h"
 #include "compat.h"
-#include "util/log.h"
+#include "log.h"
 #include "recorder.h"
 struct args {
    const char *serial;
    const char *crop;
    const char *record_filename;
    const char *window_title;
    const char *push_target;
    enum recorder_format record_format;
    bool fullscreen;
    bool no_control;
    bool no_display;
    bool help;
    bool version;
    bool show_touches;
    uint16_t port;
    uint16_t max_size;
    uint32_t bit_rate;
    bool always_on_top;
    bool turn_screen_off;
    bool render_expired_frames;
 };
 static void usage(const char *arg0) {
 #ifdef __APPLE__
 # define CTRL_OR_CMD "Cmd"
 #else
 # define CTRL_OR_CMD "Ctrl"
 #endif
    fprintf(stderr,
        "Usage: %s [options]\n"
        "\n"
        "Options:\n"
        "\n"
        "    -b, --bit-rate value\n"
        "        Encode the video at the given bit-rate, expressed in bits/s.\n"
        "        Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
        "        Default is %d.\n"
        "\n"
        "    -c, --crop width:height:x:y\n"
        "        Crop the device screen on the server.\n"
        "        The values are expressed in the device natural orientation\n"
        "        (typically, portrait for a phone, landscape for a tablet).\n"
        "        Any --max-size value is computed on the cropped size.\n"
        "\n"
        "    -f, --fullscreen\n"
        "        Start in fullscreen.\n"
        "\n"
        "    -F, --record-format\n"
        "        Force recording format (either mp4 or mkv).\n"
        "\n"
        "    -h, --help\n"
        "        Print this help.\n"
        "\n"
        "    -m, --max-size value\n"
        "        Limit both the width and height of the video to value. The\n"
        "        other dimension is computed so that the device aspect-ratio\n"
        "        is preserved.\n"
        "        Default is %d%s.\n"
        "\n"
        "    -n, --no-control\n"
        "        Disable device control (mirror the device in read-only).\n"
        "\n"
        "    -N, --no-display\n"
        "        Do not display device (only when screen recording is\n"
        "        enabled).\n"
        "\n"
        "    -p, --port port\n"
        "        Set the TCP port the client listens on.\n"
        "        Default is %d.\n"
        "\n"
        "    --push-target path\n"
        "        Set the target directory for pushing files to the device by\n"
        "        drag & drop. It is passed as-is to \"adb push\".\n"
        "        Default is \"/sdcard/\".\n"
        "\n"
        "    -r, --record file.mp4\n"
        "        Record screen to file.\n"
        "        The format is determined by the -F/--record-format option if\n"
        "        set, or by the file extension (.mp4 or .mkv).\n"
        "\n"
        "    --render-expired-frames\n"
        "        By default, to minimize latency, scrcpy always renders the\n"
        "        last available decoded frame, and drops any previous ones.\n"
        "        This flag forces to render all frames, at a cost of a\n"
        "        possible increased latency.\n"
        "\n"
        "    -s, --serial serial\n"
        "        The device serial number. Mandatory only if several devices\n"
        "        are connected to adb.\n"
        "\n"
        "    -S, --turn-screen-off\n"
        "        Turn the device screen off immediately.\n"
        "\n"
        "    -t, --show-touches\n"
        "        Enable \"show touches\" on start, disable on quit.\n"
        "        It only shows physical touches (not clicks from scrcpy).\n"
        "\n"
        "    -T, --always-on-top\n"
        "        Make scrcpy window always on top (above other windows).\n"
        "\n"
        "    -v, --version\n"
        "        Print the version of scrcpy.\n"
        "\n"
        "    --window-title text\n"
        "        Set a custom window title.\n"
        "\n"
        "Shortcuts:\n"
        "\n"
        "    " CTRL_OR_CMD "+f\n"
        "        switch fullscreen mode\n"
        "\n"
        "    " CTRL_OR_CMD "+g\n"
        "        resize window to 1:1 (pixel-perfect)\n"
        "\n"
        "    " CTRL_OR_CMD "+x\n"
        "    Double-click on black borders\n"
        "        resize window to remove black borders\n"
        "\n"
        "    Ctrl+h\n"
        "    Middle-click\n"
        "        click on HOME\n"
        "\n"
        "    " CTRL_OR_CMD "+b\n"
        "    " CTRL_OR_CMD "+Backspace\n"
        "    Right-click (when screen is on)\n"
        "        click on BACK\n"
        "\n"
        "    " CTRL_OR_CMD "+s\n"
        "        click on APP_SWITCH\n"
        "\n"
        "    Ctrl+m\n"
        "        click on MENU\n"
        "\n"
        "    " CTRL_OR_CMD "+Up\n"
        "        click on VOLUME_UP\n"
        "\n"
        "    " CTRL_OR_CMD "+Down\n"
        "        click on VOLUME_DOWN\n"
        "\n"
        "    " CTRL_OR_CMD "+p\n"
        "        click on POWER (turn screen on/off)\n"
        "\n"
        "    Right-click (when screen is off)\n"
        "        power on\n"
        "\n"
        "    " CTRL_OR_CMD "+o\n"
        "        turn device screen off (keep mirroring)\n"
        "\n"
        "    " CTRL_OR_CMD "+n\n"
        "       expand notification panel\n"
        "\n"
        "    " CTRL_OR_CMD "+Shift+n\n"
        "       collapse notification panel\n"
        "\n"
        "    " CTRL_OR_CMD "+c\n"
        "        copy device clipboard to computer\n"
        "\n"
        "    " CTRL_OR_CMD "+v\n"
        "        paste computer clipboard to device\n"
        "\n"
        "    " CTRL_OR_CMD "+Shift+v\n"
        "        copy computer clipboard to device\n"
        "\n"
        "    " CTRL_OR_CMD "+i\n"
        "        enable/disable FPS counter (print frames/second in logs)\n"
        "\n"
        "    Drag & drop APK file\n"
        "        install APK from computer\n"
        "\n",
        arg0,
        DEFAULT_BIT_RATE,
        DEFAULT_MAX_SIZE, DEFAULT_MAX_SIZE ? "" : " (unlimited)",
        DEFAULT_LOCAL_PORT);
 }
 static void
 print_version(void) {
@@ -30,23 +205,249 @@ print_version(void) {
                                               LIBAVUTIL_VERSION_MICRO);
 }
-static SDL_LogPriority
+static bool
-convert_log_level_to_sdl(enum sc_log_level level) {
+parse_bit_rate(char *optarg, uint32_t *bit_rate) {
-    switch (level) {
+    char *endptr;
-        case SC_LOG_LEVEL_DEBUG:
+    if (*optarg == '\0') {
-            return SDL_LOG_PRIORITY_DEBUG;
+        LOGE("Bit-rate parameter is empty");
-        case SC_LOG_LEVEL_INFO:
+        return false;
            return SDL_LOG_PRIORITY_INFO;
        case SC_LOG_LEVEL_WARN:
            return SDL_LOG_PRIORITY_WARN;
        case SC_LOG_LEVEL_ERROR:
            return SDL_LOG_PRIORITY_ERROR;
        default:
            assert(!"unexpected log level");
            return SDL_LOG_PRIORITY_INFO;
    }
    long value = strtol(optarg, &endptr, 0);
    int mul = 1;
    if (*endptr != '\0') {
        if (optarg == endptr) {
            LOGE("Invalid bit-rate: %s", optarg);
            return false;
        }
        if ((*endptr == 'M' || *endptr == 'm') && endptr[1] == '\0') {
            mul = 1000000;
        } else if ((*endptr == 'K' || *endptr == 'k') && endptr[1] == '\0') {
            mul = 1000;
        } else {
            LOGE("Invalid bit-rate unit: %s", optarg);
            return false;
        }
    }
    if (value < 0 || ((uint32_t) -1) / mul < value) {
        LOGE("Bitrate must be positive and less than 2^32: %s", optarg);
        return false;
    }
    *bit_rate = (uint32_t) value * mul;
    return true;
 }
 static bool
 parse_max_size(char *optarg, uint16_t *max_size) {
    char *endptr;
    if (*optarg == '\0') {
        LOGE("Max size parameter is empty");
        return false;
    }
    long value = strtol(optarg, &endptr, 0);
    if (*endptr != '\0') {
        LOGE("Invalid max size: %s", optarg);
        return false;
    }
    if (value & ~0xffff) {
        LOGE("Max size must be between 0 and 65535: %ld", value);
        return false;
    }
    *max_size = (uint16_t) value;
    return true;
 }
 static bool
 parse_port(char *optarg, uint16_t *port) {
    char *endptr;
    if (*optarg == '\0') {
        LOGE("Invalid port parameter is empty");
        return false;
    }
    long value = strtol(optarg, &endptr, 0);
    if (*endptr != '\0') {
        LOGE("Invalid port: %s", optarg);
        return false;
    }
    if (value & ~0xffff) {
        LOGE("Port out of range: %ld", value);
        return false;
    }
    *port = (uint16_t) value;
    return true;
 }
 static bool
 parse_record_format(const char *optarg, enum recorder_format *format) {
    if (!strcmp(optarg, "mp4")) {
        *format = RECORDER_FORMAT_MP4;
        return true;
    }
    if (!strcmp(optarg, "mkv")) {
        *format = RECORDER_FORMAT_MKV;
        return true;
    }
    LOGE("Unsupported format: %s (expected mp4 or mkv)", optarg);
    return false;
 }
 static enum recorder_format
 guess_record_format(const char *filename) {
    size_t len = strlen(filename);
    if (len < 4) {
        return 0;
    }
    const char *ext = &filename[len - 4];
    if (!strcmp(ext, ".mp4")) {
        return RECORDER_FORMAT_MP4;
    }
    if (!strcmp(ext, ".mkv")) {
        return RECORDER_FORMAT_MKV;
    }
    return 0;
 }
 #define OPT_RENDER_EXPIRED_FRAMES 1000
 #define OPT_WINDOW_TITLE          1001
 #define OPT_PUSH_TARGET           1002
 static bool
 parse_args(struct args *args, int argc, char *argv[]) {
    static const struct option long_options[] = {
        {"always-on-top",         no_argument,       NULL, 'T'},
        {"bit-rate",              required_argument, NULL, 'b'},
        {"crop",                  required_argument, NULL, 'c'},
        {"fullscreen",            no_argument,       NULL, 'f'},
        {"help",                  no_argument,       NULL, 'h'},
        {"max-size",              required_argument, NULL, 'm'},
        {"no-control",            no_argument,       NULL, 'n'},
        {"no-display",            no_argument,       NULL, 'N'},
        {"port",                  required_argument, NULL, 'p'},
        {"push-target",           required_argument, NULL,
                                                 OPT_PUSH_TARGET},
        {"record",                required_argument, NULL, 'r'},
        {"record-format",         required_argument, NULL, 'F'},
        {"render-expired-frames", no_argument,       NULL,
                                                 OPT_RENDER_EXPIRED_FRAMES},
        {"serial",                required_argument, NULL, 's'},
        {"show-touches",          no_argument,       NULL, 't'},
        {"turn-screen-off",       no_argument,       NULL, 'S'},
        {"version",               no_argument,       NULL, 'v'},
        {"window-title",          required_argument, NULL,
                                                 OPT_WINDOW_TITLE},
        {NULL,                    0,                 NULL, 0  },
    };
    int c;
    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTv", long_options,
                            NULL)) != -1) {
        switch (c) {
            case 'b':
                if (!parse_bit_rate(optarg, &args->bit_rate)) {
                    return false;
                }
                break;
            case 'c':
                args->crop = optarg;
                break;
            case 'f':
                args->fullscreen = true;
                break;
            case 'F':
                if (!parse_record_format(optarg, &args->record_format)) {
                    return false;
                }
                break;
            case 'h':
                args->help = true;
                break;
            case 'm':
                if (!parse_max_size(optarg, &args->max_size)) {
                    return false;
                }
                break;
            case 'n':
                args->no_control = true;
                break;
            case 'N':
                args->no_display = true;
                break;
            case 'p':
                if (!parse_port(optarg, &args->port)) {
                    return false;
                }
                break;
            case 'r':
                args->record_filename = optarg;
                break;
            case 's':
                args->serial = optarg;
                break;
            case 'S':
                args->turn_screen_off = true;
                break;
            case 't':
                args->show_touches = true;
                break;
            case 'T':
                args->always_on_top = true;
                break;
            case 'v':
                args->version = true;
                break;
            case OPT_RENDER_EXPIRED_FRAMES:
                args->render_expired_frames = true;
                break;
            case OPT_WINDOW_TITLE:
                args->window_title = optarg;
                break;
            case OPT_PUSH_TARGET:
                args->push_target = optarg;
                break;
            default:
                // getopt prints the error message on stderr
                return false;
        }
    }
    if (args->no_display && !args->record_filename) {
        LOGE("-N/--no-display requires screen recording (-r/--record)");
        return false;
    }
    if (args->no_display && args->fullscreen) {
        LOGE("-f/--fullscreen-window is incompatible with -N/--no-display");
        return false;
    }
    int index = optind;
    if (index < argc) {
        LOGE("Unexpected additional argument: %s", argv[index]);
        return false;
    }
    if (args->record_format && !args->record_filename) {
        LOGE("Record format specified without recording");
        return false;
    }
    if (args->record_filename && !args->record_format) {
        args->record_format = guess_record_format(args->record_filename);
        if (!args->record_format) {
            LOGE("No format specified for \"%s\" (try with -F mkv)",
                 args->record_filename);
            return false;
        }
    }
    if (args->no_control && args->turn_screen_off) {
        LOGE("Could not request to turn screen off if control is disabled");
        return false;
    }
    return true;
 }
 int
 main(int argc, char *argv[]) {
@@ -56,26 +457,31 @@ main(int argc, char *argv[]) {
    setbuf(stdout, NULL);
    setbuf(stderr, NULL);
 #endif
-
+    struct args args = {
-    struct scrcpy_cli_args args = {
+        .serial = NULL,
-        .opts = SCRCPY_OPTIONS_DEFAULT,
+        .crop = NULL,
        .record_filename = NULL,
        .window_title = NULL,
        .push_target = NULL,
        .record_format = 0,
        .help = false,
        .version = false,
        .show_touches = false,
        .port = DEFAULT_LOCAL_PORT,
        .max_size = DEFAULT_MAX_SIZE,
        .bit_rate = DEFAULT_BIT_RATE,
        .always_on_top = false,
        .no_control = false,
        .no_display = false,
        .turn_screen_off = false,
        .render_expired_frames = false,
    };
-
+    if (!parse_args(&args, argc, argv)) {
 #ifndef NDEBUG
    args.opts.log_level = SC_LOG_LEVEL_DEBUG;
 #endif
    if (!scrcpy_parse_args(&args, argc, argv)) {
        return 1;
    }
    SDL_LogPriority sdl_log = convert_log_level_to_sdl(args.opts.log_level);
    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, sdl_log);
    if (args.help) {
-        scrcpy_print_usage(argv[0]);
+        usage(argv[0]);
        return 0;
    }
@@ -94,9 +500,37 @@ main(int argc, char *argv[]) {
        return 1;
    }
-    int res = scrcpy(&args.opts) ? 0 : 1;
+#ifdef BUILD_DEBUG
    SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
 #endif
    struct scrcpy_options options = {
        .serial = args.serial,
        .crop = args.crop,
        .port = args.port,
        .record_filename = args.record_filename,
        .window_title = args.window_title,
        .push_target = args.push_target,
        .record_format = args.record_format,
        .max_size = args.max_size,
        .bit_rate = args.bit_rate,
        .show_touches = args.show_touches,
        .fullscreen = args.fullscreen,
        .always_on_top = args.always_on_top,
        .control = !args.no_control,
        .display = !args.no_display,
        .turn_screen_off = args.turn_screen_off,
        .render_expired_frames = args.render_expired_frames,
    };
    int res = scrcpy(&options) ? 0 : 1;
    avformat_network_deinit(); // ignore failure
 #if defined (__WINDOWS__) && ! defined (WINDOWS_NOCONSOLE)
    if (res != 0) {
        fprintf(stderr, "Press any key to continue...\n");
        getchar();
    }
 #endif
    return res;
 }
--- a/app/src/util/net.c
+++ b/app/src/util/net.c
@@ -1,7 +1,6 @@
 #include "net.h"
 #include <stdio.h>
 #include <SDL2/SDL_platform.h>
 #include "config.h"
 #include "log.h"
@@ -116,32 +115,3 @@ bool
 net_shutdown(socket_t socket, int how) {
    return !shutdown(socket, how);
 }
 bool
 net_init(void) {
 #ifdef __WINDOWS__
    WSADATA wsa;
    int res = WSAStartup(MAKEWORD(2, 2), &wsa) < 0;
    if (res < 0) {
        LOGC("WSAStartup failed with error %d", res);
        return false;
    }
 #endif
    return true;
 }
 void
 net_cleanup(void) {
 #ifdef __WINDOWS__
    WSACleanup();
 #endif
 }
 bool
 net_close(socket_t socket) {
 #ifdef __WINDOWS__
    return !closesocket(socket);
 #else
    return !close(socket);
 #endif
 }
--- a/app/src/util/net.h
+++ b/app/src/util/net.h
--- a/app/src/opengl.c
+++ b/app/src/opengl.c
@@ -1,56 +0,0 @@
 #include "opengl.h"
 #include <assert.h>
 #include <stdio.h>
 #include "SDL2/SDL.h"
 void
 sc_opengl_init(struct sc_opengl *gl) {
    gl->GetString = SDL_GL_GetProcAddress("glGetString");
    assert(gl->GetString);
    gl->TexParameterf = SDL_GL_GetProcAddress("glTexParameterf");
    assert(gl->TexParameterf);
    gl->TexParameteri = SDL_GL_GetProcAddress("glTexParameteri");
    assert(gl->TexParameteri);
    // optional
    gl->GenerateMipmap = SDL_GL_GetProcAddress("glGenerateMipmap");
    const char *version = (const char *) gl->GetString(GL_VERSION);
    assert(version);
    gl->version = version;
 #define OPENGL_ES_PREFIX "OpenGL ES "
    /* starts with "OpenGL ES " */
    gl->is_opengles = !strncmp(gl->version, OPENGL_ES_PREFIX,
                               sizeof(OPENGL_ES_PREFIX) - 1);
    if (gl->is_opengles) {
        /* skip the prefix */
        version += sizeof(PREFIX) - 1;
    }
    int r = sscanf(version, "%d.%d", &gl->version_major, &gl->version_minor);
    if (r != 2) {
        // failed to parse the version
        gl->version_major = 0;
        gl->version_minor = 0;
    }
 }
 bool
 sc_opengl_version_at_least(struct sc_opengl *gl,
                           int minver_major, int minver_minor,
                           int minver_es_major, int minver_es_minor)
 {
    if (gl->is_opengles) {
        return gl->version_major > minver_es_major
            || (gl->version_major == minver_es_major
             && gl->version_minor >= minver_es_minor);
    }
    return gl->version_major > minver_major
        || (gl->version_major == minver_major
         && gl->version_minor >= minver_minor);
 }
--- a/app/src/opengl.h
+++ b/app/src/opengl.h
@@ -1,36 +0,0 @@
 #ifndef SC_OPENGL_H
 #define SC_OPENGL_H
 #include <stdbool.h>
 #include <SDL2/SDL_opengl.h>
 #include "config.h"
 struct sc_opengl {
    const char *version;
    bool is_opengles;
    int version_major;
    int version_minor;
    const GLubyte *
    (*GetString)(GLenum name);
    void
    (*TexParameterf)(GLenum target, GLenum pname, GLfloat param);
    void
    (*TexParameteri)(GLenum target, GLenum pname, GLint param);
    void
    (*GenerateMipmap)(GLenum target);
 };
 void
 sc_opengl_init(struct sc_opengl *gl);
 bool
 sc_opengl_version_at_least(struct sc_opengl *gl,
                           int minver_major, int minver_minor,
                           int minver_es_major, int minver_es_minor);
 #endif
--- a/app/src/util/queue.h
+++ b/app/src/util/queue.h
@@ -2,9 +2,9 @@
 #ifndef QUEUE_H
 #define QUEUE_H
 #include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <SDL2/SDL_assert.h>
 #include "config.h"
@@ -67,7 +67,7 @@
 // type so that we can "return" it)
 #define queue_take(PQ, NEXTFIELD, PITEM) \
    (void) ({ \
-        assert(!queue_is_empty(PQ)); \
+        SDL_assert(!queue_is_empty(PQ)); \
        *(PITEM) = (PQ)->first; \
        (PQ)->first = (PQ)->first->NEXTFIELD; \
    })
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@@ -1,12 +1,12 @@
 #include "receiver.h"
-#include <assert.h>
+#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_clipboard.h>
 #include "config.h"
 #include "device_msg.h"
-#include "util/lock.h"
+#include "lock_util.h"
-#include "util/log.h"
+#include "log.h"
 bool
 receiver_init(struct receiver *receiver, socket_t control_socket) {
@@ -23,26 +23,17 @@ receiver_destroy(struct receiver *receiver) {
 }
 static void
-process_msg(struct device_msg *msg) {
+process_msg(struct receiver *receiver, struct device_msg *msg) {
    switch (msg->type) {
-        case DEVICE_MSG_TYPE_CLIPBOARD: {
+        case DEVICE_MSG_TYPE_CLIPBOARD:
            char *current = SDL_GetClipboardText();
            bool same = current && !strcmp(current, msg->clipboard.text);
            SDL_free(current);
            if (same) {
                LOGD("Computer clipboard unchanged");
                return;
            }
            LOGI("Device clipboard copied");
            SDL_SetClipboardText(msg->clipboard.text);
            break;
        }
    }
 }
 static ssize_t
-process_msgs(const unsigned char *buf, size_t len) {
+process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
    size_t head = 0;
    for (;;) {
        struct device_msg msg;
@@ -54,11 +45,11 @@ process_msgs(const unsigned char *buf, size_t len) {
            return head;
        }
-        process_msg(&msg);
+        process_msg(receiver, &msg);
        device_msg_destroy(&msg);
        head += r;
-        assert(head <= len);
+        SDL_assert(head <= len);
        if (head == len) {
            return head;
        }
@@ -69,29 +60,28 @@ static int
 run_receiver(void *data) {
    struct receiver *receiver = data;
-    static unsigned char buf[DEVICE_MSG_MAX_SIZE];
+    unsigned char buf[DEVICE_MSG_SERIALIZED_MAX_SIZE];
    size_t head = 0;
    for (;;) {
-        assert(head < DEVICE_MSG_MAX_SIZE);
+        SDL_assert(head < DEVICE_MSG_SERIALIZED_MAX_SIZE);
-        ssize_t r = net_recv(receiver->control_socket, buf + head,
+        ssize_t r = net_recv(receiver->control_socket, buf,
-                             DEVICE_MSG_MAX_SIZE - head);
+                             DEVICE_MSG_SERIALIZED_MAX_SIZE - head);
        if (r <= 0) {
            LOGD("Receiver stopped");
            break;
        }
-        head += r;
+        ssize_t consumed = process_msgs(receiver, buf, r);
        ssize_t consumed = process_msgs(buf, head);
        if (consumed == -1) {
            // an error occurred
            break;
        }
        if (consumed) {
            head -= consumed;
            // shift the remaining data in the buffer
-            memmove(buf, &buf[consumed], head);
+            memmove(buf, &buf[consumed], r - consumed);
            head = r - consumed;
        }
    }
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@@ -6,7 +6,7 @@
 #include <SDL2/SDL_thread.h>
 #include "config.h"
-#include "util/net.h"
+#include "net.h"
 // receive events from the device
 // managed by the controller
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@@ -1,12 +1,12 @@
 #include "recorder.h"
 #include <assert.h>
 #include <libavutil/time.h>
 #include <SDL2/SDL_assert.h>
 #include "config.h"
 #include "compat.h"
-#include "util/lock.h"
+#include "lock_util.h"
-#include "util/log.h"
+#include "log.h"
 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
@@ -63,7 +63,7 @@ recorder_queue_clear(struct recorder_queue *queue) {
 bool
 recorder_init(struct recorder *recorder,
              const char *filename,
-              enum sc_record_format format,
+              enum recorder_format format,
              struct size declared_frame_size) {
    recorder->filename = SDL_strdup(filename);
    if (!recorder->filename) {
@@ -105,10 +105,10 @@ recorder_destroy(struct recorder *recorder) {
 }
 static const char *
-recorder_get_format_name(enum sc_record_format format) {
+recorder_get_format_name(enum recorder_format format) {
    switch (format) {
-        case SC_RECORD_FORMAT_MP4: return "mp4";
+        case RECORDER_FORMAT_MP4: return "mp4";
-        case SC_RECORD_FORMAT_MKV: return "matroska";
+        case RECORDER_FORMAT_MKV: return "matroska";
        default: return NULL;
    }
 }
@@ -116,7 +116,7 @@ recorder_get_format_name(enum sc_record_format format) {
 bool
 recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    const char *format_name = recorder_get_format_name(recorder->format);
-    assert(format_name);
+    SDL_assert(format_name);
    const AVOutputFormat *format = find_muxer(format_name);
    if (!format) {
        LOGE("Could not find muxer");
@@ -135,9 +135,6 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    // <https://github.com/FFmpeg/FFmpeg/commit/0694d8702421e7aff1340038559c438b61bb30dd>
    recorder->ctx->oformat = (AVOutputFormat *) format;
    av_dict_set(&recorder->ctx->metadata, "comment",
                "Recorded by scrcpy " SCRCPY_VERSION, 0);
    AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
    if (!ostream) {
        avformat_free_context(recorder->ctx);
@@ -174,14 +171,9 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
 void
 recorder_close(struct recorder *recorder) {
-    if (recorder->header_written) {
+    int ret = av_write_trailer(recorder->ctx);
-        int ret = av_write_trailer(recorder->ctx);
+    if (ret < 0) {
-        if (ret < 0) {
+        LOGE("Failed to write trailer to %s", recorder->filename);
            LOGE("Failed to write trailer to %s", recorder->filename);
            recorder->failed = true;
        }
    } else {
        // the recorded file is empty
        recorder->failed = true;
    }
    avio_close(recorder->ctx->pb);
@@ -301,12 +293,8 @@ run_recorder(void *data) {
            continue;
        }
-        // config packets have no PTS, we must ignore them
+        // we now know the duration of the previous packet
-        if (rec->packet.pts != AV_NOPTS_VALUE
+        previous->packet.duration = rec->packet.pts - previous->packet.pts;
            && previous->packet.pts != AV_NOPTS_VALUE) {
            // we now know the duration of the previous packet
            previous->packet.duration = rec->packet.pts - previous->packet.pts;
        }
        bool ok = recorder_write(recorder, &previous->packet);
        record_packet_delete(previous);
@@ -357,18 +345,16 @@ recorder_join(struct recorder *recorder) {
 bool
 recorder_push(struct recorder *recorder, const AVPacket *packet) {
    mutex_lock(recorder->mutex);
-    assert(!recorder->stopped);
+    SDL_assert(!recorder->stopped);
    if (recorder->failed) {
        // reject any new packet (this will stop the stream)
        mutex_unlock(recorder->mutex);
        return false;
    }
    struct record_packet *rec = record_packet_new(packet);
    if (!rec) {
        LOGC("Could not allocate record packet");
        mutex_unlock(recorder->mutex);
        return false;
    }
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@@ -8,8 +8,12 @@
 #include "config.h"
 #include "common.h"
-#include "scrcpy.h"
+#include "queue.h"
-#include "util/queue.h"
+
 enum recorder_format {
    RECORDER_FORMAT_MP4 = 1,
    RECORDER_FORMAT_MKV,
 };
 struct record_packet {
    AVPacket packet;
@@ -20,7 +24,7 @@ struct recorder_queue QUEUE(struct record_packet);
 struct recorder {
    char *filename;
-    enum sc_record_format format;
+    enum recorder_format format;
    AVFormatContext *ctx;
    struct size declared_frame_size;
    bool header_written;
@@ -41,7 +45,7 @@ struct recorder {
 bool
 recorder_init(struct recorder *recorder, const char *filename,
-              enum sc_record_format format, struct size declared_frame_size);
+              enum recorder_format format, struct size declared_frame_size);
 void
 recorder_destroy(struct recorder *recorder);
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -7,12 +7,6 @@
 #include <sys/time.h>
 #include <SDL2/SDL.h>
 #ifdef _WIN32
 // not needed here, but winsock2.h must never be included AFTER windows.h
 # include <winsock2.h>
 # include <windows.h>
 #endif
 #include "config.h"
 #include "command.h"
 #include "common.h"
@@ -24,17 +18,17 @@
 #include "file_handler.h"
 #include "fps_counter.h"
 #include "input_manager.h"
 #include "log.h"
 #include "lock_util.h"
 #include "net.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
 #include "stream.h"
 #include "tiny_xpm.h"
 #include "video_buffer.h"
 #include "util/lock.h"
 #include "util/log.h"
 #include "util/net.h"
-static struct server server;
+static struct server server = SERVER_INITIALIZER;
 static struct screen screen = SCREEN_INITIALIZER;
 static struct fps_counter fps_counter;
 static struct video_buffer video_buffer;
@@ -48,32 +42,11 @@ static struct input_manager input_manager = {
    .controller = &controller,
    .video_buffer = &video_buffer,
    .screen = &screen,
    .repeat = 0,
    // initialized later
    .prefer_text = false,
    .sdl_shortcut_mods = {
        .data = {0},
        .count = 0,
    },
 };
 #ifdef _WIN32
 BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
    if (ctrl_type == CTRL_C_EVENT) {
        SDL_Event event;
        event.type = SDL_QUIT;
        SDL_PushEvent(&event);
        return TRUE;
    }
    return FALSE;
 }
 #endif // _WIN32
 // init SDL and set appropriate hints
 static bool
-sdl_init_and_configure(bool display, const char *render_driver,
+sdl_init_and_configure(bool display) {
                       bool disable_screensaver) {
    uint32_t flags = display ? SDL_INIT_VIDEO : SDL_INIT_EVENTS;
    if (SDL_Init(flags)) {
        LOGC("Could not initialize SDL: %s", SDL_GetError());
@@ -82,25 +55,13 @@ sdl_init_and_configure(bool display, const char *render_driver,
    atexit(SDL_Quit);
 #ifdef _WIN32
    // Clean up properly on Ctrl+C on Windows
    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
    if (!ok) {
        LOGW("Could not set Ctrl+C handler");
    }
 #endif // _WIN32
    if (!display) {
        return true;
    }
-    if (render_driver && !SDL_SetHint(SDL_HINT_RENDER_DRIVER, render_driver)) {
+    // Use the best available scale quality
-        LOGW("Could not set render driver");
+    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "2")) {
-    }
+        LOGW("Could not enable bilinear filtering");
    // Linear filtering
    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
        LOGW("Could not enable linear filtering");
    }
 #ifdef SCRCPY_SDL_HAS_HINT_MOUSE_FOCUS_CLICKTHROUGH
@@ -122,13 +83,8 @@ sdl_init_and_configure(bool display, const char *render_driver,
        LOGW("Could not disable minimize on focus loss");
    }
-    if (disable_screensaver) {
+    // Do not disable the screensaver when scrcpy is running
-        LOGD("Screensaver disabled");
+    SDL_EnableScreenSaver();
        SDL_DisableScreenSaver();
    } else {
        LOGD("Screensaver enabled");
        SDL_EnableScreenSaver();
    }
    return true;
 }
@@ -146,12 +102,10 @@ sdl_init_and_configure(bool display, const char *render_driver,
 // <https://stackoverflow.com/a/40693139/1987178>
 static int
 event_watcher(void *data, SDL_Event *event) {
    (void) data;
    if (event->type == SDL_WINDOWEVENT
            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
-        // In practice, it seems to always be called from the same thread in
+        // called from another thread, not very safe, but it's a workaround!
-        // that specific case. Anyway, it's just a workaround.
+        screen_render(&screen);
        screen_render(&screen, true);
    }
    return 0;
 }
@@ -170,7 +124,7 @@ enum event_result {
 };
 static enum event_result
-handle_event(SDL_Event *event, const struct scrcpy_options *options) {
+handle_event(SDL_Event *event, bool control) {
    switch (event->type) {
        case EVENT_STREAM_STOPPED:
            LOGD("Video stream stopped");
@@ -189,10 +143,15 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
            }
            break;
        case SDL_WINDOWEVENT:
-            screen_handle_window_event(&screen, &event->window);
+            switch (event->window.event) {
                case SDL_WINDOWEVENT_EXPOSED:
                case SDL_WINDOWEVENT_SIZE_CHANGED:
                    screen_render(&screen);
                    break;
            }
            break;
        case SDL_TEXTINPUT:
-            if (!options->control) {
+            if (!control) {
                break;
            }
            input_manager_process_text_input(&input_manager, &event->text);
@@ -201,16 +160,16 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
        case SDL_KEYUP:
            // some key events do not interact with the device, so process the
            // event even if control is disabled
-            input_manager_process_key(&input_manager, &event->key);
+            input_manager_process_key(&input_manager, &event->key, control);
            break;
        case SDL_MOUSEMOTION:
-            if (!options->control) {
+            if (!control) {
                break;
            }
            input_manager_process_mouse_motion(&input_manager, &event->motion);
            break;
        case SDL_MOUSEWHEEL:
-            if (!options->control) {
+            if (!control) {
                break;
            }
            input_manager_process_mouse_wheel(&input_manager, &event->wheel);
@@ -219,7 +178,8 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
        case SDL_MOUSEBUTTONUP:
            // some mouse events do not interact with the device, so process
            // the event even if control is disabled
-            input_manager_process_mouse_button(&input_manager, &event->button);
+            input_manager_process_mouse_button(&input_manager, &event->button,
                                               control);
            break;
        case SDL_FINGERMOTION:
        case SDL_FINGERDOWN:
@@ -227,7 +187,7 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
            input_manager_process_touch(&input_manager, &event->tfinger);
            break;
        case SDL_DROPFILE: {
-            if (!options->control) {
+            if (!control) {
                break;
            }
            file_handler_action_t action;
@@ -244,20 +204,19 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
 }
 static bool
-event_loop(const struct scrcpy_options *options) {
+event_loop(bool display, bool control) {
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
-    if (options->display) {
+    if (display) {
        SDL_AddEventWatch(event_watcher, NULL);
    }
 #endif
    SDL_Event event;
    while (SDL_WaitEvent(&event)) {
-        enum event_result result = handle_event(&event, options);
+        enum event_result result = handle_event(&event, control);
        switch (result) {
            case EVENT_RESULT_STOPPED_BY_USER:
                return true;
            case EVENT_RESULT_STOPPED_BY_EOS:
                LOGW("Device disconnected");
                return false;
            case EVENT_RESULT_CONTINUE:
                break;
@@ -266,6 +225,21 @@ event_loop(const struct scrcpy_options *options) {
    return false;
 }
 static process_t
 set_show_touches_enabled(const char *serial, bool enabled) {
    const char *value = enabled ? "1" : "0";
    const char *const adb_cmd[] = {
        "shell", "settings", "put", "system", "show_touches", value
    };
    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 static void
 wait_show_touches(process_t process) {
    // reap the process, ignore the result
    process_check_success(process, "show_touches");
 }
 static SDL_LogPriority
 sdl_priority_from_av_level(int level) {
    switch (level) {
@@ -285,7 +259,6 @@ sdl_priority_from_av_level(int level) {
 static void
 av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
    (void) avcl;
    SDL_LogPriority priority = sdl_priority_from_av_level(level);
    if (priority == 0) {
        return;
@@ -304,13 +277,28 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
 bool
 scrcpy(const struct scrcpy_options *options) {
-    if (!server_init(&server)) {
+    bool record = !!options->record_filename;
    struct server_params params = {
        .crop = options->crop,
        .local_port = options->port,
        .max_size = options->max_size,
        .bit_rate = options->bit_rate,
        .control = options->control,
    };
    if (!server_start(&server, options->serial, &params)) {
        return false;
    }
    process_t proc_show_touches = PROCESS_NONE;
    bool show_touches_waited;
    if (options->show_touches) {
        LOGI("Enable show_touches");
        proc_show_touches = set_show_touches_enabled(options->serial, true);
        show_touches_waited = false;
    }
    bool ret = false;
    bool server_started = false;
    bool fps_counter_initialized = false;
    bool video_buffer_initialized = false;
    bool file_handler_initialized = false;
@@ -319,31 +307,7 @@ scrcpy(const struct scrcpy_options *options) {
    bool controller_initialized = false;
    bool controller_started = false;
-    bool record = !!options->record_filename;
+    if (!sdl_init_and_configure(options->display)) {
    struct server_params params = {
        .log_level = options->log_level,
        .crop = options->crop,
        .port_range = options->port_range,
        .max_size = options->max_size,
        .bit_rate = options->bit_rate,
        .max_fps = options->max_fps,
        .lock_video_orientation = options->lock_video_orientation,
        .control = options->control,
        .display_id = options->display_id,
        .show_touches = options->show_touches,
        .stay_awake = options->stay_awake,
        .codec_options = options->codec_options,
        .encoder_name = options->encoder_name,
        .force_adb_forward = options->force_adb_forward,
    };
    if (!server_start(&server, options->serial, &params)) {
        goto end;
    }
    server_started = true;
    if (!sdl_init_and_configure(options->display, options->render_driver,
                                options->disable_screensaver)) {
        goto end;
    }
@@ -426,11 +390,7 @@ scrcpy(const struct scrcpy_options *options) {
            options->window_title ? options->window_title : device_name;
        if (!screen_init_rendering(&screen, window_title, frame_size,
-                                   options->always_on_top, options->window_x,
+                                   options->always_on_top)) {
                                   options->window_y, options->window_width,
                                   options->window_height,
                                   options->window_borderless,
                                   options->rotation, options->mipmaps)) {
            goto end;
        }
@@ -449,9 +409,12 @@ scrcpy(const struct scrcpy_options *options) {
        }
    }
-    input_manager_init(&input_manager, options);
+    if (options->show_touches) {
        wait_show_touches(proc_show_touches);
        show_touches_waited = true;
    }
-    ret = event_loop(options);
+    ret = event_loop(options->display, options->control);
    LOGD("quit...");
    screen_destroy(&screen);
@@ -472,10 +435,8 @@ end:
        fps_counter_interrupt(&fps_counter);
    }
-    if (server_started) {
+    // shutdown the sockets and kill the server
-        // shutdown the sockets and kill the server
+    server_stop(&server);
        server_stop(&server);
    }
    // now that the sockets are shutdown, the stream and controller are
    // interrupted, we can join them
@@ -507,6 +468,16 @@ end:
        fps_counter_destroy(&fps_counter);
    }
    if (options->show_touches) {
        if (!show_touches_waited) {
            // wait the process which enabled "show touches"
            wait_show_touches(proc_show_touches);
        }
        LOGI("Disable show_touches");
        proc_show_touches = set_show_touches_enabled(options->serial, false);
        wait_show_touches(proc_show_touches);
    }
    server_destroy(&server);
    return ret;
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@@ -2,70 +2,21 @@
 #define SCRCPY_H
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <recorder.h>
 #include "config.h"
 enum sc_log_level {
    SC_LOG_LEVEL_DEBUG,
    SC_LOG_LEVEL_INFO,
    SC_LOG_LEVEL_WARN,
    SC_LOG_LEVEL_ERROR,
 };
 enum sc_record_format {
    SC_RECORD_FORMAT_AUTO,
    SC_RECORD_FORMAT_MP4,
    SC_RECORD_FORMAT_MKV,
 };
 #define SC_MAX_SHORTCUT_MODS 8
 enum sc_shortcut_mod {
    SC_MOD_LCTRL = 1 << 0,
    SC_MOD_RCTRL = 1 << 1,
    SC_MOD_LALT = 1 << 2,
    SC_MOD_RALT = 1 << 3,
    SC_MOD_LSUPER = 1 << 4,
    SC_MOD_RSUPER = 1 << 5,
 };
 struct sc_shortcut_mods {
    unsigned data[SC_MAX_SHORTCUT_MODS];
    unsigned count;
 };
 struct sc_port_range {
    uint16_t first;
    uint16_t last;
 };
 #define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
 struct scrcpy_options {
    const char *serial;
    const char *crop;
    const char *record_filename;
    const char *window_title;
    const char *push_target;
-    const char *render_driver;
+    enum recorder_format record_format;
-    const char *codec_options;
+    uint16_t port;
    const char *encoder_name;
    enum sc_log_level log_level;
    enum sc_record_format record_format;
    struct sc_port_range port_range;
    struct sc_shortcut_mods shortcut_mods;
    uint16_t max_size;
    uint32_t bit_rate;
    uint16_t max_fps;
    int8_t lock_video_orientation;
    uint8_t rotation;
    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    uint16_t window_width;
    uint16_t window_height;
    uint16_t display_id;
    bool show_touches;
    bool fullscreen;
    bool always_on_top;
@@ -73,64 +24,8 @@ struct scrcpy_options {
    bool display;
    bool turn_screen_off;
    bool render_expired_frames;
    bool prefer_text;
    bool window_borderless;
    bool mipmaps;
    bool stay_awake;
    bool force_adb_forward;
    bool disable_screensaver;
    bool forward_key_repeat;
    bool forward_all_clicks;
    bool legacy_paste;
 };
 #define SCRCPY_OPTIONS_DEFAULT { \
    .serial = NULL, \
    .crop = NULL, \
    .record_filename = NULL, \
    .window_title = NULL, \
    .push_target = NULL, \
    .render_driver = NULL, \
    .codec_options = NULL, \
    .encoder_name = NULL, \
    .log_level = SC_LOG_LEVEL_INFO, \
    .record_format = SC_RECORD_FORMAT_AUTO, \
    .port_range = { \
        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
        .last = DEFAULT_LOCAL_PORT_RANGE_LAST, \
    }, \
    .shortcut_mods = { \
        .data = {SC_MOD_LALT, SC_MOD_LSUPER}, \
        .count = 2, \
    }, \
    .max_size = DEFAULT_MAX_SIZE, \
    .bit_rate = DEFAULT_BIT_RATE, \
    .max_fps = 0, \
    .lock_video_orientation = DEFAULT_LOCK_VIDEO_ORIENTATION, \
    .rotation = 0, \
    .window_x = SC_WINDOW_POSITION_UNDEFINED, \
    .window_y = SC_WINDOW_POSITION_UNDEFINED, \
    .window_width = 0, \
    .window_height = 0, \
    .display_id = 0, \
    .show_touches = false, \
    .fullscreen = false, \
    .always_on_top = false, \
    .control = true, \
    .display = true, \
    .turn_screen_off = false, \
    .render_expired_frames = false, \
    .prefer_text = false, \
    .window_borderless = false, \
    .mipmaps = true, \
    .stay_awake = false, \
    .force_adb_forward = false, \
    .disable_screensaver = false, \
    .forward_key_repeat = true, \
    .forward_all_clicks = false, \
    .legacy_paste = false, \
 }
 bool
 scrcpy(const struct scrcpy_options *options);
--- a/app/src/screen.c
+++ b/app/src/screen.c
@@ -1,6 +1,5 @@
 #include "screen.h"
 #include <assert.h>
 #include <string.h>
 #include <SDL2/SDL.h>
@@ -8,33 +7,19 @@
 #include "common.h"
 #include "compat.h"
 #include "icon.xpm"
-#include "scrcpy.h"
+#include "lock_util.h"
 #include "log.h"
 #include "tiny_xpm.h"
 #include "video_buffer.h"
 #include "util/lock.h"
 #include "util/log.h"
 #define DISPLAY_MARGINS 96
 static inline struct size
 get_rotated_size(struct size size, int rotation) {
    struct size rotated_size;
    if (rotation & 1) {
        rotated_size.width = size.height;
        rotated_size.height = size.width;
    } else {
        rotated_size.width = size.width;
        rotated_size.height = size.height;
    }
    return rotated_size;
 }
 // get the window size in a struct size
 static struct size
-get_window_size(const struct screen *screen) {
+get_native_window_size(SDL_Window *window) {
    int width;
    int height;
-    SDL_GetWindowSize(screen->window, &width, &height);
+    SDL_GetWindowSize(window, &width, &height);
    struct size size;
    size.width = width;
@@ -42,12 +27,26 @@ get_window_size(const struct screen *screen) {
    return size;
 }
 // get the windowed window size
 static struct size
 get_window_size(const struct screen *screen) {
    if (screen->fullscreen) {
        return screen->windowed_window_size;
    }
    return get_native_window_size(screen->window);
 }
 // set the window size to be applied when fullscreen is disabled
 static void
 set_window_size(struct screen *screen, struct size new_size) {
-    assert(!screen->fullscreen);
+    // setting the window size during fullscreen is implementation defined,
-    assert(!screen->maximized);
+    // so apply the resize only after fullscreen is disabled
-    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
+    if (screen->fullscreen) {
        // SDL_SetWindowSize will be called when fullscreen will be disabled
        screen->windowed_window_size = new_size;
    } else {
        SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
    }
 }
 // get the preferred display bounds (i.e. the screen bounds with some margins)
@@ -69,129 +68,58 @@ get_preferred_display_bounds(struct size *bounds) {
    return true;
 }
 static bool
 is_optimal_size(struct size current_size, struct size content_size) {
    // The size is optimal if we can recompute one dimension of the current
    // size from the other
    return current_size.height == current_size.width * content_size.height
                                                     / content_size.width
        || current_size.width == current_size.height * content_size.width
                                                     / content_size.height;
 }
 // return the optimal size of the window, with the following constraints:
 //  - it attempts to keep at least one dimension of the current_size (i.e. it
 //    crops the black borders)
 //  - it keeps the aspect ratio
 //  - it scales down to make it fit in the display_size
 static struct size
-get_optimal_size(struct size current_size, struct size content_size) {
+get_optimal_size(struct size current_size, struct size frame_size) {
-    if (content_size.width == 0 || content_size.height == 0) {
+    if (frame_size.width == 0 || frame_size.height == 0) {
        // avoid division by 0
        return current_size;
    }
    struct size window_size;
    struct size display_size;
    // 32 bits because we need to multiply two 16 bits values
    uint32_t w;
    uint32_t h;
    if (!get_preferred_display_bounds(&display_size)) {
        // could not get display bounds, do not constraint the size
-        window_size.width = current_size.width;
+        w = current_size.width;
-        window_size.height = current_size.height;
+        h = current_size.height;
    } else {
-        window_size.width = MIN(current_size.width, display_size.width);
+        w = MIN(current_size.width, display_size.width);
-        window_size.height = MIN(current_size.height, display_size.height);
+        h = MIN(current_size.height, display_size.height);
    }
-    if (is_optimal_size(window_size, content_size)) {
+    bool keep_width = frame_size.width * h > frame_size.height * w;
        return window_size;
    }
    bool keep_width = content_size.width * window_size.height
                    > content_size.height * window_size.width;
    if (keep_width) {
        // remove black borders on top and bottom
-        window_size.height = content_size.height * window_size.width
+        h = frame_size.height * w / frame_size.width;
                           / content_size.width;
    } else {
        // remove black borders on left and right (or none at all if it already
        // fits)
-        window_size.width = content_size.width * window_size.height
+        w = frame_size.width * h / frame_size.height;
                          / content_size.height;
    }
-    return window_size;
+    // w and h must fit into 16 bits
    SDL_assert_release(w < 0x10000 && h < 0x10000);
    return (struct size) {w, h};
 }
 // same as get_optimal_size(), but read the current size from the window
 static inline struct size
-get_optimal_window_size(const struct screen *screen, struct size content_size) {
+get_optimal_window_size(const struct screen *screen, struct size frame_size) {
-    struct size window_size = get_window_size(screen);
+    struct size current_size = get_window_size(screen);
-    return get_optimal_size(window_size, content_size);
+    return get_optimal_size(current_size, frame_size);
 }
 // initially, there is no current size, so use the frame size as current size
 // req_width and req_height, if not 0, are the sizes requested by the user
 static inline struct size
-get_initial_optimal_size(struct size content_size, uint16_t req_width,
+get_initial_optimal_size(struct size frame_size) {
-                         uint16_t req_height) {
+    return get_optimal_size(frame_size, frame_size);
    struct size window_size;
    if (!req_width && !req_height) {
        window_size = get_optimal_size(content_size, content_size);
    } else {
        if (req_width) {
            window_size.width = req_width;
        } else {
            // compute from the requested height
            window_size.width = (uint32_t) req_height * content_size.width
                              / content_size.height;
        }
        if (req_height) {
            window_size.height = req_height;
        } else {
            // compute from the requested width
            window_size.height = (uint32_t) req_width * content_size.height
                               / content_size.width;
        }
    }
    return window_size;
 }
 static void
 screen_update_content_rect(struct screen *screen) {
    int dw;
    int dh;
    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
    struct size content_size = screen->content_size;
    // The drawable size is the window size * the HiDPI scale
    struct size drawable_size = {dw, dh};
    SDL_Rect *rect = &screen->rect;
    if (is_optimal_size(drawable_size, content_size)) {
        rect->x = 0;
        rect->y = 0;
        rect->w = drawable_size.width;
        rect->h = drawable_size.height;
        return;
    }
    bool keep_width = content_size.width * drawable_size.height
                    > content_size.height * drawable_size.width;
    if (keep_width) {
        rect->x = 0;
        rect->w = drawable_size.width;
        rect->h = drawable_size.width * content_size.height
                                      / content_size.width;
        rect->y = (drawable_size.height - rect->h) / 2;
    } else {
        rect->y = 0;
        rect->h = drawable_size.height;
        rect->w = drawable_size.height * content_size.width
                                       / content_size.height;
        rect->x = (drawable_size.width - rect->w) / 2;
    }
 }
 void
@@ -200,48 +128,18 @@ screen_init(struct screen *screen) {
 }
 static inline SDL_Texture *
-create_texture(struct screen *screen) {
+create_texture(SDL_Renderer *renderer, struct size frame_size) {
-    SDL_Renderer *renderer = screen->renderer;
+    return SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
-    struct size size = screen->frame_size;
+                             SDL_TEXTUREACCESS_STREAMING,
-    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
+                             frame_size.width, frame_size.height);
                                             SDL_TEXTUREACCESS_STREAMING,
                                             size.width, size.height);
    if (!texture) {
        return NULL;
    }
    if (screen->mipmaps) {
        struct sc_opengl *gl = &screen->gl;
        SDL_GL_BindTexture(texture, NULL, NULL);
        // Enable trilinear filtering for downscaling
        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                          GL_LINEAR_MIPMAP_LINEAR);
        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
        SDL_GL_UnbindTexture(texture);
    }
    return texture;
 }
 bool
 screen_init_rendering(struct screen *screen, const char *window_title,
-                      struct size frame_size, bool always_on_top,
+                      struct size frame_size, bool always_on_top) {
                      int16_t window_x, int16_t window_y, uint16_t window_width,
                      uint16_t window_height, bool window_borderless,
                      uint8_t rotation, bool mipmaps) {
    screen->frame_size = frame_size;
    screen->rotation = rotation;
    if (rotation) {
        LOGI("Initial display rotation set to %u", rotation);
    }
    struct size content_size = get_rotated_size(frame_size, screen->rotation);
    screen->content_size = content_size;
-    struct size window_size =
+    struct size window_size = get_initial_optimal_size(frame_size);
        get_initial_optimal_size(content_size, window_width, window_height);
    uint32_t window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
 #ifdef HIDPI_SUPPORT
    window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
@@ -254,15 +152,9 @@ screen_init_rendering(struct screen *screen, const char *window_title,
             "(compile with SDL >= 2.0.5 to enable it)");
 #endif
    }
    if (window_borderless) {
        window_flags |= SDL_WINDOW_BORDERLESS;
    }
-    int x = window_x != SC_WINDOW_POSITION_UNDEFINED
+    screen->window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_UNDEFINED,
-          ? window_x : (int) SDL_WINDOWPOS_UNDEFINED;
+                                      SDL_WINDOWPOS_UNDEFINED,
    int y = window_y != SC_WINDOW_POSITION_UNDEFINED
          ? window_y : (int) SDL_WINDOWPOS_UNDEFINED;
    screen->window = SDL_CreateWindow(window_title, x, y,
                                      window_size.width, window_size.height,
                                      window_flags);
    if (!screen->window) {
@@ -278,35 +170,11 @@ screen_init_rendering(struct screen *screen, const char *window_title,
        return false;
    }
-    SDL_RendererInfo renderer_info;
+    if (SDL_RenderSetLogicalSize(screen->renderer, frame_size.width,
-    int r = SDL_GetRendererInfo(screen->renderer, &renderer_info);
+                                 frame_size.height)) {
-    const char *renderer_name = r ? NULL : renderer_info.name;
+        LOGE("Could not set renderer logical size: %s", SDL_GetError());
-    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
+        screen_destroy(screen);
-
+        return false;
    // starts with "opengl"
    screen->use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
    if (screen->use_opengl) {
        struct sc_opengl *gl = &screen->gl;
        sc_opengl_init(gl);
        LOGI("OpenGL version: %s", gl->version);
        if (mipmaps) {
            bool supports_mipmaps =
                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
                                               2, 0  /* OpenGL ES 2.0+ */);
            if (supports_mipmaps) {
                LOGI("Trilinear filtering enabled");
                screen->mipmaps = true;
            } else {
                LOGW("Trilinear filtering disabled "
                     "(OpenGL 3.0+ or ES 2.0+ required)");
            }
        } else {
            LOGI("Trilinear filtering disabled");
        }
    } else {
        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
    }
    SDL_Surface *icon = read_xpm(icon_xpm);
@@ -319,20 +187,13 @@ screen_init_rendering(struct screen *screen, const char *window_title,
    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width,
                                                  frame_size.height);
-    screen->texture = create_texture(screen);
+    screen->texture = create_texture(screen->renderer, frame_size);
    if (!screen->texture) {
        LOGC("Could not create texture: %s", SDL_GetError());
        screen_destroy(screen);
        return false;
    }
    // Reset the window size to trigger a SIZE_CHANGED event, to workaround
    // HiDPI issues with some SDL renderers when several displays having
    // different HiDPI scaling are connected
    SDL_SetWindowSize(screen->window, window_size.width, window_size.height);
    screen_update_content_rect(screen);
    return true;
 }
@@ -354,82 +215,35 @@ screen_destroy(struct screen *screen) {
    }
 }
 static void
 resize_for_content(struct screen *screen, struct size old_content_size,
                                                 struct size new_content_size) {
    struct size window_size = get_window_size(screen);
    struct size target_size = {
        .width = (uint32_t) window_size.width * new_content_size.width
                / old_content_size.width,
        .height = (uint32_t) window_size.height * new_content_size.height
                / old_content_size.height,
    };
    target_size = get_optimal_size(target_size, new_content_size);
    set_window_size(screen, target_size);
 }
 static void
 set_content_size(struct screen *screen, struct size new_content_size) {
    if (!screen->fullscreen && !screen->maximized) {
        resize_for_content(screen, screen->content_size, new_content_size);
    } else if (!screen->resize_pending) {
        // Store the windowed size to be able to compute the optimal size once
        // fullscreen and maximized are disabled
        screen->windowed_content_size = screen->content_size;
        screen->resize_pending = true;
    }
    screen->content_size = new_content_size;
 }
 static void
 apply_pending_resize(struct screen *screen) {
    assert(!screen->fullscreen);
    assert(!screen->maximized);
    if (screen->resize_pending) {
        resize_for_content(screen, screen->windowed_content_size,
                                   screen->content_size);
        screen->resize_pending = false;
    }
 }
 void
 screen_set_rotation(struct screen *screen, unsigned rotation) {
    assert(rotation < 4);
    if (rotation == screen->rotation) {
        return;
    }
    struct size new_content_size =
        get_rotated_size(screen->frame_size, rotation);
    set_content_size(screen, new_content_size);
    screen->rotation = rotation;
    LOGI("Display rotation set to %u", rotation);
    screen_render(screen, true);
 }
 // recreate the texture and resize the window if the frame size has changed
 static bool
 prepare_for_frame(struct screen *screen, struct size new_frame_size) {
    if (screen->frame_size.width != new_frame_size.width
            || screen->frame_size.height != new_frame_size.height) {
        if (SDL_RenderSetLogicalSize(screen->renderer, new_frame_size.width,
                                     new_frame_size.height)) {
            LOGE("Could not set renderer logical size: %s", SDL_GetError());
            return false;
        }
        // frame dimension changed, destroy texture
        SDL_DestroyTexture(screen->texture);
        struct size current_size = get_window_size(screen);
        struct size target_size = {
            (uint32_t) current_size.width * new_frame_size.width
                    / screen->frame_size.width,
            (uint32_t) current_size.height * new_frame_size.height
                    / screen->frame_size.height,
        };
        target_size = get_optimal_size(target_size, new_frame_size);
        set_window_size(screen, target_size);
        screen->frame_size = new_frame_size;
        struct size new_content_size =
            get_rotated_size(new_frame_size, screen->rotation);
        set_content_size(screen, new_content_size);
        screen_update_content_rect(screen);
        LOGI("New texture: %" PRIu16 "x%" PRIu16,
                     screen->frame_size.width, screen->frame_size.height);
-        screen->texture = create_texture(screen);
+        screen->texture = create_texture(screen->renderer, new_frame_size);
        if (!screen->texture) {
            LOGC("Could not create texture: %s", SDL_GetError());
            return false;
@@ -446,13 +260,6 @@ update_texture(struct screen *screen, const AVFrame *frame) {
            frame->data[0], frame->linesize[0],
            frame->data[1], frame->linesize[1],
            frame->data[2], frame->linesize[2]);
    if (screen->mipmaps) {
        assert(screen->use_opengl);
        SDL_GL_BindTexture(screen->texture, NULL, NULL);
        screen->gl.GenerateMipmap(GL_TEXTURE_2D);
        SDL_GL_UnbindTexture(screen->texture);
    }
 }
 bool
@@ -467,46 +274,23 @@ screen_update_frame(struct screen *screen, struct video_buffer *vb) {
    update_texture(screen, frame);
    mutex_unlock(vb->mutex);
-    screen_render(screen, false);
+    screen_render(screen);
    return true;
 }
 void
-screen_render(struct screen *screen, bool update_content_rect) {
+screen_render(struct screen *screen) {
    if (update_content_rect) {
        screen_update_content_rect(screen);
    }
    SDL_RenderClear(screen->renderer);
-    if (screen->rotation == 0) {
+    SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
    } else {
        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
        // counterclockwise (to be consistent with --lock-video-orientation)
        int cw_rotation = (4 - screen->rotation) % 4;
        double angle = 90 * cw_rotation;
        SDL_Rect *dstrect = NULL;
        SDL_Rect rect;
        if (screen->rotation & 1) {
            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
            rect.w = screen->rect.h;
            rect.h = screen->rect.w;
            dstrect = &rect;
        } else {
            assert(screen->rotation == 2);
            dstrect = &screen->rect;
        }
        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
                         angle, NULL, 0);
    }
    SDL_RenderPresent(screen->renderer);
 }
 void
 screen_switch_fullscreen(struct screen *screen) {
    if (!screen->fullscreen) {
        // going to fullscreen, store the current windowed window size
        screen->windowed_window_size = get_native_window_size(screen->window);
    }
    uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
    if (SDL_SetWindowFullscreen(screen->window, new_mode)) {
        LOGW("Could not switch fullscreen mode: %s", SDL_GetError());
@@ -514,123 +298,32 @@ screen_switch_fullscreen(struct screen *screen) {
    }
    screen->fullscreen = !screen->fullscreen;
-    if (!screen->fullscreen && !screen->maximized) {
+    if (!screen->fullscreen) {
-        apply_pending_resize(screen);
+        // fullscreen disabled, restore expected windowed window size
        SDL_SetWindowSize(screen->window, screen->windowed_window_size.width,
                          screen->windowed_window_size.height);
    }
    LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
-    screen_render(screen, true);
+    screen_render(screen);
 }
 void
 screen_resize_to_fit(struct screen *screen) {
-    if (screen->fullscreen || screen->maximized) {
+    if (!screen->fullscreen) {
-        return;
+        struct size optimal_size = get_optimal_window_size(screen,
                                                           screen->frame_size);
        SDL_SetWindowSize(screen->window, optimal_size.width,
                          optimal_size.height);
        LOGD("Resized to optimal size");
    }
    struct size optimal_size =
        get_optimal_window_size(screen, screen->content_size);
    SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
    LOGD("Resized to optimal size: %ux%u", optimal_size.width,
                                           optimal_size.height);
 }
 void
 screen_resize_to_pixel_perfect(struct screen *screen) {
-    if (screen->fullscreen) {
+    if (!screen->fullscreen) {
-        return;
+        SDL_SetWindowSize(screen->window, screen->frame_size.width,
-    }
+                          screen->frame_size.height);
-
+        LOGD("Resized to pixel-perfect");
    if (screen->maximized) {
        SDL_RestoreWindow(screen->window);
        screen->maximized = false;
    }
    struct size content_size = screen->content_size;
    SDL_SetWindowSize(screen->window, content_size.width, content_size.height);
    LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
                                            content_size.height);
 }
 void
 screen_handle_window_event(struct screen *screen,
                           const SDL_WindowEvent *event) {
    switch (event->event) {
        case SDL_WINDOWEVENT_EXPOSED:
            screen_render(screen, true);
            break;
        case SDL_WINDOWEVENT_SIZE_CHANGED:
            screen_render(screen, true);
            break;
        case SDL_WINDOWEVENT_MAXIMIZED:
            screen->maximized = true;
            break;
        case SDL_WINDOWEVENT_RESTORED:
            if (screen->fullscreen) {
                // On Windows, in maximized+fullscreen, disabling fullscreen
                // mode unexpectedly triggers the "restored" then "maximized"
                // events, leaving the window in a weird state (maximized
                // according to the events, but not maximized visually).
                break;
            }
            screen->maximized = false;
            apply_pending_resize(screen);
            break;
    }
 }
 struct point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                        int32_t x, int32_t y) {
    unsigned rotation = screen->rotation;
    assert(rotation < 4);
    int32_t w = screen->content_size.width;
    int32_t h = screen->content_size.height;
    x = (int64_t) (x - screen->rect.x) * w / screen->rect.w;
    y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;
    // rotate
    struct point result;
    switch (rotation) {
        case 0:
            result.x = x;
            result.y = y;
            break;
        case 1:
            result.x = h - y;
            result.y = x;
            break;
        case 2:
            result.x = w - x;
            result.y = h - y;
            break;
        default:
            assert(rotation == 3);
            result.x = y;
            result.y = w - x;
            break;
    }
    return result;
 }
 struct point
 screen_convert_window_to_frame_coords(struct screen *screen,
                                      int32_t x, int32_t y) {
    screen_hidpi_scale_coords(screen, &x, &y);
    return screen_convert_drawable_to_frame_coords(screen, x, y);
 }
 void
 screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y) {
    // take the HiDPI scaling (dw/ww and dh/wh) into account
    int ww, wh, dw, dh;
    SDL_GetWindowSize(screen->window, &ww, &wh);
    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
    // scale for HiDPI (64 bits for intermediate multiplications)
    *x = (int64_t) *x * dw / ww;
    *y = (int64_t) *y * dh / wh;
 }
--- a/app/src/screen.h
+++ b/app/src/screen.h
@@ -7,7 +7,6 @@
 #include "config.h"
 #include "common.h"
 #include "opengl.h"
 struct video_buffer;
@@ -15,58 +14,29 @@ struct screen {
    SDL_Window *window;
    SDL_Renderer *renderer;
    SDL_Texture *texture;
    bool use_opengl;
    struct sc_opengl gl;
    struct size frame_size;
-    struct size content_size; // rotated frame_size
+    //used only in fullscreen mode to know the windowed window size
-
+    struct size windowed_window_size;
    bool resize_pending; // resize requested while fullscreen or maximized
    // The content size the last time the window was not maximized or
    // fullscreen (meaningful only when resize_pending is true)
    struct size windowed_content_size;
    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
    unsigned rotation;
    // rectangle of the content (excluding black borders)
    struct SDL_Rect rect;
    bool has_frame;
    bool fullscreen;
    bool maximized;
    bool no_window;
    bool mipmaps;
 };
-#define SCREEN_INITIALIZER { \
+#define SCREEN_INITIALIZER {  \
-    .window = NULL, \
+    .window = NULL,           \
-    .renderer = NULL, \
+    .renderer = NULL,         \
-    .texture = NULL, \
+    .texture = NULL,          \
-    .use_opengl = false, \
+    .frame_size = {           \
-    .gl = {0}, \
+        .width = 0,           \
-    .frame_size = { \
+        .height = 0,          \
-        .width = 0, \
+    },                        \
-        .height = 0, \
+    .windowed_window_size = { \
-    }, \
+        .width = 0,           \
-    .content_size = { \
+        .height = 0,          \
-        .width = 0, \
+    },                        \
-        .height = 0, \
+    .has_frame = false,   \
-    }, \
+    .fullscreen = false,  \
-    .resize_pending = false, \
+    .no_window = false,   \
    .windowed_content_size = { \
        .width = 0, \
        .height = 0, \
    }, \
    .rotation = 0, \
    .rect = { \
        .x = 0, \
        .y = 0, \
        .w = 0, \
        .h = 0, \
    }, \
    .has_frame = false, \
    .fullscreen = false, \
    .maximized = false, \
    .no_window = false, \
    .mipmaps = false, \
 }
 // initialize default values
@@ -74,13 +44,9 @@ void
 screen_init(struct screen *screen);
 // initialize screen, create window, renderer and texture (window is hidden)
 // window_x and window_y accept SC_WINDOW_POSITION_UNDEFINED
 bool
 screen_init_rendering(struct screen *screen, const char *window_title,
-                      struct size frame_size, bool always_on_top,
+                      struct size frame_size, bool always_on_top);
                      int16_t window_x, int16_t window_y, uint16_t window_width,
                      uint16_t window_height, bool window_borderless,
                      uint8_t rotation, bool mipmaps);
 // show the window
 void
@@ -95,11 +61,8 @@ bool
 screen_update_frame(struct screen *screen, struct video_buffer *vb);
 // render the texture to the renderer
 //
 // Set the update_content_rect flag if the window or content size may have
 // changed, so that the content rectangle is recomputed
 void
-screen_render(struct screen *screen, bool update_content_rect);
+screen_render(struct screen *screen);
 // switch the fullscreen mode
 void
@@ -113,31 +76,4 @@ screen_resize_to_fit(struct screen *screen);
 void
 screen_resize_to_pixel_perfect(struct screen *screen);
 // set the display rotation (0, 1, 2 or 3, x90 degrees counterclockwise)
 void
 screen_set_rotation(struct screen *screen, unsigned rotation);
 // react to window events
 void
 screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);
 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels
 struct point
 screen_convert_window_to_frame_coords(struct screen *screen,
                                      int32_t x, int32_t y);
 // convert point from drawable coordinates to frame coordinates
 // x and y are expressed in pixels
 struct point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                        int32_t x, int32_t y);
 // Convert coordinates from window to drawable.
 // Events are expressed in window coordinates, but content is expressed in
 // drawable coordinates. They are the same if HiDPI scaling is 1, but differ
 // otherwise.
 void
 screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y);
 #endif
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -1,61 +1,38 @@
 #include "server.h"
 #include <assert.h>
 #include <errno.h>
 #include <inttypes.h>
 #include <libgen.h>
 #include <stdio.h>
-#include <SDL2/SDL_thread.h>
+#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>
 #include <SDL2/SDL_platform.h>
 #include "config.h"
 #include "command.h"
-#include "util/lock.h"
+#include "log.h"
-#include "util/log.h"
+#include "net.h"
 #include "util/net.h"
 #include "util/str_util.h"
 #define SOCKET_NAME "scrcpy"
-#define SERVER_FILENAME "scrcpy-server"
+#define SERVER_FILENAME "scrcpy-server.jar"
 #define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FILENAME
-#define DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"
+#define DEVICE_SERVER_PATH "/data/local/tmp/" SERVER_FILENAME
-static char *
+static const char *
 get_server_path(void) {
 #ifdef __WINDOWS__
    const wchar_t *server_path_env = _wgetenv(L"SCRCPY_SERVER_PATH");
 #else
    const char *server_path_env = getenv("SCRCPY_SERVER_PATH");
 #endif
    if (server_path_env) {
        LOGD("Using SCRCPY_SERVER_PATH: %s", server_path_env);
        // if the envvar is set, use it
-#ifdef __WINDOWS__
+        return server_path_env;
        char *server_path = utf8_from_wide_char(server_path_env);
 #else
        char *server_path = SDL_strdup(server_path_env);
 #endif
        if (!server_path) {
            LOGE("Could not allocate memory");
            return NULL;
        }
        LOGD("Using SCRCPY_SERVER_PATH: %s", server_path);
        return server_path;
    }
 #ifndef PORTABLE
    LOGD("Using server: " DEFAULT_SERVER_PATH);
    char *server_path = SDL_strdup(DEFAULT_SERVER_PATH);
    if (!server_path) {
        LOGE("Could not allocate memory");
        return NULL;
    }
    // the absolute path is hardcoded
-    return server_path;
+    return DEFAULT_SERVER_PATH;
 #else
-
+    // use scrcpy-server.jar in the same directory as the executable
    // use scrcpy-server in the same directory as the executable
    char *executable_path = get_executable_path();
    if (!executable_path) {
        LOGE("Could not get executable path, "
@@ -90,17 +67,7 @@ get_server_path(void) {
 static bool
 push_server(const char *serial) {
-    char *server_path = get_server_path();
+    process_t process = adb_push(serial, get_server_path(), DEVICE_SERVER_PATH);
    if (!server_path) {
        return false;
    }
    if (!is_regular_file(server_path)) {
        LOGE("'%s' does not exist or is not a regular file\n", server_path);
        SDL_free(server_path);
        return false;
    }
    process_t process = adb_push(serial, server_path, DEVICE_SERVER_PATH);
    SDL_free(server_path);
    return process_check_success(process, "adb push");
 }
@@ -128,6 +95,17 @@ disable_tunnel_forward(const char *serial, uint16_t local_port) {
    return process_check_success(process, "adb forward --remove");
 }
 static bool
 enable_tunnel(struct server *server) {
    if (enable_tunnel_reverse(server->serial, server->local_port)) {
        return true;
    }
    LOGW("'adb reverse' failed, fallback to 'adb forward'");
    server->tunnel_forward = true;
    return enable_tunnel_forward(server->serial, server->local_port);
 }
 static bool
 disable_tunnel(struct server *server) {
    if (server->tunnel_forward) {
@@ -136,181 +114,35 @@ disable_tunnel(struct server *server) {
    return disable_tunnel_reverse(server->serial);
 }
 static socket_t
 listen_on_port(uint16_t port) {
 #define IPV4_LOCALHOST 0x7F000001
    return net_listen(IPV4_LOCALHOST, port, 1);
 }
 static bool
 enable_tunnel_reverse_any_port(struct server *server,
                               struct sc_port_range port_range) {
    uint16_t port = port_range.first;
    for (;;) {
        if (!enable_tunnel_reverse(server->serial, port)) {
            // the command itself failed, it will fail on any port
            return false;
        }
        // At the application level, the device part is "the server" because it
        // serves video stream and control. However, at the network level, the
        // client listens and the server connects to the client. That way, the
        // client can listen before starting the server app, so there is no
        // need to try to connect until the server socket is listening on the
        // device.
        server->server_socket = listen_on_port(port);
        if (server->server_socket != INVALID_SOCKET) {
            // success
            server->local_port = port;
            return true;
        }
        // failure, disable tunnel and try another port
        if (!disable_tunnel_reverse(server->serial)) {
            LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
        }
        // check before incrementing to avoid overflow on port 65535
        if (port < port_range.last) {
            LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
                 port, (uint16_t) (port + 1));
            port++;
            continue;
        }
        if (port_range.first == port_range.last) {
            LOGE("Could not listen on port %" PRIu16, port_range.first);
        } else {
            LOGE("Could not listen on any port in range %" PRIu16 ":%" PRIu16,
                 port_range.first, port_range.last);
        }
        return false;
    }
 }
 static bool
 enable_tunnel_forward_any_port(struct server *server,
                               struct sc_port_range port_range) {
    server->tunnel_forward = true;
    uint16_t port = port_range.first;
    for (;;) {
        if (enable_tunnel_forward(server->serial, port)) {
            // success
            server->local_port = port;
            return true;
        }
        if (port < port_range.last) {
            LOGW("Could not forward port %" PRIu16", retrying on %" PRIu16,
                 port, (uint16_t) (port + 1));
            port++;
            continue;
        }
        if (port_range.first == port_range.last) {
            LOGE("Could not forward port %" PRIu16, port_range.first);
        } else {
            LOGE("Could not forward any port in range %" PRIu16 ":%" PRIu16,
                 port_range.first, port_range.last);
        }
        return false;
    }
 }
 static bool
 enable_tunnel_any_port(struct server *server, struct sc_port_range port_range,
                       bool force_adb_forward) {
    if (!force_adb_forward) {
        // Attempt to use "adb reverse"
        if (enable_tunnel_reverse_any_port(server, port_range)) {
            return true;
        }
        // if "adb reverse" does not work (e.g. over "adb connect"), it
        // fallbacks to "adb forward", so the app socket is the client
        LOGW("'adb reverse' failed, fallback to 'adb forward'");
    }
    return enable_tunnel_forward_any_port(server, port_range);
 }
 static const char *
 log_level_to_server_string(enum sc_log_level level) {
    switch (level) {
        case SC_LOG_LEVEL_DEBUG:
            return "debug";
        case SC_LOG_LEVEL_INFO:
            return "info";
        case SC_LOG_LEVEL_WARN:
            return "warn";
        case SC_LOG_LEVEL_ERROR:
            return "error";
        default:
            assert(!"unexpected log level");
            return "(unknown)";
    }
 }
 static process_t
 execute_server(struct server *server, const struct server_params *params) {
    char max_size_string[6];
    char bit_rate_string[11];
    char max_fps_string[6];
    char lock_video_orientation_string[5];
    char display_id_string[6];
    sprintf(max_size_string, "%"PRIu16, params->max_size);
    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
    sprintf(max_fps_string, "%"PRIu16, params->max_fps);
    sprintf(lock_video_orientation_string, "%"PRIi8, params->lock_video_orientation);
    sprintf(display_id_string, "%"PRIu16, params->display_id);
    const char *const cmd[] = {
        "shell",
-        "CLASSPATH=" DEVICE_SERVER_PATH,
+        "CLASSPATH=/data/local/tmp/" SERVER_FILENAME,
        "app_process",
 #ifdef SERVER_DEBUGGER
 # define SERVER_DEBUGGER_PORT "5005"
 # ifdef SERVER_DEBUGGER_METHOD_NEW
        /* Android 9 and above */
        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,server=y,address="
 # else
        /* Android 8 and below */
        "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
 # endif
            SERVER_DEBUGGER_PORT,
 #endif
        "/", // unused
        "com.genymobile.scrcpy.Server",
        SCRCPY_VERSION,
        log_level_to_server_string(params->log_level),
        max_size_string,
        bit_rate_string,
        max_fps_string,
        lock_video_orientation_string,
        server->tunnel_forward ? "true" : "false",
        params->crop ? params->crop : "-",
        "true", // always send frame meta (packet boundaries + timestamp)
        params->control ? "true" : "false",
        display_id_string,
        params->show_touches ? "true" : "false",
        params->stay_awake ? "true" : "false",
        params->codec_options ? params->codec_options : "-",
        params->encoder_name ? params->encoder_name : "-",
    };
 #ifdef SERVER_DEBUGGER
    LOGI("Server debugger waiting for a client on device port "
         SERVER_DEBUGGER_PORT "...");
    // From the computer, run
    //     adb forward tcp:5005 tcp:5005
    // Then, from Android Studio: Run > Debug > Edit configurations...
    // On the left, click on '+', "Remote", with:
    //     Host: localhost
    //     Port: 5005
    // Then click on "Debug"
 #endif
    return adb_execute(server->serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
 }
 #define IPV4_LOCALHOST 0x7F000001
 static socket_t
 listen_on_port(uint16_t port) {
    return net_listen(IPV4_LOCALHOST, port, 1);
 }
 static socket_t
 connect_and_read_byte(uint16_t port) {
    socket_t socket = net_connect(IPV4_LOCALHOST, port);
@@ -346,75 +178,25 @@ connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
 }
 static void
-close_socket(socket_t socket) {
+close_socket(socket_t *socket) {
-    assert(socket != INVALID_SOCKET);
+    SDL_assert(*socket != INVALID_SOCKET);
-    net_shutdown(socket, SHUT_RDWR);
+    net_shutdown(*socket, SHUT_RDWR);
-    if (!net_close(socket)) {
+    if (!net_close(*socket)) {
        LOGW("Could not close socket");
        return;
    }
    *socket = INVALID_SOCKET;
 }
-bool
+void
 server_init(struct server *server) {
-    server->serial = NULL;
+    *server = (struct server) SERVER_INITIALIZER;
    server->process = PROCESS_NONE;
    server->wait_server_thread = NULL;
    atomic_flag_clear_explicit(&server->server_socket_closed,
                               memory_order_relaxed);
    server->mutex = SDL_CreateMutex();
    if (!server->mutex) {
        return false;
    }
    server->process_terminated_cond = SDL_CreateCond();
    if (!server->process_terminated_cond) {
        SDL_DestroyMutex(server->mutex);
        return false;
    }
    server->process_terminated = false;
    server->server_socket = INVALID_SOCKET;
    server->video_socket = INVALID_SOCKET;
    server->control_socket = INVALID_SOCKET;
    server->port_range.first = 0;
    server->port_range.last = 0;
    server->local_port = 0;
    server->tunnel_enabled = false;
    server->tunnel_forward = false;
    return true;
 }
 static int
 run_wait_server(void *data) {
    struct server *server = data;
    cmd_simple_wait(server->process, NULL); // ignore exit code
    mutex_lock(server->mutex);
    server->process_terminated = true;
    cond_signal(server->process_terminated_cond);
    mutex_unlock(server->mutex);
    // no need for synchronization, server_socket is initialized before this
    // thread was created
    if (server->server_socket != INVALID_SOCKET
            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
        // On Linux, accept() is unblocked by shutdown(), but on Windows, it is
        // unblocked by closesocket(). Therefore, call both (close_socket()).
        close_socket(server->server_socket);
    }
    LOGD("Server terminated");
    return 0;
 }
 bool
 server_start(struct server *server, const char *serial,
             const struct server_params *params) {
-    server->port_range = params->port_range;
+    server->local_port = params->local_port;
    if (serial) {
        server->serial = SDL_strdup(serial);
@@ -424,51 +206,49 @@ server_start(struct server *server, const char *serial,
    }
    if (!push_server(serial)) {
-        goto error1;
+        SDL_free(server->serial);
        return false;
    }
-    if (!enable_tunnel_any_port(server, params->port_range,
+    if (!enable_tunnel(server)) {
-                                params->force_adb_forward)) {
+        SDL_free(server->serial);
-        goto error1;
+        return false;
    }
    // if "adb reverse" does not work (e.g. over "adb connect"), it fallbacks to
    // "adb forward", so the app socket is the client
    if (!server->tunnel_forward) {
        // At the application level, the device part is "the server" because it
        // serves video stream and control. However, at the network level, the
        // client listens and the server connects to the client. That way, the
        // client can listen before starting the server app, so there is no
        // need to try to connect until the server socket is listening on the
        // device.
        server->server_socket = listen_on_port(params->local_port);
        if (server->server_socket == INVALID_SOCKET) {
            LOGE("Could not listen on port %" PRIu16, params->local_port);
            disable_tunnel(server);
            SDL_free(server->serial);
            return false;
        }
    }
    // server will connect to our server socket
    server->process = execute_server(server, params);
    if (server->process == PROCESS_NONE) {
        goto error2;
    }
-    // If the server process dies before connecting to the server socket, then
+    if (server->process == PROCESS_NONE) {
-    // the client will be stuck forever on accept(). To avoid the problem, we
+        if (!server->tunnel_forward) {
-    // must be able to wake up the accept() call when the server dies. To keep
+            close_socket(&server->server_socket);
-    // things simple and multiplatform, just spawn a new thread waiting for the
+        }
-    // server process and calling shutdown()/close() on the server socket if
+        disable_tunnel(server);
-    // necessary to wake up any accept() blocking call.
+        SDL_free(server->serial);
-    server->wait_server_thread =
+        return false;
        SDL_CreateThread(run_wait_server, "wait-server", server);
    if (!server->wait_server_thread) {
        cmd_terminate(server->process);
        cmd_simple_wait(server->process, NULL); // ignore exit code
        goto error2;
    }
    server->tunnel_enabled = true;
    return true;
 error2:
    if (!server->tunnel_forward) {
        bool was_closed =
            atomic_flag_test_and_set(&server->server_socket_closed);
        // the thread is not started, the flag could not be already set
        assert(!was_closed);
        (void) was_closed;
        close_socket(server->server_socket);
    }
    disable_tunnel(server);
 error1:
    SDL_free(server->serial);
    return false;
 }
 bool
@@ -481,16 +261,12 @@ server_connect_to(struct server *server) {
        server->control_socket = net_accept(server->server_socket);
        if (server->control_socket == INVALID_SOCKET) {
-            // the video_socket will be cleaned up on destroy
+            // the video_socket will be clean up on destroy
            return false;
        }
        // we don't need the server socket anymore
-        if (!atomic_flag_test_and_set(&server->server_socket_closed)) {
+        close_socket(&server->server_socket);
            // close it from here
            close_socket(server->server_socket);
            // otherwise, it is closed by run_wait_server()
        }
    } else {
        uint32_t attempts = 100;
        uint32_t delay = 100; // ms
@@ -517,52 +293,32 @@ server_connect_to(struct server *server) {
 void
 server_stop(struct server *server) {
-    if (server->server_socket != INVALID_SOCKET
+    if (server->server_socket != INVALID_SOCKET) {
-            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
+        close_socket(&server->server_socket);
        close_socket(server->server_socket);
    }
    if (server->video_socket != INVALID_SOCKET) {
-        close_socket(server->video_socket);
+        close_socket(&server->video_socket);
    }
    if (server->control_socket != INVALID_SOCKET) {
-        close_socket(server->control_socket);
+        close_socket(&server->control_socket);
    }
-    assert(server->process != PROCESS_NONE);
+    SDL_assert(server->process != PROCESS_NONE);
    if (!cmd_terminate(server->process)) {
        LOGW("Could not terminate server");
    }
    cmd_simple_wait(server->process, NULL); // ignore exit code
    LOGD("Server terminated");
    if (server->tunnel_enabled) {
        // ignore failure
        disable_tunnel(server);
    }
    // Give some delay for the server to terminate properly
    mutex_lock(server->mutex);
    int r = 0;
    if (!server->process_terminated) {
 #define WATCHDOG_DELAY_MS 1000
        r = cond_wait_timeout(server->process_terminated_cond,
                              server->mutex,
                              WATCHDOG_DELAY_MS);
    }
    mutex_unlock(server->mutex);
    // After this delay, kill the server if it's not dead already.
    // On some devices, closing the sockets is not sufficient to wake up the
    // blocking calls while the device is asleep.
    if (r == SDL_MUTEX_TIMEDOUT) {
        // FIXME There is a race condition here: there is a small chance that
        // the process is already terminated, and the PID assigned to a new
        // process.
        LOGW("Killing the server...");
        cmd_terminate(server->process);
    }
    SDL_WaitThread(server->wait_server_thread, NULL);
 }
 void
 server_destroy(struct server *server) {
    SDL_free(server->serial);
    SDL_DestroyCond(server->process_terminated_cond);
    SDL_DestroyMutex(server->mutex);
 }
--- a/app/src/server.h
+++ b/app/src/server.h
@@ -1,56 +1,45 @@
 #ifndef SERVER_H
 #define SERVER_H
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <SDL2/SDL_thread.h>
 #include "config.h"
 #include "command.h"
-#include "common.h"
+#include "net.h"
 #include "scrcpy.h"
 #include "util/log.h"
 #include "util/net.h"
 struct server {
    char *serial;
    process_t process;
    SDL_Thread *wait_server_thread;
    atomic_flag server_socket_closed;
    SDL_mutex *mutex;
    SDL_cond *process_terminated_cond;
    bool process_terminated;
    socket_t server_socket; // only used if !tunnel_forward
    socket_t video_socket;
    socket_t control_socket;
-    struct sc_port_range port_range;
+    uint16_t local_port;
    uint16_t local_port; // selected from port_range
    bool tunnel_enabled;
    bool tunnel_forward; // use "adb forward" instead of "adb reverse"
 };
 #define SERVER_INITIALIZER {          \
    .serial = NULL,                   \
    .process = PROCESS_NONE,          \
    .server_socket = INVALID_SOCKET,  \
    .video_socket = INVALID_SOCKET,   \
    .control_socket = INVALID_SOCKET, \
    .local_port = 0,                  \
    .tunnel_enabled = false,          \
    .tunnel_forward = false,          \
 }
 struct server_params {
    enum sc_log_level log_level;
    const char *crop;
-    const char *codec_options;
+    uint16_t local_port;
    const char *encoder_name;
    struct sc_port_range port_range;
    uint16_t max_size;
    uint32_t bit_rate;
    uint16_t max_fps;
    int8_t lock_video_orientation;
    bool control;
    uint16_t display_id;
    bool show_touches;
    bool stay_awake;
    bool force_adb_forward;
 };
 // init default values
-bool
+void
 server_init(struct server *server);
 // push, enable tunnel et start the server
--- a/app/src/util/str_util.c
+++ b/app/src/util/str_util.c
@@ -1,7 +1,5 @@
 #include "str_util.h"
 #include <errno.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
@@ -62,88 +60,6 @@ strquote(const char *src) {
    return quoted;
 }
 bool
 parse_integer(const char *s, long *out) {
    char *endptr;
    if (*s == '\0') {
        return false;
    }
    errno = 0;
    long value = strtol(s, &endptr, 0);
    if (errno == ERANGE) {
        return false;
    }
    if (*endptr != '\0') {
        return false;
    }
    *out = value;
    return true;
 }
 size_t
 parse_integers(const char *s, const char sep, size_t max_items, long *out) {
    size_t count = 0;
    char *endptr;
    do {
        errno = 0;
        long value = strtol(s, &endptr, 0);
        if (errno == ERANGE) {
            return 0;
        }
        if (endptr == s || (*endptr != sep && *endptr != '\0')) {
            return 0;
        }
        out[count++] = value;
        if (*endptr == sep) {
            if (count >= max_items) {
                // max items already reached, could not accept a new item
                return 0;
            }
            // parse the next token during the next iteration
            s = endptr + 1;
        }
    } while (*endptr != '\0');
    return count;
 }
 bool
 parse_integer_with_suffix(const char *s, long *out) {
    char *endptr;
    if (*s == '\0') {
        return false;
    }
    errno = 0;
    long value = strtol(s, &endptr, 0);
    if (errno == ERANGE) {
        return false;
    }
    int mul = 1;
    if (*endptr != '\0') {
        if (s == endptr) {
            return false;
        }
        if ((*endptr == 'M' || *endptr == 'm') && endptr[1] == '\0') {
            mul = 1000000;
        } else if ((*endptr == 'K' || *endptr == 'k') && endptr[1] == '\0') {
            mul = 1000;
        } else {
            return false;
        }
    }
    if ((value < 0 && LONG_MIN / mul > value) ||
        (value > 0 && LONG_MAX / mul < value)) {
        return false;
    }
    *out = value * mul;
    return true;
 }
 size_t
 utf8_truncation_index(const char *utf8, size_t max_len) {
    size_t len = strlen(utf8);
--- a/app/src/util/str_util.h
+++ b/app/src/util/str_util.h
@@ -1,7 +1,6 @@
 #ifndef STRUTIL_H
 #define STRUTIL_H
 #include <stdbool.h>
 #include <stddef.h>
 #include "config.h"
@@ -16,7 +15,7 @@ size_t
 xstrncpy(char *dest, const char *src, size_t n);
 // join tokens by sep into dst
-// returns the number of chars actually written (max n-1) if no truncation
+// returns the number of chars actually written (max n-1) if no trucation
 // occurred, or n if truncated
 size_t
 xstrjoin(char *dst, const char *const tokens[], char sep, size_t n);
@@ -26,23 +25,6 @@ xstrjoin(char *dst, const char *const tokens[], char sep, size_t n);
 char *
 strquote(const char *src);
 // parse s as an integer into value
 // returns true if the conversion succeeded, false otherwise
 bool
 parse_integer(const char *s, long *out);
 // parse s as integers separated by sep (for example '1234:2000')
 // returns the number of integers on success, 0 on failure
 size_t
 parse_integers(const char *s, const char sep, size_t max_items, long *out);
 // parse s as an integer into value
 // like parse_integer(), but accept 'k'/'K' (x1000) and 'm'/'M' (x1000000) as
 // suffix
 // returns true if the conversion succeeded, false otherwise
 bool
 parse_integer_with_suffix(const char *s, long *out);
 // return the index to truncate a UTF-8 string at a valid position
 size_t
 utf8_truncation_index(const char *utf8, size_t max_len);
--- a/app/src/stream.c
+++ b/app/src/stream.c
@@ -1,8 +1,8 @@
 #include "stream.h"
 #include <assert.h>
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
 #include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
@@ -10,11 +10,12 @@
 #include "config.h"
 #include "compat.h"
 #include "buffer_util.h"
 #include "decoder.h"
 #include "events.h"
 #include "lock_util.h"
 #include "log.h"
 #include "recorder.h"
 #include "util/buffer_util.h"
 #include "util/log.h"
 #define BUFSIZE 0x10000
@@ -43,8 +44,7 @@ stream_recv_packet(struct stream *stream, AVPacket *packet) {
    uint64_t pts = buffer_read64be(header);
    uint32_t len = buffer_read32be(&header[8]);
-    assert(pts == NO_PTS || (pts & 0x8000000000000000) == 0);
+    SDL_assert(len);
    assert(len);
    if (av_new_packet(packet, len)) {
        LOGE("Could not allocate packet");
@@ -52,12 +52,12 @@ stream_recv_packet(struct stream *stream, AVPacket *packet) {
    }
    r = net_recv_all(stream->socket, packet->data, len);
-    if (r < 0 || ((uint32_t) r) < len) {
+    if (r < len) {
        av_packet_unref(packet);
        return false;
    }
-    packet->pts = pts != NO_PTS ? (int64_t) pts : AV_NOPTS_VALUE;
+    packet->pts = pts != NO_PTS ? pts : AV_NOPTS_VALUE;
    return true;
 }
@@ -107,9 +107,8 @@ stream_parse(struct stream *stream, AVPacket *packet) {
                             AV_NOPTS_VALUE, AV_NOPTS_VALUE, -1);
    // PARSER_FLAG_COMPLETE_FRAMES is set
-    assert(r == in_len);
+    SDL_assert(r == in_len);
-    (void) r;
+    SDL_assert(out_len == in_len);
    assert(out_len == in_len);
    if (stream->parser->key_frame == 1) {
        packet->flags |= AV_PKT_FLAG_KEY;
--- a/app/src/stream.h
+++ b/app/src/stream.h
@@ -8,12 +8,13 @@
 #include <SDL2/SDL_thread.h>
 #include "config.h"
-#include "util/net.h"
+#include "net.h"
 struct video_buffer;
 struct stream {
    socket_t socket;
    struct video_buffer *video_buffer;
    SDL_Thread *thread;
    struct decoder *decoder;
    struct recorder *recorder;
--- a/app/src/sys/unix/command.c
+++ b/app/src/sys/unix/command.c
@@ -1,14 +1,10 @@
-// for portability (kill, readlink, strdup, strtok_r)
+// for portability
-#define _POSIX_C_SOURCE 200809L
+#define _POSIX_SOURCE // for kill()
-#define _BSD_SOURCE
+#define _BSD_SOURCE // for readlink()
 // modern glibc will complain without this
 #define _DEFAULT_SOURCE
 #ifdef __APPLE__
 # define _DARWIN_C_SOURCE // for strdup(), strtok_r(), memset_pattern4()
 #endif
 #include "command.h"
 #include "config.h"
@@ -18,52 +14,13 @@
 #include <limits.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
-
+#include "log.h"
 #include "util/log.h"
 bool
 cmd_search(const char *file) {
    char *path = getenv("PATH");
    if (!path)
        return false;
    path = strdup(path);
    if (!path)
        return false;
    bool ret = false;
    size_t file_len = strlen(file);
    char *saveptr;
    for (char *dir = strtok_r(path, ":", &saveptr); dir;
            dir = strtok_r(NULL, ":", &saveptr)) {
        size_t dir_len = strlen(dir);
        char *fullpath = malloc(dir_len + file_len + 2);
        if (!fullpath)
            continue;
        memcpy(fullpath, dir, dir_len);
        fullpath[dir_len] = '/';
        memcpy(fullpath + dir_len + 1, file, file_len + 1);
        struct stat sb;
        bool fullpath_executable = stat(fullpath, &sb) == 0 &&
            sb.st_mode & S_IXUSR;
        free(fullpath);
        if (fullpath_executable) {
            ret = true;
            break;
        }
    }
    free(path);
    return ret;
 }
 enum process_result
-cmd_execute(const char *const argv[], pid_t *pid) {
+cmd_execute(const char *path, const char *const argv[], pid_t *pid) {
    int fd[2];
    if (pipe(fd) == -1) {
@@ -94,7 +51,7 @@ cmd_execute(const char *const argv[], pid_t *pid) {
        // child close read side
        close(fd[0]);
        if (fcntl(fd[1], F_SETFD, FD_CLOEXEC) == 0) {
-            execvp(argv[0], (char *const *)argv);
+            execvp(path, (char *const *)argv);
            if (errno == ENOENT) {
                ret = PROCESS_ERROR_MISSING_BINARY;
            } else {
@@ -169,14 +126,3 @@ get_executable_path(void) {
    return NULL;
 #endif
 }
 bool
 is_regular_file(const char *path) {
    struct stat path_stat;
    if (stat(path, &path_stat)) {
        perror("stat");
        return false;
    }
    return S_ISREG(path_stat.st_mode);
 }
--- a/app/src/sys/unix/net.c
+++ b/app/src/sys/unix/net.c
@@ -0,0 +1,21 @@
 #include "net.h"
 #include <unistd.h>
 #include "config.h"
 bool
 net_init(void) {
    // do nothing
    return true;
 }
 void
 net_cleanup(void) {
    // do nothing
 }
 bool
 net_close(socket_t socket) {
    return !close(socket);
 }
--- a/app/src/sys/win/command.c
+++ b/app/src/sys/win/command.c
@@ -1,10 +1,8 @@
 #include "command.h"
 #include <sys/stat.h>
 #include "config.h"
-#include "util/log.h"
+#include "log.h"
-#include "util/str_util.h"
+#include "str_util.h"
 static int
 build_cmd(char *cmd, size_t len, const char *const argv[]) {
@@ -21,7 +19,7 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
 }
 enum process_result
-cmd_execute(const char *const argv[], HANDLE *handle) {
+cmd_execute(const char *path, const char *const argv[], HANDLE *handle) {
    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
    memset(&si, 0, sizeof(si));
@@ -39,7 +37,12 @@ cmd_execute(const char *const argv[], HANDLE *handle) {
        return PROCESS_ERROR_GENERIC;
    }
-    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, 0, NULL, NULL, &si,
+#ifdef WINDOWS_NOCONSOLE
    int flags = CREATE_NO_WINDOW;
 #else
    int flags = 0;
 #endif
    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, flags, NULL, NULL, &si,
                        &pi)) {
        SDL_free(wide);
        *handle = NULL;
@@ -56,7 +59,7 @@ cmd_execute(const char *const argv[], HANDLE *handle) {
 bool
 cmd_terminate(HANDLE handle) {
-    return TerminateProcess(handle, 1);
+    return TerminateProcess(handle, 1) && CloseHandle(handle);
 }
 bool
@@ -70,7 +73,6 @@ cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
    if (exit_code) {
        *exit_code = code;
    }
    CloseHandle(handle);
    return !code;
 }
@@ -88,22 +90,3 @@ get_executable_path(void) {
    buf[len] = '\0';
    return utf8_from_wide_char(buf);
 }
 bool
 is_regular_file(const char *path) {
    wchar_t *wide_path = utf8_to_wide_char(path);
    if (!wide_path) {
        LOGC("Could not allocate wide char string");
        return false;
    }
    struct _stat path_stat;
    int r = _wstat(wide_path, &path_stat);
    SDL_free(wide_path);
    if (r) {
        perror("stat");
        return false;
    }
    return S_ISREG(path_stat.st_mode);
 }
--- a/app/src/sys/win/net.c
+++ b/app/src/sys/win/net.c
@@ -0,0 +1,25 @@
 #include "net.h"
 #include "config.h"
 #include "log.h"
 bool
 net_init(void) {
    WSADATA wsa;
    int res = WSAStartup(MAKEWORD(2, 2), &wsa) < 0;
    if (res < 0) {
        LOGC("WSAStartup failed with error %d", res);
        return false;
    }
    return true;
 }
 void
 net_cleanup(void) {
    WSACleanup();
 }
 bool
 net_close(socket_t socket) {
    return !closesocket(socket);
 }
--- a/app/src/tiny_xpm.c
+++ b/app/src/tiny_xpm.c
@@ -1,13 +1,12 @@
 #include "tiny_xpm.h"
 #include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "config.h"
-#include "util/log.h"
+#include "log.h"
 struct index {
    char c;
@@ -37,7 +36,7 @@ find_color(struct index *index, int len, char c, uint32_t *color) {
 // (non-const) "char *"
 SDL_Surface *
 read_xpm(char *xpm[]) {
-#ifndef NDEBUG
+#if SDL_ASSERT_LEVEL >= 2
    // patch the XPM to change the icon color in debug mode
    xpm[2] = ".	c #CC00CC";
 #endif
@@ -52,26 +51,24 @@ read_xpm(char *xpm[]) {
    int chars = strtol(endptr + 1, &endptr, 10);
    // sanity checks
-    assert(0 <= width && width < 256);
+    SDL_assert(0 <= width && width < 256);
-    assert(0 <= height && height < 256);
+    SDL_assert(0 <= height && height < 256);
-    assert(0 <= colors && colors < 256);
+    SDL_assert(0 <= colors && colors < 256);
-    assert(chars == 1); // this implementation does not support more
+    SDL_assert(chars == 1); // this implementation does not support more
    (void) chars;
    // init index
    struct index index[colors];
    for (int i = 0; i < colors; ++i) {
        const char *line = xpm[1+i];
        index[i].c = line[0];
-        assert(line[1] == '\t');
+        SDL_assert(line[1] == '\t');
-        assert(line[2] == 'c');
+        SDL_assert(line[2] == 'c');
-        assert(line[3] == ' ');
+        SDL_assert(line[3] == ' ');
        if (line[4] == '#') {
            index[i].color = 0xff000000 | strtol(&line[5], &endptr, 0x10);
-            assert(*endptr == '\0');
+            SDL_assert(*endptr == '\0');
        } else {
-            assert(!strcmp("None", &line[4]));
+            SDL_assert(!strcmp("None", &line[4]));
            index[i].color = 0;
        }
    }
@@ -88,8 +85,7 @@ read_xpm(char *xpm[]) {
            char c = line[x];
            uint32_t color;
            bool color_found = find_color(index, colors, c, &color);
-            assert(color_found);
+            SDL_assert(color_found);
            (void) color_found;
            pixels[y * width + x] = color;
        }
    }
--- a/app/src/util/lock.h
+++ b/app/src/util/lock.h
@@ -1,74 +0,0 @@
 #ifndef LOCK_H
 #define LOCK_H
 #include <stdint.h>
 #include <SDL2/SDL_mutex.h>
 #include "config.h"
 #include "log.h"
 static inline void
 mutex_lock(SDL_mutex *mutex) {
    int r = SDL_LockMutex(mutex);
 #ifndef NDEBUG
    if (r) {
        LOGC("Could not lock mutex: %s", SDL_GetError());
        abort();
    }
 #else
    (void) r;
 #endif
 }
 static inline void
 mutex_unlock(SDL_mutex *mutex) {
    int r = SDL_UnlockMutex(mutex);
 #ifndef NDEBUG
    if (r) {
        LOGC("Could not unlock mutex: %s", SDL_GetError());
        abort();
    }
 #else
    (void) r;
 #endif
 }
 static inline void
 cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
    int r = SDL_CondWait(cond, mutex);
 #ifndef NDEBUG
    if (r) {
        LOGC("Could not wait on condition: %s", SDL_GetError());
        abort();
    }
 #else
    (void) r;
 #endif
 }
 static inline int
 cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
    int r = SDL_CondWaitTimeout(cond, mutex, ms);
 #ifndef NDEBUG
    if (r < 0) {
        LOGC("Could not wait on condition with timeout: %s", SDL_GetError());
        abort();
    }
 #endif
    return r;
 }
 static inline void
 cond_signal(SDL_cond *cond) {
    int r = SDL_CondSignal(cond);
 #ifndef NDEBUG
    if (r) {
        LOGC("Could not signal a condition: %s", SDL_GetError());
        abort();
    }
 #else
    (void) r;
 #endif
 }
 #endif
--- a/app/src/video_buffer.c
+++ b/app/src/video_buffer.c
@@ -1,13 +1,13 @@
 #include "video_buffer.h"
-#include <assert.h>
+#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_mutex.h>
 #include <libavutil/avutil.h>
 #include <libavformat/avformat.h>
 #include "config.h"
-#include "util/lock.h"
+#include "lock_util.h"
-#include "util/log.h"
+#include "log.h"
 bool
 video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
@@ -91,7 +91,7 @@ video_buffer_offer_decoded_frame(struct video_buffer *vb,
 const AVFrame *
 video_buffer_consume_rendered_frame(struct video_buffer *vb) {
-    assert(!vb->rendering_frame_consumed);
+    SDL_assert(!vb->rendering_frame_consumed);
    vb->rendering_frame_consumed = true;
    fps_counter_add_rendered_frame(vb->fps_counter);
    if (vb->render_expired_frames) {
--- a/app/tests/test_buffer_util.c
+++ b/app/tests/test_buffer_util.c
@@ -1,79 +0,0 @@
 #include <assert.h>
 #include "util/buffer_util.h"
 static void test_buffer_write16be(void) {
    uint16_t val = 0xABCD;
    uint8_t buf[2];
    buffer_write16be(buf, val);
    assert(buf[0] == 0xAB);
    assert(buf[1] == 0xCD);
 }
 static void test_buffer_write32be(void) {
    uint32_t val = 0xABCD1234;
    uint8_t buf[4];
    buffer_write32be(buf, val);
    assert(buf[0] == 0xAB);
    assert(buf[1] == 0xCD);
    assert(buf[2] == 0x12);
    assert(buf[3] == 0x34);
 }
 static void test_buffer_write64be(void) {
    uint64_t val = 0xABCD1234567890EF;
    uint8_t buf[8];
    buffer_write64be(buf, val);
    assert(buf[0] == 0xAB);
    assert(buf[1] == 0xCD);
    assert(buf[2] == 0x12);
    assert(buf[3] == 0x34);
    assert(buf[4] == 0x56);
    assert(buf[5] == 0x78);
    assert(buf[6] == 0x90);
    assert(buf[7] == 0xEF);
 }
 static void test_buffer_read16be(void) {
    uint8_t buf[2] = {0xAB, 0xCD};
    uint16_t val = buffer_read16be(buf);
    assert(val == 0xABCD);
 }
 static void test_buffer_read32be(void) {
    uint8_t buf[4] = {0xAB, 0xCD, 0x12, 0x34};
    uint32_t val = buffer_read32be(buf);
    assert(val == 0xABCD1234);
 }
 static void test_buffer_read64be(void) {
    uint8_t buf[8] = {0xAB, 0xCD, 0x12, 0x34,
                      0x56, 0x78, 0x90, 0xEF};
    uint64_t val = buffer_read64be(buf);
    assert(val == 0xABCD1234567890EF);
 }
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;
    test_buffer_write16be();
    test_buffer_write32be();
    test_buffer_write64be();
    test_buffer_read16be();
    test_buffer_read32be();
    test_buffer_read64be();
    return 0;
 }
--- a/app/tests/test_cbuf.c
+++ b/app/tests/test_cbuf.c
@@ -1,7 +1,7 @@
 #include <assert.h>
 #include <string.h>
-#include "util/cbuf.h"
+#include "cbuf.h"
 struct int_queue CBUF(int, 32);
@@ -65,10 +65,7 @@ static void test_cbuf_push_take(void) {
    assert(item == 35);
 }
-int main(int argc, char *argv[]) {
+int main(void) {
    (void) argc;
    (void) argv;
    test_cbuf_empty();
    test_cbuf_full();
    test_cbuf_push_take();
--- a/app/tests/test_cli.c
+++ b/app/tests/test_cli.c
@@ -1,173 +0,0 @@
 #include <assert.h>
 #include <string.h>
 #include "cli.h"
 #include "common.h"
 #include "scrcpy.h"
 static void test_flag_version(void) {
    struct scrcpy_cli_args args = {
        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
    char *argv[] = {"scrcpy", "-v"};
    bool ok = scrcpy_parse_args(&args, 2, argv);
    assert(ok);
    assert(!args.help);
    assert(args.version);
 }
 static void test_flag_help(void) {
    struct scrcpy_cli_args args = {
        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
    char *argv[] = {"scrcpy", "-v"};
    bool ok = scrcpy_parse_args(&args, 2, argv);
    assert(ok);
    assert(!args.help);
    assert(args.version);
 }
 static void test_options(void) {
    struct scrcpy_cli_args args = {
        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
    char *argv[] = {
        "scrcpy",
        "--always-on-top",
        "--bit-rate", "5M",
        "--crop", "100:200:300:400",
        "--fullscreen",
        "--max-fps", "30",
        "--max-size", "1024",
        "--lock-video-orientation", "2",
        // "--no-control" is not compatible with "--turn-screen-off"
        // "--no-display" is not compatible with "--fulscreen"
        "--port", "1234:1236",
        "--push-target", "/sdcard/Movies",
        "--record", "file",
        "--record-format", "mkv",
        "--render-expired-frames",
        "--serial", "0123456789abcdef",
        "--show-touches",
        "--turn-screen-off",
        "--prefer-text",
        "--window-title", "my device",
        "--window-x", "100",
        "--window-y", "-1",
        "--window-width", "600",
        "--window-height", "0",
        "--window-borderless",
    };
    bool ok = scrcpy_parse_args(&args, ARRAY_LEN(argv), argv);
    assert(ok);
    const struct scrcpy_options *opts = &args.opts;
    assert(opts->always_on_top);
    assert(opts->bit_rate == 5000000);
    assert(!strcmp(opts->crop, "100:200:300:400"));
    assert(opts->fullscreen);
    assert(opts->max_fps == 30);
    assert(opts->max_size == 1024);
    assert(opts->lock_video_orientation == 2);
    assert(opts->port_range.first == 1234);
    assert(opts->port_range.last == 1236);
    assert(!strcmp(opts->push_target, "/sdcard/Movies"));
    assert(!strcmp(opts->record_filename, "file"));
    assert(opts->record_format == SC_RECORD_FORMAT_MKV);
    assert(opts->render_expired_frames);
    assert(!strcmp(opts->serial, "0123456789abcdef"));
    assert(opts->show_touches);
    assert(opts->turn_screen_off);
    assert(opts->prefer_text);
    assert(!strcmp(opts->window_title, "my device"));
    assert(opts->window_x == 100);
    assert(opts->window_y == -1);
    assert(opts->window_width == 600);
    assert(opts->window_height == 0);
    assert(opts->window_borderless);
 }
 static void test_options2(void) {
    struct scrcpy_cli_args args = {
        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
    char *argv[] = {
        "scrcpy",
        "--no-control",
        "--no-display",
        "--record", "file.mp4", // cannot enable --no-display without recording
    };
    bool ok = scrcpy_parse_args(&args, ARRAY_LEN(argv), argv);
    assert(ok);
    const struct scrcpy_options *opts = &args.opts;
    assert(!opts->control);
    assert(!opts->display);
    assert(!strcmp(opts->record_filename, "file.mp4"));
    assert(opts->record_format == SC_RECORD_FORMAT_MP4);
 }
 static void test_parse_shortcut_mods(void) {
    struct sc_shortcut_mods mods;
    bool ok;
    ok = sc_parse_shortcut_mods("lctrl", &mods);
    assert(ok);
    assert(mods.count == 1);
    assert(mods.data[0] == SC_MOD_LCTRL);
    ok = sc_parse_shortcut_mods("lctrl+lalt", &mods);
    assert(ok);
    assert(mods.count == 1);
    assert(mods.data[0] == (SC_MOD_LCTRL | SC_MOD_LALT));
    ok = sc_parse_shortcut_mods("rctrl,lalt", &mods);
    assert(ok);
    assert(mods.count == 2);
    assert(mods.data[0] == SC_MOD_RCTRL);
    assert(mods.data[1] == SC_MOD_LALT);
    ok = sc_parse_shortcut_mods("lsuper,rsuper+lalt,lctrl+rctrl+ralt", &mods);
    assert(ok);
    assert(mods.count == 3);
    assert(mods.data[0] == SC_MOD_LSUPER);
    assert(mods.data[1] == (SC_MOD_RSUPER | SC_MOD_LALT));
    assert(mods.data[2] == (SC_MOD_LCTRL | SC_MOD_RCTRL | SC_MOD_RALT));
    ok = sc_parse_shortcut_mods("", &mods);
    assert(!ok);
    ok = sc_parse_shortcut_mods("lctrl+", &mods);
    assert(!ok);
    ok = sc_parse_shortcut_mods("lctrl,", &mods);
    assert(!ok);
 }
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;
    test_flag_version();
    test_flag_help();
    test_options();
    test_options2();
    test_parse_shortcut_mods();
    return 0;
 };
--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@@ -9,20 +9,18 @@ static void test_serialize_inject_keycode(void) {
        .inject_keycode = {
            .action = AKEY_EVENT_ACTION_UP,
            .keycode = AKEYCODE_ENTER,
            .repeat = 5,
            .metastate = AMETA_SHIFT_ON | AMETA_SHIFT_LEFT_ON,
        },
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 14);
+    assert(size == 10);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_INJECT_KEYCODE,
        0x01, // AKEY_EVENT_ACTION_UP
        0x00, 0x00, 0x00, 0x42, // AKEYCODE_ENTER
        0x00, 0x00, 0x00, 0X05, // repeat
        0x00, 0x00, 0x00, 0x41, // AMETA_SHIFT_ON | AMETA_SHIFT_LEFT_ON
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@@ -36,13 +34,13 @@ static void test_serialize_inject_text(void) {
        },
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 18);
+    assert(size == 16);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_INJECT_TEXT,
-        0x00, 0x00, 0x00, 0x0d, // text length
+        0x00, 0x0d, // text length
        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@@ -51,32 +49,63 @@ static void test_serialize_inject_text(void) {
 static void test_serialize_inject_text_long(void) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    char text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1];
+    char text[CONTROL_MSG_TEXT_MAX_LENGTH + 1];
    memset(text, 'a', sizeof(text));
-    text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
+    text[CONTROL_MSG_TEXT_MAX_LENGTH] = '\0';
    msg.inject_text.text = text;
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    assert(size == 3 + CONTROL_MSG_TEXT_MAX_LENGTH);
-    unsigned char expected[5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
+    unsigned char expected[3 + CONTROL_MSG_TEXT_MAX_LENGTH];
    expected[0] = CONTROL_MSG_TYPE_INJECT_TEXT;
-    expected[1] = 0x00;
+    expected[1] = 0x01;
-    expected[2] = 0x00;
+    expected[2] = 0x2c; // text length (16 bits)
-    expected[3] = 0x01;
+    memset(&expected[3], 'a', CONTROL_MSG_TEXT_MAX_LENGTH);
    expected[4] = 0x2c; // text length (32 bits)
    memset(&expected[5], 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
 static void test_serialize_inject_mouse_event(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT,
        .inject_mouse_event = {
            .action = AMOTION_EVENT_ACTION_DOWN,
            .buttons = AMOTION_EVENT_BUTTON_PRIMARY,
            .position = {
                .point = {
                    .x = 260,
                    .y = 1026,
                },
                .screen_size = {
                    .width = 1080,
                    .height = 1920,
                },
            },
        },
    };
    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 18);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT,
        0x00, // AKEY_EVENT_ACTION_DOWN
        0x00, 0x00, 0x00, 0x01, // AMOTION_EVENT_BUTTON_PRIMARY
        0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x02, // 260 1026
        0x04, 0x38, 0x07, 0x80, // 1080 1920
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
 #include <stdio.h>
 static void test_serialize_inject_touch_event(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
        .inject_touch_event = {
            .action = AMOTION_EVENT_ACTION_DOWN,
-            .pointer_id = 0x1234567887654321L,
+            .finger_id = 0x1234567887654321L,
            .position = {
                .point = {
                    .x = 100,
@@ -88,22 +117,20 @@ static void test_serialize_inject_touch_event(void) {
                },
            },
            .pressure = 1.0f,
            .buttons = AMOTION_EVENT_BUTTON_PRIMARY,
        },
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 28);
+    assert(size == 24);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
        0x00, // AKEY_EVENT_ACTION_DOWN
-        0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21, // pointer id
+        0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21, // finger id
        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
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
@@ -127,7 +154,7 @@ static void test_serialize_inject_scroll_event(void) {
        },
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 21);
@@ -146,7 +173,7 @@ static void test_serialize_back_or_screen_on(void) {
        .type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);
@@ -161,7 +188,7 @@ static void test_serialize_expand_notification_panel(void) {
        .type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);
@@ -176,7 +203,7 @@ static void test_serialize_collapse_notification_panel(void) {
        .type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);
@@ -191,7 +218,7 @@ static void test_serialize_get_clipboard(void) {
        .type = CONTROL_MSG_TYPE_GET_CLIPBOARD,
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);
@@ -204,20 +231,18 @@ static void test_serialize_get_clipboard(void) {
 static void test_serialize_set_clipboard(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_SET_CLIPBOARD,
-        .set_clipboard = {
+        .inject_text = {
            .paste = true,
            .text = "hello, world!",
        },
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 19);
+    assert(size == 16);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_SET_CLIPBOARD,
-        1, // paste
+        0x00, 0x0d, // text length
        0x00, 0x00, 0x00, 0x0d, // text length
        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@@ -231,7 +256,7 @@ static void test_serialize_set_screen_power_mode(void) {
        },
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 2);
@@ -242,28 +267,11 @@ static void test_serialize_set_screen_power_mode(void) {
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
-static void test_serialize_rotate_device(void) {
+int main(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_ROTATE_DEVICE,
    };
    unsigned char buf[CONTROL_MSG_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_ROTATE_DEVICE,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;
    test_serialize_inject_keycode();
    test_serialize_inject_text();
    test_serialize_inject_text_long();
    test_serialize_inject_mouse_event();
    test_serialize_inject_touch_event();
    test_serialize_inject_scroll_event();
    test_serialize_back_or_screen_on();
@@ -272,6 +280,5 @@ int main(int argc, char *argv[]) {
    test_serialize_get_clipboard();
    test_serialize_set_clipboard();
    test_serialize_set_screen_power_mode();
    test_serialize_rotate_device();
    return 0;
 }
--- a/app/tests/test_device_msg_deserialize.c
+++ b/app/tests/test_device_msg_deserialize.c
@@ -4,17 +4,16 @@
 #include "device_msg.h"
 #include <stdio.h>
 static void test_deserialize_clipboard(void) {
    const unsigned char input[] = {
        DEVICE_MSG_TYPE_CLIPBOARD,
-        0x00, 0x00, 0x00, 0x03, // text length
+        0x00, 0x03, // text length
        0x41, 0x42, 0x43, // "ABC"
    };
    struct device_msg msg;
    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
-    assert(r == 8);
+    assert(r == 6);
    assert(msg.type == DEVICE_MSG_TYPE_CLIPBOARD);
    assert(msg.clipboard.text);
@@ -23,33 +22,7 @@ static void test_deserialize_clipboard(void) {
    device_msg_destroy(&msg);
 }
-static void test_deserialize_clipboard_big(void) {
+int main(void) {
    unsigned char input[DEVICE_MSG_MAX_SIZE];
    input[0] = DEVICE_MSG_TYPE_CLIPBOARD;
    input[1] = (DEVICE_MSG_TEXT_MAX_LENGTH & 0xff000000u) >> 24;
    input[2] = (DEVICE_MSG_TEXT_MAX_LENGTH & 0x00ff0000u) >> 16;
    input[3] = (DEVICE_MSG_TEXT_MAX_LENGTH & 0x0000ff00u) >> 8;
    input[4] =  DEVICE_MSG_TEXT_MAX_LENGTH & 0x000000ffu;
    memset(input + 5, 'a', DEVICE_MSG_TEXT_MAX_LENGTH);
    struct device_msg msg;
    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
    assert(r == DEVICE_MSG_MAX_SIZE);
    assert(msg.type == DEVICE_MSG_TYPE_CLIPBOARD);
    assert(msg.clipboard.text);
    assert(strlen(msg.clipboard.text) == DEVICE_MSG_TEXT_MAX_LENGTH);
    assert(msg.clipboard.text[0] == 'a');
    device_msg_destroy(&msg);
 }
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;
    test_deserialize_clipboard();
    test_deserialize_clipboard_big();
    return 0;
 }
--- a/app/tests/test_queue.c
+++ b/app/tests/test_queue.c
@@ -1,6 +1,6 @@
 #include <assert.h>
-#include "util/queue.h"
+#include <queue.h>
 struct foo {
    int value;
@@ -32,10 +32,7 @@ static void test_queue(void) {
    assert(queue_is_empty(&queue));
 }
-int main(int argc, char *argv[]) {
+int main(void) {
    (void) argc;
    (void) argv;
    test_queue();
    return 0;
 }
--- a/app/tests/test_strutil.c
+++ b/app/tests/test_strutil.c
@@ -1,10 +1,7 @@
 #include <assert.h>
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
 #include <SDL2/SDL.h>
-#include "util/str_util.h"
+#include "str_util.h"
 static void test_xstrncpy_simple(void) {
    char s[] = "xxxxxxxxxx";
@@ -129,16 +126,6 @@ static void test_xstrjoin_truncated_after_sep(void) {
    assert(!strcmp("abc de ", s));
 }
 static void test_strquote(void) {
    const char *s = "abcde";
    char *out = strquote(s);
    // add '"' at the beginning and the end
    assert(!strcmp("\"abcde\"", out));
    SDL_free(out);
 }
 static void test_utf8_truncate(void) {
    const char *s = "aÉbÔc";
    assert(strlen(s) == 7); // É and Ô are 2 bytes-wide
@@ -170,126 +157,7 @@ static void test_utf8_truncate(void) {
    assert(count == 7); // no more chars
 }
-static void test_parse_integer(void) {
+int main(void) {
    long value;
    bool ok = parse_integer("1234", &value);
    assert(ok);
    assert(value == 1234);
    ok = parse_integer("-1234", &value);
    assert(ok);
    assert(value == -1234);
    ok = parse_integer("1234k", &value);
    assert(!ok);
    ok = parse_integer("123456789876543212345678987654321", &value);
    assert(!ok); // out-of-range
 }
 static void test_parse_integers(void) {
    long values[5];
    size_t count = parse_integers("1234", ':', 5, values);
    assert(count == 1);
    assert(values[0] == 1234);
    count = parse_integers("1234:5678", ':', 5, values);
    assert(count == 2);
    assert(values[0] == 1234);
    assert(values[1] == 5678);
    count = parse_integers("1234:5678", ':', 2, values);
    assert(count == 2);
    assert(values[0] == 1234);
    assert(values[1] == 5678);
    count = parse_integers("1234:-5678", ':', 2, values);
    assert(count == 2);
    assert(values[0] == 1234);
    assert(values[1] == -5678);
    count = parse_integers("1:2:3:4:5", ':', 5, values);
    assert(count == 5);
    assert(values[0] == 1);
    assert(values[1] == 2);
    assert(values[2] == 3);
    assert(values[3] == 4);
    assert(values[4] == 5);
    count = parse_integers("1234:5678", ':', 1, values);
    assert(count == 0); // max_items == 1
    count = parse_integers("1:2:3:4:5", ':', 3, values);
    assert(count == 0); // max_items == 3
    count = parse_integers(":1234", ':', 5, values);
    assert(count == 0); // invalid
    count = parse_integers("1234:", ':', 5, values);
    assert(count == 0); // invalid
    count = parse_integers("1234:", ':', 1, values);
    assert(count == 0); // invalid, even when max_items == 1
    count = parse_integers("1234::5678", ':', 5, values);
    assert(count == 0); // invalid
 }
 static void test_parse_integer_with_suffix(void) {
    long value;
    bool ok = parse_integer_with_suffix("1234", &value);
    assert(ok);
    assert(value == 1234);
    ok = parse_integer_with_suffix("-1234", &value);
    assert(ok);
    assert(value == -1234);
    ok = parse_integer_with_suffix("1234k", &value);
    assert(ok);
    assert(value == 1234000);
    ok = parse_integer_with_suffix("1234m", &value);
    assert(ok);
    assert(value == 1234000000);
    ok = parse_integer_with_suffix("-1234k", &value);
    assert(ok);
    assert(value == -1234000);
    ok = parse_integer_with_suffix("-1234m", &value);
    assert(ok);
    assert(value == -1234000000);
    ok = parse_integer_with_suffix("123456789876543212345678987654321", &value);
    assert(!ok); // out-of-range
    char buf[32];
    sprintf(buf, "%ldk", LONG_MAX / 2000);
    ok = parse_integer_with_suffix(buf, &value);
    assert(ok);
    assert(value == LONG_MAX / 2000 * 1000);
    sprintf(buf, "%ldm", LONG_MAX / 2000);
    ok = parse_integer_with_suffix(buf, &value);
    assert(!ok);
    sprintf(buf, "%ldk", LONG_MIN / 2000);
    ok = parse_integer_with_suffix(buf, &value);
    assert(ok);
    assert(value == LONG_MIN / 2000 * 1000);
    sprintf(buf, "%ldm", LONG_MIN / 2000);
    ok = parse_integer_with_suffix(buf, &value);
    assert(!ok);
 }
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;
    test_xstrncpy_simple();
    test_xstrncpy_just_fit();
    test_xstrncpy_truncated();
@@ -298,10 +166,6 @@ int main(int argc, char *argv[]) {
    test_xstrjoin_truncated_in_token();
    test_xstrjoin_truncated_before_sep();
    test_xstrjoin_truncated_after_sep();
    test_strquote();
    test_utf8_truncate();
    test_parse_integer();
    test_parse_integers();
    test_parse_integer_with_suffix();
    return 0;
 }
--- a/build.gradle
+++ b/build.gradle
@@ -7,7 +7,7 @@ buildscript {
        jcenter()
    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:4.0.1'
+        classpath 'com.android.tools.build:gradle:3.4.2'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
@@ -19,9 +19,6 @@ allprojects {
        google()
        jcenter()
    }
    tasks.withType(JavaCompile) {
        options.compilerArgs << "-Xlint:deprecation"
    }
 }
 task clean(type: Delete) {
--- a/config/checkstyle/checkstyle.xml
+++ b/config/checkstyle/checkstyle.xml
@@ -54,7 +54,7 @@ page at http://checkstyle.sourceforge.net/config.html -->
    <module name="SuppressWarningsHolder"/>
    <!-- Checks for imports                              -->
-    <!-- See http://checkstyle.sf.net/config_imports.html -->
+    <!-- See http://checkstyle.sf.net/config_import.html -->
    <module name="AvoidStarImport">
      <property name="allowStaticMemberImports" value="true" />
    </module>
@@ -99,7 +99,7 @@ page at http://checkstyle.sourceforge.net/config.html -->
    <module name="WhitespaceAround" />
    <!-- Modifier Checks                                    -->
-    <!-- See http://checkstyle.sf.net/config_modifier.html -->
+    <!-- See http://checkstyle.sf.net/config_modifiers.html -->
    <module name="ModifierOrder" />
    <module name="RedundantModifier" />
@@ -129,6 +129,11 @@ page at http://checkstyle.sourceforge.net/config.html -->
    </module>
    <module name="IllegalInstantiation" />
    <module name="InnerAssignment" />
    <module name="MagicNumber">
      <property name="severity" value="info" />
      <property name="ignoreHashCodeMethod" value="true" />
      <property name="ignoreAnnotation" value="true" />
    </module>
    <module name="MissingSwitchDefault" />
    <module name="SimplifyBooleanExpression" />
    <module name="SimplifyBooleanReturn" />
--- a/cross_win32.txt
+++ b/cross_win32.txt
@@ -15,6 +15,6 @@ cpu = 'i686'
 endian = 'little'
 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.3.1-win32-shared'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.1.4-win32-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.3.1-win32-dev'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.1.4-win32-dev'
-prebuilt_sdl2 = 'SDL2-2.0.14/i686-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.10/i686-w64-mingw32'
--- a/cross_win64.txt
+++ b/cross_win64.txt
@@ -15,6 +15,6 @@ cpu = 'x86_64'
 endian = 'little'
 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.3.1-win64-shared'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.1.4-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.3.1-win64-dev'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.1.4-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.14/x86_64-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.10/x86_64-w64-mingw32'
--- a/data/scrcpy-console.bat
+++ b/data/scrcpy-console.bat
@@ -1,4 +0,0 @@
@echo off
 scrcpy.exe %*
 :: if the exit code is >= 1, then pause
 if errorlevel 1 pause
--- a/data/scrcpy-noconsole.vbs
+++ b/data/scrcpy-noconsole.vbs
@@ -1 +0,0 @@
 CreateObject("Wscript.Shell").Run "cmd /c scrcpy.exe", 0, false
--- a/gradle/wrapper/gradle-wrapper.jar
+++ b/gradle/wrapper/gradle-wrapper.jar
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.5.1-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
--- a/33
+++ b/33
@@ -125,8 +125,8 @@ if $darwin; then
    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
-# For Cygwin or MSYS, switch paths to Windows format before running java
+# For Cygwin, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+if $cygwin ; then
    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
    JAVACMD=`cygpath --unix "$JAVACMD"`
@@ -154,19 +154,19 @@ if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
        else
            eval `echo args$i`="\"$arg\""
        fi
-        i=`expr $i + 1`
+        i=$((i+1))
    done
    case $i in
-        0) set -- ;;
+        (0) set -- ;;
-        1) set -- "$args0" ;;
+        (1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
+        (2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
    esac
 fi
@@ -175,9 +175,14 @@ save () {
    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
    echo " "
 }
-APP_ARGS=`save "$@"`
+APP_ARGS=$(save "$@")
 # Collect all arguments for the java command, following the shell quoting and substitution rules
 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
 if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
  cd "$(dirname "$0")"
 fi
 exec "$JAVACMD" "$@"
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -29,9 +29,6 @@ if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
 for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
--- a/install_release.sh
+++ b/install_release.sh
@@ -1,21 +0,0 @@
 #!/usr/bin/env bash
 set -e
 BUILDDIR=build-auto
 PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-server-v1.17
 PREBUILT_SERVER_SHA256=11b5ad2d1bc9b9730fb7254a78efd71a8ff46b1938ff468e47a21b653a1b6725
 echo "[scrcpy] Downloading prebuilt server..."
 wget "$PREBUILT_SERVER_URL" -O scrcpy-server
 echo "[scrcpy] Verifying prebuilt server..."
 echo "$PREBUILT_SERVER_SHA256  scrcpy-server" | sha256sum --check
 echo "[scrcpy] Building client..."
 rm -rf "$BUILDDIR"
 meson "$BUILDDIR" --buildtype release --strip -Db_lto=true \
    -Dprebuilt_server=scrcpy-server
 cd "$BUILDDIR"
 ninja
 echo "[scrcpy] Installing (sudo)..."
 sudo ninja install
--- a/meson.build
+++ b/meson.build
@@ -1,10 +1,7 @@
 project('scrcpy', 'c',
-        version: '1.17',
+        version: '1.10',
-        meson_version: '>= 0.48',
+        meson_version: '>= 0.37',
-        default_options: [
+        default_options: 'c_std=c11')
            'c_std=c11',
            'warning_level=2',
        ])
 if get_option('compile_app')
    subdir('app')
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -1,8 +1,7 @@
 option('compile_app', type: 'boolean', value: true, description: 'Build the client')
 option('compile_server', type: 'boolean', value: true, description: 'Build the server')
 option('crossbuild_windows', type: 'boolean', value: false, description: 'Build for Windows from Linux')
 option('windows_noconsole', type: 'boolean', value: false, description: 'Disable console on Windows (pass -mwindows flag)')
 option('prebuilt_server', type: 'string', description: 'Path of the prebuilt server')
-option('portable', type: 'boolean', value: false, description: 'Use scrcpy-server from the same directory as the scrcpy executable')
+option('portable', type: 'boolean', value: false, description: 'Use scrcpy-server.jar from the same directory as the scrcpy executable')
 option('hidpi_support', type: 'boolean', value: true, description: 'Enable High DPI support')
 option('server_debugger', type: 'boolean', value: false, description: 'Run a server debugger and wait for a client to be attached')
 option('server_debugger_method', type: 'combo', choices: ['old', 'new'], value: 'new', description: 'Select the debugger method (Android < 9: "old", Android >= 9: "new")')
--- a/prebuilt-deps/Makefile
+++ b/prebuilt-deps/Makefile
@@ -10,31 +10,31 @@ prepare-win32: prepare-sdl2 prepare-ffmpeg-shared-win32 prepare-ffmpeg-dev-win32
 prepare-win64: prepare-sdl2 prepare-ffmpeg-shared-win64 prepare-ffmpeg-dev-win64 prepare-adb
 prepare-ffmpeg-shared-win32:
-	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win32-shared.zip \
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.1.4-win32-shared.zip \
-		357af9901a456f4dcbacd107e83a934d344c9cb07ddad8aaf80612eeab7d26d2 \
+		596608277f6b937c3dea7c46e854665d75b3de56790bae07f655ca331440f003 \
-		ffmpeg-4.3.1-win32-shared
+		ffmpeg-4.1.4-win32-shared
 prepare-ffmpeg-dev-win32:
-	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win32-dev.zip \
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.1.4-win32-dev.zip \
-		230efb08e9bcf225bd474da29676c70e591fc94d8790a740ca801408fddcb78b \
+		a80c86e263cfad26e202edfa5e6e939a2c88843ae26f031d3e0d981a39fd03fb \
-		ffmpeg-4.3.1-win32-dev
+		ffmpeg-4.1.4-win32-dev
 prepare-ffmpeg-shared-win64:
-	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win64-shared.zip \
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.1.4-win64-shared.zip \
-		dd29b7f92f48dead4dd940492c7509138c0f99db445076d0a597007298a79940 \
+		a90889871de2cab8a79b392591313a188189a353f69dde1db98aebe20b280989 \
-		ffmpeg-4.3.1-win64-shared
+		ffmpeg-4.1.4-win64-shared
 prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win64-dev.zip \
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.1.4-win64-dev.zip \
-		2e8038242cf8e1bd095c2978f196ff0462b122cc6ef7e74626a6af15459d8b81 \
+		6c9d53f9e94ce1821e975ec668e5b9d6e9deb4a45d0d7e30264685d3dfbbb068 \
-		ffmpeg-4.3.1-win64-dev
+		ffmpeg-4.1.4-win64-dev
 prepare-sdl2:
-	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.14-mingw.tar.gz \
+	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.10-mingw.tar.gz \
-		405eaff3eb18f2e08fe669ef9e63bc9a8710b7d343756f238619761e9b60407d \
+		a90a7cddaec4996f4d7be6d80c57ec69b062e132bffc513965f99217f603274a \
-		SDL2-2.0.14
+		SDL2-2.0.10
 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r30.0.5-windows.zip \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r29.0.2-windows.zip \
-		549ba2bdc31f335eb8a504f005f77606a479cc216d6b64a3e8b64c780003661f \
+		d78f02e5e2c9c4c1d046dcd4e6fbdf586e5f57ef66eb0da5c2b49d745d85d5ee \
 		platform-tools
--- a/prebuilt-deps/prepare-dep
+++ b/prebuilt-deps/prepare-dep
@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/bash
 set -e
 url="$1"
 sum="$2"
--- a/release.sh
+++ b/release.sh
@@ -1,2 +1,44 @@
 #!/bin/bash
-make -f release.mk
+set -e
 # test locally
 TESTDIR=build_test
 rm -rf "$TESTDIR"
 # run client tests with ASAN enabled
 meson "$TESTDIR" -Db_sanitize=address
 ninja -C"$TESTDIR" test
 # test server
 GRADLE=${GRADLE:-./gradlew}
 $GRADLE -p server check
 BUILDDIR=build_release
 rm -rf "$BUILDDIR"
 meson "$BUILDDIR" --buildtype release --strip -Db_lto=true
 cd "$BUILDDIR"
 ninja
 cd -
 # build Windows releases
 make -f Makefile.CrossWindows
 # the generated server must be the same everywhere
 cmp "$BUILDDIR/server/scrcpy-server.jar" dist/scrcpy-win32/scrcpy-server.jar
 cmp "$BUILDDIR/server/scrcpy-server.jar" dist/scrcpy-win64/scrcpy-server.jar
 # get version name
 TAG=$(git describe --tags --always)
 # create release directory
 mkdir -p "release-$TAG"
 cp "$BUILDDIR/server/scrcpy-server.jar" "release-$TAG/scrcpy-server-$TAG.jar"
 cp "dist/scrcpy-win32-$TAG.zip" "release-$TAG/"
 cp "dist/scrcpy-win64-$TAG.zip" "release-$TAG/"
 # generate checksums
 cd "release-$TAG"
 sha256sum "scrcpy-server-$TAG.jar" \
          "scrcpy-win32-$TAG.zip" \
          "scrcpy-win64-$TAG.zip" > SHA256SUMS.txt
 echo "Release generated in release-$TAG/"
--- a/4
+++ b/4
@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/bash
 # Run scrcpy generated in the specified BUILDDIR.
 #
 # This provides the same feature as "ninja run", except that it is possible to
@@ -20,4 +20,4 @@ then
    exit 1
 fi
-SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server" "$BUILDDIR/app/scrcpy" "$@"
+SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server.jar" "$BUILDDIR/app/scrcpy" "$@"
--- a/scripts/run-scrcpy.sh
+++ b/scripts/run-scrcpy.sh
@@ -1,2 +1,2 @@
-#!/usr/bin/env bash
+#!/bin/bash
-SCRCPY_SERVER_PATH="$MESON_BUILD_ROOT/server/scrcpy-server" "$MESON_BUILD_ROOT/app/scrcpy"
+SCRCPY_SERVER_PATH="$MESON_BUILD_ROOT/server/scrcpy-server.jar" "$MESON_BUILD_ROOT/app/scrcpy"
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -1,13 +1,13 @@
 apply plugin: 'com.android.application'
 android {
-    compileSdkVersion 30
+    compileSdkVersion 29
    defaultConfig {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
-        targetSdkVersion 30
+        targetSdkVersion 29
-        versionCode 20
+        versionCode 11
-        versionName "1.17"
+        versionName "1.10"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
@@ -20,7 +20,7 @@ android {
 dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
-    testImplementation 'junit:junit:4.13'
+    testImplementation 'junit:junit:4.12'
 }
 apply from: "$project.rootDir/config/android-checkstyle.gradle"
--- a/server/build_without_gradle.sh
+++ b/server/build_without_gradle.sh
@@ -1,69 +0,0 @@
 #!/usr/bin/env bash
 #
 # This script generates the scrcpy binary "manually" (without gradle).
 #
 # Adapt Android platform and build tools versions (via ANDROID_PLATFORM and
 # ANDROID_BUILD_TOOLS environment variables).
 #
 # Then execute:
 #
 #     BUILD_DIR=my_build_dir ./build_without_gradle.sh
 set -e
 SCRCPY_DEBUG=false
 SCRCPY_VERSION_NAME=1.17
 PLATFORM=${ANDROID_PLATFORM:-30}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-30.0.0}
 BUILD_DIR="$(realpath ${BUILD_DIR:-build_manual})"
 CLASSES_DIR="$BUILD_DIR/classes"
 SERVER_DIR=$(dirname "$0")
 SERVER_BINARY=scrcpy-server
 echo "Platform: android-$PLATFORM"
 echo "Build-tools: $BUILD_TOOLS"
 echo "Build dir: $BUILD_DIR"
 rm -rf "$CLASSES_DIR" "$BUILD_DIR/$SERVER_BINARY" classes.dex
 mkdir -p "$CLASSES_DIR/com/genymobile/scrcpy"
 << EOF cat > "$CLASSES_DIR/com/genymobile/scrcpy/BuildConfig.java"
 package com.genymobile.scrcpy;
 public final class BuildConfig {
  public static final boolean DEBUG = $SCRCPY_DEBUG;
  public static final String VERSION_NAME = "$SCRCPY_VERSION_NAME";
 }
 EOF
 echo "Generating java from aidl..."
 cd "$SERVER_DIR/src/main/aidl"
 "$ANDROID_HOME/build-tools/$BUILD_TOOLS/aidl" -o"$CLASSES_DIR" \
    android/view/IRotationWatcher.aidl
 "$ANDROID_HOME/build-tools/$BUILD_TOOLS/aidl" -o"$CLASSES_DIR" \
    android/content/IOnPrimaryClipChangedListener.aidl
 echo "Compiling java sources..."
 cd ../java
 javac -bootclasspath "$ANDROID_HOME/platforms/android-$PLATFORM/android.jar" \
    -cp "$CLASSES_DIR" -d "$CLASSES_DIR" -source 1.8 -target 1.8 \
    com/genymobile/scrcpy/*.java \
    com/genymobile/scrcpy/wrappers/*.java
 echo "Dexing..."
 cd "$CLASSES_DIR"
 "$ANDROID_HOME/build-tools/$BUILD_TOOLS/dx" --dex \
    --output "$BUILD_DIR/classes.dex" \
    android/view/*.class \
    android/content/*.class \
    com/genymobile/scrcpy/*.class \
    com/genymobile/scrcpy/wrappers/*.class
 echo "Archiving..."
 cd "$BUILD_DIR"
 jar cvf "$SERVER_BINARY" classes.dex
 rm -rf classes.dex classes
 echo "Server generated in $BUILD_DIR/$SERVER_BINARY"
--- a/server/meson.build
+++ b/server/meson.build
@@ -3,10 +3,8 @@
 prebuilt_server = get_option('prebuilt_server')
 if prebuilt_server == ''
    custom_target('scrcpy-server',
-                  # gradle is responsible for tracking source changes
+                  build_always: true,  # gradle is responsible for tracking source changes
-                  build_by_default: true,
+                  output: 'scrcpy-server.jar',
                  build_always_stale: true,
                  output: 'scrcpy-server',
                  command: [find_program('./scripts/build-wrapper.sh'), meson.current_source_dir(), '@OUTPUT@', get_option('buildtype')],
                  console: true,
                  install: true,
@@ -18,7 +16,7 @@ else
    endif
    custom_target('scrcpy-server-prebuilt',
                  input: prebuilt_server,
-                  output: 'scrcpy-server',
+                  output: 'scrcpy-server.jar',
                  command: ['cp', '@INPUT@', '@OUTPUT@'],
                  install: true,
                  install_dir: 'share/scrcpy')
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Romain Vimont	783eb95795	fix timestamp	2019-09-30 21:30:36 +02:00
Romain Vimont	7e21f28f2c	wip	2019-09-30 21:30:36 +02:00
Romain Vimont	ccfd4db370	localId	2019-09-30 21:30:36 +02:00
Romain Vimont	6d26ed888e	WIP ignore duplicate mouse events	2019-09-30 21:30:36 +02:00
Romain Vimont	73afdaf251	WIP process touch events on client	2019-09-30 21:30:36 +02:00
Romain Vimont	bb1bf99c6e	WIP handle touch events on server	2019-09-30 21:30:36 +02:00
Romain Vimont	7aeec1c331	WIP Add "inject touch" event	2019-09-30 21:30:36 +02:00
Romain Vimont	3bb2222a34	Rename "pointer" to "mouse pointer" This will help to distinguish them from "touch pointers".	2019-09-30 21:27:06 +02:00
Romain Vimont	bdf2644664	Add buffer_write64be() Add a function to write 64 bits in big-endian from a uint64_t.	2019-09-30 21:27:06 +02:00
		`@@ -1 +0,0 @@`
			`CreateObject("Wscript.Shell").Run "cmd /c scrcpy.exe", 0, false`
`@@ -1,2 +1,2 @@`
	`#!/usr/bin/env bash`	`#!/bin/bash`
	`SCRCPY_SERVER_PATH="$MESON_BUILD_ROOT/server/scrcpy-server" "$MESON_BUILD_ROOT/app/scrcpy"`	`SCRCPY_SERVER_PATH="$MESON_BUILD_ROOT/server/scrcpy-server.jar" "$MESON_BUILD_ROOT/app/scrcpy"`