Use Cmd instead of Ctrl on macOS when possible

Fixes <https://github.com/Genymobile/scrcpy/issues/642>
Log recording failure
2019-08-01 21:29:07 +02:00 · 2019-07-31 11:04:38 +02:00 · 2019-07-31 01:55:43 +02:00 · 2019-07-31 01:55:40 +02:00 · 2019-07-31 01:55:32 +02:00 · 2019-07-31 01:53:16 +02:00
39 changed files with 889 additions and 461 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 (`android-adb-tools`).
+tools][platform-tools], or packaged in your distribution (`adb`).

 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 make gcc pkg-config meson ninja-build \
+sudo apt install make gcc git 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
+sudo dnf install java-devel
 ```


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

 ## Prebuilt server

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

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

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

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

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

 [hidden]: https://stackoverflow.com/a/31908373/1987178
-[wrappers]: https://github.com/Genymobile/scrcpy/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
+[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


 ### Threading

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

 - the **main** thread, encoding and streaming the video to the client;
- - 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_
+ - 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_
   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/v1.8/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/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/v1.8/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L69-L70
+[surface]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L68-L69

 On device [rotation], the codec, surface and display are reinitialized, and a
 new video stream is produced.
@ -108,31 +108,30 @@ 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/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
+[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
 [repeat-flag]: https://developer.android.com/reference/android/media/MediaFormat.html#KEY_REPEAT_PREVIOUS_FRAME_AFTER


 ### Input events injection

-_Control events_ are received from the client by the [`EventController`] (run in
-a separate thread). There are several types of input events:
+_Control messages_ are received from the client by the [`Controller`] (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).

-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
+Some of them 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]).

-[`EventController`]: https://github.com/Genymobile/scrcpy/blob/v1.8/server/src/main/java/com/genymobile/scrcpy/EventController.java#L66
+[`Controller`]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/Controller.java#L81
 [`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/v1.8/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27
+[inject-wrapper]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27



@ -188,12 +187,13 @@ 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 events_ to the server.
+ - the **controller** thread, sending _control messages_ to the server,
 - the **receiver** thread (managed by the controller), receiving _device
-   events_ from the client.
+   messages_ from the client.

 In addition, another thread can be started if necessary to handle APK
-installation or file push requests (via drag&drop on the main window).
+installation or file push requests (via drag&drop on the main window) or to
+print the framerate regularly in the console.



@ -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/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
+[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

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

 ### Controller

-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.
+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.

 On SDL event, received on the main thread, the [input manager][inputmanager]
-creates appropriate [_control events_][controlevent]. It is responsible to
+creates appropriate [_control messages_][controlmsg]. It is responsible to
 convert SDL events to Android events (using [convert]). It pushes the _control
-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.
+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.

-[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
+[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


 ### UI and event loop
@ -257,10 +257,9 @@ 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/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
+[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


 ## Hack
--- a/FAQ.md
+++ b/FAQ.md
@ -19,10 +19,6 @@ 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].
-
-[issue 9]: https://github.com/Genymobile/scrcpy/issues/9
-

 ### Mouse clicks do not work

--- a/1
+++ b/1
@ -188,6 +188,7 @@
      identification within third-party archives.

   Copyright (C) 2018 Genymobile
+   Copyright (C) 2018-2019 Romain Vimont

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
--- a/Makefile.CrossWindows
+++ b/Makefile.CrossWindows
@ -44,7 +44,7 @@ clean:
 build-server:
 	[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
 		meson "$(SERVER_BUILD_DIR)" \
-			--buildtype release -Dbuild_app=false )
+			--buildtype release -Dcompile_app=false )
 		ninja -C "$(SERVER_BUILD_DIR)"

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

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

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

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

 dist-win32: build-server build-win32 build-win32-noconsole
@ -100,28 +100,29 @@ dist-win32: build-server build-win32 build-win32-noconsole
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.1-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/ffmpeg-4.1.3-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.3-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.3-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1.3-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.9/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.8/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"

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

 zip-win32: dist-win32
 	cd "$(DIST)"; \
--- a/README.md
+++ b/README.md
@ -1,15 +1,15 @@
-# scrcpy (v1.8)
+# scrcpy (v1.9)

 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)


 ## Requirements

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

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

@ -29,6 +29,12 @@ 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
@ -45,18 +51,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.8.zip`][direct-win32]  
-   _(SHA-256: c0c29ed1c66deaa73bdadacd09e598aafb3a117929cf7a314cce1cc45e34de53)_
- - [`scrcpy-win64-v1.8.zip`][direct-win64]  
-   _(SHA-256: 9cc980d07bd8f036ae4e91d0bc6fc3281d7fa8f9752d4913b643c0fb72a19fb7)_
+ - [`scrcpy-win32-v1.9.zip`][direct-win32]  
+   _(SHA-256: 3234f7fbcc26b9e399f50b5ca9ed085708954c87fda1b0dd32719d6e7dd861ef)_
+ - [`scrcpy-win64-v1.9.zip`][direct-win64]  
+   _(SHA-256: 0088eca1811ea7c7ac350d636c8465b266e6c830bb268770ff88fddbb493077e)_

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

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


-### Mac OS
+### macOS

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

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

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

-To limit both width and height to some value (e.g. 1024):
+To limit both the 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 8Mbps. To change the video bitrate (e.g. to 2Mbps):
+The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):

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

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

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

 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
@ -245,6 +251,11 @@ _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

@ -283,42 +294,47 @@ 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_.
+Audio is not forwarded by _scrcpy_. Use [USBaudio] (Linux-only).

-There is a limited solution using [AOA], implemented in the [`audio`] branch. If
-you are interested, see [issue 14].
+Also see [issue #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
+[USBaudio]: https://github.com/rom1v/usbaudio
+[issue #14]: https://github.com/Genymobile/scrcpy/issues/14


 ## Shortcuts

- | 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`                    |
+ | 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`

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

    ADB=/path/to/adb scrcpy

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

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

@ -369,6 +385,7 @@ 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
@ -93,21 +93,9 @@ conf.set_quoted('SCRCPY_VERSION', meson.project_version())
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))

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

 # the default client TCP port for the "adb reverse" tunnel
 # overridden by option --port
--- a/app/src/command.h
+++ b/app/src/command.h
@ -9,6 +9,7 @@
 // not needed here, but winsock2.h must never be included AFTER windows.h
 # include <winsock2.h>
 # include <windows.h>
+# define PATH_SEPARATOR '\\'
 # define PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
 # ifdef _WIN64
@ -23,6 +24,7 @@
 #else

 # include <sys/types.h>
+# define PATH_SEPARATOR '/'
 # define PRIsizet "zu"
 # define PRIexitcode "d"
 # define PROCESS_NONE -1
@ -76,4 +78,9 @@ adb_install(const char *serial, const char *local);
 bool
 process_check_success(process_t proc, const char *name);

+// return the absolute path of the executable (the scrcpy binary)
+// may be NULL on error; to be freed by SDL_free
+char *
+get_executable_path(void);
+
 #endif
--- a/app/src/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("Cannot write msg to socket");
+            LOGD("Could not write msg to socket");
            break;
        }
    }
--- a/app/src/device.h
+++ b/app/src/device.h
@ -7,7 +7,6 @@
 #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/file_handler.c
+++ b/app/src/file_handler.c
@ -5,17 +5,19 @@

 #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) {
+file_handler_init(struct file_handler *file_handler, const char *serial,
+                  const char *push_target) {

    cbuf_init(&file_handler->queue);

@ -31,7 +33,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("Cannot strdup serial");
+            LOGW("Could not strdup serial");
            SDL_DestroyCond(file_handler->event_cond);
            SDL_DestroyMutex(file_handler->mutex);
            return false;
@ -46,6 +48,8 @@ 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;
 }

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

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

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

@ -169,7 +176,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("Cannot terminate install process");
+            LOGW("Could not 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
@ -22,6 +22,7 @@ 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;
@ -32,7 +33,8 @@ struct file_handler {
 };

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

 void
 file_handler_destroy(struct file_handler *file_handler);
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -47,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("Cannot request 'inject %s (DOWN)'", name);
+            LOGW("Could not request 'inject %s (DOWN)'", name);
            return;
        }
    }
@ -55,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("Cannot request 'inject %s (UP)'", name);
+            LOGW("Could not request 'inject %s (UP)'", name);
        }
    }
 }
@ -102,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("Cannot request 'turn screen on'");
+        LOGW("Could not request 'turn screen on'");
    }
 }

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

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

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

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

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

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

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

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

@ -167,7 +167,7 @@ set_screen_power_mode(struct controller *controller,
    msg.set_screen_power_mode.mode = mode;

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

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

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

@ -242,16 +242,27 @@ input_manager_process_key(struct input_manager *input_manager,
    bool alt = event->keysym.mod & (KMOD_LALT | KMOD_RALT);
    bool meta = event->keysym.mod & (KMOD_LGUI | KMOD_RGUI);

+    // use Cmd on macOS, Ctrl on other platforms
+#ifdef __APPLE__
+    bool cmd = !ctrl && meta;
+#else
+    if (meta) {
+        // no shortcuts involve Meta on platforms other than macOS, and it must
+        // not be forwarded to the device
+        return;
+    }
+    bool cmd = ctrl; // && !meta, already guaranteed
+#endif
+
    if (alt) {
-        // no shortcut involves Alt or Meta, and they should not be forwarded
-        // to the device
+        // no shortcuts involve Alt, and it must not be forwarded to the device
        return;
    }

    struct controller *controller = input_manager->controller;

    // capture all Ctrl events
-    if (ctrl | meta) {
+    if (ctrl || cmd) {
        SDL_Keycode keycode = event->keysym.sym;
        bool down = event->type == SDL_KEYDOWN;
        int action = down ? ACTION_DOWN : ACTION_UP;
@ -259,63 +270,59 @@ input_manager_process_key(struct input_manager *input_manager,
        bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
        switch (keycode) {
            case SDLK_h:
+                // Ctrl+h on all platform, since Cmd+h is already captured by
+                // the system on macOS to hide the window
                if (control && ctrl && !meta && !shift && !repeat) {
                    action_home(controller, action);
                }
                return;
            case SDLK_b: // fall-through
            case SDLK_BACKSPACE:
-                if (control && ctrl && !meta && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_back(controller, action);
                }
                return;
            case SDLK_s:
-                if (control && ctrl && !meta && !shift && !repeat) {
+                if (control && cmd && !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 && ctrl && !meta && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_power(controller, action);
                }
                return;
            case SDLK_o:
-                if (control && ctrl && !shift && !meta && down) {
+                if (control && cmd && !shift && down) {
                    set_screen_power_mode(controller, SCREEN_POWER_MODE_OFF);
                }
                return;
            case SDLK_DOWN:
-#ifdef __APPLE__
-                if (control && !ctrl && meta && !shift) {
-#else
-                if (control && ctrl && !meta && !shift) {
-#endif
+                if (control && cmd && !shift) {
                    // forward repeated events
                    action_volume_down(controller, action);
                }
                return;
            case SDLK_UP:
-#ifdef __APPLE__
-                if (control && !ctrl && meta && !shift) {
-#else
-                if (control && ctrl && !meta && !shift) {
-#endif
+                if (control && cmd && !shift) {
                    // forward repeated events
                    action_volume_up(controller, action);
                }
                return;
            case SDLK_c:
-                if (control && ctrl && !meta && !shift && !repeat && down) {
+                if (control && cmd && !shift && !repeat && down) {
                    request_device_clipboard(controller);
                }
                return;
            case SDLK_v:
-                if (control && ctrl && !meta && !repeat && down) {
+                if (control && cmd && !repeat && down) {
                    if (shift) {
                        // store the text in the device clipboard
                        set_device_clipboard(controller);
@ -326,29 +333,29 @@ input_manager_process_key(struct input_manager *input_manager,
                }
                return;
            case SDLK_f:
-                if (ctrl && !meta && !shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    screen_switch_fullscreen(input_manager->screen);
                }
                return;
            case SDLK_x:
-                if (ctrl && !meta && !shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    screen_resize_to_fit(input_manager->screen);
                }
                return;
            case SDLK_g:
-                if (ctrl && !meta && !shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    screen_resize_to_pixel_perfect(input_manager->screen);
                }
                return;
            case SDLK_i:
-                if (ctrl && !meta && !shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    struct fps_counter *fps_counter =
                        input_manager->video_buffer->fps_counter;
                    switch_fps_counter_state(fps_counter);
                }
                return;
            case SDLK_n:
-                if (control && ctrl && !meta && !repeat && down) {
+                if (control && cmd && !repeat && down) {
                    if (shift) {
                        collapse_notification_panel(controller);
                    } else {
@ -368,7 +375,7 @@ input_manager_process_key(struct input_manager *input_manager,
    struct control_msg msg;
    if (input_key_from_sdl_to_android(event, &msg)) {
        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Cannot request 'inject keycode'");
+            LOGW("Could not request 'inject keycode'");
        }
    }
 }
@ -385,7 +392,7 @@ input_manager_process_mouse_motion(struct input_manager *input_manager,
                                         input_manager->screen->frame_size,
                                         &msg)) {
        if (!controller_push_msg(input_manager->controller, &msg)) {
-            LOGW("Cannot request 'inject mouse motion event'");
+            LOGW("Could not request 'inject mouse motion event'");
        }
    }
 }
@ -431,7 +438,7 @@ input_manager_process_mouse_button(struct input_manager *input_manager,
                                         input_manager->screen->frame_size,
                                         &msg)) {
        if (!controller_push_msg(input_manager->controller, &msg)) {
-            LOGW("Cannot request 'inject mouse button event'");
+            LOGW("Could not request 'inject mouse button event'");
        }
    }
 }
@ -446,7 +453,7 @@ input_manager_process_mouse_wheel(struct input_manager *input_manager,
    struct control_msg msg;
    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'");
+            LOGW("Could not request 'inject mouse wheel event'");
        }
    }
 }
--- a/app/src/main.c
+++ b/app/src/main.c
@ -17,6 +17,8 @@ struct args {
    const char *serial;
    const char *crop;
    const char *record_filename;
+    const char *window_title;
+    const char *push_target;
    enum recorder_format record_format;
    bool fullscreen;
    bool no_control;
@ -33,6 +35,11 @@ struct args {
 };

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

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

 static bool
 parse_args(struct args *args, int argc, char *argv[]) {
@ -308,6 +325,8 @@ parse_args(struct args *args, int argc, char *argv[]) {
        {"no-control",            no_argument,       NULL, 'n'},
        {"no-display",            no_argument,       NULL, 'N'},
        {"port",                  required_argument, NULL, 'p'},
+        {"push-target",           required_argument, NULL,
+                                                 OPT_PUSH_TARGET},
        {"record",                required_argument, NULL, 'r'},
        {"record-format",         required_argument, NULL, 'f'},
        {"render-expired-frames", no_argument,       NULL,
@ -316,6 +335,8 @@ parse_args(struct args *args, int argc, char *argv[]) {
        {"show-touches",          no_argument,       NULL, 't'},
        {"turn-screen-off",       no_argument,       NULL, 'S'},
        {"version",               no_argument,       NULL, 'v'},
+        {"window-title",          required_argument, NULL,
+                                                 OPT_WINDOW_TITLE},
        {NULL,                    0,                 NULL, 0  },
    };
    int c;
@ -378,6 +399,12 @@ parse_args(struct args *args, int argc, char *argv[]) {
            case OPT_RENDER_EXPIRED_FRAMES:
                args->render_expired_frames = true;
                break;
+            case OPT_WINDOW_TITLE:
+                args->window_title = optarg;
+                break;
+            case OPT_PUSH_TARGET:
+                args->push_target = optarg;
+                break;
            default:
                // getopt prints the error message on stderr
                return false;
@ -414,6 +441,11 @@ parse_args(struct args *args, int argc, char *argv[]) {
        }
    }

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

@ -429,6 +461,8 @@ main(int argc, char *argv[]) {
        .serial = NULL,
        .crop = NULL,
        .record_filename = NULL,
+        .window_title = NULL,
+        .push_target = NULL,
        .record_format = 0,
        .help = false,
        .version = false,
@ -456,6 +490,8 @@ 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
@ -473,6 +509,8 @@ main(int argc, char *argv[]) {
        .crop = args.crop,
        .port = args.port,
        .record_filename = args.record_filename,
+        .window_title = args.window_title,
+        .push_target = args.push_target,
        .record_format = args.record_format,
        .max_size = args.max_size,
        .bit_rate = args.bit_rate,
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@ -5,6 +5,7 @@

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

 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
@ -26,6 +27,82 @@ 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;
+    }
+    if (av_packet_ref(&rec->packet, packet)) {
+        SDL_free(rec);
+        return NULL;
+    }
+    rec->next = NULL;
+    return rec;
+}
+
+static void
+record_packet_delete(struct record_packet *rec) {
+    av_packet_unref(&rec->packet);
+    SDL_free(rec);
+}
+
+static void
+recorder_queue_init(struct recorder_queue *queue) {
+    queue->first = NULL;
+    // queue->last is undefined if queue->first == NULL
+}
+
+static inline bool
+recorder_queue_is_empty(struct recorder_queue *queue) {
+    return !queue->first;
+}
+
+static bool
+recorder_queue_push(struct recorder_queue *queue, const AVPacket *packet) {
+    struct record_packet *rec = record_packet_new(packet);
+    if (!rec) {
+        LOGC("Could not allocate record packet");
+        return false;
+    }
+    rec->next = NULL;
+
+    if (recorder_queue_is_empty(queue)) {
+        queue->first = queue->last = rec;
+    } else {
+        // chain rec after the (current) last packet
+        queue->last->next = rec;
+        // the last packet is now rec
+        queue->last = rec;
+    }
+    return true;
+}
+
+static inline struct record_packet *
+recorder_queue_take(struct recorder_queue *queue) {
+    SDL_assert(!recorder_queue_is_empty(queue));
+
+    struct record_packet *rec = queue->first;
+    SDL_assert(rec);
+
+    queue->first = rec->next;
+    // no need to update queue->last if the queue is left empty:
+    // queue->last is undefined if queue->first == NULL
+
+    return rec;
+}
+
+static void
+recorder_queue_clear(struct recorder_queue *queue) {
+    struct record_packet *rec = queue->first;
+    while (rec) {
+        struct record_packet *current = rec;
+        rec = rec->next;
+        record_packet_delete(current);
+    }
+    queue->first = NULL;
+}
+
 bool
 recorder_init(struct recorder *recorder,
              const char *filename,
@ -33,10 +110,28 @@ recorder_init(struct recorder *recorder,
              struct size declared_frame_size) {
    recorder->filename = SDL_strdup(filename);
    if (!recorder->filename) {
-        LOGE("Cannot strdup filename");
+        LOGE("Could not strdup filename");
        return false;
    }

+    recorder->mutex = SDL_CreateMutex();
+    if (!recorder->mutex) {
+        LOGC("Could not create mutex");
+        SDL_free(recorder->filename);
+        return false;
+    }
+
+    recorder->queue_cond = SDL_CreateCond();
+    if (!recorder->queue_cond) {
+        LOGC("Could not create cond");
+        SDL_DestroyMutex(recorder->mutex);
+        SDL_free(recorder->filename);
+        return false;
+    }
+
+    recorder_queue_init(&recorder->queue);
+    recorder->stopped = false;
+    recorder->failed = false;
    recorder->format = format;
    recorder->declared_frame_size = declared_frame_size;
    recorder->header_written = false;
@ -46,6 +141,8 @@ recorder_init(struct recorder *recorder,

 void
 recorder_destroy(struct recorder *recorder) {
+    SDL_DestroyCond(recorder->queue_cond);
+    SDL_DestroyMutex(recorder->mutex);
    SDL_free(recorder->filename);
 }

@ -119,12 +216,17 @@ recorder_close(struct recorder *recorder) {
    int ret = av_write_trailer(recorder->ctx);
    if (ret < 0) {
        LOGE("Failed to write trailer to %s", recorder->filename);
+        recorder->failed = true;
    }
    avio_close(recorder->ctx->pb);
    avformat_free_context(recorder->ctx);

-    const char *format_name = recorder_get_format_name(recorder->format);
-    LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
+    if (recorder->failed) {
+        LOGE("Recording failed to %s", recorder->filename);
+    } else {
+        const char *format_name = recorder_get_format_name(recorder->format);
+        LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
+    }
 }

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

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

@ -151,9 +253,6 @@ 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;
    }

@ -169,13 +268,110 @@ 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 &&
+                recorder_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 && recorder_queue_is_empty(&recorder->queue)) {
+            mutex_unlock(recorder->mutex);
+            break;
+        }
+
+        struct record_packet *rec = recorder_queue_take(&recorder->queue);
+
+        mutex_unlock(recorder->mutex);
+
+        bool ok = recorder_write(recorder, &rec->packet);
+        record_packet_delete(rec);
+        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;
+    }
+
+    bool ok = recorder_queue_push(&recorder->queue, packet);
+    cond_signal(recorder->queue_cond);
+
+    mutex_unlock(recorder->mutex);
+    return ok;
+}
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@ -3,6 +3,8 @@

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

 #include "common.h"

@ -11,12 +13,29 @@ enum recorder_format {
    RECORDER_FORMAT_MKV,
 };

+struct record_packet {
+    AVPacket packet;
+    struct record_packet *next;
+};
+
+struct recorder_queue {
+    struct record_packet *first;
+    struct record_packet *last; // undefined if first is NULL
+};
+
 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;
 };

 bool
@ -33,6 +52,15 @@ void
 recorder_close(struct recorder *recorder);

 bool
-recorder_write(struct recorder *recorder, AVPacket *packet);
+recorder_start(struct recorder *recorder);
+
+void
+recorder_stop(struct recorder *recorder);
+
+void
+recorder_join(struct recorder *recorder);
+
+bool
+recorder_push(struct recorder *recorder, const AVPacket *packet);

 #endif
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -259,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("Cannot allocate string");
+        LOGC("Could not allocate string");
        return;
    }
    // strcpy is safe here, the destination is large enough
@ -277,7 +277,6 @@ 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)) {
@ -334,7 +333,8 @@ scrcpy(const struct scrcpy_options *options) {
        video_buffer_initialized = true;

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

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

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

--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@ -9,6 +9,8 @@ struct scrcpy_options {
    const char *serial;
    const char *crop;
    const char *record_filename;
+    const char *window_title;
+    const char *push_target;
    enum recorder_format record_format;
    uint16_t port;
    uint16_t max_size;
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -85,7 +85,7 @@ get_optimal_size(struct size current_size, struct size frame_size) {
    uint32_t h;

    if (!get_preferred_display_bounds(&display_size)) {
-        // cannot get display bounds, do not constraint the size
+        // could not get display bounds, do not constraint the size
        w = current_size.width;
        h = current_size.height;
    } else {
@ -134,7 +134,7 @@ create_texture(SDL_Renderer *renderer, struct size frame_size) {
 }

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

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

-    screen->window = SDL_CreateWindow(device_name, SDL_WINDOWPOS_UNDEFINED,
+    screen->window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_UNDEFINED,
                                      SDL_WINDOWPOS_UNDEFINED,
                                      window_size.width, window_size.height,
                                      window_flags);
--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -44,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 *device_name,
+screen_init_rendering(struct screen *screen, const char *window_title,
                      struct size frame_size, bool always_on_top);

 // show the window
--- a/app/src/server.c
+++ b/app/src/server.c
@ -2,31 +2,67 @@

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

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

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

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

 static const char *
 get_server_path(void) {
-    const char *server_path = getenv("SCRCPY_SERVER_PATH");
-    if (!server_path) {
-        server_path = DEFAULT_SERVER_PATH;
+    const char *server_path_env = getenv("SCRCPY_SERVER_PATH");
+    if (server_path_env) {
+        LOGD("Using SCRCPY_SERVER_PATH: %s", server_path_env);
+        // if the envvar is set, use it
+        return server_path_env;
    }
+
+#ifndef PORTABLE
+    LOGD("Using server: " DEFAULT_SERVER_PATH);
+    // the absolute path is hardcoded
+    return DEFAULT_SERVER_PATH;
+#else
+    // use scrcpy-server.jar in the same directory as the executable
+    char *executable_path = get_executable_path();
+    if (!executable_path) {
+        LOGE("Could not get executable path, "
+             "using " SERVER_FILENAME " from current directory");
+        // not found, use current directory
+        return SERVER_FILENAME;
+    }
+    char *dir = dirname(executable_path);
+    size_t dirlen = strlen(dir);
+
+    // sizeof(SERVER_FILENAME) gives statically the size including the null byte
+    size_t len = dirlen + 1 + sizeof(SERVER_FILENAME);
+    char *server_path = SDL_malloc(len);
+    if (!server_path) {
+        LOGE("Could not alloc server path string, "
+             "using " SERVER_FILENAME " from current directory");
+        SDL_free(executable_path);
+        return SERVER_FILENAME;
+    }
+
+    memcpy(server_path, dir, dirlen);
+    server_path[dirlen] = PATH_SEPARATOR;
+    memcpy(&server_path[dirlen + 1], SERVER_FILENAME, sizeof(SERVER_FILENAME));
+    // the final null byte has been copied with SERVER_FILENAME
+
+    SDL_free(executable_path);
+
+    LOGD("Using server (portable): %s", server_path);
    return server_path;
+#endif
 }

 static bool
@ -86,7 +122,7 @@ execute_server(struct server *server, const struct server_params *params) {
    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
    const char *const cmd[] = {
        "shell",
-        "CLASSPATH=/data/local/tmp/scrcpy-server.jar",
+        "CLASSPATH=/data/local/tmp/" SERVER_FILENAME,
        "app_process",
        "/", // unused
        "com.genymobile.scrcpy.Server",
@ -94,7 +130,7 @@ execute_server(struct server *server, const struct server_params *params) {
        bit_rate_string,
        server->tunnel_forward ? "true" : "false",
        params->crop ? params->crop : "-",
-        params->send_frame_meta ? "true" : "false",
+        "true", // always send frame meta (packet boundaries + timestamp)
        params->control ? "true" : "false",
    };
    return adb_execute(server->serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
@ -119,6 +155,7 @@ 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;
@ -145,7 +182,7 @@ close_socket(socket_t *socket) {
    SDL_assert(*socket != INVALID_SOCKET);
    net_shutdown(*socket, SHUT_RDWR);
    if (!net_close(*socket)) {
-        LOGW("Cannot close socket");
+        LOGW("Could not close socket");
        return;
    }
    *socket = INVALID_SOCKET;
@ -269,7 +306,7 @@ server_stop(struct server *server) {
    SDL_assert(server->process != PROCESS_NONE);

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

    cmd_simple_wait(server->process, NULL); // ignore exit code
--- a/app/src/server.h
+++ b/app/src/server.h
@ -34,7 +34,6 @@ 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
@ -92,4 +92,20 @@ utf8_to_wide_char(const char *utf8) {
    return wide;
 }

+char *
+utf8_from_wide_char(const wchar_t *ws) {
+    int len = WideCharToMultiByte(CP_UTF8, 0, ws, -1, NULL, 0, NULL, NULL);
+    if (!len) {
+        return NULL;
+    }
+
+    char *utf8 = SDL_malloc(len);
+    if (!utf8) {
+        return NULL;
+    }
+
+    WideCharToMultiByte(CP_UTF8, 0, ws, -1, utf8, len, NULL, NULL);
+    return utf8;
+}
+
 #endif
--- a/app/src/str_util.h
+++ b/app/src/str_util.h
@ -32,6 +32,9 @@ utf8_truncation_index(const char *utf8, size_t max_len);
 // returns the new allocated string, to be freed by the caller
 wchar_t *
 utf8_to_wide_char(const char *utf8);
+
+char *
+utf8_from_wide_char(const wchar_t *s);
 #endif

 #endif
--- a/app/src/stream.c
+++ b/app/src/stream.c
@ -22,54 +22,8 @@
 #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
-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;
-
+stream_recv_packet(struct stream *stream, AVPacket *packet) {
    // 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.
@ -82,60 +36,30 @@ read_packet_with_meta(void *opaque, uint8_t *buf, int buf_size) {
    //
    // It is followed by <packet_size> bytes containing the packet/frame.

-    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);
-        }
+    uint8_t header[HEADER_SIZE];
+    ssize_t r = net_recv_all(stream->socket, header, HEADER_SIZE);
+    if (r < HEADER_SIZE) {
+        return false;
    }

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

-    if (buf_size > state->remaining) {
-        buf_size = state->remaining;
+    if (av_new_packet(packet, len)) {
+        LOGE("Could not allocate 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;
+    r = net_recv_all(stream->socket, packet->data, len);
+    if (r < len) {
+        av_packet_unref(packet);
+        return false;
    }

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

-    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;
+    return true;
 }

 static void
@ -145,116 +69,199 @@ 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_close_input;
+        goto finally_free_codec_ctx;
    }

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

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

-    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;
-            }
+    // 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;
        }

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

    LOGD("End of frames");

-quit:
+    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:
    if (stream->recorder) {
        recorder_close(stream->recorder);
    }
-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);
+finally_close_decoder:
+    if (stream->decoder) {
+        decoder_close(stream->decoder);
+    }
+finally_free_codec_ctx:
+    avcodec_free_context(&stream->codec_ctx);
 end:
    notify_stopped();
    return 0;
@ -266,7 +273,7 @@ stream_init(struct stream *stream, socket_t socket,
    stream->socket = socket;
    stream->decoder = decoder,
    stream->recorder = recorder;
-    SDL_AtomicSet(&stream->stopped, 0);
+    stream->has_pending = false;
 }

 bool
@ -283,7 +290,6 @@ 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,6 +3,7 @@

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

@ -10,23 +11,18 @@

 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;
-    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;
+    AVCodecContext *codec_ctx;
+    AVCodecParserContext *parser;
+    // successive packets may need to be concatenated, until a non-config
+    // packet is available
+    bool has_pending;
+    AVPacket pending;
 };

 void
--- a/app/src/sys/unix/command.c
+++ b/app/src/sys/unix/command.c
@ -1,9 +1,15 @@
+// for portability
 #define _POSIX_SOURCE // for kill()
+#define _BSD_SOURCE // for readlink()
+
+// modern glibc will complain without this
+#define _DEFAULT_SOURCE

 #include "command.h"

 #include <errno.h>
 #include <fcntl.h>
+#include <limits.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/types.h>
@ -88,7 +94,7 @@ cmd_simple_wait(pid_t pid, int *exit_code) {
    int status;
    int code;
    if (waitpid(pid, &status, 0) == -1 || !WIFEXITED(status)) {
-        // cannot wait, or exited unexpectedly, probably by a signal
+        // could not wait, or exited unexpectedly, probably by a signal
        code = -1;
    } else {
        code = WEXITSTATUS(status);
@ -98,3 +104,23 @@ cmd_simple_wait(pid_t pid, int *exit_code) {
    }
    return !code;
 }
+
+char *
+get_executable_path(void) {
+// <https://stackoverflow.com/a/1024937/1987178>
+#ifdef __linux__
+    char buf[PATH_MAX + 1]; // +1 for the null byte
+    ssize_t len = readlink("/proc/self/exe", buf, PATH_MAX);
+    if (len == -1) {
+        perror("readlink");
+        return NULL;
+    }
+    buf[len] = '\0';
+    return SDL_strdup(buf);
+#else
+    // in practice, we only need this feature for portable builds, only used on
+    // Windows, so we don't care implementing it for every platform
+    // (it's useful to have a working version on Linux for debugging though)
+    return NULL;
+#endif
+}
--- a/app/src/sys/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("Cannot allocate wide char string");
+        LOGC("Could not 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)) {
-        // cannot wait or retrieve the exit code
+        // could not wait or retrieve the exit code
        code = -1; // max value, it's unsigned
    }
    if (exit_code) {
@ -75,3 +75,18 @@ cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
    }
    return !code;
 }
+
+char *
+get_executable_path(void) {
+    HMODULE hModule = GetModuleHandleW(NULL);
+    if (!hModule) {
+        return NULL;
+    }
+    WCHAR buf[MAX_PATH + 1]; // +1 for the null byte
+    int len = GetModuleFileNameW(hModule, buf, MAX_PATH);
+    if (!len) {
+        return NULL;
+    }
+    buf[len] = '\0';
+    return utf8_from_wide_char(buf);
+}
--- a/cross_win32.txt
+++ b/cross_win32.txt
@ -15,6 +15,6 @@ cpu = 'i686'
 endian = 'little'

 [properties]
-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'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.1.3-win32-shared'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.1.3-win32-dev'
+prebuilt_sdl2 = 'SDL2-2.0.8/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-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.1-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.9/x86_64-w64-mingw32'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.1.3-win64-shared'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.1.3-win64-dev'
+prebuilt_sdl2 = 'SDL2-2.0.8/x86_64-w64-mingw32'
--- a/meson.build
+++ b/meson.build
@ -1,13 +1,13 @@
 project('scrcpy', 'c',
-        version: '1.8',
+        version: '1.9',
        meson_version: '>= 0.37',
        default_options: 'c_std=c11')

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

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

--- a/meson_options.txt
+++ b/meson_options.txt
@ -1,8 +1,7 @@
-option('build_app', type: 'boolean', value: true, description: 'Build the client')
-option('build_server', type: 'boolean', value: true, description: 'Build the server')
+option('compile_app', type: 'boolean', value: true, description: 'Build the client')
+option('compile_server', type: 'boolean', value: true, description: 'Build the server')
 option('crossbuild_windows', type: 'boolean', value: false, description: 'Build for Windows from Linux')
 option('windows_noconsole', type: 'boolean', value: false, description: 'Disable console on Windows (pass -mwindows flag)')
 option('prebuilt_server', type: 'string', description: 'Path of the prebuilt server')
-option('override_server_path', type: 'string', description: 'Hardcoded path to find the server at runtime')
-option('skip_frames', type: 'boolean', value: true, description: 'Always display the most recent frame')
+option('portable', type: 'boolean', value: false, description: 'Use scrcpy-server.jar from the same directory as the scrcpy executable')
 option('hidpi_support', type: 'boolean', value: true, description: 'Enable High DPI support')
--- 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-win32-shared.zip \
-		e692b18c01745d262c03294b382fd64df68fabe3c66aa4546a3ad3935175cde3 \
-		ffmpeg-4.1-win32-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.1.3-win32-shared.zip \
+		8ea472d673370d5e87517a75587abfa6f189ee4f82e8da21fdbc49d0db0c1a89 \
+		ffmpeg-4.1.3-win32-shared

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

 prepare-ffmpeg-shared-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.1-win64-shared.zip \
-		c4908c97436c946509dc365e421159274fa4b1e66dce6fb5b63d82a6294d5357 \
-		ffmpeg-4.1-win64-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.1.3-win64-shared.zip \
+		0b974578e07d974c4bafb36c7ed0b46e46b001d38b149455089c13b57ddefe5d \
+		ffmpeg-4.1.3-win64-shared

 prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.1-win64-dev.zip \
-		761ec79aa3dae66698c9791a2f0bb9da8794246f8356cadc741ddc0eabab0471 \
-		ffmpeg-4.1-win64-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.1.3-win64-dev.zip \
+		334b473467db096a5b74242743592a73e120a137232794508e4fc55593696a5b \
+		ffmpeg-4.1.3-win64-dev

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

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

 android {
-    compileSdkVersion 27
+    compileSdkVersion 29
    defaultConfig {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
-        targetSdkVersion 27
-        versionCode 9
-        versionName "1.8"
+        targetSdkVersion 29
+        versionCode 10
+        versionName "1.9"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -68,7 +68,7 @@ public final class Server {
    @SuppressWarnings("checkstyle:MagicNumber")
    private static Options createOptions(String... args) {
        if (args.length != 6) {
-            throw new IllegalArgumentException("Expecting 5 parameters");
+            throw new IllegalArgumentException("Expecting 6 parameters");
        }

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

--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
@ -29,7 +29,7 @@ public class StatusBarManager {
        try {
            expandNotificationsPanelMethod.invoke(manager);
        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Cannot invoke ServiceBarManager.expandNotificationsPanel()", e);
+            Ln.e("Could not invoke ServiceBarManager.expandNotificationsPanel()", e);
        }
    }

@ -45,7 +45,7 @@ public class StatusBarManager {
        try {
            collapsePanelsMethod.invoke(manager);
        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Cannot invoke ServiceBarManager.collapsePanels()", e);
+            Ln.e("Could not 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
@ -2,6 +2,7 @@ package com.genymobile.scrcpy.wrappers;

 import android.annotation.SuppressLint;
 import android.graphics.Rect;
+import android.os.Build;
 import android.os.IBinder;
 import android.view.Surface;

@ -77,7 +78,12 @@ public final class SurfaceControl {

    public static IBinder getBuiltInDisplay(int builtInDisplayId) {
        try {
-            return (IBinder) CLASS.getMethod("getBuiltInDisplay", int.class).invoke(null, builtInDisplayId);
+            // the method signature has changed in Android Q
+            // <https://github.com/Genymobile/scrcpy/issues/586>
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+                return (IBinder) CLASS.getMethod("getBuiltInDisplay", int.class).invoke(null, builtInDisplayId);
+            }
+            return (IBinder) CLASS.getMethod("getPhysicalDisplayToken", long.class).invoke(null, builtInDisplayId);
        } catch (Exception e) {
            throw new AssertionError(e);
        }
--- a/server/src/test/java/com/genymobile/scrcpy/DeviceMessageWriterTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/DeviceMessageWriterTest.java
@ -0,0 +1,35 @@
+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,7 +1,6 @@
 package com.genymobile.scrcpy;

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

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

    @Test
    @SuppressWarnings("checkstyle:MagicNumber")
-    public void testUtf8Trucate() {
+    public void testUtf8Truncate() {
        String s = "aÉbÔc";
        byte[] utf8 = s.getBytes(StandardCharsets.UTF_8);
        Assert.assertEquals(7, utf8.length);
Author	SHA1	Message	Date
Romain Vimont	f049b6bc1b	Use Cmd instead of Ctrl on macOS when possible Fixes <https://github.com/Genymobile/scrcpy/issues/642>	2019-08-01 21:29:07 +02:00
Romain Vimont	6abb4902c6	Log recording failure If recording fails, log "recording failed" instead of "recording complete".	2019-07-31 11:04:38 +02:00
Romain Vimont	d4ed8b6f26	Log scrcpy version and URL on start Keep --version which also print the version of dependencies.	2019-07-31 01:55:43 +02:00
Romain Vimont	35d9185f6c	Record asynchronously The record file was written from the stream thread. As a consequence, any blocking I/O to write the file delayed the decoder. For maximum performance even when recording is enabled, send (refcounted) packets to a separate recording thread.	2019-07-31 01:55:40 +02:00
Romain Vimont	63af7fbafe	Reduce latency by 1 frame To packetize the H.264 raw stream, av_parser_parse2() (called by av_read_frame()) knows that it has received a full frame only after it has received some data for the next frame. As a consequence, the client always waited until the next frame before sending the current frame to the decoder! On the device side, we know packets boundaries. To reduce latency, make the device always transmit the "frame meta" to packetize the stream manually (it was already implemented to send PTS, but only enabled on recording). On the client side, replace av_read_frame() by manual packetizing and parsing. <https://stackoverflow.com/questions/50682518/replacing-av-read-frame-to-reduce-delay> <https://trac.ffmpeg.org/ticket/3354>	2019-07-31 01:55:32 +02:00
Romain Vimont	a90ccbdf3b	Add option to change the push target A drag & drop always pushed the file to /sdcard/. Add an option to customize the target directory. Fixes <https://github.com/Genymobile/scrcpy/issues/659>	2019-07-31 01:53:16 +02:00
Romain Vimont	ca970e8aa6	Merge branch 'master' into dev	2019-07-31 00:14:17 +02:00
Romain Vimont	6b3d9e3eab	Add unit test for device message serialization There was a test for the deserialization, but not for the serialization.	2019-07-30 12:17:33 +02:00
Romain Vimont	02692ffa42	Rename "build_" to "compile_" Recent versions of meson complain about an option having name starting with "build_": > DEPRECATION: Option uses prefix "build_", which is reserved for Meson. > This will become an error in the future. Use "compile_" instead.	2019-07-29 15:19:07 +02:00
Jonathan	3b69463e61	Update README.md Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-07-29 14:59:44 +02:00
Romain Vimont	9dea6d2384	Add me as copyright owner	2019-07-29 14:59:44 +02:00
Romain Vimont	3c55d0c69b	Fix double-free on error If writing the recording header fails, do not clean the resources immediately to avoid double-free.	2019-07-12 21:07:06 +02:00
Romain Vimont	4961256123	Close decoder on stream ended Add missing call to decoder_close().	2019-06-26 23:50:39 +02:00
Romain Vimont	e4ac943d86	Document --window-title in README	2019-06-24 21:37:38 +02:00
Romain Vimont	4b997239f3	Merge pull request #614 from beango1:window-title-simple add option window-title to set the title	2019-06-24 21:32:45 +02:00
beango1	8e65c10720	Add option --window-title Add an option to set a custom window title. Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-06-24 19:58:00 +02:00
Romain Vimont	056e47e752	Replace "cannot" by "could not"	2019-06-23 20:52:03 +02:00
Romain Vimont	439b009a79	Fix expected parameters count in error message	2019-06-23 20:47:21 +02:00
Romain Vimont	91ecb4f218	Close socket on error Suggested-by: barry-ran <https://github.com/Genymobile/scrcpy/issues/607>	2019-06-20 12:15:45 +02:00
Romain Vimont	bfb3f0842f	Prevent to turn screen off if no control If --no-control is set, then the controller is not initialized (both in the client and the server), so it is not possible to control the device to turn its screen off. See <https://github.com/Genymobile/scrcpy/issues/608>.	2019-06-20 10:59:19 +02:00
Romain Vimont	87d7a157a9	Reference USBaudio from README	2019-06-20 10:47:02 +02:00
Romain Vimont	b91ecf5225	Fix --serial help Make explicit that --serial excepts a parameter.	2019-06-18 17:13:53 +02:00
Romain Vimont	1807de4955	Merge pull request #595 from taaem/fix_build_fedora The Java JDK is needed to build the server	2019-06-15 15:14:22 +02:00
taaem	0a233fd27f	Fix required java package for Fedora The Java JDK is needed to build the server. The relevant Fedora package is java-devel, not java. Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-06-15 15:10:51 +02:00
Romain Vimont	4940746bcb	Remove useless else The if-block ends with a return.	2019-06-14 10:15:53 +02:00
Romain Vimont	fe758e6e15	Improve comment Rephrase to simplify and add a link to the issue.	2019-06-14 10:11:15 +02:00
Romain Vimont	b29a568f08	Merge pull request #587 from schwabe/fix_586_screen_off_qbeta Use getPhysicalDisplayToken if getBuiltInDisplay is not found	2019-06-14 10:04:12 +02:00
Arne Schwabe	b769083a5b	Use getPhysicalDisplayToken on Anroid Q+ instead of getBuiltInDisplay This makes the -S (screen off) parameter work on Android Q beta 4 Closes #586	2019-06-13 13:30:54 +02:00
Romain Vimont	8ca36406b9	Remove compilation flag "skip_frames" It is unused since `ebccb9f6cc`.	2019-06-12 11:43:18 +02:00
Romain Vimont	53310a925a	Disable portable build by default The default value of a boolean meson option is true. We want non-portable build by default.	2019-06-12 11:26:23 +02:00
Romain Vimont	0cb902d58b	Merge pull request #587 from zzndb/patch-1	2019-06-12 11:23:15 +02:00
zzndb	bcd0a876f7	Fix a spell mistake After commented default portable option in `app/meson.build` get some error and then find this. :) Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-06-12 11:22:50 +02:00
Romain Vimont	de2016a48e	Add link to Snap package in README <https://github.com/Genymobile/scrcpy/issues/523>	2019-06-11 23:41:56 +02:00
Romain Vimont	19ca6a0d66	Fix typo in README	2019-06-11 23:01:23 +02:00
Romain Vimont	e2996e85c0	Update links to v1.9 in README and BUILD	2019-06-11 23:00:09 +02:00
Romain Vimont	c2df0228a3	Merge branch 'dev'	2019-06-11 22:54:58 +02:00
Romain Vimont	259d3aee93	Bump version to 1.9	2019-06-11 21:50:29 +02:00
Romain Vimont	90859f1dcf	Upgrade tarketSdkVersion to 29 This fixes a lint warning.	2019-06-11 21:49:14 +02:00
Romain Vimont	1afe9ce2ee	Fix deprecation warning in Java unit test	2019-06-11 21:48:58 +02:00
Romain Vimont	273cec8a92	Fix typo in test name	2019-06-11 21:47:31 +02:00
Romain Vimont	02f189b1de	Remove obsolete detail in README Now that scrcpy-server.jar is found in the same directory as the scrcpy executable, using SCRCPY_SERVER_PATH is not particularly useful on Windows anymore	2019-06-11 21:37:09 +02:00
Romain Vimont	4abe163233	Remove obsolete explanation in FAQ Issue 9 was about stdout/stderr not printed in Windows console. This is solved since the Windows version is cross-compiled from Linux.	2019-06-11 21:20:06 +02:00
Romain Vimont	5ffdcbb7be	Update DEVELOP.md	2019-06-11 21:18:43 +02:00
Romain Vimont	ffe0417228	Update platform-tools (29.0.1) for Windows Include the latest version of adb in Windows releases.	2019-06-11 19:19:47 +02:00
Romain Vimont	e3afb67e7f	Downgrade SDL to 2.0.8 for Windows Revert "Update SDL (2.0.9) for Windows" Several users experienced freezes with SDL 2.0.9. This reverts commit `a5787dccd6`. See: - <https://github.com/Genymobile/scrcpy/issues/425> - <https://discourse.libsdl.org/t/unstable-frame-rate-unexpectedly/25783>	2019-06-11 19:18:45 +02:00
Romain Vimont	4ee1391361	Upgrade FFmpeg (4.1.3) for Windows Include the latest version of FFmpeg in Windows releases.	2019-06-11 19:18:45 +02:00
Romain Vimont	2755bfc255	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-11 17:44:07 +02:00
Romain Vimont	3b17ff7c86	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-11 17:44:07 +02:00
Romain Vimont	4eb6b26c93	Extract "scrcpy-server.jar" string The filename is used at several places.	2019-06-11 17:44:07 +02:00
Romain Vimont	eb34098add	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-11 17:44:07 +02:00
Romain Vimont	b777760bca	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-11 17:44:07 +02:00
Romain Vimont	72bdfbc7a6	Never return 0 for stream protocol On socket disconnection, on Linux, recv() returns -1 and errno is set. But on Windows, errno is 0. In that case, AVERROR(errno) == 0, leading to the warning: > Invalid return value 0 for stream protocol To avoid the problem, if errno is 0, return AVERROR_EOF. Ref: commit `2876463d39`	2019-06-11 17:44:07 +02:00
Romain Vimont	a13524e7f9	Replace android-tools-adb by adb Here is the description of the adb package in Debian: > Description: Android Debug Bridge > > A versatile command line tool that lets you communicate with an > emulator instance or connected Android-powered device. > > This package recommends "android-sdk-platform-tools-common" which > contains the udev rules for Android devices. Without this package, adb > and fastboot need to be running with root permission. And android-tools-adb: > Description: transitional package > > This is a transitional package. It can safely be removed.	2019-06-05 09:52:25 +02:00
Romain Vimont	f3f3433163	Merge pull request #574 from crow1170/patch-1 Fix dependencies	2019-06-05 09:51:47 +02:00
Chris Knowles	232aaa386e	Fix dependencies Some missing or misspelled dependencies. Checked on Ubuntu 19.04.	2019-06-05 01:15:59 -04:00