Always prefer text events by default

This improves text input, but it breaks the expected behavior in games again: <https://github.com/Genymobile/scrcpy/issues/87>. To get the previous behavior back, pass an explicit option: scrcpy --prefer-text-events=non-alpha
Add --prefer-text-events option
2019-11-06 23:25:15 +01:00 · 2019-11-06 23:20:51 +01:00
153 changed files with 3421 additions and 13560 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 libsdl2-dev \
                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-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 libsdl2-dev \
+sudo apt install gcc git pkg-config meson ninja-build \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-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,29 @@ 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
+ninja -Cx
 ```
 _Note: `ninja` [must][ninja-user] be run as a non-root user (only `ninja
@@ -266,27 +204,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]
@@ -301,16 +221,29 @@ After a successful build, you can install _scrcpy_ on the system:
 sudo ninja -Cx 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/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
 ninja -Cx
 sudo ninja -Cx install
 ```
--- a/DEVELOP.md
+++ b/DEVELOP.md
@@ -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
@@ -282,15 +282,6 @@ meson x -Dserver_debugger=true
 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.
--- 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
@@ -9,20 +9,21 @@
 # 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 "$(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 "$(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,139 +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     # initial (current) orientation
 scrcpy --lock-video-orientation=0   # natural orientation
 scrcpy --lock-video-orientation=1   # 90° counterclockwise
 scrcpy --lock-video-orientation=2   # 180°
 scrcpy --lock-video-orientation=3   # 90° clockwise
 ```
 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 _
 ```
 ### Capture
 #### 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
 #### v4l2loopback
 On Linux, it is possible to send the video stream to a v4l2 loopback device, so
 that the Android device can be opened like a webcam by any v4l2-capable tool.
 The module `v4l2loopback` must be installed:
 ```bash
 sudo apt install v4l2loopback-dkms
 ```
 To create a v4l2 device:
 ```bash
 sudo modprobe v4l2loopback
 ```
 This will create a new video device in `/dev/videoN`, where `N` is an integer
 (more [options](https://github.com/umlaeute/v4l2loopback#options) are available
 to create several devices or devices with specific IDs).
 To list the enabled devices:
 ```bash
 # requires v4l-utils package
 v4l2-ctl --list-devices
 # simple but might be sufficient
 ls /dev/video*
 ```
 To start scrcpy using a v4l2 sink:
 ```bash
 scrcpy --v4l2-sink=/dev/videoN
 scrcpy --v4l2-sink=/dev/videoN --no-display  # disable mirroring window
 scrcpy --v4l2-sink=/dev/videoN -N            # short version
 ```
 (replace `N` by the device ID, check with `ls /dev/video*`)
 Once enabled, you can open your video stream with a v4l2-capable tool:
 ```bash
 ffplay -i /dev/videoN
 vlc v4l2:///dev/videoN   # VLC might add some buffering delay
 ```
 For example, you could capture the video within [OBS].
 [OBS]: https://obsproject.com/fr
 ### 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`)_.
@@ -351,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_:
@@ -360,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:
@@ -462,116 +217,27 @@ 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>
 _(left)_ and <kbd>MOD</kbd>+<kbd>→</kbd> _(right)_.
 Note that _scrcpy_ manages 3 different rotations:
 - <kbd>MOD</kbd>+<kbd>r</kbd> requests the device to switch between portrait
   and landscape (the current running app may refuse, if it does not support the
   requested orientation).
 - [`--lock-video-orientation`](#lock-video-orientation) changes the mirroring
   orientation (the orientation of the video sent from the device to the
   computer). This affects the recording.
 - `--rotation` (or <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
   rotates only the window content. This affects only the display, not the
   recording.
 ### Other mirroring options
 #### Read-only
 To disable controls (everything which can interact with the device: input keys,
 mouse events, drag&drop files):
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
 #### Display
 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:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
 Or by pressing <kbd>MOD</kbd>+<kbd>o</kbd> at any time.
 To turn it back on, press <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
 On Android, the `POWER` button always turns the screen on. For convenience, if
 `POWER` is sent via scrcpy (via right-click or <kbd>MOD</kbd>+<kbd>p</kbd>), it
 will force to turn the screen off after a small delay (on a best effort basis).
 The physical `POWER` button will still cause the screen to be turned on.
 It can also be useful to prevent the device from sleeping:
 ```bash
 scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
-#### Show touches
+### Show touches
 For presentations, it may be useful to show physical touches (on the physical
 device).
 Android provides this feature in _Developers options_.
-_Scrcpy_ provides an option to enable this feature on start and restore the
+_Scrcpy_ provides an option to enable this feature on start and disable on exit:
 initial value on exit:
 ```bash
 scrcpy --show-touches
@@ -581,126 +247,7 @@ scrcpy -t
 Note that it only shows _physical_ touches (with the finger on the device).
-#### Disable screensaver
+### Install APK
 By default, scrcpy does not prevent the screensaver to run on the computer.
 To disable it:
 ```bash
 scrcpy --disable-screensaver
 ```
 ### Input control
 #### Rotate device screen
 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.
@@ -708,92 +255,100 @@ window.
 There is no visual feedback, a log is printed to the console.
-#### Push file to device
+### Push file to device
-To push a file to `/sdcard/Download/` on the device, drag & drop a (non-APK)
+To push a file to `/sdcard/` on the device, drag & drop a (non-APK) file to the
-file to the _scrcpy_ window.
+_scrcpy_ window.
 There is no visual feedback, a log is printed to the console.
 The target directory can be changed on start:
 ```bash
-scrcpy --push-target=/sdcard/Movies/
+scrcpy --push-target /sdcard/foo/bar/
 ```
 ### Read-only
 To disable controls (everything which can interact with the device: input keys,
 mouse events, drag&drop files):
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
 ### Turn screen off
 It is possible to turn the device screen off while mirroring on start with a
 command-line option:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
 Or by pressing `Ctrl`+`o` at any time.
 To turn it back on, press `POWER` (or `Ctrl`+`p`).
 ### Render expired frames
 By default, to minimize latency, _scrcpy_ always renders the last decoded frame
 available, and drops any previous one.
 To force the rendering of all frames (at a cost of a possible increased
 latency), use:
 ```bash
 scrcpy --render-expired-frames
 ```
 ### Custom window title
 By default, the window title is the device model. It can be changed:
 ```bash
 scrcpy --window-title 'My device'
 ```
-### Audio forwarding
+### Forward audio
-Audio is not forwarded by _scrcpy_. Use [sndcpy].
+Audio is not forwarded by _scrcpy_. Use [USBaudio] (Linux-only).
 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-left-click¹_
 | Click on `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Middle-click_
 | Click on `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Right-click²_
 | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4th-click³_
 | Click on `MENU` (unlock screen)             | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Click on `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> \| _5th-click³_
 | Expand settings panel                       |  <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Double-5th-click³_
 | Collapse panels                             | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | Copy to clipboard⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
 | Cut to clipboard⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
 | Synchronize clipboards and paste⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | 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._
 _³4th and 5th mouse buttons, if your mouse has them._  
 _⁴Only on Android >= 7._
 Shortcuts with repeated keys are executted by releasing and pressing the key a
 second time. For example, to execute "Expand settings panel":
 1. Press and keep pressing <kbd>MOD</kbd>.
 2. Then double-press <kbd>n</kbd>.
 3. Finally, release <kbd>MOD</kbd>.
 All <kbd>Ctrl</kbd>+_key_ shortcuts are forwarded to the device, so they are
 handled by the active application.
 ## Custom paths
@@ -823,6 +378,8 @@ A colleague challenged me to find a name as unpronounceable as [gnirehtet].
 See [BUILD].
 [BUILD]: BUILD.md
 ## Common issues
@@ -839,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.
@@ -860,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,48 +1,27 @@
 src = [
    'src/main.c',
-    'src/adb.c',
+    'src/command.c',
    'src/cli.c',
    'src/compat.c',
    'src/control_msg.c',
    'src/controller.c',
    'src/decoder.c',
    'src/device.c',
    'src/device_msg.c',
    'src/event_converter.c',
    '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/process.c',
    'src/util/str_util.c',
    'src/util/thread.c',
 ]
 if host_machine.system() == 'windows'
    src += [ 'src/sys/win/process.c' ]
 else
    src += [ 'src/sys/unix/process.c' ]
 endif
 v4l2_support = host_machine.system() == 'linux'
 if v4l2_support
    src += [ 'src/v4l2_sink.c' ]
 endif
 check_functions = [
    'strdup'
 ]
 cc = meson.get_compiler('c')
 if not get_option('crossbuild_windows')
    # native build
@@ -53,13 +32,11 @@ if not get_option('crossbuild_windows')
        dependency('sdl2'),
    ]
    if v4l2_support
        dependencies += dependency('libavdevice')
    endif
 else
    # cross-compile mingw32 build (from Linux to Windows)
    cc = meson.get_compiler('c')
    prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
    sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
    sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/lib'
@@ -94,18 +71,21 @@ else
 endif
 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()
-foreach f : check_functions
+# expose the build type
-  if cc.has_function(f)
+conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')
    define = 'HAVE_' + f.underscorify().to_upper()
    conf.set(define, true)
  endif
 endforeach
 # the version, updated on release
 conf.set_quoted('SCRCPY_VERSION', meson.project_version())
@@ -117,76 +97,76 @@ conf.set_quoted('PREFIX', get_option('prefix'))
 # 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 bitrate, in bits/second
 # overridden by option --bit-rate
 conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
 # enable High DPI support
 conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
 # disable console on Windows
 conf.set('WINDOWS_NOCONSOLE', get_option('windows_noconsole'))
 # run a server debugger and wait for a client to be attached
 conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
 # select the debugger method ('old' for Android < 9, 'new' for Android >= 9)
 conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == 'new')
 # enable V4L2 support (linux only)
 conf.set('HAVE_V4L2', v4l2_support)
 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
@@ -15,10 +15,6 @@ provides display and control of Android devices connected on USB (or over TCP/IP
 .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).
@@ -26,74 +22,25 @@ Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are
 Default is 8000000.
 .TP
-.BI "\-\-codec\-options " key[:type]=value[,...]
+.BI "\-c, \-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
 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
 .BI "\-F, \-\-record\-format " format
 Force recording format (either mp4 or mkv).
 .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 "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
 Default is "unlocked".
 Passing the option without argument is equivalent to passing "initial".
 .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.
@@ -109,31 +56,26 @@ Disable device control (mirror the device in read\-only).
 Do not display device (only when screen recording is enabled).
 .TP
-.B \-\-no\-key\-repeat
+.BI "\-p, \-\-port " port
-Do not forward repeated key events when a key is held down.
+Set the TCP port the client listens on.
 Default is 27183.
 .TP
-.B \-\-no\-mipmaps
+.BI \-\-prefer\-text\-events " mode
-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.
+Configure how key/text events are forwarded to the Android device.
-.TP
+Possible \fImode\fRs are "always" (every text is sent as text), "non-alpha"
-.BI "\-p, \-\-port " port[:port]
+(only letters are sent as a sequence of key events, other characters are sent
-Set the TCP port (range) used by the client to listen.
+as text) and "never" (every text is sent as a sequence of key events).
-Default is 27183:27199.
+Default is "always".
 .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/Download/".
+Default is "/sdcard/".
 .TP
 .BI "\-r, \-\-record " file
@@ -141,206 +83,117 @@ Record screen to
 .IR file .
 The format is determined by the
-.B \-\-record\-format
+.B \-F/\-\-record\-format
 option if set, or by the file extension (.mp4 or .mkv).
 .TP
-.BI "\-\-record\-format " format
+.B \-\-render\-expired\-frames
-Force recording format (either mp4 or mkv).
+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 "\-\-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
 .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.
+Enable "show touches" on start, disable on quit.
 It only shows physical touches (not clicks from scrcpy).
 .TP
-.BI "\-\-v4l2-sink " /dev/videoN
+.B \-T, \-\-always\-on\-top
-Output to v4l2loopback device.
+Make scrcpy window always on top (above other windows).
 It requires to lock the video orientation (see --lock-video-orientation).
 .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 \-v, \-\-version
 Print the version of scrcpy.
 .TP
-.B \-w, \-\-stay-awake
+.BI \-\-window\-title " text
 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)
+.TP
-Alt or (left) Super, but it can be configured by \-\-shortcut-mod (see above).
+.B Ctrl+f
 switch fullscreen mode
 .TP
-.B MOD+f
+.B Ctrl+g
-Switch fullscreen mode
+resize window to 1:1 (pixel\-perfect)
 .TP
-.B MOD+Left
+.B Ctrl+x, Double\-click on black borders
-Rotate display left
+resize window to remove black borders
 .TP
-.B MOD+Right
+.B Ctrl+h, Home, Middle\-click
 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)
+.B Ctrl+b, Ctrl+Backspace, Right\-click (when screen is on)
 Click on BACK
 .TP
-.B MOD+s
+.B Ctrl+s
 Click on APP_SWITCH
 .TP
-.B MOD+m
+.B Ctrl+m
 Click on MENU
 .TP
-.B MOD+Up
+.B Ctrl+Up
 Click on VOLUME_UP
 .TP
-.B MOD+Down
+.B Ctrl+Down
 Click on VOLUME_DOWN
 .TP
-.B MOD+p
+.B Ctrl+p
 Click on POWER (turn screen on/off)
 .TP
 .B Right\-click (when screen is off)
-Turn screen on
+turn screen on
 .TP
-.B MOD+o
+.B Ctrl+o
-Turn device screen off (keep mirroring)
+turn device screen off (keep mirroring)
 .TP
-.B MOD+Shift+o
+.B Ctrl+n
-Turn device screen on
+expand notification panel
 .TP
-.B MOD+r
+.B Ctrl+Shift+n
-Rotate device screen
+collapse notification panel
 .TP
-.B MOD+n
+.B Ctrl+c
-Expand notification panel
+copy device clipboard to computer
 .TP
-.B MOD+Shift+n
+.B Ctrl+v
-Collapse notification panel
+paste computer clipboard to device
 .TP
-.B Mod+c
+.B Ctrl+Shift+v
-Copy to clipboard (inject COPY keycode, Android >= 7 only)
+copy computer clipboard to device
 .TP
-.B Mod+x
+.B Ctrl+i
-Cut to clipboard (inject CUT keycode, Android >= 7 only)
+enable/disable FPS counter (print frames/second in logs)
 .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
+install APK from computer
 .SH Environment variables
@@ -376,7 +229,7 @@ Copyright \(co 2018 Genymobile
 Genymobile
 .UE
-Copyright \(co 2018\-2020
+Copyright \(co 2018\-2019
 .MT rom@rom1v.com
 Romain Vimont
 .ME
--- a/app/src/adb.h
+++ b/app/src/adb.h
@@ -1,34 +0,0 @@
 #ifndef SC_ADB_H
 #define SC_ADB_H
 #include "common.h"
 #include <stdbool.h>
 #include <inttypes.h>
 #include "util/process.h"
 process_t
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
 process_t
 adb_forward(const char *serial, uint16_t local_port,
            const char *device_socket_name);
 process_t
 adb_forward_remove(const char *serial, uint16_t local_port);
 process_t
 adb_reverse(const char *serial, const char *device_socket_name,
            uint16_t local_port);
 process_t
 adb_reverse_remove(const char *serial, const char *device_socket_name);
 process_t
 adb_push(const char *serial, const char *local, const char *remote);
 process_t
 adb_install(const char *serial, const char *local);
 #endif
--- a/app/src/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
@@ -1,11 +1,11 @@
 #ifndef BUFFER_UTIL_H
 #define BUFFER_UTIL_H
 #include "common.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include "config.h"
 static inline void
 buffer_write16be(uint8_t *buf, uint16_t value) {
    buf[0] = value >> 8;
@@ -33,11 +33,11 @@ buffer_read16be(const uint8_t *buf) {
 static inline uint32_t
 buffer_read32be(const uint8_t *buf) {
-    return ((uint32_t) buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+    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
@@ -2,11 +2,11 @@
 #ifndef CBUF_H
 #define CBUF_H
 #include "common.h"
 #include <stdbool.h>
 #include <unistd.h>
 #include "config.h"
 // To define a circular buffer type of 20 ints:
 //     struct cbuf_int CBUF(int, 20);
 //
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -1,977 +0,0 @@
 #include "cli.h"
 #include <assert.h>
 #include <getopt.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <unistd.h>
 #include "scrcpy.h"
 #include "util/log.h"
 #include "util/str_util.h"
 #define STR_IMPL_(x) #x
 #define STR(x) STR_IMPL_(x)
 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 " STR(DEFAULT_BIT_RATE) ".\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 \"unlocked\", \"initial\" (locked to the\n"
        "        initial orientation), 0, 1, 2 and 3.\n"
        "        Natural device orientation is 0, and each increment adds a\n"
        "        90 degrees rotation counterclockwise.\n"
        "        Default is \"unlocked\".\n"
        "        Passing the option without argument is equivalent to passing\n"
        "        \"initial\".\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 0 (unlimited).\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 " STR(DEFAULT_LOCAL_PORT_RANGE_FIRST) ":"
                              STR(DEFAULT_LOCAL_PORT_RANGE_LAST) ".\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/Download/\".\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"
        "    --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"
 #ifdef HAVE_V4L2
        "    --v4l2-sink /dev/videoN\n"
        "        Output to v4l2loopback device.\n"
        "        It requires to lock the video orientation (see\n"
        "        --lock-video-orientation).\n"
        "\n"
 #endif
        "    -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"
        "    -v, --version\n"
        "        Print the version of scrcpy.\n"
        "\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);
 }
 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,
                             enum sc_lock_video_orientation *lock_mode) {
    if (!s || !strcmp(s, "initial")) {
        // Without argument, lock the initial orientation
        *lock_mode = SC_LOCK_VIDEO_ORIENTATION_INITIAL;
        return true;
    }
    if (!strcmp(s, "unlocked")) {
        *lock_mode = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED;
        return true;
    }
    long value;
    bool ok = parse_integer_arg(s, &value, false, 0, 3,
                                "lock video orientation");
    if (!ok) {
        return false;
    }
    *lock_mode = (enum sc_lock_video_orientation) 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, uint32_t *display_id) {
    long value;
    bool ok = parse_integer_arg(s, &value, false, 0, 0x7FFFFFFF, "display id");
    if (!ok) {
        return false;
    }
    *display_id = (uint32_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
 #define OPT_POWER_OFF_ON_CLOSE     1026
 #define OPT_V4L2_SINK              1027
 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", optional_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'},
 #ifdef HAVE_V4L2
        {"v4l2-sink",              required_argument, NULL, OPT_V4L2_SINK},
 #endif
        {"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},
        {"power-off-on-close",     no_argument,       NULL,
                                                  OPT_POWER_OFF_ON_CLOSE},
        {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:
                LOGW("Option --render-expired-frames has been removed. This "
                     "flag has been ignored.");
                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;
            case OPT_POWER_OFF_ON_CLOSE:
                opts->power_off_on_close = true;
                break;
 #ifdef HAVE_V4L2
            case OPT_V4L2_SINK:
                opts->v4l2_device = optarg;
                break;
 #endif
            default:
                // getopt prints the error message on stderr
                return false;
        }
    }
 #ifdef HAVE_V4L2
    if (!opts->display && !opts->record_filename && !opts->v4l2_device) {
        LOGE("-N/--no-display requires either screen recording (-r/--record)"
             " or sink to v4l2loopback device (--v4l2-sink)");
        return false;
    }
    if (opts->v4l2_device && opts->lock_video_orientation
                             == SC_LOCK_VIDEO_ORIENTATION_UNLOCKED) {
        LOGI("Video orientation is locked for v4l2 sink. "
             "See --lock-video-orientation.");
        opts->lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_INITIAL;
    }
 #else
    if (!opts->display && !opts->record_filename) {
        LOGE("-N/--no-display requires screen recording (-r/--record)");
        return false;
    }
 #endif
    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,27 +0,0 @@
 #ifndef SCRCPY_CLI_H
 #define SCRCPY_CLI_H
 #include "common.h"
 #include <stdbool.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
@@ -1,12 +1,14 @@
-#include "adb.h"
+#include "command.h"
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "util/log.h"
+#include "config.h"
-#include "util/str_util.h"
+#include "common.h"
 #include "log.h"
 #include "str_util.h"
 static const char *adb_command;
@@ -53,89 +55,47 @@ 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 (search_executable(pkg_managers[i].binary)) {
            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
            return;
        }
    }
 #endif
    LOGI("You may download and install 'adb' from "
         "https://developer.android.com/studio/releases/platform-tools");
 }
 static void
 show_adb_err_msg(enum process_result err, const char *const argv[]) {
-#define MAX_COMMAND_STRING_LEN 1024
+    char buf[512];
    char *buf = malloc(MAX_COMMAND_STRING_LEN);
    if (!buf) {
        LOGE("Failed to execute (could not allocate error message)");
        return;
    }
    switch (err) {
        case PROCESS_ERROR_GENERIC:
-            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
+            argv_to_string(argv, buf, sizeof(buf));
            LOGE("Failed to execute: %s", buf);
            break;
        case PROCESS_ERROR_MISSING_BINARY:
-            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
+            argv_to_string(argv, buf, sizeof(buf));
            LOGE("Command not found: %s", buf);
            LOGE("(make 'adb' accessible from your PATH or define its full"
                 "path in the ADB environment variable)");
            show_adb_installation_msg();
            break;
        case PROCESS_SUCCESS:
            // do nothing
            break;
    }
    free(buf);
 }
 process_t
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
    const char *cmd[len + 4];
    int i;
    process_t process;
-
+    cmd[0] = get_adb_command();
    const char **argv = malloc((len + 4) * sizeof(*argv));
    if (!argv) {
        return PROCESS_NONE;
    }
    argv[0] = get_adb_command();
    if (serial) {
-        argv[1] = "-s";
+        cmd[1] = "-s";
-        argv[2] = serial;
+        cmd[2] = serial;
        i = 3;
    } else {
        i = 1;
    }
-    memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
+    memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
-    argv[len + i] = NULL;
+    cmd[len + i] = NULL;
-    enum process_result r = process_execute(argv, &process);
+    enum process_result r = cmd_execute(cmd[0], cmd, &process);
    if (r != PROCESS_SUCCESS) {
-        show_adb_err_msg(r, argv);
+        show_adb_err_msg(r, cmd);
-        process = PROCESS_NONE;
+        return PROCESS_NONE;
    }
    free(argv);
    return process;
 }
@@ -188,7 +148,7 @@ adb_push(const char *serial, const char *local, const char *remote) {
    }
    remote = strquote(remote);
    if (!remote) {
-        free((void *) local);
+        SDL_free((void *) local);
        return PROCESS_NONE;
    }
 #endif
@@ -197,8 +157,8 @@ adb_push(const char *serial, const char *local, const char *remote) {
    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 #ifdef __WINDOWS__
-    free((void *) remote);
+    SDL_free((void *) remote);
-    free((void *) local);
+    SDL_free((void *) local);
 #endif
    return proc;
@@ -219,8 +179,26 @@ adb_install(const char *serial, const char *local) {
    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 #ifdef __WINDOWS__
-    free((void *) local);
+    SDL_free((void *) local);
 #endif
    return proc;
 }
 bool
 process_check_success(process_t proc, const char *name) {
    if (proc == PROCESS_NONE) {
        LOGE("Could not execute \"%s\"", name);
        return false;
    }
    exit_code_t exit_code;
    if (!cmd_simple_wait(proc, &exit_code)) {
        if (exit_code != NO_EXIT_CODE) {
            LOGE("\"%s\" returned with value %" PRIexitcode, name, exit_code);
        } else {
            LOGE("\"%s\" exited unexpectedly", name);
        }
        return false;
    }
    return true;
 }
--- a/app/src/command.h
+++ b/app/src/command.h
@@ -0,0 +1,88 @@
 #ifndef COMMAND_H
 #define COMMAND_H
 #include <stdbool.h>
 #include <inttypes.h>
 #ifdef _WIN32
 // not needed here, but winsock2.h must never be included AFTER windows.h
 # include <winsock2.h>
 # include <windows.h>
 # define PATH_SEPARATOR '\\'
 # define PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
 # ifdef _WIN64
 #   define PRIsizet PRIu64
 # else
 #   define PRIsizet PRIu32
 # endif
 # define PROCESS_NONE NULL
  typedef HANDLE process_t;
  typedef DWORD exit_code_t;
 #else
 # include <sys/types.h>
 # define PATH_SEPARATOR '/'
 # define PRIsizet "zu"
 # define PRIexitcode "d"
 # define PROCESS_NONE -1
  typedef pid_t process_t;
  typedef int exit_code_t;
 #endif
 #include "config.h"
 # define NO_EXIT_CODE -1
 enum process_result {
    PROCESS_SUCCESS,
    PROCESS_ERROR_GENERIC,
    PROCESS_ERROR_MISSING_BINARY,
 };
 enum process_result
 cmd_execute(const char *path, const char *const argv[], process_t *process);
 bool
 cmd_terminate(process_t pid);
 bool
 cmd_simple_wait(process_t pid, exit_code_t *exit_code);
 process_t
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
 process_t
 adb_forward(const char *serial, uint16_t local_port,
            const char *device_socket_name);
 process_t
 adb_forward_remove(const char *serial, uint16_t local_port);
 process_t
 adb_reverse(const char *serial, const char *device_socket_name,
            uint16_t local_port);
 process_t
 adb_reverse_remove(const char *serial, const char *device_socket_name);
 process_t
 adb_push(const char *serial, const char *local, const char *remote);
 process_t
 adb_install(const char *serial, const char *local);
 // convenience function to wait for a successful process execution
 // automatically log process errors with the provided process name
 bool
 process_check_success(process_t proc, const char *name);
 // return the absolute path of the executable (the scrcpy binary)
 // may be NULL on error; to be freed by SDL_free
 char *
 get_executable_path(void);
 #endif
--- a/app/src/common.h
+++ b/app/src/common.h
@@ -1,14 +1,30 @@
 #ifndef COMMON_H
 #define COMMON_H
 #include <stdint.h>
 #include "config.h"
 #include "compat.h"
 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
 #define MIN(X,Y) (X) < (Y) ? (X) : (Y)
 #define MAX(X,Y) (X) > (Y) ? (X) : (Y)
-#define container_of(ptr, type, member) \
+struct size {
-    ((type *) (((char *) (ptr)) - offsetof(type, member)))
+    uint16_t width;
    uint16_t height;
 };
 struct point {
    int32_t x;
    int32_t y;
 };
 struct position {
    // The video screen size may be different from the real device screen size,
    // so store to which size the absolute position apply, to scale it
    // accordingly.
    struct size screen_size;
    struct point point;
 };
 #endif
--- a/app/src/compat.c
+++ b/app/src/compat.c
@@ -1,14 +0,0 @@
 #include "compat.h"
 #include "config.h"
 #ifndef HAVE_STRDUP
 char *strdup(const char *s) {
    size_t size = strlen(s) + 1;
    char *dup = malloc(size);
    if (dup) {
        memcpy(dup, s, size);
    }
    return dup;
 }
 #endif
--- a/app/src/compat.h
+++ b/app/src/compat.h
@@ -1,16 +1,19 @@
 #ifndef COMPAT_H
 #define COMPAT_H
 #define _POSIX_C_SOURCE 200809L
 #define _XOPEN_SOURCE 700
 #define _GNU_SOURCE
 #ifdef __APPLE__
 # define _DARWIN_C_SOURCE
 #endif
 #include <libavformat/version.h>
 #include <SDL2/SDL_version.h>
 // In ffmpeg/doc/APIchanges:
 // 2016-04-11 - 6f69f7a / 9200514 - lavf 57.33.100 / 57.5.0 - avformat.h
 //   Add AVStream.codecpar, deprecate AVStream.codec.
 #if    (LIBAVFORMAT_VERSION_MICRO >= 100 /* FFmpeg */ && \
        LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 33, 100)) \
    || (LIBAVFORMAT_VERSION_MICRO < 100 && /* Libav */ \
        LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 5, 0))
 # define SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_API
 #endif
 // In ffmpeg/doc/APIchanges:
 // 2018-02-06 - 0694d87024 - lavf 58.9.100 - avformat.h
 //   Deprecate use of av_register_input_format(), av_register_output_format(),
@@ -22,16 +25,13 @@
 # define SCRCPY_LAVF_REQUIRES_REGISTER_ALL
 #endif
 // In ffmpeg/doc/APIchanges:
-// 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
+// 2016-04-21 - 7fc329e - lavc 57.37.100 - avcodec.h
-//   Deprecate AVFormatContext filename field which had limited length, use the
+//   Add a new audio/video encoding and decoding API with decoupled input
-//   new dynamically allocated url field instead.
+//   and output -- avcodec_send_packet(), avcodec_receive_frame(),
-//
+//   avcodec_send_frame() and avcodec_receive_packet().
-// 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 37, 100)
-//   Add url field to AVFormatContext and add ff_format_set_url helper function.
+# define SCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
 #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 7, 100)
 # define SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
 #endif
 #if SDL_VERSION_ATLEAST(2, 0, 5)
@@ -48,8 +48,4 @@
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
 #endif
 #ifndef HAVE_STRDUP
 char *strdup(const char *s);
 #endif
 #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 <stdlib.h>
 #include <string.h>
 #include <SDL2/SDL_assert.h>
-#include "util/buffer_util.h"
+#include "config.h"
-#include "util/log.h"
+#include "buffer_util.h"
-#include "util/str_util.h"
+#include "log.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,13 +42,11 @@ 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_TOUCH_EVENT:
@@ -67,24 +65,19 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
            buffer_write32be(&buf[17],
                             (uint32_t) msg->inject_scroll_event.vscroll);
            return 21;
        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
            buf[1] = msg->inject_keycode.action;
            return 2;
        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;
            return 2;
        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
+        case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
            // no additional data
            return 1;
        default:
@@ -97,10 +90,10 @@ void
 control_msg_destroy(struct control_msg *msg) {
    switch (msg->type) {
        case CONTROL_MSG_TYPE_INJECT_TEXT:
-            free(msg->inject_text.text);
+            SDL_free(msg->inject_text.text);
            break;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
-            free(msg->set_clipboard.text);
+            SDL_free(msg->set_clipboard.text);
            break;
        default:
            // do nothing
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@@ -1,24 +1,21 @@
 #ifndef CONTROLMSG_H
 #define CONTROLMSG_H
 #include "common.h"
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include "config.h"
 #include "android/input.h"
 #include "android/keycodes.h"
-#include "coords.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,
@@ -27,12 +24,10 @@ enum control_msg_type {
    CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
    CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
    CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
-    CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+    CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
    CONTROL_MSG_TYPE_COLLAPSE_PANELS,
    CONTROL_MSG_TYPE_GET_CLIPBOARD,
    CONTROL_MSG_TYPE_SET_CLIPBOARD,
    CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
    CONTROL_MSG_TYPE_ROTATE_DEVICE,
 };
 enum screen_power_mode {
@@ -47,11 +42,10 @@ struct control_msg {
        struct {
            enum android_keyevent_action action;
            enum android_keycode keycode;
            uint32_t repeat;
            enum android_metastate metastate;
        } inject_keycode;
        struct {
-            char *text; // owned, to be freed by free()
+            char *text; // owned, to be freed by SDL_free()
        } inject_text;
        struct {
            enum android_motionevent_action action;
@@ -66,12 +60,7 @@ struct control_msg {
            int32_t vscroll;
        } inject_scroll_event;
        struct {
-            enum android_keyevent_action action; // action for the BACK key
+            char *text; // owned, to be freed by SDL_free()
            // screen may only be turned on on ACTION_DOWN
        } back_or_screen_on;
        struct {
            char *text; // owned, to be freed by free()
            bool paste;
        } set_clipboard;
        struct {
            enum screen_power_mode mode;
@@ -79,7 +68,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,28 +1,27 @@
 #include "controller.h"
-#include <assert.h>
+#include <SDL2/SDL_assert.h>
-#include "util/log.h"
+#include "config.h"
 #include "lock_util.h"
 #include "log.h"
 bool
 controller_init(struct controller *controller, socket_t control_socket) {
    cbuf_init(&controller->queue);
-    bool ok = receiver_init(&controller->receiver, control_socket);
+    if (!receiver_init(&controller->receiver, control_socket)) {
    if (!ok) {
        return false;
    }
-    ok = sc_mutex_init(&controller->mutex);
+    if (!(controller->mutex = SDL_CreateMutex())) {
    if (!ok) {
        receiver_destroy(&controller->receiver);
        return false;
    }
-    ok = sc_cond_init(&controller->msg_cond);
+    if (!(controller->msg_cond = SDL_CreateCond())) {
    if (!ok) {
        receiver_destroy(&controller->receiver);
-        sc_mutex_destroy(&controller->mutex);
+        SDL_DestroyMutex(controller->mutex);
        return false;
    }
@@ -34,8 +33,8 @@ controller_init(struct controller *controller, socket_t control_socket) {
 void
 controller_destroy(struct controller *controller) {
-    sc_cond_destroy(&controller->msg_cond);
+    SDL_DestroyCond(controller->msg_cond);
-    sc_mutex_destroy(&controller->mutex);
+    SDL_DestroyMutex(controller->mutex);
    struct control_msg msg;
    while (cbuf_take(&controller->queue, &msg)) {
@@ -48,26 +47,26 @@ controller_destroy(struct controller *controller) {
 bool
 controller_push_msg(struct controller *controller,
                      const struct control_msg *msg) {
-    sc_mutex_lock(&controller->mutex);
+    mutex_lock(controller->mutex);
    bool was_empty = cbuf_is_empty(&controller->queue);
    bool res = cbuf_push(&controller->queue, *msg);
    if (was_empty) {
-        sc_cond_signal(&controller->msg_cond);
+        cond_signal(controller->msg_cond);
    }
-    sc_mutex_unlock(&controller->mutex);
+    mutex_unlock(controller->mutex);
    return res;
 }
 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];
-    size_t length = control_msg_serialize(msg, serialized_msg);
+    int length = control_msg_serialize(msg, serialized_msg);
    if (!length) {
        return false;
    }
    int w = net_send_all(controller->control_socket, serialized_msg, length);
-    return (size_t) w == length;
+    return w == length;
 }
 static int
@@ -75,20 +74,19 @@ run_controller(void *data) {
    struct controller *controller = data;
    for (;;) {
-        sc_mutex_lock(&controller->mutex);
+        mutex_lock(controller->mutex);
        while (!controller->stopped && cbuf_is_empty(&controller->queue)) {
-            sc_cond_wait(&controller->msg_cond, &controller->mutex);
+            cond_wait(controller->msg_cond, controller->mutex);
        }
        if (controller->stopped) {
            // stop immediately, do not process further msgs
-            sc_mutex_unlock(&controller->mutex);
+            mutex_unlock(controller->mutex);
            break;
        }
        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);
        sc_mutex_unlock(&controller->mutex);
        bool ok = process_msg(controller, &msg);
        control_msg_destroy(&msg);
@@ -104,16 +102,16 @@ bool
 controller_start(struct controller *controller) {
    LOGD("Starting controller thread");
-    bool ok = sc_thread_create(&controller->thread, run_controller,
+    controller->thread = SDL_CreateThread(run_controller, "controller",
-                               "controller", controller);
+                                          controller);
-    if (!ok) {
+    if (!controller->thread) {
        LOGC("Could not start controller thread");
        return false;
    }
    if (!receiver_start(&controller->receiver)) {
        controller_stop(controller);
-        sc_thread_join(&controller->thread, NULL);
+        SDL_WaitThread(controller->thread, NULL);
        return false;
    }
@@ -122,14 +120,14 @@ controller_start(struct controller *controller) {
 void
 controller_stop(struct controller *controller) {
-    sc_mutex_lock(&controller->mutex);
+    mutex_lock(controller->mutex);
    controller->stopped = true;
-    sc_cond_signal(&controller->msg_cond);
+    cond_signal(controller->msg_cond);
-    sc_mutex_unlock(&controller->mutex);
+    mutex_unlock(controller->mutex);
 }
 void
 controller_join(struct controller *controller) {
-    sc_thread_join(&controller->thread, NULL);
+    SDL_WaitThread(controller->thread, NULL);
    receiver_join(&controller->receiver);
 }
--- a/app/src/controller.h
+++ b/app/src/controller.h
@@ -1,23 +1,23 @@
 #ifndef CONTROLLER_H
 #define CONTROLLER_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL_mutex.h>
 #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"
 #include "util/thread.h"
 struct control_msg_queue CBUF(struct control_msg, 64);
 struct controller {
    socket_t control_socket;
-    sc_thread thread;
+    SDL_Thread *thread;
-    sc_mutex mutex;
+    SDL_mutex *mutex;
-    sc_cond msg_cond;
+    SDL_cond *msg_cond;
    bool stopped;
    struct control_msg_queue queue;
    struct receiver receiver;
--- a/app/src/coords.h
+++ b/app/src/coords.h
@@ -1,24 +0,0 @@
 #ifndef SC_COORDS
 #define SC_COORDS
 #include <stdint.h>
 struct size {
    uint16_t width;
    uint16_t height;
 };
 struct point {
    int32_t x;
    int32_t y;
 };
 struct position {
    // The video screen size may be different from the real device screen size,
    // so store to which size the absolute position apply, to scale it
    // accordingly.
    struct size screen_size;
    struct point point;
 };
 #endif
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@@ -1,43 +1,44 @@
 #include "decoder.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>
 #include <unistd.h>
 #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 "trait/frame_sink.h"
 #include "util/log.h"
 /** Downcast packet_sink to decoder */
 #define DOWNCAST(SINK) container_of(SINK, struct decoder, packet_sink)
 // set the decoded frame as ready for rendering, and notify
 static void
-decoder_close_first_sinks(struct decoder *decoder, unsigned count) {
+push_frame(struct decoder *decoder) {
-    while (count) {
+    bool previous_frame_skipped;
-        struct sc_frame_sink *sink = decoder->sinks[--count];
+    video_buffer_offer_decoded_frame(decoder->video_buffer,
-        sink->ops->close(sink);
+                                     &previous_frame_skipped);
    if (previous_frame_skipped) {
        // the previous EVENT_NEW_FRAME will consume this frame
        return;
    }
    static SDL_Event new_frame_event = {
        .type = EVENT_NEW_FRAME,
    };
    SDL_PushEvent(&new_frame_event);
 }
-static inline void
+void
-decoder_close_sinks(struct decoder *decoder) {
+decoder_init(struct decoder *decoder, struct video_buffer *vb) {
-    decoder_close_first_sinks(decoder, decoder->sink_count);
+    decoder->video_buffer = vb;
 }
-static bool
+bool
 decoder_open_sinks(struct decoder *decoder) {
    for (unsigned i = 0; i < decoder->sink_count; ++i) {
        struct sc_frame_sink *sink = decoder->sinks[i];
        if (!sink->ops->open(sink)) {
            LOGE("Could not open frame sink %d", i);
            decoder_close_first_sinks(decoder, i);
            return false;
        }
    }
    return true;
 }
 static bool
 decoder_open(struct decoder *decoder, const AVCodec *codec) {
    decoder->codec_ctx = avcodec_alloc_context3(codec);
    if (!decoder->codec_ctx) {
@@ -51,110 +52,52 @@ decoder_open(struct decoder *decoder, const AVCodec *codec) {
        return false;
    }
    decoder->frame = av_frame_alloc();
    if (!decoder->frame) {
        LOGE("Could not create decoder frame");
        avcodec_close(decoder->codec_ctx);
        avcodec_free_context(&decoder->codec_ctx);
        return false;
    }
    if (!decoder_open_sinks(decoder)) {
        LOGE("Could not open decoder sinks");
        av_frame_free(&decoder->frame);
        avcodec_close(decoder->codec_ctx);
        avcodec_free_context(&decoder->codec_ctx);
        return false;
    }
    return true;
 }
-static void
+void
 decoder_close(struct decoder *decoder) {
    decoder_close_sinks(decoder);
    av_frame_free(&decoder->frame);
    avcodec_close(decoder->codec_ctx);
    avcodec_free_context(&decoder->codec_ctx);
 }
-static bool
+bool
 push_frame_to_sinks(struct decoder *decoder, const AVFrame *frame) {
    for (unsigned i = 0; i < decoder->sink_count; ++i) {
        struct sc_frame_sink *sink = decoder->sinks[i];
        if (!sink->ops->push(sink, frame)) {
            LOGE("Could not send frame to sink %d", i);
            return false;
        }
    }
    return true;
 }
 static bool
 decoder_push(struct decoder *decoder, const AVPacket *packet) {
-    bool is_config = packet->pts == AV_NOPTS_VALUE;
+// the new decoding/encoding API has been introduced by:
-    if (is_config) {
+// <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=7fc329e2dd6226dfecaa4a1d7adf353bf2773726>
-        // nothing to do
+#ifdef SCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
-        return true;
+    int ret;
-    }
+    if ((ret = avcodec_send_packet(decoder->codec_ctx, packet)) < 0) {
    int ret = avcodec_send_packet(decoder->codec_ctx, packet);
    if (ret < 0 && ret != AVERROR(EAGAIN)) {
        LOGE("Could not send video packet: %d", ret);
        return false;
    }
-    ret = avcodec_receive_frame(decoder->codec_ctx, decoder->frame);
+    ret = avcodec_receive_frame(decoder->codec_ctx,
                                decoder->video_buffer->decoding_frame);
    if (!ret) {
        // a frame was received
-        bool ok = push_frame_to_sinks(decoder, decoder->frame);
+        push_frame(decoder);
        // A frame lost should not make the whole pipeline fail. The error, if
        // any, is already logged.
        (void) ok;
        av_frame_unref(decoder->frame);
    } else if (ret != AVERROR(EAGAIN)) {
        LOGE("Could not receive video frame: %d", ret);
        return false;
    }
 #else
    int got_picture;
    int len = avcodec_decode_video2(decoder->codec_ctx,
                                    decoder->video_buffer->decoding_frame,
                                    &got_picture,
                                    packet);
    if (len < 0) {
        LOGE("Could not decode video packet: %d", len);
        return false;
    }
    if (got_picture) {
        push_frame(decoder);
    }
 #endif
    return true;
 }
 static bool
 decoder_packet_sink_open(struct sc_packet_sink *sink, const AVCodec *codec) {
    struct decoder *decoder = DOWNCAST(sink);
    return decoder_open(decoder, codec);
 }
 static void
 decoder_packet_sink_close(struct sc_packet_sink *sink) {
    struct decoder *decoder = DOWNCAST(sink);
    decoder_close(decoder);
 }
 static bool
 decoder_packet_sink_push(struct sc_packet_sink *sink, const AVPacket *packet) {
    struct decoder *decoder = DOWNCAST(sink);
    return decoder_push(decoder, packet);
 }
 void
-decoder_init(struct decoder *decoder) {
+decoder_interrupt(struct decoder *decoder) {
-    decoder->sink_count = 0;
+    video_buffer_interrupt(decoder->video_buffer);
    static const struct sc_packet_sink_ops ops = {
        .open = decoder_packet_sink_open,
        .close = decoder_packet_sink_close,
        .push = decoder_packet_sink_push,
    };
    decoder->packet_sink.ops = &ops;
 }
 void
 decoder_add_sink(struct decoder *decoder, struct sc_frame_sink *sink) {
    assert(decoder->sink_count < DECODER_MAX_SINKS);
    assert(sink);
    assert(sink->ops);
    decoder->sinks[decoder->sink_count++] = sink;
 }
--- a/app/src/decoder.h
+++ b/app/src/decoder.h
@@ -1,29 +1,31 @@
 #ifndef DECODER_H
 #define DECODER_H
 #include "common.h"
 #include "trait/packet_sink.h"
 #include <stdbool.h>
 #include <libavformat/avformat.h>
-#define DECODER_MAX_SINKS 2
+#include "config.h"
 struct video_buffer;
 struct decoder {
-    struct sc_packet_sink packet_sink; // packet sink trait
+    struct video_buffer *video_buffer;
    struct sc_frame_sink *sinks[DECODER_MAX_SINKS];
    unsigned sink_count;
    AVCodecContext *codec_ctx;
    AVFrame *frame;
 };
 void
-decoder_init(struct decoder *decoder);
+decoder_init(struct decoder *decoder, struct video_buffer *vb);
 bool
 decoder_open(struct decoder *decoder, const AVCodec *codec);
 void
-decoder_add_sink(struct decoder *decoder, struct sc_frame_sink *sink);
+decoder_close(struct decoder *decoder);
 bool
 decoder_push(struct decoder *decoder, const AVPacket *packet);
 void
 decoder_interrupt(struct decoder *decoder);
 #endif
--- a/app/src/device.c
+++ b/app/src/device.c
@@ -0,0 +1,24 @@
 #include "device.h"
 #include "config.h"
 #include "log.h"
 bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size) {
    unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
    int r = net_recv_all(device_socket, buf, sizeof(buf));
    if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
        LOGE("Could not retrieve device information");
        return false;
    }
    // in case the client sends garbage
    buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
    // strcpy is safe here, since name contains at least
    // DEVICE_NAME_FIELD_LENGTH bytes and strlen(buf) < DEVICE_NAME_FIELD_LENGTH
    strcpy(device_name, (char *) buf);
    size->width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
            | buf[DEVICE_NAME_FIELD_LENGTH + 1];
    size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
    return true;
 }
--- a/app/src/device.h
+++ b/app/src/device.h
@@ -0,0 +1,16 @@
 #ifndef DEVICE_H
 #define DEVICE_H
 #include <stdbool.h>
 #include "config.h"
 #include "common.h"
 #include "net.h"
 #define DEVICE_NAME_FIELD_LENGTH 64
 // name must be at least DEVICE_NAME_FIELD_LENGTH bytes
 bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size);
 #endif
--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@@ -1,15 +1,16 @@
 #include "device_msg.h"
 #include <stdlib.h>
 #include <string.h>
 #include <SDL2/SDL_assert.h>
-#include "util/buffer_util.h"
+#include "config.h"
-#include "util/log.h"
+#include "buffer_util.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,22 +18,22 @@ 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 = malloc(clipboard_len + 1);
+            char *text = SDL_malloc(clipboard_len + 1);
            if (!text) {
                LOGW("Could not allocate text for clipboard");
                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);
@@ -43,6 +44,6 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
 void
 device_msg_destroy(struct device_msg *msg) {
    if (msg->type == DEVICE_MSG_TYPE_CLIPBOARD) {
-        free(msg->clipboard.text);
+        SDL_free(msg->clipboard.text);
    }
 }
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@@ -1,15 +1,14 @@
 #ifndef DEVICEMSG_H
 #define DEVICEMSG_H
 #include "common.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <unistd.h>
-#define DEVICE_MSG_MAX_SIZE (1 << 18) // 256k
+#include "config.h"
-// type: 1 byte; length: 4 bytes
+
-#define DEVICE_MSG_TEXT_MAX_LENGTH (DEVICE_MSG_MAX_SIZE - 5)
+#define DEVICE_MSG_TEXT_MAX_LENGTH 4093
 #define DEVICE_MSG_SERIALIZED_MAX_SIZE (3 + DEVICE_MSG_TEXT_MAX_LENGTH)
 enum device_msg_type {
    DEVICE_MSG_TYPE_CLIPBOARD,
@@ -19,7 +18,7 @@ struct device_msg {
    enum device_msg_type type;
    union {
        struct {
-            char *text; // owned, to be freed by free()
+            char *text; // owned, to be freed by SDL_free()
        } clipboard;
    };
 };
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@@ -1,5 +1,7 @@
 #include "event_converter.h"
 #include "config.h"
 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false
@@ -14,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;
    }
@@ -74,7 +76,7 @@ convert_meta_state(SDL_Keymod mod) {
 bool
 convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
-                bool prefer_text) {
+                enum text_events_pref pref) {
    switch (from) {
        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
@@ -90,34 +92,17 @@ 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))) {
+    if (pref == PREFER_TEXT_EVENTS_ALWAYS) {
-        // Handle Numpad events when Num Lock is disabled
+        // never forward key events
        // 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;
    }
    // forward all supported key events
    SDL_assert(pref == PREFER_TEXT_EVENTS_NEVER ||
               pref == PREFER_TEXT_EVENTS_NON_ALPHA);
    if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
        return false;
    }
--- a/app/src/event_converter.h
+++ b/app/src/event_converter.h
@@ -1,12 +1,13 @@
 #ifndef CONVERT_H
 #define CONVERT_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_events.h>
 #include "config.h"
 #include "control_msg.h"
 #include "input_manager.h"
 bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to);
@@ -16,7 +17,7 @@ convert_meta_state(SDL_Keymod mod);
 bool
 convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
-                bool prefer_text);
+                enum text_events_pref pref);
 enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state);
--- a/app/src/events.h
+++ b/app/src/events.h
@@ -1,2 +1,3 @@
-#define EVENT_NEW_FRAME       SDL_USEREVENT
+#define EVENT_NEW_SESSION SDL_USEREVENT
-#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 1)
+#define EVENT_NEW_FRAME (SDL_USEREVENT + 1)
 #define EVENT_STREAM_STOPPED (SDL_USEREVENT + 2)
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@@ -1,16 +1,18 @@
 #include "file_handler.h"
 #include <assert.h>
 #include <string.h>
 #include <SDL2/SDL_assert.h>
-#include "adb.h"
+#include "config.h"
-#include "util/log.h"
+#include "command.h"
 #include "lock_util.h"
 #include "log.h"
-#define DEFAULT_PUSH_TARGET "/sdcard/Download/"
+#define DEFAULT_PUSH_TARGET "/sdcard/"
 static void
 file_handler_request_destroy(struct file_handler_request *req) {
-    free(req->file);
+    SDL_free(req->file);
 }
 bool
@@ -19,23 +21,21 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
    cbuf_init(&file_handler->queue);
-    bool ok = sc_mutex_init(&file_handler->mutex);
+    if (!(file_handler->mutex = SDL_CreateMutex())) {
    if (!ok) {
        return false;
    }
-    ok = sc_cond_init(&file_handler->event_cond);
+    if (!(file_handler->event_cond = SDL_CreateCond())) {
-    if (!ok) {
+        SDL_DestroyMutex(file_handler->mutex);
        sc_mutex_destroy(&file_handler->mutex);
        return false;
    }
    if (serial) {
-        file_handler->serial = strdup(serial);
+        file_handler->serial = SDL_strdup(serial);
        if (!file_handler->serial) {
            LOGW("Could not strdup serial");
-            sc_cond_destroy(&file_handler->event_cond);
+            SDL_DestroyCond(file_handler->event_cond);
-            sc_mutex_destroy(&file_handler->mutex);
+            SDL_DestroyMutex(file_handler->mutex);
            return false;
        }
    } else {
@@ -55,9 +55,9 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
 void
 file_handler_destroy(struct file_handler *file_handler) {
-    sc_cond_destroy(&file_handler->event_cond);
+    SDL_DestroyCond(file_handler->event_cond);
-    sc_mutex_destroy(&file_handler->mutex);
+    SDL_DestroyMutex(file_handler->mutex);
-    free(file_handler->serial);
+    SDL_free(file_handler->serial);
    struct file_handler_request req;
    while (cbuf_take(&file_handler->queue, &req)) {
@@ -93,13 +93,13 @@ file_handler_request(struct file_handler *file_handler,
        .file = file,
    };
-    sc_mutex_lock(&file_handler->mutex);
+    mutex_lock(file_handler->mutex);
    bool was_empty = cbuf_is_empty(&file_handler->queue);
    bool res = cbuf_push(&file_handler->queue, req);
    if (was_empty) {
-        sc_cond_signal(&file_handler->event_cond);
+        cond_signal(file_handler->event_cond);
    }
-    sc_mutex_unlock(&file_handler->mutex);
+    mutex_unlock(file_handler->mutex);
    return res;
 }
@@ -108,20 +108,19 @@ run_file_handler(void *data) {
    struct file_handler *file_handler = data;
    for (;;) {
-        sc_mutex_lock(&file_handler->mutex);
+        mutex_lock(file_handler->mutex);
        file_handler->current_process = PROCESS_NONE;
        while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
-            sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
+            cond_wait(file_handler->event_cond, file_handler->mutex);
        }
        if (file_handler->stopped) {
            // stop immediately, do not process further events
-            sc_mutex_unlock(&file_handler->mutex);
+            mutex_unlock(file_handler->mutex);
            break;
        }
        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) {
@@ -133,16 +132,16 @@ run_file_handler(void *data) {
                                file_handler->push_target);
        }
        file_handler->current_process = process;
-        sc_mutex_unlock(&file_handler->mutex);
+        mutex_unlock(file_handler->mutex);
        if (req.action == ACTION_INSTALL_APK) {
-            if (process_check_success(process, "adb install", false)) {
+            if (process_check_success(process, "adb install")) {
                LOGI("%s successfully installed", req.file);
            } else {
                LOGE("Failed to install %s", req.file);
            }
        } else {
-            if (process_check_success(process, "adb push", false)) {
+            if (process_check_success(process, "adb push")) {
                LOGI("%s successfully pushed to %s", req.file,
                                                     file_handler->push_target);
            } else {
@@ -151,14 +150,6 @@ run_file_handler(void *data) {
            }
        }
        sc_mutex_lock(&file_handler->mutex);
        // Close the process (it is necessary already terminated)
        // Execute this call with mutex locked to avoid race conditions with
        // file_handler_stop()
        process_close(file_handler->current_process);
        file_handler->current_process = PROCESS_NONE;
        sc_mutex_unlock(&file_handler->mutex);
        file_handler_request_destroy(&req);
    }
    return 0;
@@ -168,9 +159,9 @@ bool
 file_handler_start(struct file_handler *file_handler) {
    LOGD("Starting file_handler thread");
-    bool ok = sc_thread_create(&file_handler->thread, run_file_handler,
+    file_handler->thread = SDL_CreateThread(run_file_handler, "file_handler",
-                               "file_handler", file_handler);
+                                            file_handler);
-    if (!ok) {
+    if (!file_handler->thread) {
        LOGC("Could not start file_handler thread");
        return false;
    }
@@ -180,18 +171,20 @@ file_handler_start(struct file_handler *file_handler) {
 void
 file_handler_stop(struct file_handler *file_handler) {
-    sc_mutex_lock(&file_handler->mutex);
+    mutex_lock(file_handler->mutex);
    file_handler->stopped = true;
-    sc_cond_signal(&file_handler->event_cond);
+    cond_signal(file_handler->event_cond);
    if (file_handler->current_process != PROCESS_NONE) {
-        if (!process_terminate(file_handler->current_process)) {
+        if (!cmd_terminate(file_handler->current_process)) {
-            LOGW("Could not terminate push/install process");
+            LOGW("Could not terminate install process");
        }
        cmd_simple_wait(file_handler->current_process, NULL);
        file_handler->current_process = PROCESS_NONE;
    }
-    sc_mutex_unlock(&file_handler->mutex);
+    mutex_unlock(file_handler->mutex);
 }
 void
 file_handler_join(struct file_handler *file_handler) {
-    sc_thread_join(&file_handler->thread, NULL);
+    SDL_WaitThread(file_handler->thread, NULL);
 }
--- a/app/src/file_handler.h
+++ b/app/src/file_handler.h
@@ -1,13 +1,13 @@
 #ifndef FILE_HANDLER_H
 #define FILE_HANDLER_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
-#include "adb.h"
+#include "config.h"
-#include "util/cbuf.h"
+#include "cbuf.h"
-#include "util/thread.h"
+#include "command.h"
 typedef enum {
    ACTION_INSTALL_APK,
@@ -24,9 +24,9 @@ struct file_handler_request_queue CBUF(struct file_handler_request, 16);
 struct file_handler {
    char *serial;
    const char *push_target;
-    sc_thread thread;
+    SDL_Thread *thread;
-    sc_mutex mutex;
+    SDL_mutex *mutex;
-    sc_cond event_cond;
+    SDL_cond *event_cond;
    bool stopped;
    bool initialized;
    process_t current_process;
@@ -49,7 +49,7 @@ file_handler_stop(struct file_handler *file_handler);
 void
 file_handler_join(struct file_handler *file_handler);
-// take ownership of file, and will free() it
+// take ownership of file, and will SDL_free() it
 bool
 file_handler_request(struct file_handler *file_handler,
                     file_handler_action_t action,
--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@@ -1,27 +1,29 @@
 #include "fps_counter.h"
-#include <assert.h>
+#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>
-#include "util/log.h"
+#include "config.h"
 #include "lock_util.h"
 #include "log.h"
 #define FPS_COUNTER_INTERVAL_MS 1000
 bool
 fps_counter_init(struct fps_counter *counter) {
-    bool ok = sc_mutex_init(&counter->mutex);
+    counter->mutex = SDL_CreateMutex();
-    if (!ok) {
+    if (!counter->mutex) {
        return false;
    }
-    ok = sc_cond_init(&counter->state_cond);
+    counter->state_cond = SDL_CreateCond();
-    if (!ok) {
+    if (!counter->state_cond) {
-        sc_mutex_destroy(&counter->mutex);
+        SDL_DestroyMutex(counter->mutex);
        return false;
    }
-    counter->thread_started = false;
+    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;
@@ -29,18 +31,8 @@ fps_counter_init(struct fps_counter *counter) {
 void
 fps_counter_destroy(struct fps_counter *counter) {
-    sc_cond_destroy(&counter->state_cond);
+    SDL_DestroyCond(counter->state_cond);
-    sc_mutex_destroy(&counter->mutex);
+    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
@@ -76,48 +68,45 @@ static int
 run_fps_counter(void *data) {
    struct fps_counter *counter = data;
-    sc_mutex_lock(&counter->mutex);
+    mutex_lock(counter->mutex);
    while (!counter->interrupted) {
-        while (!counter->interrupted && !is_started(counter)) {
+        while (!counter->interrupted && !SDL_AtomicGet(&counter->started)) {
-            sc_cond_wait(&counter->state_cond, &counter->mutex);
+            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
-            sc_cond_timedwait(&counter->state_cond, &counter->mutex, remaining);
+            cond_wait_timeout(counter->state_cond, counter->mutex, remaining);
        }
    }
-    sc_mutex_unlock(&counter->mutex);
+    mutex_unlock(counter->mutex);
    return 0;
 }
 bool
 fps_counter_start(struct fps_counter *counter) {
-    sc_mutex_lock(&counter->mutex);
+    mutex_lock(counter->mutex);
    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
    counter->nr_rendered = 0;
    counter->nr_skipped = 0;
-    sc_mutex_unlock(&counter->mutex);
+    mutex_unlock(counter->mutex);
-    set_started(counter, true);
+    SDL_AtomicSet(&counter->started, 1);
-    sc_cond_signal(&counter->state_cond);
+    cond_signal(counter->state_cond);
-    // counter->thread_started and counter->thread are always accessed from the
+    // counter->thread is always accessed from the same thread, no need to lock
-    // same thread, no need to lock
+    if (!counter->thread) {
-    if (!counter->thread_started) {
+        counter->thread =
-        bool ok = sc_thread_create(&counter->thread, run_fps_counter,
+            SDL_CreateThread(run_fps_counter, "fps counter", counter);
-                                   "fps counter", counter);
+        if (!counter->thread) {
        if (!ok) {
            LOGE("Could not start FPS counter thread");
            return false;
        }
        counter->thread_started = true;
    }
    return true;
@@ -125,61 +114,57 @@ fps_counter_start(struct fps_counter *counter) {
 void
 fps_counter_stop(struct fps_counter *counter) {
-    set_started(counter, false);
+    SDL_AtomicSet(&counter->started, 0);
-    sc_cond_signal(&counter->state_cond);
+    cond_signal(counter->state_cond);
 }
 bool
 fps_counter_is_started(struct fps_counter *counter) {
-    return is_started(counter);
+    return SDL_AtomicGet(&counter->started);
 }
 void
 fps_counter_interrupt(struct fps_counter *counter) {
-    if (!counter->thread_started) {
+    if (!counter->thread) {
        return;
    }
-    sc_mutex_lock(&counter->mutex);
+    mutex_lock(counter->mutex);
    counter->interrupted = true;
-    sc_mutex_unlock(&counter->mutex);
+    mutex_unlock(counter->mutex);
    // wake up blocking wait
-    sc_cond_signal(&counter->state_cond);
+    cond_signal(counter->state_cond);
 }
 void
 fps_counter_join(struct fps_counter *counter) {
-    if (counter->thread_started) {
+    if (counter->thread) {
-        // interrupted must be set by the thread calling join(), so no need to
+        SDL_WaitThread(counter->thread, NULL);
        // lock for the assertion
        assert(counter->interrupted);
        sc_thread_join(&counter->thread, NULL);
    }
 }
 void
 fps_counter_add_rendered_frame(struct fps_counter *counter) {
-    if (!is_started(counter)) {
+    if (!SDL_AtomicGet(&counter->started)) {
        return;
    }
-    sc_mutex_lock(&counter->mutex);
+    mutex_lock(counter->mutex);
    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_rendered;
-    sc_mutex_unlock(&counter->mutex);
+    mutex_unlock(counter->mutex);
 }
 void
 fps_counter_add_skipped_frame(struct fps_counter *counter) {
-    if (!is_started(counter)) {
+    if (!SDL_AtomicGet(&counter->started)) {
        return;
    }
-    sc_mutex_lock(&counter->mutex);
+    mutex_lock(counter->mutex);
    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_skipped;
-    sc_mutex_unlock(&counter->mutex);
+    mutex_unlock(counter->mutex);
 }
--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@@ -1,24 +1,22 @@
 #ifndef FPSCOUNTER_H
 #define FPSCOUNTER_H
 #include "common.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>
-#include "util/thread.h"
+#include "config.h"
 struct fps_counter {
-    sc_thread thread;
+    SDL_Thread *thread;
-    sc_mutex mutex;
+    SDL_mutex *mutex;
-    sc_cond state_cond;
+    SDL_cond *state_cond;
    bool thread_started;
    // 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,87 +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/log.h"
+#include "lock_util.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, struct controller *controller,
                   struct screen *screen,
                   const struct scrcpy_options *options) {
    im->controller = controller;
    im->screen = screen;
    im->repeat = 0;
    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;
    im->last_keycode = SDLK_UNKNOWN;
    im->last_mod = 0;
    im->key_repeat = 0;
 }
 static void
 send_keycode(struct controller *controller, enum android_keycode keycode,
             int actions, const char *name) {
@@ -90,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;
@@ -143,36 +97,14 @@ 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
 // If the screen is off, it is turned on only on ACTION_DOWN
 static void
-press_back_or_turn_screen_on(struct controller *controller, int actions) {
+press_back_or_turn_screen_on(struct controller *controller) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
-    if (actions & ACTION_DOWN) {
+    if (!controller_push_msg(controller, &msg)) {
-        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_DOWN;
+        LOGW("Could not request 'press back or turn screen on'");
        if (!controller_push_msg(controller, &msg)) {
            LOGW("Could not request 'press back or turn screen on'");
            return;
        }
    }
    if (actions & ACTION_UP) {
        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_UP;
        if (!controller_push_msg(controller, &msg)) {
            LOGW("Could not request 'press back or turn screen on'");
        }
    }
 }
@@ -187,19 +119,9 @@ expand_notification_panel(struct controller *controller) {
 }
 static void
-expand_settings_panel(struct controller *controller) {
+collapse_notification_panel(struct controller *controller) {
    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
+    msg.type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL;
    if (!controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'expand settings panel'");
    }
 }
 static void
 collapse_panels(struct controller *controller) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_COLLAPSE_PANELS;
    if (!controller_push_msg(controller, &msg)) {
        LOGW("Could not request 'collapse notification panel'");
@@ -207,7 +129,17 @@ collapse_panels(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());
@@ -219,20 +151,12 @@ set_device_clipboard(struct controller *controller, bool paste) {
        return;
    }
    char *text_dup = strdup(text);
    SDL_free(text);
    if (!text_dup) {
        LOGW("Could not strdup input text");
        return;
    }
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
-    msg.set_clipboard.text = text_dup;
+    msg.set_clipboard.text = text;
    msg.set_clipboard.paste = paste;
    if (!controller_push_msg(controller, &msg)) {
-        free(text_dup);
+        SDL_free(text);
        LOGW("Could not request 'set device clipboard'");
    }
 }
@@ -278,55 +202,27 @@ clipboard_paste(struct controller *controller) {
        return;
    }
    char *text_dup = strdup(text);
    SDL_free(text);
    if (!text_dup) {
        LOGW("Could not strdup input text");
        return;
    }
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = text_dup;
+    msg.inject_text.text = text;
    if (!controller_push_msg(controller, &msg)) {
-        free(text_dup);
+        SDL_free(text);
        LOGW("Could not request 'paste clipboard'");
    }
 }
-static void
+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);
 }
 static void
 input_manager_process_text_input(struct input_manager *im,
                                 const SDL_TextInputEvent *event) {
-    if (is_shortcut_mod(im, SDL_GetModState())) {
+    if (im->text_events_pref == PREFER_TEXT_EVENTS_NEVER) {
-        // A shortcut must never generate text events
+        // ignore all text events (key events will be injected instead)
        return;
    }
-    if (!im->prefer_text) {
+
    if (im->text_events_pref == PREFER_TEXT_EVENTS_NON_ALPHA) {
        char c = event->text[0];
        if (isalpha(c) || c == ' ') {
-            assert(event->text[1] == '\0');
+            SDL_assert(event->text[1] == '\0');
            // letters and space are handled as raw key event
            return;
        }
@@ -334,50 +230,20 @@ input_manager_process_text_input(struct input_manager *im,
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = strdup(event->text);
+    msg.inject_text.text = SDL_strdup(event->text);
    if (!msg.inject_text.text) {
        LOGW("Could not strdup input text");
        return;
    }
    if (!controller_push_msg(im->controller, &msg)) {
-        free(msg.inject_text.text);
+        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) {
+                  enum text_events_pref pref) {
    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
@@ -386,160 +252,147 @@ convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
    uint16_t mod = from->keysym.mod;
    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod,
-                         prefer_text)) {
+                         pref)) {
        return false;
    }
    to->inject_keycode.repeat = repeat;
    to->inject_keycode.metastate = convert_meta_state(mod);
    return true;
 }
-static void
+void
 input_manager_process_key(struct input_manager *im,
-                          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 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);
    // 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
    if (alt) {
        // no shortcuts involve Alt, and it must not be forwarded to the device
        return;
    }
    struct controller *controller = im->controller;
-    SDL_Keycode keycode = event->keysym.sym;
+    // capture all Ctrl events
-    uint16_t mod = event->keysym.mod;
+    if (ctrl || cmd) {
-    bool down = event->type == SDL_KEYDOWN;
+        SDL_Keycode keycode = event->keysym.sym;
-    bool ctrl = event->keysym.mod & KMOD_CTRL;
+        bool down = event->type == SDL_KEYDOWN;
    bool shift = event->keysym.mod & KMOD_SHIFT;
    bool repeat = event->repeat;
    bool smod = is_shortcut_mod(im, mod);
    if (down && !repeat) {
        if (keycode == im->last_keycode && mod == im->last_mod) {
            ++im->key_repeat;
        } else {
            im->key_repeat = 0;
            im->last_keycode = keycode;
            im->last_mod = mod;
        }
    }
    // The shortcut modifier is pressed
    if (smod) {
        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);
                }
                return;
-            case SDLK_w:
+            case SDLK_x:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    screen_resize_to_fit(im->screen);
                }
                return;
            case SDLK_g:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    screen_resize_to_pixel_perfect(im->screen);
                }
                return;
            case SDLK_i:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
-                    switch_fps_counter_state(&im->screen->fps_counter);
+                    struct fps_counter *fps_counter =
                        im->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_panels(controller);
+                        collapse_notification_panel(controller);
                    } else if (im->key_repeat == 0) {
                        expand_notification_panel(controller);
                    } else {
-                        expand_settings_panel(controller);
+                        expand_notification_panel(controller);
                    }
                }
                return;
            case SDLK_r:
                if (control && !shift && !repeat && down) {
                    rotate_device(controller);
                }
                return;
        }
        return;
@@ -549,28 +402,8 @@ 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, im->text_events_pref)) {
        if (!controller_push_msg(controller, &msg)) {
            LOGW("Could not request 'inject keycode'");
        }
@@ -584,15 +417,15 @@ convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
    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 =
+    to->inject_touch_event.position.point.x = from->x;
-        screen_convert_window_to_frame_coords(screen, from->x, from->y);
+    to->inject_touch_event.position.point.y = from->y;
    to->inject_touch_event.pressure = 1.f;
    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
    return true;
 }
-static void
+void
 input_manager_process_mouse_motion(struct input_manager *im,
                                   const SDL_MouseMotionEvent *event) {
    if (!event->state) {
@@ -604,18 +437,10 @@ 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, im->screen, &msg)) {
-        return;
+        if (!controller_push_msg(im->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);
    }
 }
@@ -628,25 +453,19 @@ convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
        return false;
    }
    struct size frame_size = screen->frame_size;
    to->inject_touch_event.pointer_id = from->fingerId;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
+    to->inject_touch_event.position.screen_size = 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;
+    to->inject_touch_event.position.point.x = from->x * frame_size.width;
-    int32_t y = from->y * dh;
+    to->inject_touch_event.position.point.y = from->y * frame_size.height;
    to->inject_touch_event.position.point =
        screen_convert_drawable_to_frame_coords(screen, x, y);
    to->inject_touch_event.pressure = from->pressure;
    to->inject_touch_event.buttons = 0;
    return true;
 }
-static void
+void
 input_manager_process_touch(struct input_manager *im,
                            const SDL_TouchFingerEvent *event) {
    struct control_msg msg;
@@ -657,6 +476,13 @@ input_manager_process_touch(struct input_manager *im,
    }
 }
 static bool
 is_outside_device_screen(struct input_manager *im, int x, int y)
 {
    return x < 0 || x >= im->screen->frame_size.width ||
           y < 0 || y >= im->screen->frame_size.height;
 }
 static bool
 convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
                     struct control_msg *to) {
@@ -668,63 +494,38 @@ convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
    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 =
+    to->inject_touch_event.position.point.x = from->x;
-        screen_convert_window_to_frame_coords(screen, from->x, from->y);
+    to->inject_touch_event.position.point.y = from->y;
-    to->inject_touch_event.pressure =
+    to->inject_touch_event.pressure = 1.f;
        from->type == SDL_MOUSEBUTTONDOWN ? 1.f : 0.f;
    to->inject_touch_event.buttons =
        convert_mouse_buttons(SDL_BUTTON(from->button));
    return true;
 }
-static void
+void
 input_manager_process_mouse_button(struct input_manager *im,
-                                   const SDL_MouseButtonEvent *event) {
+                                   const SDL_MouseButtonEvent *event,
-    bool control = im->control;
+                                   bool control) {
    if (event->which == SDL_TOUCH_MOUSEID) {
        // simulated from touch events, so it's a duplicate
        return;
    }
-
+    if (event->type == SDL_MOUSEBUTTONDOWN) {
    bool down = event->type == SDL_MOUSEBUTTONDOWN;
    if (!im->forward_all_clicks) {
        int action = down ? ACTION_DOWN : ACTION_UP;
        if (control && event->button == SDL_BUTTON_X1) {
            action_app_switch(im->controller, action);
            return;
        }
        if (control && event->button == SDL_BUTTON_X2 && down) {
            if (event->clicks < 2) {
                expand_notification_panel(im->controller);
            } else {
                expand_settings_panel(im->controller);
            }
            return;
        }
        if (control && event->button == SDL_BUTTON_RIGHT) {
-            press_back_or_turn_screen_on(im->controller, action);
+            press_back_or_turn_screen_on(im->controller);
            return;
        }
        if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, action);
+            action_home(im->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(im, 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) {
-                if (down) {
+                screen_resize_to_fit(im->screen);
                    screen_resize_to_fit(im->screen);
                }
                return;
            }
        }
@@ -736,64 +537,36 @@ 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, im->screen, &msg)) {
-        return;
+        if (!controller_push_msg(im->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,
+        .point = get_mouse_point(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;
+    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;
 }
-static void
+void
 input_manager_process_mouse_wheel(struct input_manager *im,
                                  const SDL_MouseWheelEvent *event) {
    struct control_msg msg;
@@ -803,46 +576,3 @@ input_manager_process_mouse_wheel(struct input_manager *im,
        }
    }
 }
 bool
 input_manager_handle_event(struct input_manager *im, SDL_Event *event) {
    switch (event->type) {
        case SDL_TEXTINPUT:
            if (!im->control) {
                return true;
            }
            input_manager_process_text_input(im, &event->text);
            return true;
        case SDL_KEYDOWN:
        case SDL_KEYUP:
            // some key events do not interact with the device, so process the
            // event even if control is disabled
            input_manager_process_key(im, &event->key);
            return true;
        case SDL_MOUSEMOTION:
            if (!im->control) {
                break;
            }
            input_manager_process_mouse_motion(im, &event->motion);
            return true;
        case SDL_MOUSEWHEEL:
            if (!im->control) {
                break;
            }
            input_manager_process_mouse_wheel(im, &event->wheel);
            return true;
        case SDL_MOUSEBUTTONDOWN:
        case SDL_MOUSEBUTTONUP:
            // some mouse events do not interact with the device, so process
            // the event even if control is disabled
            input_manager_process_mouse_button(im, &event->button);
            return true;
        case SDL_FINGERMOTION:
        case SDL_FINGERDOWN:
        case SDL_FINGERUP:
            input_manager_process_touch(im, &event->tfinger);
            return true;
    }
    return false;
 }
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@@ -1,51 +1,52 @@
 #ifndef INPUTMANAGER_H
 #define INPUTMANAGER_H
 #include "common.h"
 #include <stdbool.h>
-#include <SDL2/SDL.h>
+#include "config.h"
-
+#include "common.h"
 #include "controller.h"
 #include "fps_counter.h"
-#include "scrcpy.h"
+#include "video_buffer.h"
 #include "screen.h"
 enum text_events_pref {
    PREFER_TEXT_EVENTS_ALWAYS,
    PREFER_TEXT_EVENTS_NON_ALPHA,
    PREFER_TEXT_EVENTS_NEVER,
 };
 struct input_manager {
    struct controller *controller;
    struct video_buffer *video_buffer;
    struct screen *screen;
-
+    enum text_events_pref text_events_pref;
    // 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;
    // Tracks the number of identical consecutive shortcut key down events.
    // Not to be confused with event->repeat, which counts the number of
    // system-generated repeated key presses.
    unsigned key_repeat;
    SDL_Keycode last_keycode;
    uint16_t last_mod;
 };
 void
-input_manager_init(struct input_manager *im, struct controller *controller,
+input_manager_process_text_input(struct input_manager *im,
-                   struct screen *screen, const struct scrcpy_options *options);
+                                 const SDL_TextInputEvent *event);
-bool
+void
-input_manager_handle_event(struct input_manager *im, SDL_Event *event);
+input_manager_process_key(struct input_manager *im,
                          const SDL_KeyboardEvent *event,
                          bool control);
 void
 input_manager_process_mouse_motion(struct input_manager *im,
                                   const SDL_MouseMotionEvent *event);
 void
 input_manager_process_touch(struct input_manager *im,
                            const SDL_TouchFingerEvent *event);
 void
 input_manager_process_mouse_button(struct input_manager *im,
                                   const SDL_MouseButtonEvent *event,
                                   bool control);
 void
 input_manager_process_mouse_wheel(struct input_manager *im,
                                  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,19 +1,189 @@
 #include "scrcpy.h"
-#include "common.h"
+#include <getopt.h>
 #include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <unistd.h>
 #include <libavformat/avformat.h>
 #ifdef HAVE_V4L2
 # include <libavdevice/avdevice.h>
 #endif
 #define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
 #include <SDL2/SDL.h>
-#include "cli.h"
+#include "config.h"
-#include "util/log.h"
+#include "compat.h"
 #include "log.h"
 #include "input_manager.h"
 #include "recorder.h"
 struct args {
    struct scrcpy_options opts;
    bool help;
    bool version;
 };
 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 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"
        "    --prefer-text-events mode\n"
        "        Configure how key/text events are forwarded to the Android\n"
        "        device.\n"
        "        Possible values are:\n"
        "          always:\n"
        "            Every text is sent as text. (default)\n"
        "          non-alpha:\n"
        "            Only letters are sent as a sequence of key events, other\n"
        "            characters are sent as text.\n"
        "          never:\n"
        "            Every text is sent as a sequence of key events.\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) {
@@ -31,30 +201,286 @@ print_version(void) {
    fprintf(stderr, " - libavutil %d.%d.%d\n", LIBAVUTIL_VERSION_MAJOR,
                                               LIBAVUTIL_VERSION_MINOR,
                                               LIBAVUTIL_VERSION_MICRO);
 #ifdef HAVE_V4L2
    fprintf(stderr, " - libavdevice %d.%d.%d\n", LIBAVDEVICE_VERSION_MAJOR,
                                                 LIBAVDEVICE_VERSION_MINOR,
                                                 LIBAVDEVICE_VERSION_MICRO);
 #endif
 }
-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;
 }
 static bool
 parse_prefer_text_events(const char *optarg,
                         enum text_events_pref *pref) {
    if (!strcmp(optarg, "always")) {
        *pref = PREFER_TEXT_EVENTS_ALWAYS;
        return true;
    }
    if (!strcmp(optarg, "non-alpha")) {
        *pref = PREFER_TEXT_EVENTS_NON_ALPHA;
        return true;
    }
    if (!strcmp(optarg, "never")) {
        *pref = PREFER_TEXT_EVENTS_NEVER;
        return true;
    }
    LOGE("Unsupported text events preference: %s"
         "(expected 'always', 'non-alpha' or 'never')", optarg);
    return false;
 }
 #define OPT_RENDER_EXPIRED_FRAMES 1000
 #define OPT_WINDOW_TITLE          1001
 #define OPT_PUSH_TARGET           1002
 #define OPT_PREFER_TEXT_EVENTS    1003
 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'},
        {"prefer-text-events",    required_argument, NULL,
                                                 OPT_PREFER_TEXT_EVENTS},
        {"version",               no_argument,       NULL, 'v'},
        {"window-title",          required_argument, NULL,
                                                 OPT_WINDOW_TITLE},
        {NULL,                    0,                 NULL, 0  },
    };
    struct scrcpy_options *opts = &args->opts;
    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, &opts->bit_rate)) {
                    return false;
                }
                break;
            case 'c':
                opts->crop = optarg;
                break;
            case 'f':
                opts->fullscreen = true;
                break;
            case 'F':
                if (!parse_record_format(optarg, &opts->record_format)) {
                    return false;
                }
                break;
            case 'h':
                args->help = true;
                break;
            case 'm':
                if (!parse_max_size(optarg, &opts->max_size)) {
                    return false;
                }
                break;
            case 'n':
                opts->control = false;
                break;
            case 'N':
                opts->display = false;
                break;
            case 'p':
                if (!parse_port(optarg, &opts->port)) {
                    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':
                opts->always_on_top = true;
                break;
            case 'v':
                args->version = true;
                break;
            case OPT_RENDER_EXPIRED_FRAMES:
                opts->render_expired_frames = true;
                break;
            case OPT_WINDOW_TITLE:
                opts->window_title = optarg;
                break;
            case OPT_PUSH_TARGET:
                opts->push_target = optarg;
                break;
            case OPT_PREFER_TEXT_EVENTS:
                if (!parse_prefer_text_events(optarg,
                                              &opts->text_events_pref)) {
                    return false;
                }
                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;
    }
    if (!opts->display && opts->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 (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;
    }
    return true;
 }
 int
 main(int argc, char *argv[]) {
@@ -64,26 +490,18 @@ main(int argc, char *argv[]) {
    setbuf(stdout, NULL);
    setbuf(stderr, NULL);
 #endif
-
+    struct args args = {
    struct scrcpy_cli_args args = {
        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
-#ifndef NDEBUG
+    if (!parse_args(&args, argc, argv)) {
    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;
    }
@@ -98,19 +516,23 @@ main(int argc, char *argv[]) {
    av_register_all();
 #endif
 #ifdef HAVE_V4L2
    if (args.opts.v4l2_device) {
        avdevice_register_all();
    }
 #endif
    if (avformat_network_init()) {
        return 1;
    }
 #ifdef BUILD_DEBUG
    SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
 #endif
    int res = scrcpy(&args.opts) ? 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,8 +1,8 @@
 #include "net.h"
 #include <stdio.h>
 #include <SDL2/SDL_platform.h>
 #include "config.h"
 #include "log.h"
 #ifdef __WINDOWS__
@@ -115,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
@@ -1,8 +1,6 @@
 #ifndef NET_H
 #define NET_H
 #include "common.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <SDL2/SDL_platform.h>
@@ -19,6 +17,8 @@
  typedef int socket_t;
 #endif
 #include "config.h"
 bool
 net_init(void);
--- 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 "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL_opengl.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,11 +2,11 @@
 #ifndef QUEUE_H
 #define QUEUE_H
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <SDL2/SDL_assert.h>
 #include "config.h"
 // To define a queue type of "struct foo":
 //    struct queue_foo QUEUE(struct foo);
@@ -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,15 +1,16 @@
 #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/log.h"
+#include "lock_util.h"
 #include "log.h"
 bool
 receiver_init(struct receiver *receiver, socket_t control_socket) {
-    bool ok = sc_mutex_init(&receiver->mutex);
+    if (!(receiver->mutex = SDL_CreateMutex())) {
    if (!ok) {
        return false;
    }
    receiver->control_socket = control_socket;
@@ -18,30 +19,21 @@ receiver_init(struct receiver *receiver, socket_t control_socket) {
 void
 receiver_destroy(struct receiver *receiver) {
-    sc_mutex_destroy(&receiver->mutex);
+    SDL_DestroyMutex(receiver->mutex);
 }
 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;
@@ -53,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;
        }
@@ -68,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;
        }
    }
@@ -101,9 +92,8 @@ bool
 receiver_start(struct receiver *receiver) {
    LOGD("Starting receiver thread");
-    bool ok = sc_thread_create(&receiver->thread, run_receiver, "receiver",
+    receiver->thread = SDL_CreateThread(run_receiver, "receiver", receiver);
-                               receiver);
+    if (!receiver->thread) {
    if (!ok) {
        LOGC("Could not start receiver thread");
        return false;
    }
@@ -113,5 +103,5 @@ receiver_start(struct receiver *receiver) {
 void
 receiver_join(struct receiver *receiver) {
-    sc_thread_join(&receiver->thread, NULL);
+    SDL_WaitThread(receiver->thread, NULL);
 }
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@@ -1,19 +1,19 @@
 #ifndef RECEIVER_H
 #define RECEIVER_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
-#include "util/net.h"
+#include "config.h"
-#include "util/thread.h"
+#include "net.h"
 // receive events from the device
 // managed by the controller
 struct receiver {
    socket_t control_socket;
-    sc_thread thread;
+    SDL_Thread *thread;
-    sc_mutex mutex;
+    SDL_mutex *mutex;
 };
 bool
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@@ -1,13 +1,12 @@
 #include "recorder.h"
 #include <assert.h>
 #include <libavutil/time.h>
 #include <SDL2/SDL_assert.h>
-#include "util/log.h"
+#include "config.h"
-#include "util/str_util.h"
+#include "compat.h"
-
+#include "lock_util.h"
-/** Downcast packet_sink to recorder */
+#include "log.h"
 #define DOWNCAST(SINK) container_of(SINK, struct recorder, packet_sink)
 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
@@ -23,27 +22,24 @@ find_muxer(const char *name) {
 #else
        oformat = av_oformat_next(oformat);
 #endif
-        // until null or containing the requested name
+        // until null or with name "mp4"
-    } while (oformat && !strlist_contains(oformat->name, ',', name));
+    } while (oformat && strcmp(oformat->name, name));
    return oformat;
 }
 static struct record_packet *
 record_packet_new(const AVPacket *packet) {
-    struct record_packet *rec = malloc(sizeof(*rec));
+    struct record_packet *rec = SDL_malloc(sizeof(*rec));
    if (!rec) {
        return NULL;
    }
-    rec->packet = av_packet_alloc();
+    // av_packet_ref() does not initialize all fields in old FFmpeg versions
-    if (!rec->packet) {
+    // See <https://github.com/Genymobile/scrcpy/issues/707>
-        free(rec);
+    av_init_packet(&rec->packet);
        return NULL;
    }
-    if (av_packet_ref(rec->packet, packet)) {
+    if (av_packet_ref(&rec->packet, packet)) {
-        av_packet_free(&rec->packet);
+        SDL_free(rec);
        free(rec);
        return NULL;
    }
    return rec;
@@ -51,9 +47,8 @@ record_packet_new(const AVPacket *packet) {
 static void
 record_packet_delete(struct record_packet *rec) {
-    av_packet_unref(rec->packet);
+    av_packet_unref(&rec->packet);
-    av_packet_free(&rec->packet);
+    SDL_free(rec);
    free(rec);
 }
 static void
@@ -65,15 +60,136 @@ recorder_queue_clear(struct recorder_queue *queue) {
    }
 }
 bool
 recorder_init(struct recorder *recorder,
              const char *filename,
              enum recorder_format format,
              struct size declared_frame_size) {
    recorder->filename = SDL_strdup(filename);
    if (!recorder->filename) {
        LOGE("Could not strdup filename");
        return false;
    }
    recorder->mutex = SDL_CreateMutex();
    if (!recorder->mutex) {
        LOGC("Could not create mutex");
        SDL_free(recorder->filename);
        return false;
    }
    recorder->queue_cond = SDL_CreateCond();
    if (!recorder->queue_cond) {
        LOGC("Could not create cond");
        SDL_DestroyMutex(recorder->mutex);
        SDL_free(recorder->filename);
        return false;
    }
    queue_init(&recorder->queue);
    recorder->stopped = false;
    recorder->failed = false;
    recorder->format = format;
    recorder->declared_frame_size = declared_frame_size;
    recorder->header_written = false;
    recorder->previous = NULL;
    return true;
 }
 void
 recorder_destroy(struct recorder *recorder) {
    SDL_DestroyCond(recorder->queue_cond);
    SDL_DestroyMutex(recorder->mutex);
    SDL_free(recorder->filename);
 }
 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;
    }
 }
 bool
 recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    const char *format_name = recorder_get_format_name(recorder->format);
    SDL_assert(format_name);
    const AVOutputFormat *format = find_muxer(format_name);
    if (!format) {
        LOGE("Could not find muxer");
        return false;
    }
    recorder->ctx = avformat_alloc_context();
    if (!recorder->ctx) {
        LOGE("Could not allocate output context");
        return false;
    }
    // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
    // returns (on purpose) a pointer-to-const, but AVFormatContext.oformat
    // still expects a pointer-to-non-const (it has not be updated accordingly)
    // <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);
        return false;
    }
 #ifdef SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_API
    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
    ostream->codecpar->codec_id = input_codec->id;
    ostream->codecpar->format = AV_PIX_FMT_YUV420P;
    ostream->codecpar->width = recorder->declared_frame_size.width;
    ostream->codecpar->height = recorder->declared_frame_size.height;
 #else
    ostream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
    ostream->codec->codec_id = input_codec->id;
    ostream->codec->pix_fmt = AV_PIX_FMT_YUV420P;
    ostream->codec->width = recorder->declared_frame_size.width;
    ostream->codec->height = recorder->declared_frame_size.height;
 #endif
    int ret = avio_open(&recorder->ctx->pb, recorder->filename,
                        AVIO_FLAG_WRITE);
    if (ret < 0) {
        LOGE("Failed to open output file: %s", recorder->filename);
        // ostream will be cleaned up during context cleaning
        avformat_free_context(recorder->ctx);
        return false;
    }
    LOGI("Recording started to %s file: %s", format_name, recorder->filename);
    return true;
 }
 void
 recorder_close(struct recorder *recorder) {
    int ret = av_write_trailer(recorder->ctx);
    if (ret < 0) {
        LOGE("Failed to write trailer to %s", recorder->filename);
        recorder->failed = true;
    }
    avio_close(recorder->ctx->pb);
    avformat_free_context(recorder->ctx);
    if (recorder->failed) {
        LOGE("Recording failed to %s", recorder->filename);
    } else {
        const char *format_name = recorder_get_format_name(recorder->format);
        LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
    }
 }
 static bool
 recorder_write_header(struct recorder *recorder, const AVPacket *packet) {
    AVStream *ostream = recorder->ctx->streams[0];
@@ -87,8 +203,13 @@ recorder_write_header(struct recorder *recorder, const AVPacket *packet) {
    // copy the first packet to the extra data
    memcpy(extradata, packet->data, packet->size);
 #ifdef SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_API
    ostream->codecpar->extradata = extradata;
    ostream->codecpar->extradata_size = packet->size;
 #else
    ostream->codec->extradata = extradata;
    ostream->codec->extradata_size = packet->size;
 #endif
    int ret = avformat_write_header(recorder->ctx, NULL);
    if (ret < 0) {
@@ -105,7 +226,7 @@ recorder_rescale_packet(struct recorder *recorder, AVPacket *packet) {
    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
 }
-static bool
+bool
 recorder_write(struct recorder *recorder, AVPacket *packet) {
    if (!recorder->header_written) {
        if (packet->pts != AV_NOPTS_VALUE) {
@@ -134,22 +255,22 @@ run_recorder(void *data) {
    struct recorder *recorder = data;
    for (;;) {
-        sc_mutex_lock(&recorder->mutex);
+        mutex_lock(recorder->mutex);
        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
-            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
+            cond_wait(recorder->queue_cond, recorder->mutex);
        }
        // if stopped is set, continue to process the remaining events (to
        // finish the recording) before actually stopping
        if (recorder->stopped && queue_is_empty(&recorder->queue)) {
-            sc_mutex_unlock(&recorder->mutex);
+            mutex_unlock(recorder->mutex);
            struct record_packet *last = recorder->previous;
            if (last) {
                // assign an arbitrary duration to the last packet
-                last->packet->duration = 100000;
+                last->packet.duration = 100000;
-                bool ok = recorder_write(recorder, last->packet);
+                bool ok = recorder_write(recorder, &last->packet);
                if (!ok) {
                    // failing to write the last frame is not very serious, no
                    // future frame may depend on it, so the resulting file
@@ -164,7 +285,7 @@ run_recorder(void *data) {
        struct record_packet *rec;
        queue_take(&recorder->queue, next, &rec);
-        sc_mutex_unlock(&recorder->mutex);
+        mutex_unlock(recorder->mutex);
        // recorder->previous is only written from this thread, no need to lock
        struct record_packet *previous = recorder->previous;
@@ -175,46 +296,22 @@ 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);
+        bool ok = recorder_write(recorder, &previous->packet);
        record_packet_delete(previous);
        if (!ok) {
            LOGE("Could not record packet");
-            sc_mutex_lock(&recorder->mutex);
+            mutex_lock(recorder->mutex);
            recorder->failed = true;
            // discard pending packets
            recorder_queue_clear(&recorder->queue);
-            sc_mutex_unlock(&recorder->mutex);
+            mutex_unlock(recorder->mutex);
            break;
        }
    }
    if (!recorder->failed) {
        if (recorder->header_written) {
            int ret = av_write_trailer(recorder->ctx);
            if (ret < 0) {
                LOGE("Failed to write trailer to %s", recorder->filename);
                recorder->failed = true;
            }
        } else {
            // the recorded file is empty
            recorder->failed = true;
        }
    }
    if (recorder->failed) {
        LOGE("Recording failed to %s", recorder->filename);
    } else {
        const char *format_name = recorder_get_format_name(recorder->format);
        LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
    }
    LOGD("Recorder thread ended");
@@ -222,176 +319,51 @@ run_recorder(void *data) {
    return 0;
 }
-static bool
+bool
-recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
+recorder_start(struct recorder *recorder) {
-    bool ok = sc_mutex_init(&recorder->mutex);
+    LOGD("Starting recorder thread");
-    if (!ok) {
+
-        LOGC("Could not create mutex");
+    recorder->thread = SDL_CreateThread(run_recorder, "recorder", recorder);
    if (!recorder->thread) {
        LOGC("Could not start recorder thread");
        return false;
    }
    ok = sc_cond_init(&recorder->queue_cond);
    if (!ok) {
        LOGC("Could not create cond");
        goto error_mutex_destroy;
    }
    queue_init(&recorder->queue);
    recorder->stopped = false;
    recorder->failed = false;
    recorder->header_written = false;
    recorder->previous = NULL;
    const char *format_name = recorder_get_format_name(recorder->format);
    assert(format_name);
    const AVOutputFormat *format = find_muxer(format_name);
    if (!format) {
        LOGE("Could not find muxer");
        goto error_cond_destroy;
    }
    recorder->ctx = avformat_alloc_context();
    if (!recorder->ctx) {
        LOGE("Could not allocate output context");
        goto error_cond_destroy;
    }
    // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
    // returns (on purpose) a pointer-to-const, but AVFormatContext.oformat
    // still expects a pointer-to-non-const (it has not be updated accordingly)
    // <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) {
        goto error_avformat_free_context;
    }
    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
    ostream->codecpar->codec_id = input_codec->id;
    ostream->codecpar->format = AV_PIX_FMT_YUV420P;
    ostream->codecpar->width = recorder->declared_frame_size.width;
    ostream->codecpar->height = recorder->declared_frame_size.height;
    int ret = avio_open(&recorder->ctx->pb, recorder->filename,
                        AVIO_FLAG_WRITE);
    if (ret < 0) {
        LOGE("Failed to open output file: %s", recorder->filename);
        // ostream will be cleaned up during context cleaning
        goto error_avformat_free_context;
    }
    LOGD("Starting recorder thread");
    ok = sc_thread_create(&recorder->thread, run_recorder, "recorder",
                               recorder);
    if (!ok) {
        LOGC("Could not start recorder thread");
        goto error_avio_close;
    }
    LOGI("Recording started to %s file: %s", format_name, recorder->filename);
    return true;
 error_avio_close:
    avio_close(recorder->ctx->pb);
 error_avformat_free_context:
    avformat_free_context(recorder->ctx);
 error_cond_destroy:
    sc_cond_destroy(&recorder->queue_cond);
 error_mutex_destroy:
    sc_mutex_destroy(&recorder->mutex);
    return false;
 }
-static void
+void
-recorder_close(struct recorder *recorder) {
+recorder_stop(struct recorder *recorder) {
-    sc_mutex_lock(&recorder->mutex);
+    mutex_lock(recorder->mutex);
    recorder->stopped = true;
-    sc_cond_signal(&recorder->queue_cond);
+    cond_signal(recorder->queue_cond);
-    sc_mutex_unlock(&recorder->mutex);
+    mutex_unlock(recorder->mutex);
    sc_thread_join(&recorder->thread, NULL);
    avio_close(recorder->ctx->pb);
    avformat_free_context(recorder->ctx);
    sc_cond_destroy(&recorder->queue_cond);
    sc_mutex_destroy(&recorder->mutex);
 }
-static bool
+void
 recorder_join(struct recorder *recorder) {
    SDL_WaitThread(recorder->thread, NULL);
 }
 bool
 recorder_push(struct recorder *recorder, const AVPacket *packet) {
-    sc_mutex_lock(&recorder->mutex);
+    mutex_lock(recorder->mutex);
-    assert(!recorder->stopped);
+    SDL_assert(!recorder->stopped);
    if (recorder->failed) {
        // reject any new packet (this will stop the stream)
        sc_mutex_unlock(&recorder->mutex);
        return false;
    }
    struct record_packet *rec = record_packet_new(packet);
    if (!rec) {
        LOGC("Could not allocate record packet");
        sc_mutex_unlock(&recorder->mutex);
        return false;
    }
    queue_push(&recorder->queue, next, rec);
-    sc_cond_signal(&recorder->queue_cond);
+    cond_signal(recorder->queue_cond);
-    sc_mutex_unlock(&recorder->mutex);
+    mutex_unlock(recorder->mutex);
    return true;
 }
 static bool
 recorder_packet_sink_open(struct sc_packet_sink *sink, const AVCodec *codec) {
    struct recorder *recorder = DOWNCAST(sink);
    return recorder_open(recorder, codec);
 }
 static void
 recorder_packet_sink_close(struct sc_packet_sink *sink) {
    struct recorder *recorder = DOWNCAST(sink);
    recorder_close(recorder);
 }
 static bool
 recorder_packet_sink_push(struct sc_packet_sink *sink, const AVPacket *packet) {
    struct recorder *recorder = DOWNCAST(sink);
    return recorder_push(recorder, packet);
 }
 bool
 recorder_init(struct recorder *recorder,
              const char *filename,
              enum sc_record_format format,
              struct size declared_frame_size) {
    recorder->filename = strdup(filename);
    if (!recorder->filename) {
        LOGE("Could not strdup filename");
        return false;
    }
    recorder->format = format;
    recorder->declared_frame_size = declared_frame_size;
    static const struct sc_packet_sink_ops ops = {
        .open = recorder_packet_sink_open,
        .close = recorder_packet_sink_close,
        .push = recorder_packet_sink_push,
    };
    recorder->packet_sink.ops = &ops;
    return true;
 }
 void
 recorder_destroy(struct recorder *recorder) {
    free(recorder->filename);
 }
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@@ -1,37 +1,39 @@
 #ifndef RECORDER_H
 #define RECORDER_H
 #include "common.h"
 #include <stdbool.h>
 #include <libavformat/avformat.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
-#include "coords.h"
+#include "config.h"
-#include "scrcpy.h"
+#include "common.h"
-#include "trait/packet_sink.h"
+#include "queue.h"
-#include "util/queue.h"
+
-#include "util/thread.h"
+enum recorder_format {
    RECORDER_FORMAT_AUTO,
    RECORDER_FORMAT_MP4,
    RECORDER_FORMAT_MKV,
 };
 struct record_packet {
-    AVPacket *packet;
+    AVPacket packet;
    struct record_packet *next;
 };
 struct recorder_queue QUEUE(struct record_packet);
 struct recorder {
    struct sc_packet_sink packet_sink; // packet sink trait
    char *filename;
-    enum sc_record_format format;
+    enum recorder_format format;
    AVFormatContext *ctx;
    struct size declared_frame_size;
    bool header_written;
-    sc_thread thread;
+    SDL_Thread *thread;
-    sc_mutex mutex;
+    SDL_mutex *mutex;
-    sc_cond queue_cond;
+    SDL_cond *queue_cond;
-    bool stopped; // set on recorder_close()
+    bool stopped; // set on recorder_stop() by the stream reader
    bool failed; // set on packet write failure
    struct recorder_queue queue;
@@ -44,9 +46,27 @@ 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);
 bool
 recorder_open(struct recorder *recorder, const AVCodec *input_codec);
 void
 recorder_close(struct recorder *recorder);
 bool
 recorder_start(struct recorder *recorder);
 void
 recorder_stop(struct recorder *recorder);
 void
 recorder_join(struct recorder *recorder);
 bool
 recorder_push(struct recorder *recorder, const AVPacket *packet);
 #endif
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -7,58 +7,47 @@
 #include <sys/time.h>
 #include <SDL2/SDL.h>
-#ifdef _WIN32
+#include "config.h"
-// not needed here, but winsock2.h must never be included AFTER windows.h
+#include "command.h"
-# include <winsock2.h>
+#include "common.h"
-# include <windows.h>
+#include "compat.h"
 #endif
 #include "controller.h"
 #include "decoder.h"
 #include "device.h"
 #include "events.h"
 #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 "util/log.h"
+#include "video_buffer.h"
 #include "util/net.h"
 #ifdef HAVE_V4L2
 # include "v4l2_sink.h"
 #endif
-struct scrcpy {
+static struct server server = SERVER_INITIALIZER;
-    struct server server;
+static struct screen screen = SCREEN_INITIALIZER;
-    struct screen screen;
+static struct fps_counter fps_counter;
-    struct stream stream;
+static struct video_buffer video_buffer;
-    struct decoder decoder;
+static struct stream stream;
-    struct recorder recorder;
+static struct decoder decoder;
-#ifdef HAVE_V4L2
+static struct recorder recorder;
-    struct sc_v4l2_sink v4l2_sink;
+static struct controller controller;
-#endif
+static struct file_handler file_handler;
-    struct controller controller;
+
-    struct file_handler file_handler;
+static struct input_manager input_manager = {
-    struct input_manager input_manager;
+    .controller = &controller,
    .video_buffer = &video_buffer,
    .screen = &screen,
    .text_events_pref = 0, // initialized later
 };
 #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());
@@ -67,25 +56,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
@@ -107,17 +84,34 @@ 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;
 }
 #if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
 // On Windows and MacOS, resizing blocks the event loop, so resizing events are
 // not triggered. As a workaround, handle them in an event handler.
 //
 // <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
 // <https://stackoverflow.com/a/40693139/1987178>
 static int
 event_watcher(void *data, SDL_Event *event) {
    if (event->type == SDL_WINDOWEVENT
            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
        // called from another thread, not very safe, but it's a workaround!
        screen_render(&screen);
    }
    return 0;
 }
 #endif
 static bool
 is_apk(const char *file) {
    const char *ext = strrchr(file, '.');
@@ -131,8 +125,7 @@ enum event_result {
 };
 static enum event_result
-handle_event(struct scrcpy *s, const struct scrcpy_options *options,
+handle_event(SDL_Event *event, bool control) {
             SDL_Event *event) {
    switch (event->type) {
        case EVENT_STREAM_STOPPED:
            LOGD("Video stream stopped");
@@ -140,50 +133,91 @@ handle_event(struct scrcpy *s, const struct scrcpy_options *options,
        case SDL_QUIT:
            LOGD("User requested to quit");
            return EVENT_RESULT_STOPPED_BY_USER;
        case EVENT_NEW_FRAME:
            if (!screen.has_frame) {
                screen.has_frame = true;
                // this is the very first frame, show the window
                screen_show_window(&screen);
            }
            if (!screen_update_frame(&screen, &video_buffer)) {
                return EVENT_RESULT_CONTINUE;
            }
            break;
        case SDL_WINDOWEVENT:
            switch (event->window.event) {
                case SDL_WINDOWEVENT_EXPOSED:
                case SDL_WINDOWEVENT_SIZE_CHANGED:
                    screen_render(&screen);
                    break;
            }
            break;
        case SDL_TEXTINPUT:
            if (!control) {
                break;
            }
            input_manager_process_text_input(&input_manager, &event->text);
            break;
        case SDL_KEYDOWN:
        case SDL_KEYUP:
            // some key events do not interact with the device, so process the
            // event even if control is disabled
            input_manager_process_key(&input_manager, &event->key, control);
            break;
        case SDL_MOUSEMOTION:
            if (!control) {
                break;
            }
            input_manager_process_mouse_motion(&input_manager, &event->motion);
            break;
        case SDL_MOUSEWHEEL:
            if (!control) {
                break;
            }
            input_manager_process_mouse_wheel(&input_manager, &event->wheel);
            break;
        case SDL_MOUSEBUTTONDOWN:
        case SDL_MOUSEBUTTONUP:
            // some mouse events do not interact with the device, so process
            // the event even if control is disabled
            input_manager_process_mouse_button(&input_manager, &event->button,
                                               control);
            break;
        case SDL_FINGERMOTION:
        case SDL_FINGERDOWN:
        case SDL_FINGERUP:
            input_manager_process_touch(&input_manager, &event->tfinger);
            break;
        case SDL_DROPFILE: {
-            if (!options->control) {
+            if (!control) {
                break;
            }
            char *file = strdup(event->drop.file);
            SDL_free(event->drop.file);
            if (!file) {
                LOGW("Could not strdup drop filename\n");
                break;
            }
            file_handler_action_t action;
-            if (is_apk(file)) {
+            if (is_apk(event->drop.file)) {
                action = ACTION_INSTALL_APK;
            } else {
                action = ACTION_PUSH_FILE;
            }
-            file_handler_request(&s->file_handler, action, file);
+            file_handler_request(&file_handler, action, event->drop.file);
-            goto end;
+            break;
        }
    }
    bool consumed = screen_handle_event(&s->screen, event);
    if (consumed) {
        goto end;
    }
    consumed = input_manager_handle_event(&s->input_manager, event);
    (void) consumed;
 end:
    return EVENT_RESULT_CONTINUE;
 }
 static bool
-event_loop(struct scrcpy *s, const struct scrcpy_options *options) {
+event_loop(bool display, bool control) {
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
    if (display) {
        SDL_AddEventWatch(event_watcher, NULL);
    }
 #endif
    SDL_Event event;
    while (SDL_WaitEvent(&event)) {
-        enum event_result result = handle_event(s, options, &event);
+        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;
@@ -192,6 +226,21 @@ event_loop(struct scrcpy *s, 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) {
@@ -211,12 +260,11 @@ 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;
    }
-    char *local_fmt = malloc(strlen(fmt) + 10);
+    char *local_fmt = SDL_malloc(strlen(fmt) + 10);
    if (!local_fmt) {
        LOGC("Could not allocate string");
        return;
@@ -225,131 +273,115 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
    strcpy(local_fmt, "[FFmpeg] ");
    strcpy(local_fmt + 9, fmt);
    SDL_LogMessageV(SDL_LOG_CATEGORY_VIDEO, priority, local_fmt, vl);
-    free(local_fmt);
+    SDL_free(local_fmt);
 }
 static void
 stream_on_eos(struct stream *stream, void *userdata) {
    (void) stream;
    (void) userdata;
    SDL_Event stop_event;
    stop_event.type = EVENT_STREAM_STOPPED;
    SDL_PushEvent(&stop_event);
 }
 bool
 scrcpy(const struct scrcpy_options *options) {
-    static struct scrcpy scrcpy;
+    bool record = !!options->record_filename;
-    struct scrcpy *s = &scrcpy;
+    struct server_params params = {
-
+        .crop = options->crop,
-    if (!server_init(&s->server)) {
+        .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;
    bool recorder_initialized = false;
 #ifdef HAVE_V4L2
    bool v4l2_sink_initialized = false;
 #endif
    bool stream_started = false;
    bool controller_initialized = false;
    bool controller_started = false;
    bool screen_initialized = false;
-    bool record = !!options->record_filename;
+    if (!sdl_init_and_configure(options->display)) {
    struct server_params params = {
        .serial = options->serial,
        .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,
        .power_off_on_close = options->power_off_on_close,
    };
    if (!server_start(&s->server, &params)) {
        goto end;
    }
-    server_started = true;
+    if (!server_connect_to(&server)) {
    if (!sdl_init_and_configure(options->display, options->render_driver,
                                options->disable_screensaver)) {
        goto end;
    }
    char device_name[DEVICE_NAME_FIELD_LENGTH];
    struct size frame_size;
-    if (!server_connect_to(&s->server, device_name, &frame_size)) {
+    // screenrecord does not send frames when the screen content does not
    // change therefore, we transmit the screen size before the video stream,
    // to be able to init the window immediately
    if (!device_read_info(server.video_socket, device_name, &frame_size)) {
        goto end;
    }
-    if (options->display && options->control) {
+    struct decoder *dec = NULL;
-        if (!file_handler_init(&s->file_handler, s->server.serial,
+    if (options->display) {
-                               options->push_target)) {
+        if (!fps_counter_init(&fps_counter)) {
            goto end;
        }
-        file_handler_initialized = true;
+        fps_counter_initialized = true;
    }
-    struct decoder *dec = NULL;
+        if (!video_buffer_init(&video_buffer, &fps_counter,
-    bool needs_decoder = options->display;
+                               options->render_expired_frames)) {
-#ifdef HAVE_V4L2
+            goto end;
-    needs_decoder |= !!options->v4l2_device;
+        }
-#endif
+        video_buffer_initialized = true;
-    if (needs_decoder) {
+
-        decoder_init(&s->decoder);
+        if (options->control) {
-        dec = &s->decoder;
+            if (!file_handler_init(&file_handler, server.serial,
                                   options->push_target)) {
                goto end;
            }
            file_handler_initialized = true;
        }
        decoder_init(&decoder, &video_buffer);
        dec = &decoder;
    }
    struct recorder *rec = NULL;
    if (record) {
-        if (!recorder_init(&s->recorder,
+        if (!recorder_init(&recorder,
                           options->record_filename,
                           options->record_format,
                           frame_size)) {
            goto end;
        }
-        rec = &s->recorder;
+        rec = &recorder;
        recorder_initialized = true;
    }
    av_log_set_callback(av_log_callback);
-    const struct stream_callbacks stream_cbs = {
+    stream_init(&stream, server.video_socket, dec, rec);
        .on_eos = stream_on_eos,
    };
    stream_init(&s->stream, s->server.video_socket, &stream_cbs, NULL);
-    if (dec) {
+    // now we consumed the header values, the socket receives the video stream
-        stream_add_sink(&s->stream, &dec->packet_sink);
+    // start the stream
-    }
+    if (!stream_start(&stream)) {
-
+        goto end;
    if (rec) {
        stream_add_sink(&s->stream, &rec->packet_sink);
    }
    stream_started = true;
    if (options->display) {
        if (options->control) {
-            if (!controller_init(&s->controller, s->server.control_socket)) {
+            if (!controller_init(&controller, server.control_socket)) {
                goto end;
            }
            controller_initialized = true;
-            if (!controller_start(&s->controller)) {
+            if (!controller_start(&controller)) {
                goto end;
            }
            controller_started = true;
@@ -358,120 +390,98 @@ scrcpy(const struct scrcpy_options *options) {
        const char *window_title =
            options->window_title ? options->window_title : device_name;
-        struct screen_params screen_params = {
+        if (!screen_init_rendering(&screen, window_title, frame_size,
-            .window_title = window_title,
+                                   options->always_on_top)) {
            .frame_size = frame_size,
            .always_on_top = options->always_on_top,
            .window_x = options->window_x,
            .window_y = options->window_y,
            .window_width = options->window_width,
            .window_height = options->window_height,
            .window_borderless = options->window_borderless,
            .rotation = options->rotation,
            .mipmaps = options->mipmaps,
            .fullscreen = options->fullscreen,
        };
        if (!screen_init(&s->screen, &screen_params)) {
            goto end;
        }
        screen_initialized = true;
        decoder_add_sink(&s->decoder, &s->screen.frame_sink);
        if (options->turn_screen_off) {
            struct control_msg msg;
            msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
            msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF;
-            if (!controller_push_msg(&s->controller, &msg)) {
+            if (!controller_push_msg(&controller, &msg)) {
                LOGW("Could not request 'set screen power mode'");
            }
        }
    }
-#ifdef HAVE_V4L2
+        if (options->fullscreen) {
-    if (options->v4l2_device) {
+            screen_switch_fullscreen(&screen);
        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device, frame_size)) {
            goto end;
        }
        decoder_add_sink(&s->decoder, &s->v4l2_sink.frame_sink);
        v4l2_sink_initialized = true;
    }
 #endif
-    // now we consumed the header values, the socket receives the video stream
+    if (options->show_touches) {
-    // start the stream
+        wait_show_touches(proc_show_touches);
-    if (!stream_start(&s->stream)) {
+        show_touches_waited = true;
        goto end;
    }
    stream_started = true;
-    input_manager_init(&s->input_manager, &s->controller, &s->screen, options);
+    input_manager.text_events_pref = options->text_events_pref;
-    ret = event_loop(s, options);
+    ret = event_loop(options->display, options->control);
    LOGD("quit...");
-    // Close the window immediately on closing, because screen_destroy() may
+    screen_destroy(&screen);
    // only be called once the stream thread is joined (it may take time)
    screen_hide_window(&s->screen);
 end:
-    // The stream is not stopped explicitly, because it will stop by itself on
+    // stop stream and controller so that they don't continue once their socket
-    // end-of-stream
+    // is shutdown
    if (stream_started) {
        stream_stop(&stream);
    }
    if (controller_started) {
-        controller_stop(&s->controller);
+        controller_stop(&controller);
    }
    if (file_handler_initialized) {
-        file_handler_stop(&s->file_handler);
+        file_handler_stop(&file_handler);
    }
-    if (screen_initialized) {
+    if (fps_counter_initialized) {
-        screen_interrupt(&s->screen);
+        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(&s->server);
    }
    // now that the sockets are shutdown, the stream and controller are
    // interrupted, we can join them
    if (stream_started) {
-        stream_join(&s->stream);
+        stream_join(&stream);
    }
 #ifdef HAVE_V4L2
    if (v4l2_sink_initialized) {
        sc_v4l2_sink_destroy(&s->v4l2_sink);
    }
 #endif
    // Destroy the screen only after the stream is guaranteed to be finished,
    // because otherwise the screen could receive new frames after destruction
    if (screen_initialized) {
        screen_join(&s->screen);
        screen_destroy(&s->screen);
    }
    if (controller_started) {
-        controller_join(&s->controller);
+        controller_join(&controller);
    }
    if (controller_initialized) {
-        controller_destroy(&s->controller);
+        controller_destroy(&controller);
    }
    if (recorder_initialized) {
-        recorder_destroy(&s->recorder);
+        recorder_destroy(&recorder);
    }
    if (file_handler_initialized) {
-        file_handler_join(&s->file_handler);
+        file_handler_join(&file_handler);
-        file_handler_destroy(&s->file_handler);
+        file_handler_destroy(&file_handler);
    }
-    server_destroy(&s->server);
+    if (video_buffer_initialized) {
        video_buffer_destroy(&video_buffer);
    }
    if (fps_counter_initialized) {
        fps_counter_join(&fps_counter);
        fps_counter_destroy(&fps_counter);
    }
    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
@@ -1,57 +1,12 @@
 #ifndef SCRCPY_H
 #define SCRCPY_H
 #include "common.h"
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
-enum sc_log_level {
+#include "config.h"
-    SC_LOG_LEVEL_DEBUG,
+#include "input_manager.h"
-    SC_LOG_LEVEL_INFO,
+#include "recorder.h"
    SC_LOG_LEVEL_WARN,
    SC_LOG_LEVEL_ERROR,
 };
 enum sc_record_format {
    SC_RECORD_FORMAT_AUTO,
    SC_RECORD_FORMAT_MP4,
    SC_RECORD_FORMAT_MKV,
 };
 enum sc_lock_video_orientation {
    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
    // lock the current orientation when scrcpy starts
    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
    SC_LOCK_VIDEO_ORIENTATION_1,
    SC_LOCK_VIDEO_ORIENTATION_2,
    SC_LOCK_VIDEO_ORIENTATION_3,
 };
 #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;
@@ -59,40 +14,18 @@ struct scrcpy_options {
    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;
+    enum text_events_pref text_events_pref;
-    const char *encoder_name;
+    uint16_t port;
    const char *v4l2_device;
    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;
    enum sc_lock_video_orientation lock_video_orientation;
    uint8_t rotation;
    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    uint16_t window_width;
    uint16_t window_height;
    uint32_t display_id;
    bool show_touches;
    bool fullscreen;
    bool always_on_top;
    bool control;
    bool display;
    bool turn_screen_off;
-    bool prefer_text;
+    bool render_expired_frames;
    bool window_borderless;
    bool mipmaps;
    bool stay_awake;
    bool force_adb_forward;
    bool disable_screensaver;
    bool forward_key_repeat;
    bool forward_all_clicks;
    bool legacy_paste;
    bool power_off_on_close;
 };
 #define SCRCPY_OPTIONS_DEFAULT { \
@@ -101,46 +34,18 @@ struct scrcpy_options {
    .record_filename = NULL, \
    .window_title = NULL, \
    .push_target = NULL, \
-    .render_driver = NULL, \
+    .record_format = RECORDER_FORMAT_AUTO, \
-    .codec_options = NULL, \
+    .text_events_pref = PREFER_TEXT_EVENTS_ALWAYS, \
-    .encoder_name = NULL, \
+    .port = DEFAULT_LOCAL_PORT, \
-    .v4l2_device = NULL, \
+    .max_size = DEFAULT_LOCAL_PORT, \
    .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 = 0, \
    .bit_rate = DEFAULT_BIT_RATE, \
    .max_fps = 0, \
    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED, \
    .rotation = 0, \
    .window_x = SC_WINDOW_POSITION_UNDEFINED, \
    .window_y = SC_WINDOW_POSITION_UNDEFINED, \
    .window_width = 0, \
    .window_height = 0, \
    .display_id = 0, \
    .show_touches = false, \
    .fullscreen = false, \
    .always_on_top = false, \
    .control = true, \
    .display = true, \
    .turn_screen_off = false, \
-    .prefer_text = false, \
+    .render_expired_frames = 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, \
    .power_off_on_close = false, \
 }
 bool
--- a/app/src/screen.c
+++ b/app/src/screen.c
@@ -1,39 +1,25 @@
 #include "screen.h"
 #include <assert.h>
 #include <string.h>
 #include <SDL2/SDL.h>
-#include "events.h"
+#include "config.h"
 #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/log.h"
 #define DISPLAY_MARGINS 96
 #define DOWNCAST(SINK) container_of(SINK, struct screen, frame_sink)
 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_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;
@@ -41,24 +27,26 @@ get_window_size(const struct screen *screen) {
    return size;
 }
-static struct point
+// get the windowed window size
-get_window_position(const struct screen *screen) {
+static struct size
-    int x;
+get_windowed_window_size(const struct screen *screen) {
-    int y;
+    if (screen->fullscreen) {
-    SDL_GetWindowPosition(screen->window, &x, &y);
+        return screen->windowed_window_size;
-
+    }
-    struct point point;
+    return get_window_size(screen->window);
    point.x = x;
    point.y = y;
    return point;
 }
 // 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)
@@ -80,257 +68,83 @@ 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 frame_size) {
    struct size windowed_size = get_windowed_window_size(screen);
    return get_optimal_size(windowed_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
+void
-screen_update_content_rect(struct screen *screen) {
+screen_init(struct screen *screen) {
-    int dw;
+    *screen = (struct screen) SCREEN_INITIALIZER;
    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;
    }
 }
 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;
 }
 #if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
 // On Windows and MacOS, resizing blocks the event loop, so resizing events are
 // not triggered. As a workaround, handle them in an event handler.
 //
 // <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
 // <https://stackoverflow.com/a/40693139/1987178>
 static int
 event_watcher(void *data, SDL_Event *event) {
    struct screen *screen = data;
    if (event->type == SDL_WINDOWEVENT
            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
        // In practice, it seems to always be called from the same thread in
        // that specific case. Anyway, it's just a workaround.
        screen_render(screen, true);
    }
    return 0;
 }
 #endif
 static bool
 screen_frame_sink_open(struct sc_frame_sink *sink) {
    struct screen *screen = DOWNCAST(sink);
    (void) screen;
 #ifndef NDEBUG
    screen->open = true;
 #endif
    // nothing to do, the screen is already open on the main thread
    return true;
 }
 static void
 screen_frame_sink_close(struct sc_frame_sink *sink) {
    struct screen *screen = DOWNCAST(sink);
    (void) screen;
 #ifndef NDEBUG
    screen->open = false;
 #endif
    // nothing to do, the screen lifecycle is not managed by the frame producer
 }
 static bool
 screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
    struct screen *screen = DOWNCAST(sink);
    bool previous_frame_skipped;
    bool ok = video_buffer_push(&screen->vb, frame, &previous_frame_skipped);
    if (!ok) {
        return false;
    }
    if (previous_frame_skipped) {
        fps_counter_add_skipped_frame(&screen->fps_counter);
        // The EVENT_NEW_FRAME triggered for the previous frame will consume
        // this new frame instead
    } else {
        static SDL_Event new_frame_event = {
            .type = EVENT_NEW_FRAME,
        };
        // Post the event on the UI thread
        SDL_PushEvent(&new_frame_event);
    }
    return true;
 }
 bool
-screen_init(struct screen *screen, const struct screen_params *params) {
+screen_init_rendering(struct screen *screen, const char *window_title,
-    screen->resize_pending = false;
+                      struct size frame_size, bool always_on_top) {
-    screen->has_frame = false;
+    screen->frame_size = frame_size;
    screen->fullscreen = false;
    screen->maximized = false;
-    bool ok = video_buffer_init(&screen->vb);
+    struct size window_size = get_initial_optimal_size(frame_size);
-    if (!ok) {
+    uint32_t window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
-        LOGE("Could not initialize video buffer");
+#ifdef HIDPI_SUPPORT
-        return false;
+    window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
-    }
+#endif
-
+    if (always_on_top) {
    if (!fps_counter_init(&screen->fps_counter)) {
        LOGE("Could not initialize FPS counter");
        goto error_destroy_video_buffer;
    }
    screen->frame_size = params->frame_size;
    screen->rotation = params->rotation;
    if (screen->rotation) {
        LOGI("Initial display rotation set to %u", screen->rotation);
    }
    struct size content_size =
        get_rotated_size(screen->frame_size, screen->rotation);
    screen->content_size = content_size;
    struct size window_size = get_initial_optimal_size(content_size,
                                                       params->window_width,
                                                       params->window_height);
    uint32_t window_flags = SDL_WINDOW_HIDDEN
                          | SDL_WINDOW_RESIZABLE
                          | SDL_WINDOW_ALLOW_HIGHDPI;
    if (params->always_on_top) {
 #ifdef SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
        window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
 #else
@@ -338,60 +152,29 @@ screen_init(struct screen *screen, const struct screen_params *params) {
             "(compile with SDL >= 2.0.5 to enable it)");
 #endif
    }
    if (params->window_borderless) {
        window_flags |= SDL_WINDOW_BORDERLESS;
    }
-    int x = params->window_x != SC_WINDOW_POSITION_UNDEFINED
+    screen->window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_UNDEFINED,
-          ? params->window_x : (int) SDL_WINDOWPOS_UNDEFINED;
+                                      SDL_WINDOWPOS_UNDEFINED,
    int y = params->window_y != SC_WINDOW_POSITION_UNDEFINED
          ? params->window_y : (int) SDL_WINDOWPOS_UNDEFINED;
    screen->window = SDL_CreateWindow(params->window_title, x, y,
                                      window_size.width, window_size.height,
                                      window_flags);
    if (!screen->window) {
        LOGC("Could not create window: %s", SDL_GetError());
-        goto error_destroy_fps_counter;
+        return false;
    }
    screen->renderer = SDL_CreateRenderer(screen->window, -1,
                                          SDL_RENDERER_ACCELERATED);
    if (!screen->renderer) {
        LOGC("Could not create renderer: %s", SDL_GetError());
-        goto error_destroy_window;
+        screen_destroy(screen);
        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;
    screen->mipmaps = false;
    // starts with "opengl"
    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
    if (use_opengl) {
        struct sc_opengl *gl = &screen->gl;
        sc_opengl_init(gl);
        LOGI("OpenGL version: %s", gl->version);
        if (params->mipmaps) {
            bool supports_mipmaps =
                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
                                               2, 0  /* OpenGL ES 2.0+ */);
            if (supports_mipmaps) {
                LOGI("Trilinear filtering enabled");
                screen->mipmaps = true;
            } else {
                LOGW("Trilinear filtering disabled "
                     "(OpenGL 3.0+ or ES 2.0+ required)");
            }
        } else {
            LOGI("Trilinear filtering disabled");
        }
    } else if (params->mipmaps) {
        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
    }
    SDL_Surface *icon = read_xpm(icon_xpm);
@@ -402,151 +185,34 @@ screen_init(struct screen *screen, const struct screen_params *params) {
        LOGW("Could not load icon");
    }
-    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, params->frame_size.width,
+    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width,
-                                                  params->frame_size.height);
+                                                  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());
-        goto error_destroy_renderer;
+        screen_destroy(screen);
        return false;
    }
    screen->frame = av_frame_alloc();
    if (!screen->frame) {
        LOGC("Could not create screen frame");
        goto error_destroy_texture;
    }
    // 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);
    if (params->fullscreen) {
        screen_switch_fullscreen(screen);
    }
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
    SDL_AddEventWatch(event_watcher, screen);
 #endif
    static const struct sc_frame_sink_ops ops = {
        .open = screen_frame_sink_open,
        .close = screen_frame_sink_close,
        .push = screen_frame_sink_push,
    };
    screen->frame_sink.ops = &ops;
 #ifndef NDEBUG
    screen->open = false;
 #endif
    return true;
 error_destroy_texture:
    SDL_DestroyTexture(screen->texture);
 error_destroy_renderer:
    SDL_DestroyRenderer(screen->renderer);
 error_destroy_window:
    SDL_DestroyWindow(screen->window);
 error_destroy_fps_counter:
    fps_counter_destroy(&screen->fps_counter);
 error_destroy_video_buffer:
    video_buffer_destroy(&screen->vb);
    return false;
 }
-static void
+void
 screen_show_window(struct screen *screen) {
    SDL_ShowWindow(screen->window);
 }
 void
 screen_hide_window(struct screen *screen) {
    SDL_HideWindow(screen->window);
 }
 void
 screen_interrupt(struct screen *screen) {
    fps_counter_interrupt(&screen->fps_counter);
 }
 void
 screen_join(struct screen *screen) {
    fps_counter_join(&screen->fps_counter);
 }
 void
 screen_destroy(struct screen *screen) {
-#ifndef NDEBUG
+    if (screen->texture) {
-    assert(!screen->open);
+        SDL_DestroyTexture(screen->texture);
 #endif
    av_frame_free(&screen->frame);
    SDL_DestroyTexture(screen->texture);
    SDL_DestroyRenderer(screen->renderer);
    SDL_DestroyWindow(screen->window);
    fps_counter_destroy(&screen->fps_counter);
    video_buffer_destroy(&screen->vb);
 }
 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;
    }
-
+    if (screen->renderer) {
-    screen->content_size = new_content_size;
+        SDL_DestroyRenderer(screen->renderer);
 }
 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;
    }
-}
+    if (screen->window) {
-
+        SDL_DestroyWindow(screen->window);
 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
@@ -554,20 +220,30 @@ 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 windowed_size = get_windowed_window_size(screen);
        struct size target_size = {
            (uint32_t) windowed_size.width * new_frame_size.width
                    / screen->frame_size.width,
            (uint32_t) windowed_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;
@@ -584,68 +260,37 @@ 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) {
        SDL_GL_BindTexture(screen->texture, NULL, NULL);
        screen->gl.GenerateMipmap(GL_TEXTURE_2D);
        SDL_GL_UnbindTexture(screen->texture);
    }
 }
-static bool
+bool
-screen_update_frame(struct screen *screen) {
+screen_update_frame(struct screen *screen, struct video_buffer *vb) {
-    av_frame_unref(screen->frame);
+    mutex_lock(vb->mutex);
-    video_buffer_consume(&screen->vb, screen->frame);
+    const AVFrame *frame = video_buffer_consume_rendered_frame(vb);
    AVFrame *frame = screen->frame;
    fps_counter_add_rendered_frame(&screen->fps_counter);
    struct size new_frame_size = {frame->width, frame->height};
    if (!prepare_for_frame(screen, new_frame_size)) {
        mutex_unlock(vb->mutex);
        return false;
    }
    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_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());
@@ -653,156 +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 point point = get_window_position(screen);
    struct size window_size = get_window_size(screen);
    struct size optimal_size =
        get_optimal_size(window_size, screen->content_size);
    // Center the window related to the device screen
    assert(optimal_size.width <= window_size.width);
    assert(optimal_size.height <= window_size.height);
    uint32_t new_x = point.x + (window_size.width - optimal_size.width) / 2;
    uint32_t new_y = point.y + (window_size.height - optimal_size.height) / 2;
    SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
    SDL_SetWindowPosition(screen->window, new_x, new_y);
    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);
 }
 bool
 screen_handle_event(struct screen *screen, SDL_Event *event) {
    switch (event->type) {
        case EVENT_NEW_FRAME:
            if (!screen->has_frame) {
                screen->has_frame = true;
                // this is the very first frame, show the window
                screen_show_window(screen);
            }
            bool ok = screen_update_frame(screen);
            if (!ok) {
                LOGW("Frame update failed\n");
            }
            return true;
        case SDL_WINDOWEVENT:
            if (!screen->has_frame) {
                // Do nothing
                return true;
            }
            switch (event->window.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);
                    screen_render(screen, true);
                    break;
            }
            return true;
    }
    return false;
 }
 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
@@ -1,99 +1,68 @@
 #ifndef SCREEN_H
 #define SCREEN_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL.h>
 #include <libavformat/avformat.h>
-#include "coords.h"
+#include "config.h"
-#include "opengl.h"
+#include "common.h"
-#include "trait/frame_sink.h"
+
-#include "video_buffer.h"
+struct video_buffer;
 struct screen {
    struct sc_frame_sink frame_sink; // frame sink trait
 #ifndef NDEBUG
    bool open; // track the open/close state to assert correct behavior
 #endif
    struct video_buffer vb;
    struct fps_counter fps_counter;
    SDL_Window *window;
    SDL_Renderer *renderer;
    SDL_Texture *texture;
    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;
    AVFrame *frame;
 };
-struct screen_params {
+#define SCREEN_INITIALIZER {  \
-    const char *window_title;
+    .window = NULL,           \
-    struct size frame_size;
+    .renderer = NULL,         \
-    bool always_on_top;
+    .texture = NULL,          \
    .frame_size = {           \
        .width = 0,           \
        .height = 0,          \
    },                        \
    .windowed_window_size = { \
        .width = 0,           \
        .height = 0,          \
    },                        \
    .has_frame = false,   \
    .fullscreen = false,  \
    .no_window = false,   \
 }
-    int16_t window_x;
+// initialize default values
-    int16_t window_y;
+void
-    uint16_t window_width;  // accepts SC_WINDOW_POSITION_UNDEFINED
+screen_init(struct screen *screen);
    uint16_t window_height; // accepts SC_WINDOW_POSITION_UNDEFINED
    bool window_borderless;
    uint8_t rotation;
    bool mipmaps;
    bool fullscreen;
 };
 // initialize screen, create window, renderer and texture (window is hidden)
 bool
-screen_init(struct screen *screen, const struct screen_params *params);
+screen_init_rendering(struct screen *screen, const char *window_title,
                      struct size frame_size, bool always_on_top);
-// request to interrupt any inner thread
+// show the window
 // must be called before screen_join()
 void
-screen_interrupt(struct screen *screen);
+screen_show_window(struct screen *screen);
 // join any inner thread
 void
 screen_join(struct screen *screen);
 // destroy window, renderer and texture (if any)
 void
 screen_destroy(struct screen *screen);
-// hide the window
+// resize if necessary and write the rendered frame into the texture
-//
+bool
-// It is used to hide the window immediately on closing without waiting for
+screen_update_frame(struct screen *screen, struct video_buffer *vb);
 // screen_destroy()
 void
 screen_hide_window(struct screen *screen);
 // 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
@@ -107,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 SDL events
 bool
 screen_handle_event(struct screen *screen, SDL_Event *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,76 +1,56 @@
 #include "server.h"
 #include <assert.h>
 #include <errno.h>
 #include <inttypes.h>
 #include <libgen.h>
 #include <stdio.h>
 #include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>
 #include <SDL2/SDL_platform.h>
-#include "adb.h"
+#include "config.h"
-#include "util/log.h"
+#include "command.h"
-#include "util/net.h"
+#include "log.h"
-#include "util/str_util.h"
+#include "net.h"
 #define SOCKET_NAME "scrcpy"
 #define SERVER_FILENAME "scrcpy-server"
 #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 = 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 = 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 in the same directory as the executable
    char *executable_path = get_executable_path();
    if (!executable_path) {
        LOGE("Could not get executable path, "
             "using " SERVER_FILENAME " from current directory");
        // not found, use current directory
-        return strdup(SERVER_FILENAME);
+        return SERVER_FILENAME;
    }
    char *dir = dirname(executable_path);
    size_t dirlen = strlen(dir);
    // sizeof(SERVER_FILENAME) gives statically the size including the null byte
    size_t len = dirlen + 1 + sizeof(SERVER_FILENAME);
-    char *server_path = malloc(len);
+    char *server_path = SDL_malloc(len);
    if (!server_path) {
        LOGE("Could not alloc server path string, "
             "using " SERVER_FILENAME " from current directory");
-        free(executable_path);
+        SDL_free(executable_path);
-        return strdup(SERVER_FILENAME);
+        return SERVER_FILENAME;
    }
    memcpy(server_path, dir, dirlen);
@@ -78,7 +58,7 @@ get_server_path(void) {
    memcpy(&server_path[dirlen + 1], SERVER_FILENAME, sizeof(SERVER_FILENAME));
    // the final null byte has been copied with SERVER_FILENAME
-    free(executable_path);
+    SDL_free(executable_path);
    LOGD("Using server (portable): %s", server_path);
    return server_path;
@@ -87,42 +67,43 @@ 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 process_check_success(process, "adb push");
        return false;
    }
    if (!is_regular_file(server_path)) {
        LOGE("'%s' does not exist or is not a regular file\n", server_path);
        free(server_path);
        return false;
    }
    process_t process = adb_push(serial, server_path, DEVICE_SERVER_PATH);
    free(server_path);
    return process_check_success(process, "adb push", true);
 }
 static bool
 enable_tunnel_reverse(const char *serial, uint16_t local_port) {
    process_t process = adb_reverse(serial, SOCKET_NAME, local_port);
-    return process_check_success(process, "adb reverse", true);
+    return process_check_success(process, "adb reverse");
 }
 static bool
 disable_tunnel_reverse(const char *serial) {
    process_t process = adb_reverse_remove(serial, SOCKET_NAME);
-    return process_check_success(process, "adb reverse --remove", true);
+    return process_check_success(process, "adb reverse --remove");
 }
 static bool
 enable_tunnel_forward(const char *serial, uint16_t local_port) {
    process_t process = adb_forward(serial, local_port, SOCKET_NAME);
-    return process_check_success(process, "adb forward", true);
+    return process_check_success(process, "adb forward");
 }
 static bool
 disable_tunnel_forward(const char *serial, uint16_t local_port) {
    process_t process = adb_forward_remove(serial, local_port);
-    return process_check_success(process, "adb forward --remove", true);
+    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
@@ -133,167 +114,29 @@ 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[11];
    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, "%"PRIu32, 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 : "-",
        params->power_off_on_close ? "true" : "false",
    };
 #ifdef SERVER_DEBUGGER
    LOGI("Server debugger waiting for a client on device port "
@@ -306,7 +149,14 @@ execute_server(struct server *server, const struct server_params *params) {
    //     Port: 5005
    // Then click on "Debug"
 #endif
-    return adb_execute(server->serial, cmd, ARRAY_LEN(cmd));
+    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
@@ -344,147 +194,81 @@ 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;
    atomic_flag_clear_explicit(&server->server_socket_closed,
                               memory_order_relaxed);
    bool ok = sc_mutex_init(&server->mutex);
    if (!ok) {
        return false;
    }
    ok = sc_cond_init(&server->process_terminated_cond);
    if (!ok) {
        sc_mutex_destroy(&server->mutex);
        return false;
    }
    server->process_terminated = false;
    server->server_socket = INVALID_SOCKET;
    server->video_socket = INVALID_SOCKET;
    server->control_socket = INVALID_SOCKET;
    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;
    process_wait(server->process, false); // ignore exit code
    sc_mutex_lock(&server->mutex);
    server->process_terminated = true;
    sc_cond_signal(&server->process_terminated_cond);
    sc_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 struct server_params *params) {
+server_start(struct server *server, const char *serial,
-    if (params->serial) {
+             const struct server_params *params) {
-        server->serial = strdup(params->serial);
+    server->local_port = params->local_port;
    if (serial) {
        server->serial = SDL_strdup(serial);
        if (!server->serial) {
            return false;
        }
    }
-    if (!push_server(params->serial)) {
+    if (!push_server(serial)) {
-        /* server->serial will be freed on server_destroy() */
+        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);
        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 error;
    }
-    // 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);
-    bool ok = sc_thread_create(&server->wait_server_thread, run_wait_server,
+        return false;
                               "wait-server", server);
    if (!ok) {
        process_terminate(server->process);
        process_wait(server->process, true); // ignore exit code
        goto error;
    }
    server->tunnel_enabled = true;
    return true;
 error:
    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);
    return false;
 }
 static bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size) {
    unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
    int r = net_recv_all(device_socket, buf, sizeof(buf));
    if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
        LOGE("Could not retrieve device information");
        return false;
    }
    // in case the client sends garbage
    buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
    // strcpy is safe here, since name contains at least
    // DEVICE_NAME_FIELD_LENGTH bytes and strlen(buf) < DEVICE_NAME_FIELD_LENGTH
    strcpy(device_name, (char *) buf);
    size->width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
            | buf[DEVICE_NAME_FIELD_LENGTH + 1];
    size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
    return true;
 }
 bool
-server_connect_to(struct server *server, char *device_name, struct size *size) {
+server_connect_to(struct server *server) {
    if (!server->tunnel_forward) {
        server->video_socket = net_accept(server->server_socket);
        if (server->video_socket == INVALID_SOCKET) {
@@ -493,16 +277,12 @@ server_connect_to(struct server *server, char *device_name, struct size *size) {
        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
@@ -524,58 +304,37 @@ server_connect_to(struct server *server, char *device_name, struct size *size) {
    disable_tunnel(server); // ignore failure
    server->tunnel_enabled = false;
-    // The sockets will be closed on stop if device_read_info() fails
+    return true;
    return device_read_info(server->video_socket, device_name, size);
 }
 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
    sc_mutex_lock(&server->mutex);
    bool signaled = false;
    if (!server->process_terminated) {
 #define WATCHDOG_DELAY_MS 1000
        signaled = sc_cond_timedwait(&server->process_terminated_cond,
                                     &server->mutex,
                                     WATCHDOG_DELAY_MS);
    }
    sc_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 (!signaled) {
        // The process is terminated, but not reaped (closed) yet, so its PID
        // is still valid.
        LOGW("Killing the server...");
        process_terminate(server->process);
    }
    sc_thread_join(&server->wait_server_thread, NULL);
    process_close(server->process);
 }
 void
 server_destroy(struct server *server) {
-    free(server->serial);
+    SDL_free(server->serial);
    sc_cond_destroy(&server->process_terminated_cond);
    sc_mutex_destroy(&server->mutex);
 }
--- a/app/src/server.h
+++ b/app/src/server.h
@@ -1,69 +1,55 @@
 #ifndef SERVER_H
 #define SERVER_H
 #include "common.h"
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include "adb.h"
+#include "config.h"
-#include "coords.h"
+#include "command.h"
-#include "scrcpy.h"
+#include "net.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/thread.h"
 struct server {
    char *serial;
    process_t process;
    sc_thread wait_server_thread;
    atomic_flag server_socket_closed;
    sc_mutex mutex;
    sc_cond process_terminated_cond;
    bool process_terminated;
    socket_t server_socket; // only used if !tunnel_forward
    socket_t video_socket;
    socket_t control_socket;
-    uint16_t local_port; // selected from port_range
+    uint16_t local_port;
    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 {
    const char *serial;
    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;
    uint32_t display_id;
    bool show_touches;
    bool stay_awake;
    bool force_adb_forward;
    bool power_off_on_close;
 };
 // init default values
-bool
+void
 server_init(struct server *server);
 // push, enable tunnel et start the server
 bool
-server_start(struct server *server, const struct server_params *params);
+server_start(struct server *server, const char *serial,
             const struct server_params *params);
 #define DEVICE_NAME_FIELD_LENGTH 64
 // block until the communication with the server is established
 // device_name must point to a buffer of at least DEVICE_NAME_FIELD_LENGTH bytes
 bool
-server_connect_to(struct server *server, char *device_name, struct size *size);
+server_connect_to(struct server *server);
 // disconnect and kill the server process
 void
--- a/app/src/str_util.c
+++ b/app/src/str_util.c
@@ -0,0 +1,113 @@
 #include "str_util.h"
 #include <stdlib.h>
 #include <string.h>
 #ifdef _WIN32
 # include <windows.h>
 # include <tchar.h>
 #endif
 #include <SDL2/SDL_stdinc.h>
 #include "config.h"
 size_t
 xstrncpy(char *dest, const char *src, size_t n) {
    size_t i;
    for (i = 0; i < n - 1 && src[i] != '\0'; ++i)
        dest[i] = src[i];
    if (n)
        dest[i] = '\0';
    return src[i] == '\0' ? i : n;
 }
 size_t
 xstrjoin(char *dst, const char *const tokens[], char sep, size_t n) {
    const char *const *remaining = tokens;
    const char *token = *remaining++;
    size_t i = 0;
    while (token) {
        if (i) {
            dst[i++] = sep;
            if (i == n)
                goto truncated;
        }
        size_t w = xstrncpy(dst + i, token, n - i);
        if (w >= n - i)
            goto truncated;
        i += w;
        token = *remaining++;
    }
    return i;
 truncated:
    dst[n - 1] = '\0';
    return n;
 }
 char *
 strquote(const char *src) {
    size_t len = strlen(src);
    char *quoted = SDL_malloc(len + 3);
    if (!quoted) {
        return NULL;
    }
    memcpy(&quoted[1], src, len);
    quoted[0] = '"';
    quoted[len + 1] = '"';
    quoted[len + 2] = '\0';
    return quoted;
 }
 size_t
 utf8_truncation_index(const char *utf8, size_t max_len) {
    size_t len = strlen(utf8);
    if (len <= max_len) {
        return len;
    }
    len = max_len;
    // see UTF-8 encoding <https://en.wikipedia.org/wiki/UTF-8#Description>
    while ((utf8[len] & 0x80) != 0 && (utf8[len] & 0xc0) != 0xc0) {
        // the next byte is not the start of a new UTF-8 codepoint
        // so if we would cut there, the character would be truncated
        len--;
    }
    return len;
 }
 #ifdef _WIN32
 wchar_t *
 utf8_to_wide_char(const char *utf8) {
    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    if (!len) {
        return NULL;
    }
    wchar_t *wide = SDL_malloc(len * sizeof(wchar_t));
    if (!wide) {
        return NULL;
    }
    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wide, len);
    return wide;
 }
 char *
 utf8_from_wide_char(const wchar_t *ws) {
    int len = WideCharToMultiByte(CP_UTF8, 0, ws, -1, NULL, 0, NULL, NULL);
    if (!len) {
        return NULL;
    }
    char *utf8 = SDL_malloc(len);
    if (!utf8) {
        return NULL;
    }
    WideCharToMultiByte(CP_UTF8, 0, ws, -1, utf8, len, NULL, NULL);
    return utf8;
 }
 #endif
--- a/app/src/util/str_util.h
+++ b/app/src/util/str_util.h
@@ -1,11 +1,10 @@
 #ifndef STRUTIL_H
 #define STRUTIL_H
 #include "common.h"
 #include <stdbool.h>
 #include <stddef.h>
 #include "config.h"
 // like strncpy, except:
 //  - it copies at most n-1 chars
 //  - the dest string is nul-terminated
@@ -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,28 +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);
 // search s in the list separated by sep
 // for example, strlist_contains("a,bc,def", ',', "bc") returns true
 bool
 strlist_contains(const char *list, char sep, const char *s);
 // 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,15 +1,21 @@
 #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>
 #include <unistd.h>
 #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
@@ -38,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");
@@ -47,22 +52,43 @@ 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;
 }
 static void
 notify_stopped(void) {
    SDL_Event stop_event;
    stop_event.type = EVENT_STREAM_STOPPED;
    SDL_PushEvent(&stop_event);
 }
 static bool
-push_packet_to_sinks(struct stream *stream, const AVPacket *packet) {
+process_config_packet(struct stream *stream, AVPacket *packet) {
-    for (unsigned i = 0; i < stream->sink_count; ++i) {
+    if (stream->recorder && !recorder_push(stream->recorder, packet)) {
-        struct sc_packet_sink *sink = stream->sinks[i];
+        LOGE("Could not send config packet to recorder");
-        if (!sink->ops->push(sink, packet)) {
+        return false;
-            LOGE("Could not send config packet to sink %d", i);
+    }
    return true;
 }
 static bool
 process_frame(struct stream *stream, AVPacket *packet) {
    if (stream->decoder && !decoder_push(stream->decoder, packet)) {
        return false;
    }
    if (stream->recorder) {
        packet->dts = packet->pts;
        if (!recorder_push(stream->recorder, packet)) {
            LOGE("Could not send packet to recorder");
            return false;
        }
    }
@@ -81,19 +107,16 @@ 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;
    }
-    packet->dts = packet->pts;
+    bool ok = process_frame(stream, packet);
    bool ok = push_packet_to_sinks(stream, packet);
    if (!ok) {
-        LOGE("Could not process packet");
+        LOGE("Could not process frame");
        return false;
    }
@@ -104,44 +127,39 @@ static bool
 stream_push_packet(struct stream *stream, AVPacket *packet) {
    bool is_config = packet->pts == AV_NOPTS_VALUE;
-    // A config packet must not be decoded immediately (it contains no
+    // A config packet must not be decoded immetiately (it contains no
    // frame); instead, it must be concatenated with the future data packet.
-    if (stream->pending || is_config) {
+    if (stream->has_pending || is_config) {
        size_t offset;
-        if (stream->pending) {
+        if (stream->has_pending) {
-            offset = stream->pending->size;
+            offset = stream->pending.size;
-            if (av_grow_packet(stream->pending, packet->size)) {
+            if (av_grow_packet(&stream->pending, packet->size)) {
                LOGE("Could not grow packet");
                return false;
            }
        } else {
            offset = 0;
-            stream->pending = av_packet_alloc();
+            if (av_new_packet(&stream->pending, packet->size)) {
            if (!stream->pending) {
                LOGE("Could not allocate packet");
                return false;
            }
            if (av_new_packet(stream->pending, packet->size)) {
                LOGE("Could not create packet");
                av_packet_free(&stream->pending);
                return false;
            }
            stream->has_pending = true;
        }
-        memcpy(stream->pending->data + offset, packet->data, packet->size);
+        memcpy(stream->pending.data + offset, packet->data, packet->size);
        if (!is_config) {
            // prepare the concat packet to send to the decoder
-            stream->pending->pts = packet->pts;
+            stream->pending.pts = packet->pts;
-            stream->pending->dts = packet->dts;
+            stream->pending.dts = packet->dts;
-            stream->pending->flags = packet->flags;
+            stream->pending.flags = packet->flags;
-            packet = stream->pending;
+            packet = &stream->pending;
        }
    }
    if (is_config) {
        // config packet
-        bool ok = push_packet_to_sinks(stream, packet);
+        bool ok = process_config_packet(stream, packet);
        if (!ok) {
            return false;
        }
@@ -149,10 +167,10 @@ stream_push_packet(struct stream *stream, AVPacket *packet) {
        // data packet
        bool ok = stream_parse(stream, packet);
-        if (stream->pending) {
+        if (stream->has_pending) {
            // the pending packet must be discarded (consumed or error)
-            av_packet_unref(stream->pending);
+            stream->has_pending = false;
-            av_packet_free(&stream->pending);
+            av_packet_unref(&stream->pending);
        }
        if (!ok) {
@@ -162,33 +180,6 @@ stream_push_packet(struct stream *stream, AVPacket *packet) {
    return true;
 }
 static void
 stream_close_first_sinks(struct stream *stream, unsigned count) {
    while (count) {
        struct sc_packet_sink *sink = stream->sinks[--count];
        sink->ops->close(sink);
    }
 }
 static inline void
 stream_close_sinks(struct stream *stream) {
    stream_close_first_sinks(stream, stream->sink_count);
 }
 static bool
 stream_open_sinks(struct stream *stream, const AVCodec *codec) {
    for (unsigned i = 0; i < stream->sink_count; ++i) {
        struct sc_packet_sink *sink = stream->sinks[i];
        if (!sink->ops->open(sink, codec)) {
            LOGE("Could not open packet sink %d", i);
            stream_close_first_sinks(stream, i);
            return false;
        }
    }
    return true;
 }
 static int
 run_stream(void *data) {
    struct stream *stream = data;
@@ -205,36 +196,43 @@ run_stream(void *data) {
        goto end;
    }
-    if (!stream_open_sinks(stream, codec)) {
+    if (stream->decoder && !decoder_open(stream->decoder, codec)) {
-        LOGE("Could not open stream sinks");
+        LOGE("Could not open decoder");
        goto finally_free_codec_ctx;
    }
    if (stream->recorder) {
        if (!recorder_open(stream->recorder, codec)) {
            LOGE("Could not open recorder");
            goto finally_close_decoder;
        }
        if (!recorder_start(stream->recorder)) {
            LOGE("Could not start recorder");
            goto finally_close_recorder;
        }
    }
    stream->parser = av_parser_init(AV_CODEC_ID_H264);
    if (!stream->parser) {
        LOGE("Could not initialize parser");
-        goto finally_close_sinks;
+        goto finally_stop_and_join_recorder;
    }
    // We must only pass complete frames to av_parser_parse2()!
    // It's more complicated, but this allows to reduce the latency by 1 frame!
    stream->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
    AVPacket *packet = av_packet_alloc();
    if (!packet) {
        LOGE("Could not allocate packet");
        goto finally_close_parser;
    }
    for (;;) {
-        bool ok = stream_recv_packet(stream, packet);
+        AVPacket packet;
        bool ok = stream_recv_packet(stream, &packet);
        if (!ok) {
            // end of stream
            break;
        }
-        ok = stream_push_packet(stream, packet);
+        ok = stream_push_packet(stream, &packet);
-        av_packet_unref(packet);
+        av_packet_unref(&packet);
        if (!ok) {
            // cannot process packet (error already logged)
            break;
@@ -243,51 +241,47 @@ run_stream(void *data) {
    LOGD("End of frames");
-    if (stream->pending) {
+    if (stream->has_pending) {
-        av_packet_unref(stream->pending);
+        av_packet_unref(&stream->pending);
        av_packet_free(&stream->pending);
    }
    av_packet_free(&packet);
 finally_close_parser:
    av_parser_close(stream->parser);
-finally_close_sinks:
+finally_stop_and_join_recorder:
-    stream_close_sinks(stream);
+    if (stream->recorder) {
        recorder_stop(stream->recorder);
        LOGI("Finishing recording...");
        recorder_join(stream->recorder);
    }
 finally_close_recorder:
    if (stream->recorder) {
        recorder_close(stream->recorder);
    }
 finally_close_decoder:
    if (stream->decoder) {
        decoder_close(stream->decoder);
    }
 finally_free_codec_ctx:
    avcodec_free_context(&stream->codec_ctx);
 end:
-    stream->cbs->on_eos(stream, stream->cbs_userdata);
+    notify_stopped();
    return 0;
 }
 void
 stream_init(struct stream *stream, socket_t socket,
-            const struct stream_callbacks *cbs, void *cbs_userdata) {
+            struct decoder *decoder, struct recorder *recorder) {
    stream->socket = socket;
-    stream->pending = NULL;
+    stream->decoder = decoder,
-    stream->sink_count = 0;
+    stream->recorder = recorder;
-
+    stream->has_pending = false;
    assert(cbs && cbs->on_eos);
    stream->cbs = cbs;
    stream->cbs_userdata = cbs_userdata;
 }
 void
 stream_add_sink(struct stream *stream, struct sc_packet_sink *sink) {
    assert(stream->sink_count < STREAM_MAX_SINKS);
    assert(sink);
    assert(sink->ops);
    stream->sinks[stream->sink_count++] = sink;
 }
 bool
 stream_start(struct stream *stream) {
    LOGD("Starting stream thread");
-    bool ok = sc_thread_create(&stream->thread, run_stream, "stream", stream);
+    stream->thread = SDL_CreateThread(run_stream, "stream", stream);
-    if (!ok) {
+    if (!stream->thread) {
        LOGC("Could not start stream thread");
        return false;
    }
@@ -295,6 +289,13 @@ stream_start(struct stream *stream) {
 }
 void
-stream_join(struct stream *stream) {
+stream_stop(struct stream *stream) {
-    sc_thread_join(&stream->thread, NULL);
+    if (stream->decoder) {
        decoder_interrupt(stream->decoder);
    }
 }
 void
 stream_join(struct stream *stream) {
    SDL_WaitThread(stream->thread, NULL);
 }
--- a/app/src/stream.h
+++ b/app/src/stream.h
@@ -1,49 +1,41 @@
 #ifndef STREAM_H
 #define STREAM_H
 #include "common.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <libavformat/avformat.h>
 #include <SDL2/SDL_atomic.h>
 #include <SDL2/SDL_thread.h>
-#include "trait/packet_sink.h"
+#include "config.h"
-#include "util/net.h"
+#include "net.h"
 #include "util/thread.h"
-#define STREAM_MAX_SINKS 2
+struct video_buffer;
 struct stream {
    socket_t socket;
-    sc_thread thread;
+    struct video_buffer *video_buffer;
-
+    SDL_Thread *thread;
-    struct sc_packet_sink *sinks[STREAM_MAX_SINKS];
+    struct decoder *decoder;
-    unsigned sink_count;
+    struct recorder *recorder;
    AVCodecContext *codec_ctx;
    AVCodecParserContext *parser;
    // successive packets may need to be concatenated, until a non-config
    // packet is available
-    AVPacket *pending;
+    bool has_pending;
-
+    AVPacket pending;
    const struct stream_callbacks *cbs;
    void *cbs_userdata;
 };
 struct stream_callbacks {
    void (*on_eos)(struct stream *stream, void *userdata);
 };
 void
 stream_init(struct stream *stream, socket_t socket,
-            const struct stream_callbacks *cbs, void *cbs_userdata);
+            struct decoder *decoder, struct recorder *recorder);
 void
 stream_add_sink(struct stream *stream, struct sc_packet_sink *sink);
 bool
 stream_start(struct stream *stream);
 void
 stream_stop(struct stream *stream);
 void
 stream_join(struct stream *stream);
--- a/app/src/sys/unix/command.c
+++ b/app/src/sys/unix/command.c
@@ -1,56 +1,26 @@
-#include "util/process.h"
+// for portability
 #define _POSIX_SOURCE // for kill()
 #define _BSD_SOURCE // for readlink()
 // modern glibc will complain without this
 #define _DEFAULT_SOURCE
 #include "command.h"
 #include "config.h"
 #include <errno.h>
 #include <fcntl.h>
 #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
 search_executable(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
-process_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) {
@@ -81,7 +51,7 @@ process_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 {
@@ -112,37 +82,29 @@ end:
 }
 bool
-process_terminate(pid_t pid) {
+cmd_terminate(pid_t pid) {
    if (pid <= 0) {
        LOGC("Requested to kill %d, this is an error. Please report the bug.\n",
             (int) pid);
        abort();
    }
-    return kill(pid, SIGKILL) != -1;
+    return kill(pid, SIGTERM) != -1;
 }
-exit_code_t
+bool
-process_wait(pid_t pid, bool close) {
+cmd_simple_wait(pid_t pid, int *exit_code) {
    int status;
    int code;
-    int options = WEXITED;
+    if (waitpid(pid, &status, 0) == -1 || !WIFEXITED(status)) {
    if (!close) {
        options |= WNOWAIT;
    }
    siginfo_t info;
    int r = waitid(P_PID, pid, &info, options);
    if (r == -1 || info.si_code != CLD_EXITED) {
        // could not wait, or exited unexpectedly, probably by a signal
-        code = NO_EXIT_CODE;
+        code = -1;
    } else {
-        code = info.si_status;
+        code = WEXITSTATUS(status);
    }
-    return code;
+    if (exit_code) {
-}
+        *exit_code = code;
-
+    }
-void
+    return !code;
 process_close(pid_t pid) {
    process_wait(pid, true); // ignore exit code
 }
 char *
@@ -156,7 +118,7 @@ get_executable_path(void) {
        return NULL;
    }
    buf[len] = '\0';
-    return strdup(buf);
+    return SDL_strdup(buf);
 #else
    // in practice, we only need this feature for portable builds, only used on
    // Windows, so we don't care implementing it for every platform
@@ -164,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,14 +1,10 @@
-#include "util/process.h"
+#include "command.h"
-#include <assert.h>
+#include "config.h"
-#include <sys/stat.h>
+#include "log.h"
 #include "str_util.h"
-#include "util/log.h"
+static int
 #include "util/str_util.h"
 #define CMD_MAX_LEN 8192
 static bool
 build_cmd(char *cmd, size_t len, const char *const argv[]) {
    // Windows command-line parsing is WTF:
    // <http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS>
@@ -17,34 +13,38 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
    size_t ret = xstrjoin(cmd, argv, ' ', len);
    if (ret >= len) {
        LOGE("Command too long (%" PRIsizet " chars)", len - 1);
-        return false;
+        return -1;
    }
-    return true;
+    return 0;
 }
 enum process_result
-process_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));
    si.cb = sizeof(si);
-    char *cmd = malloc(CMD_MAX_LEN);
+    char cmd[256];
-    if (!cmd || !build_cmd(cmd, CMD_MAX_LEN, argv)) {
+    if (build_cmd(cmd, sizeof(cmd), argv)) {
        *handle = NULL;
        return PROCESS_ERROR_GENERIC;
    }
    wchar_t *wide = utf8_to_wide_char(cmd);
    free(cmd);
    if (!wide) {
        LOGC("Could not allocate wide char string");
        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)) {
-        free(wide);
+        SDL_free(wide);
        *handle = NULL;
        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
            return PROCESS_ERROR_MISSING_BINARY;
@@ -52,35 +52,28 @@ process_execute(const char *const argv[], HANDLE *handle) {
        return PROCESS_ERROR_GENERIC;
    }
-    free(wide);
+    SDL_free(wide);
    *handle = pi.hProcess;
    return PROCESS_SUCCESS;
 }
 bool
-process_terminate(HANDLE handle) {
+cmd_terminate(HANDLE handle) {
-    return TerminateProcess(handle, 1);
+    return TerminateProcess(handle, 1) && CloseHandle(handle);
 }
-exit_code_t
+bool
-process_wait(HANDLE handle, bool close) {
+cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
    DWORD code;
    if (WaitForSingleObject(handle, INFINITE) != WAIT_OBJECT_0
            || !GetExitCodeProcess(handle, &code)) {
        // could not wait or retrieve the exit code
-        code = NO_EXIT_CODE; // max value, it's unsigned
+        code = -1; // max value, it's unsigned
    }
-    if (close) {
+    if (exit_code) {
-        CloseHandle(handle);
+        *exit_code = code;
    }
-    return code;
+    return !code;
 }
 void
 process_close(HANDLE handle) {
    bool closed = CloseHandle(handle);
    assert(closed);
    (void) closed;
 }
 char *
@@ -97,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);
    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,12 +1,12 @@
 #include "tiny_xpm.h"
 #include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "util/log.h"
+#include "config.h"
 #include "log.h"
 struct index {
    char c;
@@ -36,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
@@ -51,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;
        }
    }
@@ -87,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/tiny_xpm.h
+++ b/app/src/tiny_xpm.h
@@ -1,10 +1,10 @@
 #ifndef TINYXPM_H
 #define TINYXPM_H
 #include "common.h"
 #include <SDL2/SDL.h>
 #include "config.h"
 SDL_Surface *
 read_xpm(char *xpm[]);
--- a/app/src/trait/frame_sink.h
+++ b/app/src/trait/frame_sink.h
@@ -1,26 +0,0 @@
 #ifndef SC_FRAME_SINK
 #define SC_FRAME_SINK
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
 typedef struct AVFrame AVFrame;
 /**
 * Frame sink trait.
 *
 * Component able to receive AVFrames should implement this trait.
 */
 struct sc_frame_sink {
    const struct sc_frame_sink_ops *ops;
 };
 struct sc_frame_sink_ops {
    bool (*open)(struct sc_frame_sink *sink);
    void (*close)(struct sc_frame_sink *sink);
    bool (*push)(struct sc_frame_sink *sink, const AVFrame *frame);
 };
 #endif
--- a/app/src/trait/packet_sink.h
+++ b/app/src/trait/packet_sink.h
@@ -1,27 +0,0 @@
 #ifndef SC_PACKET_SINK
 #define SC_PACKET_SINK
 #include "common.h"
 #include <assert.h>
 #include <stdbool.h>
 typedef struct AVCodec AVCodec;
 typedef struct AVPacket AVPacket;
 /**
 * Packet sink trait.
 *
 * Component able to receive AVPackets should implement this trait.
 */
 struct sc_packet_sink {
    const struct sc_packet_sink_ops *ops;
 };
 struct sc_packet_sink_ops {
    bool (*open)(struct sc_packet_sink *sink, const AVCodec *codec);
    void (*close)(struct sc_packet_sink *sink);
    bool (*push)(struct sc_packet_sink *sink, const AVPacket *packet);
 };
 #endif
--- a/app/src/util/process.c
+++ b/app/src/util/process.c
@@ -1,21 +0,0 @@
 #include "process.h"
 #include "log.h"
 bool
 process_check_success(process_t proc, const char *name, bool close) {
    if (proc == PROCESS_NONE) {
        LOGE("Could not execute \"%s\"", name);
        return false;
    }
    exit_code_t exit_code = process_wait(proc, close);
    if (exit_code) {
        if (exit_code != NO_EXIT_CODE) {
            LOGE("\"%s\" returned with value %" PRIexitcode, name, exit_code);
        } else {
            LOGE("\"%s\" exited unexpectedly", name);
        }
        return false;
    }
    return true;
 }
--- a/app/src/util/process.h
+++ b/app/src/util/process.h
@@ -1,81 +0,0 @@
 #ifndef SC_PROCESS_H
 #define SC_PROCESS_H
 #include "common.h"
 #include <stdbool.h>
 #ifdef _WIN32
 // not needed here, but winsock2.h must never be included AFTER windows.h
 # include <winsock2.h>
 # include <windows.h>
 # define PATH_SEPARATOR '\\'
 # define PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
 # define PRIsizet "Iu"
 # define PROCESS_NONE NULL
 # define NO_EXIT_CODE -1u // max value as unsigned
  typedef HANDLE process_t;
  typedef DWORD exit_code_t;
 #else
 # include <sys/types.h>
 # define PATH_SEPARATOR '/'
 # 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;
 #endif
 enum process_result {
    PROCESS_SUCCESS,
    PROCESS_ERROR_GENERIC,
    PROCESS_ERROR_MISSING_BINARY,
 };
 // execute the command and write the result to the output parameter "process"
 enum process_result
 process_execute(const char *const argv[], process_t *process);
 // kill the process
 bool
 process_terminate(process_t pid);
 // wait and close the process (like waitpid())
 // the "close" flag indicates if the process must be "closed" (reaped)
 // (passing false is equivalent to enable WNOWAIT in waitid())
 exit_code_t
 process_wait(process_t pid, bool close);
 // close the process
 //
 // Semantically, process_wait(close) = process_wait(noclose) + process_close
 void
 process_close(process_t pid);
 // convenience function to wait for a successful process execution
 // automatically log process errors with the provided process name
 bool
 process_check_success(process_t proc, const char *name, bool close);
 #ifndef _WIN32
 // only used to find package manager, not implemented for Windows
 bool
 search_executable(const char *file);
 #endif
 // return the absolute path of the executable (the scrcpy binary)
 // may be NULL on error; to be freed by free()
 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/util/str_util.c
+++ b/app/src/util/str_util.c
@@ -1,211 +0,0 @@
 #include "str_util.h"
 #include <errno.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #ifdef _WIN32
 # include <windows.h>
 # include <tchar.h>
 #endif
 size_t
 xstrncpy(char *dest, const char *src, size_t n) {
    size_t i;
    for (i = 0; i < n - 1 && src[i] != '\0'; ++i)
        dest[i] = src[i];
    if (n)
        dest[i] = '\0';
    return src[i] == '\0' ? i : n;
 }
 size_t
 xstrjoin(char *dst, const char *const tokens[], char sep, size_t n) {
    const char *const *remaining = tokens;
    const char *token = *remaining++;
    size_t i = 0;
    while (token) {
        if (i) {
            dst[i++] = sep;
            if (i == n)
                goto truncated;
        }
        size_t w = xstrncpy(dst + i, token, n - i);
        if (w >= n - i)
            goto truncated;
        i += w;
        token = *remaining++;
    }
    return i;
 truncated:
    dst[n - 1] = '\0';
    return n;
 }
 char *
 strquote(const char *src) {
    size_t len = strlen(src);
    char *quoted = malloc(len + 3);
    if (!quoted) {
        return NULL;
    }
    memcpy(&quoted[1], src, len);
    quoted[0] = '"';
    quoted[len + 1] = '"';
    quoted[len + 2] = '\0';
    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;
 }
 bool
 strlist_contains(const char *list, char sep, const char *s) {
    char *p;
    do {
        p = strchr(list, sep);
        size_t token_len = p ? (size_t) (p - list) : strlen(list);
        if (!strncmp(list, s, token_len)) {
            return true;
        }
        if (p) {
            list = p + 1;
        }
    } while (p);
    return false;
 }
 size_t
 utf8_truncation_index(const char *utf8, size_t max_len) {
    size_t len = strlen(utf8);
    if (len <= max_len) {
        return len;
    }
    len = max_len;
    // see UTF-8 encoding <https://en.wikipedia.org/wiki/UTF-8#Description>
    while ((utf8[len] & 0x80) != 0 && (utf8[len] & 0xc0) != 0xc0) {
        // the next byte is not the start of a new UTF-8 codepoint
        // so if we would cut there, the character would be truncated
        len--;
    }
    return len;
 }
 #ifdef _WIN32
 wchar_t *
 utf8_to_wide_char(const char *utf8) {
    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    if (!len) {
        return NULL;
    }
    wchar_t *wide = malloc(len * sizeof(wchar_t));
    if (!wide) {
        return NULL;
    }
    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wide, len);
    return wide;
 }
 char *
 utf8_from_wide_char(const wchar_t *ws) {
    int len = WideCharToMultiByte(CP_UTF8, 0, ws, -1, NULL, 0, NULL, NULL);
    if (!len) {
        return NULL;
    }
    char *utf8 = malloc(len);
    if (!utf8) {
        return NULL;
    }
    WideCharToMultiByte(CP_UTF8, 0, ws, -1, utf8, len, NULL, NULL);
    return utf8;
 }
 #endif
--- a/app/src/util/thread.c
+++ b/app/src/util/thread.c
@@ -1,160 +0,0 @@
 #include "thread.h"
 #include <assert.h>
 #include <SDL2/SDL_thread.h>
 #include "log.h"
 bool
 sc_thread_create(sc_thread *thread, sc_thread_fn fn, const char *name,
                 void *userdata) {
    SDL_Thread *sdl_thread = SDL_CreateThread(fn, name, userdata);
    if (!sdl_thread) {
        return false;
    }
    thread->thread = sdl_thread;
    return true;
 }
 void
 sc_thread_join(sc_thread *thread, int *status) {
    SDL_WaitThread(thread->thread, status);
 }
 bool
 sc_mutex_init(sc_mutex *mutex) {
    SDL_mutex *sdl_mutex = SDL_CreateMutex();
    if (!sdl_mutex) {
        return false;
    }
    mutex->mutex = sdl_mutex;
 #ifndef NDEBUG
    mutex->locker = 0;
 #endif
    return true;
 }
 void
 sc_mutex_destroy(sc_mutex *mutex) {
    SDL_DestroyMutex(mutex->mutex);
 }
 void
 sc_mutex_lock(sc_mutex *mutex) {
    // SDL mutexes are recursive, but we don't want to use recursive mutexes
    assert(!sc_mutex_held(mutex));
    int r = SDL_LockMutex(mutex->mutex);
 #ifndef NDEBUG
    if (r) {
        LOGC("Could not lock mutex: %s", SDL_GetError());
        abort();
    }
    mutex->locker = sc_thread_get_id();
 #else
    (void) r;
 #endif
 }
 void
 sc_mutex_unlock(sc_mutex *mutex) {
 #ifndef NDEBUG
    assert(sc_mutex_held(mutex));
    mutex->locker = 0;
 #endif
    int r = SDL_UnlockMutex(mutex->mutex);
 #ifndef NDEBUG
    if (r) {
        LOGC("Could not lock mutex: %s", SDL_GetError());
        abort();
    }
 #else
    (void) r;
 #endif
 }
 sc_thread_id
 sc_thread_get_id(void) {
    return SDL_ThreadID();
 }
 #ifndef NDEBUG
 bool
 sc_mutex_held(struct sc_mutex *mutex) {
    return mutex->locker == sc_thread_get_id();
 }
 #endif
 bool
 sc_cond_init(sc_cond *cond) {
    SDL_cond *sdl_cond = SDL_CreateCond();
    if (!sdl_cond) {
        return false;
    }
    cond->cond = sdl_cond;
    return true;
 }
 void
 sc_cond_destroy(sc_cond *cond) {
    SDL_DestroyCond(cond->cond);
 }
 void
 sc_cond_wait(sc_cond *cond, sc_mutex *mutex) {
    int r = SDL_CondWait(cond->cond, mutex->mutex);
 #ifndef NDEBUG
    if (r) {
        LOGC("Could not wait on condition: %s", SDL_GetError());
        abort();
    }
    mutex->locker = sc_thread_get_id();
 #else
    (void) r;
 #endif
 }
 bool
 sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms) {
    int r = SDL_CondWaitTimeout(cond->cond, mutex->mutex, ms);
 #ifndef NDEBUG
    if (r < 0) {
        LOGC("Could not wait on condition with timeout: %s", SDL_GetError());
        abort();
    }
    mutex->locker = sc_thread_get_id();
 #endif
    assert(r == 0 || r == SDL_MUTEX_TIMEDOUT);
    return r == 0;
 }
 void
 sc_cond_signal(sc_cond *cond) {
    int r = SDL_CondSignal(cond->cond);
 #ifndef NDEBUG
    if (r) {
        LOGC("Could not signal a condition: %s", SDL_GetError());
        abort();
    }
 #else
    (void) r;
 #endif
 }
 void
 sc_cond_broadcast(sc_cond *cond) {
    int r = SDL_CondBroadcast(cond->cond);
 #ifndef NDEBUG
    if (r) {
        LOGC("Could not broadcast a condition: %s", SDL_GetError());
        abort();
    }
 #else
    (void) r;
 #endif
 }
--- a/app/src/util/thread.h
+++ b/app/src/util/thread.h
@@ -1,81 +0,0 @@
 #ifndef SC_THREAD_H
 #define SC_THREAD_H
 #include "common.h"
 #include <stdbool.h>
 #include <stdint.h>
 /* Forward declarations */
 typedef struct SDL_Thread SDL_Thread;
 typedef struct SDL_mutex SDL_mutex;
 typedef struct SDL_cond SDL_cond;
 typedef int sc_thread_fn(void *);
 typedef unsigned int sc_thread_id;
 typedef struct sc_thread {
    SDL_Thread *thread;
 } sc_thread;
 typedef struct sc_mutex {
    SDL_mutex *mutex;
 #ifndef NDEBUG
    sc_thread_id locker;
 #endif
 } sc_mutex;
 typedef struct sc_cond {
    SDL_cond *cond;
 } sc_cond;
 bool
 sc_thread_create(sc_thread *thread, sc_thread_fn fn, const char *name,
                 void *userdata);
 void
 sc_thread_join(sc_thread *thread, int *status);
 bool
 sc_mutex_init(sc_mutex *mutex);
 void
 sc_mutex_destroy(sc_mutex *mutex);
 void
 sc_mutex_lock(sc_mutex *mutex);
 void
 sc_mutex_unlock(sc_mutex *mutex);
 sc_thread_id
 sc_thread_get_id(void);
 #ifndef NDEBUG
 bool
 sc_mutex_held(struct sc_mutex *mutex);
 # define sc_mutex_assert(mutex) assert(sc_mutex_held(mutex))
 #else
 # define sc_mutex_assert(mutex)
 #endif
 bool
 sc_cond_init(sc_cond *cond);
 void
 sc_cond_destroy(sc_cond *cond);
 void
 sc_cond_wait(sc_cond *cond, sc_mutex *mutex);
 // return true on signaled, false on timeout
 bool
 sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms);
 void
 sc_cond_signal(sc_cond *cond);
 void
 sc_cond_broadcast(sc_cond *cond);
 #endif
--- a/app/src/v4l2_sink.c
+++ b/app/src/v4l2_sink.c
@@ -1,356 +0,0 @@
 #include "v4l2_sink.h"
 #include "util/log.h"
 #include "util/str_util.h"
 /** Downcast frame_sink to sc_v4l2_sink */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_v4l2_sink, frame_sink)
 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
 static const AVOutputFormat *
 find_muxer(const char *name) {
 #ifdef SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
    void *opaque = NULL;
 #endif
    const AVOutputFormat *oformat = NULL;
    do {
 #ifdef SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
        oformat = av_muxer_iterate(&opaque);
 #else
        oformat = av_oformat_next(oformat);
 #endif
        // until null or containing the requested name
    } while (oformat && !strlist_contains(oformat->name, ',', name));
    return oformat;
 }
 static bool
 write_header(struct sc_v4l2_sink *vs, const AVPacket *packet) {
    AVStream *ostream = vs->format_ctx->streams[0];
    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
    if (!extradata) {
        LOGC("Could not allocate extradata");
        return false;
    }
    // copy the first packet to the extra data
    memcpy(extradata, packet->data, packet->size);
    ostream->codecpar->extradata = extradata;
    ostream->codecpar->extradata_size = packet->size;
    int ret = avformat_write_header(vs->format_ctx, NULL);
    if (ret < 0) {
        LOGE("Failed to write header to %s", vs->device_name);
        return false;
    }
    return true;
 }
 static void
 rescale_packet(struct sc_v4l2_sink *vs, AVPacket *packet) {
    AVStream *ostream = vs->format_ctx->streams[0];
    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
 }
 static bool
 write_packet(struct sc_v4l2_sink *vs, AVPacket *packet) {
    if (!vs->header_written) {
        bool ok = write_header(vs, packet);
        if (!ok) {
            return false;
        }
        vs->header_written = true;
        return true;
    }
    rescale_packet(vs, packet);
    bool ok = av_write_frame(vs->format_ctx, packet) >= 0;
    // Failing to write the last frame is not very serious, no future frame may
    // depend on it, so the resulting file will still be valid
    (void) ok;
    return true;
 }
 static bool
 encode_and_write_frame(struct sc_v4l2_sink *vs, const AVFrame *frame) {
    int ret = avcodec_send_frame(vs->encoder_ctx, frame);
    if (ret < 0 && ret != AVERROR(EAGAIN)) {
        LOGE("Could not send v4l2 video frame: %d", ret);
        return false;
    }
    AVPacket *packet = vs->packet;
    ret = avcodec_receive_packet(vs->encoder_ctx, packet);
    if (ret == 0) {
        // A packet was received
        bool ok = write_packet(vs, packet);
        av_packet_unref(packet);
        if (!ok) {
            LOGW("Could not send packet to v4l2 sink");
            return false;
        }
    } else if (ret != AVERROR(EAGAIN)) {
        LOGE("Could not receive v4l2 video packet: %d", ret);
        return false;
    }
    return true;
 }
 static int
 run_v4l2_sink(void *data) {
    struct sc_v4l2_sink *vs = data;
    for (;;) {
        sc_mutex_lock(&vs->mutex);
        while (!vs->stopped && vs->vb.pending_frame_consumed) {
            sc_cond_wait(&vs->cond, &vs->mutex);
        }
        if (vs->stopped) {
            sc_mutex_unlock(&vs->mutex);
            break;
        }
        sc_mutex_unlock(&vs->mutex);
        video_buffer_consume(&vs->vb, vs->frame);
        bool ok = encode_and_write_frame(vs, vs->frame);
        av_frame_unref(vs->frame);
        if (!ok) {
            LOGE("Could not send frame to v4l2 sink");
            break;
        }
    }
    LOGD("V4l2 thread ended");
    return 0;
 }
 static bool
 sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
    bool ok = video_buffer_init(&vs->vb);
    if (!ok) {
        return false;
    }
    ok = sc_mutex_init(&vs->mutex);
    if (!ok) {
        LOGC("Could not create mutex");
        goto error_video_buffer_destroy;
    }
    ok = sc_cond_init(&vs->cond);
    if (!ok) {
        LOGC("Could not create cond");
        goto error_mutex_destroy;
    }
    // FIXME
    const AVOutputFormat *format = find_muxer("video4linux2,v4l2");
    if (!format) {
        LOGE("Could not find v4l2 muxer");
        goto error_cond_destroy;
    }
    const AVCodec *encoder = avcodec_find_encoder(AV_CODEC_ID_RAWVIDEO);
    if (!encoder) {
        LOGE("Raw video encoder not found");
        return false;
    }
    vs->format_ctx = avformat_alloc_context();
    if (!vs->format_ctx) {
        LOGE("Could not allocate v4l2 output context");
        return false;
    }
    // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
    // returns (on purpose) a pointer-to-const, but AVFormatContext.oformat
    // still expects a pointer-to-non-const (it has not be updated accordingly)
    // <https://github.com/FFmpeg/FFmpeg/commit/0694d8702421e7aff1340038559c438b61bb30dd>
    vs->format_ctx->oformat = (AVOutputFormat *) format;
 #ifdef SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
    vs->format_ctx->url = strdup(vs->device_name);
    if (!vs->format_ctx->url) {
        LOGE("Could not strdup v4l2 device name");
        goto error_avformat_free_context;
        return false;
    }
 #else
    strncpy(vs->format_ctx->filename, vs->device_name,
            sizeof(vs->format_ctx->filename));
 #endif
    AVStream *ostream = avformat_new_stream(vs->format_ctx, encoder);
    if (!ostream) {
        LOGE("Could not allocate new v4l2 stream");
        goto error_avformat_free_context;
        return false;
    }
    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
    ostream->codecpar->codec_id = encoder->id;
    ostream->codecpar->format = AV_PIX_FMT_YUV420P;
    ostream->codecpar->width = vs->frame_size.width;
    ostream->codecpar->height = vs->frame_size.height;
    int ret = avio_open(&vs->format_ctx->pb, vs->device_name, AVIO_FLAG_WRITE);
    if (ret < 0) {
        LOGE("Failed to open output device: %s", vs->device_name);
        // ostream will be cleaned up during context cleaning
        goto error_avformat_free_context;
    }
    vs->encoder_ctx = avcodec_alloc_context3(encoder);
    if (!vs->encoder_ctx) {
        LOGC("Could not allocate codec context for v4l2");
        goto error_avio_close;
    }
    vs->encoder_ctx->width = vs->frame_size.width;
    vs->encoder_ctx->height = vs->frame_size.height;
    vs->encoder_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
    vs->encoder_ctx->time_base.num = 1;
    vs->encoder_ctx->time_base.den = 1;
    if (avcodec_open2(vs->encoder_ctx, encoder, NULL) < 0) {
        LOGE("Could not open codec for v4l2");
        goto error_avcodec_free_context;
    }
    vs->frame = av_frame_alloc();
    if (!vs->frame) {
        LOGE("Could not create v4l2 frame");
        goto error_avcodec_close;
    }
    vs->packet = av_packet_alloc();
    if (!vs->packet) {
        LOGE("Could not allocate packet");
        goto error_av_frame_free;
    }
    LOGD("Starting v4l2 thread");
    ok = sc_thread_create(&vs->thread, run_v4l2_sink, "v4l2", vs);
    if (!ok) {
        LOGC("Could not start v4l2 thread");
        goto error_av_packet_free;
    }
    vs->header_written = false;
    vs->stopped = false;
    LOGI("v4l2 sink started to device: %s", vs->device_name);
    return true;
 error_av_packet_free:
    av_packet_free(&vs->packet);
 error_av_frame_free:
    av_frame_free(&vs->frame);
 error_avcodec_close:
    avcodec_close(vs->encoder_ctx);
 error_avcodec_free_context:
    avcodec_free_context(&vs->encoder_ctx);
 error_avio_close:
    avio_close(vs->format_ctx->pb);
 error_avformat_free_context:
    avformat_free_context(vs->format_ctx);
 error_cond_destroy:
    sc_cond_destroy(&vs->cond);
 error_mutex_destroy:
    sc_mutex_destroy(&vs->mutex);
 error_video_buffer_destroy:
    video_buffer_destroy(&vs->vb);
    return false;
 }
 static void
 sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
    sc_mutex_lock(&vs->mutex);
    vs->stopped = true;
    sc_cond_signal(&vs->cond);
    sc_mutex_unlock(&vs->mutex);
    sc_thread_join(&vs->thread, NULL);
    av_packet_free(&vs->packet);
    av_frame_free(&vs->frame);
    avcodec_close(vs->encoder_ctx);
    avcodec_free_context(&vs->encoder_ctx);
    avio_close(vs->format_ctx->pb);
    avformat_free_context(vs->format_ctx);
    sc_cond_destroy(&vs->cond);
    sc_mutex_destroy(&vs->mutex);
    video_buffer_destroy(&vs->vb);
 }
 static bool
 sc_v4l2_sink_push(struct sc_v4l2_sink *vs, const AVFrame *frame) {
    bool ok = video_buffer_push(&vs->vb, frame, NULL);
    if (!ok) {
        return false;
    }
    // signal possible change of vs->vb.pending_frame_consumed
    sc_cond_signal(&vs->cond);
    return true;
 }
 static bool
 sc_v4l2_frame_sink_open(struct sc_frame_sink *sink) {
    struct sc_v4l2_sink *vs = DOWNCAST(sink);
    return sc_v4l2_sink_open(vs);
 }
 static void
 sc_v4l2_frame_sink_close(struct sc_frame_sink *sink) {
    struct sc_v4l2_sink *vs = DOWNCAST(sink);
    sc_v4l2_sink_close(vs);
 }
 static bool
 sc_v4l2_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
    struct sc_v4l2_sink *vs = DOWNCAST(sink);
    return sc_v4l2_sink_push(vs, frame);
 }
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
                  struct size frame_size) {
    vs->device_name = strdup(device_name);
    if (!vs->device_name) {
        LOGE("Could not strdup v4l2 device name");
        return false;
    }
    vs->frame_size = frame_size;
    static const struct sc_frame_sink_ops ops = {
        .open = sc_v4l2_frame_sink_open,
        .close = sc_v4l2_frame_sink_close,
        .push = sc_v4l2_frame_sink_push,
    };
    vs->frame_sink.ops = &ops;
    return true;
 }
 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs) {
    free(vs->device_name);
 }
--- a/app/src/v4l2_sink.h
+++ b/app/src/v4l2_sink.h
@@ -1,39 +0,0 @@
 #ifndef SC_V4L2_SINK_H
 #define SC_V4L2_SINK_H
 #include "common.h"
 #include "coords.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
 #include <libavformat/avformat.h>
 struct sc_v4l2_sink {
    struct sc_frame_sink frame_sink; // frame sink trait
    struct video_buffer vb;
    AVFormatContext *format_ctx;
    AVCodecContext *encoder_ctx;
    char *device_name;
    struct size frame_size;
    sc_thread thread;
    sc_mutex mutex;
    sc_cond cond;
    bool stopped;
    bool header_written;
    AVFrame *frame;
    AVPacket *packet;
 };
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
                  struct size frame_size);
 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);
 #endif
--- a/app/src/video_buffer.c
+++ b/app/src/video_buffer.c
@@ -1,88 +1,113 @@
 #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 "util/log.h"
+#include "config.h"
 #include "lock_util.h"
 #include "log.h"
 bool
-video_buffer_init(struct video_buffer *vb) {
+video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
-    vb->pending_frame = av_frame_alloc();
+                  bool render_expired_frames) {
-    if (!vb->pending_frame) {
+    vb->fps_counter = fps_counter;
-        return false;
+
    if (!(vb->decoding_frame = av_frame_alloc())) {
        goto error_0;
    }
-    vb->tmp_frame = av_frame_alloc();
+    if (!(vb->rendering_frame = av_frame_alloc())) {
-    if (!vb->tmp_frame) {
+        goto error_1;
        av_frame_free(&vb->pending_frame);
        return false;
    }
-    bool ok = sc_mutex_init(&vb->mutex);
+    if (!(vb->mutex = SDL_CreateMutex())) {
-    if (!ok) {
+        goto error_2;
        av_frame_free(&vb->pending_frame);
        av_frame_free(&vb->tmp_frame);
        return false;
    }
-    // there is initially no frame, so consider it has already been consumed
+    vb->render_expired_frames = render_expired_frames;
-    vb->pending_frame_consumed = true;
+    if (render_expired_frames) {
        if (!(vb->rendering_frame_consumed_cond = SDL_CreateCond())) {
            SDL_DestroyMutex(vb->mutex);
            goto error_2;
        }
        // interrupted is not used if expired frames are not rendered
        // since offering a frame will never block
        vb->interrupted = false;
    }
    // there is initially no rendering frame, so consider it has already been
    // consumed
    vb->rendering_frame_consumed = true;
    return true;
 error_2:
    av_frame_free(&vb->rendering_frame);
 error_1:
    av_frame_free(&vb->decoding_frame);
 error_0:
    return false;
 }
 void
 video_buffer_destroy(struct video_buffer *vb) {
-    sc_mutex_destroy(&vb->mutex);
+    if (vb->render_expired_frames) {
-    av_frame_free(&vb->pending_frame);
+        SDL_DestroyCond(vb->rendering_frame_consumed_cond);
-    av_frame_free(&vb->tmp_frame);
+    }
    SDL_DestroyMutex(vb->mutex);
    av_frame_free(&vb->rendering_frame);
    av_frame_free(&vb->decoding_frame);
 }
-static inline void
+static void
-swap_frames(AVFrame **lhs, AVFrame **rhs) {
+video_buffer_swap_frames(struct video_buffer *vb) {
-    AVFrame *tmp = *lhs;
+    AVFrame *tmp = vb->decoding_frame;
-    *lhs = *rhs;
+    vb->decoding_frame = vb->rendering_frame;
-    *rhs = tmp;
+    vb->rendering_frame = tmp;
 }
 bool
 video_buffer_push(struct video_buffer *vb, const AVFrame *frame,
                  bool *previous_frame_skipped) {
    sc_mutex_lock(&vb->mutex);
    // Use a temporary frame to preserve pending_frame in case of error.
    // tmp_frame is an empty frame, no need to call av_frame_unref() beforehand.
    int r = av_frame_ref(vb->tmp_frame, frame);
    if (r) {
        LOGE("Could not ref frame: %d", r);
        return false;
    }
    // Now that av_frame_ref() succeeded, we can replace the previous
    // pending_frame
    swap_frames(&vb->pending_frame, &vb->tmp_frame);
    av_frame_unref(vb->tmp_frame);
    if (previous_frame_skipped) {
        *previous_frame_skipped = !vb->pending_frame_consumed;
    }
    vb->pending_frame_consumed = false;
    sc_mutex_unlock(&vb->mutex);
    return true;
 }
 void
-video_buffer_consume(struct video_buffer *vb, AVFrame *dst) {
+video_buffer_offer_decoded_frame(struct video_buffer *vb,
-    sc_mutex_lock(&vb->mutex);
+                                 bool *previous_frame_skipped) {
-    assert(!vb->pending_frame_consumed);
+    mutex_lock(vb->mutex);
-    vb->pending_frame_consumed = true;
+    if (vb->render_expired_frames) {
        // wait for the current (expired) frame to be consumed
        while (!vb->rendering_frame_consumed && !vb->interrupted) {
            cond_wait(vb->rendering_frame_consumed_cond, vb->mutex);
        }
    } else if (!vb->rendering_frame_consumed) {
        fps_counter_add_skipped_frame(vb->fps_counter);
    }
-    av_frame_move_ref(dst, vb->pending_frame);
+    video_buffer_swap_frames(vb);
    // av_frame_move_ref() resets its source frame, so no need to call
    // av_frame_unref()
-    sc_mutex_unlock(&vb->mutex);
+    *previous_frame_skipped = !vb->rendering_frame_consumed;
    vb->rendering_frame_consumed = false;
    mutex_unlock(vb->mutex);
 }
 const AVFrame *
 video_buffer_consume_rendered_frame(struct video_buffer *vb) {
    SDL_assert(!vb->rendering_frame_consumed);
    vb->rendering_frame_consumed = true;
    fps_counter_add_rendered_frame(vb->fps_counter);
    if (vb->render_expired_frames) {
        // unblock video_buffer_offer_decoded_frame()
        cond_signal(vb->rendering_frame_consumed_cond);
    }
    return vb->rendering_frame;
 }
 void
 video_buffer_interrupt(struct video_buffer *vb) {
    if (vb->render_expired_frames) {
        mutex_lock(vb->mutex);
        vb->interrupted = true;
        mutex_unlock(vb->mutex);
        // wake up blocking wait
        cond_signal(vb->rendering_frame_consumed_cond);
    }
 }
--- a/app/src/video_buffer.h
+++ b/app/src/video_buffer.h
@@ -1,50 +1,49 @@
 #ifndef VIDEO_BUFFER_H
 #define VIDEO_BUFFER_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL_mutex.h>
 #include "config.h"
 #include "fps_counter.h"
 #include "util/thread.h"
 // forward declarations
 typedef struct AVFrame AVFrame;
 /**
 * A video buffer holds 1 pending frame, which is the last frame received from
 * the producer (typically, the decoder).
 *
 * If a pending frame has not been consumed when the producer pushes a new
 * frame, then it is lost. The intent is to always provide access to the very
 * last frame to minimize latency.
 *
 * The producer and the consumer typically do not live in the same thread.
 * That's the reason why the callback on_frame_available() does not provide the
 * frame as parameter: the consumer might post an event to its own thread to
 * retrieve the pending frame from there, and that frame may have changed since
 * the callback if producer pushed a new one in between.
 */
 struct video_buffer {
-    AVFrame *pending_frame;
+    AVFrame *decoding_frame;
-    AVFrame *tmp_frame; // To preserve the pending frame on error
+    AVFrame *rendering_frame;
-
+    SDL_mutex *mutex;
-    sc_mutex mutex;
+    bool render_expired_frames;
-
+    bool interrupted;
-    bool pending_frame_consumed;
+    SDL_cond *rendering_frame_consumed_cond;
    bool rendering_frame_consumed;
    struct fps_counter *fps_counter;
 };
 bool
-video_buffer_init(struct video_buffer *vb);
+video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
                  bool render_expired_frames);
 void
 video_buffer_destroy(struct video_buffer *vb);
-bool
+// set the decoded frame as ready for rendering
-video_buffer_push(struct video_buffer *vb, const AVFrame *frame, bool *skipped);
+// this function locks frames->mutex during its execution
-
+// the output flag is set to report whether the previous frame has been skipped
 void
-video_buffer_consume(struct video_buffer *vb, AVFrame *dst);
+video_buffer_offer_decoded_frame(struct video_buffer *vb,
                                 bool *previous_frame_skipped);
 // mark the rendering frame as consumed and return it
 // MUST be called with frames->mutex locked!!!
 // the caller is expected to render the returned frame to some texture before
 // unlocking frames->mutex
 const AVFrame *
 video_buffer_consume_rendered_frame(struct video_buffer *vb);
 // wake up and avoid any blocking call
 void
 video_buffer_interrupt(struct video_buffer *vb);
 #endif
--- a/app/tests/test_buffer_util.c
+++ b/app/tests/test_buffer_util.c
@@ -1,81 +0,0 @@
 #include "common.h"
 #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,9 +1,7 @@
 #include "common.h"
 #include <assert.h>
 #include <string.h>
-#include "util/cbuf.h"
+#include "cbuf.h"
 struct int_queue CBUF(int, 32);
@@ -67,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,172 +0,0 @@
 #include "common.h"
 #include <assert.h>
 #include <string.h>
 #include "cli.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", // optional arguments require '='
        // "--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",
        "--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(!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
@@ -1,5 +1,3 @@
 #include "common.h"
 #include <assert.h>
 #include <string.h>
@@ -11,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];
-    size_t size = control_msg_serialize(&msg, buf);
+    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)));
@@ -38,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];
-    size_t size = control_msg_serialize(&msg, buf);
+    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)));
@@ -53,22 +49,20 @@ 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];
-    size_t size = control_msg_serialize(&msg, buf);
+    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)));
 }
@@ -94,8 +88,8 @@ static void test_serialize_inject_touch_event(void) {
        },
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    size_t size = control_msg_serialize(&msg, buf);
+    int size = control_msg_serialize(&msg, buf);
    assert(size == 28);
    const unsigned char expected[] = {
@@ -129,8 +123,8 @@ static void test_serialize_inject_scroll_event(void) {
        },
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    size_t size = control_msg_serialize(&msg, buf);
+    int size = control_msg_serialize(&msg, buf);
    assert(size == 21);
    const unsigned char expected[] = {
@@ -146,18 +140,14 @@ static void test_serialize_inject_scroll_event(void) {
 static void test_serialize_back_or_screen_on(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
        .back_or_screen_on = {
            .action = AKEY_EVENT_ACTION_UP,
        },
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    size_t size = control_msg_serialize(&msg, buf);
+    int size = control_msg_serialize(&msg, buf);
-    assert(size == 2);
+    assert(size == 1);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
        0x01, // AKEY_EVENT_ACTION_UP
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
@@ -167,8 +157,8 @@ 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];
-    size_t size = control_msg_serialize(&msg, buf);
+    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);
    const unsigned char expected[] = {
@@ -177,32 +167,17 @@ static void test_serialize_expand_notification_panel(void) {
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
-static void test_serialize_expand_settings_panel(void) {
+static void test_serialize_collapse_notification_panel(void) {
    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+        .type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    size_t size = control_msg_serialize(&msg, buf);
+    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);
    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+        CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
 static void test_serialize_collapse_panels(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_COLLAPSE_PANELS,
    };
    unsigned char buf[CONTROL_MSG_MAX_SIZE];
    size_t size = control_msg_serialize(&msg, buf);
    assert(size == 1);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_COLLAPSE_PANELS,
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
@@ -212,8 +187,8 @@ 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];
-    size_t size = control_msg_serialize(&msg, buf);
+    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);
    const unsigned char expected[] = {
@@ -225,20 +200,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];
-    size_t size = control_msg_serialize(&msg, buf);
+    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)));
@@ -252,8 +225,8 @@ static void test_serialize_set_screen_power_mode(void) {
        },
    };
-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    size_t size = control_msg_serialize(&msg, buf);
+    int size = control_msg_serialize(&msg, buf);
    assert(size == 2);
    const unsigned char expected[] = {
@@ -263,25 +236,7 @@ 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];
    size_t 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();
@@ -289,11 +244,9 @@ int main(int argc, char *argv[]) {
    test_serialize_inject_scroll_event();
    test_serialize_back_or_screen_on();
    test_serialize_expand_notification_panel();
-    test_serialize_expand_settings_panel();
+    test_serialize_collapse_notification_panel();
    test_serialize_collapse_panels();
    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
@@ -1,22 +1,19 @@
 #include "common.h"
 #include <assert.h>
 #include <string.h>
 #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);
@@ -25,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,8 +1,6 @@
 #include "common.h"
 #include <assert.h>
-#include "util/queue.h"
+#include <queue.h>
 struct foo {
    int value;
@@ -34,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,11 +1,7 @@
 #include "common.h"
 #include <assert.h>
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
-#include "util/str_util.h"
+#include "str_util.h"
 static void test_xstrncpy_simple(void) {
    char s[] = "xxxxxxxxxx";
@@ -130,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));
    free(out);
 }
 static void test_utf8_truncate(void) {
    const char *s = "aÉbÔc";
    assert(strlen(s) == 7); // É and Ô are 2 bytes-wide
@@ -171,138 +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);
 }
 static void test_strlist_contains(void) {
    assert(strlist_contains("a,bc,def", ',', "bc"));
    assert(!strlist_contains("a,bc,def", ',', "b"));
    assert(strlist_contains("", ',', ""));
    assert(strlist_contains("abc,", ',', ""));
    assert(strlist_contains(",abc", ',', ""));
    assert(strlist_contains("abc,,def", ',', ""));
    assert(!strlist_contains("abc", ',', ""));
    assert(strlist_contains(",,|x", '|', ",,"));
    assert(strlist_contains("xyz", '\0', "xyz"));
 }
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;
    test_xstrncpy_simple();
    test_xstrncpy_just_fit();
    test_xstrncpy_truncated();
@@ -311,11 +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();
    test_strlist_contains();
    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
@@ -2,11 +2,11 @@
 [binaries]
 name = 'mingw'
-c = 'i686-w64-mingw32-gcc'
+c = '/usr/bin/i686-w64-mingw32-gcc'
-cpp = 'i686-w64-mingw32-g++'
+cpp = '/usr/bin/i686-w64-mingw32-g++'
-ar = 'i686-w64-mingw32-ar'
+ar = '/usr/bin/i686-w64-mingw32-ar'
-strip = 'i686-w64-mingw32-strip'
+strip = '/usr/bin/i686-w64-mingw32-strip'
-pkgconfig = 'i686-w64-mingw32-pkg-config'
+pkgconfig = '/usr/bin/i686-w64-mingw32-pkg-config'
 [host_machine]
 system = 'windows'
@@ -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
@@ -2,11 +2,11 @@
 [binaries]
 name = 'mingw'
-c = 'x86_64-w64-mingw32-gcc'
+c = '/usr/bin/x86_64-w64-mingw32-gcc'
-cpp = 'x86_64-w64-mingw32-g++'
+cpp = '/usr/bin/x86_64-w64-mingw32-g++'
-ar = 'x86_64-w64-mingw32-ar'
+ar = '/usr/bin/x86_64-w64-mingw32-ar'
-strip = 'x86_64-w64-mingw32-strip'
+strip = '/usr/bin/x86_64-w64-mingw32-strip'
-pkgconfig = 'x86_64-w64-mingw32-pkg-config'
+pkgconfig = '/usr/bin/x86_64-w64-mingw32-pkg-config'
 [host_machine]
 system = 'windows'
@@ -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/Show More
+++ b/Show More