Use Cmd instead of Ctrl on macOS when possible

Fixes <https://github.com/Genymobile/scrcpy/issues/642>

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:

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

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
 

LICENSE

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

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,36 +100,37 @@ 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)"; \
-		zip -r "$(WIN32_TARGET)" "$(WIN32_TARGET_DIR)"
+	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
+		zip -r "../$(WIN32_TARGET)" .
 
 zip-win64: dist-win64
-	cd "$(DIST)"; \
-		zip -r "$(WIN64_TARGET)" "$(WIN64_TARGET_DIR)"
+	cd "$(DIST)/$(WIN64_TARGET_DIR)"; \
+		zip -r "../$(WIN64_TARGET)" .
 
 sums:
 	cd "$(DIST)"; \

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.

app/meson.build

@@ -10,7 +10,6 @@ src = [
     'src/file_handler.c',
     'src/fps_counter.c',
     'src/input_manager.c',
-    'src/lock_util.c',
     'src/net.c',
     'src/receiver.c',
     'src/recorder.c',
@@ -94,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
@@ -163,6 +150,9 @@ tests = [
         'tests/test_device_msg_deserialize.c',
         'src/device_msg.c'
     ]],
+    ['test_queue', [
+        'tests/test_queue.c',
+    ]],
     ['test_strutil', [
         'tests/test_strutil.c',
         'src/str_util.c'

app/src/cbuf.h

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

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

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

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

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;

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

app/src/fps_counter.c

@@ -1,60 +1,169 @@
 #include "fps_counter.h"
 
+#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>
 
+#include "lock_util.h"
 #include "log.h"
 
-void
+#define FPS_COUNTER_INTERVAL_MS 1000
+
+bool
 fps_counter_init(struct fps_counter *counter) {
-    counter->started = false;
-    // no need to initialize the other fields, they are meaningful only when
-    // started is true
+    counter->mutex = SDL_CreateMutex();
+    if (!counter->mutex) {
+        return false;
+    }
+
+    counter->state_cond = SDL_CreateCond();
+    if (!counter->state_cond) {
+        SDL_DestroyMutex(counter->mutex);
+        return false;
+    }
+
+    counter->thread = NULL;
+    SDL_AtomicSet(&counter->started, 0);
+    // no need to initialize the other fields, they are unused until started
+
+    return true;
 }
 
 void
-fps_counter_start(struct fps_counter *counter) {
-    counter->started = true;
-    counter->slice_start = SDL_GetTicks();
+fps_counter_destroy(struct fps_counter *counter) {
+    SDL_DestroyCond(counter->state_cond);
+    SDL_DestroyMutex(counter->mutex);
+}
+
+// must be called with mutex locked
+static void
+display_fps(struct fps_counter *counter) {
+    unsigned rendered_per_second =
+        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;
+    if (counter->nr_skipped) {
+        LOGI("%u fps (+%u frames skipped)", rendered_per_second,
+                                            counter->nr_skipped);
+    } else {
+        LOGI("%u fps", rendered_per_second);
+    }
+}
+
+// must be called with mutex locked
+static void
+check_interval_expired(struct fps_counter *counter, uint32_t now) {
+    if (now < counter->next_timestamp) {
+        return;
+    }
+
+    display_fps(counter);
     counter->nr_rendered = 0;
     counter->nr_skipped = 0;
+    // add a multiple of the interval
+    uint32_t elapsed_slices =
+        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL_MS + 1;
+    counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;
+}
+
+static int
+run_fps_counter(void *data) {
+    struct fps_counter *counter = data;
+
+    mutex_lock(counter->mutex);
+    while (!counter->interrupted) {
+        while (!counter->interrupted && !SDL_AtomicGet(&counter->started)) {
+            cond_wait(counter->state_cond, counter->mutex);
+        }
+        while (!counter->interrupted && SDL_AtomicGet(&counter->started)) {
+            uint32_t now = SDL_GetTicks();
+            check_interval_expired(counter, now);
+
+            SDL_assert(counter->next_timestamp > now);
+            uint32_t remaining = counter->next_timestamp - now;
+
+            // ignore the reason (timeout or signaled), we just loop anyway
+            cond_wait_timeout(counter->state_cond, counter->mutex, remaining);
+        }
+    }
+    mutex_unlock(counter->mutex);
+    return 0;
+}
+
+bool
+fps_counter_start(struct fps_counter *counter) {
+    mutex_lock(counter->mutex);
+    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
+    counter->nr_rendered = 0;
+    counter->nr_skipped = 0;
+    mutex_unlock(counter->mutex);
+
+    SDL_AtomicSet(&counter->started, 1);
+    cond_signal(counter->state_cond);
+
+    // counter->thread is always accessed from the same thread, no need to lock
+    if (!counter->thread) {
+        counter->thread =
+            SDL_CreateThread(run_fps_counter, "fps counter", counter);
+        if (!counter->thread) {
+            LOGE("Could not start FPS counter thread");
+            return false;
+        }
+    }
+
+    return true;
 }
 
 void
 fps_counter_stop(struct fps_counter *counter) {
-    counter->started = false;
+    SDL_AtomicSet(&counter->started, 0);
+    cond_signal(counter->state_cond);
 }
 
-static void
-display_fps(struct fps_counter *counter) {
-    if (counter->nr_skipped) {
-        LOGI("%d fps (+%d frames skipped)", counter->nr_rendered,
-                                            counter->nr_skipped);
-    } else {
-        LOGI("%d fps", counter->nr_rendered);
+bool
+fps_counter_is_started(struct fps_counter *counter) {
+    return SDL_AtomicGet(&counter->started);
+}
+
+void
+fps_counter_interrupt(struct fps_counter *counter) {
+    if (!counter->thread) {
+        return;
     }
+
+    mutex_lock(counter->mutex);
+    counter->interrupted = true;
+    mutex_unlock(counter->mutex);
+    // wake up blocking wait
+    cond_signal(counter->state_cond);
 }
 
-static void
-check_expired(struct fps_counter *counter) {
-    uint32_t now = SDL_GetTicks();
-    if (now - counter->slice_start >= 1000) {
-        display_fps(counter);
-        // add a multiple of one second
-        uint32_t elapsed_slices = (now - counter->slice_start) / 1000;
-        counter->slice_start += 1000 * elapsed_slices;
-        counter->nr_rendered = 0;
-        counter->nr_skipped = 0;
+void
+fps_counter_join(struct fps_counter *counter) {
+    if (counter->thread) {
+        SDL_WaitThread(counter->thread, NULL);
     }
 }
 
 void
 fps_counter_add_rendered_frame(struct fps_counter *counter) {
-    check_expired(counter);
+    if (!SDL_AtomicGet(&counter->started)) {
+        return;
+    }
+
+    mutex_lock(counter->mutex);
+    uint32_t now = SDL_GetTicks();
+    check_interval_expired(counter, now);
     ++counter->nr_rendered;
+    mutex_unlock(counter->mutex);
 }
 
 void
 fps_counter_add_skipped_frame(struct fps_counter *counter) {
-    check_expired(counter);
+    if (!SDL_AtomicGet(&counter->started)) {
+        return;
+    }
+
+    mutex_lock(counter->mutex);
+    uint32_t now = SDL_GetTicks();
+    check_interval_expired(counter, now);
     ++counter->nr_skipped;
+    mutex_unlock(counter->mutex);
 }

app/src/fps_counter.h

@@ -3,23 +3,49 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include <SDL2/SDL_atomic.h>
+#include <SDL2/SDL_mutex.h>
+#include <SDL2/SDL_thread.h>
 
 struct fps_counter {
-    bool started;
-    uint32_t slice_start; // initialized by SDL_GetTicks()
-    int nr_rendered;
-    int nr_skipped;
+    SDL_Thread *thread;
+    SDL_mutex *mutex;
+    SDL_cond *state_cond;
+
+    // atomic so that we can check without locking the mutex
+    // if the FPS counter is disabled, we don't want to lock unnecessarily
+    SDL_atomic_t started;
+
+    // the following fields are protected by the mutex
+    bool interrupted;
+    unsigned nr_rendered;
+    unsigned nr_skipped;
+    uint32_t next_timestamp;
 };
 
-void
+bool
 fps_counter_init(struct fps_counter *counter);
 
 void
+fps_counter_destroy(struct fps_counter *counter);
+
+bool
 fps_counter_start(struct fps_counter *counter);
 
 void
 fps_counter_stop(struct fps_counter *counter);
 
+bool
+fps_counter_is_started(struct fps_counter *counter);
+
+// request to stop the thread (on quit)
+// must be called before fps_counter_join()
+void
+fps_counter_interrupt(struct fps_counter *counter);
+
+void
+fps_counter_join(struct fps_counter *counter);
+
 void
 fps_counter_add_rendered_frame(struct fps_counter *counter);
 

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,28 +167,31 @@ 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'");
     }
 }
 
 static void
-switch_fps_counter_state(struct video_buffer *vb) {
-    mutex_lock(vb->mutex);
-    if (vb->fps_counter.started) {
+switch_fps_counter_state(struct fps_counter *fps_counter) {
+    // the started state can only be written from the current thread, so there
+    // is no ToCToU issue
+    if (fps_counter_is_started(fps_counter)) {
+        fps_counter_stop(fps_counter);
         LOGI("FPS counter stopped");
-        fps_counter_stop(&vb->fps_counter);
     } else {
-        LOGI("FPS counter started");
-        fps_counter_start(&vb->fps_counter);
+        if (fps_counter_start(fps_counter)) {
+            LOGI("FPS counter started");
+        } else {
+            LOGE("FPS counter starting failed");
+        }
     }
-    mutex_unlock(vb->mutex);
 }
 
 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) {
@@ -202,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'");
     }
 }
 
@@ -219,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'");
     }
 }
 
@@ -239,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;
@@ -256,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);
@@ -323,27 +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) {
-                    switch_fps_counter_state(input_manager->video_buffer);
+                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 {
@@ -363,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'");
         }
     }
 }
@@ -380,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'");
         }
     }
 }
@@ -426,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'");
         }
     }
 }
@@ -441,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'");
         }
     }
 }

app/src/lock_util.c

@@ -1,38 +0,0 @@
-#include <lock_util.h>
-#include <stdlib.h>
-#include <SDL2/SDL_mutex.h>
-
-#include "log.h"
-
-void
-mutex_lock(SDL_mutex *mutex) {
-    if (SDL_LockMutex(mutex)) {
-        LOGC("Could not lock mutex");
-        abort();
-    }
-}
-
-void
-mutex_unlock(SDL_mutex *mutex) {
-    if (SDL_UnlockMutex(mutex)) {
-        LOGC("Could not unlock mutex");
-        abort();
-    }
-}
-
-void
-cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
-    if (SDL_CondWait(cond, mutex)) {
-        LOGC("Could not wait on condition");
-        abort();
-    }
-}
-
-void
-cond_signal(SDL_cond *cond) {
-    if (SDL_CondSignal(cond)) {
-        LOGC("Could not signal a condition");
-        abort();
-    }
-}
-

app/src/lock_util.h

@@ -1,20 +1,51 @@
 #ifndef LOCKUTIL_H
 #define LOCKUTIL_H
 
-// forward declarations
-typedef struct SDL_mutex SDL_mutex;
-typedef struct SDL_cond SDL_cond;
+#include <stdint.h>
+#include <SDL2/SDL_mutex.h>
 
-void
-mutex_lock(SDL_mutex *mutex);
+#include "log.h"
 
-void
-mutex_unlock(SDL_mutex *mutex);
+static inline void
+mutex_lock(SDL_mutex *mutex) {
+    if (SDL_LockMutex(mutex)) {
+        LOGC("Could not lock mutex");
+        abort();
+    }
+}
 
-void
-cond_wait(SDL_cond *cond, SDL_mutex *mutex);
+static inline void
+mutex_unlock(SDL_mutex *mutex) {
+    if (SDL_UnlockMutex(mutex)) {
+        LOGC("Could not unlock mutex");
+        abort();
+    }
+}
 
-void
-cond_signal(SDL_cond *cond);
+static inline void
+cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
+    if (SDL_CondWait(cond, mutex)) {
+        LOGC("Could not wait on condition");
+        abort();
+    }
+}
+
+static inline int
+cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
+    int r = SDL_CondWaitTimeout(cond, mutex, ms);
+    if (r < 0) {
+        LOGC("Could not wait on condition with timeout");
+        abort();
+    }
+    return r;
+}
+
+static inline void
+cond_signal(SDL_cond *cond) {
+    if (SDL_CondSignal(cond)) {
+        LOGC("Could not signal a condition");
+        abort();
+    }
+}
 
 #endif

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,

app/src/queue.h

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

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,34 @@ 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;
+    }
+    return rec;
+}
+
+static void
+record_packet_delete(struct record_packet *rec) {
+    av_packet_unref(&rec->packet);
+    SDL_free(rec);
+}
+
+static void
+recorder_queue_clear(struct recorder_queue *queue) {
+    while (!queue_is_empty(queue)) {
+        struct record_packet *rec;
+        queue_take(queue, next, &rec);
+        record_packet_delete(rec);
+    }
+}
+
 bool
 recorder_init(struct recorder *recorder,
               const char *filename,
@@ -33,10 +62,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;
+    }
+
+    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 +93,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 +168,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 +187,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 +205,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 +220,116 @@ recorder_rescale_packet(struct recorder *recorder, AVPacket *packet) {
 bool
 recorder_write(struct recorder *recorder, AVPacket *packet) {
     if (!recorder->header_written) {
+        if (packet->pts != AV_NOPTS_VALUE) {
+            LOGE("The first packet is not a config packet");
+            return false;
+        }
         bool ok = recorder_write_header(recorder, packet);
         if (!ok) {
             return false;
         }
         recorder->header_written = true;
+        return true;
+    }
+
+    if (packet->pts == AV_NOPTS_VALUE) {
+        // ignore config packets
+        return true;
     }
 
     recorder_rescale_packet(recorder, packet);
     return av_write_frame(recorder->ctx, packet) >= 0;
 }
+
+static int
+run_recorder(void *data) {
+    struct recorder *recorder = data;
+
+    for (;;) {
+        mutex_lock(recorder->mutex);
+
+        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
+            cond_wait(recorder->queue_cond, recorder->mutex);
+        }
+
+        // if stopped is set, continue to process the remaining events (to
+        // finish the recording) before actually stopping
+
+        if (recorder->stopped && queue_is_empty(&recorder->queue)) {
+            mutex_unlock(recorder->mutex);
+            break;
+        }
+
+        struct record_packet *rec;
+        queue_take(&recorder->queue, next, &rec);
+
+        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;
+    }
+
+    struct record_packet *rec = record_packet_new(packet);
+    if (!rec) {
+        LOGC("Could not allocate record packet");
+        return false;
+    }
+
+    queue_push(&recorder->queue, next, rec);
+    cond_signal(recorder->queue_cond);
+
+    mutex_unlock(recorder->mutex);
+    return true;
+}

app/src/recorder.h

@@ -3,20 +3,37 @@
 
 #include <stdbool.h>
 #include <libavformat/avformat.h>
+#include <SDL2/SDL_mutex.h>
+#include <SDL2/SDL_thread.h>
 
 #include "common.h"
+#include "queue.h"
 
 enum recorder_format {
     RECORDER_FORMAT_MP4 = 1,
     RECORDER_FORMAT_MKV,
 };
 
+struct record_packet {
+    AVPacket packet;
+    struct record_packet *next;
+};
+
+struct recorder_queue QUEUE(struct record_packet);
+
 struct recorder {
     char *filename;
     enum recorder_format format;
     AVFormatContext *ctx;
     struct size declared_frame_size;
     bool header_written;
+
+    SDL_Thread *thread;
+    SDL_mutex *mutex;
+    SDL_cond *queue_cond;
+    bool stopped; // set on recorder_stop() by the stream reader
+    bool failed; // set on packet write failure
+    struct recorder_queue queue;
 };
 
 bool
@@ -33,6 +50,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

app/src/scrcpy.c

@@ -29,6 +29,7 @@
 
 static struct server server = SERVER_INITIALIZER;
 static struct screen screen = SCREEN_INITIALIZER;
+static struct fps_counter fps_counter;
 static struct video_buffer video_buffer;
 static struct stream stream;
 static struct decoder decoder;
@@ -258,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
@@ -276,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)) {
@@ -293,6 +293,7 @@ scrcpy(const struct scrcpy_options *options) {
 
     bool ret = false;
 
+    bool fps_counter_initialized = false;
     bool video_buffer_initialized = false;
     bool file_handler_initialized = false;
     bool recorder_initialized = false;
@@ -320,13 +321,20 @@ scrcpy(const struct scrcpy_options *options) {
 
     struct decoder *dec = NULL;
     if (options->display) {
-        if (!video_buffer_init(&video_buffer, options->render_expired_frames)) {
+        if (!fps_counter_init(&fps_counter)) {
+            goto end;
+        }
+        fps_counter_initialized = true;
+
+        if (!video_buffer_init(&video_buffer, &fps_counter,
+                               options->render_expired_frames)) {
             goto end;
         }
         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;
@@ -372,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;
         }
@@ -383,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'");
             }
         }
 
@@ -414,6 +425,9 @@ end:
     if (file_handler_initialized) {
         file_handler_stop(&file_handler);
     }
+    if (fps_counter_initialized) {
+        fps_counter_interrupt(&fps_counter);
+    }
 
     // shutdown the sockets and kill the server
     server_stop(&server);
@@ -443,6 +457,11 @@ end:
         video_buffer_destroy(&video_buffer);
     }
 
+    if (fps_counter_initialized) {
+        fps_counter_join(&fps_counter);
+        fps_counter_destroy(&fps_counter);
+    }
+
     if (options->show_touches) {
         if (!show_touches_waited) {
             // wait the process which enabled "show touches"

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;

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

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

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

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

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

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

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

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

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

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

app/src/video_buffer.c

@@ -10,7 +10,10 @@
 #include "log.h"
 
 bool
-video_buffer_init(struct video_buffer *vb, bool render_expired_frames) {
+video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
+                  bool render_expired_frames) {
+    vb->fps_counter = fps_counter;
+
     if (!(vb->decoding_frame = av_frame_alloc())) {
         goto error_0;
     }
@@ -37,7 +40,6 @@ video_buffer_init(struct video_buffer *vb, bool render_expired_frames) {
     // there is initially no rendering frame, so consider it has already been
     // consumed
     vb->rendering_frame_consumed = true;
-    fps_counter_init(&vb->fps_counter);
 
     return true;
 
@@ -75,10 +77,8 @@ video_buffer_offer_decoded_frame(struct video_buffer *vb,
         while (!vb->rendering_frame_consumed && !vb->interrupted) {
             cond_wait(vb->rendering_frame_consumed_cond, vb->mutex);
         }
-    } else {
-        if (vb->fps_counter.started && !vb->rendering_frame_consumed) {
-            fps_counter_add_skipped_frame(&vb->fps_counter);
-        }
+    } else if (!vb->rendering_frame_consumed) {
+        fps_counter_add_skipped_frame(vb->fps_counter);
     }
 
     video_buffer_swap_frames(vb);
@@ -93,9 +93,7 @@ const AVFrame *
 video_buffer_consume_rendered_frame(struct video_buffer *vb) {
     SDL_assert(!vb->rendering_frame_consumed);
     vb->rendering_frame_consumed = true;
-    if (vb->fps_counter.started) {
-        fps_counter_add_rendered_frame(&vb->fps_counter);
-    }
+    fps_counter_add_rendered_frame(vb->fps_counter);
     if (vb->render_expired_frames) {
         // unblock video_buffer_offer_decoded_frame()
         cond_signal(vb->rendering_frame_consumed_cond);

app/src/video_buffer.h

@@ -17,11 +17,12 @@ struct video_buffer {
     bool interrupted;
     SDL_cond *rendering_frame_consumed_cond;
     bool rendering_frame_consumed;
-    struct fps_counter fps_counter;
+    struct fps_counter *fps_counter;
 };
 
 bool
-video_buffer_init(struct video_buffer *vb, bool render_expired_frames);
+video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
+                  bool render_expired_frames);
 
 void
 video_buffer_destroy(struct video_buffer *vb);

app/tests/test_queue.c

@@ -0,0 +1,38 @@
+#include <assert.h>
+
+#include <queue.h>
+
+struct foo {
+    int value;
+    struct foo *next;
+};
+
+static void test_queue(void) {
+    struct my_queue QUEUE(struct foo) queue;
+    queue_init(&queue);
+
+    assert(queue_is_empty(&queue));
+
+    struct foo v1 = { .value = 42 };
+    struct foo v2 = { .value = 27 };
+
+    queue_push(&queue, next, &v1);
+    queue_push(&queue, next, &v2);
+
+    struct foo *foo;
+
+    assert(!queue_is_empty(&queue));
+    queue_take(&queue, next, &foo);
+    assert(foo->value == 42);
+
+    assert(!queue_is_empty(&queue));
+    queue_take(&queue, next, &foo);
+    assert(foo->value == 27);
+
+    assert(queue_is_empty(&queue));
+}
+
+int main(void) {
+    test_queue();
+    return 0;
+}

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'

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'

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
 

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')

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

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 {

server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java

@@ -89,7 +89,7 @@ public final class DesktopConnection implements Closeable {
         byte[] buffer = new byte[DEVICE_NAME_FIELD_LENGTH + 4];
 
         byte[] deviceNameBytes = deviceName.getBytes(StandardCharsets.UTF_8);
-        int len = Math.min(DEVICE_NAME_FIELD_LENGTH - 1, deviceNameBytes.length);
+        int len = StringUtils.getUtf8TruncationIndex(deviceNameBytes, DEVICE_NAME_FIELD_LENGTH - 1);
         System.arraycopy(deviceNameBytes, 0, buffer, 0, len);
         // byte[] are always 0-initialized in java, no need to set '\0' explicitly
 

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

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

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

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

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