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

BUILD.md

@@ -0,0 +1,236 @@
+# 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 \
+                 libavcodec-dev libavformat-dev libavutil-dev \
+                 libsdl2-dev
+
+# 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
+```
+
+
+
+### 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
+```
+
+### 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.4.jar`][direct-scrcpy-server]  
+   _(SHA-256: 1ff7a72fcfe81dadccfab9d6f86c971cd7c7f38f17196748fe05480e301b443d)_
+
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.4/scrcpy-server-v1.4.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
+```

FAQ.md

@@ -26,10 +26,11 @@ If you still encounter problems, please see [issue 9].
 
 ### I get a black screen for some applications like Silence
 
-This is expected, they requested to protect the screen.
+This is expected, they requested to [protect] the screen.
 
 In [Silence], you can disable it in settings → Privacy → Screen security.
 
+[protect]: https://developer.android.com/reference/android/view/Display#FLAG_SECURE
 [silence]: https://f-droid.org/en/packages/org.smssecure.smssecure/
 
 See [issue 36].

Makefile.CrossWindows

@@ -100,10 +100,10 @@ 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-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	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/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)/"
@@ -114,10 +114,10 @@ dist-win64: build-server build-win64 build-win64-noconsole
 	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-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	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/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)/"

README.md

@@ -1,4 +1,4 @@
-# scrcpy (v1.2)
+# scrcpy (v1.4)
 
 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,49 @@ 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
 
-### System-specific steps
+## Get the app
 
-#### Linux
 
-Install the required packages from your package manager.
+### Linux
 
-##### Debian/Ubuntu
+On Linux, you typically need to [build the app manually][BUILD]. Don't worry,
+it's not that hard.
 
-```bash
-# runtime dependencies
-sudo apt install ffmpeg libsdl2-2.0.0
-
-# client build dependencies
-sudo apt install make gcc pkg-config meson \
-                 libavcodec-dev libavformat-dev libavutil-dev \
-                 libsdl2-dev
-
-# 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.2.zip`][direct-win32].  
-   _(SHA-256: a1fe1de67ec75dcf970ca5d97a04c26ff0f2d61871f2ef51b6f2f0bf666966b2)_
- - [`scrcpy-win64-v1.2.zip`][direct-win64].  
-   _(SHA-256: 35ae3bcee51771e7c51b8a8be87aef2295c9f267606a7cf83ebb0a4d583ef536)_
+ - [`scrcpy-win32-v1.4.zip`][direct-win32]  
+   _(SHA-256: 1f72fa520980727e8943b7214b64c66b00b9b5267f7cffefb64fa37c3ca803cf)_
+ - [`scrcpy-win64-v1.4.zip`][direct-win64]  
+   _(SHA-256: 382f02bd8ed3db2cc7ab15aabdb83674744993b936d602b01e6959a150584a79)_
 
-[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.2/scrcpy-win32-v1.2.zip
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.2/scrcpy-win64-v1.2.zip
+[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.4/scrcpy-win32-v1.4.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.4/scrcpy-win64-v1.4.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 +63,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.2.jar`][direct-scrcpy-server].  
-   _(SHA-256: cb39654ed2fda3d30ddff292806950ccc5c394375ea12b974f790c7f38f61f60)_
-
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.2/scrcpy-server-v1.2.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
@@ -294,6 +99,12 @@ screen is smaller, or cannot decode such a high definition):
 scrcpy -m 1024
 ```
 
+The device screen may be cropped to mirror only part of the screen:
+
+```bash
+scrcpy -c 1224:1440:0:0   # 1224x1440 at offset (0,0)
+```
+
 If several devices are listed in `adb devices`, you must specify the _serial_:
 
 ```bash
@@ -306,14 +117,11 @@ To show physical touches while scrcpy is running:
 scrcpy -t
 ```
 
-To run without installing:
+The app may be started directly in fullscreen:
 
-```bash
-./run x [options]
 ```
-
-(where `x` is your build directory).
-
+scrcpy -f
+```
 
 ## Shortcuts
 
@@ -326,13 +134,14 @@ 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._
@@ -348,6 +157,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).

app/meson.build

@@ -1,22 +1,22 @@
 src = [
     'src/main.c',
     'src/command.c',
-    'src/controlevent.c',
+    'src/control_event.c',
     'src/controller.c',
     'src/convert.c',
     'src/decoder.c',
     'src/device.c',
-    'src/fpscounter.c',
+    'src/file_handler.c',
+    'src/fps_counter.c',
     'src/frames.c',
-    'src/inputmanager.c',
-    'src/installer.c',
-    'src/lockutil.c',
+    'src/input_manager.c',
+    'src/lock_util.c',
     'src/net.c',
     'src/scrcpy.c',
     'src/screen.c',
     'src/server.c',
-    'src/strutil.c',
-    'src/tinyxpm.c',
+    'src/str_util.c',
+    'src/tiny_xpm.c',
 ]
 
 if not get_option('crossbuild_windows')
@@ -85,7 +85,7 @@ conf = configuration_data()
 conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')
 
 # the version, updated on release
-conf.set_quoted('SCRCPY_VERSION', '1.2')
+conf.set_quoted('SCRCPY_VERSION', '1.4')
 
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))
@@ -147,9 +147,9 @@ executable('scrcpy', src, dependencies: dependencies, include_directories: src_d
 ### TESTS
 
 tests = [
-    ['test_control_event_queue', ['tests/test_control_event_queue.c', 'src/controlevent.c']],
-    ['test_control_event_serialize', ['tests/test_control_event_serialize.c', 'src/controlevent.c']],
-    ['test_strutil', ['tests/test_strutil.c', 'src/strutil.c']],
+    ['test_control_event_queue', ['tests/test_control_event_queue.c', 'src/control_event.c']],
+    ['test_control_event_serialize', ['tests/test_control_event_serialize.c', 'src/control_event.c']],
+    ['test_strutil', ['tests/test_strutil.c', 'src/str_util.c']],
 ]
 
 foreach t : tests

app/src/android/input.h

@@ -777,9 +777,6 @@ enum android_input_source {
     AINPUT_SOURCE_JOYSTICK = 0x01000000 | AINPUT_SOURCE_CLASS_JOYSTICK,
     /** rotary encoder */
     AINPUT_SOURCE_ROTARY_ENCODER = 0x00400000 | AINPUT_SOURCE_CLASS_NONE,
-
-    /** any */
-    AINPUT_SOURCE_ANY = 0xffffff00,
 };
 
 /**

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)
@@ -18,9 +19,25 @@ static inline const char *get_adb_command() {
     return adb_command;
 }
 
+static void show_adb_err_msg(enum process_result err) {
+    switch (err) {
+        case PROCESS_ERROR_GENERIC:
+            LOGE("Failed to execute adb");
+            break;
+        case PROCESS_ERROR_MISSING_BINARY:
+            LOGE("'adb' command not found (make it accessible from your PATH "
+                  "or define its full path in the ADB environment variable)");
+            break;
+        case PROCESS_SUCCESS:
+            /* do nothing */
+            break;
+    }
+}
+
 process_t adb_execute(const char *serial, const char *const adb_cmd[], int len) {
     const char *cmd[len + 4];
     int i;
+    process_t process;
     cmd[0] = get_adb_command();
     if (serial) {
         cmd[1] = "-s";
@@ -32,7 +49,12 @@ process_t adb_execute(const char *serial, const char *const adb_cmd[], int len)
 
     memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
     cmd[len + i] = NULL;
-    return cmd_execute(cmd[0], cmd);
+    enum process_result r = cmd_execute(cmd[0], cmd, &process);
+    if (r != PROCESS_SUCCESS) {
+        show_adb_err_msg(r);
+        return PROCESS_NONE;
+    }
+    return process;
 }
 
 process_t adb_forward(const char *serial, uint16_t local_port, const char *device_socket_name) {
@@ -68,23 +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 proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+
+#ifdef __WINDOWS__
+    free((void *) local);
+#endif
+
+    return proc;
 }
 
 process_t adb_remove_path(const char *serial, const char *path) {

app/src/command.h

@@ -32,7 +32,13 @@
 #endif
 # define NO_EXIT_CODE -1
 
-process_t cmd_execute(const char *path, const char *const argv[]);
+enum process_result {
+    PROCESS_SUCCESS,
+    PROCESS_ERROR_GENERIC,
+    PROCESS_ERROR_MISSING_BINARY,
+};
+
+enum process_result cmd_execute(const char *path, const char *const argv[], process_t *process);
 SDL_bool cmd_terminate(process_t pid);
 SDL_bool cmd_simple_wait(process_t pid, exit_code_t *exit_code);
 

app/src/control_event.c

@@ -1,9 +1,9 @@
-#include "controlevent.h"
+#include "control_event.h"
 
 #include <SDL2/SDL_stdinc.h>
 #include <string.h>
 
-#include "lockutil.h"
+#include "lock_util.h"
 #include "log.h"
 
 static inline void write16(Uint8 *buf, Uint16 value) {

app/src/controller.c

@@ -1,6 +1,8 @@
 #include "controller.h"
 
-#include "lockutil.h"
+#include <SDL2/SDL_assert.h>
+#include "config.h"
+#include "lock_util.h"
 #include "log.h"
 
 SDL_bool controller_init(struct controller *controller, socket_t video_socket) {
@@ -65,12 +67,8 @@ static int run_controller(void *data) {
             break;
         }
         struct control_event event;
-#ifdef BUILD_DEBUG
-        bool non_empty = control_event_queue_take(&controller->queue, &event);
+        SDL_bool non_empty = control_event_queue_take(&controller->queue, &event);
         SDL_assert(non_empty);
-#else
-        control_event_queue_take(&controller->queue, &event);
-#endif
         mutex_unlock(controller->mutex);
 
         SDL_bool ok = process_event(controller, &event);

app/src/controller.h

@@ -1,7 +1,7 @@
 #ifndef CONTROL_H
 #define CONTROL_H
 
-#include "controlevent.h"
+#include "control_event.h"
 
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_stdinc.h>

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

app/src/convert.h

@@ -3,7 +3,7 @@
 
 #include <SDL2/SDL_stdinc.h>
 #include <SDL2/SDL_events.h>
-#include "controlevent.h"
+#include "control_event.h"
 
 struct complete_mouse_motion_event {
     SDL_MouseMotionEvent *mouse_motion_event;

app/src/decoder.c

@@ -9,7 +9,7 @@
 #include "config.h"
 #include "events.h"
 #include "frames.h"
-#include "lockutil.h"
+#include "lock_util.h"
 #include "log.h"
 
 #define BUFSIZE 0x10000

app/src/device.h

@@ -7,6 +7,7 @@
 #include "net.h"
 
 #define DEVICE_NAME_FIELD_LENGTH 64
+#define DEVICE_SDCARD_PATH "/sdcard/"
 
 // name must be at least DEVICE_NAME_FIELD_LENGTH bytes
 SDL_bool device_read_info(socket_t device_socket, char *name, struct size *frame_size);

app/src/file_handler.c

@@ -0,0 +1,231 @@
+#include "file_handler.h"
+
+#include <string.h>
+#include <SDL2/SDL_assert.h>
+#include "config.h"
+#include "command.h"
+#include "device.h"
+#include "lock_util.h"
+#include "log.h"
+
+struct request {
+    file_handler_action_t action;
+    const char *file;
+};
+
+static struct request *request_new(file_handler_action_t action, const char *file) {
+    struct request *req = SDL_malloc(sizeof(*req));
+    if (!req) {
+        return NULL;
+    }
+    req->action = action;
+    req->file = file;
+    return req;
+}
+
+static void request_free(struct request *req) {
+    if (!req) {
+        return;
+    }
+    SDL_free((void *) req->file);
+    SDL_free((void *) req);
+}
+
+static SDL_bool request_queue_is_empty(const struct request_queue *queue) {
+    return queue->head == queue->tail;
+}
+
+static SDL_bool request_queue_is_full(const struct request_queue *queue) {
+    return (queue->head + 1) % REQUEST_QUEUE_SIZE == queue->tail;
+}
+
+static SDL_bool request_queue_init(struct request_queue *queue) {
+    queue->head = 0;
+    queue->tail = 0;
+    return SDL_TRUE;
+}
+
+static void request_queue_destroy(struct request_queue *queue) {
+    int i = queue->tail;
+    while (i != queue->head) {
+        request_free(queue->reqs[i]);
+        i = (i + 1) % REQUEST_QUEUE_SIZE;
+    }
+}
+
+static SDL_bool request_queue_push(struct request_queue *queue, struct request *req) {
+    if (request_queue_is_full(queue)) {
+        return SDL_FALSE;
+    }
+    queue->reqs[queue->head] = req;
+    queue->head = (queue->head + 1) % REQUEST_QUEUE_SIZE;
+    return SDL_TRUE;
+}
+
+static SDL_bool request_queue_take(struct request_queue *queue, struct request **req) {
+    if (request_queue_is_empty(queue)) {
+        return SDL_FALSE;
+    }
+    // transfer ownership
+    *req = queue->reqs[queue->tail];
+    queue->tail = (queue->tail + 1) % REQUEST_QUEUE_SIZE;
+    return SDL_TRUE;
+}
+
+SDL_bool file_handler_init(struct file_handler *file_handler, const char *serial) {
+
+    if (!request_queue_init(&file_handler->queue)) {
+        return SDL_FALSE;
+    }
+
+    if (!(file_handler->mutex = SDL_CreateMutex())) {
+        return SDL_FALSE;
+    }
+
+    if (!(file_handler->event_cond = SDL_CreateCond())) {
+        SDL_DestroyMutex(file_handler->mutex);
+        return SDL_FALSE;
+    }
+
+    if (serial) {
+        file_handler->serial = SDL_strdup(serial);
+        if (!file_handler->serial) {
+            LOGW("Cannot strdup serial");
+            SDL_DestroyMutex(file_handler->mutex);
+            return SDL_FALSE;
+        }
+    } else {
+        file_handler->serial = NULL;
+    }
+
+    // lazy initialization
+    file_handler->initialized = SDL_FALSE;
+
+    file_handler->stopped = SDL_FALSE;
+    file_handler->current_process = PROCESS_NONE;
+
+    return SDL_TRUE;
+}
+
+void file_handler_destroy(struct file_handler *file_handler) {
+    SDL_DestroyCond(file_handler->event_cond);
+    SDL_DestroyMutex(file_handler->mutex);
+    request_queue_destroy(&file_handler->queue);
+    SDL_free((void *) file_handler->serial);
+}
+
+static process_t install_apk(const char *serial, const char *file) {
+    return adb_install(serial, file);
+}
+
+static process_t push_file(const char *serial, const char *file) {
+    return adb_push(serial, file, DEVICE_SDCARD_PATH);
+}
+
+SDL_bool file_handler_request(struct file_handler *file_handler,
+                              file_handler_action_t action,
+                              const char *file) {
+    SDL_bool res;
+
+    // start file_handler if it's used for the first time
+    if (!file_handler->initialized) {
+        if (!file_handler_start(file_handler)) {
+            return SDL_FALSE;
+        }
+        file_handler->initialized = SDL_TRUE;
+    }
+
+    LOGI("Request to %s %s", action == ACTION_INSTALL_APK ? "install" : "push", file);
+    struct request *req = request_new(action, file);
+    if (!req) {
+        LOGE("Could not create request");
+        return SDL_FALSE;
+    }
+
+    mutex_lock(file_handler->mutex);
+    SDL_bool was_empty = request_queue_is_empty(&file_handler->queue);
+    res = request_queue_push(&file_handler->queue, req);
+    if (was_empty) {
+        cond_signal(file_handler->event_cond);
+    }
+    mutex_unlock(file_handler->mutex);
+    return res;
+}
+
+static int run_file_handler(void *data) {
+    struct file_handler *file_handler = data;
+
+    for (;;) {
+        mutex_lock(file_handler->mutex);
+        file_handler->current_process = PROCESS_NONE;
+        while (!file_handler->stopped && request_queue_is_empty(&file_handler->queue)) {
+            cond_wait(file_handler->event_cond, file_handler->mutex);
+        }
+        if (file_handler->stopped) {
+            // stop immediately, do not process further events
+            mutex_unlock(file_handler->mutex);
+            break;
+        }
+        struct request *req;
+        SDL_bool non_empty = request_queue_take(&file_handler->queue, &req);
+        SDL_assert(non_empty);
+
+        process_t process;
+        if (req->action == ACTION_INSTALL_APK) {
+            LOGI("Installing %s...", req->file);
+            process = install_apk(file_handler->serial, req->file);
+        } else {
+            LOGI("Pushing %s...", req->file);
+            process = push_file(file_handler->serial, req->file);
+        }
+        file_handler->current_process = process;
+        mutex_unlock(file_handler->mutex);
+
+        if (req->action == ACTION_INSTALL_APK) {
+            if (process_check_success(process, "adb install")) {
+                LOGI("%s successfully installed", req->file);
+            } else {
+                LOGE("Failed to install %s", req->file);
+            }
+        } else {
+            if (process_check_success(process, "adb push")) {
+                LOGI("%s successfully pushed to /sdcard/", req->file);
+            } else {
+                LOGE("Failed to push %s to /sdcard/", req->file);
+            }
+        }
+
+        request_free(req);
+    }
+    return 0;
+}
+
+SDL_bool file_handler_start(struct file_handler *file_handler) {
+    LOGD("Starting file_handler thread");
+
+    file_handler->thread = SDL_CreateThread(run_file_handler, "file_handler", file_handler);
+    if (!file_handler->thread) {
+        LOGC("Could not start file_handler thread");
+        return SDL_FALSE;
+    }
+
+    return SDL_TRUE;
+}
+
+void file_handler_stop(struct file_handler *file_handler) {
+    mutex_lock(file_handler->mutex);
+    file_handler->stopped = SDL_TRUE;
+    cond_signal(file_handler->event_cond);
+    if (file_handler->current_process != PROCESS_NONE) {
+        if (!cmd_terminate(file_handler->current_process)) {
+            LOGW("Cannot terminate install process");
+        }
+        cmd_simple_wait(file_handler->current_process, NULL);
+        file_handler->current_process = PROCESS_NONE;
+    }
+    mutex_unlock(file_handler->mutex);
+}
+
+void file_handler_join(struct file_handler *file_handler) {
+    SDL_WaitThread(file_handler->thread, NULL);
+}

app/src/file_handler.h

@@ -0,0 +1,44 @@
+#ifndef FILE_HANDLER_H
+#define FILE_HANDLER_H
+
+#include <SDL2/SDL_mutex.h>
+#include <SDL2/SDL_stdinc.h>
+#include <SDL2/SDL_thread.h>
+#include "command.h"
+
+#define REQUEST_QUEUE_SIZE 16
+
+typedef enum {
+    ACTION_INSTALL_APK,
+    ACTION_PUSH_FILE,
+} file_handler_action_t;
+
+struct request_queue {
+    struct request *reqs[REQUEST_QUEUE_SIZE];
+    int tail;
+    int head;
+};
+
+struct file_handler {
+    const char *serial;
+    SDL_Thread *thread;
+    SDL_mutex *mutex;
+    SDL_cond *event_cond;
+    SDL_bool stopped;
+    SDL_bool initialized;
+    process_t current_process;
+    struct request_queue queue;
+};
+
+SDL_bool file_handler_init(struct file_handler *file_handler, const char *serial);
+void file_handler_destroy(struct file_handler *file_handler);
+
+SDL_bool file_handler_start(struct file_handler *file_handler);
+void file_handler_stop(struct file_handler *file_handler);
+void file_handler_join(struct file_handler *file_handler);
+
+SDL_bool file_handler_request(struct file_handler *file_handler,
+                              file_handler_action_t action,
+                              const char *file);
+
+#endif

app/src/fps_counter.c

@@ -1,4 +1,4 @@
-#include "fpscounter.h"
+#include "fps_counter.h"
 
 #include <SDL2/SDL_timer.h>
 

app/src/frames.c

@@ -6,7 +6,7 @@
 #include <libavformat/avformat.h>
 
 #include "config.h"
-#include "lockutil.h"
+#include "lock_util.h"
 #include "log.h"
 
 SDL_bool frames_init(struct frames *frames) {

app/src/frames.h

@@ -5,7 +5,7 @@
 #include <SDL2/SDL_stdinc.h>
 
 #include "config.h"
-#include "fpscounter.h"
+#include "fps_counter.h"
 
 // forward declarations
 typedef struct AVFrame AVFrame;

app/src/input_manager.c

@@ -1,7 +1,8 @@
-#include "inputmanager.h"
+#include "input_manager.h"
 
+#include <SDL2/SDL_assert.h>
 #include "convert.h"
-#include "lockutil.h"
+#include "lock_util.h"
 #include "log.h"
 
 // Convert window coordinates (as provided by SDL_GetMouseState() to renderer coordinates (as provided in SDL mouse events)
@@ -129,6 +130,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);
@@ -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;
@@ -265,7 +292,7 @@ void input_manager_process_mouse_button(struct input_manager *input_manager,
             }
             // 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)) {

app/src/input_manager.h

@@ -3,7 +3,7 @@
 
 #include "common.h"
 #include "controller.h"
-#include "fpscounter.h"
+#include "fps_counter.h"
 #include "frames.h"
 #include "screen.h"
 

app/src/installer.c

@@ -1,180 +0,0 @@
-#include "installer.h"
-
-#include <string.h>
-#include "command.h"
-#include "lockutil.h"
-#include "log.h"
-
-// NOTE(adopi) this can be more generic:
-// it could be used with a command queue instead of a filename queue
-// then we would have a generic invoker (useful if we want to handle more async commands)
-
-SDL_bool apk_queue_is_empty(const struct apk_queue *queue) {
-    return queue->head == queue->tail;
-}
-
-SDL_bool apk_queue_is_full(const struct apk_queue *queue) {
-    return (queue->head + 1) % APK_QUEUE_SIZE == queue->tail;
-}
-
-SDL_bool apk_queue_init(struct apk_queue *queue) {
-    queue->head = 0;
-    queue->tail = 0;
-    return SDL_TRUE;
-}
-
-void apk_queue_destroy(struct apk_queue *queue) {
-    int i = queue->tail;
-    while (i != queue->head) {
-        SDL_free(queue->data[i]);
-        i = (i + 1) % APK_QUEUE_SIZE;
-    }
-}
-
-SDL_bool apk_queue_push(struct apk_queue *queue, const char *apk) {
-    if (apk_queue_is_full(queue)) {
-        return SDL_FALSE;
-    }
-    queue->data[queue->head] = SDL_strdup(apk);
-    queue->head = (queue->head + 1) % APK_QUEUE_SIZE;
-    return SDL_TRUE;
-}
-
-SDL_bool apk_queue_take(struct apk_queue *queue, char **apk) {
-    if (apk_queue_is_empty(queue)) {
-        return SDL_FALSE;
-    }
-    // transfer ownership
-    *apk = queue->data[queue->tail];
-    queue->tail = (queue->tail + 1) % APK_QUEUE_SIZE;
-    return SDL_TRUE;
-}
-
-SDL_bool installer_init(struct installer *installer, const char *serial) {
-
-    if (!apk_queue_init(&installer->queue)) {
-        return SDL_FALSE;
-    }
-
-    if (!(installer->mutex = SDL_CreateMutex())) {
-        return SDL_FALSE;
-    }
-
-    if (!(installer->event_cond = SDL_CreateCond())) {
-        SDL_DestroyMutex(installer->mutex);
-        return SDL_FALSE;
-    }
-
-    if (serial) {
-        installer->serial = SDL_strdup(serial);
-        if (!installer->serial) {
-            LOGW("Cannot strdup serial");
-            return SDL_FALSE;
-        }
-    } else {
-        installer->serial = NULL;
-    }
-
-    // lazy initialization
-    installer->initialized = SDL_FALSE;
-
-    installer->stopped = SDL_FALSE;
-    installer->current_process = PROCESS_NONE;
-
-    return SDL_TRUE;
-}
-
-void installer_destroy(struct installer *installer) {
-    SDL_DestroyCond(installer->event_cond);
-    SDL_DestroyMutex(installer->mutex);
-    apk_queue_destroy(&installer->queue);
-    SDL_free((void *) installer->serial);
-}
-
-SDL_bool installer_install_apk(struct installer *installer, const char *apk) {
-    SDL_bool res;
-
-    // start installer if it's used for the first time
-    if (!installer->initialized) {
-        if (!installer_start(installer)) {
-            return SDL_FALSE;
-        }
-        installer->initialized = SDL_TRUE;
-    }
-
-    mutex_lock(installer->mutex);
-    SDL_bool was_empty = apk_queue_is_empty(&installer->queue);
-    res = apk_queue_push(&installer->queue, apk);
-    if (was_empty) {
-        cond_signal(installer->event_cond);
-    }
-    mutex_unlock(installer->mutex);
-    return res;
-}
-
-static int run_installer(void *data) {
-    struct installer *installer = data;
-
-    for (;;) {
-        mutex_lock(installer->mutex);
-        while (!installer->stopped && apk_queue_is_empty(&installer->queue)) {
-            cond_wait(installer->event_cond, installer->mutex);
-        }
-        if (installer->stopped) {
-            // stop immediately, do not process further events
-            mutex_unlock(installer->mutex);
-            break;
-        }
-        char *current_apk;
-#ifdef BUILD_DEBUG
-        bool non_empty = apk_queue_take(&installer->queue, &current_apk);
-        SDL_assert(non_empty);
-#else
-        apk_queue_take(&installer->queue, &current_apk);
-#endif
-
-        LOGI("Installing %s...", current_apk);
-        process_t process = adb_install(installer->serial, current_apk);
-        installer->current_process = process;
-
-        mutex_unlock(installer->mutex);
-
-        if (process_check_success(process, "adb install")) {
-            LOGI("%s installed successfully", current_apk);
-        } else {
-            LOGE("Failed to install %s", current_apk);
-        }
-        SDL_free(current_apk);
-    }
-    return 0;
-}
-
-SDL_bool installer_start(struct installer *installer) {
-    LOGD("Starting installer thread");
-
-    installer->thread = SDL_CreateThread(run_installer, "installer", installer);
-    if (!installer->thread) {
-        LOGC("Could not start installer thread");
-        return SDL_FALSE;
-    }
-
-    return SDL_TRUE;
-}
-
-void installer_stop(struct installer *installer) {
-    mutex_lock(installer->mutex);
-    installer->stopped = SDL_TRUE;
-    cond_signal(installer->event_cond);
-    if (installer->current_process != PROCESS_NONE) {
-        if (!cmd_terminate(installer->current_process)) {
-            LOGW("Cannot terminate install process");
-        }
-        cmd_simple_wait(installer->current_process, NULL);
-        installer->current_process = PROCESS_NONE;
-    }
-    mutex_unlock(installer->mutex);
-}
-
-void installer_join(struct installer *installer) {
-    SDL_WaitThread(installer->thread, NULL);
-}

app/src/installer.h

@@ -1,40 +0,0 @@
-#ifndef APK_INSTALLER_H
-#define APK_INSTALLER_H
-
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_stdinc.h>
-#include <SDL2/SDL_thread.h>
-#include "command.h"
-
-#define APK_QUEUE_SIZE 16
-
-// NOTE(AdoPi) apk_queue and control_event can use a generic queue
-
-struct apk_queue {
-    char *data[APK_QUEUE_SIZE];
-    int tail;
-    int head;
-};
-
-struct installer {
-    const char *serial;
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *event_cond;
-    SDL_bool stopped;
-    SDL_bool initialized;
-    process_t current_process;
-    struct apk_queue queue;
-};
-
-SDL_bool installer_init(struct installer *installer, const char *serial);
-void installer_destroy(struct installer *installer);
-
-SDL_bool installer_start(struct installer *installer);
-void installer_stop(struct installer *installer);
-void installer_join(struct installer *installer);
-
-// install an apk
-SDL_bool installer_install_apk(struct installer *installer, const char *filename);
-
-#endif

app/src/lock_util.c

@@ -1,3 +1,4 @@
+#include <lock_util.h>
 #include <stdlib.h>
 #include <SDL2/SDL_mutex.h>
 

app/src/main.c

@@ -10,6 +10,8 @@
 
 struct args {
     const char *serial;
+    const char *crop;
+    SDL_bool fullscreen;
     SDL_bool help;
     SDL_bool version;
     SDL_bool show_touches;
@@ -29,6 +31,15 @@ static void usage(const char *arg0) {
         "        Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
         "        Default is %d.\n"
         "\n"
+        "    -c, --crop width:height:x:y\n"
+        "        Crop the device screen on the server.\n"
+        "        The values are expressed in the device natural orientation\n"
+        "        (typically, portrait for a phone, landscape for a tablet).\n"
+        "        Any --max-size value is computed on the cropped size.\n"
+        "\n"
+        "    -f, --fullscreen\n"
+        "        Start in fullscreen.\n"
+        "\n"
         "    -h, --help\n"
         "        Print this help.\n"
         "\n"
@@ -192,6 +203,8 @@ 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'},
@@ -201,13 +214,19 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
         {NULL,           0,                 NULL, 0  },
     };
     int c;
-    while ((c = getopt_long(argc, argv, "b:hm:p:s:tv", long_options, NULL)) != -1) {
+    while ((c = getopt_long(argc, argv, "b:c:fhm:p:s:tv", long_options, NULL)) != -1) {
         switch (c) {
             case 'b':
                 if (!parse_bit_rate(optarg, &args->bit_rate)) {
                     return SDL_FALSE;
                 }
                 break;
+            case 'c':
+                args->crop = optarg;
+                break;
+            case 'f':
+                args->fullscreen = SDL_TRUE;
+                break;
             case 'h':
                 args->help = SDL_TRUE;
                 break;
@@ -253,6 +272,7 @@ int main(int argc, char *argv[]) {
 #endif
     struct args args = {
         .serial = NULL,
+        .crop = NULL,
         .help = SDL_FALSE,
         .version = SDL_FALSE,
         .show_touches = SDL_FALSE,
@@ -274,7 +294,9 @@ int main(int argc, char *argv[]) {
         return 0;
     }
 
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 9, 100)
     av_register_all();
+#endif
 
     if (avformat_network_init()) {
         return 1;
@@ -286,14 +308,22 @@ int main(int argc, char *argv[]) {
 
     struct scrcpy_options options = {
         .serial = args.serial,
+        .crop = args.crop,
         .port = args.port,
         .max_size = args.max_size,
         .bit_rate = args.bit_rate,
         .show_touches = args.show_touches,
+        .fullscreen = args.fullscreen,
     };
     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;
 }

app/src/scrcpy.c

@@ -13,23 +13,23 @@
 #include "decoder.h"
 #include "device.h"
 #include "events.h"
+#include "file_handler.h"
 #include "frames.h"
-#include "fpscounter.h"
-#include "inputmanager.h"
+#include "fps_counter.h"
+#include "input_manager.h"
 #include "log.h"
-#include "lockutil.h"
+#include "lock_util.h"
 #include "net.h"
 #include "screen.h"
 #include "server.h"
-#include "tinyxpm.h"
-#include "installer.h"
+#include "tiny_xpm.h"
 
 static struct server server = SERVER_INITIALIZER;
 static struct screen screen = SCREEN_INITIALIZER;
 static struct frames frames;
 static struct decoder decoder;
 static struct controller controller;
-static struct installer installer;
+static struct file_handler file_handler;
 
 static struct input_manager input_manager = {
     .controller = &controller,
@@ -56,7 +56,12 @@ static int event_watcher(void *data, SDL_Event *event) {
 }
 #endif
 
-static void event_loop(void) {
+static SDL_bool is_apk(const char *file) {
+    const char *ext = strrchr(file, '.');
+    return ext && !strcmp(ext, ".apk");
+}
+
+static SDL_bool event_loop(void) {
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
     SDL_AddEventWatch(event_watcher, NULL);
 #endif
@@ -65,10 +70,10 @@ static void event_loop(void) {
         switch (event.type) {
             case EVENT_DECODER_STOPPED:
                 LOGD("Video decoder stopped");
-                return;
+                return SDL_FALSE;
             case SDL_QUIT:
                 LOGD("User requested to quit");
-                return;
+                return SDL_TRUE;
             case EVENT_NEW_FRAME:
                 if (!screen.has_frame) {
                     screen.has_frame = SDL_TRUE;
@@ -76,7 +81,7 @@ static void event_loop(void) {
                     screen_show_window(&screen);
                 }
                 if (!screen_update_frame(&screen, &frames)) {
-                    return;
+                    return SDL_FALSE;
                 }
                 break;
             case SDL_WINDOWEVENT:
@@ -104,11 +109,19 @@ static void event_loop(void) {
             case SDL_MOUSEBUTTONUP:
                 input_manager_process_mouse_button(&input_manager, &event.button);
                 break;
-            case SDL_DROPFILE:
-                installer_install_apk(&installer, event.drop.file);
+            case SDL_DROPFILE: {
+                file_handler_action_t action;
+                if (is_apk(event.drop.file)) {
+                    action = ACTION_INSTALL_APK;
+                } else {
+                    action = ACTION_PUSH_FILE;
+                }
+                file_handler_request(&file_handler, action, event.drop.file);
                 break;
+            }
         }
     }
+    return SDL_FALSE;
 }
 
 static process_t set_show_touches_enabled(const char *serial, SDL_bool enabled) {
@@ -126,7 +139,7 @@ static void wait_show_touches(process_t process) {
 
 SDL_bool scrcpy(const struct scrcpy_options *options) {
     if (!server_start(&server, options->serial, options->port,
-                      options->max_size, options->bit_rate)) {
+                      options->max_size, options->bit_rate, options->crop)) {
         return SDL_FALSE;
     }
 
@@ -174,7 +187,7 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
         goto finally_destroy_server;
     }
 
-    if (!installer_init(&installer, server.serial)) {
+    if (!file_handler_init(&file_handler, server.serial)) {
         ret = SDL_FALSE;
         server_stop(&server);
         goto finally_destroy_frames;
@@ -187,7 +200,7 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
     if (!decoder_start(&decoder)) {
         ret = SDL_FALSE;
         server_stop(&server);
-        goto finally_destroy_installer;
+        goto finally_destroy_file_handler;
     }
 
     if (!controller_init(&controller, device_socket)) {
@@ -210,7 +223,11 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
         show_touches_waited = SDL_TRUE;
     }
 
-    event_loop();
+    if (options->fullscreen) {
+        screen_switch_fullscreen(&screen);
+    }
+
+    ret = event_loop();
     LOGD("quit...");
 
     screen_destroy(&screen);
@@ -225,10 +242,10 @@ finally_stop_decoder:
     // stop the server before decoder_join() to wake up the decoder
     server_stop(&server);
     decoder_join(&decoder);
-finally_destroy_installer:
-    installer_stop(&installer);
-    installer_join(&installer);
-    installer_destroy(&installer);
+finally_destroy_file_handler:
+    file_handler_stop(&file_handler);
+    file_handler_join(&file_handler);
+    file_handler_destroy(&file_handler);
 finally_destroy_frames:
     frames_destroy(&frames);
 finally_destroy_server:

app/src/scrcpy.h

@@ -5,10 +5,12 @@
 
 struct scrcpy_options {
     const char *serial;
+    const char *crop;
     Uint16 port;
     Uint16 max_size;
     Uint32 bit_rate;
     SDL_bool show_touches;
+    SDL_bool fullscreen;
 };
 
 SDL_bool scrcpy(const struct scrcpy_options *options);

app/src/screen.c

@@ -4,9 +4,9 @@
 #include <string.h>
 
 #include "icon.xpm"
-#include "lockutil.h"
+#include "lock_util.h"
 #include "log.h"
-#include "tinyxpm.h"
+#include "tiny_xpm.h"
 
 #define DISPLAY_MARGINS 96
 

app/src/server.c

@@ -77,7 +77,8 @@ static SDL_bool disable_tunnel(struct server *server) {
 }
 
 static process_t execute_server(const char *serial,
-                                Uint16 max_size, Uint32 bit_rate, SDL_bool tunnel_forward) {
+                                Uint16 max_size, Uint32 bit_rate,
+                                const char *crop, SDL_bool tunnel_forward) {
     char max_size_string[6];
     char bit_rate_string[11];
     sprintf(max_size_string, "%"PRIu16, max_size);
@@ -91,6 +92,7 @@ static process_t execute_server(const char *serial,
         max_size_string,
         bit_rate_string,
         tunnel_forward ? "true" : "false",
+        crop ? crop : "",
     };
     return adb_execute(serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
 }
@@ -147,7 +149,7 @@ void server_init(struct server *server) {
 }
 
 SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port,
-                      Uint16 max_size, Uint32 bit_rate) {
+                      Uint16 max_size, Uint32 bit_rate, const char *crop) {
     server->local_port = local_port;
 
     if (serial) {
@@ -188,7 +190,8 @@ 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, server->tunnel_forward);
+    server->process = execute_server(serial, max_size, bit_rate, crop,
+                                     server->tunnel_forward);
     if (server->process == PROCESS_NONE) {
         if (!server->tunnel_forward) {
             close_socket(&server->server_socket);
@@ -207,7 +210,7 @@ socket_t server_connect_to(struct server *server) {
     if (!server->tunnel_forward) {
         server->device_socket = net_accept(server->server_socket);
     } else {
-        Uint32 attempts = 50;
+        Uint32 attempts = 100;
         Uint32 delay = 100; // ms
         server->device_socket = connect_to_server(server->local_port, attempts, delay);
     }

app/src/server.h

@@ -31,7 +31,7 @@ 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);
+                      Uint16 max_size, Uint32 bit_rate, const char *crop);
 
 // block until the communication with the server is established
 socket_t server_connect_to(struct server *server);

app/src/str_util.c

@@ -1,4 +1,7 @@
-#include "strutil.h"
+#include "str_util.h"
+
+#include <stdlib.h>
+#include <string.h>
 
 size_t xstrncpy(char *dest, const char *src, size_t n) {
     size_t 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;
+}

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

app/src/sys/unix/command.c

@@ -1,5 +1,7 @@
 #include "command.h"
 
+#include <errno.h>
+#include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ -7,18 +9,65 @@
 #include <unistd.h>
 #include "log.h"
 
-pid_t cmd_execute(const char *path, const char *const argv[]) {
-    pid_t pid = fork();
-    if (pid == -1) {
-        perror("fork");
-        return -1;
+enum process_result cmd_execute(const char *path, const char *const argv[], pid_t *pid) {
+    int fd[2];
+
+    if (pipe(fd) == -1) {
+        perror("pipe");
+        return PROCESS_ERROR_GENERIC;
     }
-    if (pid == 0) {
-        execvp(path, (char *const *)argv);
-        perror("exec");
+
+    enum process_result ret = PROCESS_SUCCESS;
+
+    *pid = fork();
+    if (*pid == -1) {
+        perror("fork");
+        ret = PROCESS_ERROR_GENERIC;
+        goto end;
+    }
+
+    if (*pid > 0) {
+        // parent close write side
+        close(fd[1]);
+        fd[1] = -1;
+        // wait for EOF or receive errno from child
+        if (read(fd[0], &ret, sizeof(ret)) == -1) {
+            perror("read");
+            ret = PROCESS_ERROR_GENERIC;
+            goto end;
+        }
+    } else if (*pid == 0) {
+        // child close read side
+        close(fd[0]);
+        if (fcntl(fd[1], F_SETFD, FD_CLOEXEC) == 0) {
+            execvp(path, (char *const *)argv);
+            if (errno == ENOENT) {
+                ret = PROCESS_ERROR_MISSING_BINARY;
+            } else {
+                ret = PROCESS_ERROR_GENERIC;
+            }
+            perror("exec");
+        } else {
+            perror("fcntl");
+            ret = PROCESS_ERROR_GENERIC;
+        }
+        // send ret to the parent
+        if (write(fd[1], &ret, sizeof(ret)) == -1) {
+            perror("write");
+        }
+        // close write side before exiting
+        close(fd[1]);
         _exit(1);
     }
-    return pid;
+
+end:
+    if (fd[0] != -1) {
+        close(fd[0]);
+    }
+    if (fd[1] != -1) {
+        close(fd[1]);
+    }
+    return ret;
 }
 
 SDL_bool cmd_terminate(pid_t pid) {

app/src/sys/win/command.c

@@ -2,23 +2,31 @@
 
 #include "config.h"
 #include "log.h"
-#include "strutil.h"
+#include "str_util.h"
 
-HANDLE cmd_execute(const char *path, const char *const argv[]) {
+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);
-        return NULL;
+    if (build_cmd(cmd, sizeof(cmd), argv)) {
+        *handle = NULL;
+        return PROCESS_ERROR_GENERIC;
     }
 
 #ifdef WINDOWS_NOCONSOLE
@@ -27,10 +35,15 @@ HANDLE cmd_execute(const char *path, const char *const argv[]) {
     int flags = 0;
 #endif
     if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, flags, NULL, NULL, &si, &pi)) {
-        return NULL;
+        *handle = NULL;
+        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
+            return PROCESS_ERROR_MISSING_BINARY;
+        }
+        return PROCESS_ERROR_GENERIC;
     }
 
-    return pi.hProcess;
+    *handle = pi.hProcess;
+    return PROCESS_SUCCESS;
 }
 
 SDL_bool cmd_terminate(HANDLE handle) {

app/src/tiny_xpm.c

@@ -1,4 +1,4 @@
-#include "tinyxpm.h"
+#include "tiny_xpm.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -40,15 +40,15 @@ SDL_Surface *read_xpm(char *xpm[]) {
     // *** No error handling, assume the XPM source is valid ***
     // (it's in our source repo)
     // Assertions are only checked in debug
-    Uint32 width = strtol(xpm[0], &endptr, 10);
-    Uint32 height = strtol(endptr + 1, &endptr, 10);
-    Uint32 colors = strtol(endptr + 1, &endptr, 10);
-    Uint32 chars = strtol(endptr + 1, &endptr, 10);
+    int width = strtol(xpm[0], &endptr, 10);
+    int height = strtol(endptr + 1, &endptr, 10);
+    int colors = strtol(endptr + 1, &endptr, 10);
+    int chars = strtol(endptr + 1, &endptr, 10);
 
     // sanity checks
-    SDL_assert(width < 256);
-    SDL_assert(height < 256);
-    SDL_assert(colors < 256);
+    SDL_assert(0 <= width && width < 256);
+    SDL_assert(0 <= height && height < 256);
+    SDL_assert(0 <= colors && colors < 256);
     SDL_assert(chars == 1); // this implementation does not support more
 
     // init index

app/tests/test_control_event_queue.c

@@ -1,9 +1,9 @@
 #include <assert.h>
 #include <string.h>
 
-#include "controlevent.h"
+#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();

app/tests/test_control_event_serialize.c

@@ -1,9 +1,9 @@
 #include <assert.h>
 #include <string.h>
 
-#include "controlevent.h"
+#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;
 }

app/tests/test_strutil.c

@@ -1,9 +1,9 @@
 #include <assert.h>
 #include <string.h>
 
-#include "strutil.h"
+#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();

cross_win32.txt

@@ -15,6 +15,6 @@ cpu = 'i686'
 endian = 'little'
 
 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.0-win32-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.0-win32-dev'
+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'

cross_win64.txt

@@ -15,6 +15,6 @@ cpu = 'x86_64'
 endian = 'little'
 
 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.0-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.0-win64-dev'
+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'

meson.build

@@ -1,4 +1,4 @@
-project('scrcpy', 'c', meson_version: '>= 0.37', default_options : 'c_std=c99')
+project('scrcpy', 'c', meson_version: '>= 0.37', default_options : 'c_std=c11')
 
 if get_option('build_app')
     subdir('app')

prebuilt-deps/Makefile

@@ -10,24 +10,24 @@ 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-win32-shared.zip \
-		530c92df0ca14c35901b4b681847d62da3c50a0cc9b7ced37b04968f6b5c243d \
-		ffmpeg-4.0-win32-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.0.2-win32-shared.zip \
+		cc190a3a4cf7bfbd4fbaa92609c1501a1de458055e6cfea8b745c1d515013aa8 \
+		ffmpeg-4.0.2-win32-shared
 
 prepare-ffmpeg-dev-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.0-win32-dev.zip \
-		e2f5200b5e73c4d0abb9b89c4ffc0438f92a0aadc54c81cf57e18c81a9f11c6b \
-		ffmpeg-4.0-win32-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.0.2-win32-dev.zip \
+		c72c74bad74ac0541f1b43090c26a50017c49041c182a703abd2057bb8cdc238 \
+		ffmpeg-4.0.2-win32-dev
 
 prepare-ffmpeg-shared-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.0-win64-shared.zip \
-		8fe2d344463dbefc2db4239a4203a55ed0324faceaae57276a40c4fabda84c37 \
-		ffmpeg-4.0-win64-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.0.2-win64-shared.zip \
+		ede566aca8b5348dff85570f9638c6bad33209f9419f79db7bde7daa37599bff \
+		ffmpeg-4.0.2-win64-shared
 
 prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.0-win64-dev.zip \
-		facced738eabfc53fa92834dea8b24426f64db61298688fed480145945be07fa \
-		ffmpeg-4.0-win64-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.0.2-win64-dev.zip \
+		23ee994161c51285cb956b98d3caa499d48083dae7b26c1fdf77f22e98df1c5f \
+		ffmpeg-4.0.2-win64-dev
 
 prepare-sdl2:
 	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.8-mingw.tar.gz \
@@ -35,6 +35,6 @@ prepare-sdl2:
 		SDL2-2.0.8
 
 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r27.0.1-windows.zip \
-	    880662adfb0d6911ff250b9e13930ae1a4110fc36d5866afd4f8f56d935f7939 \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r28.0.1-windows.zip \
+		db78f726d5dc653706dcd15a462ab1b946c643f598df76906c4c1858411c54df \
 		platform-tools

server/build.gradle

@@ -6,8 +6,8 @@ android {
         applicationId "com.genymobile.scrcpy"
         minSdkVersion 21
         targetSdkVersion 27
-        versionCode 3
-        versionName "1.2"
+        versionCode 5
+        versionName "1.4"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
     }
     buildTypes {

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

@@ -5,9 +5,9 @@ import android.net.LocalSocket;
 import android.net.LocalSocketAddress;
 
 import java.io.Closeable;
+import java.io.FileDescriptor;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
 
 public final class DesktopConnection implements Closeable {
@@ -18,14 +18,14 @@ public final class DesktopConnection implements Closeable {
 
     private final LocalSocket socket;
     private final InputStream inputStream;
-    private final OutputStream outputStream;
+    private final FileDescriptor fd;
 
     private final ControlEventReader reader = new ControlEventReader();
 
     private DesktopConnection(LocalSocket socket) throws IOException {
         this.socket = socket;
         inputStream = socket.getInputStream();
-        outputStream = socket.getOutputStream();
+        fd = socket.getFileDescriptor();
     }
 
     private static LocalSocket connect(String abstractName) throws IOException {
@@ -78,11 +78,11 @@ public final class DesktopConnection implements Closeable {
         buffer[DEVICE_NAME_FIELD_LENGTH + 1] = (byte) width;
         buffer[DEVICE_NAME_FIELD_LENGTH + 2] = (byte) (height >> 8);
         buffer[DEVICE_NAME_FIELD_LENGTH + 3] = (byte) height;
-        outputStream.write(buffer, 0, buffer.length);
+        IO.writeFully(fd, buffer, 0, buffer.length);
     }
 
-    public OutputStream getOutputStream() {
-        return outputStream;
+    public FileDescriptor getFd() {
+        return fd;
     }
 
     public ControlEvent receiveControlEvent() throws IOException {

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

@@ -3,6 +3,7 @@ package com.genymobile.scrcpy;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 
 import android.graphics.Point;
+import android.graphics.Rect;
 import android.os.Build;
 import android.os.RemoteException;
 import android.view.IRotationWatcher;
@@ -20,7 +21,7 @@ public final class Device {
     private RotationListener rotationListener;
 
     public Device(Options options) {
-        screenInfo = computeScreenInfo(options.getMaxSize());
+        screenInfo = computeScreenInfo(options.getCrop(), options.getMaxSize());
         registerRotationWatcher(new IRotationWatcher.Stub() {
             @Override
             public void onRotationChanged(int rotation) throws RemoteException {
@@ -40,18 +41,40 @@ public final class Device {
         return screenInfo;
     }
 
+    private ScreenInfo computeScreenInfo(Rect crop, int maxSize) {
+        DisplayInfo displayInfo = serviceManager.getDisplayManager().getDisplayInfo();
+        boolean rotated = (displayInfo.getRotation() & 1) != 0;
+        Size deviceSize = displayInfo.getSize();
+        Rect contentRect = new Rect(0, 0, deviceSize.getWidth(), deviceSize.getHeight());
+        if (crop != null) {
+            if (rotated) {
+                // the crop (provided by the user) is expressed in the natural orientation
+                crop = flipRect(crop);
+            }
+            if (!contentRect.intersect(crop)) {
+                // intersect() changes contentRect so that it is intersected with crop
+                Ln.w("Crop rectangle (" + formatCrop(crop) + ") does not intersect device screen (" + formatCrop(deviceSize.toRect()) + ")");
+                contentRect = new Rect(); // empty
+            }
+        }
+
+        Size videoSize = computeVideoSize(contentRect.width(), contentRect.height(), maxSize);
+        return new ScreenInfo(contentRect, videoSize, rotated);
+    }
+
+    private static String formatCrop(Rect rect) {
+        return rect.width() + ":" + rect.height() + ":" + rect.left + ":" + rect.top;
+    }
+
     @SuppressWarnings("checkstyle:MagicNumber")
-    private ScreenInfo computeScreenInfo(int maxSize) {
+    private static Size computeVideoSize(int w, int h, int maxSize) {
         // Compute the video size and the padding of the content inside this video.
         // Principle:
         // - scale down the great side of the screen to maxSize (if necessary);
         // - scale down the other side so that the aspect ratio is preserved;
         // - round this value to the nearest multiple of 8 (H.264 only accepts multiples of 8)
-        DisplayInfo displayInfo = serviceManager.getDisplayManager().getDisplayInfo();
-        boolean rotated = (displayInfo.getRotation() & 1) != 0;
-        Size deviceSize = displayInfo.getSize();
-        int w = deviceSize.getWidth() & ~7; // in case it's not a multiple of 8
-        int h = deviceSize.getHeight() & ~7;
+        w &= ~7; // in case it's not a multiple of 8
+        h &= ~7;
         if (maxSize > 0) {
             if (BuildConfig.DEBUG && maxSize % 8 != 0) {
                 throw new AssertionError("Max size must be a multiple of 8");
@@ -68,12 +91,12 @@ public final class Device {
             w = portrait ? minor : major;
             h = portrait ? major : minor;
         }
-        Size videoSize = new Size(w, h);
-        return new ScreenInfo(deviceSize, videoSize, rotated);
+        return new Size(w, h);
     }
 
     public Point getPhysicalPoint(Position position) {
-        @SuppressWarnings("checkstyle:HiddenField") // it hides the field on purpose, to read it with a lock
+        // it hides the field on purpose, to read it with a lock
+        @SuppressWarnings("checkstyle:HiddenField")
         ScreenInfo screenInfo = getScreenInfo(); // read with synchronization
         Size videoSize = screenInfo.getVideoSize();
         Size clientVideoSize = position.getScreenSize();
@@ -82,10 +105,10 @@ public final class Device {
             // the device may have been rotated since the event was generated, so ignore the event
             return null;
         }
-        Size deviceSize = screenInfo.getDeviceSize();
+        Rect contentRect = screenInfo.getContentRect();
         Point point = position.getPoint();
-        int scaledX = point.x * deviceSize.getWidth() / videoSize.getWidth();
-        int scaledY = point.y * deviceSize.getHeight() / videoSize.getHeight();
+        int scaledX = contentRect.left + point.x * contentRect.width() / videoSize.getWidth();
+        int scaledY = contentRect.top + point.y * contentRect.height() / videoSize.getHeight();
         return new Point(scaledX, scaledY);
     }
 
@@ -108,4 +131,8 @@ public final class Device {
     public synchronized void setRotationListener(RotationListener rotationListener) {
         this.rotationListener = rotationListener;
     }
+
+    static Rect flipRect(Rect crop) {
+        return new Rect(crop.top, crop.left, crop.bottom, crop.right);
+    }
 }

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

@@ -0,0 +1,40 @@
+package com.genymobile.scrcpy;
+
+import android.system.ErrnoException;
+import android.system.Os;
+import android.system.OsConstants;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+public class IO {
+    private IO() {
+        // not instantiable
+    }
+
+    public static void writeFully(FileDescriptor fd, ByteBuffer from) throws IOException {
+        // 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 {
+                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);
+                }
+            }
+        }
+    }
+
+    public static void writeFully(FileDescriptor fd, byte[] buffer, int offset, int len) throws IOException {
+        writeFully(fd, ByteBuffer.wrap(buffer, offset, len));
+    }
+}

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

@@ -1,9 +1,12 @@
 package com.genymobile.scrcpy;
 
+import android.graphics.Rect;
+
 public class Options {
     private int maxSize;
     private int bitRate;
     private boolean tunnelForward;
+    private Rect crop;
 
     public int getMaxSize() {
         return maxSize;
@@ -28,4 +31,12 @@ public class Options {
     public void setTunnelForward(boolean tunnelForward) {
         this.tunnelForward = tunnelForward;
     }
+
+    public Rect getCrop() {
+        return crop;
+    }
+
+    public void setCrop(Rect crop) {
+        this.crop = crop;
+    }
 }

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

@@ -9,8 +9,8 @@ import android.media.MediaFormat;
 import android.os.IBinder;
 import android.view.Surface;
 
+import java.io.FileDescriptor;
 import java.io.IOException;
-import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ -48,7 +48,7 @@ public class ScreenEncoder implements Device.RotationListener {
         return rotationChanged.getAndSet(false);
     }
 
-    public void streamScreen(Device device, OutputStream outputStream) throws IOException {
+    public void streamScreen(Device device, FileDescriptor fd) throws IOException {
         MediaFormat format = createFormat(bitRate, frameRate, iFrameInterval);
         device.setRotationListener(this);
         boolean alive;
@@ -56,15 +56,15 @@ public class ScreenEncoder implements Device.RotationListener {
             do {
                 MediaCodec codec = createCodec();
                 IBinder display = createDisplay();
-                Rect deviceRect = device.getScreenInfo().getDeviceSize().toRect();
+                Rect contentRect = device.getScreenInfo().getContentRect();
                 Rect videoRect = device.getScreenInfo().getVideoSize().toRect();
                 setSize(format, videoRect.width(), videoRect.height());
                 configure(codec, format);
                 Surface surface = codec.createInputSurface();
-                setDisplaySurface(display, surface, deviceRect, videoRect);
+                setDisplaySurface(display, surface, contentRect, videoRect);
                 codec.start();
                 try {
-                    alive = encode(codec, outputStream);
+                    alive = encode(codec, fd);
                 } finally {
                     codec.stop();
                     destroyDisplay(display);
@@ -77,9 +77,7 @@ public class ScreenEncoder implements Device.RotationListener {
         }
     }
 
-    private boolean encode(MediaCodec codec, OutputStream outputStream) throws IOException {
-        @SuppressWarnings("checkstyle:MagicNumber")
-        byte[] buf = new byte[bitRate / 8]; // may contain up to 1 second of video
+    private boolean encode(MediaCodec codec, FileDescriptor fd) throws IOException {
         boolean eof = false;
         MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
         while (!consumeRotationChange() && !eof) {
@@ -91,15 +89,8 @@ public class ScreenEncoder implements Device.RotationListener {
                     break;
                 }
                 if (outputBufferId >= 0) {
-                    ByteBuffer outputBuffer = codec.getOutputBuffer(outputBufferId);
-                    while (outputBuffer.hasRemaining()) {
-                        int remaining = outputBuffer.remaining();
-                        int len = Math.min(buf.length, remaining);
-                        // the outputBuffer is probably direct (it has no underlying array), and LocalSocket does not expose channels,
-                        // so we must copy the data locally to write them manually to the output stream
-                        outputBuffer.get(buf, 0, len);
-                        outputStream.write(buf, 0, len);
-                    }
+                    ByteBuffer codecBuffer = codec.getOutputBuffer(outputBufferId);
+                    IO.writeFully(fd, codecBuffer);
                 }
             } finally {
                 if (outputBufferId >= 0) {

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

@@ -1,18 +1,20 @@
 package com.genymobile.scrcpy;
 
+import android.graphics.Rect;
+
 public final class ScreenInfo {
-    private final Size deviceSize;
+    private final Rect contentRect; // device size, possibly cropped
     private final Size videoSize;
     private final boolean rotated;
 
-    public ScreenInfo(Size deviceSize, Size videoSize, boolean rotated) {
-        this.deviceSize = deviceSize;
+    public ScreenInfo(Rect contentRect, Size videoSize, boolean rotated) {
+        this.contentRect = contentRect;
         this.videoSize = videoSize;
         this.rotated = rotated;
     }
 
-    public Size getDeviceSize() {
-        return deviceSize;
+    public Rect getContentRect() {
+        return contentRect;
     }
 
     public Size getVideoSize() {
@@ -24,6 +26,6 @@ public final class ScreenInfo {
         if (rotated == newRotated) {
             return this;
         }
-        return new ScreenInfo(deviceSize.rotate(), videoSize.rotate(), newRotated);
+        return new ScreenInfo(Device.flipRect(contentRect), videoSize.rotate(), newRotated);
     }
 }

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

@@ -1,5 +1,7 @@
 package com.genymobile.scrcpy;
 
+import android.graphics.Rect;
+
 import java.io.IOException;
 
 public final class Server {
@@ -19,7 +21,7 @@ public final class Server {
 
             try {
                 // synchronous
-                screenEncoder.streamScreen(device, connection.getOutputStream());
+                screenEncoder.streamScreen(device, connection.getFd());
             } catch (IOException e) {
                 // this is expected on close
                 Ln.d("Screen streaming stopped");
@@ -63,9 +65,31 @@ public final class Server {
         boolean tunnelForward = Boolean.parseBoolean(args[2]);
         options.setTunnelForward(tunnelForward);
 
+        if (args.length < 4) {
+            return options;
+        }
+        Rect crop = parseCrop(args[3]);
+        options.setCrop(crop);
+
         return options;
     }
 
+    private static Rect parseCrop(String crop) {
+        if (crop.isEmpty()) {
+            return null;
+        }
+        // input format: "width:height:x:y"
+        String[] tokens = crop.split(":");
+        if (tokens.length != 4) {
+            throw new IllegalArgumentException("Crop must contains 4 values separated by colons: \"" + crop + "\"");
+        }
+        int width = Integer.parseInt(tokens[0]);
+        int height = Integer.parseInt(tokens[1]);
+        int x = Integer.parseInt(tokens[2]);
+        int y = Integer.parseInt(tokens[3]);
+        return new Rect(x, y, x + width, y + height);
+    }
+
     public static void main(String... args) throws Exception {
         Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
             @Override