realfps

2019-06-07 00:04:18 +02:00
89 changed files with 903 additions and 2079 deletions
--- a/BUILD.md
+++ b/BUILD.md
@ -12,7 +12,7 @@ case, use the [prebuilt server] (so you will not need Java or the Android SDK).
 ## Requirements

 You need [adb]. It is available in the [Android SDK platform
-tools][platform-tools], or packaged in your distribution (`adb`).
+tools][platform-tools], or packaged in your distribution (`android-adb-tools`).

 On Windows, download the [platform-tools][platform-tools-windows] and extract
 the following files to a directory accessible from your `PATH`:
@ -40,10 +40,10 @@ Install the required packages from your package manager.

 ```bash
 # runtime dependencies
-sudo apt install ffmpeg libsdl2-2.0-0
+sudo apt install ffmpeg libsdl2-2.0.0

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

@ -70,7 +70,7 @@ sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-rele
 sudo dnf install SDL2-devel ffms2-devel meson gcc make

 # server build dependencies
-sudo dnf install java-devel
+sudo dnf install java
 ```


@ -234,10 +234,10 @@ You can then [run](README.md#run) _scrcpy_.

 ## Prebuilt server

- - [`scrcpy-server-v1.10.jar`][direct-scrcpy-server]  
-   _(SHA-256: cbeb1a4e046f1392c1dc73c3ccffd7f86dec4636b505556ea20929687a119390)_
+ - [`scrcpy-server-v1.8.jar`][direct-scrcpy-server]  
+   _(SHA-256: 839055ef905903bf98ead1b9b8a127fe402b39ad657a81f9a914b2dbcb2ce5c0)_

-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.10/scrcpy-server-v1.10.jar
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.8/scrcpy-server-v1.8.jar

 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/DEVELOP.md
+++ b/DEVELOP.md
@ -32,7 +32,7 @@ The server is a Java application (with a [`public static void main(String...
 args)`][main] method), compiled against the Android framework, and executed as
 `shell` on the Android device.

-[main]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/Server.java#L123
+[main]: https://github.com/Genymobile/scrcpy/blob/v1.8/server/src/main/java/com/genymobile/scrcpy/Server.java#L100

 To run such a Java application, the classes must be [_dexed_][dex] (typically,
 to `classes.dex`). If `my.package.MainClass` is the main class, compiled to
@ -65,18 +65,18 @@ They can be called using reflection though. The communication with hidden
 components is provided by [_wrappers_ classes][wrappers] and [aidl].

 [hidden]: https://stackoverflow.com/a/31908373/1987178
-[wrappers]: https://github.com/Genymobile/scrcpy/tree/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/wrappers
-[aidl]: https://github.com/Genymobile/scrcpy/tree/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/aidl/android/view
+[wrappers]: https://github.com/Genymobile/scrcpy/blob/v1.8/server/src/main/java/com/genymobile/scrcpy/wrappers
+[aidl]: https://github.com/Genymobile/scrcpy/blob/v1.8/server/src/main/aidl/android/view


 ### Threading

-The server uses 3 threads:
+The server uses 2 threads:

 - the **main** thread, encoding and streaming the video to the client;
- - the **controller** thread, listening for _control messages_ (typically,
-   keyboard and mouse events) from the client;
- - the **receiver** thread (managed by the controller), sending _device messges_
+ - the **controller** thread, listening for _control events_ (typically,
+   keyboard and mouse events) from the client.
+ - the **receiver** thread (managed by the controller), sending _device events_
   to the clients (currently, it is only used to send the device clipboard
   content).

@ -92,9 +92,9 @@ The video is encoded using the [`MediaCodec`] API. The codec takes its input
 from a [surface] associated to the display, and writes the resulting H.264
 stream to the provided output stream (the socket connected to the client).

-[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/v1.8/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
 [`MediaCodec`]: https://developer.android.com/reference/android/media/MediaCodec.html
-[surface]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L68-L69
+[surface]: https://github.com/Genymobile/scrcpy/blob/v1.8/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L69-L70

 On device [rotation], the codec, surface and display are reinitialized, and a
 new video stream is produced.
@ -108,30 +108,31 @@ because it avoids to send unnecessary frames, but there are drawbacks:
 Both problems are [solved][repeat] by the flag
 [`KEY_REPEAT_PREVIOUS_FRAME_AFTER`][repeat-flag].

-[rotation]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L90
-[repeat]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L147-L148
+[rotation]: https://github.com/Genymobile/scrcpy/blob/v1.8/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L90
+[repeat]:
+https://github.com/Genymobile/scrcpy/blob/v1.8/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L147-L148
 [repeat-flag]: https://developer.android.com/reference/android/media/MediaFormat.html#KEY_REPEAT_PREVIOUS_FRAME_AFTER


 ### Input events injection

-_Control messages_ are received from the client by the [`Controller`] (run in a
-separate thread). There are several types of input events:
+_Control events_ are received from the client by the [`EventController`] (run in
+a separate thread). There are several types of input events:
 - keycode (cf [`KeyEvent`]),
 - text (special characters may not be handled by keycodes directly),
 - mouse motion/click,
 - mouse scroll,
 - other commands (e.g. to switch the screen on or to copy the clipboard).

-Some of them need to inject input events to the system. To do so, they use the
-_hidden_ method [`InputManager.injectInputEvent`] (exposed by our
+All of them may need to inject input events to the system. To do so, they use
+the _hidden_ method [`InputManager.injectInputEvent`] (exposed by our
 [`InputManager` wrapper][inject-wrapper]).

-[`Controller`]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/Controller.java#L81
+[`EventController`]: https://github.com/Genymobile/scrcpy/blob/v1.8/server/src/main/java/com/genymobile/scrcpy/EventController.java#L66
 [`KeyEvent`]: https://developer.android.com/reference/android/view/KeyEvent.html
 [`MotionEvent`]: https://developer.android.com/reference/android/view/MotionEvent.html
 [`InputManager.injectInputEvent`]: https://android.googlesource.com/platform/frameworks/base/+/oreo-release/core/java/android/hardware/input/InputManager.java#857
-[inject-wrapper]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27
+[inject-wrapper]: https://github.com/Genymobile/scrcpy/blob/v1.8/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27



@ -187,13 +188,12 @@ The client uses 4 threads:
 - the **main** thread, executing the SDL event loop,
 - the **stream** thread, receiving the video and used for decoding and
   recording,
- - the **controller** thread, sending _control messages_ to the server,
+ - the **controller** thread, sending _control events_ to the server.
 - the **receiver** thread (managed by the controller), receiving _device
-   messages_ from the client.
+   events_ 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
-print the framerate regularly in the console.
+installation or file push requests (via drag&drop on the main window).



@ -217,10 +217,10 @@ to decode a new frame while the main thread renders the last one.
 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
-[decoder]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/decoder.h
-[video_buffer]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/video_buffer.h
-[recorder]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/recorder.h
+[stream]: https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/stream.h
+[decoder]: https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/decoder.h
+[video_buffer]: https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/video_buffer.h
+[recorder]: https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/recorder.h

 ```
                                   +----------+      +----------+
@ -234,19 +234,19 @@ H.264 packet to the output video file.

 ### Controller

-The [controller] is responsible to send _control messages_ to the device. It
-runs in a separate thread, to avoid I/O on the main thread.
+The [controller] is responsible to send _control events_ to the device. It runs
+in a separate thread, to avoid I/O on the main thread.

 On SDL event, received on the main thread, the [input manager][inputmanager]
-creates appropriate [_control messages_][controlmsg]. It is responsible to
+creates appropriate [_control events_][controlevent]. It is responsible to
 convert SDL events to Android events (using [convert]). It pushes the _control
-messages_ to a queue hold by the controller. On its own thread, the controller
-takes messages from the queue, that it serializes and sends to the client.
+events_ to a queue hold by the controller. On its own thread, the controller
+takes events from the queue, that it serializes and sends to the client.

-[controller]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/controller.h
-[controlmsg]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/control_msg.h
-[inputmanager]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/input_manager.h
-[convert]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/convert.h
+[controller]: https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/controller.h
+[controlevent]: https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/control_event.h
+[inputmanager]: https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/input_manager.h
+[convert]: https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/convert.h


 ### UI and event loop
@ -257,9 +257,10 @@ thread.
 Events are handled in the [event loop], which either updates the [screen] or
 delegates to the [input manager][inputmanager].

-[scrcpy]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/scrcpy.c
-[event loop]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/scrcpy.c#L201
-[screen]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/screen.h
+[scrcpy]: https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/scrcpy.c
+[event loop]:
+https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/scrcpy.c#L187
+[screen]: https://github.com/Genymobile/scrcpy/blob/v1.8/app/src/screen.h


 ## Hack
--- a/FAQ.md
+++ b/FAQ.md
@ -1,5 +1,10 @@
 # Frequently Asked Questions

+## Common issues
+
+The application is very young, it is not unlikely that you encounter problems
+with it.
+
 Here are the common reported problems and their status.


@ -14,14 +19,14 @@ Windows may need some [drivers] to detect your device.

 [drivers]: https://developer.android.com/studio/run/oem-usb.html

+If you still encounter problems, please see [issue 9].

-### I can only mirror, I cannot interact with the device
+[issue 9]: https://github.com/Genymobile/scrcpy/issues/9
+
+
+### Mouse clicks do not work

 On some devices, you may need to enable an option to allow [simulating input].
-In developer options, enable:
-
-> **USB debugging (Security settings)**  
-> _Allow granting permissions and simulating input via USB debugging_

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

@ -42,16 +47,6 @@ meson x --buildtype release -Dhidpi_support=false
 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_.
-
-[scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
-
-
 ### KWin compositor crashes

 On Plasma Desktop, compositor is disabled while _scrcpy_ is running.
@ -59,26 +54,3 @@ On Plasma Desktop, compositor is disabled while _scrcpy_ is running.
 As a workaround, [disable "Block compositing"][kwin].

 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
-
-
-### I get an error "Could not open video stream"
-
-There may be many reasons. One common cause is that the hardware encoder of your
-device is not able to encode at the given definition:
-
-```
-ERROR: Exception on thread Thread[main,5,main]
-android.media.MediaCodec$CodecException: Error 0xfffffc0e
-...
-Exit due to uncaughtException in main thread:
-ERROR: Could not open video stream
-INFO: Initial texture: 1080x2336
-```
-
-Just try with a lower definition:
-
-```
-scrcpy -m 1920
-scrcpy -m 1024
-scrcpy -m 800
-```
--- a/1
+++ b/1
@ -188,7 +188,6 @@
      identification within third-party archives.

   Copyright (C) 2018 Genymobile
-   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
@ -44,7 +44,7 @@ clean:
 build-server:
 	[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
 		meson "$(SERVER_BUILD_DIR)" \
-			--buildtype release -Dcompile_app=false )
+			--buildtype release -Dbuild_app=false )
 		ninja -C "$(SERVER_BUILD_DIR)"

 prepare-deps-win32:
@ -56,8 +56,8 @@ build-win32: prepare-deps-win32
 			--cross-file cross_win32.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
-			-Dportable=true )
+			-Dbuild_server=false \
+			-Doverride_server_path=scrcpy-server.jar )
 	ninja -C "$(WIN32_BUILD_DIR)"

 build-win32-noconsole: prepare-deps-win32
@ -66,9 +66,9 @@ build-win32-noconsole: prepare-deps-win32
 			--cross-file cross_win32.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
+			-Dbuild_server=false \
 			-Dwindows_noconsole=true \
-			-Dportable=true )
+			-Doverride_server_path=scrcpy-server.jar )
 	ninja -C "$(WIN32_NOCONSOLE_BUILD_DIR)"

 prepare-deps-win64:
@ -80,8 +80,8 @@ build-win64: prepare-deps-win64
 			--cross-file cross_win64.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
-			-Dportable=true )
+			-Dbuild_server=false \
+			-Doverride_server_path=scrcpy-server.jar )
 	ninja -C "$(WIN64_BUILD_DIR)"

 build-win64-noconsole: prepare-deps-win64
@ -90,9 +90,9 @@ build-win64-noconsole: prepare-deps-win64
 			--cross-file cross_win64.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
+			-Dbuild_server=false \
 			-Dwindows_noconsole=true \
-			-Dportable=true )
+			-Doverride_server_path=scrcpy-server.jar )
 	ninja -C "$(WIN64_NOCONSOLE_BUILD_DIR)"

 dist-win32: build-server build-win32 build-win32-noconsole
@ -100,38 +100,36 @@ dist-win32: build-server build-win32 build-win32-noconsole
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.1.4-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.1.4-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.1.4-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/swresample-3.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.10/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.9/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"

 dist-win64: build-server build-win64 build-win64-noconsole
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.1.4-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.1.4-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.1.4-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win64-shared/bin/swresample-3.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.10/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.9/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"

 zip-win32: dist-win32
-	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
-		zip -r "../$(WIN32_TARGET)" .
+	cd "$(DIST)"; \
+		zip -r "$(WIN32_TARGET)" "$(WIN32_TARGET_DIR)"

 zip-win64: dist-win64
-	cd "$(DIST)/$(WIN64_TARGET_DIR)"; \
-		zip -r "../$(WIN64_TARGET)" .
+	cd "$(DIST)"; \
+		zip -r "$(WIN64_TARGET)" "$(WIN64_TARGET_DIR)"

 sums:
 	cd "$(DIST)"; \
--- a/README.md
+++ b/README.md
@ -1,26 +1,15 @@
-# scrcpy (v1.10)
+# scrcpy (v1.8)

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

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

-It focuses on:
-
- - **lightness** (native, displays only the device screen)
- - **performance** (30~60fps)
- - **quality** (1920×1080 or above)
- - **low latency** ([35~70ms][lowlatency])
- - **low startup time** (~1 second to display the first image)
- - **non-intrusiveness** (nothing is left installed on the device)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-

 ## Requirements

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

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

@ -40,12 +29,6 @@ control it using keyboard and mouse.
 On Linux, you typically need to [build the app manually][BUILD]. Don't worry,
 it's not that hard.

-A [Snap] package is available: [`scrcpy`][snap-link].
-
-[snap-link]: https://snapstats.org/snaps/scrcpy
-
-[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
-
 For Arch Linux, an [AUR] package is available: [`scrcpy`][aur-link].

 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
@ -62,18 +45,18 @@ For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
 For Windows, for simplicity, prebuilt archives with all the dependencies
 (including `adb`) are available:

- - [`scrcpy-win32-v1.10.zip`][direct-win32]  
-   _(SHA-256: f98b400b3764404b33b212e9762dd6f1593ddb766c1480fc2609c94768e4a8e1)_
- - [`scrcpy-win64-v1.10.zip`][direct-win64]  
-   _(SHA-256: 95de34575d873c7e95dfcfb5e74d0f6af4f70b2a5bc6fde0f48d1a05480e3a44)_
+ - [`scrcpy-win32-v1.8.zip`][direct-win32]  
+   _(SHA-256: c0c29ed1c66deaa73bdadacd09e598aafb3a117929cf7a314cce1cc45e34de53)_
+ - [`scrcpy-win64-v1.8.zip`][direct-win64]  
+   _(SHA-256: 9cc980d07bd8f036ae4e91d0bc6fc3281d7fa8f9752d4913b643c0fb72a19fb7)_

-[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
+[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.8/scrcpy-win32-v1.8.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.8/scrcpy-win64-v1.8.zip

 You can also [build the app manually][BUILD].


-### macOS
+### Mac OS

 The application is available in [Homebrew]. Just install it:

@ -112,22 +95,22 @@ scrcpy --help
 ### Reduce size

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

-To limit both the width and height to some value (e.g. 1024):
+To limit both width and height to some value (e.g. 1024):

 ```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # short version
 ```

-The other dimension is computed to that the device aspect ratio is preserved.
+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

-The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):
+The default bit-rate is 8Mbps. To change the video bitrate (e.g. to 2Mbps):

 ```bash
 scrcpy --bit-rate 2M
@ -139,7 +122,7 @@ scrcpy -b 2M  # short version

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

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

 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
@ -262,11 +245,6 @@ _scrcpy_ window.

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

-The target directory can be changed on start:
-
-```bash
-scrcpy --push-target /sdcard/foo/bar/
-```

 ### Read-only

@ -305,47 +283,42 @@ latency), use:
 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'
-```
-

 ### Forward audio

-Audio is not forwarded by _scrcpy_. Use [USBaudio] (Linux-only).
+Audio is not forwarded by _scrcpy_.

-Also see [issue #14].
+There is a limited solution using [AOA], implemented in the [`audio`] branch. If
+you are interested, see [issue 14].

-[USBaudio]: https://github.com/rom1v/usbaudio
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
+
+[AOA]: https://source.android.com/devices/accessories/aoa2
+[`audio`]: https://github.com/Genymobile/scrcpy/commits/audio
+[issue 14]: https://github.com/Genymobile/scrcpy/issues/14


 ## Shortcuts

- | Action                                 |   Shortcut                    |   Shortcut (macOS)
- | -------------------------------------- |:----------------------------- |:-----------------------------
- | Switch fullscreen mode                 | `Ctrl`+`f`                    | `Cmd`+`f`
- | Resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`                    | `Cmd`+`g`
- | 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_
- | Click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  | `Cmd`+`b`  \| _Right-click²_
- | Click on `APP_SWITCH`                  | `Ctrl`+`s`                    | `Cmd`+`s`
- | Click on `MENU`                        | `Ctrl`+`m`                    | `Ctrl`+`m`
- | Click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_             | `Cmd`+`↑` _(up)_
- | Click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_           | `Cmd`+`↓` _(down)_
- | Click on `POWER`                       | `Ctrl`+`p`                    | `Cmd`+`p`
- | Power on                               | _Right-click²_                | _Right-click²_
- | Turn device screen off (keep mirroring)| `Ctrl`+`o`                    | `Cmd`+`o`
- | Expand notification panel              | `Ctrl`+`n`                    | `Cmd`+`n`
- | Collapse notification panel            | `Ctrl`+`Shift`+`n`            | `Cmd`+`Shift`+`n`
- | Copy device clipboard to computer      | `Ctrl`+`c`                    | `Cmd`+`c`
- | Paste computer clipboard to device     | `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`
+ | Action                                 |   Shortcut                    |
+ | -------------------------------------- |:----------------------------  |
+ | switch fullscreen mode                 | `Ctrl`+`f`                    |
+ | resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`                    |
+ | resize window to remove black borders  | `Ctrl`+`x` \| _Double-click¹_ |
+ | click on `HOME`                        | `Ctrl`+`h` \| _Middle-click_  |
+ | click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  |
+ | click on `APP_SWITCH`                  | `Ctrl`+`s`                    |
+ | click on `MENU`                        | `Ctrl`+`m`                    |
+ | click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_   (`Cmd`+`↑` on MacOS) |
+ | click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_ (`Cmd`+`↓` on MacOS) |
+ | click on `POWER`                       | `Ctrl`+`p`                    |
+ | power on                               | _Right-click²_                |
+ | turn device screen off (keep mirroring)| `Ctrl`+`o`                    |
+ | expand notification panel              | `Ctrl`+`n`                    |
+ | collapse notification panel            | `Ctrl`+`Shift`+`n`            |
+ | copy device clipboard to computer      | `Ctrl`+`c`                    |
+ | paste computer clipboard to device     | `Ctrl`+`v`                    |
+ | copy computer clipboard to device      | `Ctrl`+`Shift+`v`             |
+ | enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    |

 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._
@ -358,8 +331,8 @@ To use a specific _adb_ binary, configure its path in the environment variable

    ADB=/path/to/adb scrcpy

-To override the path of the `scrcpy-server.jar` file, configure its path in
-`SCRCPY_SERVER_PATH`.
+To override the path of the `scrcpy-server.jar` file (it can be [useful] on
+Windows), configure its path in `SCRCPY_SERVER_PATH`.

 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345

@ -396,7 +369,6 @@ Read the [developers page].
 ## Licence

    Copyright (C) 2018 Genymobile
-    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/app/meson.build
+++ b/app/meson.build
@ -3,13 +3,14 @@ src = [
    'src/command.c',
    'src/control_msg.c',
    'src/controller.c',
+    'src/convert.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/lock_util.c',
    'src/net.c',
    'src/receiver.c',
    'src/recorder.c',
@ -93,9 +94,21 @@ conf.set_quoted('SCRCPY_VERSION', meson.project_version())
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))

-# build a "portable" version (with scrcpy-server.jar accessible from the same
-# directory as the executable)
-conf.set('PORTABLE', get_option('portable'))
+# the path of the server, which will be appended to the prefix
+# ignored if OVERRIDE_SERVER_PATH if defined
+# must be consistent with the install_dir in server/meson.build
+conf.set_quoted('PREFIXED_SERVER_PATH', '/share/scrcpy/scrcpy-server.jar')
+
+# the path of the server to be used "as is"
+# this is useful for building a "portable" version (with the server in the same
+# directory as the client)
+override_server_path = get_option('override_server_path')
+if override_server_path != ''
+    conf.set_quoted('OVERRIDE_SERVER_PATH', override_server_path)
+else
+    # undefine it
+    conf.set('OVERRIDE_SERVER_PATH', false)
+endif

 # the default client TCP port for the "adb reverse" tunnel
 # overridden by option --port
@ -150,9 +163,6 @@ tests = [
        'tests/test_device_msg_deserialize.c',
        'src/device_msg.c'
    ]],
-    ['test_queue', [
-        'tests/test_queue.c',
-    ]],
    ['test_strutil', [
        'tests/test_strutil.c',
        'src/str_util.c'
--- a/app/src/buffer_util.h
+++ b/app/src/buffer_util.h
@ -4,8 +4,6 @@
 #include <stdbool.h>
 #include <stdint.h>

-#include "config.h"
-
 static inline void
 buffer_write16be(uint8_t *buf, uint16_t value) {
    buf[0] = value >> 8;
@ -20,12 +18,6 @@ buffer_write32be(uint8_t *buf, uint32_t value) {
    buf[3] = value;
 }

-static inline void
-buffer_write64be(uint8_t *buf, uint64_t value) {
-    buffer_write32be(buf, value >> 32);
-    buffer_write32be(&buf[4], (uint32_t) value);
-}
-
 static inline uint16_t
 buffer_read16be(const uint8_t *buf) {
    return (buf[0] << 8) | buf[1];
--- a/app/src/cbuf.h
+++ b/app/src/cbuf.h
@ -5,10 +5,8 @@
 #include <stdbool.h>
 #include <unistd.h>

-#include "config.h"
-
 // To define a circular buffer type of 20 ints:
-//     struct cbuf_int CBUF(int, 20);
+//     typedef CBUF(int, 20) my_cbuf_t;
 //
 // data has length CAP + 1 to distinguish empty vs full.
 #define CBUF(TYPE, CAP) { \
@ -37,7 +35,7 @@
            (PCBUF)->head = ((PCBUF)->head + 1) % cbuf_size_(PCBUF); \
        } \
        ok; \
-    })
+    }) \

 #define cbuf_take(PCBUF, PITEM) \
    ({ \
--- a/app/src/command.c
+++ b/app/src/command.c
@ -5,7 +5,6 @@
 #include <stdlib.h>
 #include <string.h>

-#include "config.h"
 #include "common.h"
 #include "log.h"
 #include "str_util.h"
--- a/app/src/command.h
+++ b/app/src/command.h
@ -9,7 +9,6 @@
 // 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
@ -24,7 +23,6 @@
 #else

 # include <sys/types.h>
-# define PATH_SEPARATOR '/'
 # define PRIsizet "zu"
 # define PRIexitcode "d"
 # define PROCESS_NONE -1
@ -33,8 +31,6 @@

 #endif

-#include "config.h"
-
 # define NO_EXIT_CODE -1

 enum process_result {
@ -80,9 +76,4 @@ adb_install(const char *serial, const char *local);
 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
@ -3,8 +3,6 @@

 #include <stdint.h>

-#include "config.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)
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@ -1,9 +1,7 @@
 #include "control_msg.h"

 #include <string.h>
-#include <SDL2/SDL_assert.h>

-#include "config.h"
 #include "buffer_util.h"
 #include "log.h"
 #include "str_util.h"
@ -25,16 +23,6 @@ write_string(const char *utf8, size_t max_len, unsigned char *buf) {
    return 2 + len;
 }

-static uint16_t
-to_fixed_point_16(float f) {
-    SDL_assert(f >= 0.0f && f <= 1.0f);
-    uint32_t u = f * 0x1p16f; // 2^16
-    if (u >= 0xffff) {
-        u = 0xffff;
-    }
-    return (uint16_t) u;
-}
-
 size_t
 control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
    buf[0] = msg->type;
@ -49,15 +37,11 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
                                      CONTROL_MSG_TEXT_MAX_LENGTH, &buf[1]);
            return 1 + len;
        }
-        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
-            buf[1] = msg->inject_touch_event.action;
-            buffer_write64be(&buf[2], msg->inject_touch_event.pointer_id);
-            write_position(&buf[10], &msg->inject_touch_event.position);
-            uint16_t pressure =
-                to_fixed_point_16(msg->inject_touch_event.pressure);
-            buffer_write16be(&buf[22], pressure);
-            buffer_write32be(&buf[24], msg->inject_touch_event.buttons);
-            return 28;
+        case CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT:
+            buf[1] = msg->inject_mouse_event.action;
+            buffer_write32be(&buf[2], msg->inject_mouse_event.buttons);
+            write_position(&buf[6], &msg->inject_mouse_event.position);
+            return 18;
        case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
            write_position(&buf[1], &msg->inject_scroll_event.position);
            buffer_write32be(&buf[13],
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@ -5,7 +5,6 @@
 #include <stddef.h>
 #include <stdint.h>

-#include "config.h"
 #include "android/input.h"
 #include "android/keycodes.h"
 #include "common.h"
@ -15,12 +14,10 @@
 #define CONTROL_MSG_SERIALIZED_MAX_SIZE \
    (3 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)

-#define POINTER_ID_MOUSE UINT64_C(-1);
-
 enum control_msg_type {
    CONTROL_MSG_TYPE_INJECT_KEYCODE,
    CONTROL_MSG_TYPE_INJECT_TEXT,
-    CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+    CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT,
    CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
    CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
    CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
@ -50,10 +47,8 @@ struct control_msg {
        struct {
            enum android_motionevent_action action;
            enum android_motionevent_buttons buttons;
-            uint64_t pointer_id;
            struct position position;
-            float pressure;
-        } inject_touch_event;
+        } inject_mouse_event;
        struct {
            struct position position;
            int32_t hscroll;
--- a/app/src/controller.c
+++ b/app/src/controller.c
@ -91,7 +91,7 @@ run_controller(void *data) {
        bool ok = process_msg(controller, &msg);
        control_msg_destroy(&msg);
        if (!ok) {
-            LOGD("Could not write msg to socket");
+            LOGD("Cannot write msg to socket");
            break;
        }
    }
--- a/app/src/controller.h
+++ b/app/src/controller.h
@ -5,7 +5,6 @@
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>

-#include "config.h"
 #include "cbuf.h"
 #include "control_msg.h"
 #include "net.h"
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@ -1,6 +1,4 @@
-#include "event_converter.h"
-
-#include "config.h"
+#include "convert.h"

 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false
@ -33,6 +31,7 @@ autocomplete_metastate(enum android_metastate metastate) {
    return metastate;
 }

+
 static enum android_metastate
 convert_meta_state(SDL_Keymod mod) {
    enum android_metastate metastate = 0;
@ -128,6 +127,15 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod) {
    }
 }

+static bool
+convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
+    switch (from) {
+        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
+        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
+        FAIL;
+    }
+}
+
 static enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state) {
    enum android_motionevent_buttons buttons = 0;
@ -150,7 +158,8 @@ convert_mouse_buttons(uint32_t state) {
 }

 bool
-convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to) {
+input_key_from_sdl_to_android(const SDL_KeyboardEvent *from,
+                              struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;

    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
@ -167,100 +176,45 @@ convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to) {
    return true;
 }

-static bool
-convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
-    switch (from) {
-        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
-        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
-        FAIL;
-    }
-}
-
-static inline void
-map_coords(int32_t *x, int32_t *y, const SDL_Rect *rect,
-           struct size frame_size) {
-    *x = (*x - rect->x) * frame_size.width / rect->w;
-    *y = (*y - rect->y) * frame_size.height / rect->h;
-}
-
 bool
-convert_mouse_button(const SDL_MouseButtonEvent *from, const SDL_Rect *rect,
-                     struct size frame_size, struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
+mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from,
+                                 struct size screen_size,
+                                 struct control_msg *to) {
+    to->type = CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT;

-    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
+    if (!convert_mouse_action(from->type, &to->inject_mouse_event.action)) {
        return false;
    }

-    int32_t x = from->x;
-    int32_t y = from->y;
-    map_coords(&x, &y, rect, frame_size);
-
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = frame_size;
-    to->inject_touch_event.position.point.x = x;
-    to->inject_touch_event.position.point.y = y;
-    to->inject_touch_event.pressure = 1.f;
-    to->inject_touch_event.buttons =
+    to->inject_mouse_event.buttons =
        convert_mouse_buttons(SDL_BUTTON(from->button));
+    to->inject_mouse_event.position.screen_size = screen_size;
+    to->inject_mouse_event.position.point.x = from->x;
+    to->inject_mouse_event.position.point.y = from->y;

    return true;
 }

 bool
-convert_mouse_motion(const SDL_MouseMotionEvent *from, const SDL_Rect *rect,
-                     struct size frame_size, struct control_msg *to) {
-    int32_t x = from->x;
-    int32_t y = from->y;
-    map_coords(&x, &y, rect, frame_size);
-
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = frame_size;
-    to->inject_touch_event.position.point.x = x;
-    to->inject_touch_event.position.point.y = y;
-    to->inject_touch_event.pressure = 1.f;
-    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
+mouse_motion_from_sdl_to_android(const SDL_MouseMotionEvent *from,
+                                 struct size screen_size,
+                                 struct control_msg *to) {
+    to->type = CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT;
+    to->inject_mouse_event.action = AMOTION_EVENT_ACTION_MOVE;
+    to->inject_mouse_event.buttons = convert_mouse_buttons(from->state);
+    to->inject_mouse_event.position.screen_size = screen_size;
+    to->inject_mouse_event.position.point.x = from->x;
+    to->inject_mouse_event.position.point.y = from->y;

    return true;
 }

-static bool
-convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
-    switch (from) {
-        MAP(SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE);
-        MAP(SDL_FINGERDOWN,   AMOTION_EVENT_ACTION_DOWN);
-        MAP(SDL_FINGERUP,     AMOTION_EVENT_ACTION_UP);
-        FAIL;
-    }
-}
-
 bool
-convert_touch(const SDL_TouchFingerEvent *from, struct size screen_size,
-              struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-
-    if (!convert_touch_action(from->type, &to->inject_touch_event.action)) {
-        return false;
-    }
-
-    to->inject_touch_event.pointer_id = from->fingerId;
-    to->inject_touch_event.position.screen_size = screen_size;
-    // SDL touch event coordinates are normalized in the range [0; 1]
-    to->inject_touch_event.position.point.x = from->x * screen_size.width;
-    to->inject_touch_event.position.point.y = from->y * screen_size.height;
-    to->inject_touch_event.pressure = from->pressure;
-    to->inject_touch_event.buttons = 0;
-    return true;
-}
-
-bool
-convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct position position,
-                    struct control_msg *to) {
+mouse_wheel_from_sdl_to_android(const SDL_MouseWheelEvent *from,
+                                struct position position,
+                                struct control_msg *to) {
    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;

-    // TODO map coords
    to->inject_scroll_event.position = position;

    int mul = from->direction == SDL_MOUSEWHEEL_NORMAL ? 1 : -1;
--- a/app/src/convert.h
+++ b/app/src/convert.h
@ -0,0 +1,41 @@
+#ifndef CONVERT_H
+#define CONVERT_H
+
+#include <stdbool.h>
+#include <SDL2/SDL_events.h>
+
+#include "control_msg.h"
+
+struct complete_mouse_motion_event {
+    SDL_MouseMotionEvent *mouse_motion_event;
+    struct size screen_size;
+};
+
+struct complete_mouse_wheel_event {
+    SDL_MouseWheelEvent *mouse_wheel_event;
+    struct point position;
+};
+
+bool
+input_key_from_sdl_to_android(const SDL_KeyboardEvent *from,
+                              struct control_msg *to);
+
+bool
+mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from,
+                                 struct size screen_size,
+                                 struct control_msg *to);
+
+// the video size may be different from the real device size, so we need the
+// size to which the absolute position apply, to scale it accordingly
+bool
+mouse_motion_from_sdl_to_android(const SDL_MouseMotionEvent *from,
+                                 struct size screen_size,
+                                 struct control_msg *to);
+
+// on Android, a scroll event requires the current mouse position
+bool
+mouse_wheel_from_sdl_to_android(const SDL_MouseWheelEvent *from,
+                                struct position position,
+                                struct control_msg *to);
+
+#endif
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@ -8,8 +8,8 @@
 #include <SDL2/SDL_thread.h>
 #include <unistd.h>

-#include "config.h"
 #include "compat.h"
+#include "config.h"
 #include "buffer_util.h"
 #include "events.h"
 #include "lock_util.h"
--- a/app/src/decoder.h
+++ b/app/src/decoder.h
@ -4,8 +4,6 @@
 #include <stdbool.h>
 #include <libavformat/avformat.h>

-#include "config.h"
-
 struct video_buffer;

 struct decoder {
--- a/app/src/device.c
+++ b/app/src/device.c
@ -1,6 +1,4 @@
 #include "device.h"
-
-#include "config.h"
 #include "log.h"

 bool
--- a/app/src/device.h
+++ b/app/src/device.h
@ -3,11 +3,11 @@

 #include <stdbool.h>

-#include "config.h"
 #include "common.h"
 #include "net.h"

 #define DEVICE_NAME_FIELD_LENGTH 64
+#define DEVICE_SDCARD_PATH "/sdcard/"

 // name must be at least DEVICE_NAME_FIELD_LENGTH bytes
 bool
--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@ -3,7 +3,6 @@
 #include <string.h>
 #include <SDL2/SDL_assert.h>

-#include "config.h"
 #include "buffer_util.h"
 #include "log.h"

--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@ -5,8 +5,6 @@
 #include <stdint.h>
 #include <unistd.h>

-#include "config.h"
-
 #define DEVICE_MSG_TEXT_MAX_LENGTH 4093
 #define DEVICE_MSG_SERIALIZED_MAX_SIZE (3 + DEVICE_MSG_TEXT_MAX_LENGTH)

--- a/app/src/event_converter.h
+++ b/app/src/event_converter.h
@ -1,42 +0,0 @@
-#ifndef CONVERT_H
-#define CONVERT_H
-
-#include <stdbool.h>
-#include <SDL2/SDL_events.h>
-
-#include "config.h"
-#include "control_msg.h"
-
-struct complete_mouse_motion_event {
-    SDL_MouseMotionEvent *mouse_motion_event;
-    struct size screen_size;
-};
-
-struct complete_mouse_wheel_event {
-    SDL_MouseWheelEvent *mouse_wheel_event;
-    struct point position;
-};
-
-bool
-convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to);
-
-bool
-convert_mouse_button(const SDL_MouseButtonEvent *from, const SDL_Rect *rect,
-                     struct size frame_size, struct control_msg *to);
-
-// the video size may be different from the real device size, so we need the
-// size to which the absolute position apply, to scale it accordingly
-bool
-convert_mouse_motion(const SDL_MouseMotionEvent *from, const SDL_Rect *rect,
-                     struct size frame_size, struct control_msg *to);
-
-bool
-convert_touch(const SDL_TouchFingerEvent *from, struct size screen_size,
-              struct control_msg *to);
-
-// on Android, a scroll event requires the current mouse position
-bool
-convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct position position,
-                    struct control_msg *to);
-
-#endif
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@ -5,19 +5,17 @@

 #include "config.h"
 #include "command.h"
+#include "device.h"
 #include "lock_util.h"
 #include "log.h"

-#define DEFAULT_PUSH_TARGET "/sdcard/"
-
 static void
 file_handler_request_destroy(struct file_handler_request *req) {
    SDL_free(req->file);
 }

 bool
-file_handler_init(struct file_handler *file_handler, const char *serial,
-                  const char *push_target) {
+file_handler_init(struct file_handler *file_handler, const char *serial) {

    cbuf_init(&file_handler->queue);

@ -33,7 +31,7 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
    if (serial) {
        file_handler->serial = SDL_strdup(serial);
        if (!file_handler->serial) {
-            LOGW("Could not strdup serial");
+            LOGW("Cannot strdup serial");
            SDL_DestroyCond(file_handler->event_cond);
            SDL_DestroyMutex(file_handler->mutex);
            return false;
@ -48,8 +46,6 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
    file_handler->stopped = false;
    file_handler->current_process = PROCESS_NONE;

-    file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
-
    return true;
 }

@ -71,8 +67,8 @@ install_apk(const char *serial, const char *file) {
 }

 static process_t
-push_file(const char *serial, const char *file, const char *push_target) {
-    return adb_push(serial, file, push_target);
+push_file(const char *serial, const char *file) {
+    return adb_push(serial, file, DEVICE_SDCARD_PATH);
 }

 bool
@ -128,8 +124,7 @@ run_file_handler(void *data) {
            process = install_apk(file_handler->serial, req.file);
        } else {
            LOGI("Pushing %s...", req.file);
-            process = push_file(file_handler->serial, req.file,
-                                file_handler->push_target);
+            process = push_file(file_handler->serial, req.file);
        }
        file_handler->current_process = process;
        mutex_unlock(file_handler->mutex);
@ -142,11 +137,9 @@ run_file_handler(void *data) {
            }
        } else {
            if (process_check_success(process, "adb push")) {
-                LOGI("%s successfully pushed to %s", req.file,
-                                                     file_handler->push_target);
+                LOGI("%s successfully pushed to /sdcard/", req.file);
            } else {
-                LOGE("Failed to push %s to %s", req.file,
-                                                file_handler->push_target);
+                LOGE("Failed to push %s to /sdcard/", req.file);
            }
        }

@ -176,7 +169,7 @@ file_handler_stop(struct file_handler *file_handler) {
    cond_signal(file_handler->event_cond);
    if (file_handler->current_process != PROCESS_NONE) {
        if (!cmd_terminate(file_handler->current_process)) {
-            LOGW("Could not terminate install process");
+            LOGW("Cannot terminate install process");
        }
        cmd_simple_wait(file_handler->current_process, NULL);
        file_handler->current_process = PROCESS_NONE;
--- a/app/src/file_handler.h
+++ b/app/src/file_handler.h
@ -5,7 +5,6 @@
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>

-#include "config.h"
 #include "cbuf.h"
 #include "command.h"

@ -23,7 +22,6 @@ struct file_handler_request_queue CBUF(struct file_handler_request, 16);

 struct file_handler {
    char *serial;
-    const char *push_target;
    SDL_Thread *thread;
    SDL_mutex *mutex;
    SDL_cond *event_cond;
@ -34,8 +32,7 @@ struct file_handler {
 };

 bool
-file_handler_init(struct file_handler *file_handler, const char *serial,
-                  const char *push_target);
+file_handler_init(struct file_handler *file_handler, const char *serial);

 void
 file_handler_destroy(struct file_handler *file_handler);
--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@ -1,13 +1,12 @@
 #include "fps_counter.h"

-#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>
+#include <SDL2/SDL_assert.h>

-#include "config.h"
 #include "lock_util.h"
 #include "log.h"

-#define FPS_COUNTER_INTERVAL_MS 1000
+#define FPS_COUNTER_INTERVAL 1000

 bool
 fps_counter_init(struct fps_counter *counter) {
@ -23,8 +22,11 @@ fps_counter_init(struct fps_counter *counter) {
    }

    counter->thread = NULL;
-    SDL_AtomicSet(&counter->started, 0);
-    // no need to initialize the other fields, they are unused until started
+    counter->started = false;
+    counter->interrupted = false;
+    counter->nr_rendered = 0;
+    counter->nr_skipped = 0;
+    // no need to initialize slice_start, it is meaningful only when started

    return true;
 }
@ -35,48 +37,40 @@ fps_counter_destroy(struct fps_counter *counter) {
    SDL_DestroyMutex(counter->mutex);
 }

-// must be called with mutex locked
 static void
 display_fps(struct fps_counter *counter) {
    unsigned rendered_per_second =
-        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;
+        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL;
    if (counter->nr_skipped) {
+        unsigned skipped_per_second =
+            counter->nr_skipped * 1000 / FPS_COUNTER_INTERVAL;
        LOGI("%u fps (+%u frames skipped)", rendered_per_second,
-                                            counter->nr_skipped);
+                                            skipped_per_second);
    } else {
        LOGI("%u fps", rendered_per_second);
    }
 }

-// must be called with mutex locked
-static void
-check_interval_expired(struct fps_counter *counter, uint32_t now) {
-    if (now < counter->next_timestamp) {
-        return;
-    }
-
-    display_fps(counter);
-    counter->nr_rendered = 0;
-    counter->nr_skipped = 0;
-    // add a multiple of the interval
-    uint32_t elapsed_slices =
-        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL_MS + 1;
-    counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;
-}
-
 static int
 run_fps_counter(void *data) {
    struct fps_counter *counter = data;

    mutex_lock(counter->mutex);
    while (!counter->interrupted) {
-        while (!counter->interrupted && !SDL_AtomicGet(&counter->started)) {
+        while (!counter->interrupted && !counter->started) {
            cond_wait(counter->state_cond, counter->mutex);
        }
-        while (!counter->interrupted && SDL_AtomicGet(&counter->started)) {
+        while (!counter->interrupted && counter->started) {
            uint32_t now = SDL_GetTicks();
-            check_interval_expired(counter, now);
-
+            if (now >= counter->next_timestamp) {
+                display_fps(counter);
+                counter->nr_rendered = 0;
+                counter->nr_skipped = 0;
+                // add a multiple of the interval
+                uint32_t elapsed_slices =
+                    (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL + 1;
+                counter->next_timestamp += FPS_COUNTER_INTERVAL * elapsed_slices;
+            }
            SDL_assert(counter->next_timestamp > now);
            uint32_t remaining = counter->next_timestamp - now;

@ -90,16 +84,6 @@ run_fps_counter(void *data) {

 bool
 fps_counter_start(struct fps_counter *counter) {
-    mutex_lock(counter->mutex);
-    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
-    counter->nr_rendered = 0;
-    counter->nr_skipped = 0;
-    mutex_unlock(counter->mutex);
-
-    SDL_AtomicSet(&counter->started, 1);
-    cond_signal(counter->state_cond);
-
-    // counter->thread is always accessed from the same thread, no need to lock
    if (!counter->thread) {
        counter->thread =
            SDL_CreateThread(run_fps_counter, "fps counter", counter);
@ -109,31 +93,34 @@ fps_counter_start(struct fps_counter *counter) {
        }
    }

+    mutex_lock(counter->mutex);
+    counter->started = true;
+    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL;
+    counter->nr_rendered = 0;
+    counter->nr_skipped = 0;
+    mutex_unlock(counter->mutex);
+
+    cond_signal(counter->state_cond);
    return true;
 }

 void
 fps_counter_stop(struct fps_counter *counter) {
-    SDL_AtomicSet(&counter->started, 0);
+    mutex_lock(counter->mutex);
+    counter->started = false;
+    mutex_unlock(counter->mutex);
    cond_signal(counter->state_cond);
 }

-bool
-fps_counter_is_started(struct fps_counter *counter) {
-    return SDL_AtomicGet(&counter->started);
-}
-
 void
 fps_counter_interrupt(struct fps_counter *counter) {
-    if (!counter->thread) {
-        return;
+    if (counter->thread) {
+        mutex_lock(counter->mutex);
+        counter->interrupted = true;
+        mutex_unlock(counter->mutex);
+        // wake up blocking wait
+        cond_signal(counter->state_cond);
    }
-
-    mutex_lock(counter->mutex);
-    counter->interrupted = true;
-    mutex_unlock(counter->mutex);
-    // wake up blocking wait
-    cond_signal(counter->state_cond);
 }

 void
@ -145,26 +132,10 @@ fps_counter_join(struct fps_counter *counter) {

 void
 fps_counter_add_rendered_frame(struct fps_counter *counter) {
-    if (!SDL_AtomicGet(&counter->started)) {
-        return;
-    }
-
-    mutex_lock(counter->mutex);
-    uint32_t now = SDL_GetTicks();
-    check_interval_expired(counter, now);
    ++counter->nr_rendered;
-    mutex_unlock(counter->mutex);
 }

 void
 fps_counter_add_skipped_frame(struct fps_counter *counter) {
-    if (!SDL_AtomicGet(&counter->started)) {
-        return;
-    }
-
-    mutex_lock(counter->mutex);
-    uint32_t now = SDL_GetTicks();
-    check_interval_expired(counter, now);
    ++counter->nr_skipped;
-    mutex_unlock(counter->mutex);
 }
--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@ -7,18 +7,11 @@
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>

-#include "config.h"
-
 struct fps_counter {
    SDL_Thread *thread;
    SDL_mutex *mutex;
    SDL_cond *state_cond;
-
-    // atomic so that we can check without locking the mutex
-    // if the FPS counter is disabled, we don't want to lock unnecessarily
-    SDL_atomic_t started;
-
-    // the following fields are protected by the mutex
+    bool started;
    bool interrupted;
    unsigned nr_rendered;
    unsigned nr_skipped;
@ -37,9 +30,6 @@ fps_counter_start(struct fps_counter *counter);
 void
 fps_counter_stop(struct fps_counter *counter);

-bool
-fps_counter_is_started(struct fps_counter *counter);
-
 // request to stop the thread (on quit)
 // must be called before fps_counter_join()
 void
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -1,9 +1,7 @@
 #include "input_manager.h"

 #include <SDL2/SDL_assert.h>
-
-#include "config.h"
-#include "event_converter.h"
+#include "convert.h"
 #include "lock_util.h"
 #include "log.h"

@ -49,7 +47,7 @@ send_keycode(struct controller *controller, enum android_keycode keycode,
    if (actions & ACTION_DOWN) {
        msg.inject_keycode.action = AKEY_EVENT_ACTION_DOWN;
        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'inject %s (DOWN)'", name);
+            LOGW("Cannot request 'inject %s (DOWN)'", name);
            return;
        }
    }
@ -57,7 +55,7 @@ send_keycode(struct controller *controller, enum android_keycode keycode,
    if (actions & ACTION_UP) {
        msg.inject_keycode.action = AKEY_EVENT_ACTION_UP;
        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'inject %s (UP)'", name);
+            LOGW("Cannot request 'inject %s (UP)'", name);
        }
    }
 }
@ -104,7 +102,7 @@ press_back_or_turn_screen_on(struct controller *controller) {
    msg.type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;

    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request 'press back or turn screen on'");
+        LOGW("Cannot request 'turn screen on'");
    }
 }

@ -114,7 +112,7 @@ expand_notification_panel(struct controller *controller) {
    msg.type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;

    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request 'expand notification panel'");
+        LOGW("Cannot request 'expand notification panel'");
    }
 }

@ -124,7 +122,7 @@ collapse_notification_panel(struct controller *controller) {
    msg.type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL;

    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request 'collapse notification panel'");
+        LOGW("Cannot request 'collapse notification panel'");
    }
 }

@ -134,7 +132,7 @@ request_device_clipboard(struct controller *controller) {
    msg.type = CONTROL_MSG_TYPE_GET_CLIPBOARD;

    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request device clipboard");
+        LOGW("Cannot request device clipboard");
    }
 }

@ -142,7 +140,7 @@ static void
 set_device_clipboard(struct controller *controller) {
    char *text = SDL_GetClipboardText();
    if (!text) {
-        LOGW("Could not get clipboard text: %s", SDL_GetError());
+        LOGW("Cannot get clipboard text: %s", SDL_GetError());
        return;
    }
    if (!*text) {
@ -157,7 +155,7 @@ set_device_clipboard(struct controller *controller) {

    if (!controller_push_msg(controller, &msg)) {
        SDL_free(text);
-        LOGW("Could not request 'set device clipboard'");
+        LOGW("Cannot request 'set device clipboard'");
    }
 }

@ -169,15 +167,14 @@ set_screen_power_mode(struct controller *controller,
    msg.set_screen_power_mode.mode = mode;

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

 static void
 switch_fps_counter_state(struct fps_counter *fps_counter) {
-    // the started state can only be written from the current thread, so there
-    // is no ToCToU issue
-    if (fps_counter_is_started(fps_counter)) {
+    mutex_lock(fps_counter->mutex);
+    if (fps_counter->started) {
        fps_counter_stop(fps_counter);
        LOGI("FPS counter stopped");
    } else {
@ -187,13 +184,14 @@ switch_fps_counter_state(struct fps_counter *fps_counter) {
            LOGE("FPS counter starting failed");
        }
    }
+    mutex_unlock(fps_counter->mutex);
 }

 static void
 clipboard_paste(struct controller *controller) {
    char *text = SDL_GetClipboardText();
    if (!text) {
-        LOGW("Could not get clipboard text: %s", SDL_GetError());
+        LOGW("Cannot get clipboard text: %s", SDL_GetError());
        return;
    }
    if (!*text) {
@ -207,7 +205,7 @@ clipboard_paste(struct controller *controller) {
    msg.inject_text.text = text;
    if (!controller_push_msg(controller, &msg)) {
        SDL_free(text);
-        LOGW("Could not request 'paste clipboard'");
+        LOGW("Cannot request 'paste clipboard'");
    }
 }

@ -224,12 +222,12 @@ input_manager_process_text_input(struct input_manager *input_manager,
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
    msg.inject_text.text = SDL_strdup(event->text);
    if (!msg.inject_text.text) {
-        LOGW("Could not strdup input text");
+        LOGW("Cannot strdup input text");
        return;
    }
    if (!controller_push_msg(input_manager->controller, &msg)) {
        SDL_free(msg.inject_text.text);
-        LOGW("Could not request 'inject text'");
+        LOGW("Cannot request 'inject text'");
    }
 }

@ -244,27 +242,16 @@ input_manager_process_key(struct input_manager *input_manager,
    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
+        // no shortcut involves Alt or Meta, and they should not be forwarded
+        // to the device
        return;
    }

    struct controller *controller = input_manager->controller;

    // capture all Ctrl events
-    if (ctrl || cmd) {
+    if (ctrl | meta) {
        SDL_Keycode keycode = event->keysym.sym;
        bool down = event->type == SDL_KEYDOWN;
        int action = down ? ACTION_DOWN : ACTION_UP;
@ -272,59 +259,63 @@ input_manager_process_key(struct input_manager *input_manager,
        bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
        switch (keycode) {
            case SDLK_h:
-                // 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 && cmd && !shift && !repeat) {
+                if (control && ctrl && !meta && !shift && !repeat) {
                    action_back(controller, action);
                }
                return;
            case SDLK_s:
-                if (control && cmd && !shift && !repeat) {
+                if (control && ctrl && !meta && !shift && !repeat) {
                    action_app_switch(controller, action);
                }
                return;
            case SDLK_m:
-                // 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 && cmd && !shift && !repeat) {
+                if (control && ctrl && !meta && !shift && !repeat) {
                    action_power(controller, action);
                }
                return;
            case SDLK_o:
-                if (control && cmd && !shift && down) {
+                if (control && ctrl && !shift && !meta && down) {
                    set_screen_power_mode(controller, SCREEN_POWER_MODE_OFF);
                }
                return;
            case SDLK_DOWN:
-                if (control && cmd && !shift) {
+#ifdef __APPLE__
+                if (control && !ctrl && meta && !shift) {
+#else
+                if (control && ctrl && !meta && !shift) {
+#endif
                    // forward repeated events
                    action_volume_down(controller, action);
                }
                return;
            case SDLK_UP:
-                if (control && cmd && !shift) {
+#ifdef __APPLE__
+                if (control && !ctrl && meta && !shift) {
+#else
+                if (control && ctrl && !meta && !shift) {
+#endif
                    // forward repeated events
                    action_volume_up(controller, action);
                }
                return;
            case SDLK_c:
-                if (control && cmd && !shift && !repeat && down) {
+                if (control && ctrl && !meta && !shift && !repeat && down) {
                    request_device_clipboard(controller);
                }
                return;
            case SDLK_v:
-                if (control && cmd && !repeat && down) {
+                if (control && ctrl && !meta && !repeat && down) {
                    if (shift) {
                        // store the text in the device clipboard
                        set_device_clipboard(controller);
@ -335,29 +326,29 @@ input_manager_process_key(struct input_manager *input_manager,
                }
                return;
            case SDLK_f:
-                if (!shift && cmd && !repeat && down) {
+                if (ctrl && !meta && !shift && !repeat && down) {
                    screen_switch_fullscreen(input_manager->screen);
                }
                return;
            case SDLK_x:
-                if (!shift && cmd && !repeat && down) {
+                if (ctrl && !meta && !shift && !repeat && down) {
                    screen_resize_to_fit(input_manager->screen);
                }
                return;
            case SDLK_g:
-                if (!shift && cmd && !repeat && down) {
+                if (ctrl && !meta && !shift && !repeat && down) {
                    screen_resize_to_pixel_perfect(input_manager->screen);
                }
                return;
            case SDLK_i:
-                if (!shift && cmd && !repeat && down) {
+                if (ctrl && !meta && !shift && !repeat && down) {
                    struct fps_counter *fps_counter =
                        input_manager->video_buffer->fps_counter;
                    switch_fps_counter_state(fps_counter);
                }
                return;
            case SDLK_n:
-                if (control && cmd && !repeat && down) {
+                if (control && ctrl && !meta && !repeat && down) {
                    if (shift) {
                        collapse_notification_panel(controller);
                    } else {
@ -375,9 +366,9 @@ input_manager_process_key(struct input_manager *input_manager,
    }

    struct control_msg msg;
-    if (convert_input_key(event, &msg)) {
+    if (input_key_from_sdl_to_android(event, &msg)) {
        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'inject keycode'");
+            LOGW("Cannot request 'inject keycode'");
        }
    }
 }
@ -389,25 +380,12 @@ input_manager_process_mouse_motion(struct input_manager *input_manager,
        // do not send motion events when no button is pressed
        return;
    }
-    if (event->which == SDL_TOUCH_MOUSEID) {
-        // simulated from touch events, so it's a duplicate
-        return;
-    }
    struct control_msg msg;
-    if (convert_mouse_motion(event, &input_manager->screen->rect, input_manager->screen->frame_size, &msg)) {
+    if (mouse_motion_from_sdl_to_android(event,
+                                         input_manager->screen->frame_size,
+                                         &msg)) {
        if (!controller_push_msg(input_manager->controller, &msg)) {
-            LOGW("Could not request 'inject mouse motion event'");
-        }
-    }
-}
-
-void
-input_manager_process_touch(struct input_manager *input_manager,
-                            const SDL_TouchFingerEvent *event) {
-    struct control_msg msg;
-    if (convert_touch(event, input_manager->screen->frame_size, &msg)) {
-        if (!controller_push_msg(input_manager->controller, &msg)) {
-            LOGW("Could not request 'inject touch event'");
+            LOGW("Cannot request 'inject mouse motion event'");
        }
    }
 }
@ -423,10 +401,6 @@ void
 input_manager_process_mouse_button(struct input_manager *input_manager,
                                   const SDL_MouseButtonEvent *event,
                                   bool control) {
-    if (event->which == SDL_TOUCH_MOUSEID) {
-        // simulated from touch events, so it's a duplicate
-        return;
-    }
    if (event->type == SDL_MOUSEBUTTONDOWN) {
        if (control && event->button == SDL_BUTTON_RIGHT) {
            press_back_or_turn_screen_on(input_manager->controller);
@ -453,9 +427,11 @@ input_manager_process_mouse_button(struct input_manager *input_manager,
    }

    struct control_msg msg;
-    if (convert_mouse_button(event, &input_manager->screen->rect, input_manager->screen->frame_size, &msg)) {
+    if (mouse_button_from_sdl_to_android(event,
+                                         input_manager->screen->frame_size,
+                                         &msg)) {
        if (!controller_push_msg(input_manager->controller, &msg)) {
-            LOGW("Could not request 'inject mouse button event'");
+            LOGW("Cannot request 'inject mouse button event'");
        }
    }
 }
@ -468,9 +444,9 @@ input_manager_process_mouse_wheel(struct input_manager *input_manager,
        .point = get_mouse_point(input_manager->screen),
    };
    struct control_msg msg;
-    if (convert_mouse_wheel(event, position, &msg)) {
+    if (mouse_wheel_from_sdl_to_android(event, position, &msg)) {
        if (!controller_push_msg(input_manager->controller, &msg)) {
-            LOGW("Could not request 'inject mouse wheel event'");
+            LOGW("Cannot request 'inject mouse wheel event'");
        }
    }
 }
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@ -3,7 +3,6 @@

 #include <stdbool.h>

-#include "config.h"
 #include "common.h"
 #include "controller.h"
 #include "fps_counter.h"
@ -29,10 +28,6 @@ void
 input_manager_process_mouse_motion(struct input_manager *input_manager,
                                   const SDL_MouseMotionEvent *event);

-void
-input_manager_process_touch(struct input_manager *input_manager,
-                            const SDL_TouchFingerEvent *event);
-
 void
 input_manager_process_mouse_button(struct input_manager *input_manager,
                                   const SDL_MouseButtonEvent *event,
--- a/app/src/lock_util.c
+++ b/app/src/lock_util.c
@ -0,0 +1,48 @@
+#include <lock_util.h>
+#include <stdlib.h>
+#include <SDL2/SDL_mutex.h>
+
+#include "log.h"
+
+void
+mutex_lock(SDL_mutex *mutex) {
+    if (SDL_LockMutex(mutex)) {
+        LOGC("Could not lock mutex");
+        abort();
+    }
+}
+
+void
+mutex_unlock(SDL_mutex *mutex) {
+    if (SDL_UnlockMutex(mutex)) {
+        LOGC("Could not unlock mutex");
+        abort();
+    }
+}
+
+void
+cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
+    if (SDL_CondWait(cond, mutex)) {
+        LOGC("Could not wait on condition");
+        abort();
+    }
+}
+
+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;
+}
+
+void
+cond_signal(SDL_cond *cond) {
+    if (SDL_CondSignal(cond)) {
+        LOGC("Could not signal a condition");
+        abort();
+    }
+}
+
--- a/app/src/lock_util.h
+++ b/app/src/lock_util.h
@ -2,51 +2,25 @@
 #define LOCKUTIL_H

 #include <stdint.h>
-#include <SDL2/SDL_mutex.h>

-#include "config.h"
-#include "log.h"
+// forward declarations
+typedef struct SDL_mutex SDL_mutex;
+typedef struct SDL_cond SDL_cond;

-static inline void
-mutex_lock(SDL_mutex *mutex) {
-    if (SDL_LockMutex(mutex)) {
-        LOGC("Could not lock mutex");
-        abort();
-    }
-}
+void
+mutex_lock(SDL_mutex *mutex);

-static inline void
-mutex_unlock(SDL_mutex *mutex) {
-    if (SDL_UnlockMutex(mutex)) {
-        LOGC("Could not unlock mutex");
-        abort();
-    }
-}
+void
+mutex_unlock(SDL_mutex *mutex);

-static inline void
-cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
-    if (SDL_CondWait(cond, mutex)) {
-        LOGC("Could not wait on condition");
-        abort();
-    }
-}
+void
+cond_wait(SDL_cond *cond, SDL_mutex *mutex);

-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;
-}
+// return 0 or SDL_MUTEX_TIMEDOUT
+int
+cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms);

-static inline void
-cond_signal(SDL_cond *cond) {
-    if (SDL_CondSignal(cond)) {
-        LOGC("Could not signal a condition");
-        abort();
-    }
-}
+void
+cond_signal(SDL_cond *cond);

 #endif
--- a/app/src/main.c
+++ b/app/src/main.c
@ -8,8 +8,8 @@
 #define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
 #include <SDL2/SDL.h>

-#include "config.h"
 #include "compat.h"
+#include "config.h"
 #include "log.h"
 #include "recorder.h"

@ -17,8 +17,6 @@ struct args {
    const char *serial;
    const char *crop;
    const char *record_filename;
-    const char *window_title;
-    const char *push_target;
    enum recorder_format record_format;
    bool fullscreen;
    bool no_control;
@ -35,11 +33,6 @@ struct args {
 };

 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"
@ -82,11 +75,6 @@ static void usage(const char *arg0) {
        "        Set the TCP port the client listens on.\n"
        "        Default is %d.\n"
        "\n"
-        "    --push-target path\n"
-        "        Set the target directory for pushing files to the device by\n"
-        "        drag & drop. It is passed as-is to \"adb push\".\n"
-        "        Default is \"/sdcard/\".\n"
-        "\n"
        "    -r, --record file.mp4\n"
        "        Record screen to file.\n"
        "        The format is determined by the -F/--record-format option if\n"
@ -98,7 +86,7 @@ static void usage(const char *arg0) {
        "        This flag forces to render all frames, at a cost of a\n"
        "        possible increased latency.\n"
        "\n"
-        "    -s, --serial serial\n"
+        "    -s, --serial\n"
        "        The device serial number. Mandatory only if several devices\n"
        "        are connected to adb.\n"
        "\n"
@ -115,18 +103,15 @@ static void usage(const char *arg0) {
        "    -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"
+        "    Ctrl+f\n"
        "        switch fullscreen mode\n"
        "\n"
-        "    " CTRL_OR_CMD "+g\n"
+        "    Ctrl+g\n"
        "        resize window to 1:1 (pixel-perfect)\n"
        "\n"
-        "    " CTRL_OR_CMD "+x\n"
+        "    Ctrl+x\n"
        "    Double-click on black borders\n"
        "        resize window to remove black borders\n"
        "\n"
@ -134,48 +119,48 @@ static void usage(const char *arg0) {
        "    Middle-click\n"
        "        click on HOME\n"
        "\n"
-        "    " CTRL_OR_CMD "+b\n"
-        "    " CTRL_OR_CMD "+Backspace\n"
+        "    Ctrl+b\n"
+        "    Ctrl+Backspace\n"
        "    Right-click (when screen is on)\n"
        "        click on BACK\n"
        "\n"
-        "    " CTRL_OR_CMD "+s\n"
+        "    Ctrl+s\n"
        "        click on APP_SWITCH\n"
        "\n"
        "    Ctrl+m\n"
        "        click on MENU\n"
        "\n"
-        "    " CTRL_OR_CMD "+Up\n"
+        "    Ctrl+Up\n"
        "        click on VOLUME_UP\n"
        "\n"
-        "    " CTRL_OR_CMD "+Down\n"
+        "    Ctrl+Down\n"
        "        click on VOLUME_DOWN\n"
        "\n"
-        "    " CTRL_OR_CMD "+p\n"
+        "    Ctrl+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"
+        "    Ctrl+o\n"
        "        turn device screen off (keep mirroring)\n"
        "\n"
-        "    " CTRL_OR_CMD "+n\n"
+        "    Ctrl+n\n"
        "       expand notification panel\n"
        "\n"
-        "    " CTRL_OR_CMD "+Shift+n\n"
+        "    Ctrl+Shift+n\n"
        "       collapse notification panel\n"
        "\n"
-        "    " CTRL_OR_CMD "+c\n"
+        "    Ctrl+c\n"
        "        copy device clipboard to computer\n"
        "\n"
-        "    " CTRL_OR_CMD "+v\n"
+        "    Ctrl+v\n"
        "        paste computer clipboard to device\n"
        "\n"
-        "    " CTRL_OR_CMD "+Shift+v\n"
+        "    Ctrl+Shift+v\n"
        "        copy computer clipboard to device\n"
        "\n"
-        "    " CTRL_OR_CMD "+i\n"
+        "    Ctrl+i\n"
        "        enable/disable FPS counter (print frames/second in logs)\n"
        "\n"
        "    Drag & drop APK file\n"
@ -310,8 +295,6 @@ guess_record_format(const char *filename) {
 }

 #define OPT_RENDER_EXPIRED_FRAMES 1000
-#define OPT_WINDOW_TITLE          1001
-#define OPT_PUSH_TARGET           1002

 static bool
 parse_args(struct args *args, int argc, char *argv[]) {
@ -325,18 +308,14 @@ parse_args(struct args *args, int argc, char *argv[]) {
        {"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'},
+        {"record-format",         required_argument, NULL, 'f'},
        {"render-expired-frames", no_argument,       NULL,
                                                 OPT_RENDER_EXPIRED_FRAMES},
        {"serial",                required_argument, NULL, 's'},
        {"show-touches",          no_argument,       NULL, 't'},
        {"turn-screen-off",       no_argument,       NULL, 'S'},
        {"version",               no_argument,       NULL, 'v'},
-        {"window-title",          required_argument, NULL,
-                                                 OPT_WINDOW_TITLE},
        {NULL,                    0,                 NULL, 0  },
    };
    int c;
@ -399,12 +378,6 @@ parse_args(struct args *args, int argc, char *argv[]) {
            case OPT_RENDER_EXPIRED_FRAMES:
                args->render_expired_frames = true;
                break;
-            case OPT_WINDOW_TITLE:
-                args->window_title = optarg;
-                break;
-            case OPT_PUSH_TARGET:
-                args->push_target = optarg;
-                break;
            default:
                // getopt prints the error message on stderr
                return false;
@ -441,11 +414,6 @@ parse_args(struct args *args, int argc, char *argv[]) {
        }
    }

-    if (args->no_control && args->turn_screen_off) {
-        LOGE("Could not request to turn screen off if control is disabled");
-        return false;
-    }
-
    return true;
 }

@ -461,8 +429,6 @@ main(int argc, char *argv[]) {
        .serial = NULL,
        .crop = NULL,
        .record_filename = NULL,
-        .window_title = NULL,
-        .push_target = NULL,
        .record_format = 0,
        .help = false,
        .version = false,
@ -490,8 +456,6 @@ main(int argc, char *argv[]) {
        return 0;
    }

-    LOGI("scrcpy " SCRCPY_VERSION " <https://github.com/Genymobile/scrcpy>");
-
 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
    av_register_all();
 #endif
@ -509,8 +473,6 @@ main(int argc, char *argv[]) {
        .crop = args.crop,
        .port = args.port,
        .record_filename = args.record_filename,
-        .window_title = args.window_title,
-        .push_target = args.push_target,
        .record_format = args.record_format,
        .max_size = args.max_size,
        .bit_rate = args.bit_rate,
--- a/app/src/net.c
+++ b/app/src/net.c
@ -2,7 +2,6 @@

 #include <stdio.h>

-#include "config.h"
 #include "log.h"

 #ifdef __WINDOWS__
--- a/app/src/net.h
+++ b/app/src/net.h
@ -17,8 +17,6 @@
  typedef int socket_t;
 #endif

-#include "config.h"
-
 bool
 net_init(void);

--- a/app/src/queue.h
+++ b/app/src/queue.h
@ -1,77 +0,0 @@
-// generic intrusive FIFO queue
-#ifndef QUEUE_H
-#define QUEUE_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);
-#define QUEUE(TYPE) { \
-    TYPE *first; \
-    TYPE *last; \
-}
-
-#define queue_init(PQ) \
-    (void) ((PQ)->first = (PQ)->last = NULL)
-
-#define queue_is_empty(PQ) \
-    !(PQ)->first
-
-// NEXTFIELD is the field in the ITEM type used for intrusive linked-list
-//
-// For example:
-//    struct foo {
-//        int value;
-//        struct foo *next;
-//    };
-//
-//    // define the type "struct my_queue"
-//    struct my_queue QUEUE(struct foo);
-//
-//    struct my_queue queue;
-//    queue_init(&queue);
-//
-//    struct foo v1 = { .value = 42 };
-//    struct foo v2 = { .value = 27 };
-//
-//    queue_push(&queue, next, v1);
-//    queue_push(&queue, next, v2);
-//
-//    struct foo *foo;
-//    queue_take(&queue, next, &foo);
-//    assert(foo->value == 42);
-//    queue_take(&queue, next, &foo);
-//    assert(foo->value == 27);
-//    assert(queue_is_empty(&queue));
-//
-
-// push a new item into the queue
-#define queue_push(PQ, NEXTFIELD, ITEM) \
-    (void) ({ \
-        (ITEM)->NEXTFIELD = NULL; \
-        if (queue_is_empty(PQ)) { \
-            (PQ)->first = (PQ)->last = (ITEM); \
-        } else { \
-            (PQ)->last->NEXTFIELD = (ITEM); \
-            (PQ)->last = (ITEM); \
-        } \
-    })
-
-// take the next item and remove it from the queue (the queue must not be empty)
-// the result is stored in *(PITEM)
-// (without typeof(), we could not store a local variable having the correct
-// type so that we can "return" it)
-#define queue_take(PQ, NEXTFIELD, PITEM) \
-    (void) ({ \
-        SDL_assert(!queue_is_empty(PQ)); \
-        *(PITEM) = (PQ)->first; \
-        (PQ)->first = (PQ)->first->NEXTFIELD; \
-    })
-    // no need to update (PQ)->last if the queue is left empty:
-    // (PQ)->last is undefined if !(PQ)->first anyway
-
-#endif
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@ -5,7 +5,6 @@
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>

-#include "config.h"
 #include "net.h"

 // receive events from the device
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@ -3,9 +3,8 @@
 #include <libavutil/time.h>
 #include <SDL2/SDL_assert.h>

-#include "config.h"
 #include "compat.h"
-#include "lock_util.h"
+#include "config.h"
 #include "log.h"

 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
@ -27,39 +26,6 @@ find_muxer(const char *name) {
    return oformat;
 }

-static struct record_packet *
-record_packet_new(const AVPacket *packet) {
-    struct record_packet *rec = SDL_malloc(sizeof(*rec));
-    if (!rec) {
-        return NULL;
-    }
-
-    // av_packet_ref() does not initialize all fields in old FFmpeg versions
-    // See <https://github.com/Genymobile/scrcpy/issues/707>
-    av_init_packet(&rec->packet);
-
-    if (av_packet_ref(&rec->packet, packet)) {
-        SDL_free(rec);
-        return NULL;
-    }
-    return rec;
-}
-
-static void
-record_packet_delete(struct record_packet *rec) {
-    av_packet_unref(&rec->packet);
-    SDL_free(rec);
-}
-
-static void
-recorder_queue_clear(struct recorder_queue *queue) {
-    while (!queue_is_empty(queue)) {
-        struct record_packet *rec;
-        queue_take(queue, next, &rec);
-        record_packet_delete(rec);
-    }
-}
-
 bool
 recorder_init(struct recorder *recorder,
              const char *filename,
@ -67,40 +33,19 @@ recorder_init(struct recorder *recorder,
              struct size declared_frame_size) {
    recorder->filename = SDL_strdup(filename);
    if (!recorder->filename) {
-        LOGE("Could not strdup filename");
+        LOGE("Cannot 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);
 }

@ -174,17 +119,12 @@ 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);
-    }
+    const char *format_name = recorder_get_format_name(recorder->format);
+    LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
 }

 static bool
@ -193,7 +133,7 @@ recorder_write_header(struct recorder *recorder, const AVPacket *packet) {

    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
    if (!extradata) {
-        LOGC("Could not allocate extradata");
+        LOGC("Cannot allocate extradata");
        return false;
    }

@ -211,6 +151,9 @@ recorder_write_header(struct recorder *recorder, const AVPacket *packet) {
    int ret = avformat_write_header(recorder->ctx, NULL);
    if (ret < 0) {
        LOGE("Failed to write header to %s", recorder->filename);
+        SDL_free(extradata);
+        avio_closep(&recorder->ctx->pb);
+        avformat_free_context(recorder->ctx);
        return false;
    }

@ -226,141 +169,13 @@ recorder_rescale_packet(struct recorder *recorder, AVPacket *packet) {
 bool
 recorder_write(struct recorder *recorder, AVPacket *packet) {
    if (!recorder->header_written) {
-        if (packet->pts != AV_NOPTS_VALUE) {
-            LOGE("The first packet is not a config packet");
-            return false;
-        }
        bool ok = recorder_write_header(recorder, packet);
        if (!ok) {
            return false;
        }
        recorder->header_written = true;
-        return true;
-    }
-
-    if (packet->pts == AV_NOPTS_VALUE) {
-        // ignore config packets
-        return true;
    }

    recorder_rescale_packet(recorder, packet);
    return av_write_frame(recorder->ctx, packet) >= 0;
 }
-
-static int
-run_recorder(void *data) {
-    struct recorder *recorder = data;
-
-    for (;;) {
-        mutex_lock(recorder->mutex);
-
-        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
-            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)) {
-            mutex_unlock(recorder->mutex);
-            struct record_packet *last = recorder->previous;
-            if (last) {
-                // assign an arbitrary duration to the last packet
-                last->packet.duration = 100000;
-                bool ok = recorder_write(recorder, &last->packet);
-                if (!ok) {
-                    // failing to write the last frame is not very serious, no
-                    // future frame may depend on it, so the resulting file
-                    // will still be valid
-                    LOGW("Could not record last packet");
-                }
-                record_packet_delete(last);
-            }
-            break;
-        }
-
-        struct record_packet *rec;
-        queue_take(&recorder->queue, next, &rec);
-
-        mutex_unlock(recorder->mutex);
-
-        // recorder->previous is only written from this thread, no need to lock
-        struct record_packet *previous = recorder->previous;
-        recorder->previous = rec;
-
-        if (!previous) {
-            // we just received the first packet
-            continue;
-        }
-
-        // we now know the duration of the previous packet
-        previous->packet.duration = rec->packet.pts - previous->packet.pts;
-
-        bool ok = recorder_write(recorder, &previous->packet);
-        record_packet_delete(previous);
-        if (!ok) {
-            LOGE("Could not record packet");
-
-            mutex_lock(recorder->mutex);
-            recorder->failed = true;
-            // discard pending packets
-            recorder_queue_clear(&recorder->queue);
-            mutex_unlock(recorder->mutex);
-            break;
-        }
-
-    }
-
-    LOGD("Recorder thread ended");
-
-    return 0;
-}
-
-bool
-recorder_start(struct recorder *recorder) {
-    LOGD("Starting recorder thread");
-
-    recorder->thread = SDL_CreateThread(run_recorder, "recorder", recorder);
-    if (!recorder->thread) {
-        LOGC("Could not start recorder thread");
-        return false;
-    }
-
-    return true;
-}
-
-void
-recorder_stop(struct recorder *recorder) {
-    mutex_lock(recorder->mutex);
-    recorder->stopped = true;
-    cond_signal(recorder->queue_cond);
-    mutex_unlock(recorder->mutex);
-}
-
-void
-recorder_join(struct recorder *recorder) {
-    SDL_WaitThread(recorder->thread, NULL);
-}
-
-bool
-recorder_push(struct recorder *recorder, const AVPacket *packet) {
-    mutex_lock(recorder->mutex);
-    SDL_assert(!recorder->stopped);
-
-    if (recorder->failed) {
-        // reject any new packet (this will stop the stream)
-        return false;
-    }
-
-    struct record_packet *rec = record_packet_new(packet);
-    if (!rec) {
-        LOGC("Could not allocate record packet");
-        return false;
-    }
-
-    queue_push(&recorder->queue, next, rec);
-    cond_signal(recorder->queue_cond);
-
-    mutex_unlock(recorder->mutex);
-    return true;
-}
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@ -3,44 +3,20 @@

 #include <stdbool.h>
 #include <libavformat/avformat.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>

-#include "config.h"
 #include "common.h"
-#include "queue.h"

 enum recorder_format {
    RECORDER_FORMAT_MP4 = 1,
    RECORDER_FORMAT_MKV,
 };

-struct record_packet {
-    AVPacket packet;
-    struct record_packet *next;
-};
-
-struct recorder_queue QUEUE(struct record_packet);
-
 struct recorder {
    char *filename;
    enum recorder_format format;
    AVFormatContext *ctx;
    struct size declared_frame_size;
    bool header_written;
-
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *queue_cond;
-    bool stopped; // set on recorder_stop() by the stream reader
-    bool failed; // set on packet write failure
-    struct recorder_queue queue;
-
-    // we can write a packet only once we received the next one so that we can
-    // set its duration (next_pts - current_pts)
-    // "previous" is only accessed from the recorder thread, so it does not
-    // need to be protected by the mutex
-    struct record_packet *previous;
 };

 bool
@ -57,15 +33,6 @@ 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);
+recorder_write(struct recorder *recorder, AVPacket *packet);

 #endif
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -7,7 +7,6 @@
 #include <sys/time.h>
 #include <SDL2/SDL.h>

-#include "config.h"
 #include "command.h"
 #include "common.h"
 #include "compat.h"
@ -145,10 +144,8 @@ handle_event(SDL_Event *event, bool control) {
        case SDL_WINDOWEVENT:
            switch (event->window.event) {
                case SDL_WINDOWEVENT_EXPOSED:
-                    screen_render(&screen);
-                    break;
                case SDL_WINDOWEVENT_SIZE_CHANGED:
-                    screen_resized(&screen);
+                    screen_render(&screen);
                    break;
            }
            break;
@ -183,11 +180,6 @@ handle_event(SDL_Event *event, bool control) {
            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 (!control) {
                break;
@ -267,7 +259,7 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
    }
    char *local_fmt = SDL_malloc(strlen(fmt) + 10);
    if (!local_fmt) {
-        LOGC("Could not allocate string");
+        LOGC("Cannot allocate string");
        return;
    }
    // strcpy is safe here, the destination is large enough
@ -285,6 +277,7 @@ scrcpy(const struct scrcpy_options *options) {
        .local_port = options->port,
        .max_size = options->max_size,
        .bit_rate = options->bit_rate,
+        .send_frame_meta = record,
        .control = options->control,
    };
    if (!server_start(&server, options->serial, &params)) {
@ -341,8 +334,7 @@ scrcpy(const struct scrcpy_options *options) {
        video_buffer_initialized = true;

        if (options->control) {
-            if (!file_handler_init(&file_handler, server.serial,
-                                   options->push_target)) {
+            if (!file_handler_init(&file_handler, server.serial)) {
                goto end;
            }
            file_handler_initialized = true;
@ -388,10 +380,7 @@ scrcpy(const struct scrcpy_options *options) {
            controller_started = true;
        }

-        const char *window_title =
-            options->window_title ? options->window_title : device_name;
-
-        if (!screen_init_rendering(&screen, window_title, frame_size,
+        if (!screen_init_rendering(&screen, device_name, frame_size,
                                   options->always_on_top)) {
            goto end;
        }
@ -402,7 +391,7 @@ scrcpy(const struct scrcpy_options *options) {
            msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF;

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

--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@ -5,14 +5,10 @@
 #include <stdint.h>
 #include <recorder.h>

-#include "config.h"
-
 struct scrcpy_options {
    const char *serial;
    const char *crop;
    const char *record_filename;
-    const char *window_title;
-    const char *push_target;
    enum recorder_format record_format;
    uint16_t port;
    uint16_t max_size;
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -3,7 +3,6 @@
 #include <string.h>
 #include <SDL2/SDL.h>

-#include "config.h"
 #include "common.h"
 #include "compat.h"
 #include "icon.xpm"
@ -86,7 +85,7 @@ get_optimal_size(struct size current_size, struct size frame_size) {
    uint32_t h;

    if (!get_preferred_display_bounds(&display_size)) {
-        // could not get display bounds, do not constraint the size
+        // cannot get display bounds, do not constraint the size
        w = current_size.width;
        h = current_size.height;
    } else {
@ -122,32 +121,6 @@ get_initial_optimal_size(struct size frame_size) {
    return get_optimal_size(frame_size, frame_size);
 }

-static void
-update_frame_rect(struct screen *screen) {
-    struct size window_size = get_window_size(screen);
-
-    // 32 bits because we need to multiply two 16 bits values
-    uint32_t ww = window_size.width;
-    uint32_t wh = window_size.height;
-    uint32_t fw = screen->frame_size.width;
-    uint32_t fh = screen->frame_size.height;
-
-    SDL_Rect *rect = &screen->rect;
-
-    bool keep_width = fw * wh > fh * ww;
-    if (keep_width) {
-        rect->x = 0;
-        rect->w = ww;
-        rect->h = ww * fh / fw;
-        rect->y = (wh - rect->h) / 2;
-    } else {
-        rect->y = 0;
-        rect->h = wh;
-        rect->w = wh * fw / fh;
-        rect->x = (ww - rect->w) / 2;
-    }
-}
-
 void
 screen_init(struct screen *screen) {
    *screen = (struct screen) SCREEN_INITIALIZER;
@ -161,7 +134,7 @@ create_texture(SDL_Renderer *renderer, struct size frame_size) {
 }

 bool
-screen_init_rendering(struct screen *screen, const char *window_title,
+screen_init_rendering(struct screen *screen, const char *device_name,
                      struct size frame_size, bool always_on_top) {
    screen->frame_size = frame_size;

@ -179,7 +152,7 @@ screen_init_rendering(struct screen *screen, const char *window_title,
 #endif
    }

-    screen->window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_UNDEFINED,
+    screen->window = SDL_CreateWindow(device_name, SDL_WINDOWPOS_UNDEFINED,
                                      SDL_WINDOWPOS_UNDEFINED,
                                      window_size.width, window_size.height,
                                      window_flags);
@ -196,6 +169,13 @@ screen_init_rendering(struct screen *screen, const char *window_title,
        return false;
    }

+    if (SDL_RenderSetLogicalSize(screen->renderer, frame_size.width,
+                                 frame_size.height)) {
+        LOGE("Could not set renderer logical size: %s", SDL_GetError());
+        screen_destroy(screen);
+        return false;
+    }
+
    SDL_Surface *icon = read_xpm(icon_xpm);
    if (icon) {
        SDL_SetWindowIcon(screen->window, icon);
@ -239,6 +219,12 @@ 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);

@ -284,7 +270,6 @@ screen_update_frame(struct screen *screen, struct video_buffer *vb) {
        mutex_unlock(vb->mutex);
        return false;
    }
-    update_frame_rect(screen);
    update_texture(screen, frame);
    mutex_unlock(vb->mutex);

@ -292,16 +277,10 @@ screen_update_frame(struct screen *screen, struct video_buffer *vb) {
    return true;
 }

-void
-screen_resized(struct screen *screen) {
-    update_frame_rect(screen);
-    screen_render(screen);
-}
-
 void
 screen_render(struct screen *screen) {
    SDL_RenderClear(screen->renderer);
-    SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
+    SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
    SDL_RenderPresent(screen->renderer);
 }

--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -5,7 +5,6 @@
 #include <SDL2/SDL.h>
 #include <libavformat/avformat.h>

-#include "config.h"
 #include "common.h"

 struct video_buffer;
@ -17,7 +16,6 @@ struct screen {
    struct size frame_size;
    //used only in fullscreen mode to know the windowed window size
    struct size windowed_window_size;
-    struct SDL_Rect rect; // frame location and size inside the window
    bool has_frame;
    bool fullscreen;
    bool no_window;
@ -35,15 +33,9 @@ struct screen {
        .width = 0,           \
        .height = 0,          \
    },                        \
-    .rect = {                 \
-        .x = 0,               \
-        .y = 0,               \
-        .w = 0,               \
-        .h = 0,               \
-    },                        \
-    .has_frame = false,       \
-    .fullscreen = false,      \
-    .no_window = false,       \
+    .has_frame = false,   \
+    .fullscreen = false,  \
+    .no_window = false,   \
 }

 // initialize default values
@ -52,7 +44,7 @@ screen_init(struct screen *screen);

 // initialize screen, create window, renderer and texture (window is hidden)
 bool
-screen_init_rendering(struct screen *screen, const char *window_title,
+screen_init_rendering(struct screen *screen, const char *device_name,
                      struct size frame_size, bool always_on_top);

 // show the window
@ -67,9 +59,6 @@ screen_destroy(struct screen *screen);
 bool
 screen_update_frame(struct screen *screen, struct video_buffer *vb);

-void
-screen_resized(struct screen *screen);
-
 // render the texture to the renderer
 void
 screen_render(struct screen *screen);
--- a/app/src/server.c
+++ b/app/src/server.c
@ -2,67 +2,31 @@

 #include <errno.h>
 #include <inttypes.h>
-#include <libgen.h>
 #include <stdio.h>
 #include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>

 #include "config.h"
-#include "command.h"
 #include "log.h"
 #include "net.h"

 #define SOCKET_NAME "scrcpy"
-#define SERVER_FILENAME "scrcpy-server.jar"

-#define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FILENAME
-#define DEVICE_SERVER_PATH "/data/local/tmp/" SERVER_FILENAME
+#ifdef OVERRIDE_SERVER_PATH
+# define DEFAULT_SERVER_PATH OVERRIDE_SERVER_PATH
+#else
+# define DEFAULT_SERVER_PATH PREFIX PREFIXED_SERVER_PATH
+#endif
+
+#define DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"

 static const char *
 get_server_path(void) {
-    const char *server_path_env = getenv("SCRCPY_SERVER_PATH");
-    if (server_path_env) {
-        LOGD("Using SCRCPY_SERVER_PATH: %s", server_path_env);
-        // if the envvar is set, use it
-        return server_path_env;
-    }
-
-#ifndef PORTABLE
-    LOGD("Using server: " DEFAULT_SERVER_PATH);
-    // the absolute path is hardcoded
-    return DEFAULT_SERVER_PATH;
-#else
-    // use scrcpy-server.jar 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 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 = SDL_malloc(len);
+    const char *server_path = getenv("SCRCPY_SERVER_PATH");
    if (!server_path) {
-        LOGE("Could not alloc server path string, "
-             "using " SERVER_FILENAME " from current directory");
-        SDL_free(executable_path);
-        return SERVER_FILENAME;
+        server_path = DEFAULT_SERVER_PATH;
    }
-
-    memcpy(server_path, dir, dirlen);
-    server_path[dirlen] = PATH_SEPARATOR;
-    memcpy(&server_path[dirlen + 1], SERVER_FILENAME, sizeof(SERVER_FILENAME));
-    // the final null byte has been copied with SERVER_FILENAME
-
-    SDL_free(executable_path);
-
-    LOGD("Using server (portable): %s", server_path);
    return server_path;
-#endif
 }

 static bool
@ -122,7 +86,7 @@ execute_server(struct server *server, const struct server_params *params) {
    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
    const char *const cmd[] = {
        "shell",
-        "CLASSPATH=/data/local/tmp/" SERVER_FILENAME,
+        "CLASSPATH=/data/local/tmp/scrcpy-server.jar",
        "app_process",
        "/", // unused
        "com.genymobile.scrcpy.Server",
@ -130,7 +94,7 @@ execute_server(struct server *server, const struct server_params *params) {
        bit_rate_string,
        server->tunnel_forward ? "true" : "false",
        params->crop ? params->crop : "-",
-        "true", // always send frame meta (packet boundaries + timestamp)
+        params->send_frame_meta ? "true" : "false",
        params->control ? "true" : "false",
    };
    return adb_execute(server->serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
@ -155,7 +119,6 @@ connect_and_read_byte(uint16_t port) {
    // is not listening, so read one byte to detect a working connection
    if (net_recv(socket, &byte, 1) != 1) {
        // the server is not listening yet behind the adb tunnel
-        net_close(socket);
        return INVALID_SOCKET;
    }
    return socket;
@ -182,7 +145,7 @@ close_socket(socket_t *socket) {
    SDL_assert(*socket != INVALID_SOCKET);
    net_shutdown(*socket, SHUT_RDWR);
    if (!net_close(*socket)) {
-        LOGW("Could not close socket");
+        LOGW("Cannot close socket");
        return;
    }
    *socket = INVALID_SOCKET;
@ -306,7 +269,7 @@ server_stop(struct server *server) {
    SDL_assert(server->process != PROCESS_NONE);

    if (!cmd_terminate(server->process)) {
-        LOGW("Could not terminate server");
+        LOGW("Cannot terminate server");
    }

    cmd_simple_wait(server->process, NULL); // ignore exit code
--- a/app/src/server.h
+++ b/app/src/server.h
@ -4,7 +4,6 @@
 #include <stdbool.h>
 #include <stdint.h>

-#include "config.h"
 #include "command.h"
 #include "net.h"

@ -35,6 +34,7 @@ struct server_params {
    uint16_t local_port;
    uint16_t max_size;
    uint32_t bit_rate;
+    bool send_frame_meta;
    bool control;
 };

--- a/app/src/str_util.c
+++ b/app/src/str_util.c
@ -10,8 +10,6 @@

 #include <SDL2/SDL_stdinc.h>

-#include "config.h"
-
 size_t
 xstrncpy(char *dest, const char *src, size_t n) {
    size_t i;
@ -94,20 +92,4 @@ utf8_to_wide_char(const char *utf8) {
    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/str_util.h
+++ b/app/src/str_util.h
@ -3,8 +3,6 @@

 #include <stddef.h>

-#include "config.h"
-
 // like strncpy, except:
 //  - it copies at most n-1 chars
 //  - the dest string is nul-terminated
@ -34,9 +32,6 @@ utf8_truncation_index(const char *utf8, size_t max_len);
 // returns the new allocated string, to be freed by the caller
 wchar_t *
 utf8_to_wide_char(const char *utf8);
-
-char *
-utf8_from_wide_char(const wchar_t *s);
 #endif

 #endif
--- a/app/src/stream.c
+++ b/app/src/stream.c
@ -8,8 +8,8 @@
 #include <SDL2/SDL_thread.h>
 #include <unistd.h>

-#include "config.h"
 #include "compat.h"
+#include "config.h"
 #include "buffer_util.h"
 #include "decoder.h"
 #include "events.h"
@ -22,8 +22,54 @@
 #define HEADER_SIZE 12
 #define NO_PTS UINT64_C(-1)

+static struct frame_meta *
+frame_meta_new(uint64_t pts) {
+    struct frame_meta *meta = SDL_malloc(sizeof(*meta));
+    if (!meta) {
+        return meta;
+    }
+    meta->pts = pts;
+    meta->next = NULL;
+    return meta;
+}
+
+static void
+frame_meta_delete(struct frame_meta *frame_meta) {
+    SDL_free(frame_meta);
+}
+
 static bool
-stream_recv_packet(struct stream *stream, AVPacket *packet) {
+receiver_state_push_meta(struct receiver_state *state, uint64_t pts) {
+    struct frame_meta *frame_meta = frame_meta_new(pts);
+    if (!frame_meta) {
+        return false;
+    }
+
+    // append to the list
+    // (iterate to find the last item, in practice the list should be tiny)
+    struct frame_meta **p = &state->frame_meta_queue;
+    while (*p) {
+        p = &(*p)->next;
+    }
+    *p = frame_meta;
+    return true;
+}
+
+static uint64_t
+receiver_state_take_meta(struct receiver_state *state) {
+    struct frame_meta *frame_meta = state->frame_meta_queue; // first item
+    SDL_assert(frame_meta); // must not be empty
+    uint64_t pts = frame_meta->pts;
+    state->frame_meta_queue = frame_meta->next; // remove the item
+    frame_meta_delete(frame_meta);
+    return pts;
+}
+
+static int
+read_packet_with_meta(void *opaque, uint8_t *buf, int buf_size) {
+    struct stream *stream = opaque;
+    struct receiver_state *state = &stream->receiver_state;
+
    // The video stream contains raw packets, without time information. When we
    // record, we retrieve the timestamps separately, from a "meta" header
    // added by the server before each raw packet.
@ -36,30 +82,60 @@ stream_recv_packet(struct stream *stream, AVPacket *packet) {
    //
    // It is followed by <packet_size> bytes containing the packet/frame.

-    uint8_t header[HEADER_SIZE];
-    ssize_t r = net_recv_all(stream->socket, header, HEADER_SIZE);
-    if (r < HEADER_SIZE) {
-        return false;
+    if (!state->remaining) {
+#define HEADER_SIZE 12
+        uint8_t header[HEADER_SIZE];
+        ssize_t r = net_recv_all(stream->socket, header, HEADER_SIZE);
+        if (r == -1) {
+            return AVERROR(errno);
+        }
+        if (r == 0) {
+            return AVERROR_EOF;
+        }
+        // no partial read (net_recv_all())
+        SDL_assert_release(r == HEADER_SIZE);
+
+        uint64_t pts = buffer_read64be(header);
+        state->remaining = buffer_read32be(&header[8]);
+
+        if (pts != NO_PTS && !receiver_state_push_meta(state, pts)) {
+            LOGE("Could not store PTS for recording");
+            // we cannot save the PTS, the recording would be broken
+            return AVERROR(ENOMEM);
+        }
    }

-    uint64_t pts = buffer_read64be(header);
-    uint32_t len = buffer_read32be(&header[8]);
-    SDL_assert(len);
+    SDL_assert(state->remaining);

-    if (av_new_packet(packet, len)) {
-        LOGE("Could not allocate packet");
-        return false;
+    if (buf_size > state->remaining) {
+        buf_size = state->remaining;
    }

-    r = net_recv_all(stream->socket, packet->data, len);
-    if (r < len) {
-        av_packet_unref(packet);
-        return false;
+    ssize_t r = net_recv(stream->socket, buf, buf_size);
+    if (r == -1) {
+        return AVERROR(errno);
+    }
+    if (r == 0) {
+        return AVERROR_EOF;
    }

-    packet->pts = pts != NO_PTS ? pts : AV_NOPTS_VALUE;
+    SDL_assert(state->remaining >= r);
+    state->remaining -= r;

-    return true;
+    return r;
+}
+
+static int
+read_raw_packet(void *opaque, uint8_t *buf, int buf_size) {
+    struct stream *stream = opaque;
+    ssize_t r = net_recv(stream->socket, buf, buf_size);
+    if (r == -1) {
+        return AVERROR(errno);
+    }
+    if (r == 0) {
+        return AVERROR_EOF;
+    }
+    return r;
 }

 static void
@ -69,199 +145,116 @@ notify_stopped(void) {
    SDL_PushEvent(&stop_event);
 }

-static bool
-process_config_packet(struct stream *stream, AVPacket *packet) {
-    if (stream->recorder && !recorder_push(stream->recorder, packet)) {
-        LOGE("Could not send config packet to recorder");
-        return false;
-    }
-    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;
-        }
-    }
-
-    return true;
-}
-
-static bool
-stream_parse(struct stream *stream, AVPacket *packet) {
-    uint8_t *in_data = packet->data;
-    int in_len = packet->size;
-    uint8_t *out_data = NULL;
-    int out_len = 0;
-    int r = av_parser_parse2(stream->parser, stream->codec_ctx,
-                             &out_data, &out_len, in_data, in_len,
-                             AV_NOPTS_VALUE, AV_NOPTS_VALUE, -1);
-
-    // PARSER_FLAG_COMPLETE_FRAMES is set
-    SDL_assert(r == in_len);
-    SDL_assert(out_len == in_len);
-
-    if (stream->parser->key_frame == 1) {
-        packet->flags |= AV_PKT_FLAG_KEY;
-    }
-
-    bool ok = process_frame(stream, packet);
-    if (!ok) {
-        LOGE("Could not process frame");
-        return false;
-    }
-
-    return true;
-}
-
-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 immetiately (it contains no
-    // frame); instead, it must be concatenated with the future data packet.
-    if (stream->has_pending || is_config) {
-        size_t offset;
-        if (stream->has_pending) {
-            offset = stream->pending.size;
-            if (av_grow_packet(&stream->pending, packet->size)) {
-                LOGE("Could not grow packet");
-                return false;
-            }
-        } else {
-            offset = 0;
-            if (av_new_packet(&stream->pending, packet->size)) {
-                LOGE("Could not create packet");
-                return false;
-            }
-            stream->has_pending = true;
-        }
-
-        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.dts = packet->dts;
-            stream->pending.flags = packet->flags;
-            packet = &stream->pending;
-        }
-    }
-
-    if (is_config) {
-        // config packet
-        bool ok = process_config_packet(stream, packet);
-        if (!ok) {
-            return false;
-        }
-    } else {
-        // data packet
-        bool ok = stream_parse(stream, packet);
-
-        if (stream->has_pending) {
-            // the pending packet must be discarded (consumed or error)
-            stream->has_pending = false;
-            av_packet_unref(&stream->pending);
-        }
-
-        if (!ok) {
-            return false;
-        }
-    }
-    return true;
-}
-
 static int
 run_stream(void *data) {
    struct stream *stream = data;

+    AVFormatContext *format_ctx = avformat_alloc_context();
+    if (!format_ctx) {
+        LOGC("Could not allocate format context");
+        goto end;
+    }
+
+    unsigned char *buffer = av_malloc(BUFSIZE);
+    if (!buffer) {
+        LOGC("Could not allocate buffer");
+        goto finally_free_format_ctx;
+    }
+
+    // initialize the receiver state
+    stream->receiver_state.frame_meta_queue = NULL;
+    stream->receiver_state.remaining = 0;
+
+    // if recording is enabled, a "header" is sent between raw packets
+    int (*read_packet)(void *, uint8_t *, int) =
+            stream->recorder ? read_packet_with_meta : read_raw_packet;
+    AVIOContext *avio_ctx = avio_alloc_context(buffer, BUFSIZE, 0, stream,
+                                               read_packet, NULL, NULL);
+    if (!avio_ctx) {
+        LOGC("Could not allocate avio context");
+        // avformat_open_input takes ownership of 'buffer'
+        // so only free the buffer before avformat_open_input()
+        av_free(buffer);
+        goto finally_free_format_ctx;
+    }
+
+    format_ctx->pb = avio_ctx;
+
+    if (avformat_open_input(&format_ctx, NULL, NULL, NULL) < 0) {
+        LOGE("Could not open video stream");
+        goto finally_free_avio_ctx;
+    }
+
    AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
    if (!codec) {
        LOGE("H.264 decoder not found");
        goto end;
    }

-    stream->codec_ctx = avcodec_alloc_context3(codec);
-    if (!stream->codec_ctx) {
-        LOGC("Could not allocate codec context");
-        goto end;
-    }
-
    if (stream->decoder && !decoder_open(stream->decoder, codec)) {
        LOGE("Could not open decoder");
-        goto finally_free_codec_ctx;
+        goto finally_close_input;
    }

-    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;
-        }
+    if (stream->recorder && !recorder_open(stream->recorder, codec)) {
+        LOGE("Could not open recorder");
+        goto finally_close_input;
    }

-    stream->parser = av_parser_init(AV_CODEC_ID_H264);
-    if (!stream->parser) {
-        LOGE("Could not initialize parser");
-        goto finally_stop_and_join_recorder;
-    }
+    AVPacket packet;
+    av_init_packet(&packet);
+    packet.data = NULL;
+    packet.size = 0;

-    // 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;
-
-    for (;;) {
-        AVPacket packet;
-        bool ok = stream_recv_packet(stream, &packet);
-        if (!ok) {
-            // end of stream
-            break;
+    while (!av_read_frame(format_ctx, &packet)) {
+        if (SDL_AtomicGet(&stream->stopped)) {
+            // if the stream is stopped, the socket had been shutdown, so the
+            // last packet is probably corrupted (but not detected as such by
+            // FFmpeg) and will not be decoded correctly
+            av_packet_unref(&packet);
+            goto quit;
+        }
+        if (stream->decoder && !decoder_push(stream->decoder, &packet)) {
+            av_packet_unref(&packet);
+            goto quit;
+        }
+
+        if (stream->recorder) {
+            // we retrieve the PTS in order they were received, so they will
+            // be assigned to the correct frame
+            uint64_t pts = receiver_state_take_meta(&stream->receiver_state);
+            packet.pts = pts;
+            packet.dts = pts;
+
+            // no need to rescale with av_packet_rescale_ts(), the timestamps
+            // are in microseconds both in input and output
+            if (!recorder_write(stream->recorder, &packet)) {
+                LOGE("Could not write frame to output file");
+                av_packet_unref(&packet);
+                goto quit;
+            }
        }

-        ok = stream_push_packet(stream, &packet);
        av_packet_unref(&packet);
-        if (!ok) {
-            // cannot process packet (error already logged)
+
+        if (avio_ctx->eof_reached) {
            break;
        }
    }

    LOGD("End of frames");

-    if (stream->has_pending) {
-        av_packet_unref(&stream->pending);
-    }
-
-    av_parser_close(stream->parser);
-finally_stop_and_join_recorder:
-    if (stream->recorder) {
-        recorder_stop(stream->recorder);
-        LOGI("Finishing recording...");
-        recorder_join(stream->recorder);
-    }
-finally_close_recorder:
+quit:
    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);
+finally_close_input:
+    avformat_close_input(&format_ctx);
+finally_free_avio_ctx:
+    av_free(avio_ctx->buffer);
+    av_free(avio_ctx);
+finally_free_format_ctx:
+    avformat_free_context(format_ctx);
 end:
    notify_stopped();
    return 0;
@ -273,7 +266,7 @@ stream_init(struct stream *stream, socket_t socket,
    stream->socket = socket;
    stream->decoder = decoder,
    stream->recorder = recorder;
-    stream->has_pending = false;
+    SDL_AtomicSet(&stream->stopped, 0);
 }

 bool
@ -290,6 +283,7 @@ stream_start(struct stream *stream) {

 void
 stream_stop(struct stream *stream) {
+    SDL_AtomicSet(&stream->stopped, 1);
    if (stream->decoder) {
        decoder_interrupt(stream->decoder);
    }
--- a/app/src/stream.h
+++ b/app/src/stream.h
@ -3,27 +3,30 @@

 #include <stdbool.h>
 #include <stdint.h>
-#include <libavformat/avformat.h>
 #include <SDL2/SDL_atomic.h>
 #include <SDL2/SDL_thread.h>

-#include "config.h"
 #include "net.h"

 struct video_buffer;

+struct frame_meta {
+    uint64_t pts;
+    struct frame_meta *next;
+};
+
 struct stream {
    socket_t socket;
    struct video_buffer *video_buffer;
    SDL_Thread *thread;
+    SDL_atomic_t stopped;
    struct decoder *decoder;
    struct recorder *recorder;
-    AVCodecContext *codec_ctx;
-    AVCodecParserContext *parser;
-    // successive packets may need to be concatenated, until a non-config
-    // packet is available
-    bool has_pending;
-    AVPacket pending;
+    struct receiver_state {
+        // meta (in order) for frames not consumed yet
+        struct frame_meta *frame_meta_queue;
+        size_t remaining; // remaining bytes to receive for the current frame
+    } receiver_state;
 };

 void
--- a/app/src/sys/unix/command.c
+++ b/app/src/sys/unix/command.c
@ -1,17 +1,9 @@
-// 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 <sys/types.h>
@ -96,7 +88,7 @@ cmd_simple_wait(pid_t pid, int *exit_code) {
    int status;
    int code;
    if (waitpid(pid, &status, 0) == -1 || !WIFEXITED(status)) {
-        // could not wait, or exited unexpectedly, probably by a signal
+        // cannot wait, or exited unexpectedly, probably by a signal
        code = -1;
    } else {
        code = WEXITSTATUS(status);
@ -106,23 +98,3 @@ cmd_simple_wait(pid_t pid, int *exit_code) {
    }
    return !code;
 }
-
-char *
-get_executable_path(void) {
-// <https://stackoverflow.com/a/1024937/1987178>
-#ifdef __linux__
-    char buf[PATH_MAX + 1]; // +1 for the null byte
-    ssize_t len = readlink("/proc/self/exe", buf, PATH_MAX);
-    if (len == -1) {
-        perror("readlink");
-        return NULL;
-    }
-    buf[len] = '\0';
-    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
-    // (it's useful to have a working version on Linux for debugging though)
-    return NULL;
-#endif
-}
--- a/app/src/sys/unix/net.c
+++ b/app/src/sys/unix/net.c
@ -2,8 +2,6 @@

 #include <unistd.h>

-#include "config.h"
-
 bool
 net_init(void) {
    // do nothing
--- a/app/src/sys/win/command.c
+++ b/app/src/sys/win/command.c
@ -33,7 +33,7 @@ cmd_execute(const char *path, const char *const argv[], HANDLE *handle) {

    wchar_t *wide = utf8_to_wide_char(cmd);
    if (!wide) {
-        LOGC("Could not allocate wide char string");
+        LOGC("Cannot allocate wide char string");
        return PROCESS_ERROR_GENERIC;
    }

@ -67,7 +67,7 @@ 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
+        // cannot wait or retrieve the exit code
        code = -1; // max value, it's unsigned
    }
    if (exit_code) {
@ -75,18 +75,3 @@ cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
    }
    return !code;
 }
-
-char *
-get_executable_path(void) {
-    HMODULE hModule = GetModuleHandleW(NULL);
-    if (!hModule) {
-        return NULL;
-    }
-    WCHAR buf[MAX_PATH + 1]; // +1 for the null byte
-    int len = GetModuleFileNameW(hModule, buf, MAX_PATH);
-    if (!len) {
-        return NULL;
-    }
-    buf[len] = '\0';
-    return utf8_from_wide_char(buf);
-}
--- a/app/src/sys/win/net.c
+++ b/app/src/sys/win/net.c
@ -1,6 +1,5 @@
 #include "net.h"

-#include "config.h"
 #include "log.h"

 bool
--- a/app/src/tiny_xpm.c
+++ b/app/src/tiny_xpm.c
@ -5,7 +5,6 @@
 #include <stdio.h>
 #include <stdlib.h>

-#include "config.h"
 #include "log.h"

 struct index {
--- a/app/src/tiny_xpm.h
+++ b/app/src/tiny_xpm.h
@ -3,8 +3,6 @@

 #include <SDL2/SDL.h>

-#include "config.h"
-
 SDL_Surface *
 read_xpm(char *xpm[]);

--- a/app/src/video_buffer.c
+++ b/app/src/video_buffer.c
@ -77,8 +77,10 @@ video_buffer_offer_decoded_frame(struct video_buffer *vb,
        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);
+    } else {
+        if (vb->fps_counter->started && !vb->rendering_frame_consumed) {
+            fps_counter_add_skipped_frame(vb->fps_counter);
+        }
    }

    video_buffer_swap_frames(vb);
@ -93,7 +95,9 @@ 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->fps_counter->started) {
+        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);
--- a/app/src/video_buffer.h
+++ b/app/src/video_buffer.h
@ -4,7 +4,6 @@
 #include <stdbool.h>
 #include <SDL2/SDL_mutex.h>

-#include "config.h"
 #include "fps_counter.h"

 // forward declarations
--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@ -67,39 +67,35 @@ static void test_serialize_inject_text_long(void) {
    assert(!memcmp(buf, expected, sizeof(expected)));
 }

-static void test_serialize_inject_touch_event(void) {
+static void test_serialize_inject_mouse_event(void) {
    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-        .inject_touch_event = {
+        .type = CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT,
+        .inject_mouse_event = {
            .action = AMOTION_EVENT_ACTION_DOWN,
-            .pointer_id = 0x1234567887654321L,
+            .buttons = AMOTION_EVENT_BUTTON_PRIMARY,
            .position = {
                .point = {
-                    .x = 100,
-                    .y = 200,
+                    .x = 260,
+                    .y = 1026,
                },
                .screen_size = {
                    .width = 1080,
                    .height = 1920,
                },
            },
-            .pressure = 1.0f,
-            .buttons = AMOTION_EVENT_BUTTON_PRIMARY,
        },
    };

    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 28);
+    assert(size == 18);

    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+        CONTROL_MSG_TYPE_INJECT_MOUSE_EVENT,
        0x00, // AKEY_EVENT_ACTION_DOWN
-        0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21, // pointer id
-        0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0xc8, // 100 200
+        0x00, 0x00, 0x00, 0x01, // AMOTION_EVENT_BUTTON_PRIMARY
+        0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x02, // 260 1026
        0x04, 0x38, 0x07, 0x80, // 1080 1920
-        0xff, 0xff, // pressure
-        0x00, 0x00, 0x00, 0x01 // AMOTION_EVENT_BUTTON_PRIMARY
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
@ -240,7 +236,7 @@ int main(void) {
    test_serialize_inject_keycode();
    test_serialize_inject_text();
    test_serialize_inject_text_long();
-    test_serialize_inject_touch_event();
+    test_serialize_inject_mouse_event();
    test_serialize_inject_scroll_event();
    test_serialize_back_or_screen_on();
    test_serialize_expand_notification_panel();
--- a/app/tests/test_queue.c
+++ b/app/tests/test_queue.c
@ -1,38 +0,0 @@
-#include <assert.h>
-
-#include <queue.h>
-
-struct foo {
-    int value;
-    struct foo *next;
-};
-
-static void test_queue(void) {
-    struct my_queue QUEUE(struct foo) queue;
-    queue_init(&queue);
-
-    assert(queue_is_empty(&queue));
-
-    struct foo v1 = { .value = 42 };
-    struct foo v2 = { .value = 27 };
-
-    queue_push(&queue, next, &v1);
-    queue_push(&queue, next, &v2);
-
-    struct foo *foo;
-
-    assert(!queue_is_empty(&queue));
-    queue_take(&queue, next, &foo);
-    assert(foo->value == 42);
-
-    assert(!queue_is_empty(&queue));
-    queue_take(&queue, next, &foo);
-    assert(foo->value == 27);
-
-    assert(queue_is_empty(&queue));
-}
-
-int main(void) {
-    test_queue();
-    return 0;
-}
--- a/build.gradle
+++ b/build.gradle
@ -7,7 +7,7 @@ buildscript {
        jcenter()
    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:3.4.2'
+        classpath 'com.android.tools.build:gradle:3.3.0'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
--- a/cross_win32.txt
+++ b/cross_win32.txt
@ -15,6 +15,6 @@ cpu = 'i686'
 endian = 'little'

 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.1.4-win32-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.1.4-win32-dev'
-prebuilt_sdl2 = 'SDL2-2.0.10/i686-w64-mingw32'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.1-win32-shared'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.1-win32-dev'
+prebuilt_sdl2 = 'SDL2-2.0.9/i686-w64-mingw32'
--- a/cross_win64.txt
+++ b/cross_win64.txt
@ -15,6 +15,6 @@ cpu = 'x86_64'
 endian = 'little'

 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.1.4-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.1.4-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.10/x86_64-w64-mingw32'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.1-win64-shared'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.1-win64-dev'
+prebuilt_sdl2 = 'SDL2-2.0.9/x86_64-w64-mingw32'
--- a/gradle/wrapper/gradle-wrapper.jar
+++ b/gradle/wrapper/gradle-wrapper.jar
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@ -1,5 +1,6 @@
+#Thu Apr 18 11:45:59 CEST 2019
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.5.1-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.1-all.zip
--- a/116
+++ b/116
@ -1,20 +1,4 @@
-#!/usr/bin/env sh
-
-#
-# Copyright 2015 the original author or authors.
-#
-# 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
-#
-#      https://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.
-#
+#!/usr/bin/env bash

 ##############################################################################
 ##
@ -22,6 +6,42 @@
 ##
 ##############################################################################

+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@ -40,46 +60,6 @@ cd "`dirname \"$PRG\"`/" >/dev/null
 APP_HOME="`pwd -P`"
 cd "$SAVED" >/dev/null

-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
-
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar

 # Determine the Java command to use to start the JVM.
@ -105,7 +85,7 @@ location of your Java installation."
 fi

 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
    MAX_FD_LIMIT=`ulimit -H -n`
    if [ $? -eq 0 ] ; then
        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@ -170,19 +150,11 @@ if $cygwin ; then
    esac
 fi

-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
 }
-APP_ARGS=$(save "$@")
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"

-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
-exec "$JAVACMD" "$@"
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
--- a/gradlew.bat
+++ b/gradlew.bat
@ -1,19 +1,3 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@ -24,14 +8,14 @@
@rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal

+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%

-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
@rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome

@ -62,9 +46,10 @@ echo location of your Java installation.
 goto fail

 :init
-@rem Get command-line arguments, handling Windows variants
+@rem Get command-line arguments, handling Windowz variants

 if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args

 :win9xME_args
@rem Slurp the command line arguments.
@ -75,6 +60,11 @@ set _SKIP=2
 if "x%~1" == "x" goto execute

 set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$

 :execute
@rem Setup the command line
--- a/meson.build
+++ b/meson.build
@ -1,13 +1,13 @@
 project('scrcpy', 'c',
-        version: '1.10',
+        version: '1.8',
        meson_version: '>= 0.37',
        default_options: 'c_std=c11')

-if get_option('compile_app')
+if get_option('build_app')
    subdir('app')
 endif

-if get_option('compile_server')
+if get_option('build_server')
    subdir('server')
 endif

--- a/meson_options.txt
+++ b/meson_options.txt
@ -1,7 +1,8 @@
-option('compile_app', type: 'boolean', value: true, description: 'Build the client')
-option('compile_server', type: 'boolean', value: true, description: 'Build the server')
+option('build_app', type: 'boolean', value: true, description: 'Build the client')
+option('build_server', type: 'boolean', value: true, description: 'Build the server')
 option('crossbuild_windows', type: 'boolean', value: false, description: 'Build for Windows from Linux')
 option('windows_noconsole', type: 'boolean', value: false, description: 'Disable console on Windows (pass -mwindows flag)')
 option('prebuilt_server', type: 'string', description: 'Path of the prebuilt server')
-option('portable', type: 'boolean', value: false, description: 'Use scrcpy-server.jar from the same directory as the scrcpy executable')
+option('override_server_path', type: 'string', description: 'Hardcoded path to find the server at runtime')
+option('skip_frames', type: 'boolean', value: true, description: 'Always display the most recent frame')
 option('hidpi_support', type: 'boolean', value: true, description: 'Enable High DPI support')
--- a/prebuilt-deps/Makefile
+++ b/prebuilt-deps/Makefile
@ -10,31 +10,31 @@ prepare-win32: prepare-sdl2 prepare-ffmpeg-shared-win32 prepare-ffmpeg-dev-win32
 prepare-win64: prepare-sdl2 prepare-ffmpeg-shared-win64 prepare-ffmpeg-dev-win64 prepare-adb

 prepare-ffmpeg-shared-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.1.4-win32-shared.zip \
-		596608277f6b937c3dea7c46e854665d75b3de56790bae07f655ca331440f003 \
-		ffmpeg-4.1.4-win32-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.1-win32-shared.zip \
+		e692b18c01745d262c03294b382fd64df68fabe3c66aa4546a3ad3935175cde3 \
+		ffmpeg-4.1-win32-shared

 prepare-ffmpeg-dev-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.1.4-win32-dev.zip \
-		a80c86e263cfad26e202edfa5e6e939a2c88843ae26f031d3e0d981a39fd03fb \
-		ffmpeg-4.1.4-win32-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.1-win32-dev.zip \
+		34bc5e471fb9160609abd6bc271e361050f3ff7376b1b8a0873cca02b38277c8 \
+		ffmpeg-4.1-win32-dev

 prepare-ffmpeg-shared-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.1.4-win64-shared.zip \
-		a90889871de2cab8a79b392591313a188189a353f69dde1db98aebe20b280989 \
-		ffmpeg-4.1.4-win64-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.1-win64-shared.zip \
+		c4908c97436c946509dc365e421159274fa4b1e66dce6fb5b63d82a6294d5357 \
+		ffmpeg-4.1-win64-shared

 prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.1.4-win64-dev.zip \
-		6c9d53f9e94ce1821e975ec668e5b9d6e9deb4a45d0d7e30264685d3dfbbb068 \
-		ffmpeg-4.1.4-win64-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.1-win64-dev.zip \
+		761ec79aa3dae66698c9791a2f0bb9da8794246f8356cadc741ddc0eabab0471 \
+		ffmpeg-4.1-win64-dev

 prepare-sdl2:
-	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.10-mingw.tar.gz \
-		a90a7cddaec4996f4d7be6d80c57ec69b062e132bffc513965f99217f603274a \
-		SDL2-2.0.10
+	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.9-mingw.tar.gz \
+		0f9f00d0f2a9a95dfb5cce929718210c3f85432cc2e9d4abade4adcb7f6bb39d \
+		SDL2-2.0.9

 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r29.0.2-windows.zip \
-		d78f02e5e2c9c4c1d046dcd4e6fbdf586e5f57ef66eb0da5c2b49d745d85d5ee \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r28.0.1-windows.zip \
+		db78f726d5dc653706dcd15a462ab1b946c643f598df76906c4c1858411c54df \
 		platform-tools
--- a/server/build.gradle
+++ b/server/build.gradle
@ -1,13 +1,13 @@
 apply plugin: 'com.android.application'

 android {
-    compileSdkVersion 29
+    compileSdkVersion 27
    defaultConfig {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
-        targetSdkVersion 29
-        versionCode 11
-        versionName "1.10"
+        targetSdkVersion 27
+        versionCode 9
+        versionName "1.8"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
--- a/server/meson.build
+++ b/server/meson.build
@ -6,7 +6,6 @@ if prebuilt_server == ''
                  build_always: true,  # gradle is responsible for tracking source changes
                  output: 'scrcpy-server.jar',
                  command: [find_program('./scripts/build-wrapper.sh'), meson.current_source_dir(), '@OUTPUT@', get_option('buildtype')],
-                  console: true,
                  install: true,
                  install_dir: 'share/scrcpy')
 else
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
@ -7,7 +7,7 @@ public final class ControlMessage {

    public static final int TYPE_INJECT_KEYCODE = 0;
    public static final int TYPE_INJECT_TEXT = 1;
-    public static final int TYPE_INJECT_TOUCH_EVENT = 2;
+    public static final int TYPE_INJECT_MOUSE_EVENT = 2;
    public static final int TYPE_INJECT_SCROLL_EVENT = 3;
    public static final int TYPE_BACK_OR_SCREEN_ON = 4;
    public static final int TYPE_EXPAND_NOTIFICATION_PANEL = 5;
@ -22,8 +22,6 @@ public final class ControlMessage {
    private int action; // KeyEvent.ACTION_* or MotionEvent.ACTION_* or POWER_MODE_*
    private int keycode; // KeyEvent.KEYCODE_*
    private int buttons; // MotionEvent.BUTTON_*
-    private long pointerId;
-    private float pressure;
    private Position position;
    private int hScroll;
    private int vScroll;
@ -32,63 +30,60 @@ public final class ControlMessage {
    }

    public static ControlMessage createInjectKeycode(int action, int keycode, int metaState) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = TYPE_INJECT_KEYCODE;
-        msg.action = action;
-        msg.keycode = keycode;
-        msg.metaState = metaState;
-        return msg;
+        ControlMessage event = new ControlMessage();
+        event.type = TYPE_INJECT_KEYCODE;
+        event.action = action;
+        event.keycode = keycode;
+        event.metaState = metaState;
+        return event;
    }

    public static ControlMessage createInjectText(String text) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = TYPE_INJECT_TEXT;
-        msg.text = text;
-        return msg;
+        ControlMessage event = new ControlMessage();
+        event.type = TYPE_INJECT_TEXT;
+        event.text = text;
+        return event;
    }

-    public static ControlMessage createInjectTouchEvent(int action, long pointerId, Position position, float pressure,
-            int buttons) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = TYPE_INJECT_TOUCH_EVENT;
-        msg.action = action;
-        msg.pointerId = pointerId;
-        msg.pressure = pressure;
-        msg.position = position;
-        msg.buttons = buttons;
-        return msg;
+    public static ControlMessage createInjectMouseEvent(int action, int buttons, Position position) {
+        ControlMessage event = new ControlMessage();
+        event.type = TYPE_INJECT_MOUSE_EVENT;
+        event.action = action;
+        event.buttons = buttons;
+        event.position = position;
+        return event;
    }

    public static ControlMessage createInjectScrollEvent(Position position, int hScroll, int vScroll) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = TYPE_INJECT_SCROLL_EVENT;
-        msg.position = position;
-        msg.hScroll = hScroll;
-        msg.vScroll = vScroll;
-        return msg;
+        ControlMessage event = new ControlMessage();
+        event.type = TYPE_INJECT_SCROLL_EVENT;
+        event.position = position;
+        event.hScroll = hScroll;
+        event.vScroll = vScroll;
+        return event;
    }

    public static ControlMessage createSetClipboard(String text) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = TYPE_SET_CLIPBOARD;
-        msg.text = text;
-        return msg;
+        ControlMessage event = new ControlMessage();
+        event.type = TYPE_SET_CLIPBOARD;
+        event.text = text;
+        return event;
    }

    /**
     * @param mode one of the {@code Device.SCREEN_POWER_MODE_*} constants
     */
    public static ControlMessage createSetScreenPowerMode(int mode) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = TYPE_SET_SCREEN_POWER_MODE;
-        msg.action = mode;
-        return msg;
+        ControlMessage event = new ControlMessage();
+        event.type = TYPE_SET_SCREEN_POWER_MODE;
+        event.action = mode;
+        return event;
    }

    public static ControlMessage createEmpty(int type) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = type;
-        return msg;
+        ControlMessage event = new ControlMessage();
+        event.type = type;
+        return event;
    }

    public int getType() {
@ -115,14 +110,6 @@ public final class ControlMessage {
        return buttons;
    }

-    public long getPointerId() {
-        return pointerId;
-    }
-
-    public float getPressure() {
-        return pressure;
-    }
-
    public Position getPosition() {
        return position;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
@ -10,7 +10,6 @@ public class ControlMessageReader {

    private static final int INJECT_KEYCODE_PAYLOAD_LENGTH = 9;
    private static final int INJECT_MOUSE_EVENT_PAYLOAD_LENGTH = 17;
-    private static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 21;
    private static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
    private static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;

@ -60,8 +59,8 @@ public class ControlMessageReader {
            case ControlMessage.TYPE_INJECT_TEXT:
                msg = parseInjectText();
                break;
-            case ControlMessage.TYPE_INJECT_TOUCH_EVENT:
-                msg = parseInjectTouchEvent();
+            case ControlMessage.TYPE_INJECT_MOUSE_EVENT:
+                msg = parseInjectMouseEvent();
                break;
            case ControlMessage.TYPE_INJECT_SCROLL_EVENT:
                msg = parseInjectScrollEvent();
@ -121,20 +120,14 @@ public class ControlMessageReader {
        return ControlMessage.createInjectText(text);
    }

-    @SuppressWarnings("checkstyle:MagicNumber")
-    private ControlMessage parseInjectTouchEvent() {
-        if (buffer.remaining() < INJECT_TOUCH_EVENT_PAYLOAD_LENGTH) {
+    private ControlMessage parseInjectMouseEvent() {
+        if (buffer.remaining() < INJECT_MOUSE_EVENT_PAYLOAD_LENGTH) {
            return null;
        }
        int action = toUnsigned(buffer.get());
-        long pointerId = buffer.getLong();
-        Position position = readPosition(buffer);
-        // 16 bits fixed-point
-        int pressureInt = toUnsigned(buffer.getShort());
-        // convert it to a float between 0 and 1 (0x1p16f is 2^16 as float)
-        float pressure = pressureInt == 0xffff ? 1f : (pressureInt / 0x1p16f);
        int buttons = buffer.getInt();
-        return ControlMessage.createInjectTouchEvent(action, pointerId, position, pressure, buttons);
+        Position position = readPosition(buffer);
+        return ControlMessage.createInjectMouseEvent(action, buttons, position);
    }

    private ControlMessage parseInjectScrollEvent() {
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@ -19,32 +19,38 @@ public class Controller {

    private final KeyCharacterMap charMap = KeyCharacterMap.load(KeyCharacterMap.VIRTUAL_KEYBOARD);

-    private long lastTouchDown;
-    private final PointersState pointersState = new PointersState();
-    private final MotionEvent.PointerProperties[] pointerProperties =
-            new MotionEvent.PointerProperties[PointersState.MAX_POINTERS];
-    private final MotionEvent.PointerCoords[] pointerCoords =
-            new MotionEvent.PointerCoords[PointersState.MAX_POINTERS];
+    private long lastMouseDown;
+    private final MotionEvent.PointerProperties[] pointerProperties = {new MotionEvent.PointerProperties()};
+    private final MotionEvent.PointerCoords[] pointerCoords = {new MotionEvent.PointerCoords()};

    public Controller(Device device, DesktopConnection connection) {
        this.device = device;
        this.connection = connection;
-        initPointers();
+        initPointer();
        sender = new DeviceMessageSender(connection);
    }

-    private void initPointers() {
-        for (int i = 0; i < PointersState.MAX_POINTERS; ++i) {
-            MotionEvent.PointerProperties props = new MotionEvent.PointerProperties();
-            props.toolType = MotionEvent.TOOL_TYPE_FINGER;
+    private void initPointer() {
+        MotionEvent.PointerProperties props = pointerProperties[0];
+        props.id = 0;
+        props.toolType = MotionEvent.TOOL_TYPE_FINGER;

-            MotionEvent.PointerCoords coords = new MotionEvent.PointerCoords();
-            coords.orientation = 0;
-            coords.size = 1;
+        MotionEvent.PointerCoords coords = pointerCoords[0];
+        coords.orientation = 0;
+        coords.pressure = 1;
+        coords.size = 1;
+    }

-            pointerProperties[i] = props;
-            pointerCoords[i] = coords;
-        }
+    private void setPointerCoords(Point point) {
+        MotionEvent.PointerCoords coords = pointerCoords[0];
+        coords.x = point.getX();
+        coords.y = point.getY();
+    }
+
+    private void setScroll(int hScroll, int vScroll) {
+        MotionEvent.PointerCoords coords = pointerCoords[0];
+        coords.setAxisValue(MotionEvent.AXIS_HSCROLL, hScroll);
+        coords.setAxisValue(MotionEvent.AXIS_VSCROLL, vScroll);
    }

    @SuppressWarnings("checkstyle:MagicNumber")
@ -81,8 +87,8 @@ public class Controller {
            case ControlMessage.TYPE_INJECT_TEXT:
                injectText(msg.getText());
                break;
-            case ControlMessage.TYPE_INJECT_TOUCH_EVENT:
-                injectTouch(msg.getAction(), msg.getPointerId(), msg.getPosition(), msg.getPressure(), 0);
+            case ControlMessage.TYPE_INJECT_MOUSE_EVENT:
+                injectMouse(msg.getAction(), msg.getButtons(), msg.getPosition());
                break;
            case ControlMessage.TYPE_INJECT_SCROLL_EVENT:
                injectScroll(msg.getPosition(), msg.getHScroll(), msg.getVScroll());
@ -142,42 +148,19 @@ public class Controller {
        return successCount;
    }

-    private boolean injectTouch(int action, long pointerId, Position position, float pressure, int buttons) {
+    private boolean injectMouse(int action, int buttons, Position position) {
        long now = SystemClock.uptimeMillis();
-
+        if (action == MotionEvent.ACTION_DOWN) {
+            lastMouseDown = now;
+        }
        Point point = device.getPhysicalPoint(position);
        if (point == null) {
            // ignore event
            return false;
        }
-
-        int pointerIndex = pointersState.getPointerIndex(pointerId);
-        if (pointerIndex == -1) {
-            Ln.w("Too many pointers for touch event");
-            return false;
-        }
-        Pointer pointer = pointersState.get(pointerIndex);
-        pointer.setPoint(point);
-        pointer.setPressure(pressure);
-        pointer.setUp(action == MotionEvent.ACTION_UP);
-
-        int pointerCount = pointersState.update(pointerProperties, pointerCoords);
-
-        if (pointerCount == 1) {
-            if (action == MotionEvent.ACTION_DOWN) {
-                lastTouchDown = now;
-            }
-        } else {
-            // secondary pointers must use ACTION_POINTER_* ORed with the pointerIndex
-            if (action == MotionEvent.ACTION_UP) {
-                action = MotionEvent.ACTION_POINTER_UP | (pointerIndex << MotionEvent.ACTION_POINTER_INDEX_SHIFT);
-            } else if (action == MotionEvent.ACTION_DOWN) {
-                action = MotionEvent.ACTION_POINTER_DOWN | (pointerIndex << MotionEvent.ACTION_POINTER_INDEX_SHIFT);
-            }
-        }
-
-        MotionEvent event = MotionEvent.obtain(lastTouchDown, now, action, pointerCount, pointerProperties,
-                pointerCoords, 0, 0, 1f, 1f, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
+        setPointerCoords(point);
+        MotionEvent event = MotionEvent.obtain(lastMouseDown, now, action, 1, pointerProperties, pointerCoords, 0, buttons, 1f, 1f, 0, 0,
+                InputDevice.SOURCE_TOUCHSCREEN, 0);
        return injectEvent(event);
    }

@ -188,30 +171,23 @@ public class Controller {
            // ignore event
            return false;
        }
-
-        MotionEvent.PointerProperties props = pointerProperties[0];
-        props.id = 0;
-
-        MotionEvent.PointerCoords coords = pointerCoords[0];
-        coords.x = point.getX();
-        coords.y = point.getY();
-        coords.setAxisValue(MotionEvent.AXIS_HSCROLL, hScroll);
-        coords.setAxisValue(MotionEvent.AXIS_VSCROLL, vScroll);
-
-        MotionEvent event = MotionEvent.obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties,
-                pointerCoords, 0, 0, 1f, 1f, 0, 0, InputDevice.SOURCE_MOUSE, 0);
+        setPointerCoords(point);
+        setScroll(hScroll, vScroll);
+        MotionEvent event = MotionEvent.obtain(lastMouseDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, 0,
+                0, InputDevice.SOURCE_MOUSE, 0);
        return injectEvent(event);
    }

    private boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState) {
        long now = SystemClock.uptimeMillis();
-        KeyEvent event = new KeyEvent(now, now, action, keyCode, repeat, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD,
-                0, 0, InputDevice.SOURCE_KEYBOARD);
+        KeyEvent event = new KeyEvent(now, now, action, keyCode, repeat, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0,
+                InputDevice.SOURCE_KEYBOARD);
        return injectEvent(event);
    }

    private boolean injectKeycode(int keyCode) {
-        return injectKeyEvent(KeyEvent.ACTION_DOWN, keyCode, 0, 0) && injectKeyEvent(KeyEvent.ACTION_UP, keyCode, 0, 0);
+        return injectKeyEvent(KeyEvent.ACTION_DOWN, keyCode, 0, 0)
+                && injectKeyEvent(KeyEvent.ACTION_UP, keyCode, 0, 0);
    }

    private boolean injectEvent(InputEvent event) {
--- a/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
@ -89,7 +89,7 @@ public final class DesktopConnection implements Closeable {
        byte[] buffer = new byte[DEVICE_NAME_FIELD_LENGTH + 4];

        byte[] deviceNameBytes = deviceName.getBytes(StandardCharsets.UTF_8);
-        int len = StringUtils.getUtf8TruncationIndex(deviceNameBytes, DEVICE_NAME_FIELD_LENGTH - 1);
+        int len = Math.min(DEVICE_NAME_FIELD_LENGTH - 1, deviceNameBytes.length);
        System.arraycopy(deviceNameBytes, 0, buffer, 0, len);
        // byte[] are always 0-initialized in java, no need to set '\0' explicitly

--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@ -161,11 +161,7 @@ public final class Device {
     * @param mode one of the {@code SCREEN_POWER_MODE_*} constants
     */
    public void setScreenPowerMode(int mode) {
-        IBinder d = SurfaceControl.getBuiltInDisplay();
-        if (d == null) {
-            Ln.e("Could not get built-in display");
-            return;
-        }
+        IBinder d = SurfaceControl.getBuiltInDisplay(0);
        SurfaceControl.setDisplayPowerMode(d, mode);
        Ln.i("Device screen turned " + (mode == Device.POWER_MODE_OFF ? "off" : "on"));
    }
--- a/server/src/main/java/com/genymobile/scrcpy/Pointer.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Pointer.java
@ -1,55 +0,0 @@
-package com.genymobile.scrcpy;
-
-public class Pointer {
-
-    /**
-     * Pointer id as received from the client.
-     */
-    private final long id;
-
-    /**
-     * Local pointer id, using the lowest possible values to fill the {@link android.view.MotionEvent.PointerProperties PointerProperties}.
-     */
-    private final int localId;
-
-    private Point point;
-    private float pressure;
-    private boolean up;
-
-    public Pointer(long id, int localId) {
-        this.id = id;
-        this.localId = localId;
-    }
-
-    public long getId() {
-        return id;
-    }
-
-    public int getLocalId() {
-        return localId;
-    }
-
-    public Point getPoint() {
-        return point;
-    }
-
-    public void setPoint(Point point) {
-        this.point = point;
-    }
-
-    public float getPressure() {
-        return pressure;
-    }
-
-    public void setPressure(float pressure) {
-        this.pressure = pressure;
-    }
-
-    public boolean isUp() {
-        return up;
-    }
-
-    public void setUp(boolean up) {
-        this.up = up;
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/PointersState.java
+++ b/server/src/main/java/com/genymobile/scrcpy/PointersState.java
@ -1,103 +0,0 @@
-package com.genymobile.scrcpy;
-
-import android.view.MotionEvent;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class PointersState {
-
-    public static final int MAX_POINTERS = 10;
-
-    private final List<Pointer> pointers = new ArrayList<>();
-
-    private int indexOf(long id) {
-        for (int i = 0; i < pointers.size(); ++i) {
-            Pointer pointer = pointers.get(i);
-            if (pointer.getId() == id) {
-                return i;
-            }
-        }
-        return -1;
-    }
-
-    private boolean isLocalIdAvailable(int localId) {
-        for (int i = 0; i < pointers.size(); ++i) {
-            Pointer pointer = pointers.get(i);
-            if (pointer.getLocalId() == localId) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    private int nextUnusedLocalId() {
-        for (int localId = 0; localId < MAX_POINTERS; ++localId) {
-            if (isLocalIdAvailable(localId)) {
-                return localId;
-            }
-        }
-        return -1;
-    }
-
-    public Pointer get(int index) {
-        return pointers.get(index);
-    }
-
-    public int getPointerIndex(long id) {
-        int index = indexOf(id);
-        if (index != -1) {
-            // already exists, return it
-            return index;
-        }
-        if (pointers.size() >= MAX_POINTERS) {
-            // it's full
-            return -1;
-        }
-        // id 0 is reserved for mouse events
-        int localId = nextUnusedLocalId();
-        if (localId == -1) {
-            throw new AssertionError("pointers.size() < maxFingers implies that a local id is available");
-        }
-        Pointer pointer = new Pointer(id, localId);
-        pointers.add(pointer);
-        // return the index of the pointer
-        return pointers.size() - 1;
-    }
-
-    /**
-     * Initialize the motion event parameters.
-     *
-     * @param props  the pointer properties
-     * @param coords the pointer coordinates
-     * @return The number of items initialized (the number of pointers).
-     */
-    public int update(MotionEvent.PointerProperties[] props, MotionEvent.PointerCoords[] coords) {
-        int count = pointers.size();
-        for (int i = 0; i < count; ++i) {
-            Pointer pointer = pointers.get(i);
-
-            // id 0 is reserved for mouse events
-            props[i].id = pointer.getLocalId();
-
-            Point point = pointer.getPoint();
-            coords[i].x = point.getX();
-            coords[i].y = point.getY();
-            coords[i].pressure = pointer.getPressure();
-        }
-        cleanUp();
-        return count;
-    }
-
-    /**
-     * Remove all pointers which are UP.
-     */
-    private void cleanUp() {
-        for (int i = pointers.size() - 1; i >= 0; --i) {
-            Pointer pointer = pointers.get(i);
-            if (pointer.isUp()) {
-                pointers.remove(i);
-            }
-        }
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -68,7 +68,7 @@ public final class Server {
    @SuppressWarnings("checkstyle:MagicNumber")
    private static Options createOptions(String... args) {
        if (args.length != 6) {
-            throw new IllegalArgumentException("Expecting 6 parameters");
+            throw new IllegalArgumentException("Expecting 5 parameters");
        }

        Options options = new Options();
@ -116,7 +116,7 @@ public final class Server {
        try {
            new File(SERVER_PATH).delete();
        } catch (Exception e) {
-            Ln.e("Could not unlink server", e);
+            Ln.e("Cannot unlink server", e);
        }
    }

--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
@ -1,102 +1,44 @@
 package com.genymobile.scrcpy.wrappers;

-import com.genymobile.scrcpy.Ln;
-
 import android.content.ClipData;
-import android.os.Build;
 import android.os.IInterface;

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

 public class ClipboardManager {
-
-    private static final String PACKAGE_NAME = "com.android.shell";
-    private static final int USER_ID = 0;
-
    private final IInterface manager;
-    private Method getPrimaryClipMethod;
-    private Method setPrimaryClipMethod;
+    private final Method getPrimaryClipMethod;
+    private final Method setPrimaryClipMethod;

    public ClipboardManager(IInterface manager) {
        this.manager = manager;
-    }
-
-    private Method getGetPrimaryClipMethod() {
-        if (getPrimaryClipMethod == null) {
-            try {
-                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-                    getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class);
-                } else {
-                    getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, int.class);
-                }
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
-        }
-        return getPrimaryClipMethod;
-    }
-
-    private Method getSetPrimaryClipMethod() {
-        if (setPrimaryClipMethod == null) {
-            try {
-                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-                    setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class);
-                } else {
-                    setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class,
-                            String.class, int.class);
-                }
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
-        }
-        return setPrimaryClipMethod;
-    }
-
-    private static ClipData getPrimaryClip(Method method, IInterface manager) throws InvocationTargetException,
-            IllegalAccessException {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            return (ClipData) method.invoke(manager, PACKAGE_NAME);
-        }
-        return (ClipData) method.invoke(manager, PACKAGE_NAME, USER_ID);
-    }
-
-    private static void setPrimaryClip(Method method, IInterface manager, ClipData clipData) throws InvocationTargetException,
-            IllegalAccessException {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            method.invoke(manager, clipData, PACKAGE_NAME);
-        } else {
-            method.invoke(manager, clipData, PACKAGE_NAME, USER_ID);
+        try {
+            getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class);
+            setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class);
+        } catch (NoSuchMethodException e) {
+            throw new AssertionError(e);
        }
    }

    public CharSequence getText() {
-        Method method = getGetPrimaryClipMethod();
-        if (method == null) {
-            return null;
-        }
        try {
-            ClipData clipData = getPrimaryClip(method, manager);
+            ClipData clipData = (ClipData) getPrimaryClipMethod.invoke(manager, "com.android.shell");
            if (clipData == null || clipData.getItemCount() == 0) {
                return null;
            }
            return clipData.getItemAt(0).getText();
        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
-            return null;
+            throw new AssertionError(e);
        }
    }

    public void setText(CharSequence text) {
-        Method method = getSetPrimaryClipMethod();
-        if (method == null) {
-            return;
-        }
        ClipData clipData = ClipData.newPlainText(null, text);
        try {
-            setPrimaryClip(method, manager, clipData);
+            setPrimaryClipMethod.invoke(manager, clipData, "com.android.shell");
        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+            throw new AssertionError(e);
        }
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
@ -1,7 +1,5 @@
 package com.genymobile.scrcpy.wrappers;

-import com.genymobile.scrcpy.Ln;
-
 import android.os.IInterface;
 import android.view.InputEvent;

@ -15,33 +13,22 @@ public final class InputManager {
    public static final int INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH = 2;

    private final IInterface manager;
-    private Method injectInputEventMethod;
+    private final Method injectInputEventMethod;

    public InputManager(IInterface manager) {
        this.manager = manager;
-    }
-
-    private Method getInjectInputEventMethod() {
-        if (injectInputEventMethod == null) {
-            try {
-                injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
+        try {
+            injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
+        } catch (NoSuchMethodException e) {
+            throw new AssertionError(e);
        }
-        return injectInputEventMethod;
    }

    public boolean injectInputEvent(InputEvent inputEvent, int mode) {
-        Method method = getInjectInputEventMethod();
-        if (method == null) {
-            return false;
-        }
        try {
-            return (Boolean) method.invoke(manager, inputEvent, mode);
+            return (Boolean) injectInputEventMethod.invoke(manager, inputEvent, mode);
        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
-            return false;
+            throw new AssertionError(e);
        }
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/PowerManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/PowerManager.java
@ -1,7 +1,5 @@
 package com.genymobile.scrcpy.wrappers;

-import com.genymobile.scrcpy.Ln;
-
 import android.annotation.SuppressLint;
 import android.os.Build;
 import android.os.IInterface;
@ -11,35 +9,24 @@ import java.lang.reflect.Method;

 public final class PowerManager {
    private final IInterface manager;
-    private Method isScreenOnMethod;
+    private final Method isScreenOnMethod;

    public PowerManager(IInterface manager) {
        this.manager = manager;
-    }
-
-    private Method getIsScreenOnMethod() {
-        if (isScreenOnMethod == null) {
-            try {
-                @SuppressLint("ObsoleteSdkInt") // we may lower minSdkVersion in the future
-                        String methodName = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH ? "isInteractive" : "isScreenOn";
-                isScreenOnMethod = manager.getClass().getMethod(methodName);
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
+        try {
+            @SuppressLint("ObsoleteSdkInt") // we may lower minSdkVersion in the future
+            String methodName = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH ? "isInteractive" : "isScreenOn";
+            isScreenOnMethod = manager.getClass().getMethod(methodName);
+        } catch (NoSuchMethodException e) {
+            throw new AssertionError(e);
        }
-        return isScreenOnMethod;
    }

    public boolean isScreenOn() {
-        Method method = getIsScreenOnMethod();
-        if (method == null) {
-            return false;
-        }
        try {
-            return (Boolean) method.invoke(manager);
+            return (Boolean) isScreenOnMethod.invoke(manager);
        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
-            return false;
+            throw new AssertionError(e);
        }
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
@ -17,49 +17,35 @@ public class StatusBarManager {
        this.manager = manager;
    }

-    private Method getExpandNotificationsPanelMethod() {
+    public void expandNotificationsPanel() {
        if (expandNotificationsPanelMethod == null) {
            try {
                expandNotificationsPanelMethod = manager.getClass().getMethod("expandNotificationsPanel");
            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
+                Ln.e("ServiceBarManager.expandNotificationsPanel() is not available on this device");
+                return;
            }
        }
-        return expandNotificationsPanelMethod;
-    }
-
-    private Method getCollapsePanelsMethod() {
-        if (collapsePanelsMethod == null) {
-            try {
-                collapsePanelsMethod = manager.getClass().getMethod("collapsePanels");
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
-        }
-        return collapsePanelsMethod;
-    }
-
-    public void expandNotificationsPanel() {
-        Method method = getExpandNotificationsPanelMethod();
-        if (method == null) {
-            return;
-        }
        try {
-            method.invoke(manager);
+            expandNotificationsPanelMethod.invoke(manager);
        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+            Ln.e("Cannot invoke ServiceBarManager.expandNotificationsPanel()", e);
        }
    }

    public void collapsePanels() {
-        Method method = getCollapsePanelsMethod();
-        if (method == null) {
-            return;
+        if (collapsePanelsMethod == null) {
+            try {
+                collapsePanelsMethod = manager.getClass().getMethod("collapsePanels");
+            } catch (NoSuchMethodException e) {
+                Ln.e("ServiceBarManager.collapsePanels() is not available on this device");
+                return;
+            }
        }
        try {
-            method.invoke(manager);
+            collapsePanelsMethod.invoke(manager);
        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+            Ln.e("Cannot invoke ServiceBarManager.collapsePanels()", e);
        }
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java
@ -1,16 +1,10 @@
 package com.genymobile.scrcpy.wrappers;

-import com.genymobile.scrcpy.Ln;
-
 import android.annotation.SuppressLint;
 import android.graphics.Rect;
-import android.os.Build;
 import android.os.IBinder;
 import android.view.Surface;

-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
@SuppressLint("PrivateApi")
 public final class SurfaceControl {

@ -28,9 +22,6 @@ public final class SurfaceControl {
        }
    }

-    private static Method getBuiltInDisplayMethod;
-    private static Method setDisplayPowerModeMethod;
-
    private SurfaceControl() {
        // only static methods
    }
@ -84,62 +75,19 @@ public final class SurfaceControl {
        }
    }

-    private static Method getGetBuiltInDisplayMethod() {
-        if (getBuiltInDisplayMethod == null) {
-            try {
-                // the method signature has changed in Android Q
-                // <https://github.com/Genymobile/scrcpy/issues/586>
-                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-                    getBuiltInDisplayMethod = CLASS.getMethod("getBuiltInDisplay", int.class);
-                } else {
-                    getBuiltInDisplayMethod = CLASS.getMethod("getInternalDisplayToken");
-                }
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
-        }
-        return getBuiltInDisplayMethod;
-    }
-
-    public static IBinder getBuiltInDisplay() {
-        Method method = getGetBuiltInDisplayMethod();
-        if (method == null) {
-            return null;
-        }
+    public static IBinder getBuiltInDisplay(int builtInDisplayId) {
        try {
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-                // call getBuiltInDisplay(0)
-                return (IBinder) method.invoke(null, 0);
-            }
-
-            // call getInternalDisplayToken()
-            return (IBinder) method.invoke(null);
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
-            return null;
+            return (IBinder) CLASS.getMethod("getBuiltInDisplay", int.class).invoke(null, builtInDisplayId);
+        } catch (Exception e) {
+            throw new AssertionError(e);
        }
    }

-    private static Method getSetDisplayPowerModeMethod() {
-        if (setDisplayPowerModeMethod == null) {
-            try {
-                setDisplayPowerModeMethod = CLASS.getMethod("setDisplayPowerMode", IBinder.class, int.class);
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
-        }
-        return setDisplayPowerModeMethod;
-    }
-
    public static void setDisplayPowerMode(IBinder displayToken, int mode) {
-        Method method = getSetDisplayPowerModeMethod();
-        if (method == null) {
-            return;
-        }
        try {
-            method.invoke(null, displayToken, mode);
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+            CLASS.getMethod("setDisplayPowerMode", IBinder.class, int.class).invoke(null, displayToken, mode);
+        } catch (Exception e) {
+            throw new AssertionError(e);
        }
    }

--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java
@ -14,7 +14,7 @@ public final class WindowManager {
        try {
            Class<?> cls = manager.getClass();
            try {
-                return (Integer) cls.getMethod("getRotation").invoke(manager);
+                return (Integer) manager.getClass().getMethod("getRotation").invoke(manager);
            } catch (NoSuchMethodException e) {
                // method changed since this commit:
                // https://android.googlesource.com/platform/frameworks/base/+/8ee7285128c3843401d4c4d0412cd66e86ba49e3%5E%21/#F2
--- a/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
@ -77,36 +77,24 @@ public class ControlMessageReaderTest {
    }

    @Test
-    @SuppressWarnings("checkstyle:MagicNumber")
-    public void testParseTouchEvent() throws IOException {
+    public void testParseMouseEvent() throws IOException {
        ControlMessageReader reader = new ControlMessageReader();

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
-        dos.writeByte(ControlMessage.TYPE_INJECT_TOUCH_EVENT);
+        dos.writeByte(ControlMessage.TYPE_INJECT_KEYCODE);
        dos.writeByte(MotionEvent.ACTION_DOWN);
-        dos.writeLong(-42); // pointerId
-        dos.writeInt(100);
-        dos.writeInt(200);
-        dos.writeShort(1080);
-        dos.writeShort(1920);
-        dos.writeShort(0xffff); // pressure
        dos.writeInt(MotionEvent.BUTTON_PRIMARY);
-
+        dos.writeInt(KeyEvent.META_CTRL_ON);
        byte[] packet = bos.toByteArray();

        reader.readFrom(new ByteArrayInputStream(packet));
        ControlMessage event = reader.next();

-        Assert.assertEquals(ControlMessage.TYPE_INJECT_TOUCH_EVENT, event.getType());
+        Assert.assertEquals(ControlMessage.TYPE_INJECT_KEYCODE, event.getType());
        Assert.assertEquals(MotionEvent.ACTION_DOWN, event.getAction());
-        Assert.assertEquals(-42, event.getPointerId());
-        Assert.assertEquals(100, event.getPosition().getPoint().getX());
-        Assert.assertEquals(200, event.getPosition().getPoint().getY());
-        Assert.assertEquals(1080, event.getPosition().getScreenSize().getWidth());
-        Assert.assertEquals(1920, event.getPosition().getScreenSize().getHeight());
-        Assert.assertEquals(1f, event.getPressure(), 0f); // must be exact
-        Assert.assertEquals(MotionEvent.BUTTON_PRIMARY, event.getButtons());
+        Assert.assertEquals(MotionEvent.BUTTON_PRIMARY, event.getKeycode());
+        Assert.assertEquals(KeyEvent.META_CTRL_ON, event.getMetaState());
    }

    @Test
--- a/server/src/test/java/com/genymobile/scrcpy/DeviceMessageWriterTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/DeviceMessageWriterTest.java
@ -1,35 +0,0 @@
-package com.genymobile.scrcpy;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.io.ByteArrayOutputStream;
-import java.io.DataOutputStream;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-
-public class DeviceMessageWriterTest {
-
-    @Test
-    public void testSerializeClipboard() throws IOException {
-        DeviceMessageWriter writer = new DeviceMessageWriter();
-
-        String text = "aéûoç";
-        byte[] data = text.getBytes(StandardCharsets.UTF_8);
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        DataOutputStream dos = new DataOutputStream(bos);
-        dos.writeByte(DeviceMessage.TYPE_CLIPBOARD);
-        dos.writeShort(data.length);
-        dos.write(data);
-
-        byte[] expected = bos.toByteArray();
-
-        DeviceMessage msg = DeviceMessage.createClipboard(text);
-        bos = new ByteArrayOutputStream();
-        writer.writeTo(msg, bos);
-
-        byte[] actual = bos.toByteArray();
-
-        Assert.assertArrayEquals(expected, actual);
-    }
-}
--- a/server/src/test/java/com/genymobile/scrcpy/StringUtilsTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/StringUtilsTest.java
@ -1,6 +1,7 @@
 package com.genymobile.scrcpy;

-import org.junit.Assert;
+import junit.framework.Assert;
+
 import org.junit.Test;

 import java.nio.charset.StandardCharsets;
@ -9,7 +10,7 @@ public class StringUtilsTest {

    @Test
    @SuppressWarnings("checkstyle:MagicNumber")
-    public void testUtf8Truncate() {
+    public void testUtf8Trucate() {
        String s = "aÉbÔc";
        byte[] utf8 = s.getBytes(StandardCharsets.UTF_8);
        Assert.assertEquals(7, utf8.length);