Support Android API 19

Since "adb forward" fallback has been implemented, it is easy to support
API 19.

Replace the incompatible calls related to MediaCodec to use
minSdkVersion 19 instead of 21.

FAQ.md

@@ -7,8 +7,29 @@ with it.
 
 Here are the common reported problems and their status.
 
+### On Windows, I have no output in the console
 
-### On Windows, my device is not detected
+When run in `cmd.exe`, the application does not print anything. Even `scrcpy
+--help` have no output. We don't know why yet.
+
+However, if you run the very same `scrcpy.exe` from
+[MSYS2](https://www.msys2.org/) (`mingw64`), then it correctly prints output.
+
+As a workaround, redirect outputs to files, so that you can read the files
+afterwards:
+
+```bash
+scrcpy >stdout 2>stderr
+type stdout
+type stderr
+```
+
+_Note that all SDL logs are printed to stderr._
+
+
+### On Windows, when I start the application, nothing happens
+
+The previous problem does not help to get a clue about the cause.
 
 The most common is your device not being detected by `adb`, or is unauthorized.
 Check everything is ok by calling:
@@ -58,12 +79,3 @@ meson x --buildtype release -Dhidpi_support=false
 ```
 
 However, the video will be displayed at lower resolution.
-
-
-### KWin compositor crashes
-
-On Plasma Desktop, compositor is disabled while _scrcpy_ is running.
-
-As a workaround, [disable "Block compositing"][kwin].
-
-[kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613

Makefile

@@ -0,0 +1,62 @@
+# This makefile provides recipes to build a "portable" version of scrcpy.
+#
+# Here, "portable" means that the client and server binaries are expected to be
+# anywhere, but in the same directory, instead of well-defined separate
+# locations (e.g. /usr/bin/scrcpy and /usr/share/scrcpy/scrcpy-server.jar).
+#
+# In particular, this implies to change the location from where the client push
+# the server to the device.
+#
+# "make release-portable" builds a zip containing the client and the server.
+#
+# This is a simple Makefile because Meson is not flexible enough to execute some
+# arbitrary commands.
+
+.PHONY: default clean build-portable release-portable dist-portable dist-portable-zip sums test check
+
+GRADLE ?= ./gradlew
+
+PORTABLE_BUILD_DIR := build-portable
+DIST := dist
+TARGET_DIR := scrcpy
+
+VERSION := $(shell git describe --tags --always)
+TARGET := $(TARGET_DIR)-$(VERSION).zip
+
+default:
+	@echo 'You must specify a target. Try: make release-portable'
+
+clean:
+	$(GRADLE) clean
+	rm -rf "$(PORTABLE_BUILD_DIR)" "$(DIST)"
+
+build-portable:
+	[ -d "$(PORTABLE_BUILD_DIR)" ] || ( mkdir "$(PORTABLE_BUILD_DIR)" && \
+		meson "$(PORTABLE_BUILD_DIR)" \
+			--buildtype release --strip -Db_lto=true \
+			-Doverride_server_path=scrcpy-server.jar )
+	ninja -C "$(PORTABLE_BUILD_DIR)"
+
+release-portable: clean dist-portable-zip sums
+	@echo "Release created in $(DIST)/."
+
+dist-portable: build-portable
+	mkdir -p "$(DIST)/$(TARGET_DIR)"
+	cp "$(PORTABLE_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(TARGET_DIR)/"
+	cp "$(PORTABLE_BUILD_DIR)"/app/scrcpy "$(DIST)/$(TARGET_DIR)/"
+
+dist-portable-zip: dist-portable
+	cd "$(DIST)"; \
+		zip -r "$(TARGET)" "$(TARGET_DIR)"
+
+sums:
+	cd "$(DIST)"; \
+		sha256sum *.zip > SHA256SUM.txt
+
+test: build-portable
+	$(GRADLE) test
+	ninja -C "$(PORTABLE_BUILD_DIR)" test
+
+check: build-portable
+	$(GRADLE) check
+	ninja -C "$(PORTABLE_BUILD_DIR)" test

Makefile.CrossWindows

@@ -1,136 +0,0 @@
-# This makefile provides recipes to build a "portable" version of scrcpy for
-# Windows.
-#
-# Here, "portable" means that the client and server binaries are expected to be
-# anywhere, but in the same directory, instead of well-defined separate
-# locations (e.g. /usr/bin/scrcpy and /usr/share/scrcpy/scrcpy-server.jar).
-#
-# In particular, this implies to change the location from where the client push
-# the server to the device.
-
-.PHONY: default clean \
-	build-server \
-	prepare-deps-win32 prepare-deps-win64 \
-	build-win32 build-win32-noconsole \
-	build-win64 build-win64-noconsole \
-	dist-win32 dist-win64 \
-	zip-win32 zip-win64 \
-	sums release
-
-GRADLE ?= ./gradlew
-
-SERVER_BUILD_DIR := build-server
-WIN32_BUILD_DIR := build-win32
-WIN32_NOCONSOLE_BUILD_DIR := build-win32-noconsole
-WIN64_BUILD_DIR := build-win64
-WIN64_NOCONSOLE_BUILD_DIR := build-win64-noconsole
-
-DIST := dist
-WIN32_TARGET_DIR := scrcpy-win32
-WIN64_TARGET_DIR := scrcpy-win64
-
-VERSION := $(shell git describe --tags --always)
-WIN32_TARGET := $(WIN32_TARGET_DIR)-$(VERSION).zip
-WIN64_TARGET := $(WIN64_TARGET_DIR)-$(VERSION).zip
-
-release: clean zip-win32 zip-win64 sums
-	@echo "Release created in $(DIST)/."
-
-clean:
-	$(GRADLE) clean
-	rm -rf "$(SERVER_BUILD_DIR)" "$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)" \
-		   "$(WIN32_NOCONSOLE_BUILD_DIR)" "$(WIN64_NOCONSOLE_BUILD_DIR)" "$(DIST)"
-
-build-server:
-	[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
-		meson "$(SERVER_BUILD_DIR)" \
-			--buildtype release -Dbuild_app=false )
-		ninja -C "$(SERVER_BUILD_DIR)"
-
-prepare-deps-win32:
-	-$(MAKE) -C prebuilt-deps prepare-win32
-
-build-win32: prepare-deps-win32
-	[ -d "$(WIN32_BUILD_DIR)" ] || ( mkdir "$(WIN32_BUILD_DIR)" && \
-		meson "$(WIN32_BUILD_DIR)" \
-			--cross-file cross_win32.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dbuild_server=false \
-			-Doverride_server_path=scrcpy-server.jar )
-	ninja -C "$(WIN32_BUILD_DIR)"
-
-build-win32-noconsole: prepare-deps-win32
-	[ -d "$(WIN32_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN32_NOCONSOLE_BUILD_DIR)" && \
-		meson "$(WIN32_NOCONSOLE_BUILD_DIR)" \
-			--cross-file cross_win32.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dbuild_server=false \
-			-Dwindows_noconsole=true \
-			-Doverride_server_path=scrcpy-server.jar )
-	ninja -C "$(WIN32_NOCONSOLE_BUILD_DIR)"
-
-prepare-deps-win64:
-	-$(MAKE) -C prebuilt-deps prepare-win64
-
-build-win64: prepare-deps-win64
-	[ -d "$(WIN64_BUILD_DIR)" ] || ( mkdir "$(WIN64_BUILD_DIR)" && \
-		meson "$(WIN64_BUILD_DIR)" \
-			--cross-file cross_win64.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dbuild_server=false \
-			-Doverride_server_path=scrcpy-server.jar )
-	ninja -C "$(WIN64_BUILD_DIR)"
-
-build-win64-noconsole: prepare-deps-win64
-	[ -d "$(WIN64_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN64_NOCONSOLE_BUILD_DIR)" && \
-		meson "$(WIN64_NOCONSOLE_BUILD_DIR)" \
-			--cross-file cross_win64.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dbuild_server=false \
-			-Dwindows_noconsole=true \
-			-Doverride_server_path=scrcpy-server.jar )
-	ninja -C "$(WIN64_NOCONSOLE_BUILD_DIR)"
-
-dist-win32: build-server build-win32 build-win32-noconsole
-	mkdir -p "$(DIST)/$(WIN32_TARGET_DIR)"
-	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp "$(WIN32_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.0.2-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0.2-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0.2-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0.2-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.8/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-
-dist-win64: build-server build-win64 build-win64-noconsole
-	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
-	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp "$(WIN64_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.0.2-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0.2-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0.2-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.0.2-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.8/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-
-zip-win32: dist-win32
-	cd "$(DIST)"; \
-		zip -r "$(WIN32_TARGET)" "$(WIN32_TARGET_DIR)"
-
-zip-win64: dist-win64
-	cd "$(DIST)"; \
-		zip -r "$(WIN64_TARGET)" "$(WIN64_TARGET_DIR)"
-
-sums:
-	cd "$(DIST)"; \
-		sha256sum *.zip > SHA256SUMS.txt

README.md

@@ -1,25 +1,29 @@
-# scrcpy (v1.3)
+# scrcpy
 
 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.
+USB. It does not require any _root_ access. It works on _GNU/Linux_, _Windows_
-It works on _GNU/Linux_, _Windows_ and _MacOS_.
+and _MacOS_.
 
 ![screenshot](assets/screenshot-debian-600.jpg)
 
 
 ## Requirements
 
-The Android part requires at least API 21 (Android 5.0).
+The Android part requires at least API 19 (Android 4.4).
 
 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.
+On Windows, if you use the [prebuilt application](#windows), it is already
+included. Otherwise, just 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`
 
 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
+The client requires [FFmpeg] and [LibSDL2].
-[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
@@ -76,54 +80,18 @@ Two [AUR] packages have been created by users:
 
 #### Windows
 
-For Windows, for simplicity, prebuilt archives with all the dependencies
+For Windows, for simplicity, a prebuilt archive with all the dependencies
-(including `adb`) are available:
+(including `adb`) is available:
 
- - [`scrcpy-win32-v1.3.zip`][direct-win32].  
+ - [`scrcpy-windows-with-deps-v1.1.zip`][direct-windows-with-deps].  
-   _(SHA-256: 51a2990e631ed469a7a86ff38107d517a91d313fb3f8327eb7bc71dde40870b5)_
+   _(SHA-256: 27eb36c15937601d1062c1dc0b45faae0e06fefea2019aadeb4fa7f76a07bb4c)_
- - [`scrcpy-win64-v1.3.zip`][direct-win64].  
-   _(SHA-256: 0768a80d3d600d0bbcd220ca150ae88a3a58d1fe85c308a8c61f44480b711e43)_
 
-[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-win32-v1.3.zip
+[direct-windows-with-deps]: https://github.com/Genymobile/scrcpy/releases/download/v1.1/scrcpy-windows-with-deps-v1.1.zip
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-win64-v1.3.zip
 
-Instead, you may want to build it manually.
+_(It's just a portable version including _dll_ copied from MSYS2.)_
 
-In that case, download the [platform-tools][platform-tools-windows] and extract
+Instead, you may want to build it manually. You need [MSYS2] to build the
-the following files to a directory accessible from your `PATH`:
+project. From an MSYS2 terminal, install the required packages:
- - `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/`.
-
-
-##### In MSYS2
-
-From Windows, you need [MSYS2] to build the project. From an MSYS2 terminal,
-install the required packages:
 
 [MSYS2]: http://www.msys2.org/
 
@@ -139,20 +107,6 @@ pacman -S mingw-w64-x86_64-make \
           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`:
 
@@ -162,17 +116,10 @@ export PATH="$JAVA_HOME/bin:$PATH"
 
 #### Mac OS
 
-The application is available in [Homebrew]. Just install it:
+Use [Homebrew] to install the packages:
 
 [Homebrew]: https://brew.sh/
 
-```bash
-brew install scrcpy
-```
-
-Instead, you may want to build it manually. Install the packages:
-
-
 ```bash
 # runtime dependencies
 brew install sdl2 ffmpeg
@@ -247,10 +194,10 @@ Since the server binary, that will be pushed to the Android device, does not
 depend on your system and architecture, you may want to use the prebuilt binary
 instead:
 
- - [`scrcpy-server-v1.3.jar`][direct-scrcpy-server].  
+ - [`scrcpy-server-v1.1.jar`][direct-scrcpy-server].  
-   _(SHA-256: 0f9a5a217f33f0ed7a1498ceb3c0cccf31c53533893aa952e674c1571d2740c1)_
+   _(SHA-256: 14826512bf38447ec94adf3b531676ce038d19e7e06757fb4e537882b17e77b3)_
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-server-v1.3.jar
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.1/scrcpy-server-v1.1.jar
 
 In that case, the build does not require Java or the Android SDK.
 
@@ -294,12 +241,6 @@ 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
@@ -312,12 +253,6 @@ To show physical touches while scrcpy is running:
 scrcpy -t
 ```
 
-The app may be started directly in fullscreen:
-
-```
-scrcpy -f
-```
-
 To run without installing:
 
 ```bash
@@ -338,14 +273,12 @@ To run without installing:
  | click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  |
  | click on `APP_SWITCH`                  | `Ctrl`+`s`                    |
  | click on `MENU`                        | `Ctrl`+`m`                    |
- | click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_             |
+ | click on `VOLUME_UP`                   | `Ctrl`+`+`                    |
- | click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_           |
+ | click on `VOLUME_DOWN`                 | `Ctrl`+`-`                    |
  | 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._
@@ -391,8 +324,5 @@ Read the [developers page].
 
 ## Articles
 
-- [Introducing scrcpy][article-intro]
+- [Introducing scrcpy](https://blog.rom1v.com/2018/03/introducing-scrcpy/)
-- [Scrcpy now works wirelessly][article-tcpip]
+- [Scrcpy now works wirelessly](https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/)
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/

app/meson.build

@@ -1,27 +1,23 @@
 src = [
     'src/main.c',
     'src/command.c',
-    'src/control_event.c',
+    'src/controlevent.c',
     'src/controller.c',
     'src/convert.c',
     'src/decoder.c',
     'src/device.c',
-    'src/file_handler.c',
+    'src/fpscounter.c',
-    'src/fps_counter.c',
     'src/frames.c',
-    'src/input_manager.c',
+    'src/inputmanager.c',
-    'src/lock_util.c',
+    'src/lockutil.c',
     'src/net.c',
     'src/scrcpy.c',
     'src/screen.c',
     'src/server.c',
-    'src/str_util.c',
+    'src/strutil.c',
-    'src/tiny_xpm.c',
+    'src/tinyxpm.c',
 ]
 
-if not get_option('crossbuild_windows')
-
-    # native build
 dependencies = [
     dependency('libavformat'),
     dependency('libavcodec'),
@@ -29,45 +25,6 @@ if not get_option('crossbuild_windows')
     dependency('sdl2'),
 ]
 
-else
-
-    # cross-compile mingw32 build (from Linux to Windows)
-    cc = meson.get_compiler('c')
-
-    prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
-    sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
-    sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/lib'
-    sdl2_include_dir = '../prebuilt-deps/' + prebuilt_sdl2 + '/include'
-
-    sdl2 = declare_dependency(
-        dependencies: [
-            cc.find_library('SDL2', dirs: sdl2_bin_dir),
-            cc.find_library('SDL2main', dirs: sdl2_lib_dir),
-        ],
-        include_directories: include_directories(sdl2_include_dir)
-    )
-
-    prebuilt_ffmpeg_shared = meson.get_cross_property('prebuilt_ffmpeg_shared')
-    prebuilt_ffmpeg_dev = meson.get_cross_property('prebuilt_ffmpeg_dev')
-    ffmpeg_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_ffmpeg_shared + '/bin'
-    ffmpeg_include_dir = '../prebuilt-deps/' + prebuilt_ffmpeg_dev + '/include'
-    ffmpeg = declare_dependency(
-        dependencies: [
-            cc.find_library('avcodec-58', dirs: ffmpeg_bin_dir),
-            cc.find_library('avformat-58', dirs: ffmpeg_bin_dir),
-            cc.find_library('avutil-56', dirs: ffmpeg_bin_dir),
-        ],
-        include_directories: include_directories(ffmpeg_include_dir)
-    )
-
-    dependencies = [
-        ffmpeg,
-        sdl2,
-        cc.find_library('mingw32')
-    ]
-
-endif
-
 cc = meson.get_compiler('c')
 
 if host_machine.system() == 'windows'
@@ -85,7 +42,7 @@ conf = configuration_data()
 conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')
 
 # the version, updated on release
-conf.set_quoted('SCRCPY_VERSION', '1.3')
+conf.set_quoted('SCRCPY_VERSION', '1.1')
 
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))
@@ -126,30 +83,18 @@ conf.set('SKIP_FRAMES', get_option('skip_frames'))
 # enable High DPI support
 conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
 
-# disable console on Windows
-conf.set('WINDOWS_NOCONSOLE', get_option('windows_noconsole'))
-
 configure_file(configuration: conf, output: 'config.h')
 
 src_dir = include_directories('src')
-
+executable('scrcpy', src, dependencies: dependencies, include_directories: src_dir, install: true)
-if get_option('windows_noconsole')
-    c_args = [ '-mwindows' ]
-    link_args = [ '-mwindows' ]
-else
-    c_args = []
-    link_args = []
-endif
-
-executable('scrcpy', src, dependencies: dependencies, include_directories: src_dir, install: true, c_args: c_args, link_args: link_args)
 
 
 ### TESTS
 
 tests = [
-    ['test_control_event_queue', ['tests/test_control_event_queue.c', 'src/control_event.c']],
+    ['test_control_event_queue', ['tests/test_control_event_queue.c', 'src/controlevent.c']],
-    ['test_control_event_serialize', ['tests/test_control_event_serialize.c', 'src/control_event.c']],
+    ['test_control_event_serialize', ['tests/test_control_event_serialize.c', 'src/controlevent.c']],
-    ['test_strutil', ['tests/test_strutil.c', 'src/str_util.c']],
+    ['test_strutil', ['tests/test_strutil.c', 'src/strutil.c']],
 ]
 
 foreach t : tests

app/src/android/input.h

@@ -777,6 +777,9 @@ 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

@@ -18,25 +18,9 @@ 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";
@@ -48,12 +32,7 @@ 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;
-    enum process_result r = cmd_execute(cmd[0], cmd, &process);
+    return cmd_execute(cmd[0], cmd);
-    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) {
@@ -93,21 +72,6 @@ process_t adb_push(const char *serial, const char *local, const char *remote) {
     return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
-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;
-#endif
-    const char *const adb_cmd[] = {"install", "-r", local};
-    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
-}
-
 process_t adb_remove_path(const char *serial, const char *path) {
     const char *const adb_cmd[] = {"shell", "rm", path};
     return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));

app/src/command.h

@@ -32,13 +32,7 @@
 #endif
 # define NO_EXIT_CODE -1
 
-enum process_result {
+process_t cmd_execute(const char *path, const char *const argv[]);
-    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);
 
@@ -48,7 +42,6 @@ process_t adb_forward_remove(const char *serial, uint16_t local_port);
 process_t adb_reverse(const char *serial, const char *device_socket_name, uint16_t local_port);
 process_t adb_reverse_remove(const char *serial, const char *device_socket_name);
 process_t adb_push(const char *serial, const char *local, const char *remote);
-process_t adb_install(const char *serial, const char *local);
 process_t adb_remove_path(const char *serial, const char *path);
 
 // convenience function to wait for a successful process execution

app/src/controlevent.c

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

app/src/controller.c

@@ -1,8 +1,6 @@
 #include "controller.h"
 
-#include <SDL2/SDL_assert.h>
+#include "lockutil.h"
-#include "config.h"
-#include "lock_util.h"
 #include "log.h"
 
 SDL_bool controller_init(struct controller *controller, socket_t video_socket) {
@@ -56,28 +54,27 @@ static SDL_bool process_event(struct controller *controller, const struct contro
 static int run_controller(void *data) {
     struct controller *controller = data;
 
-    for (;;) {
     mutex_lock(controller->mutex);
+    for (;;) {
         while (!controller->stopped && control_event_queue_is_empty(&controller->queue)) {
             cond_wait(controller->event_cond, controller->mutex);
         }
         if (controller->stopped) {
             // stop immediately, do not process further events
-            mutex_unlock(controller->mutex);
             break;
         }
         struct control_event event;
-        SDL_bool non_empty = control_event_queue_take(&controller->queue, &event);
+        while (control_event_queue_take(&controller->queue, &event)) {
-        SDL_assert(non_empty);
-        mutex_unlock(controller->mutex);
-
             SDL_bool ok = process_event(controller, &event);
             control_event_destroy(&event);
             if (!ok) {
                 LOGD("Cannot write event to socket");
-            break;
+                goto end;
             }
         }
+    }
+end:
+    mutex_unlock(controller->mutex);
     return 0;
 }
 

app/src/controller.h

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

app/src/convert.c

@@ -73,7 +73,6 @@ static enum android_metastate convert_meta_state(SDL_Keymod mod) {
 static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to) {
     switch (from) {
         MAP(SDLK_RETURN,       AKEYCODE_ENTER);
-        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
         MAP(SDLK_ESCAPE,       AKEYCODE_ESCAPE);
         MAP(SDLK_BACKSPACE,    AKEYCODE_DEL);
         MAP(SDLK_TAB,          AKEYCODE_TAB);

app/src/convert.h

@@ -3,7 +3,7 @@
 
 #include <SDL2/SDL_stdinc.h>
 #include <SDL2/SDL_events.h>
-#include "control_event.h"
+#include "controlevent.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 "lock_util.h"
+#include "lockutil.h"
 #include "log.h"
 
 #define BUFSIZE 0x10000

app/src/device.h

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

app/src/file_handler.c

@@ -1,231 +0,0 @@
-#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

@@ -1,44 +0,0 @@
-#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/fpscounter.c

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

app/src/frames.c

@@ -6,7 +6,7 @@
 #include <libavformat/avformat.h>
 
 #include "config.h"
-#include "lock_util.h"
+#include "lockutil.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 "fps_counter.h"
+#include "fpscounter.h"
 
 // forward declarations
 typedef struct AVFrame AVFrame;

app/src/inputmanager.c

@@ -1,7 +1,7 @@
-#include "input_manager.h"
+#include "inputmanager.h"
 
 #include "convert.h"
-#include "lock_util.h"
+#include "lockutil.h"
 #include "log.h"
 
 // Convert window coordinates (as provided by SDL_GetMouseState() to renderer coordinates (as provided in SDL mouse events)
@@ -29,58 +29,57 @@ static struct point get_mouse_point(struct screen *screen) {
     };
 }
 
-static const int ACTION_DOWN = 1;
+static SDL_bool is_ctrl_down(void) {
-static const int ACTION_UP = 1 << 1;
+    const Uint8 *state = SDL_GetKeyboardState(NULL);
+    return state[SDL_SCANCODE_LCTRL] || state[SDL_SCANCODE_RCTRL];
+}
 
-static void send_keycode(struct controller *controller, enum android_keycode keycode, int actions, const char *name) {
+static void send_keycode(struct controller *controller, enum android_keycode keycode, const char *name) {
     // send DOWN event
     struct control_event control_event;
     control_event.type = CONTROL_EVENT_TYPE_KEYCODE;
+    control_event.keycode_event.action = AKEY_EVENT_ACTION_DOWN;
     control_event.keycode_event.keycode = keycode;
     control_event.keycode_event.metastate = 0;
 
-    if (actions & ACTION_DOWN) {
-        control_event.keycode_event.action = AKEY_EVENT_ACTION_DOWN;
     if (!controller_push_event(controller, &control_event)) {
         LOGW("Cannot send %s (DOWN)", name);
         return;
     }
-    }
 
-    if (actions & ACTION_UP) {
+    // send UP event
     control_event.keycode_event.action = AKEY_EVENT_ACTION_UP;
     if (!controller_push_event(controller, &control_event)) {
         LOGW("Cannot send %s (UP)", name);
     }
 }
+
+static inline void action_home(struct controller *controller) {
+    send_keycode(controller, AKEYCODE_HOME, "HOME");
 }
 
-static inline void action_home(struct controller *controller, int actions) {
+static inline void action_back(struct controller *controller) {
-    send_keycode(controller, AKEYCODE_HOME, actions, "HOME");
+    send_keycode(controller, AKEYCODE_BACK, "BACK");
 }
 
-static inline void action_back(struct controller *controller, int actions) {
+static inline void action_app_switch(struct controller *controller) {
-    send_keycode(controller, AKEYCODE_BACK, actions, "BACK");
+    send_keycode(controller, AKEYCODE_APP_SWITCH, "APP_SWITCH");
 }
 
-static inline void action_app_switch(struct controller *controller, int actions) {
+static inline void action_power(struct controller *controller) {
-    send_keycode(controller, AKEYCODE_APP_SWITCH, actions, "APP_SWITCH");
+    send_keycode(controller, AKEYCODE_POWER, "POWER");
 }
 
-static inline void action_power(struct controller *controller, int actions) {
+static inline void action_volume_up(struct controller *controller) {
-    send_keycode(controller, AKEYCODE_POWER, actions, "POWER");
+    send_keycode(controller, AKEYCODE_VOLUME_UP, "VOLUME_UP");
 }
 
-static inline void action_volume_up(struct controller *controller, int actions) {
+static inline void action_volume_down(struct controller *controller) {
-    send_keycode(controller, AKEYCODE_VOLUME_UP, actions, "VOLUME_UP");
+    send_keycode(controller, AKEYCODE_VOLUME_DOWN, "VOLUME_DOWN");
 }
 
-static inline void action_volume_down(struct controller *controller, int actions) {
+static inline void action_menu(struct controller *controller) {
-    send_keycode(controller, AKEYCODE_VOLUME_DOWN, actions, "VOLUME_DOWN");
+    send_keycode(controller, AKEYCODE_MENU, "MENU");
-}
-
-static inline void action_menu(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_MENU, actions, "MENU");
 }
 
 // turn the screen on if it was off, press BACK otherwise
@@ -129,6 +128,18 @@ static void clipboard_paste(struct controller *controller) {
 
 void input_manager_process_text_input(struct input_manager *input_manager,
                                       const SDL_TextInputEvent *event) {
+    if (is_ctrl_down()) {
+        switch (event->text[0]) {
+            case '+':
+                action_volume_up(input_manager->controller);
+                break;
+            case '-':
+                action_volume_down(input_manager->controller);
+                break;
+        }
+        return;
+    }
+
     struct control_event control_event;
     control_event.type = CONTROL_EVENT_TYPE_TEXT;
     control_event.text_event.text = SDL_strdup(event->text);
@@ -147,74 +158,51 @@ void input_manager_process_key(struct input_manager *input_manager,
 
     // capture all Ctrl events
     if (ctrl) {
+        SDL_bool repeat = event->repeat;
+
+        // only consider keydown events, and ignore repeated events
+        if (repeat || event->type != SDL_KEYDOWN) {
+            return;
+        }
+
         SDL_bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
         if (shift) {
-            // currently, there is no shortcut involving SHIFT
+            // currently, there is no shortcut implying SHIFT
             return;
         }
 
         SDL_Keycode keycode = event->keysym.sym;
-        int action = event->type == SDL_KEYDOWN ? ACTION_DOWN : ACTION_UP;
-        SDL_bool repeat = event->repeat;
         switch (keycode) {
             case SDLK_h:
-                if (!repeat) {
+                action_home(input_manager->controller);
-                    action_home(input_manager->controller, action);
-                }
                 return;
             case SDLK_b: // fall-through
             case SDLK_BACKSPACE:
-                if (!repeat) {
+                action_back(input_manager->controller);
-                    action_back(input_manager->controller, action);
-                }
                 return;
             case SDLK_s:
-                if (!repeat) {
+                action_app_switch(input_manager->controller);
-                    action_app_switch(input_manager->controller, action);
-                }
                 return;
             case SDLK_m:
-                if (!repeat) {
+                action_menu(input_manager->controller);
-                    action_menu(input_manager->controller, action);
-                }
                 return;
             case SDLK_p:
-                if (!repeat) {
+                action_power(input_manager->controller);
-                    action_power(input_manager->controller, action);
-                }
-                return;
-            case SDLK_DOWN:
-                // forward repeated events
-                action_volume_down(input_manager->controller, action);
-                return;
-            case SDLK_UP:
-                // forward repeated events
-                action_volume_up(input_manager->controller, action);
                 return;
             case SDLK_v:
-                if (!repeat && event->type == SDL_KEYDOWN) {
                 clipboard_paste(input_manager->controller);
-                }
                 return;
             case SDLK_f:
-                if (!repeat && event->type == SDL_KEYDOWN) {
                 screen_switch_fullscreen(input_manager->screen);
-                }
                 return;
             case SDLK_x:
-                if (!repeat && event->type == SDL_KEYDOWN) {
                 screen_resize_to_fit(input_manager->screen);
-                }
                 return;
             case SDLK_g:
-                if (!repeat && event->type == SDL_KEYDOWN) {
                 screen_resize_to_pixel_perfect(input_manager->screen);
-                }
                 return;
             case SDLK_i:
-                if (!repeat && event->type == SDL_KEYDOWN) {
                 switch_fps_counter_state(input_manager->frames);
-                }
                 return;
         }
 
@@ -251,7 +239,7 @@ void input_manager_process_mouse_button(struct input_manager *input_manager,
             return;
         }
         if (event->button == SDL_BUTTON_MIDDLE) {
-            action_home(input_manager->controller, ACTION_DOWN | ACTION_UP);
+            action_home(input_manager->controller);
             return;
         }
         // double-click on black borders resize to fit the device screen
@@ -265,7 +253,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/inputmanager.h

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

app/src/lockutil.c

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

app/src/main.c

@@ -10,8 +10,6 @@
 
 struct args {
     const char *serial;
-    const char *crop;
-    SDL_bool fullscreen;
     SDL_bool help;
     SDL_bool version;
     SDL_bool show_touches;
@@ -31,15 +29,6 @@ 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"
@@ -92,10 +81,10 @@ static void usage(const char *arg0) {
         "    Ctrl+m\n"
         "        click on MENU\n"
         "\n"
-        "    Ctrl+Up\n"
+        "    Ctrl+'+'\n"
         "        click on VOLUME_UP\n"
         "\n"
-        "    Ctrl+Down\n"
+        "    Ctrl+'-'\n"
         "        click on VOLUME_DOWN\n"
         "\n"
         "    Ctrl+p\n"
@@ -109,9 +98,6 @@ static void usage(const char *arg0) {
         "\n"
         "    Ctrl+i\n"
         "        enable/disable FPS counter (print frames/second in logs)\n"
-        "\n"
-        "    Drag & drop APK file\n"
-        "        install APK from computer\n"
         "\n",
         arg0,
         DEFAULT_BIT_RATE,
@@ -203,8 +189,6 @@ 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'},
@@ -214,19 +198,13 @@ 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:c:fhm:p:s:tv", long_options, NULL)) != -1) {
+    while ((c = getopt_long(argc, argv, "b:hm: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;
@@ -272,7 +250,6 @@ int main(int argc, char *argv[]) {
 #endif
     struct args args = {
         .serial = NULL,
-        .crop = NULL,
         .help = SDL_FALSE,
         .version = SDL_FALSE,
         .show_touches = SDL_FALSE,
@@ -294,9 +271,7 @@ 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;
@@ -308,12 +283,10 @@ 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;
 

app/src/net.c

@@ -82,19 +82,19 @@ ssize_t net_recv_all(socket_t socket, void *buf, size_t len) {
     return recv(socket, buf, len, MSG_WAITALL);
 }
 
-ssize_t net_send(socket_t socket, const void *buf, size_t len) {
+ssize_t net_send(socket_t socket, void *buf, size_t len) {
     return send(socket, buf, len, 0);
 }
 
-ssize_t net_send_all(socket_t socket, const void *buf, size_t len) {
+ssize_t net_send_all(socket_t socket, void *buf, size_t len) {
-    ssize_t w = 0;
+    ssize_t w;
     while (len > 0) {
         w = send(socket, buf, len, 0);
         if (w == -1) {
             return -1;
         }
         len -= w;
-        buf = (char *) buf + w;
+        buf += w;
     }
     return w;
 }

app/src/net.h

@@ -26,8 +26,8 @@ socket_t net_accept(socket_t server_socket);
 // the _all versions wait/retry until len bytes have been written/read
 ssize_t net_recv(socket_t socket, void *buf, size_t len);
 ssize_t net_recv_all(socket_t socket, void *buf, size_t len);
-ssize_t net_send(socket_t socket, const void *buf, size_t len);
+ssize_t net_send(socket_t socket, void *buf, size_t len);
-ssize_t net_send_all(socket_t socket, const void *buf, size_t len);
+ssize_t net_send_all(socket_t socket, void *buf, size_t len);
 // how is SHUT_RD (read), SHUT_WR (write) or SHUT_RDWR (both)
 SDL_bool net_shutdown(socket_t socket, int how);
 SDL_bool net_close(socket_t socket);

app/src/scrcpy.c

@@ -13,23 +13,21 @@
 #include "decoder.h"
 #include "device.h"
 #include "events.h"
-#include "file_handler.h"
 #include "frames.h"
-#include "fps_counter.h"
+#include "fpscounter.h"
-#include "input_manager.h"
+#include "inputmanager.h"
 #include "log.h"
-#include "lock_util.h"
+#include "lockutil.h"
 #include "net.h"
 #include "screen.h"
 #include "server.h"
-#include "tiny_xpm.h"
+#include "tinyxpm.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 file_handler file_handler;
 
 static struct input_manager input_manager = {
     .controller = &controller,
@@ -56,12 +54,7 @@ static int event_watcher(void *data, SDL_Event *event) {
 }
 #endif
 
-static SDL_bool is_apk(const char *file) {
+static void event_loop(void) {
-    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
@@ -70,10 +63,10 @@ static SDL_bool event_loop(void) {
         switch (event.type) {
             case EVENT_DECODER_STOPPED:
                 LOGD("Video decoder stopped");
-                return SDL_FALSE;
+                return;
             case SDL_QUIT:
                 LOGD("User requested to quit");
-                return SDL_TRUE;
+                return;
             case EVENT_NEW_FRAME:
                 if (!screen.has_frame) {
                     screen.has_frame = SDL_TRUE;
@@ -81,14 +74,13 @@ static SDL_bool event_loop(void) {
                     screen_show_window(&screen);
                 }
                 if (!screen_update_frame(&screen, &frames)) {
-                    return SDL_FALSE;
+                    return;
                 }
                 break;
             case SDL_WINDOWEVENT:
                 switch (event.window.event) {
                     case SDL_WINDOWEVENT_EXPOSED:
                     case SDL_WINDOWEVENT_SIZE_CHANGED:
-                        screen_update_scale(&screen);
                         screen_render(&screen);
                         break;
                 }
@@ -110,20 +102,9 @@ static SDL_bool event_loop(void) {
             case SDL_MOUSEBUTTONUP:
                 input_manager_process_mouse_button(&input_manager, &event.button);
                 break;
-            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) {
     const char *value = enabled ? "1" : "0";
@@ -140,11 +121,11 @@ 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->crop)) {
+                      options->max_size, options->bit_rate)) {
         return SDL_FALSE;
     }
 
-    process_t proc_show_touches = PROCESS_NONE;
+    process_t proc_show_touches;
     SDL_bool show_touches_waited;
     if (options->show_touches) {
         LOGI("Enable show_touches");
@@ -188,12 +169,6 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
         goto finally_destroy_server;
     }
 
-    if (!file_handler_init(&file_handler, server.serial)) {
-        ret = SDL_FALSE;
-        server_stop(&server);
-        goto finally_destroy_frames;
-    }
-
     decoder_init(&decoder, &frames, device_socket);
 
     // now we consumed the header values, the socket receives the video stream
@@ -201,7 +176,7 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
     if (!decoder_start(&decoder)) {
         ret = SDL_FALSE;
         server_stop(&server);
-        goto finally_destroy_file_handler;
+        goto finally_destroy_frames;
     }
 
     if (!controller_init(&controller, device_socket)) {
@@ -224,11 +199,7 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
         show_touches_waited = SDL_TRUE;
     }
 
-    if (options->fullscreen) {
+    event_loop();
-        screen_switch_fullscreen(&screen);
-    }
-
-    ret = event_loop();
     LOGD("quit...");
 
     screen_destroy(&screen);
@@ -243,10 +214,6 @@ finally_stop_decoder:
     // stop the server before decoder_join() to wake up the decoder
     server_stop(&server);
     decoder_join(&decoder);
-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,12 +5,10 @@
 
 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 "lock_util.h"
+#include "lockutil.h"
 #include "log.h"
-#include "tiny_xpm.h"
+#include "tinyxpm.h"
 
 #define DISPLAY_MARGINS 96
 
@@ -132,17 +132,6 @@ static inline struct size get_initial_optimal_size(struct size frame_size) {
     return get_optimal_size(frame_size, frame_size);
 }
 
-// apply hidpi scaling and call SDL_RenderSetLogicalSize
-static inline SDL_bool render_set_scaled_logical_size(struct screen *screen, struct size size) {
-    int w, h, dw, dh;
-    SDL_GL_GetDrawableSize(screen->window, &w, &h);
-    SDL_GetWindowSize(screen->window, &dw, &dh);
-    // use 32 bits unsigned not to lose precision (width and height fit in 16 bits)
-    int scaled_x = (Uint32) size.width * (Uint32) w / (Uint32) dw;
-    int scaled_y = (Uint32) size.height * (Uint32) h / (Uint32) dh;
-    return SDL_RenderSetLogicalSize(screen->renderer, scaled_x, scaled_y);
-}
-
 void screen_init(struct screen *screen) {
     *screen = (struct screen) SCREEN_INITIALIZER;
 }
@@ -174,7 +163,7 @@ SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, s
         return SDL_FALSE;
     }
 
-    if (render_set_scaled_logical_size(screen, frame_size)) {
+    if (SDL_RenderSetLogicalSize(screen->renderer, frame_size.width, frame_size.height)) {
         LOGE("Could not set renderer logical size: %s", SDL_GetError());
         screen_destroy(screen);
         return SDL_FALSE;
@@ -219,7 +208,7 @@ void screen_destroy(struct screen *screen) {
 // recreate the texture and resize the window if the frame size has changed
 static SDL_bool prepare_for_frame(struct screen *screen, struct size new_frame_size) {
     if (screen->frame_size.width != new_frame_size.width || screen->frame_size.height != new_frame_size.height) {
-        if (render_set_scaled_logical_size(screen, new_frame_size)) {
+        if (SDL_RenderSetLogicalSize(screen->renderer, new_frame_size.width, new_frame_size.height)) {
             LOGE("Could not set renderer logical size: %s", SDL_GetError());
             return SDL_FALSE;
         }
@@ -313,7 +302,3 @@ void screen_resize_to_pixel_perfect(struct screen *screen) {
         LOGD("Resized to pixel-perfect");
     }
 }
-
-void screen_update_scale(struct screen *screen) {
-    render_set_scaled_logical_size(screen, screen->frame_size);
-}

app/src/screen.h

@@ -66,8 +66,4 @@ void screen_resize_to_fit(struct screen *screen);
 // resize window to 1:1 (pixel-perfect)
 void screen_resize_to_pixel_perfect(struct screen *screen);
 
-// recompute the scale in case the window moved from/to another screen with a
-// different HiDPI
-void screen_update_scale(struct screen *screen);
-
 #endif

app/src/server.c

@@ -3,7 +3,6 @@
 #include <errno.h>
 #include <inttypes.h>
 #include <stdint.h>
-#include <stdio.h>
 #include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>
 
@@ -77,8 +76,7 @@ static SDL_bool disable_tunnel(struct server *server) {
 }
 
 static process_t execute_server(const char *serial,
-                                Uint16 max_size, Uint32 bit_rate,
+                                Uint16 max_size, Uint32 bit_rate, SDL_bool tunnel_forward) {
-                                const char *crop, SDL_bool tunnel_forward) {
     char max_size_string[6];
     char bit_rate_string[11];
     sprintf(max_size_string, "%"PRIu16, max_size);
@@ -92,7 +90,6 @@ 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]));
 }
@@ -149,25 +146,20 @@ 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, const char *crop) {
+                      Uint16 max_size, Uint32 bit_rate) {
     server->local_port = local_port;
 
     if (serial) {
         server->serial = SDL_strdup(serial);
-        if (!server->serial) {
-            return SDL_FALSE;
-        }
     }
 
     if (!push_server(serial)) {
-        SDL_free((void *) server->serial);
         return SDL_FALSE;
     }
 
     server->server_copied_to_device = SDL_TRUE;
 
     if (!enable_tunnel(server)) {
-        SDL_free((void *) server->serial);
         return SDL_FALSE;
     }
 
@@ -184,20 +176,17 @@ SDL_bool server_start(struct server *server, const char *serial, Uint16 local_po
         if (server->server_socket == INVALID_SOCKET) {
             LOGE("Could not listen on port %" PRIu16, local_port);
             disable_tunnel(server);
-            SDL_free((void *) server->serial);
             return SDL_FALSE;
         }
     }
 
     // server will connect to our server socket
-    server->process = execute_server(serial, max_size, bit_rate, crop,
+    server->process = execute_server(serial, max_size, bit_rate, server->tunnel_forward);
-                                     server->tunnel_forward);
     if (server->process == PROCESS_NONE) {
         if (!server->tunnel_forward) {
             close_socket(&server->server_socket);
         }
         disable_tunnel(server);
-        SDL_free((void *) server->serial);
         return SDL_FALSE;
     }
 
@@ -210,7 +199,7 @@ socket_t server_connect_to(struct server *server) {
     if (!server->tunnel_forward) {
         server->device_socket = net_accept(server->server_socket);
     } else {
-        Uint32 attempts = 100;
+        Uint32 attempts = 50;
         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, const char *crop);
+                      Uint16 max_size, Uint32 bit_rate);
 
 // block until the communication with the server is established
 socket_t server_connect_to(struct server *server);

app/src/strutil.c

@@ -1,4 +1,4 @@
-#include "str_util.h"
+#include "strutil.h"
 
 size_t xstrncpy(char *dest, const char *src, size_t n) {
     size_t i;

app/src/sys/unix/command.c

@@ -1,80 +1,25 @@
 #include "command.h"
 
-#include <errno.h>
-#include <fcntl.h>
 #include <signal.h>
-#include <stdlib.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
-#include "log.h"
 
-enum process_result cmd_execute(const char *path, const char *const argv[], pid_t *pid) {
+pid_t cmd_execute(const char *path, const char *const argv[]) {
-    int fd[2];
+    pid_t pid = fork();
-
+    if (pid == -1) {
-    if (pipe(fd) == -1) {
-        perror("pipe");
-        return PROCESS_ERROR_GENERIC;
-    }
-
-    enum process_result ret = PROCESS_SUCCESS;
-
-    *pid = fork();
-    if (*pid == -1) {
         perror("fork");
-        ret = PROCESS_ERROR_GENERIC;
+        return -1;
-        goto end;
     }
-
+    if (pid == 0) {
-    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) {
-    if (pid <= 0) {
-        LOGC("Requested to kill %d, this is an error. Please report the bug.\n", (int) pid);
-        abort();
-    }
     return kill(pid, SIGTERM) != -1;
 }
 

app/src/sys/win/command.c

@@ -1,10 +1,9 @@
 #include "command.h"
 
-#include "config.h"
 #include "log.h"
-#include "str_util.h"
+#include "strutil.h"
 
-enum process_result cmd_execute(const char *path, const char *const argv[], HANDLE *handle) {
+HANDLE cmd_execute(const char *path, const char *const argv[]) {
     STARTUPINFO si;
     PROCESS_INFORMATION pi;
     memset(&si, 0, sizeof(si));
@@ -18,25 +17,14 @@ enum process_result cmd_execute(const char *path, const char *const argv[], HAND
     size_t ret = xstrjoin(cmd, argv, ' ', sizeof(cmd));
     if (ret >= sizeof(cmd)) {
         LOGE("Command too long (%" PRIsizet " chars)", sizeof(cmd) - 1);
-        *handle = NULL;
+        return NULL;
-        return PROCESS_ERROR_GENERIC;
     }
 
-#ifdef WINDOWS_NOCONSOLE
+    if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) {
-    int flags = CREATE_NO_WINDOW;
+        return NULL;
-#else
-    int flags = 0;
-#endif
-    if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, flags, NULL, NULL, &si, &pi)) {
-        *handle = NULL;
-        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
-            return PROCESS_ERROR_MISSING_BINARY;
-        }
-        return PROCESS_ERROR_GENERIC;
     }
 
-    *handle = pi.hProcess;
+    return pi.hProcess;
-    return PROCESS_SUCCESS;
 }
 
 SDL_bool cmd_terminate(HANDLE handle) {

app/src/tinyxpm.c

@@ -1,4 +1,4 @@
-#include "tiny_xpm.h"
+#include "tinyxpm.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
-    int width = strtol(xpm[0], &endptr, 10);
+    Uint32 width = strtol(xpm[0], &endptr, 10);
-    int height = strtol(endptr + 1, &endptr, 10);
+    Uint32 height = strtol(endptr + 1, &endptr, 10);
-    int colors = strtol(endptr + 1, &endptr, 10);
+    Uint32 colors = strtol(endptr + 1, &endptr, 10);
-    int chars = strtol(endptr + 1, &endptr, 10);
+    Uint32 chars = strtol(endptr + 1, &endptr, 10);
 
     // sanity checks
-    SDL_assert(0 <= width && width < 256);
+    SDL_assert(width < 256);
-    SDL_assert(0 <= height && height < 256);
+    SDL_assert(height < 256);
-    SDL_assert(0 <= colors && colors < 256);
+    SDL_assert(colors < 256);
     SDL_assert(chars == 1); // this implementation does not support more
 
     // init index

app/tests/test_control_event_queue.c

@@ -1,7 +1,6 @@
 #include <assert.h>
-#include <string.h>
 
-#include "control_event.h"
+#include "controlevent.h"
 
 static void test_control_event_queue_empty() {
     struct control_event_queue queue;

app/tests/test_control_event_serialize.c

@@ -1,7 +1,6 @@
 #include <assert.h>
-#include <string.h>
 
-#include "control_event.h"
+#include "controlevent.h"
 
 static void test_serialize_keycode_event() {
     struct control_event event = {

app/tests/test_strutil.c

@@ -1,7 +1,7 @@
 #include <assert.h>
 #include <string.h>
 
-#include "str_util.h"
+#include "strutil.h"
 
 static void test_xstrncpy_simple() {
     char s[] = "xxxxxxxxxx";

build.gradle

@@ -7,7 +7,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.1.1'
+        classpath 'com.android.tools.build:gradle:3.0.1'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

cross_win32.txt

@@ -1,20 +0,0 @@
-# apt install mingw-w64 mingw-w64-tools
-
-[binaries]
-name = 'mingw'
-c = '/usr/bin/i686-w64-mingw32-gcc'
-cpp = '/usr/bin/i686-w64-mingw32-g++'
-ar = '/usr/bin/i686-w64-mingw32-ar'
-strip = '/usr/bin/i686-w64-mingw32-strip'
-pkgconfig = '/usr/bin/i686-w64-mingw32-pkg-config'
-
-[host_machine]
-system = 'windows'
-cpu_family = 'x86'
-cpu = 'i686'
-endian = 'little'
-
-[properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.0.2-win32-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.0.2-win32-dev'
-prebuilt_sdl2 = 'SDL2-2.0.8/i686-w64-mingw32'

cross_win64.txt

@@ -1,20 +0,0 @@
-# apt install mingw-w64 mingw-w64-tools
-
-[binaries]
-name = 'mingw'
-c = '/usr/bin/x86_64-w64-mingw32-gcc'
-cpp = '/usr/bin/x86_64-w64-mingw32-g++'
-ar = '/usr/bin/x86_64-w64-mingw32-ar'
-strip = '/usr/bin/x86_64-w64-mingw32-strip'
-pkgconfig = '/usr/bin/x86_64-w64-mingw32-pkg-config'
-
-[host_machine]
-system = 'windows'
-cpu_family = 'x86'
-cpu = 'x86_64'
-endian = 'little'
-
-[properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.0.2-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.0.2-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.8/x86_64-w64-mingw32'

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Mon Jun 04 11:48:32 CEST 2018
+#Mon Jan 29 16:38:49 CET 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-all.zip

meson.build

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

meson_options.txt

@@ -1,7 +1,5 @@
 option('build_app', type: 'boolean', value: true, description: 'Build the client')
 option('build_server', type: 'boolean', value: true, description: 'Build the server')
-option('crossbuild_windows', type: 'boolean', value: false, description: 'Build for Windows from Linux')
-option('windows_noconsole', type: 'boolean', value: false, description: 'Disable console on Windows (pass -mwindows flag)')
 option('prebuilt_server', type: 'string', description: 'Path of the prebuilt server')
 option('override_server_path', type: 'string', description: 'Hardcoded path to find the server at runtime')
 option('skip_frames', type: 'boolean', value: true, description: 'Always display the most recent frame')

prebuilt-deps/.gitignore

@@ -1,4 +0,0 @@
-*
-!/.gitignore
-!/Makefile
-!/prepare-dep

prebuilt-deps/Makefile

@@ -1,40 +0,0 @@
-.PHONY: prepare-win32 prepare-win64 \
-	prepare-ffmpeg-shared-win32 \
-	prepare-ffmpeg-dev-win32 \
-	prepare-ffmpeg-shared-win64 \
-	prepare-ffmpeg-dev-win64 \
-	prepare-sdl2 \
-	prepare-adb
-
-prepare-win32: prepare-sdl2 prepare-ffmpeg-shared-win32 prepare-ffmpeg-dev-win32 prepare-adb
-prepare-win64: prepare-sdl2 prepare-ffmpeg-shared-win64 prepare-ffmpeg-dev-win64 prepare-adb
-
-prepare-ffmpeg-shared-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.0.2-win32-shared.zip \
-		cc190a3a4cf7bfbd4fbaa92609c1501a1de458055e6cfea8b745c1d515013aa8 \
-		ffmpeg-4.0.2-win32-shared
-
-prepare-ffmpeg-dev-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.0.2-win32-dev.zip \
-		c72c74bad74ac0541f1b43090c26a50017c49041c182a703abd2057bb8cdc238 \
-		ffmpeg-4.0.2-win32-dev
-
-prepare-ffmpeg-shared-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.0.2-win64-shared.zip \
-		ede566aca8b5348dff85570f9638c6bad33209f9419f79db7bde7daa37599bff \
-		ffmpeg-4.0.2-win64-shared
-
-prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.0.2-win64-dev.zip \
-		23ee994161c51285cb956b98d3caa499d48083dae7b26c1fdf77f22e98df1c5f \
-		ffmpeg-4.0.2-win64-dev
-
-prepare-sdl2:
-	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.8-mingw.tar.gz \
-		ffff7305d634aff5e1df5b7bb935435c3a02c8b03ad94a1a2be9169a558a7961 \
-		SDL2-2.0.8
-
-prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r28.0.0-windows.zip \
-		e2c1ec7c8e9b71cf1c8befd3bff91d06b26dd334c3f32b3817e9d46ba260b0e8 \
-		platform-tools

prebuilt-deps/prepare-dep

@@ -1,58 +0,0 @@
-#!/bin/bash
-set -e
-url="$1"
-sum="$2"
-dir="$3"
-
-checksum() {
-    local file="$1"
-    local sum="$2"
-    echo "$file: verifying checksum..."
-    echo "$sum  $file" | sha256sum -c
-}
-
-get_file() {
-    local url="$1"
-    local file="$2"
-    local sum="$3"
-    if [[ -f "$file" ]]
-    then
-        echo "$file: found"
-    else
-        echo "$file: not found, downloading..."
-        wget "$url" -O "$file"
-    fi
-    checksum "$file" "$sum"
-}
-
-extract() {
-    local file="$1"
-    echo "Extracting $file..."
-    if [[ "$file" == *.zip ]]
-    then
-        unzip -q "$file"
-    elif [[ "$file" == *.tar.gz ]]
-    then
-        tar xf "$file"
-    else
-        echo "Unsupported file: $file"
-        return 1
-    fi
-}
-
-get_dep() {
-    local url="$1"
-    local sum="$2"
-    local dir="$3"
-    local file="${url##*/}"
-    if [[ -d "$dir" ]]
-    then
-        echo "$dir: found"
-    else
-        echo "$dir: not found"
-        get_file "$url" "$file" "$sum"
-        extract "$file"
-    fi
-}
-
-get_dep "$1" "$2" "$3"

server/build.gradle

@@ -4,10 +4,10 @@ android {
     compileSdkVersion 27
     defaultConfig {
         applicationId "com.genymobile.scrcpy"
-        minSdkVersion 21
+        minSdkVersion 19
         targetSdkVersion 27
-        versionCode 4
+        versionCode 2
-        versionName "1.3"
+        versionName "1.1"
         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 FileDescriptor fd;
+    private final OutputStream outputStream;
 
     private final ControlEventReader reader = new ControlEventReader();
 
     private DesktopConnection(LocalSocket socket) throws IOException {
         this.socket = socket;
         inputStream = socket.getInputStream();
-        fd = socket.getFileDescriptor();
+        outputStream = socket.getOutputStream();
     }
 
     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;
-        IO.writeFully(fd, buffer, 0, buffer.length);
+        outputStream.write(buffer, 0, buffer.length);
     }
 
-    public FileDescriptor getFd() {
+    public OutputStream getOutputStream() {
-        return fd;
+        return outputStream;
     }
 
     public ControlEvent receiveControlEvent() throws IOException {

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

@@ -3,7 +3,6 @@ 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;
@@ -21,7 +20,7 @@ public final class Device {
     private RotationListener rotationListener;
 
     public Device(Options options) {
-        screenInfo = computeScreenInfo(options.getCrop(), options.getMaxSize());
+        screenInfo = computeScreenInfo(options.getMaxSize());
         registerRotationWatcher(new IRotationWatcher.Stub() {
             @Override
             public void onRotationChanged(int rotation) throws RemoteException {
@@ -41,40 +40,18 @@ 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 static Size computeVideoSize(int w, int h, int maxSize) {
+    private ScreenInfo computeScreenInfo(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)
-        w &= ~7; // in case it's not a multiple of 8
+        DisplayInfo displayInfo = serviceManager.getDisplayManager().getDisplayInfo();
-        h &= ~7;
+        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;
         if (maxSize > 0) {
             if (BuildConfig.DEBUG && maxSize % 8 != 0) {
                 throw new AssertionError("Max size must be a multiple of 8");
@@ -91,12 +68,12 @@ public final class Device {
             w = portrait ? minor : major;
             h = portrait ? major : minor;
         }
-        return new Size(w, h);
+        Size videoSize = new Size(w, h);
+        return new ScreenInfo(deviceSize, videoSize, rotated);
     }
 
     public Point getPhysicalPoint(Position position) {
-        // it hides the field on purpose, to read it with a lock
+        @SuppressWarnings("checkstyle:HiddenField") // 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();
@@ -105,10 +82,10 @@ public final class Device {
             // the device may have been rotated since the event was generated, so ignore the event
             return null;
         }
-        Rect contentRect = screenInfo.getContentRect();
+        Size deviceSize = screenInfo.getDeviceSize();
         Point point = position.getPoint();
-        int scaledX = contentRect.left + point.x * contentRect.width() / videoSize.getWidth();
+        int scaledX = point.x * deviceSize.getWidth() / videoSize.getWidth();
-        int scaledY = contentRect.top + point.y * contentRect.height() / videoSize.getHeight();
+        int scaledY = point.y * deviceSize.getHeight() / videoSize.getHeight();
         return new Point(scaledX, scaledY);
     }
 
@@ -131,8 +108,4 @@ 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

@@ -1,31 +0,0 @@
-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 {
-        while (from.hasRemaining()) {
-            try {
-                Os.write(fd, from);
-            } 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,12 +1,9 @@
 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;
@@ -31,12 +28,4 @@ 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

@@ -6,11 +6,12 @@ import android.graphics.Rect;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaFormat;
+import android.os.Build;
 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 +49,7 @@ public class ScreenEncoder implements Device.RotationListener {
         return rotationChanged.getAndSet(false);
     }
 
-    public void streamScreen(Device device, FileDescriptor fd) throws IOException {
+    public void streamScreen(Device device, OutputStream outputStream) throws IOException {
         MediaFormat format = createFormat(bitRate, frameRate, iFrameInterval);
         device.setRotationListener(this);
         boolean alive;
@@ -56,15 +57,15 @@ public class ScreenEncoder implements Device.RotationListener {
             do {
                 MediaCodec codec = createCodec();
                 IBinder display = createDisplay();
-                Rect contentRect = device.getScreenInfo().getContentRect();
+                Rect deviceRect = device.getScreenInfo().getDeviceSize().toRect();
                 Rect videoRect = device.getScreenInfo().getVideoSize().toRect();
                 setSize(format, videoRect.width(), videoRect.height());
                 configure(codec, format);
                 Surface surface = codec.createInputSurface();
-                setDisplaySurface(display, surface, contentRect, videoRect);
+                setDisplaySurface(display, surface, deviceRect, videoRect);
                 codec.start();
                 try {
-                    alive = encode(codec, fd);
+                    alive = encode(codec, outputStream);
                 } finally {
                     codec.stop();
                     destroyDisplay(display);
@@ -77,9 +78,17 @@ public class ScreenEncoder implements Device.RotationListener {
         }
     }
 
-    private boolean encode(MediaCodec codec, FileDescriptor fd) throws IOException {
+    @SuppressWarnings("deprecation") // Android API 19 requires to call deprecated methods
+    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
         boolean eof = false;
         MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+
+        ByteBuffer[] outputBuffers = null;
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+            outputBuffers = codec.getOutputBuffers();
+        }
         while (!consumeRotationChange() && !eof) {
             int outputBufferId = codec.dequeueOutputBuffer(bufferInfo, -1);
             eof = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
@@ -89,8 +98,22 @@ public class ScreenEncoder implements Device.RotationListener {
                     break;
                 }
                 if (outputBufferId >= 0) {
-                    ByteBuffer codecBuffer = codec.getOutputBuffer(outputBufferId);
+                    ByteBuffer outputBuffer;
-                    IO.writeFully(fd, codecBuffer);
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                        outputBuffer = codec.getOutputBuffer(outputBufferId);
+                    } else {
+                        outputBuffer = outputBuffers[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);
+                    }
+                } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP && outputBufferId == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
+                    outputBuffers = codec.getOutputBuffers();
                 }
             } finally {
                 if (outputBufferId >= 0) {

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

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

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

@@ -1,7 +1,5 @@
 package com.genymobile.scrcpy;
 
-import android.graphics.Rect;
-
 import java.io.IOException;
 
 public final class Server {
@@ -21,7 +19,7 @@ public final class Server {
 
             try {
                 // synchronous
-                screenEncoder.streamScreen(device, connection.getFd());
+                screenEncoder.streamScreen(device, connection.getOutputStream());
             } catch (IOException e) {
                 // this is expected on close
                 Ln.d("Screen streaming stopped");
@@ -65,30 +63,8 @@ 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() {

server/src/test/java/com/genymobile/scrcpy/ControlEventReaderTest.java

@@ -3,9 +3,6 @@ package com.genymobile.scrcpy;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 
-import org.junit.Assert;
-import org.junit.Test;
-
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
@@ -13,6 +10,8 @@ import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 
+import org.junit.Assert;
+import org.junit.Test;
 
 public class ControlEventReaderTest {