Improve portable builds

In portable builds, scrcpy-server.jar was supposed to be present in the current directory, so in practice it worked only if scrcpy was launched from its own directory. Instead, find the absolute path of the executable and build a suitable path to use scrcpy-server.jar from the same directory.
Add functions to convert wide char to UTF-8
2019-06-10 16:08:00 +02:00 · 2019-06-10 16:06:32 +02:00 · 2019-06-10 16:06:32 +02:00 · 2019-06-10 16:02:57 +02:00 · 2019-06-10 15:52:54 +02:00
92 changed files with 982 additions and 2458 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
 ```


@@ -195,7 +195,8 @@ Then, build:

 ```bash
 meson x --buildtype release --strip -Db_lto=true
-ninja -Cx
+cd x
+ninja
 ```

 _Note: `ninja` [must][ninja-user] be run as a non-root user (only `ninja
@@ -218,13 +219,13 @@ To run without installing:
 After a successful build, you can install _scrcpy_ on the system:

 ```bash
-sudo ninja -Cx install    # without sudo on Windows
+sudo ninja install    # without sudo on Windows
 ```

 This installs two files:

 - `/usr/local/bin/scrcpy`
- - `/usr/local/share/scrcpy/scrcpy-server`
+ - `/usr/local/share/scrcpy/scrcpy-server.jar`

 Just remove them to "uninstall" the application.

@@ -233,17 +234,18 @@ 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:

 ```bash
 meson x --buildtype release --strip -Db_lto=true \
-    -Dprebuilt_server=/path/to/scrcpy-server
-ninja -Cx
-sudo ninja -Cx install
+    -Dprebuilt_server=/path/to/scrcpy-server.jar
+cd x
+ninja
+sudo ninja install
 ```
--- a/DEVELOP.md
+++ b/DEVELOP.md
@@ -3,7 +3,7 @@
 ## Overview

 This application is composed of two parts:
- - the server (`scrcpy-server`), to be executed on the device,
+ - the server (`scrcpy-server.jar`), to be executed on the device,
 - the client (the `scrcpy` binary), executed on the host computer.

 The client is responsible to push the server to the device and start its
@@ -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
@@ -49,7 +49,7 @@ application may not replace the server just before the client executes it._
 Instead of a raw _dex_ file, `app_process` accepts a _jar_ containing
 `classes.dex` (e.g. an [APK]). For simplicity, and to benefit from the gradle
 build system, the server is built to an (unsigned) APK (renamed to
-`scrcpy-server`).
+`scrcpy-server.jar`).

 [dex]: https://en.wikipedia.org/wiki/Dalvik_(software)
 [apk]: https://en.wikipedia.org/wiki/Android_application_package
@@ -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
@@ -268,33 +269,3 @@ For more details, go read the code!

 If you find a bug, or have an awesome idea to implement, please discuss and
 contribute ;-)
-
-
-### Debug the server
-
-The server is pushed to the device by the client on startup.
-
-To debug it, enable the server debugger during configuration:
-
-```bash
-meson x -Dserver_debugger=true
-# or, if x is already configured
-meson configure x -Dserver_debugger=true
-```
-
-Then recompile.
-
-When you start scrcpy, it will start a debugger on port 5005 on the device.
-Redirect that port to the computer:
-
-```bash
-adb forward tcp:5005 tcp:5005
-```
-
-In Android Studio, _Run_ > _Debug_ > _Edit configurations..._ On the left, click on
-`+`, _Remote_, and fill the form:
-
- - Host: `localhost`
- - Port: `5005`
-
-Then click on _Debug_.
--- a/FAQ.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
@@ -3,7 +3,7 @@
 #
 # Here, "portable" means that the client and server binaries are expected to be
 # anywhere, but in the same directory, instead of well-defined separate
-# locations (e.g. /usr/bin/scrcpy and /usr/share/scrcpy/scrcpy-server).
+# locations (e.g. /usr/bin/scrcpy and /usr/share/scrcpy/scrcpy-server.jar).
 #
 # In particular, this implies to change the location from where the client push
 # the server to the device.
@@ -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,7 +56,7 @@ build-win32: prepare-deps-win32
 			--cross-file cross_win32.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
+			-Dbuild_server=false \
 			-Dportable=true )
 	ninja -C "$(WIN32_BUILD_DIR)"

@@ -66,7 +66,7 @@ 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 )
 	ninja -C "$(WIN32_NOCONSOLE_BUILD_DIR)"
@@ -80,7 +80,7 @@ build-win64: prepare-deps-win64
 			--cross-file cross_win64.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
+			-Dbuild_server=false \
 			-Dportable=true )
 	ninja -C "$(WIN64_BUILD_DIR)"

@@ -90,48 +90,46 @@ 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 )
 	ninja -C "$(WIN64_NOCONSOLE_BUILD_DIR)"

 dist-win32: build-server build-win32 build-win32-noconsole
 	mkdir -p "$(DIST)/$(WIN32_TARGET_DIR)"
-	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(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 "$(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,10 +122,11 @@ 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)
+scrcpy -c 1224:1440:0:0       # short version
 ```

 If `--max-size` is also specified, resizing is applied after cropping.
@@ -225,6 +209,7 @@ The window of app can always be above others by:

 ```bash
 scrcpy --always-on-top
+scrcpy -T  # short version
 ```


@@ -260,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

@@ -303,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._
@@ -356,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` 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

@@ -394,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,10 +3,10 @@ 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',
@@ -93,7 +93,7 @@ conf.set_quoted('SCRCPY_VERSION', meson.project_version())
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))

-# build a "portable" version (with scrcpy-server accessible from the same
+# build a "portable" version (with scrcpy-server.jar accessible from the same
 # directory as the executable)
 conf.set('PORTABLE', get_option('portable'))

@@ -115,9 +115,6 @@ conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
 # disable console on Windows
 conf.set('WINDOWS_NOCONSOLE', get_option('windows_noconsole'))

-# run a server debugger and wait for a client to be attached
-conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
-
 configure_file(configuration: conf, output: 'config.h')

 src_dir = include_directories('src')
@@ -137,8 +134,6 @@ executable('scrcpy', src,
           c_args: c_args,
           link_args: link_args)

-install_man('scrcpy.1')
-

 ### TESTS

@@ -155,9 +150,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/scrcpy.1
+++ b/app/scrcpy.1
@@ -1,238 +0,0 @@
-.TH "scrcpy" "1"
-.SH NAME
-scrcpy \- Display and control your Android device
-
-
-.SH SYNOPSIS
-.B scrcpy
-.RI [ options ]
-
-
-.SH DESCRIPTION
-.B scrcpy
-provides display and control of Android devices connected on USB (or over TCP/IP). It does not require any root access.
-
-
-.SH OPTIONS
-
-.TP
-.BI "\-b, \-\-bit\-rate " value
-Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
-
-Default is 8000000.
-
-.TP
-.BI "\-c, \-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
-Crop the device screen on the server.
-
-The values are expressed in the device natural orientation (typically, portrait for a phone, landscape for a tablet). Any
-.B \-\-max\-size
-value is computed on the cropped size.
-
-.TP
-.B \-f, \-\-fullscreen
-Start in fullscreen.
-
-.TP
-.BI "\-F, \-\-record\-format " format
-Force recording format (either mp4 or mkv).
-
-.TP
-.B \-h, \-\-help
-Print this help.
-
-.TP
-.BI "\-m, \-\-max\-size " value
-Limit both the width and height of the video to \fIvalue\fR. The other dimension is computed so that the device aspect\-ratio is preserved.
-
-Default is 0 (unlimited).
-
-.TP
-.B \-n, \-\-no\-control
-Disable device control (mirror the device in read\-only).
-
-.TP
-.B \-N, \-\-no\-display
-Do not display device (only when screen recording is enabled).
-
-.TP
-.BI "\-p, \-\-port " port
-Set the TCP port the client listens on.
-
-Default is 27183.
-
-.TP
-.B \-\-prefer\-text
-Inject alpha characters and space as text events instead of key events.
-
-This avoids issues when combining multiple keys to enter special characters,
-but breaks the expected behavior of alpha keys in games (typically WASD).
-
-.TP
-.BI "\-\-push\-target " path
-Set the target directory for pushing files to the device by drag & drop. It is passed as\-is to "adb push".
-
-Default is "/sdcard/".
-
-.TP
-.BI "\-r, \-\-record " file
-Record screen to
-.IR file .
-
-The format is determined by the
-.B \-F/\-\-record\-format
-option if set, or by the file extension (.mp4 or .mkv).
-
-.TP
-.B \-\-render\-expired\-frames
-By default, to minimize latency, scrcpy always renders the last available decoded frame, and drops any previous ones. This flag forces to render all frames, at a cost of a possible increased latency.
-
-.TP
-.BI "\-s, \-\-serial " number
-The device serial number. Mandatory only if several devices are connected to adb.
-
-.TP
-.B \-S, \-\-turn\-screen\-off
-Turn the device screen off immediately.
-
-.TP
-.B \-t, \-\-show\-touches
-Enable "show touches" on start, disable on quit.
-
-It only shows physical touches (not clicks from scrcpy).
-
-.TP
-.B \-T, \-\-always\-on\-top
-Make scrcpy window always on top (above other windows).
-
-.TP
-.B \-v, \-\-version
-Print the version of scrcpy.
-
-.TP
-.BI \-\-window\-title " text
-Set a custom window title.
-
-
-.SH SHORTCUTS
-
-.TP
-.B Ctrl+f
-switch fullscreen mode
-
-.TP
-.B Ctrl+g
-resize window to 1:1 (pixel\-perfect)
-
-.TP
-.B Ctrl+x, Double\-click on black borders
-resize window to remove black borders
-
-.TP
-.B Ctrl+h, Home, Middle\-click
-Click on HOME
-
-.TP
-.B Ctrl+b, Ctrl+Backspace, Right\-click (when screen is on)
-Click on BACK
-
-.TP
-.B Ctrl+s
-Click on APP_SWITCH
-
-.TP
-.B Ctrl+m
-Click on MENU
-
-.TP
-.B Ctrl+Up
-Click on VOLUME_UP
-
-.TP
-.B Ctrl+Down
-Click on VOLUME_DOWN
-
-.TP
-.B Ctrl+p
-Click on POWER (turn screen on/off)
-
-.TP
-.B Right\-click (when screen is off)
-turn screen on
-
-.TP
-.B Ctrl+o
-turn device screen off (keep mirroring)
-
-.TP
-.B Ctrl+n
-expand notification panel
-
-.TP
-.B Ctrl+Shift+n
-collapse notification panel
-
-.TP
-.B Ctrl+c
-copy device clipboard to computer
-
-.TP
-.B Ctrl+v
-paste computer clipboard to device
-
-.TP
-.B Ctrl+Shift+v
-copy computer clipboard to device
-
-.TP
-.B Ctrl+i
-enable/disable FPS counter (print frames/second in logs)
-
-.TP
-.B Drag & drop APK file
-install APK from computer
-
-
-.SH Environment variables
-
-.TP
-.B ADB
-Specify the path to adb.
-
-.TP
-.B SCRCPY_SERVER_PATH
-Specify the path to server binary.
-
-
-.SH AUTHORS
-.B scrcpy
-is written by Romain Vimont.
-
-This manual page was written by
-.MT mmyangfl@gmail.com
-Yangfl
-.ME
-for the Debian Project (and may be used by others).
-
-
-.SH "REPORTING BUGS"
-Report bugs to
-.UR https://github.com/Genymobile/scrcpy/issues
-.UE .
-
-.SH COPYRIGHT
-Copyright \(co 2018 Genymobile
-.UR https://www.genymobile.com
-Genymobile
-.UE
-
-Copyright \(co 2018\-2019
-.MT rom@rom1v.com
-Romain Vimont
-.ME
-
-Licensed under the Apache License, Version 2.0.
-
-.SH WWW
-.UR https://github.com/Genymobile/scrcpy
-.UE
--- a/app/src/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
@@ -33,8 +33,6 @@

 #endif

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

 enum process_result {
--- 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,11 +1,9 @@
-#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

-bool
+static bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
    switch (from) {
        MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
@@ -33,7 +31,8 @@ autocomplete_metastate(enum android_metastate metastate) {
    return metastate;
 }

-enum android_metastate
+
+static enum android_metastate
 convert_meta_state(SDL_Keymod mod) {
    enum android_metastate metastate = 0;
    if (mod & KMOD_LSHIFT) {
@@ -74,9 +73,8 @@ convert_meta_state(SDL_Keymod mod) {
    return autocomplete_metastate(metastate);
 }

-bool
-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
-                bool prefer_text) {
+static bool
+convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod) {
    switch (from) {
        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
@@ -93,12 +91,6 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
    }
-
-    if (prefer_text) {
-        // do not forward alpha and space key events
-        return false;
-    }
-
    if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
        return false;
    }
@@ -135,7 +127,16 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
    }
 }

-enum android_motionevent_buttons
+static bool
+convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
+    switch (from) {
+        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
+        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
+        FAIL;
+    }
+}
+
+static enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state) {
    enum android_motionevent_buttons buttons = 0;
    if (state & SDL_BUTTON_LMASK) {
@@ -147,30 +148,81 @@ convert_mouse_buttons(uint32_t state) {
    if (state & SDL_BUTTON_MMASK) {
        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
    }
-    if (state & SDL_BUTTON_X1MASK) {
+    if (state & SDL_BUTTON_X1) {
        buttons |= AMOTION_EVENT_BUTTON_BACK;
    }
-    if (state & SDL_BUTTON_X2MASK) {
+    if (state & SDL_BUTTON_X2) {
        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
    }
    return buttons;
 }

 bool
-convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
-    switch (from) {
-        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
-        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
-        FAIL;
+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)) {
+        return false;
    }
+
+    uint16_t mod = from->keysym.mod;
+    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod)) {
+        return false;
+    }
+
+    to->inject_keycode.metastate = convert_meta_state(mod);
+
+    return true;
 }

 bool
-convert_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;
+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_mouse_event.action)) {
+        return false;
    }
+
+    to->inject_mouse_event.buttons =
+        convert_mouse_buttons(SDL_BUTTON(from->button));
+    to->inject_mouse_event.position.screen_size = screen_size;
+    to->inject_mouse_event.position.point.x = from->x;
+    to->inject_mouse_event.position.point.y = from->y;
+
+    return true;
+}
+
+bool
+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;
+}
+
+bool
+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;
+
+    to->inject_scroll_event.position = position;
+
+    int mul = from->direction == SDL_MOUSEWHEEL_NORMAL ? 1 : -1;
+    // SDL behavior seems inconsistent between horizontal and vertical scrolling
+    // so reverse the horizontal
+    // <https://wiki.libsdl.org/SDL_MouseWheelEvent#Remarks>
+    to->inject_scroll_event.hscroll = -mul * from->x;
+    to->inject_scroll_event.vscroll = mul * from->y;
+
+    return true;
 }
--- a/app/src/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,29 +0,0 @@
-#ifndef CONVERT_H
-#define CONVERT_H
-
-#include <stdbool.h>
-#include <SDL2/SDL_events.h>
-
-#include "config.h"
-#include "control_msg.h"
-
-bool
-convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to);
-
-enum android_metastate
-convert_meta_state(SDL_Keymod mod);
-
-bool
-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
-                bool prefer_text);
-
-enum android_motionevent_buttons
-convert_mouse_buttons(uint32_t state);
-
-bool
-convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to);
-
-bool
-convert_touch_action(SDL_EventType from, enum android_motionevent_action *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
@@ -3,7 +3,6 @@
 #include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>

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

--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@@ -7,8 +7,6 @@
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>

-#include "config.h"
-
 struct fps_counter {
    SDL_Thread *thread;
    SDL_mutex *mutex;
--- 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,7 +167,7 @@ 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'");
    }
 }

@@ -193,7 +191,7 @@ 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,57 +205,34 @@ 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'");
    }
 }

 void
-input_manager_process_text_input(struct input_manager *im,
+input_manager_process_text_input(struct input_manager *input_manager,
                                 const SDL_TextInputEvent *event) {
-    if (!im->prefer_text) {
-        char c = event->text[0];
-        if (isalpha(c) || c == ' ') {
-            SDL_assert(event->text[1] == '\0');
-            // letters and space are handled as raw key event
-            return;
-        }
+    char c = event->text[0];
+    if (isalpha(c) || c == ' ') {
+        SDL_assert(event->text[1] == '\0');
+        // letters and space are handled as raw key event
+        return;
    }
-
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
    msg.inject_text.text = SDL_strdup(event->text);
    if (!msg.inject_text.text) {
-        LOGW("Could not strdup input text");
+        LOGW("Cannot strdup input text");
        return;
    }
-    if (!controller_push_msg(im->controller, &msg)) {
+    if (!controller_push_msg(input_manager->controller, &msg)) {
        SDL_free(msg.inject_text.text);
-        LOGW("Could not request 'inject text'");
+        LOGW("Cannot request 'inject text'");
    }
 }

-static bool
-convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
-                  bool prefer_text) {
-    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
-
-    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
-        return false;
-    }
-
-    uint16_t mod = from->keysym.mod;
-    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod,
-                         prefer_text)) {
-        return false;
-    }
-
-    to->inject_keycode.metastate = convert_meta_state(mod);
-
-    return true;
-}
-
 void
-input_manager_process_key(struct input_manager *im,
+input_manager_process_key(struct input_manager *input_manager,
                          const SDL_KeyboardEvent *event,
                          bool control) {
    // control: indicates the state of the command-line option --no-control
@@ -267,27 +242,16 @@ input_manager_process_key(struct input_manager *im,
    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 = im->controller;
+    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;
@@ -295,59 +259,63 @@ input_manager_process_key(struct input_manager *im,
        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);
@@ -358,29 +326,29 @@ input_manager_process_key(struct input_manager *im,
                }
                return;
            case SDLK_f:
-                if (!shift && cmd && !repeat && down) {
-                    screen_switch_fullscreen(im->screen);
+                if (ctrl && !meta && !shift && !repeat && down) {
+                    screen_switch_fullscreen(input_manager->screen);
                }
                return;
            case SDLK_x:
-                if (!shift && cmd && !repeat && down) {
-                    screen_resize_to_fit(im->screen);
+                if (ctrl && !meta && !shift && !repeat && down) {
+                    screen_resize_to_fit(input_manager->screen);
                }
                return;
            case SDLK_g:
-                if (!shift && cmd && !repeat && down) {
-                    screen_resize_to_pixel_perfect(im->screen);
+                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 =
-                        im->video_buffer->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 {
@@ -398,129 +366,56 @@ input_manager_process_key(struct input_manager *im,
    }

    struct control_msg msg;
-    if (convert_input_key(event, &msg, im->prefer_text)) {
+    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'");
        }
    }
 }

-static bool
-convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
-                     struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point.x = from->x;
-    to->inject_touch_event.position.point.y = from->y;
-    to->inject_touch_event.pressure = 1.f;
-    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
-
-    return true;
-}
-
 void
-input_manager_process_mouse_motion(struct input_manager *im,
+input_manager_process_mouse_motion(struct input_manager *input_manager,
                                   const SDL_MouseMotionEvent *event) {
    if (!event->state) {
        // do not send motion events when no button is pressed
        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, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject mouse motion event'");
+    if (mouse_motion_from_sdl_to_android(event,
+                                         input_manager->screen->frame_size,
+                                         &msg)) {
+        if (!controller_push_msg(input_manager->controller, &msg)) {
+            LOGW("Cannot request 'inject mouse motion event'");
        }
    }
 }

 static bool
-convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
-              struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-
-    if (!convert_touch_action(from->type, &to->inject_touch_event.action)) {
-        return false;
-    }
-
-    struct size frame_size = screen->frame_size;
-
-    to->inject_touch_event.pointer_id = from->fingerId;
-    to->inject_touch_event.position.screen_size = frame_size;
-    // SDL touch event coordinates are normalized in the range [0; 1]
-    to->inject_touch_event.position.point.x = from->x * frame_size.width;
-    to->inject_touch_event.position.point.y = from->y * frame_size.height;
-    to->inject_touch_event.pressure = from->pressure;
-    to->inject_touch_event.buttons = 0;
-    return true;
-}
-
-void
-input_manager_process_touch(struct input_manager *im,
-                            const SDL_TouchFingerEvent *event) {
-    struct control_msg msg;
-    if (convert_touch(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject touch event'");
-        }
-    }
-}
-
-static bool
-is_outside_device_screen(struct input_manager *im, int x, int y)
+is_outside_device_screen(struct input_manager *input_manager, int x, int y)
 {
-    return x < 0 || x >= im->screen->frame_size.width ||
-           y < 0 || y >= im->screen->frame_size.height;
-}
-
-static bool
-convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
-                     struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-
-    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
-        return false;
-    }
-
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point.x = from->x;
-    to->inject_touch_event.position.point.y = from->y;
-    to->inject_touch_event.pressure = 1.f;
-    to->inject_touch_event.buttons =
-        convert_mouse_buttons(SDL_BUTTON(from->button));
-
-    return true;
+    return x < 0 || x >= input_manager->screen->frame_size.width ||
+           y < 0 || y >= input_manager->screen->frame_size.height;
 }

 void
-input_manager_process_mouse_button(struct input_manager *im,
+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(im->controller);
+            press_back_or_turn_screen_on(input_manager->controller);
            return;
        }
        if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, ACTION_DOWN | ACTION_UP);
+            action_home(input_manager->controller, ACTION_DOWN | ACTION_UP);
            return;
        }
        // double-click on black borders resize to fit the device screen
        if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
            bool outside =
-                is_outside_device_screen(im, event->x, event->y);
+                is_outside_device_screen(input_manager, event->x, event->y);
            if (outside) {
-                screen_resize_to_fit(im->screen);
+                screen_resize_to_fit(input_manager->screen);
                return;
            }
        }
@@ -532,42 +427,26 @@ input_manager_process_mouse_button(struct input_manager *im,
    }

    struct control_msg msg;
-    if (convert_mouse_button(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject mouse button event'");
+    if (mouse_button_from_sdl_to_android(event,
+                                         input_manager->screen->frame_size,
+                                         &msg)) {
+        if (!controller_push_msg(input_manager->controller, &msg)) {
+            LOGW("Cannot request 'inject mouse button event'");
        }
    }
 }

-static bool
-convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
-                    struct control_msg *to) {
-    struct position position = {
-        .screen_size = screen->frame_size,
-        .point = get_mouse_point(screen),
-    };
-
-    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
-
-    to->inject_scroll_event.position = position;
-
-    int mul = from->direction == SDL_MOUSEWHEEL_NORMAL ? 1 : -1;
-    // SDL behavior seems inconsistent between horizontal and vertical scrolling
-    // so reverse the horizontal
-    // <https://wiki.libsdl.org/SDL_MouseWheelEvent#Remarks>
-    to->inject_scroll_event.hscroll = -mul * from->x;
-    to->inject_scroll_event.vscroll = mul * from->y;
-
-    return true;
-}
-
 void
-input_manager_process_mouse_wheel(struct input_manager *im,
+input_manager_process_mouse_wheel(struct input_manager *input_manager,
                                  const SDL_MouseWheelEvent *event) {
+    struct position position = {
+        .screen_size = input_manager->screen->frame_size,
+        .point = get_mouse_point(input_manager->screen),
+    };
    struct control_msg msg;
-    if (convert_mouse_wheel(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject mouse wheel event'");
+    if (mouse_wheel_from_sdl_to_android(event, position, &msg)) {
+        if (!controller_push_msg(input_manager->controller, &msg)) {
+            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"
@@ -14,33 +13,28 @@ struct input_manager {
    struct controller *controller;
    struct video_buffer *video_buffer;
    struct screen *screen;
-    bool prefer_text;
 };

 void
-input_manager_process_text_input(struct input_manager *im,
+input_manager_process_text_input(struct input_manager *input_manager,
                                 const SDL_TextInputEvent *event);

 void
-input_manager_process_key(struct input_manager *im,
+input_manager_process_key(struct input_manager *input_manager,
                          const SDL_KeyboardEvent *event,
                          bool control);

 void
-input_manager_process_mouse_motion(struct input_manager *im,
+input_manager_process_mouse_motion(struct input_manager *input_manager,
                                   const SDL_MouseMotionEvent *event);

 void
-input_manager_process_touch(struct input_manager *im,
-                            const SDL_TouchFingerEvent *event);
-
-void
-input_manager_process_mouse_button(struct input_manager *im,
+input_manager_process_mouse_button(struct input_manager *input_manager,
                                   const SDL_MouseButtonEvent *event,
                                   bool control);

 void
-input_manager_process_mouse_wheel(struct input_manager *im,
+input_manager_process_mouse_wheel(struct input_manager *input_manager,
                                  const SDL_MouseWheelEvent *event);

 #endif
--- a/app/src/lock_util.h
+++ b/app/src/lock_util.h
@@ -4,7 +4,6 @@
 #include <stdint.h>
 #include <SDL2/SDL_mutex.h>

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

 static inline void
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -8,23 +8,31 @@
 #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"

 struct args {
-    struct scrcpy_options opts;
+    const char *serial;
+    const char *crop;
+    const char *record_filename;
+    enum recorder_format record_format;
+    bool fullscreen;
+    bool no_control;
+    bool no_display;
    bool help;
    bool version;
+    bool show_touches;
+    uint16_t port;
+    uint16_t max_size;
+    uint32_t bit_rate;
+    bool always_on_top;
+    bool turn_screen_off;
+    bool render_expired_frames;
 };

 static void usage(const char *arg0) {
-#ifdef __APPLE__
-# define CTRL_OR_CMD "Cmd"
-#else
-# define CTRL_OR_CMD "Ctrl"
-#endif
    fprintf(stderr,
        "Usage: %s [options]\n"
        "\n"
@@ -44,7 +52,7 @@ static void usage(const char *arg0) {
        "    -f, --fullscreen\n"
        "        Start in fullscreen.\n"
        "\n"
-        "    -F, --record-format format\n"
+        "    -F, --record-format\n"
        "        Force recording format (either mp4 or mkv).\n"
        "\n"
        "    -h, --help\n"
@@ -67,18 +75,6 @@ static void usage(const char *arg0) {
        "        Set the TCP port the client listens on.\n"
        "        Default is %d.\n"
        "\n"
-        "    --prefer-text\n"
-        "        Inject alpha characters and space as text events instead of\n"
-        "        key events.\n"
-        "        This avoids issues when combining multiple keys to enter a\n"
-        "        special character, but breaks the expected behavior of alpha\n"
-        "        keys in games (typically WASD).\n"
-        "\n"
-        "    --push-target path\n"
-        "        Set the target directory for pushing files to the device by\n"
-        "        drag & drop. It is passed as-is to \"adb push\".\n"
-        "        Default is \"/sdcard/\".\n"
-        "\n"
        "    -r, --record file.mp4\n"
        "        Record screen to file.\n"
        "        The format is determined by the -F/--record-format option if\n"
@@ -90,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"
@@ -107,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"
@@ -126,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"
@@ -302,65 +295,46 @@ guess_record_format(const char *filename) {
 }

 #define OPT_RENDER_EXPIRED_FRAMES 1000
-#define OPT_WINDOW_TITLE          1001
-#define OPT_PUSH_TARGET           1002
-#define OPT_ALWAYS_ON_TOP         1003
-#define OPT_CROP                  1004
-#define OPT_RECORD_FORMAT         1005
-#define OPT_PREFER_TEXT           1006

 static bool
 parse_args(struct args *args, int argc, char *argv[]) {
    static const struct option long_options[] = {
-        {"always-on-top",         no_argument,       NULL, OPT_ALWAYS_ON_TOP},
+        {"always-on-top",         no_argument,       NULL, 'T'},
        {"bit-rate",              required_argument, NULL, 'b'},
-        {"crop",                  required_argument, NULL, OPT_CROP},
+        {"crop",                  required_argument, NULL, 'c'},
        {"fullscreen",            no_argument,       NULL, 'f'},
        {"help",                  no_argument,       NULL, 'h'},
        {"max-size",              required_argument, NULL, 'm'},
        {"no-control",            no_argument,       NULL, 'n'},
        {"no-display",            no_argument,       NULL, 'N'},
        {"port",                  required_argument, NULL, 'p'},
-        {"push-target",           required_argument, NULL, OPT_PUSH_TARGET},
        {"record",                required_argument, NULL, 'r'},
-        {"record-format",         required_argument, NULL, OPT_RECORD_FORMAT},
+        {"record-format",         required_argument, NULL, 'f'},
        {"render-expired-frames", no_argument,       NULL,
-                                                     OPT_RENDER_EXPIRED_FRAMES},
+                                                 OPT_RENDER_EXPIRED_FRAMES},
        {"serial",                required_argument, NULL, 's'},
        {"show-touches",          no_argument,       NULL, 't'},
        {"turn-screen-off",       no_argument,       NULL, 'S'},
-        {"prefer-text",           no_argument,       NULL, OPT_PREFER_TEXT},
        {"version",               no_argument,       NULL, 'v'},
-        {"window-title",          required_argument, NULL,
-                                                     OPT_WINDOW_TITLE},
        {NULL,                    0,                 NULL, 0  },
    };
-
-    struct scrcpy_options *opts = &args->opts;
-
    int c;
    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTv", long_options,
                            NULL)) != -1) {
        switch (c) {
            case 'b':
-                if (!parse_bit_rate(optarg, &opts->bit_rate)) {
+                if (!parse_bit_rate(optarg, &args->bit_rate)) {
                    return false;
                }
                break;
            case 'c':
-                LOGW("Deprecated option -c. Use --crop instead.");
-                // fall through
-            case OPT_CROP:
-                opts->crop = optarg;
+                args->crop = optarg;
                break;
            case 'f':
-                opts->fullscreen = true;
+                args->fullscreen = true;
                break;
            case 'F':
-                LOGW("Deprecated option -F. Use --record-format instead.");
-                // fall through
-            case OPT_RECORD_FORMAT:
-                if (!parse_record_format(optarg, &opts->record_format)) {
+                if (!parse_record_format(optarg, &args->record_format)) {
                    return false;
                }
                break;
@@ -368,53 +342,41 @@ parse_args(struct args *args, int argc, char *argv[]) {
                args->help = true;
                break;
            case 'm':
-                if (!parse_max_size(optarg, &opts->max_size)) {
+                if (!parse_max_size(optarg, &args->max_size)) {
                    return false;
                }
                break;
            case 'n':
-                opts->control = false;
+                args->no_control = true;
                break;
            case 'N':
-                opts->display = false;
+                args->no_display = true;
                break;
            case 'p':
-                if (!parse_port(optarg, &opts->port)) {
+                if (!parse_port(optarg, &args->port)) {
                    return false;
                }
                break;
            case 'r':
-                opts->record_filename = optarg;
+                args->record_filename = optarg;
                break;
            case 's':
-                opts->serial = optarg;
+                args->serial = optarg;
                break;
            case 'S':
-                opts->turn_screen_off = true;
+                args->turn_screen_off = true;
                break;
            case 't':
-                opts->show_touches = true;
+                args->show_touches = true;
                break;
            case 'T':
-                LOGW("Deprecated option -T. Use --always-on-top instead.");
-                // fall through
-            case OPT_ALWAYS_ON_TOP:
-                opts->always_on_top = true;
+                args->always_on_top = true;
                break;
            case 'v':
                args->version = true;
                break;
            case OPT_RENDER_EXPIRED_FRAMES:
-                opts->render_expired_frames = true;
-                break;
-            case OPT_WINDOW_TITLE:
-                opts->window_title = optarg;
-                break;
-            case OPT_PUSH_TARGET:
-                opts->push_target = optarg;
-                break;
-            case OPT_PREFER_TEXT:
-                opts->prefer_text = true;
+                args->render_expired_frames = true;
                break;
            default:
                // getopt prints the error message on stderr
@@ -422,12 +384,12 @@ parse_args(struct args *args, int argc, char *argv[]) {
        }
    }

-    if (!opts->display && !opts->record_filename) {
+    if (args->no_display && !args->record_filename) {
        LOGE("-N/--no-display requires screen recording (-r/--record)");
        return false;
    }

-    if (!opts->display && opts->fullscreen) {
+    if (args->no_display && args->fullscreen) {
        LOGE("-f/--fullscreen-window is incompatible with -N/--no-display");
        return false;
    }
@@ -438,25 +400,20 @@ parse_args(struct args *args, int argc, char *argv[]) {
        return false;
    }

-    if (opts->record_format && !opts->record_filename) {
+    if (args->record_format && !args->record_filename) {
        LOGE("Record format specified without recording");
        return false;
    }

-    if (opts->record_filename && !opts->record_format) {
-        opts->record_format = guess_record_format(opts->record_filename);
-        if (!opts->record_format) {
+    if (args->record_filename && !args->record_format) {
+        args->record_format = guess_record_format(args->record_filename);
+        if (!args->record_format) {
            LOGE("No format specified for \"%s\" (try with -F mkv)",
-                 opts->record_filename);
+                 args->record_filename);
            return false;
        }
    }

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

@@ -469,11 +426,22 @@ main(int argc, char *argv[]) {
    setbuf(stderr, NULL);
 #endif
    struct args args = {
-        .opts = SCRCPY_OPTIONS_DEFAULT,
+        .serial = NULL,
+        .crop = NULL,
+        .record_filename = NULL,
+        .record_format = 0,
        .help = false,
        .version = false,
+        .show_touches = false,
+        .port = DEFAULT_LOCAL_PORT,
+        .max_size = DEFAULT_MAX_SIZE,
+        .bit_rate = DEFAULT_BIT_RATE,
+        .always_on_top = false,
+        .no_control = false,
+        .no_display = false,
+        .turn_screen_off = false,
+        .render_expired_frames = false,
    };
-
    if (!parse_args(&args, argc, argv)) {
        return 1;
    }
@@ -488,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
@@ -502,7 +468,23 @@ main(int argc, char *argv[]) {
    SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
 #endif

-    int res = scrcpy(&args.opts) ? 0 : 1;
+    struct scrcpy_options options = {
+        .serial = args.serial,
+        .crop = args.crop,
+        .port = args.port,
+        .record_filename = args.record_filename,
+        .record_format = args.record_format,
+        .max_size = args.max_size,
+        .bit_rate = args.bit_rate,
+        .show_touches = args.show_touches,
+        .fullscreen = args.fullscreen,
+        .always_on_top = args.always_on_top,
+        .control = !args.no_control,
+        .display = !args.no_display,
+        .turn_screen_off = args.turn_screen_off,
+        .render_expired_frames = args.render_expired_frames,
+    };
+    int res = scrcpy(&options) ? 0 : 1;

    avformat_network_deinit(); // ignore failure

--- 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);
 }

@@ -135,9 +80,6 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    // <https://github.com/FFmpeg/FFmpeg/commit/0694d8702421e7aff1340038559c438b61bb30dd>
    recorder->ctx->oformat = (AVOutputFormat *) format;

-    av_dict_set(&recorder->ctx->metadata, "comment",
-                "Recorded by scrcpy " SCRCPY_VERSION, 0);
-
    AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
    if (!ostream) {
        avformat_free_context(recorder->ctx);
@@ -174,25 +116,15 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {

 void
 recorder_close(struct recorder *recorder) {
-    if (recorder->header_written) {
-        int ret = av_write_trailer(recorder->ctx);
-        if (ret < 0) {
-            LOGE("Failed to write trailer to %s", recorder->filename);
-            recorder->failed = true;
-        }
-    } else {
-        // the recorded file is empty
-        recorder->failed = true;
+    int ret = av_write_trailer(recorder->ctx);
+    if (ret < 0) {
+        LOGE("Failed to write trailer to %s", recorder->filename);
    }
    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
@@ -201,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;
    }

@@ -219,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;
    }

@@ -234,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,45 +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_AUTO,
-    RECORDER_FORMAT_MP4,
+    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
@@ -58,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"
@@ -42,7 +41,6 @@ static struct input_manager input_manager = {
    .controller = &controller,
    .video_buffer = &video_buffer,
    .screen = &screen,
-    .prefer_text = false, // initialized later
 };

 // init SDL and set appropriate hints
@@ -144,7 +142,12 @@ handle_event(SDL_Event *event, bool control) {
            }
            break;
        case SDL_WINDOWEVENT:
-            screen_handle_window_event(&screen, &event->window);
+            switch (event->window.event) {
+                case SDL_WINDOWEVENT_EXPOSED:
+                case SDL_WINDOWEVENT_SIZE_CHANGED:
+                    screen_render(&screen);
+                    break;
+            }
            break;
        case SDL_TEXTINPUT:
            if (!control) {
@@ -177,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;
@@ -213,7 +211,6 @@ event_loop(bool display, bool control) {
            case EVENT_RESULT_STOPPED_BY_USER:
                return true;
            case EVENT_RESULT_STOPPED_BY_EOS:
-                LOGW("Device disconnected");
                return false;
            case EVENT_RESULT_CONTINUE:
                break;
@@ -262,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
@@ -280,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)) {
@@ -336,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;
@@ -383,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;
        }
@@ -397,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'");
            }
        }

@@ -411,8 +405,6 @@ scrcpy(const struct scrcpy_options *options) {
        show_touches_waited = true;
    }

-    input_manager.prefer_text = options->prefer_text;
-
    ret = event_loop(options->display, options->control);
    LOGD("quit...");

--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@@ -3,17 +3,12 @@

 #include <stdbool.h>
 #include <stdint.h>
-
-#include "config.h"
-#include "input_manager.h"
-#include "recorder.h"
+#include <recorder.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;
@@ -25,29 +20,8 @@ struct scrcpy_options {
    bool display;
    bool turn_screen_off;
    bool render_expired_frames;
-    bool prefer_text;
 };

-#define SCRCPY_OPTIONS_DEFAULT { \
-    .serial = NULL, \
-    .crop = NULL, \
-    .record_filename = NULL, \
-    .window_title = NULL, \
-    .push_target = NULL, \
-    .record_format = RECORDER_FORMAT_AUTO, \
-    .port = DEFAULT_LOCAL_PORT, \
-    .max_size = DEFAULT_LOCAL_PORT, \
-    .bit_rate = DEFAULT_BIT_RATE, \
-    .show_touches = false, \
-    .fullscreen = false, \
-    .always_on_top = false, \
-    .control = true, \
-    .display = true, \
-    .turn_screen_off = false, \
-    .render_expired_frames = false, \
-    .prefer_text = false, \
-}
-
 bool
 scrcpy(const struct scrcpy_options *options);

--- 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"
@@ -16,7 +15,7 @@

 // get the window size in a struct size
 static struct size
-get_window_size(SDL_Window *window) {
+get_native_window_size(SDL_Window *window) {
    int width;
    int height;
    SDL_GetWindowSize(window, &width, &height);
@@ -29,20 +28,11 @@ get_window_size(SDL_Window *window) {

 // get the windowed window size
 static struct size
-get_windowed_window_size(const struct screen *screen) {
-    if (screen->fullscreen || screen->maximized) {
+get_window_size(const struct screen *screen) {
+    if (screen->fullscreen) {
        return screen->windowed_window_size;
    }
-    return get_window_size(screen->window);
-}
-
-// apply the windowed window size if fullscreen and maximized are disabled
-static void
-apply_windowed_size(struct screen *screen) {
-    if (!screen->fullscreen && !screen->maximized) {
-        SDL_SetWindowSize(screen->window, screen->windowed_window_size.width,
-                                          screen->windowed_window_size.height);
-    }
+    return get_native_window_size(screen->window);
 }

 // set the window size to be applied when fullscreen is disabled
@@ -50,8 +40,12 @@ static void
 set_window_size(struct screen *screen, struct size new_size) {
    // setting the window size during fullscreen is implementation defined,
    // so apply the resize only after fullscreen is disabled
-    screen->windowed_window_size = new_size;
-    apply_windowed_size(screen);
+    if (screen->fullscreen) {
+        // SDL_SetWindowSize will be called when fullscreen will be disabled
+        screen->windowed_window_size = new_size;
+    } else {
+        SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
+    }
 }

 // get the preferred display bounds (i.e. the screen bounds with some margins)
@@ -91,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 {
@@ -117,8 +111,8 @@ get_optimal_size(struct size current_size, struct size frame_size) {
 // same as get_optimal_size(), but read the current size from the window
 static inline struct size
 get_optimal_window_size(const struct screen *screen, struct size frame_size) {
-    struct size windowed_size = get_windowed_window_size(screen);
-    return get_optimal_size(windowed_size, frame_size);
+    struct size current_size = get_window_size(screen);
+    return get_optimal_size(current_size, frame_size);
 }

 // initially, there is no current size, so use the frame size as current size
@@ -140,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;

@@ -158,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);
@@ -199,8 +193,6 @@ screen_init_rendering(struct screen *screen, const char *window_title,
        return false;
    }

-    screen->windowed_window_size = window_size;
-
    return true;
 }

@@ -236,11 +228,11 @@ prepare_for_frame(struct screen *screen, struct size new_frame_size) {
        // frame dimension changed, destroy texture
        SDL_DestroyTexture(screen->texture);

-        struct size windowed_size = get_windowed_window_size(screen);
+        struct size current_size = get_window_size(screen);
        struct size target_size = {
-            (uint32_t) windowed_size.width * new_frame_size.width
+            (uint32_t) current_size.width * new_frame_size.width
                    / screen->frame_size.width,
-            (uint32_t) windowed_size.height * new_frame_size.height
+            (uint32_t) current_size.height * new_frame_size.height
                    / screen->frame_size.height,
        };
        target_size = get_optimal_size(target_size, new_frame_size);
@@ -294,6 +286,10 @@ screen_render(struct screen *screen) {

 void
 screen_switch_fullscreen(struct screen *screen) {
+    if (!screen->fullscreen) {
+        // going to fullscreen, store the current windowed window size
+        screen->windowed_window_size = get_native_window_size(screen->window);
+    }
    uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
    if (SDL_SetWindowFullscreen(screen->window, new_mode)) {
        LOGW("Could not switch fullscreen mode: %s", SDL_GetError());
@@ -301,7 +297,11 @@ screen_switch_fullscreen(struct screen *screen) {
    }

    screen->fullscreen = !screen->fullscreen;
-    apply_windowed_size(screen);
+    if (!screen->fullscreen) {
+        // fullscreen disabled, restore expected windowed window size
+        SDL_SetWindowSize(screen->window, screen->windowed_window_size.width,
+                          screen->windowed_window_size.height);
+    }

    LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
    screen_render(screen);
@@ -309,75 +309,20 @@ screen_switch_fullscreen(struct screen *screen) {

 void
 screen_resize_to_fit(struct screen *screen) {
-    if (screen->fullscreen) {
-        return;
+    if (!screen->fullscreen) {
+        struct size optimal_size = get_optimal_window_size(screen,
+                                                           screen->frame_size);
+        SDL_SetWindowSize(screen->window, optimal_size.width,
+                          optimal_size.height);
+        LOGD("Resized to optimal size");
    }
-
-    if (screen->maximized) {
-        SDL_RestoreWindow(screen->window);
-        screen->maximized = false;
-    }
-
-    struct size optimal_size =
-        get_optimal_window_size(screen, screen->frame_size);
-    SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
-    LOGD("Resized to optimal size");
 }

 void
 screen_resize_to_pixel_perfect(struct screen *screen) {
-    if (screen->fullscreen) {
-        return;
-    }
-
-    if (screen->maximized) {
-        SDL_RestoreWindow(screen->window);
-        screen->maximized = false;
-    }
-
-    SDL_SetWindowSize(screen->window, screen->frame_size.width,
-                      screen->frame_size.height);
-    LOGD("Resized to pixel-perfect");
-}
-
-void
-screen_handle_window_event(struct screen *screen,
-                           const SDL_WindowEvent *event) {
-    switch (event->event) {
-        case SDL_WINDOWEVENT_EXPOSED:
-            screen_render(screen);
-            break;
-        case SDL_WINDOWEVENT_SIZE_CHANGED:
-            if (!screen->fullscreen && !screen->maximized) {
-                // Backup the previous size: if we receive the MAXIMIZED event,
-                // then the new size must be ignored (it's the maximized size).
-                // We could not rely on the window flags due to race conditions
-                // (they could be updated asynchronously, at least on X11).
-                screen->windowed_window_size_backup =
-                    screen->windowed_window_size;
-
-                // Save the windowed size, so that it is available once the
-                // window is maximized or fullscreen is enabled.
-                screen->windowed_window_size = get_window_size(screen->window);
-            }
-            screen_render(screen);
-            break;
-        case SDL_WINDOWEVENT_MAXIMIZED:
-            // The backup size must be non-nul.
-            SDL_assert(screen->windowed_window_size_backup.width);
-            SDL_assert(screen->windowed_window_size_backup.height);
-            // Revert the last size, it was updated while screen was maximized.
-            screen->windowed_window_size = screen->windowed_window_size_backup;
-#ifdef DEBUG
-            // Reset the backup to invalid values to detect unexpected usage
-            screen->windowed_window_size_backup.width = 0;
-            screen->windowed_window_size_backup.height = 0;
-#endif
-            screen->maximized = true;
-            break;
-        case SDL_WINDOWEVENT_RESTORED:
-            screen->maximized = false;
-            apply_windowed_size(screen);
-            break;
+    if (!screen->fullscreen) {
+        SDL_SetWindowSize(screen->window, screen->frame_size.width,
+                          screen->frame_size.height);
+        LOGD("Resized to pixel-perfect");
    }
 }
--- 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;
@@ -15,37 +14,28 @@ struct screen {
    SDL_Renderer *renderer;
    SDL_Texture *texture;
    struct size frame_size;
-    // The window size the last time it was not maximized or fullscreen.
+    //used only in fullscreen mode to know the windowed window size
    struct size windowed_window_size;
-    // Since we receive the event SIZE_CHANGED before MAXIMIZED, we must be
-    // able to revert the size to its non-maximized value.
-    struct size windowed_window_size_backup;
    bool has_frame;
    bool fullscreen;
-    bool maximized;
    bool no_window;
 };

-#define SCREEN_INITIALIZER { \
-    .window = NULL, \
-    .renderer = NULL, \
-    .texture = NULL, \
-    .frame_size = { \
-        .width = 0,  \
-        .height = 0, \
-    }, \
+#define SCREEN_INITIALIZER {  \
+    .window = NULL,           \
+    .renderer = NULL,         \
+    .texture = NULL,          \
+    .frame_size = {           \
+        .width = 0,           \
+        .height = 0,          \
+    },                        \
    .windowed_window_size = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
-    .windowed_window_size_backup = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
-    .has_frame = false, \
-    .fullscreen = false, \
-    .maximized = false, \
-    .no_window = false, \
+        .width = 0,           \
+        .height = 0,          \
+    },                        \
+    .has_frame = false,   \
+    .fullscreen = false,  \
+    .no_window = false,   \
 }

 // initialize default values
@@ -54,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
@@ -85,8 +75,4 @@ screen_resize_to_fit(struct screen *screen);
 void
 screen_resize_to_pixel_perfect(struct screen *screen);

-// react to window events
-void
-screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);
-
 #endif
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -13,9 +13,9 @@
 #include "net.h"

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

-#define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FILENAME
+#define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FLENAME
 #define DEVICE_SERVER_PATH "/data/local/tmp/" SERVER_FILENAME

 static const char *
@@ -32,10 +32,10 @@ get_server_path(void) {
    // the absolute path is hardcoded
    return DEFAULT_SERVER_PATH;
 #else
-    // use scrcpy-server in the same directory as the executable
+    // 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, "
+        LOGE("Cannot get executable path, "
             "using " SERVER_FILENAME " from current directory");
        // not found, use current directory
        return SERVER_FILENAME;
@@ -47,7 +47,7 @@ get_server_path(void) {
    size_t len = dirlen + 1 + sizeof(SERVER_FILENAME);
    char *server_path = SDL_malloc(len);
    if (!server_path) {
-        LOGE("Could not alloc server path string, "
+        LOGE("Cannot alloc server path string, "
             "using " SERVER_FILENAME " from current directory");
        SDL_free(executable_path);
        return SERVER_FILENAME;
@@ -124,31 +124,15 @@ execute_server(struct server *server, const struct server_params *params) {
        "shell",
        "CLASSPATH=/data/local/tmp/" SERVER_FILENAME,
        "app_process",
-#ifdef SERVER_DEBUGGER
-# define SERVER_DEBUGGER_PORT "5005"
-        "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
-            SERVER_DEBUGGER_PORT,
-#endif
        "/", // unused
        "com.genymobile.scrcpy.Server",
        max_size_string,
        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",
    };
-#ifdef SERVER_DEBUGGER
-    LOGI("Server debugger waiting for a client on device port "
-         SERVER_DEBUGGER_PORT "...");
-    // From the computer, run
-    //     adb forward tcp:5005 tcp:5005
-    // Then, from Android Studio: Run > Debug > Edit configurations...
-    // On the left, click on '+', "Remote", with:
-    //     Host: localhost
-    //     Port: 5005
-    // Then click on "Debug"
-#endif
    return adb_execute(server->serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
 }

@@ -171,7 +155,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;
@@ -198,7 +181,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;
@@ -322,7 +305,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;
--- 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
--- 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
@@ -7,8 +7,6 @@

 #include "command.h"

-#include "config.h"
-
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
@@ -96,7 +94,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);
@@ -109,8 +107,6 @@ cmd_simple_wait(pid_t pid, int *exit_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) {
@@ -119,10 +115,4 @@ get_executable_path(void) {
    }
    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) {
--- 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.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,8 +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 from the same directory as the scrcpy executable')
+option('portable', type: 'boolean', description: 'Use scrcpy-server.jar from the same directory as the scrcpy executable')
+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')
-option('server_debugger', type: 'boolean', value: false, description: 'Run a server debugger and wait for a client to be attached')
--- 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/release.sh
+++ b/release.sh
@@ -23,21 +23,21 @@ cd -
 make -f Makefile.CrossWindows

 # the generated server must be the same everywhere
-cmp "$BUILDDIR/server/scrcpy-server" dist/scrcpy-win32/scrcpy-server
-cmp "$BUILDDIR/server/scrcpy-server" dist/scrcpy-win64/scrcpy-server
+cmp "$BUILDDIR/server/scrcpy-server.jar" dist/scrcpy-win32/scrcpy-server.jar
+cmp "$BUILDDIR/server/scrcpy-server.jar" dist/scrcpy-win64/scrcpy-server.jar

 # get version name
 TAG=$(git describe --tags --always)

 # create release directory
 mkdir -p "release-$TAG"
-cp "$BUILDDIR/server/scrcpy-server" "release-$TAG/scrcpy-server-$TAG"
+cp "$BUILDDIR/server/scrcpy-server.jar" "release-$TAG/scrcpy-server-$TAG.jar"
 cp "dist/scrcpy-win32-$TAG.zip" "release-$TAG/"
 cp "dist/scrcpy-win64-$TAG.zip" "release-$TAG/"

 # generate checksums
 cd "release-$TAG"
-sha256sum "scrcpy-server-$TAG" \
+sha256sum "scrcpy-server-$TAG.jar" \
          "scrcpy-win32-$TAG.zip" \
          "scrcpy-win64-$TAG.zip" > SHA256SUMS.txt

--- a/2
+++ b/2
@@ -20,4 +20,4 @@ then
    exit 1
 fi

-SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server" "$BUILDDIR/app/scrcpy" "$@"
+SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server.jar" "$BUILDDIR/app/scrcpy" "$@"
--- a/scripts/run-scrcpy.sh
+++ b/scripts/run-scrcpy.sh
@@ -1,2 +1,2 @@
 #!/bin/bash
-SCRCPY_SERVER_PATH="$MESON_BUILD_ROOT/server/scrcpy-server" "$MESON_BUILD_ROOT/app/scrcpy"
+SCRCPY_SERVER_PATH="$MESON_BUILD_ROOT/server/scrcpy-server.jar" "$MESON_BUILD_ROOT/app/scrcpy"
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -1,13 +1,13 @@
 apply plugin: 'com.android.application'

 android {
-    compileSdkVersion 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/build_without_gradle.sh
+++ b/server/build_without_gradle.sh
@@ -1,62 +0,0 @@
-#!/bin/bash
-#
-# This script generates the scrcpy binary "manually" (without gradle).
-#
-# Adapt Android platform and build tools versions (via ANDROID_PLATFORM and
-# ANDROID_BUILD_TOOLS environment variables).
-#
-# Then execute:
-#
-#     BUILD_DIR=my_build_dir ./build_without_gradle.sh
-
-set -e
-
-PLATFORM=${ANDROID_PLATFORM:-29}
-BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-29.0.2}
-
-BUILD_DIR="$(realpath ${BUILD_DIR:-build_manual})"
-CLASSES_DIR="$BUILD_DIR/classes"
-SERVER_DIR=$(dirname "$0")
-SERVER_BINARY=scrcpy-server
-
-echo "Platform: android-$PLATFORM"
-echo "Build-tools: $BUILD_TOOLS"
-echo "Build dir: $BUILD_DIR"
-
-rm -rf "$CLASSES_DIR" "$BUILD_DIR/$SERVER_BINARY" classes.dex
-mkdir -p "$CLASSES_DIR/com/genymobile/scrcpy"
-
-<< EOF cat > "$CLASSES_DIR/com/genymobile/scrcpy/BuildConfig.java"
-package com.genymobile.scrcpy;
-
-public final class BuildConfig {
-  public static final boolean DEBUG = false;
-}
-EOF
-
-echo "Generating java from aidl..."
-cd "$SERVER_DIR/src/main/aidl"
-"$ANDROID_HOME/build-tools/$BUILD_TOOLS/aidl" -o "$CLASSES_DIR" \
-    android/view/IRotationWatcher.aidl
-
-echo "Compiling java sources..."
-cd ../java
-javac -bootclasspath "$ANDROID_HOME/platforms/android-$PLATFORM/android.jar" \
-    -cp "$CLASSES_DIR" -d "$CLASSES_DIR" -source 1.8 -target 1.8 \
-    com/genymobile/scrcpy/*.java \
-    com/genymobile/scrcpy/wrappers/*.java
-
-echo "Dexing..."
-cd "$CLASSES_DIR"
-"$ANDROID_HOME/build-tools/$BUILD_TOOLS/dx" --dex \
-    --output "$BUILD_DIR/classes.dex" \
-    android/view/*.class \
-    com/genymobile/scrcpy/*.class \
-    com/genymobile/scrcpy/wrappers/*.class
-
-echo "Archiving..."
-cd "$BUILD_DIR"
-jar cvf "$SERVER_BINARY" classes.dex
-rm -rf classes.dex classes
-
-echo "Server generated in $BUILD_DIR/$SERVER_BINARY"
--- a/server/meson.build
+++ b/server/meson.build
@@ -4,9 +4,8 @@ prebuilt_server = get_option('prebuilt_server')
 if prebuilt_server == ''
    custom_target('scrcpy-server',
                  build_always: true,  # gradle is responsible for tracking source changes
-                  output: 'scrcpy-server',
+                  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
@@ -16,7 +15,7 @@ else
    endif
    custom_target('scrcpy-server-prebuilt',
                  input: prebuilt_server,
-                  output: 'scrcpy-server',
+                  output: 'scrcpy-server.jar',
                  command: ['cp', '@INPUT@', '@OUTPUT@'],
                  install: true,
                  install_dir: 'share/scrcpy')
--- a/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(), msg.getButtons());
+            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, buttons, 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/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/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@@ -7,7 +7,6 @@ import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaFormat;
 import android.os.IBinder;
-import android.os.Looper;
 import android.view.Surface;

 import java.io.FileDescriptor;
@@ -55,16 +54,6 @@ public class ScreenEncoder implements Device.RotationListener {
    }

    public void streamScreen(Device device, FileDescriptor fd) throws IOException {
-        // Some devices internally create a Handler when creating an input Surface, causing an exception:
-        //   "Can't create handler inside thread that has not called Looper.prepare()"
-        // <https://github.com/Genymobile/scrcpy/issues/240>
-        //
-        // Use Looper.prepareMainLooper() instead of Looper.prepare() to avoid a NullPointerException:
-        //   "Attempt to read from field 'android.os.MessageQueue android.os.Looper.mQueue'
-        //    on a null object reference"
-        // <https://github.com/Genymobile/scrcpy/issues/921>
-        Looper.prepareMainLooper();
-
        MediaFormat format = createFormat(bitRate, frameRate, iFrameInterval);
        device.setRotationListener(this);
        boolean alive;
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@@ -7,7 +7,7 @@ import java.io.IOException;

 public final class Server {

-    private static final String SERVER_PATH = "/data/local/tmp/scrcpy-server";
+    private static final String SERVER_PATH = "/data/local/tmp/scrcpy-server.jar";

    private Server() {
        // not instantiable
@@ -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);
Author	SHA1	Message	Date
Romain Vimont	6eabe5a8bc	Improve portable builds In portable builds, scrcpy-server.jar was supposed to be present in the current directory, so in practice it worked only if scrcpy was launched from its own directory. Instead, find the absolute path of the executable and build a suitable path to use scrcpy-server.jar from the same directory.	2019-06-10 16:08:00 +02:00
Romain Vimont	9988d6186e	Add functions to convert wide char to UTF-8 There was already utf8_to_wide_char(), used to correctly execute commands on Windows. Add the reverse converter: utf8_from_wide_char(). We will need it to build the scrcpy-server path based on the executable directory.	2019-06-10 16:06:32 +02:00
Romain Vimont	451f3ed309	Extract "scrcpy-server.jar" string The filename is used at several places.	2019-06-10 16:06:32 +02:00
Romain Vimont	5142e0e621	Simplify portable build configuration To create a portable build (with scrcpy-server.jar accessible from the scrcpy directory), replace OVERRIDE_SERVER_PATH by a simple compilation flag: PORTABLE. This paves the way to use more complex rules to determine the path of scrcpy-server.jar in portable builds.	2019-06-10 16:02:57 +02:00
Romain Vimont	e9bacc196a	Simplify scrcpy-server path configuration The full path of scrcpy-server.jar was partially configured from meson.build then concatenated by C code. Instead, directly write the path in C.	2019-06-10 15:52:54 +02:00