Write header file with correct extradata

When recording, the header must be written with extradata set to the content of the very first packet. Suggested-by: Steve Lhomme <robux4@ycbcr.xyz>
Forward FFmpeg logs
2019-02-09 12:54:12 +01:00 · 2019-02-09 12:27:13 +01:00 · 2019-02-09 12:27:13 +01:00 · 2019-02-09 12:27:13 +01:00 · 2019-01-27 14:09:19 +01:00 · 2019-01-27 20:54:24 +08:00
43 changed files with 1254 additions and 464 deletions
--- a/BUILD.md
+++ b/BUILD.md
@ -0,0 +1,251 @@
+# Build scrcpy
+
+Here are the instructions to build _scrcpy_ (client and server).
+
+You may want to build only the client: the server binary, which will be pushed
+to the Android device, does not depend on your system and architecture. In that
+case, use the [prebuilt server] (so you will not need Java or the Android SDK).
+
+[prebuilt server]: #prebuilt-server
+
+
+## Requirements
+
+You need [adb]. It is available in the [Android SDK platform
+tools][platform-tools], or packaged in your distribution (`android-adb-tools`).
+
+On Windows, download the [platform-tools][platform-tools-windows] and extract
+the following files to a directory accessible from your `PATH`:
+ - `adb.exe`
+ - `AdbWinApi.dll`
+ - `AdbWinUsbApi.dll`
+
+The client requires [FFmpeg] and [LibSDL2]. Just follow the instructions.
+
+[adb]: https://developer.android.com/studio/command-line/adb.html
+[platform-tools]: https://developer.android.com/studio/releases/platform-tools.html
+[platform-tools-windows]: https://dl.google.com/android/repository/platform-tools-latest-windows.zip
+[ffmpeg]: https://en.wikipedia.org/wiki/FFmpeg
+[LibSDL2]: https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer
+
+
+
+## System-specific steps
+
+### Linux
+
+Install the required packages from your package manager.
+
+#### Debian/Ubuntu
+
+```bash
+# runtime dependencies
+sudo apt install ffmpeg libsdl2-2.0.0
+
+# client build dependencies
+sudo apt install make gcc pkg-config meson ninja-build \
+                 libavcodec-dev libavformat-dev libavutil-dev \
+                 libsdl2-dev
+
+# server build dependencies
+sudo apt install openjdk-8-jdk
+```
+
+On old versions (like Ubuntu 16.04), `meson` is too old. In that case, install
+it from `pip3`:
+
+```bash
+sudo apt install python3-pip
+pip3 install meson
+```
+
+
+#### Fedora
+
+```bash
+# enable RPM fusion free
+sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
+
+# client build dependencies
+sudo dnf install SDL2-devel ffms2-devel meson gcc make
+
+# server build dependencies
+sudo dnf install java
+```
+
+
+
+### Windows
+
+#### Cross-compile from Linux
+
+This is the preferred method (and the way the release is built).
+
+From _Debian_, install _mingw_:
+
+```bash
+sudo apt install mingw-w64 mingw-w64-tools
+```
+
+You also need the JDK to build the server:
+
+```bash
+sudo apt install openjdk-8-jdk
+```
+
+Then generate the releases:
+
+```bash
+make -f Makefile.CrossWindows
+```
+
+It will generate win32 and win64 releases into `dist/`.
+
+
+#### In MSYS2
+
+From Windows, you need [MSYS2] to build the project. From an MSYS2 terminal,
+install the required packages:
+
+[MSYS2]: http://www.msys2.org/
+
+```bash
+# runtime dependencies
+pacman -S mingw-w64-x86_64-SDL2 \
+          mingw-w64-x86_64-ffmpeg
+
+# client build dependencies
+pacman -S mingw-w64-x86_64-make \
+          mingw-w64-x86_64-gcc \
+          mingw-w64-x86_64-pkg-config \
+          mingw-w64-x86_64-meson
+```
+
+For a 32 bits version, replace `x86_64` by `i686`:
+
+```bash
+# runtime dependencies
+pacman -S mingw-w64-i686-SDL2 \
+          mingw-w64-i686-ffmpeg
+
+# client build dependencies
+pacman -S mingw-w64-i686-make \
+          mingw-w64-i686-gcc \
+          mingw-w64-i686-pkg-config \
+          mingw-w64-i686-meson
+```
+
+Java (>= 7) is not available in MSYS2, so if you plan to build the server,
+install it manually and make it available from the `PATH`:
+
+```bash
+export PATH="$JAVA_HOME/bin:$PATH"
+```
+
+### Mac OS
+
+Install the packages with [Homebrew]:
+
+[Homebrew]: https://brew.sh/
+
+```bash
+# runtime dependencies
+brew install sdl2 ffmpeg
+
+# client build dependencies
+brew install pkg-config meson
+```
+
+Additionally, if you want to build the server, install Java 8 from Caskroom, and
+make it avaliable from the `PATH`:
+
+```bash
+brew tap caskroom/versions
+brew cask install java8
+export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
+export PATH="$JAVA_HOME/bin:$PATH"
+```
+
+### Docker
+
+See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).
+
+
+## Common steps
+
+If you want to build the server, install the [Android SDK] (_Android Studio_),
+and set `ANDROID_HOME` to its directory. For example:
+
+[Android SDK]: https://developer.android.com/studio/index.html
+
+```bash
+export ANDROID_HOME=~/android/sdk
+```
+
+If you don't want to build the server, use the [prebuilt server].
+
+Clone the project:
+
+```bash
+git clone https://github.com/Genymobile/scrcpy
+cd scrcpy
+```
+
+Then, build:
+
+```bash
+meson x --buildtype release --strip -Db_lto=true
+cd x
+ninja
+```
+
+_Note: `ninja` [must][ninja-user] be run as a non-root user (only `ninja
+install` must be run as root)._
+
+[ninja-user]: https://github.com/Genymobile/scrcpy/commit/4c49b27e9f6be02b8e63b508b60535426bd0291a
+
+
+### Run
+
+To run without installing:
+
+```bash
+./run x [options]
+```
+
+
+### Install
+
+After a successful build, you can install _scrcpy_ on the system:
+
+```bash
+sudo ninja install    # without sudo on Windows
+```
+
+This installs two files:
+
+ - `/usr/local/bin/scrcpy`
+ - `/usr/local/share/scrcpy/scrcpy-server.jar`
+
+Just remove them to "uninstall" the application.
+
+You can then [run](README.md#run) _scrcpy_.
+
+
+## Prebuilt server
+
+ - [`scrcpy-server-v1.6.jar`][direct-scrcpy-server]  
+   _(SHA-256: 08df924bf6d10943df9eaacfff548a99871ebfca4641f8c7ddddb73f27cb905b)_
+
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.6/scrcpy-server-v1.6.jar
+
+Download the prebuilt server somewhere, and specify its path during the Meson
+configuration:
+
+```bash
+meson x --buildtype release --strip -Db_lto=true \
+    -Dprebuilt_server=/path/to/scrcpy-server.jar
+cd x
+ninja
+sudo ninja install
+```
--- a/FAQ.md
+++ b/FAQ.md
@ -24,19 +24,6 @@ If you still encounter problems, please see [issue 9].
 [issue 9]: https://github.com/Genymobile/scrcpy/issues/9


-### I get a black screen for some applications like Silence
-
-This is expected, they requested to protect the screen.
-
-In [Silence], you can disable it in settings → Privacy → Screen security.
-
-[silence]: https://f-droid.org/en/packages/org.smssecure.smssecure/
-
-See [issue 36].
-
-[issue 36]: https://github.com/Genymobile/scrcpy/issues/36
-
-
 ### Mouse clicks do not work

 On some devices, you may need to enable an option to allow [simulating input].
--- a/Makefile.CrossWindows
+++ b/Makefile.CrossWindows
@ -100,28 +100,28 @@ 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.0.2-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0.2-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0.2-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0.2-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.8/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.9/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"

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

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

 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.
@ -11,156 +11,54 @@ It works on _GNU/Linux_, _Windows_ and _MacOS_.

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

-You need [adb]. It is available in the [Android SDK platform
-tools][platform-tools], or packaged in your distribution (`android-adb-tools`).
-
-On Windows, just [download scrcpy for Windows](#windows), `adb` is included.
-
 Make sure you [enabled adb debugging][enable-adb] on your device(s).

-The client requires [FFmpeg] and [LibSDL2]. On Windows, they are included in the
-[prebuilt application](#windows).
-
-[adb]: https://developer.android.com/studio/command-line/adb.html
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-[platform-tools]: https://developer.android.com/studio/releases/platform-tools.html
-[platform-tools-windows]: https://dl.google.com/android/repository/platform-tools-latest-windows.zip
-[ffmpeg]: https://en.wikipedia.org/wiki/FFmpeg
-[LibSDL2]: https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer

-## Build and install
+On some devices, you also need to enable [an additional option][control] to
+control it using keyboard and mouse.

-### System-specific steps
+[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323

-#### Linux

-Install the required packages from your package manager.
+## Get the app

-##### Debian/Ubuntu

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

-# client build dependencies
-sudo apt install make gcc pkg-config meson \
-                 libavcodec-dev libavformat-dev libavutil-dev \
-                 libsdl2-dev
+On Linux, you typically need to [build the app manually][BUILD]. Don't worry,
+it's not that hard.

-# server build dependencies
-sudo apt install openjdk-8-jdk
-```
-
-##### Fedora
-
-```bash
-# enable RPM fusion free
-sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
-
-# client build dependencies
-sudo dnf install SDL2-devel ffms2-devel meson gcc make
-
-# server build dependencies
-sudo dnf install java
-```
-
-##### Arch Linux
-
-Two [AUR] packages have been created by users:
+For Arch Linux, two [AUR] packages have been created by users:

 - [`scrcpy`](https://aur.archlinux.org/packages/scrcpy/)
 - [`scrcpy-prebuiltserver`](https://aur.archlinux.org/packages/scrcpy-prebuiltserver/)

 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository

+For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].

-#### Windows
+[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
+[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
+
+
+### Windows

 For Windows, for simplicity, prebuilt archives with all the dependencies
 (including `adb`) are available:

- - [`scrcpy-win32-v1.3.zip`][direct-win32].  
-   _(SHA-256: 51a2990e631ed469a7a86ff38107d517a91d313fb3f8327eb7bc71dde40870b5)_
- - [`scrcpy-win64-v1.3.zip`][direct-win64].  
-   _(SHA-256: 0768a80d3d600d0bbcd220ca150ae88a3a58d1fe85c308a8c61f44480b711e43)_
+ - [`scrcpy-win32-v1.6.zip`][direct-win32]  
+   _(SHA-256: 4ca0c5924ab2ebf19b70f6598b2e546f65ba469a72ded2d1b213df3380fb46b1)_
+ - [`scrcpy-win64-v1.6.zip`][direct-win64]  
+   _(SHA-256: f66b7eace8dd6537a9a27176fd824704a284d8e82077ccc903344396043f90c9)_

-[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-win32-v1.3.zip
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-win64-v1.3.zip
+[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.6/scrcpy-win32-v1.6.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.6/scrcpy-win64-v1.6.zip

-Instead, you may want to build it manually.
-
-In that case, download the [platform-tools][platform-tools-windows] and extract
-the following files to a directory accessible from your `PATH`:
- - `adb.exe`
- - `AdbWinApi.dll`
- - `AdbWinUsbApi.dll`
-
-##### Cross-compile from Linux
-
-This is the preferred method (and the way the release is built).
-
-From _Debian_, install _mingw_:
-
-```bash
-sudo apt install mingw-w64 mingw-w64-tools
-```
-
-You also need the JDK to build the server:
-
-```bash
-sudo apt install openjdk-8-jdk
-```
-
-Then generate the releases:
-
-```bash
-make -f Makefile.CrossWindows
-```
-
-It will generate win32 and win64 releases into `dist/`.
+You can also [build the app manually][BUILD].


-##### In MSYS2
-
-From Windows, you need [MSYS2] to build the project. From an MSYS2 terminal,
-install the required packages:
-
-[MSYS2]: http://www.msys2.org/
-
-```bash
-# runtime dependencies
-pacman -S mingw-w64-x86_64-SDL2 \
-          mingw-w64-x86_64-ffmpeg
-
-# client build dependencies
-pacman -S mingw-w64-x86_64-make \
-          mingw-w64-x86_64-gcc \
-          mingw-w64-x86_64-pkg-config \
-          mingw-w64-x86_64-meson
-```
-
-For a 32 bits version, replace `x86_64` by `i686`:
-
-```bash
-# runtime dependencies
-pacman -S mingw-w64-i686-SDL2 \
-          mingw-w64-i686-ffmpeg
-
-# client build dependencies
-pacman -S mingw-w64-i686-make \
-          mingw-w64-i686-gcc \
-          mingw-w64-i686-pkg-config \
-          mingw-w64-i686-meson
-```
-
-Java (>= 7) is not available in MSYS2, so if you plan to build the server,
-install it manually and make it available from the `PATH`:
-
-```bash
-export PATH="$JAVA_HOME/bin:$PATH"
-```
-
-#### Mac OS
+### Mac OS

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

@ -170,106 +68,18 @@ The application is available in [Homebrew]. Just install it:
 brew install scrcpy
 ```

-Instead, you may want to build it manually. Install the packages:
-
+You need `adb`, accessible from your `PATH`. If you don't have it yet:

 ```bash
-# runtime dependencies
-brew install sdl2 ffmpeg
-
-# client build dependencies
-brew install pkg-config meson
+brew cask install android-platform-tools
 ```

-Additionally, if you want to build the server, install Java 8 from Caskroom, and
-make it avaliable from the `PATH`:
+You can also [build the app manually][BUILD].

-```bash
-brew tap caskroom/versions
-brew cask install java8
-export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
-export PATH="$JAVA_HOME/bin:$PATH"
-```
-
-#### Docker
-
-See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).
-
-### Common steps
-
-Install the [Android SDK] (_Android Studio_), and set `ANDROID_HOME` to
-its directory. For example:
-
-[Android SDK]: https://developer.android.com/studio/index.html
-
-```bash
-export ANDROID_HOME=~/android/sdk
-```
-
-Clone the project:
-
-```bash
-git clone https://github.com/Genymobile/scrcpy
-cd scrcpy
-```
-
-Then, build:
-
-```bash
-meson x --buildtype release --strip -Db_lto=true
-cd x
-ninja
-```
-
-You can test it from here:
-
-```bash
-ninja run
-```
-
-Or you can install it on the system:
-
-```bash
-sudo ninja install    # without sudo on Windows
-```
-
-This installs two files:
-
- - `/usr/local/bin/scrcpy`
- - `/usr/local/share/scrcpy/scrcpy-server.jar`
-
-Just remove them to "uninstall" the application.
-
-
-#### Prebuilt server
-
-Since the server binary, that will be pushed to the Android device, does not
-depend on your system and architecture, you may want to use the prebuilt binary
-instead:
-
- - [`scrcpy-server-v1.3.jar`][direct-scrcpy-server].  
-   _(SHA-256: 0f9a5a217f33f0ed7a1498ceb3c0cccf31c53533893aa952e674c1571d2740c1)_
-
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-server-v1.3.jar
-
-In that case, the build does not require Java or the Android SDK.
-
-Download the prebuilt server somewhere, and specify its path during the Meson
-configuration:
-
-```bash
-meson x --buildtype release --strip -Db_lto=true \
-    -Dprebuilt_server=/path/to/scrcpy-server.jar
-cd x
-ninja
-sudo ninja install
-```

 ## Run

-_At runtime, `adb` must be accessible from your `PATH`._
-
-If everything is ok, just plug an Android device, and execute:
+Plug an Android device, and execute:

 ```bash
 scrcpy
@ -281,50 +91,165 @@ It accepts command-line arguments, listed by:
 scrcpy --help
 ```

-For example, to decrease video bitrate to 2Mbps (default is 8Mbps):
+## Features
+
+
+### Reduce size
+
+Sometimes, it is useful to mirror an Android device at a lower definition to
+increase performances.
+
+To limit both width and height to some value (e.g. 1024):

 ```bash
-scrcpy -b 2M
+scrcpy --max-size 1024
+scrcpy -m 1024  # short version
 ```

-To limit the video dimensions (e.g. if the device is 2540×1440, but the host
-screen is smaller, or cannot decode such a high definition):
+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):

 ```bash
-scrcpy -m 1024
+scrcpy --bit-rate 2M
+scrcpy -b 2M  # short version
 ```

-The device screen may be cropped to mirror only part of the screen:
+
+### Crop
+
+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:

 ```bash
-scrcpy -c 1224:1440:0:0   # 1224x1440 at offset (0,0)
+scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
+scrcpy -c 1224:1440:0:0       # short version
 ```

+If `--max-size` is also specified, resizing is applied after cropping.
+
+
+### Wireless
+
+_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
+device over TCP/IP:
+
+1. Connect the device to the same Wi-Fi as your computer.
+2. Get your device IP address (in Settings → About phone → Status).
+3. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
+4. Unplug your device.
+5. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`)_.
+6. Run `scrcpy` as usual.
+
+It may be useful to decrease the bit-rate and the definition:
+
+```bash
+scrcpy --bit-rate 2M --max-size 800
+scrcpy -b2M -m800  # short version
+```
+
+[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
+
+
+### Record screen
+
+It is possible to record the screen while mirroring:
+
+```bash
+scrcpy --record file.mp4
+scrcpy -r file.mp4
+```
+
+"Skipped frames" are recorded, even if they are not displayed in real time (for
+performance reasons). Frames are _timestamped_ on the device, so [packet delay
+variation] does not impact the recorded file.
+
+[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
+
+
+### Multi-devices
+
 If several devices are listed in `adb devices`, you must specify the _serial_:

 ```bash
-scrcpy -s 0123456789abcdef
+scrcpy --serial 0123456789abcdef
+scrcpy -s 0123456789abcdef  # short version
 ```

-To show physical touches while scrcpy is running:
+You can start several instances of _scrcpy_ for several devices.

-```bash
-scrcpy -t
-```
+
+### Fullscreen

 The app may be started directly in fullscreen:

-```
-scrcpy -f
+```bash
+scrcpy --fullscreen
+scrcpy -f  # short version
 ```

-To run without installing:
+Fullscreen can then be toggled dynamically with `Ctrl`+`f`.
+
+
+### Always on top
+
+The window of app can always be above others by:

 ```bash
-./run x [options]
+scrcpy --always-on-top
+scrcpy -T  # short version
 ```

-(where `x` is your build directory).
+
+### Show touches
+
+For presentations, it may be useful to show physical touches (on the physical
+device).
+
+Android provides this feature in _Developers options_.
+
+_Scrcpy_ provides an option to enable this feature on start and disable on exit:
+
+```bash
+scrcpy --show-touches
+scrcpy -t
+```
+
+Note that it only shows _physical_ touches (with the finger on the device).
+
+
+### Install APK
+
+To install an APK, drag & drop an APK file (ending with `.apk`) to the _scrcpy_
+window.
+
+There is no visual feedback, a log is printed to the console.
+
+
+### Push file to device
+
+To push a file to `/sdcard/` on the device, drag & drop a (non-APK) file to the
+_scrcpy_ window.
+
+There is no visual feedback, a log is printed to the console.
+
+
+### Forward audio
+
+Audio is not forwarded by _scrcpy_.
+
+There is a limited solution using [AOA], implemented in the [`audio`] branch. If
+you are interested, 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


 ## Shortcuts
@ -338,14 +263,12 @@ To run without installing:
 | click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  |
 | click on `APP_SWITCH`                  | `Ctrl`+`s`                    |
 | click on `MENU`                        | `Ctrl`+`m`                    |
- | click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_             |
- | click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_           |
+ | click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_   (`Cmd`+`↑` on MacOS) |
+ | click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_ (`Cmd`+`↓` on MacOS) |
 | click on `POWER`                       | `Ctrl`+`p`                    |
 | turn screen on                         | _Right-click²_                |
 | paste computer clipboard to device     | `Ctrl`+`v`                    |
 | enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    |
- | install APK from computer              | drag & drop APK file          |
- | push file to `/sdcard/`                | drag & drop non-APK file      |

 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._
@ -361,6 +284,13 @@ A colleague challenged me to find a name as unpronounceable as [gnirehtet].
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html


+## How to build?
+
+See [BUILD].
+
+[BUILD]: BUILD.md
+
+
 ## Common issues

 See the [FAQ](FAQ.md).
--- a/app/meson.build
+++ b/app/meson.build
@ -12,6 +12,7 @@ src = [
    'src/input_manager.c',
    'src/lock_util.c',
    'src/net.c',
+    'src/recorder.c',
    'src/scrcpy.c',
    'src/screen.c',
    'src/server.c',
@ -85,7 +86,7 @@ conf = configuration_data()
 conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')

 # the version, updated on release
-conf.set_quoted('SCRCPY_VERSION', '1.3')
+conf.set_quoted('SCRCPY_VERSION', meson.project_version())

 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))
--- a/app/src/buffer_util.h
+++ b/app/src/buffer_util.h
@ -0,0 +1,28 @@
+#ifndef BUFFER_UTIL_H
+#define BUFFER_UTIL_H
+
+#include <SDL2/SDL_stdinc.h>
+
+static inline void buffer_write16be(Uint8 *buf, Uint16 value) {
+    buf[0] = value >> 8;
+    buf[1] = value;
+}
+
+static inline void buffer_write32be(Uint8 *buf, Uint32 value) {
+    buf[0] = value >> 24;
+    buf[1] = value >> 16;
+    buf[2] = value >> 8;
+    buf[3] = value;
+}
+
+static inline Uint32 buffer_read32be(Uint8 *buf) {
+    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+}
+
+static inline Uint64 buffer_read64be(Uint8 *buf) {
+    Uint32 msb = buffer_read32be(buf);
+    Uint32 lsb = buffer_read32be(&buf[4]);
+    return ((Uint64) msb << 32) | lsb;
+}
+
+#endif
--- a/app/src/command.c
+++ b/app/src/command.c
@ -6,10 +6,11 @@

 #include "common.h"
 #include "log.h"
+#include "str_util.h"

 static const char *adb_command;

-static inline const char *get_adb_command() {
+static inline const char *get_adb_command(void) {
    if (!adb_command) {
        adb_command = getenv("ADB");
        if (!adb_command)
@ -89,28 +90,49 @@ process_t adb_reverse_remove(const char *serial, const char *device_socket_name)
 }

 process_t adb_push(const char *serial, const char *local, const char *remote) {
+#ifdef __WINDOWS__
+    // Windows will parse the string, so the paths must be quoted
+    // (see sys/win/command.c)
+    local = strquote(local);
+    if (!local) {
+        return PROCESS_NONE;
+    }
+    remote = strquote(remote);
+    if (!remote) {
+        free((void *) local);
+        return PROCESS_NONE;
+    }
+#endif
+
    const char *const adb_cmd[] = {"push", local, remote};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+
+#ifdef __WINDOWS__
+    free((void *) remote);
+    free((void *) local);
+#endif
+
+    return proc;
 }

 process_t adb_install(const char *serial, const char *local) {
 #ifdef __WINDOWS__
-    // Windows will parse the string, so the local name must be quoted (see sys/win/command.c)
-    size_t len = strlen(local);
-    char quoted[len + 3];
-    memcpy(&quoted[1], local, len);
-    quoted[0] = '"';
-    quoted[len + 1] = '"';
-    quoted[len + 2] = '\0';
-    local = quoted;
+    // Windows will parse the string, so the local name must be quoted
+    // (see sys/win/command.c)
+    local = strquote(local);
+    if (!local) {
+        return PROCESS_NONE;
+    }
 #endif
-    const char *const adb_cmd[] = {"install", "-r", local};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
-}

-process_t adb_remove_path(const char *serial, const char *path) {
-    const char *const adb_cmd[] = {"shell", "rm", path};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    const char *const adb_cmd[] = {"install", "-r", local};
+    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+
+#ifdef __WINDOWS__
+    free((void *) local);
+#endif
+
+    return proc;
 }

 SDL_bool process_check_success(process_t proc, const char *name) {
--- a/app/src/command.h
+++ b/app/src/command.h
@ -49,7 +49,6 @@ process_t adb_reverse(const char *serial, const char *device_socket_name, uint16
 process_t adb_reverse_remove(const char *serial, const char *device_socket_name);
 process_t adb_push(const char *serial, const char *local, const char *remote);
 process_t adb_install(const char *serial, const char *local);
-process_t adb_remove_path(const char *serial, const char *path);

 // convenience function to wait for a successful process execution
 // automatically log process errors with the provided process name
--- a/app/src/common.h
+++ b/app/src/common.h
@ -13,8 +13,8 @@ struct size {
 };

 struct point {
-    Uint16 x;
-    Uint16 y;
+    Sint32 x;
+    Sint32 y;
 };

 struct position {
--- a/app/src/control_event.c
+++ b/app/src/control_event.c
@ -3,26 +3,15 @@
 #include <SDL2/SDL_stdinc.h>
 #include <string.h>

+#include "buffer_util.h"
 #include "lock_util.h"
 #include "log.h"

-static inline void write16(Uint8 *buf, Uint16 value) {
-    buf[0] = value >> 8;
-    buf[1] = value;
-}
-
-static inline void write32(Uint8 *buf, Uint32 value) {
-    buf[0] = value >> 24;
-    buf[1] = value >> 16;
-    buf[2] = value >> 8;
-    buf[3] = value;
-}
-
 static void write_position(Uint8 *buf, const struct position *position) {
-    write16(&buf[0], position->point.x);
-    write16(&buf[2], position->point.y);
-    write16(&buf[4], position->screen_size.width);
-    write16(&buf[6], position->screen_size.height);
+    buffer_write32be(&buf[0], position->point.x);
+    buffer_write32be(&buf[4], position->point.y);
+    buffer_write16be(&buf[8], position->screen_size.width);
+    buffer_write16be(&buf[10], position->screen_size.height);
 }

 int control_event_serialize(const struct control_event *event, unsigned char *buf) {
@ -30,30 +19,30 @@ int control_event_serialize(const struct control_event *event, unsigned char *bu
    switch (event->type) {
        case CONTROL_EVENT_TYPE_KEYCODE:
            buf[1] = event->keycode_event.action;
-            write32(&buf[2], event->keycode_event.keycode);
-            write32(&buf[6], event->keycode_event.metastate);
+            buffer_write32be(&buf[2], event->keycode_event.keycode);
+            buffer_write32be(&buf[6], event->keycode_event.metastate);
            return 10;
        case CONTROL_EVENT_TYPE_TEXT: {
-            // write length (1 byte) + date (non nul-terminated)
+            // write length (2 bytes) + string (non nul-terminated)
            size_t len = strlen(event->text_event.text);
            if (len > TEXT_MAX_LENGTH) {
                // injecting a text takes time, so limit the text length
                len = TEXT_MAX_LENGTH;
            }
-            write16(&buf[1], (Uint16) len);
+            buffer_write16be(&buf[1], (Uint16) len);
            memcpy(&buf[3], event->text_event.text, len);
            return 3 + len;
        }
        case CONTROL_EVENT_TYPE_MOUSE:
            buf[1] = event->mouse_event.action;
-            write32(&buf[2], event->mouse_event.buttons);
+            buffer_write32be(&buf[2], event->mouse_event.buttons);
            write_position(&buf[6], &event->mouse_event.position);
-            return 14;
+            return 18;
        case CONTROL_EVENT_TYPE_SCROLL:
            write_position(&buf[1], &event->scroll_event.position);
-            write32(&buf[9], (Uint32) event->scroll_event.hscroll);
-            write32(&buf[13], (Uint32) event->scroll_event.vscroll);
-            return 17;
+            buffer_write32be(&buf[13], (Uint32) event->scroll_event.hscroll);
+            buffer_write32be(&buf[17], (Uint32) event->scroll_event.vscroll);
+            return 21;
        case CONTROL_EVENT_TYPE_COMMAND:
            buf[1] = event->command_event.action;
            return 2;
--- a/app/src/convert.c
+++ b/app/src/convert.c
@ -70,7 +70,7 @@ static enum android_metastate convert_meta_state(SDL_Keymod mod) {
    return autocomplete_metastate(metastate);
 }

-static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to) {
+static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to, Uint16 mod) {
    switch (from) {
        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
@ -86,6 +86,39 @@ static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to) {
        MAP(SDLK_LEFT,         AKEYCODE_DPAD_LEFT);
        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
+    }
+    if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
+        return SDL_FALSE;
+    }
+    // if ALT and META are not pressed, also handle letters and space
+    switch (from) {
+        MAP(SDLK_a,            AKEYCODE_A);
+        MAP(SDLK_b,            AKEYCODE_B);
+        MAP(SDLK_c,            AKEYCODE_C);
+        MAP(SDLK_d,            AKEYCODE_D);
+        MAP(SDLK_e,            AKEYCODE_E);
+        MAP(SDLK_f,            AKEYCODE_F);
+        MAP(SDLK_g,            AKEYCODE_G);
+        MAP(SDLK_h,            AKEYCODE_H);
+        MAP(SDLK_i,            AKEYCODE_I);
+        MAP(SDLK_j,            AKEYCODE_J);
+        MAP(SDLK_k,            AKEYCODE_K);
+        MAP(SDLK_l,            AKEYCODE_L);
+        MAP(SDLK_m,            AKEYCODE_M);
+        MAP(SDLK_n,            AKEYCODE_N);
+        MAP(SDLK_o,            AKEYCODE_O);
+        MAP(SDLK_p,            AKEYCODE_P);
+        MAP(SDLK_q,            AKEYCODE_Q);
+        MAP(SDLK_r,            AKEYCODE_R);
+        MAP(SDLK_s,            AKEYCODE_S);
+        MAP(SDLK_t,            AKEYCODE_T);
+        MAP(SDLK_u,            AKEYCODE_U);
+        MAP(SDLK_v,            AKEYCODE_V);
+        MAP(SDLK_w,            AKEYCODE_W);
+        MAP(SDLK_x,            AKEYCODE_X);
+        MAP(SDLK_y,            AKEYCODE_Y);
+        MAP(SDLK_z,            AKEYCODE_Z);
+        MAP(SDLK_SPACE,        AKEYCODE_SPACE);
        FAIL;
    }
 }
@ -126,11 +159,12 @@ SDL_bool input_key_from_sdl_to_android(const SDL_KeyboardEvent *from,
        return SDL_FALSE;
    }

-    if (!convert_keycode(from->keysym.sym, &to->keycode_event.keycode)) {
+    Uint16 mod = from->keysym.mod;
+    if (!convert_keycode(from->keysym.sym, &to->keycode_event.keycode, mod)) {
        return SDL_FALSE;
    }

-    to->keycode_event.metastate = convert_meta_state(from->keysym.mod);
+    to->keycode_event.metastate = convert_meta_state(mod);

    return SDL_TRUE;
 }
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@ -1,22 +1,134 @@
 #include "decoder.h"

 #include <libavformat/avformat.h>
+#include <libavutil/time.h>
+#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
 #include <unistd.h>

 #include "config.h"
+#include "buffer_util.h"
 #include "events.h"
 #include "frames.h"
 #include "lock_util.h"
 #include "log.h"
+#include "recorder.h"

 #define BUFSIZE 0x10000

-static int read_packet(void *opaque, uint8_t *buf, int buf_size) {
+#define HEADER_SIZE 12
+#define NO_PTS UINT64_C(-1)
+
+static struct frame_meta *frame_meta_new(uint64_t pts) {
+    struct frame_meta *meta = 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) {
+    free(frame_meta);
+}
+
+static SDL_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 SDL_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 SDL_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 decoder *decoder = opaque;
-    return net_recv(decoder->video_socket, buf, buf_size);
+    struct receiver_state *state = &decoder->receiver_state;
+
+    // The video stream contains raw packets, without time information. When we
+    // record, we retrieve the timestamps separately, from a "meta" header
+    // added by the server before each raw packet.
+    //
+    // The "meta" header length is 12 bytes:
+    // [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
+    //  <-------------> <-----> <-----------------------------...
+    //        PTS        packet        raw packet
+    //                    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(decoder->video_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);
+        }
+    }
+
+    SDL_assert(state->remaining);
+
+    if (buf_size > state->remaining)
+        buf_size = state->remaining;
+
+    ssize_t r = net_recv(decoder->video_socket, buf, buf_size);
+    if (r == -1) {
+        return AVERROR(errno);
+    }
+    if (r == 0) {
+        return AVERROR_EOF;
+    }
+
+    SDL_assert(state->remaining >= r);
+    state->remaining -= r;
+
+    return r;
+}
+
+static int read_raw_packet(void *opaque, uint8_t *buf, int buf_size) {
+    struct decoder *decoder = opaque;
+    ssize_t r = net_recv(decoder->video_socket, buf, buf_size);
+    if (r == -1) {
+        return AVERROR(errno);
+    }
+    if (r == 0) {
+        return AVERROR_EOF;
+    }
+    return r;
 }

 // set the decoded frame as ready for rendering, and notify
@ -70,7 +182,15 @@ static int run_decoder(void *data) {
        goto run_finally_free_format_ctx;
    }

-    AVIOContext *avio_ctx = avio_alloc_context(buffer, BUFSIZE, 0, decoder, read_packet, NULL, NULL);
+    // initialize the receiver state
+    decoder->receiver_state.frame_meta_queue = NULL;
+    decoder->receiver_state.remaining = 0;
+
+    // if recording is enabled, a "header" is sent between raw packets
+    int (*read_packet)(void *, uint8_t *, int) =
+            decoder->recorder ? read_packet_with_meta : read_raw_packet;
+    AVIOContext *avio_ctx = avio_alloc_context(buffer, BUFSIZE, 0, decoder,
+                                               read_packet, NULL, NULL);
    if (!avio_ctx) {
        LOGC("Could not allocate avio context");
        // avformat_open_input takes ownership of 'buffer'
@ -86,6 +206,12 @@ static int run_decoder(void *data) {
        goto run_finally_free_avio_ctx;
    }

+    if (decoder->recorder &&
+            !recorder_open(decoder->recorder, codec)) {
+        LOGE("Could not open recorder");
+        goto run_finally_close_input;
+    }
+
    AVPacket packet;
    av_init_packet(&packet);
    packet.data = NULL;
@ -115,6 +241,7 @@ static int run_decoder(void *data) {
            int len = avcodec_decode_video2(codec_ctx, decoder->frames->decoding_frame, &got_picture, &packet);
            if (len < 0) {
                LOGE("Could not decode video packet: %d", len);
+                av_packet_unref(&packet);
                goto run_quit;
            }
            if (got_picture) {
@ -124,6 +251,23 @@ static int run_decoder(void *data) {
            packet.data += len;
        }
 #endif
+
+        if (decoder->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(&decoder->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(decoder->recorder, &packet)) {
+                LOGE("Could not write frame to output file");
+                av_packet_unref(&packet);
+                goto run_quit;
+            }
+        }
+
        av_packet_unref(&packet);

        if (avio_ctx->eof_reached) {
@ -134,9 +278,14 @@ static int run_decoder(void *data) {
    LOGD("End of frames");

 run_quit:
+    if (decoder->recorder) {
+        recorder_close(decoder->recorder);
+    }
+run_finally_close_input:
    avformat_close_input(&format_ctx);
 run_finally_free_avio_ctx:
-    av_freep(&avio_ctx);
+    av_free(avio_ctx->buffer);
+    av_free(avio_ctx);
 run_finally_free_format_ctx:
    avformat_free_context(format_ctx);
 run_finally_close_codec:
@ -148,9 +297,11 @@ run_end:
    return 0;
 }

-void decoder_init(struct decoder *decoder, struct frames *frames, socket_t video_socket) {
+void decoder_init(struct decoder *decoder, struct frames *frames,
+                  socket_t video_socket, struct recorder *recorder) {
    decoder->frames = frames;
    decoder->video_socket = video_socket;
+    decoder->recorder = recorder;
 }

 SDL_bool decoder_start(struct decoder *decoder) {
@ -161,7 +312,6 @@ SDL_bool decoder_start(struct decoder *decoder) {
        LOGC("Could not start decoder thread");
        return SDL_FALSE;
    }
-
    return SDL_TRUE;
 }

--- a/app/src/decoder.h
+++ b/app/src/decoder.h
@ -4,18 +4,31 @@
 #include <SDL2/SDL_stdinc.h>
 #include <SDL2/SDL_thread.h>

+#include "common.h"
 #include "net.h"

 struct frames;

+struct frame_meta {
+    uint64_t pts;
+    struct frame_meta *next;
+};
+
 struct decoder {
    struct frames *frames;
    socket_t video_socket;
    SDL_Thread *thread;
    SDL_mutex *mutex;
+    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;
 };

-void decoder_init(struct decoder *decoder, struct frames *frames, socket_t video_socket);
+void decoder_init(struct decoder *decoder, struct frames *frames,
+                  socket_t video_socket, struct recorder *recoder);
 SDL_bool decoder_start(struct decoder *decoder);
 void decoder_stop(struct decoder *decoder);
 void decoder_join(struct decoder *decoder);
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -1,5 +1,6 @@
 #include "input_manager.h"

+#include <SDL2/SDL_assert.h>
 #include "convert.h"
 #include "lock_util.h"
 #include "log.h"
@ -22,10 +23,9 @@ static struct point get_mouse_point(struct screen *screen) {
    int y;
    SDL_GetMouseState(&x, &y);
    convert_to_renderer_coordinates(screen->renderer, &x, &y);
-    SDL_assert_release(x >= 0 && x < 0x10000 && y >= 0 && y < 0x10000);
    return (struct point) {
-        .x = (Uint16) x,
-        .y = (Uint16) y,
+        .x = x,
+        .y = y,
    };
 }

@ -129,6 +129,12 @@ static void clipboard_paste(struct controller *controller) {

 void input_manager_process_text_input(struct input_manager *input_manager,
                                      const SDL_TextInputEvent *event) {
+    char c = event->text[0];
+    if (isalpha(c) || c == ' ') {
+        SDL_assert(event->text[1] == '\0');
+        // letters and space are handled as raw key event
+        return;
+    }
    struct control_event control_event;
    control_event.type = CONTROL_EVENT_TYPE_TEXT;
    control_event.text_event.text = SDL_strdup(event->text);
@ -137,6 +143,7 @@ void input_manager_process_text_input(struct input_manager *input_manager,
        return;
    }
    if (!controller_push_event(input_manager->controller, &control_event)) {
+        SDL_free(control_event.text_event.text);
        LOGW("Cannot send text event");
    }
 }
@ -144,9 +151,17 @@ void input_manager_process_text_input(struct input_manager *input_manager,
 void input_manager_process_key(struct input_manager *input_manager,
                               const SDL_KeyboardEvent *event) {
    SDL_bool ctrl = event->keysym.mod & (KMOD_LCTRL | KMOD_RCTRL);
+    SDL_bool alt = event->keysym.mod & (KMOD_LALT | KMOD_RALT);
+    SDL_bool meta = event->keysym.mod & (KMOD_LGUI | KMOD_RGUI);
+
+    if (alt) {
+        // no shortcut involves Alt or Meta, and they should not be forwarded
+        // to the device
+        return;
+    }

    // capture all Ctrl events
-    if (ctrl) {
+    if (ctrl | meta) {
        SDL_bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
        if (shift) {
            // currently, there is no shortcut involving SHIFT
@ -158,61 +173,73 @@ void input_manager_process_key(struct input_manager *input_manager,
        SDL_bool repeat = event->repeat;
        switch (keycode) {
            case SDLK_h:
-                if (!repeat) {
+                if (ctrl && !meta && !repeat) {
                    action_home(input_manager->controller, action);
                }
                return;
            case SDLK_b: // fall-through
            case SDLK_BACKSPACE:
-                if (!repeat) {
+                if (ctrl && !meta && !repeat) {
                    action_back(input_manager->controller, action);
                }
                return;
            case SDLK_s:
-                if (!repeat) {
+                if (ctrl && !meta && !repeat) {
                    action_app_switch(input_manager->controller, action);
                }
                return;
            case SDLK_m:
-                if (!repeat) {
+                if (ctrl && !meta && !repeat) {
                    action_menu(input_manager->controller, action);
                }
                return;
            case SDLK_p:
-                if (!repeat) {
+                if (ctrl && !meta && !repeat) {
                    action_power(input_manager->controller, action);
                }
                return;
            case SDLK_DOWN:
-                // forward repeated events
-                action_volume_down(input_manager->controller, action);
+#ifdef __APPLE__
+                if (!ctrl && meta) {
+#else
+                if (ctrl && !meta) {
+#endif
+                    // forward repeated events
+                    action_volume_down(input_manager->controller, action);
+                }
                return;
            case SDLK_UP:
-                // forward repeated events
-                action_volume_up(input_manager->controller, action);
+#ifdef __APPLE__
+                if (!ctrl && meta) {
+#else
+                if (ctrl && !meta) {
+#endif
+                    // forward repeated events
+                    action_volume_up(input_manager->controller, action);
+                }
                return;
            case SDLK_v:
-                if (!repeat && event->type == SDL_KEYDOWN) {
+                if (ctrl && !meta && !repeat && event->type == SDL_KEYDOWN) {
                    clipboard_paste(input_manager->controller);
                }
                return;
            case SDLK_f:
-                if (!repeat && event->type == SDL_KEYDOWN) {
+                if (ctrl && !meta && !repeat && event->type == SDL_KEYDOWN) {
                    screen_switch_fullscreen(input_manager->screen);
                }
                return;
            case SDLK_x:
-                if (!repeat && event->type == SDL_KEYDOWN) {
+                if (ctrl && !meta && !repeat && event->type == SDL_KEYDOWN) {
                    screen_resize_to_fit(input_manager->screen);
                }
                return;
            case SDLK_g:
-                if (!repeat && event->type == SDL_KEYDOWN) {
+                if (ctrl && !meta && !repeat && event->type == SDL_KEYDOWN) {
                    screen_resize_to_pixel_perfect(input_manager->screen);
                }
                return;
            case SDLK_i:
-                if (!repeat && event->type == SDL_KEYDOWN) {
+                if (ctrl && !meta && !repeat && event->type == SDL_KEYDOWN) {
                    switch_fps_counter_state(input_manager->frames);
                }
                return;
@ -243,6 +270,13 @@ void input_manager_process_mouse_motion(struct input_manager *input_manager,
    }
 }

+static SDL_bool is_outside_device_screen(struct input_manager *input_manager,
+                                         int x, int y)
+{
+    return x < 0 || x >= input_manager->screen->frame_size.width ||
+           y < 0 || y >= input_manager->screen->frame_size.height;
+}
+
 void input_manager_process_mouse_button(struct input_manager *input_manager,
                                        const SDL_MouseButtonEvent *event) {
    if (event->type == SDL_MOUSEBUTTONDOWN) {
@ -256,16 +290,17 @@ void input_manager_process_mouse_button(struct input_manager *input_manager,
        }
        // double-click on black borders resize to fit the device screen
        if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
-            SDL_bool outside_device_screen =
-                    event->x < 0 || event->x >= input_manager->screen->frame_size.width ||
-                    event->y < 0 || event->y >= input_manager->screen->frame_size.height;
-            if (outside_device_screen) {
+            SDL_bool outside= is_outside_device_screen(input_manager,
+                                                       event->x,
+                                                       event->y);
+            if (outside) {
                screen_resize_to_fit(input_manager->screen);
                return;
            }
-            // otherwise, send the click event to the device
        }
+        // otherwise, send the click event to the device
    }
+
    struct control_event control_event;
    if (mouse_button_from_sdl_to_android(event, input_manager->screen->frame_size, &control_event)) {
        if (!controller_push_event(input_manager->controller, &control_event)) {
--- a/app/src/log.h
+++ b/app/src/log.h
@ -3,6 +3,7 @@

 #include <SDL2/SDL_log.h>

+#define LOGV(...) SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGI(...) SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGW(...) SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
--- a/app/src/main.c
+++ b/app/src/main.c
@ -11,6 +11,7 @@
 struct args {
    const char *serial;
    const char *crop;
+    const char *record_filename;
    SDL_bool fullscreen;
    SDL_bool help;
    SDL_bool version;
@ -18,6 +19,7 @@ struct args {
    Uint16 port;
    Uint16 max_size;
    Uint32 bit_rate;
+    SDL_bool always_on_top;
 };

 static void usage(const char *arg0) {
@ -53,6 +55,9 @@ static void usage(const char *arg0) {
        "        Set the TCP port the client listens on.\n"
        "        Default is %d.\n"
        "\n"
+        "    -r, --record file.mp4\n"
+        "        Record screen to file.\n"
+        "\n"
        "    -s, --serial\n"
        "        The device serial number. Mandatory only if several devices\n"
        "        are connected to adb.\n"
@ -61,6 +66,9 @@ static void usage(const char *arg0) {
        "        Enable \"show touches\" on start, disable on quit.\n"
        "        It only shows physical touches (not clicks from scrcpy).\n"
        "\n"
+        "    -T, --always-on-top\n"
+        "        Make scrcpy window always on top (above other windows).\n"
+        "\n"
        "    -v, --version\n"
        "        Print the version of scrcpy.\n"
        "\n"
@ -120,7 +128,7 @@ static void usage(const char *arg0) {
 }

 static void print_version(void) {
-    fprintf(stderr, "scrcpy v%s\n\n", SCRCPY_VERSION);
+    fprintf(stderr, "scrcpy %s\n\n", SCRCPY_VERSION);

    fprintf(stderr, "dependencies:\n");
    fprintf(stderr, " - SDL %d.%d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
@ -202,19 +210,21 @@ static SDL_bool parse_port(char *optarg, Uint16 *port) {

 static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
    static const struct option long_options[] = {
-        {"bit-rate",     required_argument, NULL, 'b'},
-        {"crop",         required_argument, NULL, 'c'},
-        {"fullscreen",   no_argument,       NULL, 'f'},
-        {"help",         no_argument,       NULL, 'h'},
-        {"max-size",     required_argument, NULL, 'm'},
-        {"port",         required_argument, NULL, 'p'},
-        {"serial",       required_argument, NULL, 's'},
-        {"show-touches", no_argument,       NULL, 't'},
-        {"version",      no_argument,       NULL, 'v'},
-        {NULL,           0,                 NULL, 0  },
+        {"always-on-top", no_argument,       NULL, 'T'},
+        {"bit-rate",      required_argument, NULL, 'b'},
+        {"crop",          required_argument, NULL, 'c'},
+        {"fullscreen",    no_argument,       NULL, 'f'},
+        {"help",          no_argument,       NULL, 'h'},
+        {"max-size",      required_argument, NULL, 'm'},
+        {"port",          required_argument, NULL, 'p'},
+        {"record",        required_argument, NULL, 'r'},
+        {"serial",        required_argument, NULL, 's'},
+        {"show-touches",  no_argument,       NULL, 't'},
+        {"version",       no_argument,       NULL, 'v'},
+        {NULL,            0,                 NULL, 0  },
    };
    int c;
-    while ((c = getopt_long(argc, argv, "b:c:fhm:p:s:tv", long_options, NULL)) != -1) {
+    while ((c = getopt_long(argc, argv, "b:c:fhm:p:r:s:tTv", long_options, NULL)) != -1) {
        switch (c) {
            case 'b':
                if (!parse_bit_rate(optarg, &args->bit_rate)) {
@ -240,12 +250,18 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
                    return SDL_FALSE;
                }
                break;
+            case 'r':
+                args->record_filename = optarg;
+                break;
            case 's':
                args->serial = optarg;
                break;
            case 't':
                args->show_touches = SDL_TRUE;
                break;
+            case 'T':
+                args->always_on_top = SDL_TRUE;
+                break;
            case 'v':
                args->version = SDL_TRUE;
                break;
@ -273,12 +289,14 @@ int main(int argc, char *argv[]) {
    struct args args = {
        .serial = NULL,
        .crop = NULL,
+        .record_filename = NULL,
        .help = SDL_FALSE,
        .version = SDL_FALSE,
        .show_touches = SDL_FALSE,
        .port = DEFAULT_LOCAL_PORT,
        .max_size = DEFAULT_MAX_SIZE,
        .bit_rate = DEFAULT_BIT_RATE,
+        .always_on_top = SDL_FALSE,
    };
    if (!parse_args(&args, argc, argv)) {
        return 1;
@ -310,14 +328,22 @@ int main(int argc, char *argv[]) {
        .serial = args.serial,
        .crop = args.crop,
        .port = args.port,
+        .record_filename = args.record_filename,
        .max_size = args.max_size,
        .bit_rate = args.bit_rate,
        .show_touches = args.show_touches,
        .fullscreen = args.fullscreen,
+        .always_on_top = args.always_on_top,
    };
    int res = scrcpy(&options) ? 0 : 1;

    avformat_network_deinit(); // ignore failure

+#if defined (__WINDOWS__) && ! defined (WINDOWS_NOCONSOLE)
+    if (res != 0) {
+        fprintf(stderr, "Press any key to continue...\n");
+        getchar();
+    }
+#endif
    return res;
 }
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@ -0,0 +1,155 @@
+#include "recorder.h"
+
+#include <libavutil/time.h>
+
+#include "config.h"
+#include "log.h"
+
+// In ffmpeg/doc/APIchanges:
+// 2016-04-11 - 6f69f7a / 9200514 - lavf 57.33.100 / 57.5.0 - avformat.h
+//   Add AVStream.codecpar, deprecate AVStream.codec.
+#if    (LIBAVFORMAT_VERSION_MICRO >= 100 /* FFmpeg */ && \
+        LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 33, 100)) \
+    || (LIBAVFORMAT_VERSION_MICRO < 100 && /* Libav */ \
+        LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 5, 0))
+# define LAVF_NEW_CODEC_API
+#endif
+
+static const AVOutputFormat *find_mp4_muxer(void) {
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 9, 100)
+    void *opaque = NULL;
+#endif
+    const AVOutputFormat *oformat = NULL;
+    do {
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 9, 100)
+        oformat = av_muxer_iterate(&opaque);
+#else
+        oformat = av_oformat_next(oformat);
+#endif
+        // until null or with name "mp4"
+    } while (oformat && strcmp(oformat->name, "mp4"));
+    return oformat;
+}
+
+SDL_bool recorder_init(struct recorder *recorder, const char *filename,
+                       struct size declared_frame_size) {
+    recorder->filename = SDL_strdup(filename);
+    if (!recorder->filename) {
+        LOGE("Cannot strdup filename");
+        return SDL_FALSE;
+    }
+
+    recorder->declared_frame_size = declared_frame_size;
+    recorder->header_written = SDL_FALSE;
+
+    return SDL_TRUE;
+}
+
+void recorder_destroy(struct recorder *recorder) {
+    SDL_free(recorder->filename);
+}
+
+SDL_bool recorder_open(struct recorder *recorder, AVCodec *input_codec) {
+    const AVOutputFormat *mp4 = find_mp4_muxer();
+    if (!mp4) {
+        LOGE("Could not find mp4 muxer");
+        return SDL_FALSE;
+    }
+
+    recorder->ctx = avformat_alloc_context();
+    if (!recorder->ctx) {
+        LOGE("Could not allocate output context");
+        return SDL_FALSE;
+    }
+
+    // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
+    // returns (on purpose) a pointer-to-const, but AVFormatContext.oformat
+    // still expects a pointer-to-non-const (it has not be updated accordingly)
+    // <https://github.com/FFmpeg/FFmpeg/commit/0694d8702421e7aff1340038559c438b61bb30dd>
+    recorder->ctx->oformat = (AVOutputFormat *) mp4;
+
+    AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
+    if (!ostream) {
+        avformat_free_context(recorder->ctx);
+        return SDL_FALSE;
+    }
+
+#ifdef LAVF_NEW_CODEC_API
+    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
+    ostream->codecpar->codec_id = input_codec->id;
+    ostream->codecpar->format = AV_PIX_FMT_YUV420P;
+    ostream->codecpar->width = recorder->declared_frame_size.width;
+    ostream->codecpar->height = recorder->declared_frame_size.height;
+#else
+    ostream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+    ostream->codec->codec_id = input_codec->id;
+    ostream->codec->pix_fmt = AV_PIX_FMT_YUV420P;
+    ostream->codec->width = recorder->declared_frame_size.width;
+    ostream->codec->height = recorder->declared_frame_size.height;
+#endif
+    ostream->time_base = (AVRational) {1, 1000000}; // timestamps in us
+
+    int ret = avio_open(&recorder->ctx->pb, recorder->filename,
+                        AVIO_FLAG_WRITE);
+    if (ret < 0) {
+        LOGE("Failed to open output file: %s", recorder->filename);
+        // ostream will be cleaned up during context cleaning
+        avformat_free_context(recorder->ctx);
+        return SDL_FALSE;
+    }
+
+    return SDL_TRUE;
+}
+
+void recorder_close(struct recorder *recorder) {
+    int ret = av_write_trailer(recorder->ctx);
+    if (ret < 0) {
+        LOGE("Failed to write trailer to %s", recorder->filename);
+    }
+    avio_close(recorder->ctx->pb);
+    avformat_free_context(recorder->ctx);
+}
+
+SDL_bool recorder_write_header(struct recorder *recorder, AVPacket *packet) {
+    AVStream *ostream = recorder->ctx->streams[0];
+
+    uint8_t *extradata = SDL_malloc(packet->size * sizeof(uint8_t));
+    if (!extradata) {
+        LOGC("Cannot allocate extradata");
+        return SDL_FALSE;
+    }
+
+    // copy the first packet to the extra data
+    memcpy(extradata, packet->data, packet->size);
+
+#ifdef LAVF_NEW_CODEC_API
+    ostream->codecpar->extradata = extradata;
+    ostream->codecpar->extradata_size = packet->size;
+#else
+    ostream->codec->extradata = extradata;
+    ostream->codec->extradata_size = packet->size;
+#endif
+
+    int ret = avformat_write_header(recorder->ctx, NULL);
+    if (ret < 0) {
+        LOGE("Failed to write header to %s", recorder->filename);
+        SDL_free(extradata);
+        avio_closep(&recorder->ctx->pb);
+        avformat_free_context(recorder->ctx);
+        return SDL_FALSE;
+    }
+
+    return SDL_TRUE;
+}
+
+SDL_bool recorder_write(struct recorder *recorder, AVPacket *packet) {
+    if (!recorder->header_written) {
+        SDL_bool ok = recorder_write_header(recorder, packet);
+        if (!ok) {
+            return SDL_FALSE;
+        }
+        recorder->header_written = SDL_TRUE;
+    }
+
+    return av_write_frame(recorder->ctx, packet) >= 0;
+}
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@ -0,0 +1,25 @@
+#ifndef RECORDER_H
+#define RECORDER_H
+
+#include <libavformat/avformat.h>
+#include <SDL2/SDL_stdinc.h>
+
+#include "common.h"
+
+struct recorder {
+    char *filename;
+    AVFormatContext *ctx;
+    struct size declared_frame_size;
+    SDL_bool header_written;
+};
+
+SDL_bool recorder_init(struct recorder *recoder, const char *filename,
+                       struct size declared_frame_size);
+void recorder_destroy(struct recorder *recorder);
+
+SDL_bool recorder_open(struct recorder *recorder, AVCodec *input_codec);
+void recorder_close(struct recorder *recorder);
+
+SDL_bool recorder_write(struct recorder *recorder, AVPacket *packet);
+
+#endif
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -20,6 +20,7 @@
 #include "log.h"
 #include "lock_util.h"
 #include "net.h"
+#include "recorder.h"
 #include "screen.h"
 #include "server.h"
 #include "tiny_xpm.h"
@ -30,6 +31,7 @@ static struct frames frames;
 static struct decoder decoder;
 static struct controller controller;
 static struct file_handler file_handler;
+static struct recorder recorder;

 static struct input_manager input_manager = {
    .controller = &controller,
@ -137,9 +139,45 @@ static void wait_show_touches(process_t process) {
    process_check_success(process, "show_touches");
 }

+static SDL_LogPriority sdl_priority_from_av_level(int level) {
+    switch (level) {
+        case AV_LOG_PANIC:
+        case AV_LOG_FATAL:
+            return SDL_LOG_PRIORITY_CRITICAL;
+        case AV_LOG_ERROR:
+            return SDL_LOG_PRIORITY_ERROR;
+        case AV_LOG_WARNING:
+            return SDL_LOG_PRIORITY_WARN;
+        case AV_LOG_INFO:
+            return SDL_LOG_PRIORITY_INFO;
+    }
+    // do not forward others, which are too verbose
+    return 0;
+}
+
+static void
+av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
+    SDL_LogPriority priority = sdl_priority_from_av_level(level);
+    if (priority == 0) {
+        return;
+    }
+    char *local_fmt = SDL_malloc(strlen(fmt) + 10);
+    if (!local_fmt) {
+        LOGC("Cannot allocate string");
+        return;
+    }
+    // strcpy is safe here, the destination is large enough
+    strcpy(local_fmt, "[FFmpeg] ");
+    strcpy(local_fmt + 9, fmt);
+    SDL_LogMessageV(SDL_LOG_CATEGORY_VIDEO, priority, local_fmt, vl);
+    SDL_free(local_fmt);
+}
+
 SDL_bool scrcpy(const struct scrcpy_options *options) {
+    SDL_bool send_frame_meta = !!options->record_filename;
    if (!server_start(&server, options->serial, options->port,
-                      options->max_size, options->bit_rate, options->crop)) {
+                      options->max_size, options->bit_rate, options->crop,
+                      send_frame_meta)) {
        return SDL_FALSE;
    }

@ -153,10 +191,6 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {

    SDL_bool ret = SDL_TRUE;

-    if (!SDL_SetHint(SDL_HINT_NO_SIGNAL_HANDLERS, "1")) {
-        LOGW("Cannot request to keep default signal handlers");
-    }
-
    if (!sdl_init_and_configure()) {
        ret = SDL_FALSE;
        goto finally_destroy_server;
@ -193,14 +227,26 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
        goto finally_destroy_frames;
    }

-    decoder_init(&decoder, &frames, device_socket);
+    struct recorder *rec = NULL;
+    if (options->record_filename) {
+        if (!recorder_init(&recorder, options->record_filename, frame_size)) {
+            ret = SDL_FALSE;
+            server_stop(&server);
+            goto finally_destroy_file_handler;
+        }
+        rec = &recorder;
+    }
+
+    av_log_set_callback(av_log_callback);
+
+    decoder_init(&decoder, &frames, device_socket, rec);

    // now we consumed the header values, the socket receives the video stream
    // start the decoder
    if (!decoder_start(&decoder)) {
        ret = SDL_FALSE;
        server_stop(&server);
-        goto finally_destroy_file_handler;
+        goto finally_destroy_recorder;
    }

    if (!controller_init(&controller, device_socket)) {
@ -213,7 +259,7 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
        goto finally_destroy_controller;
    }

-    if (!screen_init_rendering(&screen, device_name, frame_size)) {
+    if (!screen_init_rendering(&screen, device_name, frame_size, options->always_on_top)) {
        ret = SDL_FALSE;
        goto finally_stop_and_join_controller;
    }
@ -246,6 +292,10 @@ finally_destroy_file_handler:
    file_handler_stop(&file_handler);
    file_handler_join(&file_handler);
    file_handler_destroy(&file_handler);
+finally_destroy_recorder:
+    if (options->record_filename) {
+        recorder_destroy(&recorder);
+    }
 finally_destroy_frames:
    frames_destroy(&frames);
 finally_destroy_server:
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@ -6,11 +6,13 @@
 struct scrcpy_options {
    const char *serial;
    const char *crop;
+    const char *record_filename;
    Uint16 port;
    Uint16 max_size;
    Uint32 bit_rate;
    SDL_bool show_touches;
    SDL_bool fullscreen;
+    SDL_bool always_on_top;
 };

 SDL_bool scrcpy(const struct scrcpy_options *options);
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -30,6 +30,9 @@ SDL_bool sdl_init_and_configure(void) {
    }
 #endif

+    // Do not disable the screensaver when scrcpy is running
+    SDL_EnableScreenSaver();
+
    return SDL_TRUE;
 }

@ -141,7 +144,10 @@ static inline SDL_Texture *create_texture(SDL_Renderer *renderer, struct size fr
                             frame_size.width, frame_size.height);
 }

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

    struct size window_size = get_initial_optimal_size(frame_size);
@ -149,6 +155,10 @@ SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, s
 #ifdef HIDPI_SUPPORT
    window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
 #endif
+    if (always_on_top) {
+        window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
+    }
+
    screen->window = SDL_CreateWindow(device_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
                                      window_size.width, window_size.height, window_flags);
    if (!screen->window) {
--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -43,7 +43,8 @@ void screen_init(struct screen *screen);
 // initialize screen, create window, renderer and texture (window is hidden)
 SDL_bool screen_init_rendering(struct screen *screen,
                               const char *device_name,
-                               struct size frame_size);
+                               struct size frame_size,
+                               SDL_bool always_on_top);

 // show the window
 void screen_show_window(struct screen *screen);
--- a/app/src/server.c
+++ b/app/src/server.c
@ -34,11 +34,6 @@ static SDL_bool push_server(const char *serial) {
    return process_check_success(process, "adb push");
 }

-static SDL_bool remove_server(const char *serial) {
-    process_t process = adb_remove_path(serial, DEVICE_SERVER_PATH);
-    return process_check_success(process, "adb shell rm");
-}
-
 static SDL_bool enable_tunnel_reverse(const char *serial, Uint16 local_port) {
    process_t process = adb_reverse(serial, SOCKET_NAME, local_port);
    return process_check_success(process, "adb reverse");
@ -78,7 +73,8 @@ static SDL_bool disable_tunnel(struct server *server) {

 static process_t execute_server(const char *serial,
                                Uint16 max_size, Uint32 bit_rate,
-                                const char *crop, SDL_bool tunnel_forward) {
+                                SDL_bool tunnel_forward, const char *crop,
+                                SDL_bool send_frame_meta) {
    char max_size_string[6];
    char bit_rate_string[11];
    sprintf(max_size_string, "%"PRIu16, max_size);
@ -92,7 +88,8 @@ static process_t execute_server(const char *serial,
        max_size_string,
        bit_rate_string,
        tunnel_forward ? "true" : "false",
-        crop ? crop : "",
+        crop ? crop : "-",
+        send_frame_meta ? "true" : "false",
    };
    return adb_execute(serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
 }
@ -148,8 +145,9 @@ void server_init(struct server *server) {
    *server = (struct server) SERVER_INITIALIZER;
 }

-SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port,
-                      Uint16 max_size, Uint32 bit_rate, const char *crop) {
+SDL_bool server_start(struct server *server, const char *serial,
+                      Uint16 local_port, Uint16 max_size, Uint32 bit_rate,
+                      const char *crop, SDL_bool send_frame_meta) {
    server->local_port = local_port;

    if (serial) {
@ -164,8 +162,6 @@ SDL_bool server_start(struct server *server, const char *serial, Uint16 local_po
        return SDL_FALSE;
    }

-    server->server_copied_to_device = SDL_TRUE;
-
    if (!enable_tunnel(server)) {
        SDL_free((void *) server->serial);
        return SDL_FALSE;
@ -190,8 +186,10 @@ SDL_bool server_start(struct server *server, const char *serial, Uint16 local_po
    }

    // server will connect to our server socket
-    server->process = execute_server(serial, max_size, bit_rate, crop,
-                                     server->tunnel_forward);
+    server->process = execute_server(serial, max_size, bit_rate,
+                                     server->tunnel_forward, crop,
+                                     send_frame_meta);
+
    if (server->process == PROCESS_NONE) {
        if (!server->tunnel_forward) {
            close_socket(&server->server_socket);
@ -224,10 +222,6 @@ socket_t server_connect_to(struct server *server) {
        close_socket(&server->server_socket);
    }

-    // the server is started, we can clean up the jar from the temporary folder
-    remove_server(server->serial); // ignore failure
-    server->server_copied_to_device = SDL_FALSE;
-
    // we don't need the adb tunnel anymore
    disable_tunnel(server); // ignore failure
    server->tunnel_enabled = SDL_FALSE;
@ -249,10 +243,6 @@ void server_stop(struct server *server) {
        // ignore failure
        disable_tunnel(server);
    }
-
-    if (server->server_copied_to_device) {
-        remove_server(server->serial); // ignore failure
-    }
 }

 void server_destroy(struct server *server) {
--- a/app/src/server.h
+++ b/app/src/server.h
@ -12,7 +12,7 @@ struct server {
    Uint16 local_port;
    SDL_bool tunnel_enabled;
    SDL_bool tunnel_forward; // use "adb forward" instead of "adb reverse"
-    SDL_bool server_copied_to_device;
+    SDL_bool send_frame_meta; // request frame PTS to be able to record properly
 };

 #define SERVER_INITIALIZER {              \
@ -23,15 +23,16 @@ struct server {
    .local_port = 0,                      \
    .tunnel_enabled = SDL_FALSE,          \
    .tunnel_forward = SDL_FALSE,          \
-    .server_copied_to_device = SDL_FALSE, \
+    .send_frame_meta = SDL_FALSE,         \
 }

 // init default values
 void server_init(struct server *server);

 // push, enable tunnel et start the server
-SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port,
-                      Uint16 max_size, Uint32 bit_rate, const char *crop);
+SDL_bool server_start(struct server *server, const char *serial,
+                      Uint16 local_port, Uint16 max_size, Uint32 bit_rate,
+                      const char *crop, SDL_bool send_frame_meta);

 // block until the communication with the server is established
 socket_t server_connect_to(struct server *server);
--- a/app/src/str_util.c
+++ b/app/src/str_util.c
@ -1,5 +1,8 @@
 #include "str_util.h"

+#include <stdlib.h>
+#include <string.h>
+
 size_t xstrncpy(char *dest, const char *src, size_t n) {
    size_t i;
    for (i = 0; i < n - 1 && src[i] != '\0'; ++i)
@ -31,3 +34,16 @@ truncated:
    dst[n - 1] = '\0';
    return n;
 }
+
+char *strquote(const char *src) {
+    size_t len = strlen(src);
+    char *quoted = malloc(len + 3);
+    if (!quoted) {
+        return NULL;
+    }
+    memcpy(&quoted[1], src, len);
+    quoted[0] = '"';
+    quoted[len + 1] = '"';
+    quoted[len + 2] = '\0';
+    return quoted;
+}
--- a/app/src/str_util.h
+++ b/app/src/str_util.h
@ -16,4 +16,8 @@ size_t xstrncpy(char *dest, const char *src, size_t n);
 // occurred, or n if truncated
 size_t xstrjoin(char *dst, const char *const tokens[], char sep, size_t n);

+// quote a string
+// returns the new allocated string, to be freed by the caller
+char *strquote(const char *src);
+
 #endif
--- a/app/src/sys/unix/command.c
+++ b/app/src/sys/unix/command.c
@ -1,3 +1,5 @@
+#define _POSIX_SOURCE // for kill()
+
 #include "command.h"

 #include <errno.h>
--- a/app/src/sys/win/command.c
+++ b/app/src/sys/win/command.c
@ -4,20 +4,27 @@
 #include "log.h"
 #include "str_util.h"

+static int build_cmd(char *cmd, size_t len, const char *const argv[]) {
+    // Windows command-line parsing is WTF:
+    // <http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS>
+    // only make it work for this very specific program
+    // (don't handle escaping nor quotes)
+    size_t ret = xstrjoin(cmd, argv, ' ', len);
+    if (ret >= len) {
+        LOGE("Command too long (%" PRIsizet " chars)", len - 1);
+        return -1;
+    }
+    return 0;
+}
+
 enum process_result cmd_execute(const char *path, const char *const argv[], HANDLE *handle) {
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);

-    // Windows command-line parsing is WTF:
-    // <http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS>
-    // only make it work for this very specific program
-    // (don't handle escaping nor quotes)
    char cmd[256];
-    size_t ret = xstrjoin(cmd, argv, ' ', sizeof(cmd));
-    if (ret >= sizeof(cmd)) {
-        LOGE("Command too long (%" PRIsizet " chars)", sizeof(cmd) - 1);
+    if (build_cmd(cmd, sizeof(cmd), argv)) {
        *handle = NULL;
        return PROCESS_ERROR_GENERIC;
    }
--- a/app/tests/test_control_event_queue.c
+++ b/app/tests/test_control_event_queue.c
@ -3,7 +3,7 @@

 #include "control_event.h"

-static void test_control_event_queue_empty() {
+static void test_control_event_queue_empty(void) {
    struct control_event_queue queue;
    SDL_bool init_ok = control_event_queue_init(&queue);
    assert(init_ok);
@ -25,7 +25,7 @@ static void test_control_event_queue_empty() {
    control_event_queue_destroy(&queue);
 }

-static void test_control_event_queue_full() {
+static void test_control_event_queue_full(void) {
    struct control_event_queue queue;
    SDL_bool init_ok = control_event_queue_init(&queue);
    assert(init_ok);
@ -43,7 +43,7 @@ static void test_control_event_queue_full() {
    control_event_queue_destroy(&queue);
 }

-static void test_control_event_queue_push_take() {
+static void test_control_event_queue_push_take(void) {
    struct control_event_queue queue;
    SDL_bool init_ok = control_event_queue_init(&queue);
    assert(init_ok);
@ -87,7 +87,7 @@ static void test_control_event_queue_push_take() {
    control_event_queue_destroy(&queue);
 }

-int main() {
+int main(void) {
    test_control_event_queue_empty();
    test_control_event_queue_full();
    test_control_event_queue_push_take();
--- a/app/tests/test_control_event_serialize.c
+++ b/app/tests/test_control_event_serialize.c
@ -3,7 +3,7 @@

 #include "control_event.h"

-static void test_serialize_keycode_event() {
+static void test_serialize_keycode_event(void) {
    struct control_event event = {
        .type = CONTROL_EVENT_TYPE_KEYCODE,
        .keycode_event = {
@ -26,7 +26,7 @@ static void test_serialize_keycode_event() {
    assert(!memcmp(buf, expected, sizeof(expected)));
 }

-static void test_serialize_text_event() {
+static void test_serialize_text_event(void) {
    struct control_event event = {
        .type = CONTROL_EVENT_TYPE_TEXT,
        .text_event = {
@ -46,7 +46,7 @@ static void test_serialize_text_event() {
    assert(!memcmp(buf, expected, sizeof(expected)));
 }

-static void test_serialize_long_text_event() {
+static void test_serialize_long_text_event(void) {
    struct control_event event;
    event.type = CONTROL_EVENT_TYPE_TEXT;
    char text[TEXT_MAX_LENGTH];
@ -66,7 +66,7 @@ static void test_serialize_long_text_event() {
    assert(!memcmp(buf, expected, sizeof(expected)));
 }

-static void test_serialize_mouse_event() {
+static void test_serialize_mouse_event(void) {
    struct control_event event = {
        .type = CONTROL_EVENT_TYPE_MOUSE,
        .mouse_event = {
@ -99,7 +99,7 @@ static void test_serialize_mouse_event() {
    assert(!memcmp(buf, expected, sizeof(expected)));
 }

-static void test_serialize_scroll_event() {
+static void test_serialize_scroll_event(void) {
    struct control_event event = {
        .type = CONTROL_EVENT_TYPE_SCROLL,
        .scroll_event = {
@ -132,11 +132,10 @@ static void test_serialize_scroll_event() {
    assert(!memcmp(buf, expected, sizeof(expected)));
 }

-int main() {
+int main(void) {
    test_serialize_keycode_event();
    test_serialize_text_event();
    test_serialize_long_text_event();
    test_serialize_mouse_event();
    test_serialize_scroll_event();
-    return 0;
 }
--- a/app/tests/test_strutil.c
+++ b/app/tests/test_strutil.c
@ -3,7 +3,7 @@

 #include "str_util.h"

-static void test_xstrncpy_simple() {
+static void test_xstrncpy_simple(void) {
    char s[] = "xxxxxxxxxx";
    size_t w = xstrncpy(s, "abcdef", sizeof(s));

@ -20,7 +20,7 @@ static void test_xstrncpy_simple() {
    assert(!strcmp("abcdef", s));
 }

-static void test_xstrncpy_just_fit() {
+static void test_xstrncpy_just_fit(void) {
    char s[] = "xxxxxx";
    size_t w = xstrncpy(s, "abcdef", sizeof(s));

@ -34,7 +34,7 @@ static void test_xstrncpy_just_fit() {
    assert(!strcmp("abcdef", s));
 }

-static void test_xstrncpy_truncated() {
+static void test_xstrncpy_truncated(void) {
    char s[] = "xxx";
    size_t w = xstrncpy(s, "abcdef", sizeof(s));

@ -48,7 +48,7 @@ static void test_xstrncpy_truncated() {
    assert(!strncmp("abcdef", s, 3));
 }

-static void test_xstrjoin_simple() {
+static void test_xstrjoin_simple(void) {
    const char *const tokens[] = { "abc", "de", "fghi", NULL };
    char s[] = "xxxxxxxxxxxxxx";
    size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
@ -66,7 +66,7 @@ static void test_xstrjoin_simple() {
    assert(!strcmp("abc de fghi", s));
 }

-static void test_xstrjoin_just_fit() {
+static void test_xstrjoin_just_fit(void) {
    const char *const tokens[] = { "abc", "de", "fghi", NULL };
    char s[] = "xxxxxxxxxxx";
    size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
@ -81,7 +81,7 @@ static void test_xstrjoin_just_fit() {
    assert(!strcmp("abc de fghi", s));
 }

-static void test_xstrjoin_truncated_in_token() {
+static void test_xstrjoin_truncated_in_token(void) {
    const char *const tokens[] = { "abc", "de", "fghi", NULL };
    char s[] = "xxxxx";
    size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
@ -96,7 +96,7 @@ static void test_xstrjoin_truncated_in_token() {
    assert(!strcmp("abc d", s));
 }

-static void test_xstrjoin_truncated_before_sep() {
+static void test_xstrjoin_truncated_before_sep(void) {
    const char *const tokens[] = { "abc", "de", "fghi", NULL };
    char s[] = "xxxxxx";
    size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
@ -111,7 +111,7 @@ static void test_xstrjoin_truncated_before_sep() {
    assert(!strcmp("abc de", s));
 }

-static void test_xstrjoin_truncated_after_sep() {
+static void test_xstrjoin_truncated_after_sep(void) {
    const char *const tokens[] = { "abc", "de", "fghi", NULL };
    char s[] = "xxxxxxx";
    size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
@ -126,7 +126,7 @@ static void test_xstrjoin_truncated_after_sep() {
    assert(!strcmp("abc de ", s));
 }

-int main() {
+int main(void) {
    test_xstrncpy_simple();
    test_xstrncpy_just_fit();
    test_xstrncpy_truncated();
--- a/cross_win32.txt
+++ b/cross_win32.txt
@ -15,6 +15,6 @@ cpu = 'i686'
 endian = 'little'

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

 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.0.2-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.0.2-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.8/x86_64-w64-mingw32'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.1-win64-shared'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.1-win64-dev'
+prebuilt_sdl2 = 'SDL2-2.0.9/x86_64-w64-mingw32'
--- a/gradle.properties
+++ b/gradle.properties
@ -15,3 +15,4 @@ org.gradle.jvmargs=-Xmx1536m
 # This option should only be used with decoupled projects. More details, visit
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 # org.gradle.parallel=true
+
--- a/meson.build
+++ b/meson.build
@ -1,4 +1,7 @@
-project('scrcpy', 'c', meson_version: '>= 0.37', default_options : 'c_std=c11')
+project('scrcpy', 'c',
+        version: '1.6',
+        meson_version: '>= 0.37',
+        default_options: 'c_std=c11')

 if get_option('build_app')
    subdir('app')
--- a/prebuilt-deps/Makefile
+++ b/prebuilt-deps/Makefile
@ -10,31 +10,31 @@ prepare-win32: prepare-sdl2 prepare-ffmpeg-shared-win32 prepare-ffmpeg-dev-win32
 prepare-win64: prepare-sdl2 prepare-ffmpeg-shared-win64 prepare-ffmpeg-dev-win64 prepare-adb

 prepare-ffmpeg-shared-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.0.2-win32-shared.zip \
-		cc190a3a4cf7bfbd4fbaa92609c1501a1de458055e6cfea8b745c1d515013aa8 \
-		ffmpeg-4.0.2-win32-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.1-win32-shared.zip \
+		e692b18c01745d262c03294b382fd64df68fabe3c66aa4546a3ad3935175cde3 \
+		ffmpeg-4.1-win32-shared

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

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

 prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.0.2-win64-dev.zip \
-		23ee994161c51285cb956b98d3caa499d48083dae7b26c1fdf77f22e98df1c5f \
-		ffmpeg-4.0.2-win64-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.1-win64-dev.zip \
+		761ec79aa3dae66698c9791a2f0bb9da8794246f8356cadc741ddc0eabab0471 \
+		ffmpeg-4.1-win64-dev

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

 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r28.0.0-windows.zip \
-		e2c1ec7c8e9b71cf1c8befd3bff91d06b26dd334c3f32b3817e9d46ba260b0e8 \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r28.0.1-windows.zip \
+		db78f726d5dc653706dcd15a462ab1b946c643f598df76906c4c1858411c54df \
 		platform-tools
--- a/prebuilt-deps/prepare-dep
+++ b/prebuilt-deps/prepare-dep
@ -55,4 +55,4 @@ get_dep() {
    fi
 }

-get_dep "$1" "$2" "$3"
+get_dep "$url" "$sum" "$dir"
--- a/server/build.gradle
+++ b/server/build.gradle
@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 27
-        versionCode 4
-        versionName "1.3"
+        versionCode 7
+        versionName "1.6"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
--- a/server/src/main/java/com/genymobile/scrcpy/ControlEventReader.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlEventReader.java
@ -9,8 +9,8 @@ import java.nio.charset.StandardCharsets;
 public class ControlEventReader {

    private static final int KEYCODE_PAYLOAD_LENGTH = 9;
-    private static final int MOUSE_PAYLOAD_LENGTH = 13;
-    private static final int SCROLL_PAYLOAD_LENGTH = 16;
+    private static final int MOUSE_PAYLOAD_LENGTH = 17;
+    private static final int SCROLL_PAYLOAD_LENGTH = 20;
    private static final int COMMAND_PAYLOAD_LENGTH = 1;

    public static final int TEXT_MAX_LENGTH = 300;
@ -132,8 +132,8 @@ public class ControlEventReader {
    }

    private static Position readPosition(ByteBuffer buffer) {
-        int x = toUnsigned(buffer.getShort());
-        int y = toUnsigned(buffer.getShort());
+        int x = buffer.getInt();
+        int y = buffer.getInt();
        int screenWidth = toUnsigned(buffer.getShort());
        int screenHeight = toUnsigned(buffer.getShort());
        return new Position(x, y, screenWidth, screenHeight);
--- a/server/src/main/java/com/genymobile/scrcpy/IO.java
+++ b/server/src/main/java/com/genymobile/scrcpy/IO.java
@ -14,9 +14,18 @@ public class IO {
    }

    public static void writeFully(FileDescriptor fd, ByteBuffer from) throws IOException {
-        while (from.hasRemaining()) {
+        // ByteBuffer position is not updated as expected by Os.write() on old Android versions, so
+        // count the remaining bytes manually.
+        // See <https://github.com/Genymobile/scrcpy/issues/291>.
+        int remaining = from.remaining();
+        while (remaining > 0) {
            try {
-                Os.write(fd, from);
+                int w = Os.write(fd, from);
+                if (BuildConfig.DEBUG && w < 0) {
+                    // w should not be negative, since an exception is thrown on error
+                    throw new AssertionError("Os.write() returned a negative value (" + w + ")");
+                }
+                remaining -= w;
            } catch (ErrnoException e) {
                if (e.errno != OsConstants.EINTR) {
                    throw new IOException(e);
--- a/server/src/main/java/com/genymobile/scrcpy/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@ -7,6 +7,7 @@ public class Options {
    private int bitRate;
    private boolean tunnelForward;
    private Rect crop;
+    private boolean sendFrameMeta; // send PTS so that the client may record properly

    public int getMaxSize() {
        return maxSize;
@ -39,4 +40,12 @@ public class Options {
    public void setCrop(Rect crop) {
        this.crop = crop;
    }
+
+    public boolean getSendFrameMeta() {
+        return sendFrameMeta;
+    }
+
+    public void setSendFrameMeta(boolean sendFrameMeta) {
+        this.sendFrameMeta = sendFrameMeta;
+    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@ -3,6 +3,7 @@ package com.genymobile.scrcpy;
 import com.genymobile.scrcpy.wrappers.SurfaceControl;

 import android.graphics.Rect;
+import android.media.MediaMuxer;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaFormat;
@ -22,21 +23,26 @@ public class ScreenEncoder implements Device.RotationListener {
    private static final int REPEAT_FRAME_DELAY = 6; // repeat after 6 frames

    private static final int MICROSECONDS_IN_ONE_SECOND = 1_000_000;
+    private static final int NO_PTS = -1;

    private final AtomicBoolean rotationChanged = new AtomicBoolean();
+    private final ByteBuffer headerBuffer = ByteBuffer.allocate(12);

    private int bitRate;
    private int frameRate;
    private int iFrameInterval;
+    private boolean sendFrameMeta;
+    private long ptsOrigin;

-    public ScreenEncoder(int bitRate, int frameRate, int iFrameInterval) {
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int frameRate, int iFrameInterval) {
+        this.sendFrameMeta = sendFrameMeta;
        this.bitRate = bitRate;
        this.frameRate = frameRate;
        this.iFrameInterval = iFrameInterval;
    }

-    public ScreenEncoder(int bitRate) {
-        this(bitRate, DEFAULT_FRAME_RATE, DEFAULT_I_FRAME_INTERVAL);
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate) {
+        this(sendFrameMeta, bitRate, DEFAULT_FRAME_RATE, DEFAULT_I_FRAME_INTERVAL);
    }

    @Override
@ -80,6 +86,8 @@ public class ScreenEncoder implements Device.RotationListener {
    private boolean encode(MediaCodec codec, FileDescriptor fd) throws IOException {
        boolean eof = false;
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+
+
        while (!consumeRotationChange() && !eof) {
            int outputBufferId = codec.dequeueOutputBuffer(bufferInfo, -1);
            eof = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
@ -90,6 +98,11 @@ public class ScreenEncoder implements Device.RotationListener {
                }
                if (outputBufferId >= 0) {
                    ByteBuffer codecBuffer = codec.getOutputBuffer(outputBufferId);
+
+                    if (sendFrameMeta) {
+                        writeFrameMeta(fd, bufferInfo, codecBuffer.remaining());
+                    }
+
                    IO.writeFully(fd, codecBuffer);
                }
            } finally {
@ -102,6 +115,25 @@ public class ScreenEncoder implements Device.RotationListener {
        return !eof;
    }

+    private void writeFrameMeta(FileDescriptor fd, MediaCodec.BufferInfo bufferInfo, int packetSize) throws IOException {
+        headerBuffer.clear();
+
+        long pts;
+        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
+            pts = NO_PTS; // non-media data packet
+        } else {
+            if (ptsOrigin == 0) {
+                ptsOrigin = bufferInfo.presentationTimeUs;
+            }
+            pts = bufferInfo.presentationTimeUs - ptsOrigin;
+        }
+
+        headerBuffer.putLong(pts);
+        headerBuffer.putInt(packetSize);
+        headerBuffer.flip();
+        IO.writeFully(fd, headerBuffer);
+    }
+
    private static MediaCodec createCodec() throws IOException {
        return MediaCodec.createEncoderByType("video/avc");
    }
@ -119,7 +151,7 @@ public class ScreenEncoder implements Device.RotationListener {
    }

    private static IBinder createDisplay() {
-        return SurfaceControl.createDisplay("scrcpy", false);
+        return SurfaceControl.createDisplay("scrcpy", true);
    }

    private static void configure(MediaCodec codec, MediaFormat format) {
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -2,10 +2,14 @@ package com.genymobile.scrcpy;

 import android.graphics.Rect;

+import java.io.File;
 import java.io.IOException;
+import java.util.Arrays;

 public final class Server {

+    private static final String SERVER_PATH = "/data/local/tmp/scrcpy-server.jar";
+
    private Server() {
        // not instantiable
    }
@ -14,7 +18,7 @@ public final class Server {
        final Device device = new Device(options);
        boolean tunnelForward = options.isTunnelForward();
        try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward)) {
-            ScreenEncoder screenEncoder = new ScreenEncoder(options.getBitRate());
+            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate());

            // asynchronous
            startEventController(device, connection);
@ -45,37 +49,32 @@ public final class Server {

    @SuppressWarnings("checkstyle:MagicNumber")
    private static Options createOptions(String... args) {
+        if (args.length != 5)
+            throw new IllegalArgumentException("Expecting 5 parameters");
+
        Options options = new Options();
-        if (args.length < 1) {
-            return options;
-        }
+
        int maxSize = Integer.parseInt(args[0]) & ~7; // multiple of 8
        options.setMaxSize(maxSize);

-        if (args.length < 2) {
-            return options;
-        }
        int bitRate = Integer.parseInt(args[1]);
        options.setBitRate(bitRate);

-        if (args.length < 3) {
-            return options;
-        }
        // use "adb forward" instead of "adb tunnel"? (so the server must listen)
        boolean tunnelForward = Boolean.parseBoolean(args[2]);
        options.setTunnelForward(tunnelForward);

-        if (args.length < 4) {
-            return options;
-        }
        Rect crop = parseCrop(args[3]);
        options.setCrop(crop);

+        boolean sendFrameMeta = Boolean.parseBoolean(args[4]);
+        options.setSendFrameMeta(sendFrameMeta);
+
        return options;
    }

    private static Rect parseCrop(String crop) {
-        if (crop.isEmpty()) {
+        if ("-".equals(crop)) {
            return null;
        }
        // input format: "width:height:x:y"
@ -90,6 +89,14 @@ public final class Server {
        return new Rect(x, y, x + width, y + height);
    }

+    private static void unlinkSelf() {
+        try {
+            new File(SERVER_PATH).delete();
+        } catch (Exception e) {
+            Ln.e("Cannot unlink server", e);
+        }
+    }
+
    public static void main(String... args) throws Exception {
        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
@ -98,6 +105,7 @@ public final class Server {
            }
        });

+        unlinkSelf();
        Options options = createOptions(args);
        scrcpy(options);
    }
Author	SHA1	Message	Date
Romain Vimont	57687bdfcd	Write header file with correct extradata When recording, the header must be written with extradata set to the content of the very first packet. Suggested-by: Steve Lhomme <robux4@ycbcr.xyz>	2019-02-09 12:54:12 +01:00
Romain Vimont	ee3cba57a8	Forward FFmpeg logs FFmpeg logs can be useful to understand the cause of issues.	2019-02-09 12:27:13 +01:00
Romain Vimont	c11905b860	Add log verbose macro This was the only log priority missing.	2019-02-09 12:27:13 +01:00
Romain Vimont	1a5ba59504	Fix memory leak on close The buffer associated to the AVIOContext must be freed.	2019-02-09 12:27:13 +01:00
Romain Vimont	aa07dfd2ca	Merge pull request #412 from npes87184/dev app: add always_on_top	2019-01-27 14:09:19 +01:00
Yu-Chen Lin	eca82e09c3	app: add always_on_top It is very convenient when I play mobile game and watch video at the same time. Tested on Linux mint Cinnamon as well as Windows 10. Signed-off-by: Yu-Chen Lin <npes87184@gmail.com>	2019-01-27 20:54:24 +08:00
Romain Vimont	b35733edb6	Fix expected mouse event sizes Commit `fefb9816a9` modified mouse events serialization. The server-side parsing was updated to correctly read the position, but the expected size of these events was not updated. As a result, the server might try to parse incomplete events, leading to BufferUnderflowException. Fixes <https://github.com/Genymobile/scrcpy/issues/350#issuecomment-456298816>.	2019-01-22 09:47:26 +01:00
Romain Vimont	7764a836f1	Fix incorrect comment Comment had not been updated along with the code.	2019-01-22 09:38:51 +01:00
Romain Vimont	0bfaf7b7ff	Update links to v1.6 in README and BUILD	2019-01-20 22:05:32 +01:00
Romain Vimont	446c682374	Bump version to 1.6	2019-01-20 21:35:42 +01:00
Romain Vimont	3aacb7967d	Merge branch 'dev' into master	2019-01-19 21:40:55 +01:00
Romain Vimont	06a0bbbc71	Update FFmpeg (4.1) for Windows Include the last version of FFmpeg in Windows releases.	2019-01-19 18:14:05 +01:00
Romain Vimont	d71e036f3a	Do not disable screensaver Keep screensaver enabled while scrcpy is running. Fixes <https://github.com/Genymobile/scrcpy/issues/380>.	2019-01-18 23:17:31 +01:00
Romain Vimont	b343a5dc59	Merge pull request #401 from npes87184/dev input_manager: don't ignore double click event when clicking inside device	2019-01-18 13:34:41 +01:00
Yu-Chen Lin	c5ec1a194c	input_manager: don't ignore double click event when clicking inside device Signed-off-by: Yu-Chen Lin <npes87184@gmail.com>	2019-01-18 20:21:25 +08:00
Romain Vimont	4f254d8232	Merge pull request #396 from npes87184/master prepare-dep: use variable for better readability	2019-01-16 21:16:04 +01:00
Romain Vimont	1fdde490fd	Mirror "secure" content Some applications, like Silence, prevent the content of a window from being viewed on non-secure displays: <https://developer.android.com/reference/android/view/WindowManager.LayoutParams.html#FLAG_SECURE> We can mirror it by just creating a "secure" display: <https://developer.android.com/reference/android/view/Display#FLAG_SECURE>	2019-01-16 14:21:18 +01:00
yuchenlin	fb73aa101a	prepare-dep: use variable for better readability The arguments are saved to variable when script started. Instead of using $1, $2 and $3, we can use these variables. Signed-off-by: yuchenlin <npes87184@gmail.com>	2019-01-15 21:32:46 +08:00
Romain Vimont	39c5e71605	Make the server unlink itself To clean up the device, the client executed "adb shell rm" once the server was guaranteed to be started (after the connection succeeded). This implied to track whether the installation state, and failed if an additional tunnel was used in "forward" mode: <https://github.com/Genymobile/scrcpy/issues/386#issuecomment-453936034> Instead, make the server unlink itself on start.	2019-01-14 21:12:23 +01:00
Romain Vimont	fefb9816a9	Handle mouse events outside device screen Mouse events position were unsigned (so negative values could not be handled properly). To avoid issues with negative values, mouse events outside the device screen were ignored (commit `a7fe9ad779`). But as a consequence, drag&drop were "broken" if the "drop" occurred outside the device screen. Instead, use signed 32-bits to store the position, and forward events outside the device screen. Fixes <https://github.com/Genymobile/scrcpy/issues/357>.	2018-11-27 08:59:22 +01:00
Romain Vimont	7830859c21	Merge branch 'master' into dev	2018-11-27 08:38:57 +01:00
Romain Vimont	0e019f8ab8	Add a note to allow simulating input in README	2018-11-25 11:29:27 +01:00
Romain Vimont	f7d02cad4b	Add ninja-build to the packages list to install The package ninja-build should be installed automatically as a meson dependency, but some users need to install a newer meson from pip3, so ninja must be installed explicitly.	2018-11-19 09:43:05 +01:00
Romain Vimont	a7fe9ad779	Ignore mouse events outside device screen Never create a "struct point" with a position possibly outside the device screen (i.e. in the black borders area), and do not transmit such events. This fixes an assertion failure on mouse wheel events outside the device screen area.	2018-11-18 21:31:57 +01:00
Romain Vimont	1e22ebcac2	Always use non-empty arguments The client passes parameters to the server via "adb shell" arguments. Use "-" instead of "" when no crop is specified to avoid empty arguments, which are not handled the same way on all devices. Fixed <https://github.com/Genymobile/scrcpy/issues/337>.	2018-11-16 18:39:41 +01:00
Romain Vimont	d81729ba39	Always expect 5 parameters for the server The client always sends all the arguments, so there is no need to check.	2018-11-16 18:36:01 +01:00
Romain Vimont	b2c3df7550	Point out that ninja must not be run as root See https://github.com/Genymobile/scrcpy/issues/335.	2018-11-15 21:11:58 +01:00
Romain Vimont	46fec41b7b	Move drag&drop features in README Present how to install an APK and how to push a file in the "features" section (instead of "shortcuts").	2018-11-13 20:39:18 +01:00
Romain Vimont	2876463d39	Fix read_packet() return value on error or EOF Fix warning on error or EOF: > Invalid return value 0 for stream protocol See <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=a606f27f4c610708fa96e35eed7b7537d3d8f712>. Fixes <https://github.com/Genymobile/scrcpy/issues/333>.	2018-11-12 14:45:43 +01:00
Romain Vimont	6dc6ec05d5	Configure version at meson project level Make meson aware of the project version, so that it does not print: Project version: undefined	2018-11-12 14:10:21 +01:00
Romain Vimont	b5e630eea3	Update links to v1.5-fixversion I forgot to bump version _before_ the release, so I had to make a new one which fixes the version string (for scrcpy --help).	2018-11-12 08:52:45 +01:00
Pierre Gordon	a17f1116ce	Bump version to 1.5 Signed-off-by: Romain Vimont <rom@rom1v.com>	2018-11-12 08:24:18 +01:00
Romain Vimont	e4cf152b26	Update links to v1.5 in README and BUILD	2018-11-11 23:35:47 +01:00
Romain Vimont	bd32016632	Improve features presentation in README	2018-11-11 21:40:05 +01:00
Romain Vimont	77b620e1d0	Merge branch 'record' into dev (#292 ) Record screen to file	2018-11-11 21:39:38 +01:00
Romain Vimont	22ff03f2f7	Do not queue invalid PTS Configuration packets produced by MediaCodec have no valid PTS, and do not produce frame. Do not queue their (invalid) PTS not to break the matching between frames and their PTS.	2018-11-11 21:37:31 +01:00
Romain Vimont	60afb46c8d	Store queue of PTS for pending frames Several frames may be read by read_packet() before they are consumed (returned by av_read_frame()), so we need to store the PTS of frames in order, so that the right PTS is assigned to the right frame.	2018-11-11 21:37:31 +01:00
Romain Vimont	345f8858d3	Send frame meta only if recording is enabled The client needs the PTS for each frame only if recording is enabled. Otherwise, the PTS are not necessary, and the protocol is more straighforward.	2018-11-11 21:37:31 +01:00
Romain Vimont	22bf0c19d6	Rename --output-file to --record To record the screen to a local file: scrcpy --record file.mp4	2018-11-11 21:37:31 +01:00
Romain Vimont	70579dc709	Wrap receiver state into separate struct For readability, wrap the state of the receiver in a separate struct receiver_state.	2018-11-11 21:37:31 +01:00
Romain Vimont	e562837c0b	Avoid partial header reads Use net_recv_all() to avoid partial reads for the "meta" header (this would break the whole stream).	2018-11-11 21:37:31 +01:00
Romain Vimont	ebe998cf78	Move buffer reader functions to buffer_util.h	2018-11-11 21:37:31 +01:00
Romain Vimont	b98eb7d0fa	Support AVStream.codec for old FFmpeg versions AVStream.codec has been deprecated in favor of AVStream.codecpar. Due to the FFmpeg/Libav split, this happened in two separate versions: - 57.33.100 for FFmpeg - 57.5.0 for Libav	2018-11-11 21:37:31 +01:00
yuchenlin	e361b49b4a	recorder: use av_oformat_next to support older FFmpeg Signed-off-by: yuchenlin <npes87184@gmail.com>	2018-11-11 21:37:31 +01:00
Romain Vimont	d0e090e1f9	Reenable custom SDL signal handlers This partially reverts commit `f00c6c5b13`. On Ctrl+C, we need to execute cleanup code. For instance, if recording is enabled, we need to write MP4 file trailer on exit. Custom SDL signal handlers were disabled because it leaded to process hanging on Ctrl+C during network calls on initialization, but now it seems to work correctly, the network calls return immediately on signal.	2018-11-11 21:37:31 +01:00
Romain Vimont	475912a39c	Do not transmit MediaCodec flags Since PTS handling has been fixed, the recorder do not associate a PTS to a wrong frame anymore, so PTS of "configuration packets" (which never produce a frame), are never read by the recorder. Therefore, there is no need to ignore them explicitly, so we can remove the MediaCodec flags completely.	2018-11-11 21:37:31 +01:00
Romain Vimont	27e8a9a79d	Assign PTS to the right frame The PTS was read from the socket and set as the current one even before the frame was consumed, so it could be assigned to the previous frame "in advance". Store the PTS for the current frame and the last PTS read from the packet header of the next frame in separate fields. As a side-effect, this fixes the warning on quit: > Application provided invalid, non monotonically increasing dts to > muxer in stream 0: 17164020 >= 17164020	2018-11-11 21:37:31 +01:00
Romain Vimont	61db575861	Decode and push frame before recording Handle display before recording, to reduce latency.	2018-11-11 21:37:31 +01:00
Romain Vimont	2cd99e7205	Only set valid PTS/DTS When the PTS is valid, set both PTS and DTS to avoid FFmpeg warnings. Since configuration packets have no PTS, do not record these packets.	2018-11-11 21:37:26 +01:00
Romain Vimont	27686e9361	Add recorder Implement recording in a separate "class".	2018-11-11 16:30:23 +01:00
Ivan Gorinov	d706c5df39	Enable video output file, with pts set by server	2018-11-11 16:30:23 +01:00
Romain Vimont	b5c64c0f5a	Fix SDL 2.0.9 for Windows Add missing version upgrade in cross_winXX.txt files.	2018-11-11 16:29:03 +01:00
Romain Vimont	a5787dccd6	Update SDL (2.0.9) for Windows Include the last version of SDL in Windows releases.	2018-11-11 16:04:17 +01:00
Romain Vimont	cb3cf801c8	Extract bit operations to buffer_util.h Move util functions to a reusable separate header.	2018-11-11 01:01:56 +01:00
Romain Vimont	b1d2c2c640	Explain how to install up-to-date meson On Ubuntu 16.04, meson is 0.29, while scrcpy requires >= 0.37. Explain how to install a newer version from pip3.	2018-11-11 00:08:41 +01:00
Romain Vimont	9160d465ec	Add feature test macro to declare kill() Avoid the following warning on some systems: > warning: implicit declaration of function 'kill' > [-Wimplicit-function-declaration]	2018-11-10 16:16:08 +01:00
Romain Vimont	5c739874a4	Fix memory leak on error On decode error, unref the packet.	2018-11-09 16:10:44 +01:00
Romain Vimont	d061c30965	Replace Ctrl by Meta for volume shortcuts on MacOS Ctrl+UP and Ctrl+DOWN are already used by the window manager on MacOS. Use Cmd key instead (like on VLC).	2018-11-01 16:19:07 +01:00
Romain Vimont	5bf1261364	Refactor to support Meta in shortcuts Move the Ctrl and Meta key down checks to each shortcut individually, so that we can add a shortcut involving Meta.	2018-11-01 16:19:07 +01:00
Romain Vimont	facbbced9e	Merge pull request #310 from npes87184/master fix text memory leak	2018-10-27 14:49:00 +02:00
yuchenlin	96056e3213	input_manager: fix potential memory leak on text Fix potential memory leak when controller_push_event failed. Signed-off-by: yuchenlin <npes87184@gmail.com>	2018-10-27 20:07:22 +08:00
Romain Vimont	0b92b93358	Capture Alt and Meta keys Alt and Meta keys should not be forwarded to the device. For now, they are not used for shortcuts, but they could be.	2018-10-24 19:08:36 +02:00
Romain Vimont	c20245630e	Factorize Windows command building Extract command line building to a separate method.	2018-10-21 18:57:06 +02:00
Romain Vimont	b882322f73	Work around Os.write() not updating position ByteBuffer position is not updated as expected by Os.write() on old Android versions. Count the remaining bytes manually. Fixes <https://github.com/Genymobile/scrcpy/issues/291>.	2018-10-09 08:43:17 +02:00
Romain Vimont	8875955921	Support paths containing spaces on Windows Quote the arguments of "adb push" to support paths which contain spaces on Windows. Fixes <https://github.com/Genymobile/scrcpy/issues/288>.	2018-10-04 21:01:23 +02:00
Romain Vimont	ff4430b2a3	Declare fun(void) functions with no parameters This is not C++.	2018-10-04 17:04:20 +02:00
Romain Vimont	cea176c210	Update links to v1.4 in README and BUILD	2018-10-04 00:13:28 +02:00
Romain Vimont	f613752606	Update platform-tools (28.0.1) for Windows Include the latest version of adb in Windows releases.	2018-10-03 23:18:37 +02:00
Romain Vimont	24d107d017	Bump version to 1.4	2018-10-03 23:03:27 +02:00
Romain Vimont	66d1f81f56	Merge branch 'master' into dev	2018-10-03 23:02:09 +02:00
Romain Vimont	411aa4fcfd	Handle alpha and space chars as raw events To handle special chars, text is handled as text input instead of key events. However, this breaks the separation of DOWN and UP key events. As a compromise, send letters and space as key events, to preserve original DOWN/UP events, but send other text input events as text, to be able to send "special" characters. Fixes <https://github.com/Genymobile/scrcpy/issues/87>. Suggested-by: pete1414 Suggested-by: King-Slide <kingslide@gmail.com>	2018-10-03 22:07:09 +02:00
Romain Vimont	78d5a4d8a1	Add link to Gentoo Ebuild in README	2018-09-19 22:09:52 +02:00
Romain Vimont	52e2c60190	Merge pull request #261 from npes87184/dev prevent closing console right after process error in windows	2018-09-18 08:56:40 +02:00
yuchenlin	140b1ef6a5	prevent closing console right after process error in windows Signed-off-by: yuchenlin <npes87184@gmail.com>	2018-09-14 20:34:59 +08:00
Romain Vimont	fdbb725436	Add link to FLAG_SECURE in FAQ	2018-08-20 15:00:01 +02:00
Romain Vimont	ce6e5d1969	Explain how to install adb on Mac OS The package scrcpy from Homebrew does not install adb.	2018-08-17 19:51:25 +02:00
Romain Vimont	963890e9c2	Separate build instructions from README README included build instructions, which made it complicated to follow. Move the build instructions to a separate file (BUILD.md).	2018-08-17 17:57:08 +02:00