Add shortcut to rotate screen

On Ctrl+r, disable auto-rotation (if enabled), set the screen rotation and re-enable auto-rotation (if it was enabled). Closes #11 <https://github.com/Genymobile/scrcpy/issues/11>
Refactor wrappers for Android SDK classes
2019-12-04 22:03:25 +01:00 · 2019-12-04 19:34:20 +01:00 · 2019-12-04 19:32:38 +01:00 · 2019-12-04 19:25:58 +01:00 · 2019-12-04 19:24:59 +01:00 · 2019-12-04 19:24:59 +01:00
82 changed files with 1391 additions and 667 deletions
--- a/BUILD.md
+++ b/BUILD.md
@@ -233,10 +233,10 @@ You can then [run](README.md#run) _scrcpy_.

 ## Prebuilt server

- - [`scrcpy-server-v1.10.jar`][direct-scrcpy-server]  
-   _(SHA-256: cbeb1a4e046f1392c1dc73c3ccffd7f86dec4636b505556ea20929687a119390)_
+ - [`scrcpy-server-v1.11`][direct-scrcpy-server]  
+   _(SHA-256: ff3a454012e91d9185cfe8ca7691cea16c43a7dcc08e92fa47ab9f0ea675abd1)_

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

 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/Makefile.CrossWindows
+++ b/Makefile.CrossWindows
@@ -100,11 +100,11 @@ dist-win32: build-server build-win32 build-win32-noconsole
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/swscale-5.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)/"
@@ -115,11 +115,11 @@ dist-win64: build-server build-win64 build-win64-noconsole
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# scrcpy (v1.10)
+# scrcpy (v1.11)

 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.
@@ -62,13 +62,13 @@ For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
 For Windows, for simplicity, prebuilt archives with all the dependencies
 (including `adb`) are available:

- - [`scrcpy-win32-v1.10.zip`][direct-win32]  
-   _(SHA-256: f98b400b3764404b33b212e9762dd6f1593ddb766c1480fc2609c94768e4a8e1)_
- - [`scrcpy-win64-v1.10.zip`][direct-win64]  
-   _(SHA-256: 95de34575d873c7e95dfcfb5e74d0f6af4f70b2a5bc6fde0f48d1a05480e3a44)_
+ - [`scrcpy-win32-v1.11.zip`][direct-win32]  
+   _(SHA-256: f25ed46e6f3e81e0ff9b9b4df7fe1a4bbd13f8396b7391be0a488b64c675b41e)_
+ - [`scrcpy-win64-v1.11.zip`][direct-win64]  
+   _(SHA-256: 3802c9ea0307d437947ff150ec65e53990b0beaacd0c8d0bed19c7650ce141bd)_

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

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

@@ -108,8 +108,9 @@ scrcpy --help

 ## Features

+### Capture configuration

-### Reduce size
+#### Reduce size

 Sometimes, it is useful to mirror an Android device at a lower definition to
 increase performance.
@@ -125,7 +126,7 @@ The other dimension is computed to that the device aspect ratio is preserved.
 That way, a device in 1920×1080 will be mirrored at 1024×576.


-### Change bit-rate
+#### Change bit-rate

 The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):

@@ -134,8 +135,15 @@ scrcpy --bit-rate 2M
 scrcpy -b 2M  # short version
 ```

+#### Limit frame rate

-### Crop
+On devices with Android >= 10, the capture frame rate can be limited:
+
+```bash
+scrcpy --max-fps 15
+```
+
+#### Crop

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

@@ -143,35 +151,12 @@ This is useful for example to mirror only one eye of the Oculus Go:

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

 If `--max-size` is also specified, resizing is applied after cropping.


-### Wireless
-
-_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
-device over TCP/IP:
-
-1. Connect the device to the same Wi-Fi as your computer.
-2. Get your device IP address (in Settings → About phone → Status).
-3. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
-4. Unplug your device.
-5. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`)_.
-6. Run `scrcpy` as usual.
-
-It may be useful to decrease the bit-rate and the definition:
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # short version
-```
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-### Record screen
+### Recording

 It is possible to record the screen while mirroring:

@@ -196,7 +181,31 @@ variation] does not impact the recorded file.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation


-### Multi-devices
+### Connection
+
+#### Wireless
+
+_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
+device over TCP/IP:
+
+1. Connect the device to the same Wi-Fi as your computer.
+2. Get your device IP address (in Settings → About phone → Status).
+3. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
+4. Unplug your device.
+5. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`)_.
+6. Run `scrcpy` as usual.
+
+It may be useful to decrease the bit-rate and the definition:
+
+```bash
+scrcpy --bit-rate 2M --max-size 800
+scrcpy -b2M -m800  # short version
+```
+
+[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
+
+
+#### Multi-devices

 If several devices are listed in `adb devices`, you must specify the _serial_:

@@ -207,8 +216,65 @@ scrcpy -s 0123456789abcdef  # short version

 You can start several instances of _scrcpy_ for several devices.

+#### SSH tunnel

-### Fullscreen
+To connect to a remote device, it is possible to connect a local `adb` client to
+a remote `adb` server (provided they use the same version of the _adb_
+protocol):
+
+```bash
+adb kill-server    # kill the local adb server on 5037
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
+# keep this open
+```
+
+From another terminal:
+
+```bash
+scrcpy
+```
+
+Like for wireless connections, it may be useful to reduce quality:
+
+```
+scrcpy -b2M -m800 --max-fps 15
+```
+
+### Window configuration
+
+#### Title
+
+By default, the window title is the device model. It can be changed:
+
+```bash
+scrcpy --window-title 'My device'
+```
+
+#### Position and size
+
+The initial window position and size may be specified:
+
+```bash
+scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
+```
+
+#### Borderless
+
+To disable window decorations:
+
+```bash
+scrcpy --window-borderless
+```
+
+#### Always on top
+
+To keep the scrcpy window always on top:
+
+```bash
+scrcpy --always-on-top
+```
+
+#### Fullscreen

 The app may be started directly in fullscreen:

@@ -220,17 +286,45 @@ scrcpy -f  # short version
 Fullscreen can then be toggled dynamically with `Ctrl`+`f`.


-### Always on top
+### Other mirroring options

-The window of app can always be above others by:
+#### Read-only
+
+To disable controls (everything which can interact with the device: input keys,
+mouse events, drag&drop files):

 ```bash
-scrcpy --always-on-top
-scrcpy -T  # short version
+scrcpy --no-control
+scrcpy -n
 ```

+#### Turn screen off

-### Show touches
+It is possible to turn the device screen off while mirroring on start with a
+command-line option:
+
+```bash
+scrcpy --turn-screen-off
+scrcpy -S
+```
+
+Or by pressing `Ctrl`+`o` at any time.
+
+To turn it back on, press `POWER` (or `Ctrl`+`p`).
+
+#### Render expired frames
+
+By default, to minimize latency, _scrcpy_ always renders the last decoded frame
+available, and drops any previous one.
+
+To force the rendering of all frames (at a cost of a possible increased
+latency), use:
+
+```bash
+scrcpy --render-expired-frames
+```
+
+#### Show touches

 For presentations, it may be useful to show physical touches (on the physical
 device).
@@ -247,7 +341,43 @@ scrcpy -t
 Note that it only shows _physical_ touches (with the finger on the device).


-### Install APK
+### Input control
+
+#### Copy-paste
+
+It is possible to synchronize clipboards between the computer and the device, in
+both directions:
+
+ - `Ctrl`+`c` copies the device clipboard to the computer clipboard;
+ - `Ctrl`+`Shift`+`v` copies the computer clipboard to the device clipboard;
+ - `Ctrl`+`v` _pastes_ the computer clipboard as a sequence of text events (but
+   breaks non-ASCII characters).
+
+#### Text injection preference
+
+There are two kinds of [events][textevents] generated when typing text:
+ - _key events_, signaling that a key is pressed or released;
+ - _text events_, signaling that a text has been entered.
+
+By default, letters are injected using key events, so that the keyboard behaves
+as expected in games (typically for WASD keys).
+
+But this may [cause issues][prefertext]. If you encounter such a problem, you
+can avoid it by:
+
+```bash
+scrcpy --prefer-text
+```
+
+(but this will break keyboard behavior in games)
+
+[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
+[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
+
+
+### File drop
+
+#### Install APK

 To install an APK, drag & drop an APK file (ending with `.apk`) to the _scrcpy_
 window.
@@ -255,7 +385,7 @@ window.
 There is no visual feedback, a log is printed to the console.


-### Push file to device
+#### Push file to device

 To push a file to `/sdcard/` on the device, drag & drop a (non-APK) file to the
 _scrcpy_ window.
@@ -268,53 +398,8 @@ The target directory can be changed on start:
 scrcpy --push-target /sdcard/foo/bar/
 ```

-### Read-only

-To disable controls (everything which can interact with the device: input keys,
-mouse events, drag&drop files):
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-### Turn screen off
-
-It is possible to turn the device screen off while mirroring on start with a
-command-line option:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-Or by pressing `Ctrl`+`o` at any time.
-
-To turn it back on, press `POWER` (or `Ctrl`+`p`).
-
-
-### Render expired frames
-
-By default, to minimize latency, _scrcpy_ always renders the last decoded frame
-available, and drops any previous one.
-
-To force the rendering of all frames (at a cost of a possible increased
-latency), use:
-
-```bash
-scrcpy --render-expired-frames
-```
-
-### Custom window title
-
-By default, the window title is the device model. It can be changed:
-
-```bash
-scrcpy --window-title 'My device'
-```
-
-
-### Forward audio
+### Audio forwarding

 Audio is not forwarded by _scrcpy_. Use [USBaudio] (Linux-only).

@@ -340,6 +425,7 @@ Also see [issue #14].
 | Click on `POWER`                       | `Ctrl`+`p`                    | `Cmd`+`p`
 | Power on                               | _Right-click²_                | _Right-click²_
 | Turn device screen off (keep mirroring)| `Ctrl`+`o`                    | `Cmd`+`o`
+ | Rotate device screen                   | `Ctrl`+`r`                    | `Cmd`+`r`
 | Expand notification panel              | `Ctrl`+`n`                    | `Cmd`+`n`
 | Collapse notification panel            | `Ctrl`+`Shift`+`n`            | `Cmd`+`Shift`+`n`
 | Copy device clipboard to computer      | `Ctrl`+`c`                    | `Cmd`+`c`
--- a/app/meson.build
+++ b/app/meson.build
@@ -10,16 +10,16 @@ src = [
    'src/file_handler.c',
    'src/fps_counter.c',
    'src/input_manager.c',
-    'src/net.c',
    'src/receiver.c',
    'src/recorder.c',
    'src/scrcpy.c',
    'src/screen.c',
    'src/server.c',
-    'src/str_util.c',
-    'src/tiny_xpm.c',
    'src/stream.c',
+    'src/tiny_xpm.c',
    'src/video_buffer.c',
+    'src/util/net.c',
+    'src/util/str_util.c'
 ]

 if not get_option('crossbuild_windows')
@@ -85,7 +85,7 @@ endif
 conf = configuration_data()

 # expose the build type
-conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')
+conf.set('NDEBUG', get_option('buildtype') != 'debug')

 # the version, updated on release
 conf.set_quoted('SCRCPY_VERSION', meson.project_version())
@@ -123,10 +123,8 @@ configure_file(configuration: conf, output: 'config.h')
 src_dir = include_directories('src')

 if get_option('windows_noconsole')
-    c_args = [ '-mwindows' ]
-    link_args = [ '-mwindows' ]
+    link_args = [ '-Wl,--subsystem,windows' ]
 else
-    c_args = []
    link_args = []
 endif

@@ -134,7 +132,7 @@ executable('scrcpy', src,
           dependencies: dependencies,
           include_directories: src_dir,
           install: true,
-           c_args: c_args,
+           c_args: [],
           link_args: link_args)

 install_man('scrcpy.1')
@@ -143,13 +141,16 @@ install_man('scrcpy.1')
 ### TESTS

 tests = [
+    ['test_buffer_util', [
+        'tests/test_buffer_util.c'
+    ]],
    ['test_cbuf', [
        'tests/test_cbuf.c',
    ]],
    ['test_control_event_serialize', [
        'tests/test_control_msg_serialize.c',
        'src/control_msg.c',
-        'src/str_util.c'
+        'src/util/str_util.c'
    ]],
    ['test_device_event_deserialize', [
        'tests/test_device_msg_deserialize.c',
@@ -160,7 +161,7 @@ tests = [
    ]],
    ['test_strutil', [
        'tests/test_strutil.c',
-        'src/str_util.c'
+        'src/util/str_util.c'
    ]],
 ]

--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -15,6 +15,10 @@ provides display and control of Android devices connected on USB (or over TCP/IP

 .SH OPTIONS

+.TP
+.B \-\-always\-on\-top
+Make scrcpy window always on top (above other windows).
+
 .TP
 .BI "\-b, \-\-bit\-rate " value
 Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
@@ -22,7 +26,7 @@ Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are
 Default is 8000000.

 .TP
-.BI "\-c, \-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
+.BI \-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
 Crop the device screen on the server.

 The values are expressed in the device natural orientation (typically, portrait for a phone, landscape for a tablet). Any
@@ -33,14 +37,14 @@ value is computed on the cropped size.
 .B \-f, \-\-fullscreen
 Start in fullscreen.

-.TP
-.BI "\-F, \-\-record\-format " format
-Force recording format (either mp4 or mkv).
-
 .TP
 .B \-h, \-\-help
 Print this help.

+.TP
+.BI \-\-max\-fps " value
+Limit the framerate of screen capture (only supported on devices with Android >= 10).
+
 .TP
 .BI "\-m, \-\-max\-size " value
 Limit both the width and height of the video to \fIvalue\fR. The other dimension is computed so that the device aspect\-ratio is preserved.
@@ -61,6 +65,13 @@ Set the TCP port the client listens on.

 Default is 27183.

+.TP
+.B \-\-prefer\-text
+Inject alpha characters and space as text events instead of key events.
+
+This avoids issues when combining multiple keys to enter special characters,
+but breaks the expected behavior of alpha keys in games (typically WASD).
+
 .TP
 .BI "\-\-push\-target " path
 Set the target directory for pushing files to the device by drag & drop. It is passed as\-is to "adb push".
@@ -73,9 +84,13 @@ Record screen to
 .IR file .

 The format is determined by the
-.B \-F/\-\-record\-format
+.B \-\-record\-format
 option if set, or by the file extension (.mp4 or .mkv).

+.TP
+.BI \-\-record\-format " format
+Force recording format (either mp4 or mkv).
+
 .TP
 .B \-\-render\-expired\-frames
 By default, to minimize latency, scrcpy always renders the last available decoded frame, and drops any previous ones. This flag forces to render all frames, at a cost of a possible increased latency.
@@ -94,18 +109,41 @@ Enable "show touches" on start, disable on quit.

 It only shows physical touches (not clicks from scrcpy).

-.TP
-.B \-T, \-\-always\-on\-top
-Make scrcpy window always on top (above other windows).
-
 .TP
 .B \-v, \-\-version
 Print the version of scrcpy.

+.TP
+.B \-\-window\-borderless
+Disable window decorations (display borderless window).
+
 .TP
 .BI \-\-window\-title " text
 Set a custom window title.

+.TP
+.BI \-\-window\-x " value
+Set the initial window horizontal position.
+
+Default is -1 (automatic).\n
+
+.TP
+.BI \-\-window\-y " value
+Set the initial window vertical position.
+
+Default is -1 (automatic).\n
+
+.TP
+.BI \-\-window\-width " value
+Set the initial window width.
+
+Default is 0 (automatic).\n
+
+.TP
+.BI \-\-window\-height " value
+Set the initial window height.
+
+Default is 0 (automatic).\n

 .SH SHORTCUTS

@@ -157,6 +195,10 @@ turn screen on
 .B Ctrl+o
 turn device screen off (keep mirroring)

+.TP
+.B Ctrl+r
+rotate device screen
+
 .TP
 .B Ctrl+n
 expand notification panel
--- a/app/src/command.c
+++ b/app/src/command.c
@@ -7,8 +7,8 @@

 #include "config.h"
 #include "common.h"
-#include "log.h"
-#include "str_util.h"
+#include "util/log.h"
+#include "util/str_util.h"

 static const char *adb_command;

@@ -91,7 +91,7 @@ adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {

    memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
    cmd[len + i] = NULL;
-    enum process_result r = cmd_execute(cmd[0], cmd, &process);
+    enum process_result r = cmd_execute(cmd, &process);
    if (r != PROCESS_SUCCESS) {
        show_adb_err_msg(r, cmd);
        return PROCESS_NONE;
--- a/app/src/command.h
+++ b/app/src/command.h
@@ -18,6 +18,7 @@
 #   define PRIsizet PRIu32
 # endif
 # define PROCESS_NONE NULL
+# define NO_EXIT_CODE -1u // max value as unsigned
  typedef HANDLE process_t;
  typedef DWORD exit_code_t;

@@ -28,6 +29,7 @@
 # define PRIsizet "zu"
 # define PRIexitcode "d"
 # define PROCESS_NONE -1
+# define NO_EXIT_CODE -1
  typedef pid_t process_t;
  typedef int exit_code_t;

@@ -35,8 +37,6 @@

 #include "config.h"

-# define NO_EXIT_CODE -1
-
 enum process_result {
    PROCESS_SUCCESS,
    PROCESS_ERROR_GENERIC,
@@ -44,7 +44,7 @@ enum process_result {
 };

 enum process_result
-cmd_execute(const char *path, const char *const argv[], process_t *process);
+cmd_execute(const char *const argv[], process_t *process);

 bool
 cmd_terminate(process_t pid);
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@@ -1,12 +1,12 @@
 #include "control_msg.h"

+#include <assert.h>
 #include <string.h>
-#include <SDL2/SDL_assert.h>

 #include "config.h"
-#include "buffer_util.h"
-#include "log.h"
-#include "str_util.h"
+#include "util/buffer_util.h"
+#include "util/log.h"
+#include "util/str_util.h"

 static void
 write_position(uint8_t *buf, const struct position *position) {
@@ -27,7 +27,7 @@ write_string(const char *utf8, size_t max_len, unsigned char *buf) {

 static uint16_t
 to_fixed_point_16(float f) {
-    SDL_assert(f >= 0.0f && f <= 1.0f);
+    assert(f >= 0.0f && f <= 1.0f);
    uint32_t u = f * 0x1p16f; // 2^16
    if (u >= 0xffff) {
        u = 0xffff;
@@ -78,6 +78,7 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
        case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
+        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
            // no additional data
            return 1;
        default:
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@@ -28,6 +28,7 @@ enum control_msg_type {
    CONTROL_MSG_TYPE_GET_CLIPBOARD,
    CONTROL_MSG_TYPE_SET_CLIPBOARD,
    CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
+    CONTROL_MSG_TYPE_ROTATE_DEVICE,
 };

 enum screen_power_mode {
--- a/app/src/controller.c
+++ b/app/src/controller.c
@@ -1,10 +1,10 @@
 #include "controller.h"

-#include <SDL2/SDL_assert.h>
+#include <assert.h>

 #include "config.h"
-#include "lock_util.h"
-#include "log.h"
+#include "util/lock.h"
+#include "util/log.h"

 bool
 controller_init(struct controller *controller, socket_t control_socket) {
@@ -85,7 +85,8 @@ run_controller(void *data) {
        }
        struct control_msg msg;
        bool non_empty = cbuf_take(&controller->queue, &msg);
-        SDL_assert(non_empty);
+        assert(non_empty);
+        (void) non_empty;
        mutex_unlock(controller->mutex);

        bool ok = process_msg(controller, &msg);
--- a/app/src/controller.h
+++ b/app/src/controller.h
@@ -6,10 +6,10 @@
 #include <SDL2/SDL_thread.h>

 #include "config.h"
-#include "cbuf.h"
 #include "control_msg.h"
-#include "net.h"
 #include "receiver.h"
+#include "util/cbuf.h"
+#include "util/net.h"

 struct control_msg_queue CBUF(struct control_msg, 64);

--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@@ -2,7 +2,6 @@

 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
-#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
@@ -10,12 +9,11 @@

 #include "config.h"
 #include "compat.h"
-#include "buffer_util.h"
 #include "events.h"
-#include "lock_util.h"
-#include "log.h"
 #include "recorder.h"
 #include "video_buffer.h"
+#include "util/buffer_util.h"
+#include "util/log.h"

 // set the decoded frame as ready for rendering, and notify
 static void
--- a/app/src/device.c
+++ b/app/src/device.c
@@ -1,7 +1,7 @@
 #include "device.h"

 #include "config.h"
-#include "log.h"
+#include "util/log.h"

 bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size) {
--- a/app/src/device.h
+++ b/app/src/device.h
@@ -5,7 +5,7 @@

 #include "config.h"
 #include "common.h"
-#include "net.h"
+#include "util/net.h"

 #define DEVICE_NAME_FIELD_LENGTH 64

--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@@ -1,11 +1,10 @@
 #include "device_msg.h"

 #include <string.h>
-#include <SDL2/SDL_assert.h>

 #include "config.h"
-#include "buffer_util.h"
-#include "log.h"
+#include "util/buffer_util.h"
+#include "util/log.h"

 ssize_t
 device_msg_deserialize(const unsigned char *buf, size_t len,
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@@ -75,7 +75,8 @@ convert_meta_state(SDL_Keymod mod) {
 }

 bool
-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod) {
+convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
+                bool prefer_text) {
    switch (from) {
        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
@@ -92,6 +93,12 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod) {
        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
    }
+
+    if (prefer_text) {
+        // do not forward alpha and space key events
+        return false;
+    }
+
    if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
        return false;
    }
--- a/app/src/event_converter.h
+++ b/app/src/event_converter.h
@@ -14,7 +14,8 @@ enum android_metastate
 convert_meta_state(SDL_Keymod mod);

 bool
-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod);
+convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
+                bool prefer_text);

 enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state);
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@@ -1,12 +1,12 @@
 #include "file_handler.h"

+#include <assert.h>
 #include <string.h>
-#include <SDL2/SDL_assert.h>

 #include "config.h"
 #include "command.h"
-#include "lock_util.h"
-#include "log.h"
+#include "util/lock.h"
+#include "util/log.h"

 #define DEFAULT_PUSH_TARGET "/sdcard/"

@@ -120,7 +120,8 @@ run_file_handler(void *data) {
        }
        struct file_handler_request req;
        bool non_empty = cbuf_take(&file_handler->queue, &req);
-        SDL_assert(non_empty);
+        assert(non_empty);
+        (void) non_empty;

        process_t process;
        if (req.action == ACTION_INSTALL_APK) {
--- a/app/src/file_handler.h
+++ b/app/src/file_handler.h
@@ -6,8 +6,8 @@
 #include <SDL2/SDL_thread.h>

 #include "config.h"
-#include "cbuf.h"
 #include "command.h"
+#include "util/cbuf.h"

 typedef enum {
    ACTION_INSTALL_APK,
--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@@ -1,11 +1,11 @@
 #include "fps_counter.h"

-#include <SDL2/SDL_assert.h>
+#include <assert.h>
 #include <SDL2/SDL_timer.h>

 #include "config.h"
-#include "lock_util.h"
-#include "log.h"
+#include "util/lock.h"
+#include "util/log.h"

 #define FPS_COUNTER_INTERVAL_MS 1000

@@ -77,7 +77,7 @@ run_fps_counter(void *data) {
            uint32_t now = SDL_GetTicks();
            check_interval_expired(counter, now);

-            SDL_assert(counter->next_timestamp > now);
+            assert(counter->next_timestamp > now);
            uint32_t remaining = counter->next_timestamp - now;

            // ignore the reason (timeout or signaled), we just loop anyway
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@@ -1,11 +1,11 @@
 #include "input_manager.h"

-#include <SDL2/SDL_assert.h>
+#include <assert.h>

 #include "config.h"
 #include "event_converter.h"
-#include "lock_util.h"
-#include "log.h"
+#include "util/lock.h"
+#include "util/log.h"

 // Convert window coordinates (as provided by SDL_GetMouseState() to renderer
 // coordinates (as provided in SDL mouse events)
@@ -211,15 +211,28 @@ clipboard_paste(struct controller *controller) {
    }
 }

+static void
+rotate_device(struct controller *controller) {
+    struct control_msg msg;
+    msg.type = CONTROL_MSG_TYPE_ROTATE_DEVICE;
+
+    if (!controller_push_msg(controller, &msg)) {
+        LOGW("Could not request device rotation");
+    }
+}
+
 void
 input_manager_process_text_input(struct input_manager *im,
                                 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;
+    if (!im->prefer_text) {
+        char c = event->text[0];
+        if (isalpha(c) || c == ' ') {
+            assert(event->text[1] == '\0');
+            // letters and space are handled as raw key event
+            return;
+        }
    }
+
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
    msg.inject_text.text = SDL_strdup(event->text);
@@ -234,7 +247,8 @@ input_manager_process_text_input(struct input_manager *im,
 }

 static bool
-convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to) {
+convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
+                  bool prefer_text) {
    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;

    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
@@ -242,7 +256,8 @@ convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to) {
    }

    uint16_t mod = from->keysym.mod;
-    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod)) {
+    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod,
+                         prefer_text)) {
        return false;
    }

@@ -383,6 +398,11 @@ input_manager_process_key(struct input_manager *im,
                    }
                }
                return;
+            case SDLK_r:
+                if (control && cmd && !shift && !repeat && down) {
+                    rotate_device(controller);
+                }
+                return;
        }

        return;
@@ -393,7 +413,7 @@ input_manager_process_key(struct input_manager *im,
    }

    struct control_msg msg;
-    if (convert_input_key(event, &msg)) {
+    if (convert_input_key(event, &msg, im->prefer_text)) {
        if (!controller_push_msg(controller, &msg)) {
            LOGW("Could not request 'inject keycode'");
        }
@@ -545,13 +565,8 @@ convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;

    to->inject_scroll_event.position = position;
-
-    int mul = from->direction == SDL_MOUSEWHEEL_NORMAL ? 1 : -1;
-    // SDL behavior seems inconsistent between horizontal and vertical scrolling
-    // so reverse the horizontal
-    // <https://wiki.libsdl.org/SDL_MouseWheelEvent#Remarks>
-    to->inject_scroll_event.hscroll = -mul * from->x;
-    to->inject_scroll_event.vscroll = mul * from->y;
+    to->inject_scroll_event.hscroll = from->x;
+    to->inject_scroll_event.vscroll = from->y;

    return true;
 }
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@@ -14,6 +14,7 @@ struct input_manager {
    struct controller *controller;
    struct video_buffer *video_buffer;
    struct screen *screen;
+    bool prefer_text;
 };

 void
--- a/app/src/lock_util.h
+++ b/app/src/lock_util.h
@@ -1,52 +0,0 @@
-#ifndef LOCKUTIL_H
-#define LOCKUTIL_H
-
-#include <stdint.h>
-#include <SDL2/SDL_mutex.h>
-
-#include "config.h"
-#include "log.h"
-
-static inline void
-mutex_lock(SDL_mutex *mutex) {
-    if (SDL_LockMutex(mutex)) {
-        LOGC("Could not lock mutex");
-        abort();
-    }
-}
-
-static inline void
-mutex_unlock(SDL_mutex *mutex) {
-    if (SDL_UnlockMutex(mutex)) {
-        LOGC("Could not unlock mutex");
-        abort();
-    }
-}
-
-static inline void
-cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
-    if (SDL_CondWait(cond, mutex)) {
-        LOGC("Could not wait on condition");
-        abort();
-    }
-}
-
-static inline int
-cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
-    int r = SDL_CondWaitTimeout(cond, mutex, ms);
-    if (r < 0) {
-        LOGC("Could not wait on condition with timeout");
-        abort();
-    }
-    return r;
-}
-
-static inline void
-cond_signal(SDL_cond *cond) {
-    if (SDL_CondSignal(cond)) {
-        LOGC("Could not signal a condition");
-        abort();
-    }
-}
-
-#endif
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -10,28 +10,13 @@

 #include "config.h"
 #include "compat.h"
-#include "log.h"
 #include "recorder.h"
+#include "util/log.h"

 struct args {
-    const char *serial;
-    const char *crop;
-    const char *record_filename;
-    const char *window_title;
-    const char *push_target;
-    enum recorder_format record_format;
-    bool fullscreen;
-    bool no_control;
-    bool no_display;
+    struct scrcpy_options opts;
    bool help;
    bool version;
-    bool show_touches;
-    uint16_t port;
-    uint16_t max_size;
-    uint32_t bit_rate;
-    bool always_on_top;
-    bool turn_screen_off;
-    bool render_expired_frames;
 };

 static void usage(const char *arg0) {
@@ -45,12 +30,15 @@ static void usage(const char *arg0) {
        "\n"
        "Options:\n"
        "\n"
+        "    --always-on-top\n"
+        "        Make scrcpy window always on top (above other windows).\n"
+        "\n"
        "    -b, --bit-rate value\n"
        "        Encode the video at the given bit-rate, expressed in bits/s.\n"
        "        Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
        "        Default is %d.\n"
        "\n"
-        "    -c, --crop width:height:x:y\n"
+        "    --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"
@@ -59,12 +47,13 @@ static void usage(const char *arg0) {
        "    -f, --fullscreen\n"
        "        Start in fullscreen.\n"
        "\n"
-        "    -F, --record-format format\n"
-        "        Force recording format (either mp4 or mkv).\n"
-        "\n"
        "    -h, --help\n"
        "        Print this help.\n"
        "\n"
+        "    --max-fps value\n"
+        "        Limit the frame rate of screen capture (only supported on\n"
+        "        devices with Android >= 10).\n"
+        "\n"
        "    -m, --max-size value\n"
        "        Limit both the width and height of the video to value. The\n"
        "        other dimension is computed so that the device aspect-ratio\n"
@@ -82,6 +71,13 @@ static void usage(const char *arg0) {
        "        Set the TCP port the client listens on.\n"
        "        Default is %d.\n"
        "\n"
+        "    --prefer-text\n"
+        "        Inject alpha characters and space as text events instead of\n"
+        "        key events.\n"
+        "        This avoids issues when combining multiple keys to enter a\n"
+        "        special character, but breaks the expected behavior of alpha\n"
+        "        keys in games (typically WASD).\n"
+        "\n"
        "    --push-target path\n"
        "        Set the target directory for pushing files to the device by\n"
        "        drag & drop. It is passed as-is to \"adb push\".\n"
@@ -89,9 +85,12 @@ static void usage(const char *arg0) {
        "\n"
        "    -r, --record file.mp4\n"
        "        Record screen to file.\n"
-        "        The format is determined by the -F/--record-format option if\n"
+        "        The format is determined by the --record-format option if\n"
        "        set, or by the file extension (.mp4 or .mkv).\n"
        "\n"
+        "    --record-format format\n"
+        "        Force recording format (either mp4 or mkv).\n"
+        "\n"
        "    --render-expired-frames\n"
        "        By default, to minimize latency, scrcpy always renders the\n"
        "        last available decoded frame, and drops any previous ones.\n"
@@ -109,15 +108,31 @@ static void usage(const char *arg0) {
        "        Enable \"show touches\" on start, disable on quit.\n"
        "        It only shows physical touches (not clicks from scrcpy).\n"
        "\n"
-        "    -T, --always-on-top\n"
-        "        Make scrcpy window always on top (above other windows).\n"
-        "\n"
        "    -v, --version\n"
        "        Print the version of scrcpy.\n"
        "\n"
+        "    --window-borderless\n"
+        "        Disable window decorations (display borderless window).\n"
+        "\n"
        "    --window-title text\n"
        "        Set a custom window title.\n"
        "\n"
+        "    --window-x value\n"
+        "        Set the initial window horizontal position.\n"
+        "        Default is -1 (automatic).\n"
+        "\n"
+        "    --window-y value\n"
+        "        Set the initial window vertical position.\n"
+        "        Default is -1 (automatic).\n"
+        "\n"
+        "    --window-width value\n"
+        "        Set the initial window width.\n"
+        "        Default is 0 (automatic).\n"
+        "\n"
+        "    --window-height value\n"
+        "        Set the initial window width.\n"
+        "        Default is 0 (automatic).\n"
+        "\n"
        "Shortcuts:\n"
        "\n"
        "    " CTRL_OR_CMD "+f\n"
@@ -160,6 +175,9 @@ static void usage(const char *arg0) {
        "    " CTRL_OR_CMD "+o\n"
        "        turn device screen off (keep mirroring)\n"
        "\n"
+        "    " CTRL_OR_CMD "+r\n"
+        "        rotate device screen\n"
+        "\n"
        "    " CTRL_OR_CMD "+n\n"
        "       expand notification panel\n"
        "\n"
@@ -228,7 +246,7 @@ parse_bit_rate(char *optarg, uint32_t *bit_rate) {
            return false;
        }
    }
-    if (value < 0 || ((uint32_t) -1) / mul < value) {
+    if (value < 0 || ((uint32_t) -1) / mul < (unsigned long) value) {
        LOGE("Bitrate must be positive and less than 2^32: %s", optarg);
        return false;
    }
@@ -258,11 +276,75 @@ parse_max_size(char *optarg, uint16_t *max_size) {
    return true;
 }

+static bool
+parse_max_fps(const char *optarg, uint16_t *max_fps) {
+    char *endptr;
+    if (*optarg == '\0') {
+        LOGE("Max FPS parameter is empty");
+        return false;
+    }
+    long value = strtol(optarg, &endptr, 0);
+    if (*endptr != '\0') {
+        LOGE("Invalid max FPS: %s", optarg);
+        return false;
+    }
+    if (value & ~0xffff) {
+        // in practice, it should not be higher than 60
+        LOGE("Max FPS value is invalid: %ld", value);
+        return false;
+    }
+
+    *max_fps = (uint16_t) value;
+    return true;
+}
+
+static bool
+parse_window_position(char *optarg, int16_t *position) {
+    char *endptr;
+    if (*optarg == '\0') {
+        LOGE("Window position parameter is empty");
+        return false;
+    }
+    long value = strtol(optarg, &endptr, 0);
+    if (*endptr != '\0') {
+        LOGE("Invalid window position: %s", optarg);
+        return false;
+    }
+    if (value < -1 || value > 0x7fff) {
+        LOGE("Window position must be between -1 and 32767: %ld", value);
+        return false;
+    }
+
+    *position = (int16_t) value;
+    return true;
+}
+
+static bool
+parse_window_dimension(char *optarg, uint16_t *dimension) {
+    char *endptr;
+    if (*optarg == '\0') {
+        LOGE("Window dimension parameter is empty");
+        return false;
+    }
+    long value = strtol(optarg, &endptr, 0);
+    if (*endptr != '\0') {
+        LOGE("Invalid window dimension: %s", optarg);
+        return false;
+    }
+    if (value & ~0xffff) {
+        LOGE("Window position must be between 0 and 65535: %ld", value);
+        return false;
+    }
+
+    *dimension = (uint16_t) value;
+    return true;
+}
+
 static bool
 parse_port(char *optarg, uint16_t *port) {
    char *endptr;
    if (*optarg == '\0') {
-        LOGE("Invalid port parameter is empty");
+        LOGE("Port parameter is empty");
        return false;
    }
    long value = strtol(optarg, &endptr, 0);
@@ -312,98 +394,157 @@ guess_record_format(const char *filename) {
 #define OPT_RENDER_EXPIRED_FRAMES 1000
 #define OPT_WINDOW_TITLE          1001
 #define OPT_PUSH_TARGET           1002
+#define OPT_ALWAYS_ON_TOP         1003
+#define OPT_CROP                  1004
+#define OPT_RECORD_FORMAT         1005
+#define OPT_PREFER_TEXT           1006
+#define OPT_WINDOW_X              1007
+#define OPT_WINDOW_Y              1008
+#define OPT_WINDOW_WIDTH          1009
+#define OPT_WINDOW_HEIGHT         1010
+#define OPT_WINDOW_BORDERLESS     1011
+#define OPT_MAX_FPS               1012

 static bool
 parse_args(struct args *args, int argc, char *argv[]) {
    static const struct option long_options[] = {
-        {"always-on-top",         no_argument,       NULL, 'T'},
+        {"always-on-top",         no_argument,       NULL, OPT_ALWAYS_ON_TOP},
        {"bit-rate",              required_argument, NULL, 'b'},
-        {"crop",                  required_argument, NULL, 'c'},
+        {"crop",                  required_argument, NULL, OPT_CROP},
        {"fullscreen",            no_argument,       NULL, 'f'},
        {"help",                  no_argument,       NULL, 'h'},
+        {"max-fps",               required_argument, NULL, OPT_MAX_FPS},
        {"max-size",              required_argument, NULL, 'm'},
        {"no-control",            no_argument,       NULL, 'n'},
        {"no-display",            no_argument,       NULL, 'N'},
        {"port",                  required_argument, NULL, 'p'},
-        {"push-target",           required_argument, NULL,
-                                                 OPT_PUSH_TARGET},
+        {"push-target",           required_argument, NULL, OPT_PUSH_TARGET},
        {"record",                required_argument, NULL, 'r'},
-        {"record-format",         required_argument, NULL, 'F'},
+        {"record-format",         required_argument, NULL, OPT_RECORD_FORMAT},
        {"render-expired-frames", no_argument,       NULL,
-                                                 OPT_RENDER_EXPIRED_FRAMES},
+                                                     OPT_RENDER_EXPIRED_FRAMES},
        {"serial",                required_argument, NULL, 's'},
        {"show-touches",          no_argument,       NULL, 't'},
        {"turn-screen-off",       no_argument,       NULL, 'S'},
+        {"prefer-text",           no_argument,       NULL, OPT_PREFER_TEXT},
        {"version",               no_argument,       NULL, 'v'},
-        {"window-title",          required_argument, NULL,
-                                                 OPT_WINDOW_TITLE},
+        {"window-title",          required_argument, NULL, OPT_WINDOW_TITLE},
+        {"window-x",              required_argument, NULL, OPT_WINDOW_X},
+        {"window-y",              required_argument, NULL, OPT_WINDOW_Y},
+        {"window-width",          required_argument, NULL, OPT_WINDOW_WIDTH},
+        {"window-height",         required_argument, NULL, OPT_WINDOW_HEIGHT},
+        {"window-borderless",     no_argument,       NULL,
+                                                     OPT_WINDOW_BORDERLESS},
        {NULL,                    0,                 NULL, 0  },
    };
+
+    struct scrcpy_options *opts = &args->opts;
+
    int c;
    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTv", long_options,
                            NULL)) != -1) {
        switch (c) {
            case 'b':
-                if (!parse_bit_rate(optarg, &args->bit_rate)) {
+                if (!parse_bit_rate(optarg, &opts->bit_rate)) {
                    return false;
                }
                break;
            case 'c':
-                args->crop = optarg;
+                LOGW("Deprecated option -c. Use --crop instead.");
+                // fall through
+            case OPT_CROP:
+                opts->crop = optarg;
                break;
            case 'f':
-                args->fullscreen = true;
+                opts->fullscreen = true;
                break;
            case 'F':
-                if (!parse_record_format(optarg, &args->record_format)) {
+                LOGW("Deprecated option -F. Use --record-format instead.");
+                // fall through
+            case OPT_RECORD_FORMAT:
+                if (!parse_record_format(optarg, &opts->record_format)) {
                    return false;
                }
                break;
            case 'h':
                args->help = true;
                break;
+            case OPT_MAX_FPS:
+                if (!parse_max_fps(optarg, &opts->max_fps)) {
+                    return false;
+                }
+                break;
            case 'm':
-                if (!parse_max_size(optarg, &args->max_size)) {
+                if (!parse_max_size(optarg, &opts->max_size)) {
                    return false;
                }
                break;
            case 'n':
-                args->no_control = true;
+                opts->control = false;
                break;
            case 'N':
-                args->no_display = true;
+                opts->display = false;
                break;
            case 'p':
-                if (!parse_port(optarg, &args->port)) {
+                if (!parse_port(optarg, &opts->port)) {
                    return false;
                }
                break;
            case 'r':
-                args->record_filename = optarg;
+                opts->record_filename = optarg;
                break;
            case 's':
-                args->serial = optarg;
+                opts->serial = optarg;
                break;
            case 'S':
-                args->turn_screen_off = true;
+                opts->turn_screen_off = true;
                break;
            case 't':
-                args->show_touches = true;
+                opts->show_touches = true;
                break;
            case 'T':
-                args->always_on_top = true;
+                LOGW("Deprecated option -T. Use --always-on-top instead.");
+                // fall through
+            case OPT_ALWAYS_ON_TOP:
+                opts->always_on_top = true;
                break;
            case 'v':
                args->version = true;
                break;
            case OPT_RENDER_EXPIRED_FRAMES:
-                args->render_expired_frames = true;
+                opts->render_expired_frames = true;
                break;
            case OPT_WINDOW_TITLE:
-                args->window_title = optarg;
+                opts->window_title = optarg;
+                break;
+            case OPT_WINDOW_X:
+                if (!parse_window_position(optarg, &opts->window_x)) {
+                    return false;
+                }
+                break;
+            case OPT_WINDOW_Y:
+                if (!parse_window_position(optarg, &opts->window_y)) {
+                    return false;
+                }
+                break;
+            case OPT_WINDOW_WIDTH:
+                if (!parse_window_dimension(optarg, &opts->window_width)) {
+                    return false;
+                }
+                break;
+            case OPT_WINDOW_HEIGHT:
+                if (!parse_window_dimension(optarg, &opts->window_height)) {
+                    return false;
+                }
+                break;
+            case OPT_WINDOW_BORDERLESS:
+                opts->window_borderless = true;
                break;
            case OPT_PUSH_TARGET:
-                args->push_target = optarg;
+                opts->push_target = optarg;
+                break;
+            case OPT_PREFER_TEXT:
+                opts->prefer_text = true;
                break;
            default:
                // getopt prints the error message on stderr
@@ -411,12 +552,12 @@ parse_args(struct args *args, int argc, char *argv[]) {
        }
    }

-    if (args->no_display && !args->record_filename) {
+    if (!opts->display && !opts->record_filename) {
        LOGE("-N/--no-display requires screen recording (-r/--record)");
        return false;
    }

-    if (args->no_display && args->fullscreen) {
+    if (!opts->display && opts->fullscreen) {
        LOGE("-f/--fullscreen-window is incompatible with -N/--no-display");
        return false;
    }
@@ -427,21 +568,21 @@ parse_args(struct args *args, int argc, char *argv[]) {
        return false;
    }

-    if (args->record_format && !args->record_filename) {
+    if (opts->record_format && !opts->record_filename) {
        LOGE("Record format specified without recording");
        return false;
    }

-    if (args->record_filename && !args->record_format) {
-        args->record_format = guess_record_format(args->record_filename);
-        if (!args->record_format) {
+    if (opts->record_filename && !opts->record_format) {
+        opts->record_format = guess_record_format(opts->record_filename);
+        if (!opts->record_format) {
            LOGE("No format specified for \"%s\" (try with -F mkv)",
-                 args->record_filename);
+                 opts->record_filename);
            return false;
        }
    }

-    if (args->no_control && args->turn_screen_off) {
+    if (!opts->control && opts->turn_screen_off) {
        LOGE("Could not request to turn screen off if control is disabled");
        return false;
    }
@@ -458,24 +599,11 @@ main(int argc, char *argv[]) {
    setbuf(stderr, NULL);
 #endif
    struct args args = {
-        .serial = NULL,
-        .crop = NULL,
-        .record_filename = NULL,
-        .window_title = NULL,
-        .push_target = NULL,
-        .record_format = 0,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
-        .show_touches = false,
-        .port = DEFAULT_LOCAL_PORT,
-        .max_size = DEFAULT_MAX_SIZE,
-        .bit_rate = DEFAULT_BIT_RATE,
-        .always_on_top = false,
-        .no_control = false,
-        .no_display = false,
-        .turn_screen_off = false,
-        .render_expired_frames = false,
    };
+
    if (!parse_args(&args, argc, argv)) {
        return 1;
    }
@@ -500,29 +628,11 @@ main(int argc, char *argv[]) {
        return 1;
    }

-#ifdef BUILD_DEBUG
+#ifndef NDEBUG
    SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
 #endif

-    struct scrcpy_options options = {
-        .serial = args.serial,
-        .crop = args.crop,
-        .port = args.port,
-        .record_filename = args.record_filename,
-        .window_title = args.window_title,
-        .push_target = args.push_target,
-        .record_format = args.record_format,
-        .max_size = args.max_size,
-        .bit_rate = args.bit_rate,
-        .show_touches = args.show_touches,
-        .fullscreen = args.fullscreen,
-        .always_on_top = args.always_on_top,
-        .control = !args.no_control,
-        .display = !args.no_display,
-        .turn_screen_off = args.turn_screen_off,
-        .render_expired_frames = args.render_expired_frames,
-    };
-    int res = scrcpy(&options) ? 0 : 1;
+    int res = scrcpy(&args.opts) ? 0 : 1;

    avformat_network_deinit(); // ignore failure

--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@@ -1,12 +1,12 @@
 #include "receiver.h"

-#include <SDL2/SDL_assert.h>
+#include <assert.h>
 #include <SDL2/SDL_clipboard.h>

 #include "config.h"
 #include "device_msg.h"
-#include "lock_util.h"
-#include "log.h"
+#include "util/lock.h"
+#include "util/log.h"

 bool
 receiver_init(struct receiver *receiver, socket_t control_socket) {
@@ -23,7 +23,7 @@ receiver_destroy(struct receiver *receiver) {
 }

 static void
-process_msg(struct receiver *receiver, struct device_msg *msg) {
+process_msg(struct device_msg *msg) {
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD:
            LOGI("Device clipboard copied");
@@ -33,7 +33,7 @@ process_msg(struct receiver *receiver, struct device_msg *msg) {
 }

 static ssize_t
-process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
+process_msgs(const unsigned char *buf, size_t len) {
    size_t head = 0;
    for (;;) {
        struct device_msg msg;
@@ -45,11 +45,11 @@ process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
            return head;
        }

-        process_msg(receiver, &msg);
+        process_msg(&msg);
        device_msg_destroy(&msg);

        head += r;
-        SDL_assert(head <= len);
+        assert(head <= len);
        if (head == len) {
            return head;
        }
@@ -64,7 +64,7 @@ run_receiver(void *data) {
    size_t head = 0;

    for (;;) {
-        SDL_assert(head < DEVICE_MSG_SERIALIZED_MAX_SIZE);
+        assert(head < DEVICE_MSG_SERIALIZED_MAX_SIZE);
        ssize_t r = net_recv(receiver->control_socket, buf,
                             DEVICE_MSG_SERIALIZED_MAX_SIZE - head);
        if (r <= 0) {
@@ -72,7 +72,7 @@ run_receiver(void *data) {
            break;
        }

-        ssize_t consumed = process_msgs(receiver, buf, r);
+        ssize_t consumed = process_msgs(buf, r);
        if (consumed == -1) {
            // an error occurred
            break;
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@@ -6,7 +6,7 @@
 #include <SDL2/SDL_thread.h>

 #include "config.h"
-#include "net.h"
+#include "util/net.h"

 // receive events from the device
 // managed by the controller
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@@ -1,12 +1,12 @@
 #include "recorder.h"

+#include <assert.h>
 #include <libavutil/time.h>
-#include <SDL2/SDL_assert.h>

 #include "config.h"
 #include "compat.h"
-#include "lock_util.h"
-#include "log.h"
+#include "util/lock.h"
+#include "util/log.h"

 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us

@@ -116,7 +116,7 @@ recorder_get_format_name(enum recorder_format format) {
 bool
 recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    const char *format_name = recorder_get_format_name(recorder->format);
-    SDL_assert(format_name);
+    assert(format_name);
    const AVOutputFormat *format = find_muxer(format_name);
    if (!format) {
        LOGE("Could not find muxer");
@@ -174,9 +174,14 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {

 void
 recorder_close(struct recorder *recorder) {
-    int ret = av_write_trailer(recorder->ctx);
-    if (ret < 0) {
-        LOGE("Failed to write trailer to %s", recorder->filename);
+    if (recorder->header_written) {
+        int ret = av_write_trailer(recorder->ctx);
+        if (ret < 0) {
+            LOGE("Failed to write trailer to %s", recorder->filename);
+            recorder->failed = true;
+        }
+    } else {
+        // the recorded file is empty
        recorder->failed = true;
    }
    avio_close(recorder->ctx->pb);
@@ -296,8 +301,12 @@ run_recorder(void *data) {
            continue;
        }

-        // we now know the duration of the previous packet
-        previous->packet.duration = rec->packet.pts - previous->packet.pts;
+        // config packets have no PTS, we must ignore them
+        if (rec->packet.pts != AV_NOPTS_VALUE
+            && previous->packet.pts != AV_NOPTS_VALUE) {
+            // we now know the duration of the previous packet
+            previous->packet.duration = rec->packet.pts - previous->packet.pts;
+        }

        bool ok = recorder_write(recorder, &previous->packet);
        record_packet_delete(previous);
@@ -348,7 +357,7 @@ recorder_join(struct recorder *recorder) {
 bool
 recorder_push(struct recorder *recorder, const AVPacket *packet) {
    mutex_lock(recorder->mutex);
-    SDL_assert(!recorder->stopped);
+    assert(!recorder->stopped);

    if (recorder->failed) {
        // reject any new packet (this will stop the stream)
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@@ -8,10 +8,11 @@

 #include "config.h"
 #include "common.h"
-#include "queue.h"
+#include "util/queue.h"

 enum recorder_format {
-    RECORDER_FORMAT_MP4 = 1,
+    RECORDER_FORMAT_AUTO,
+    RECORDER_FORMAT_MP4,
    RECORDER_FORMAT_MKV,
 };

--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -18,15 +18,15 @@
 #include "file_handler.h"
 #include "fps_counter.h"
 #include "input_manager.h"
-#include "log.h"
-#include "lock_util.h"
-#include "net.h"
 #include "recorder.h"
 #include "screen.h"
 #include "server.h"
 #include "stream.h"
 #include "tiny_xpm.h"
 #include "video_buffer.h"
+#include "util/lock.h"
+#include "util/log.h"
+#include "util/net.h"

 static struct server server = SERVER_INITIALIZER;
 static struct screen screen = SCREEN_INITIALIZER;
@@ -42,6 +42,7 @@ static struct input_manager input_manager = {
    .controller = &controller,
    .video_buffer = &video_buffer,
    .screen = &screen,
+    .prefer_text = false, // initialized later
 };

 // init SDL and set appropriate hints
@@ -102,6 +103,7 @@ sdl_init_and_configure(bool display) {
 // <https://stackoverflow.com/a/40693139/1987178>
 static int
 event_watcher(void *data, SDL_Event *event) {
+    (void) data;
    if (event->type == SDL_WINDOWEVENT
            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
        // called from another thread, not very safe, but it's a workaround!
@@ -143,12 +145,7 @@ handle_event(SDL_Event *event, bool control) {
            }
            break;
        case SDL_WINDOWEVENT:
-            switch (event->window.event) {
-                case SDL_WINDOWEVENT_EXPOSED:
-                case SDL_WINDOWEVENT_SIZE_CHANGED:
-                    screen_render(&screen);
-                    break;
-            }
+            screen_handle_window_event(&screen, &event->window);
            break;
        case SDL_TEXTINPUT:
            if (!control) {
@@ -205,6 +202,7 @@ handle_event(SDL_Event *event, bool control) {

 static bool
 event_loop(bool display, bool control) {
+    (void) display;
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
    if (display) {
        SDL_AddEventWatch(event_watcher, NULL);
@@ -217,6 +215,7 @@ event_loop(bool display, bool control) {
            case EVENT_RESULT_STOPPED_BY_USER:
                return true;
            case EVENT_RESULT_STOPPED_BY_EOS:
+                LOGW("Device disconnected");
                return false;
            case EVENT_RESULT_CONTINUE:
                break;
@@ -259,6 +258,7 @@ sdl_priority_from_av_level(int level) {

 static void
 av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
+    (void) avcl;
    SDL_LogPriority priority = sdl_priority_from_av_level(level);
    if (priority == 0) {
        return;
@@ -283,6 +283,7 @@ scrcpy(const struct scrcpy_options *options) {
        .local_port = options->port,
        .max_size = options->max_size,
        .bit_rate = options->bit_rate,
+        .max_fps = options->max_fps,
        .control = options->control,
    };
    if (!server_start(&server, options->serial, &params)) {
@@ -390,7 +391,10 @@ scrcpy(const struct scrcpy_options *options) {
            options->window_title ? options->window_title : device_name;

        if (!screen_init_rendering(&screen, window_title, frame_size,
-                                   options->always_on_top)) {
+                                   options->always_on_top, options->window_x,
+                                   options->window_y, options->window_width,
+                                   options->window_height,
+                                   options->window_borderless)) {
            goto end;
        }

@@ -414,6 +418,8 @@ scrcpy(const struct scrcpy_options *options) {
        show_touches_waited = true;
    }

+    input_manager.prefer_text = options->prefer_text;
+
    ret = event_loop(options->display, options->control);
    LOGD("quit...");

--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@@ -3,9 +3,10 @@

 #include <stdbool.h>
 #include <stdint.h>
-#include <recorder.h>

 #include "config.h"
+#include "input_manager.h"
+#include "recorder.h"

 struct scrcpy_options {
    const char *serial;
@@ -17,6 +18,11 @@ struct scrcpy_options {
    uint16_t port;
    uint16_t max_size;
    uint32_t bit_rate;
+    uint16_t max_fps;
+    int16_t window_x;
+    int16_t window_y;
+    uint16_t window_width;
+    uint16_t window_height;
    bool show_touches;
    bool fullscreen;
    bool always_on_top;
@@ -24,8 +30,36 @@ struct scrcpy_options {
    bool display;
    bool turn_screen_off;
    bool render_expired_frames;
+    bool prefer_text;
+    bool window_borderless;
 };

+#define SCRCPY_OPTIONS_DEFAULT { \
+    .serial = NULL, \
+    .crop = NULL, \
+    .record_filename = NULL, \
+    .window_title = NULL, \
+    .push_target = NULL, \
+    .record_format = RECORDER_FORMAT_AUTO, \
+    .port = DEFAULT_LOCAL_PORT, \
+    .max_size = DEFAULT_LOCAL_PORT, \
+    .bit_rate = DEFAULT_BIT_RATE, \
+    .max_fps = 0, \
+    .window_x = -1, \
+    .window_y = -1, \
+    .window_width = 0, \
+    .window_height = 0, \
+    .show_touches = false, \
+    .fullscreen = false, \
+    .always_on_top = false, \
+    .control = true, \
+    .display = true, \
+    .turn_screen_off = false, \
+    .render_expired_frames = false, \
+    .prefer_text = false, \
+    .window_borderless = false, \
+}
+
 bool
 scrcpy(const struct scrcpy_options *options);

--- a/app/src/screen.c
+++ b/app/src/screen.c
@@ -1,5 +1,6 @@
 #include "screen.h"

+#include <assert.h>
 #include <string.h>
 #include <SDL2/SDL.h>

@@ -7,10 +8,10 @@
 #include "common.h"
 #include "compat.h"
 #include "icon.xpm"
-#include "lock_util.h"
-#include "log.h"
 #include "tiny_xpm.h"
 #include "video_buffer.h"
+#include "util/lock.h"
+#include "util/log.h"

 #define DISPLAY_MARGINS 96

@@ -30,23 +31,28 @@ get_window_size(SDL_Window *window) {
 // get the windowed window size
 static struct size
 get_windowed_window_size(const struct screen *screen) {
-    if (screen->fullscreen) {
+    if (screen->fullscreen || screen->maximized) {
        return screen->windowed_window_size;
    }
    return get_window_size(screen->window);
 }

+// apply the windowed window size if fullscreen and maximized are disabled
+static void
+apply_windowed_size(struct screen *screen) {
+    if (!screen->fullscreen && !screen->maximized) {
+        SDL_SetWindowSize(screen->window, screen->windowed_window_size.width,
+                                          screen->windowed_window_size.height);
+    }
+}
+
 // set the window size to be applied when fullscreen is disabled
 static void
 set_window_size(struct screen *screen, struct size new_size) {
    // setting the window size during fullscreen is implementation defined,
    // so apply the resize only after fullscreen is disabled
-    if (screen->fullscreen) {
-        // SDL_SetWindowSize will be called when fullscreen will be disabled
-        screen->windowed_window_size = new_size;
-    } else {
-        SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
-    }
+    screen->windowed_window_size = new_size;
+    apply_windowed_size(screen);
 }

 // get the preferred display bounds (i.e. the screen bounds with some margins)
@@ -105,7 +111,7 @@ get_optimal_size(struct size current_size, struct size frame_size) {
    }

    // w and h must fit into 16 bits
-    SDL_assert_release(w < 0x10000 && h < 0x10000);
+    assert(w < 0x10000 && h < 0x10000);
    return (struct size) {w, h};
 }

@@ -117,9 +123,30 @@ get_optimal_window_size(const struct screen *screen, struct size frame_size) {
 }

 // initially, there is no current size, so use the frame size as current size
+// req_width and req_height, if not 0, are the sizes requested by the user
 static inline struct size
-get_initial_optimal_size(struct size frame_size) {
-    return get_optimal_size(frame_size, frame_size);
+get_initial_optimal_size(struct size frame_size, uint16_t req_width,
+                         uint16_t req_height) {
+    struct size window_size;
+    if (!req_width && !req_height) {
+        window_size = get_optimal_size(frame_size, frame_size);
+    } else {
+        if (req_width) {
+            window_size.width = req_width;
+        } else {
+            // compute from the requested height
+            window_size.width = (uint32_t) req_height * frame_size.width
+                              / frame_size.height;
+        }
+        if (req_height) {
+            window_size.height = req_height;
+        } else {
+            // compute from the requested width
+            window_size.height = (uint32_t) req_width * frame_size.height
+                               / frame_size.width;
+        }
+    }
+    return window_size;
 }

 void
@@ -136,10 +163,13 @@ create_texture(SDL_Renderer *renderer, struct size frame_size) {

 bool
 screen_init_rendering(struct screen *screen, const char *window_title,
-                      struct size frame_size, bool always_on_top) {
+                      struct size frame_size, bool always_on_top,
+                      int16_t window_x, int16_t window_y, uint16_t window_width,
+                      uint16_t window_height, bool window_borderless) {
    screen->frame_size = frame_size;

-    struct size window_size = get_initial_optimal_size(frame_size);
+    struct size window_size =
+        get_initial_optimal_size(frame_size, window_width, window_height);
    uint32_t window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
 #ifdef HIDPI_SUPPORT
    window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
@@ -152,9 +182,13 @@ screen_init_rendering(struct screen *screen, const char *window_title,
             "(compile with SDL >= 2.0.5 to enable it)");
 #endif
    }
+    if (window_borderless) {
+        window_flags |= SDL_WINDOW_BORDERLESS;
+    }

-    screen->window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_UNDEFINED,
-                                      SDL_WINDOWPOS_UNDEFINED,
+    int x = window_x != -1 ? window_x : (int) SDL_WINDOWPOS_UNDEFINED;
+    int y = window_y != -1 ? window_y : (int) SDL_WINDOWPOS_UNDEFINED;
+    screen->window = SDL_CreateWindow(window_title, x, y,
                                      window_size.width, window_size.height,
                                      window_flags);
    if (!screen->window) {
@@ -194,6 +228,8 @@ screen_init_rendering(struct screen *screen, const char *window_title,
        return false;
    }

+    screen->windowed_window_size = window_size;
+
    return true;
 }

@@ -287,10 +323,6 @@ screen_render(struct screen *screen) {

 void
 screen_switch_fullscreen(struct screen *screen) {
-    if (!screen->fullscreen) {
-        // going to fullscreen, store the current windowed window size
-        screen->windowed_window_size = get_window_size(screen->window);
-    }
    uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
    if (SDL_SetWindowFullscreen(screen->window, new_mode)) {
        LOGW("Could not switch fullscreen mode: %s", SDL_GetError());
@@ -298,11 +330,7 @@ screen_switch_fullscreen(struct screen *screen) {
    }

    screen->fullscreen = !screen->fullscreen;
-    if (!screen->fullscreen) {
-        // fullscreen disabled, restore expected windowed window size
-        SDL_SetWindowSize(screen->window, screen->windowed_window_size.width,
-                          screen->windowed_window_size.height);
-    }
+    apply_windowed_size(screen);

    LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
    screen_render(screen);
@@ -310,20 +338,75 @@ screen_switch_fullscreen(struct screen *screen) {

 void
 screen_resize_to_fit(struct screen *screen) {
-    if (!screen->fullscreen) {
-        struct size optimal_size = get_optimal_window_size(screen,
-                                                           screen->frame_size);
-        SDL_SetWindowSize(screen->window, optimal_size.width,
-                          optimal_size.height);
-        LOGD("Resized to optimal size");
+    if (screen->fullscreen) {
+        return;
    }
+
+    if (screen->maximized) {
+        SDL_RestoreWindow(screen->window);
+        screen->maximized = false;
+    }
+
+    struct size optimal_size =
+        get_optimal_window_size(screen, screen->frame_size);
+    SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
+    LOGD("Resized to optimal size");
 }

 void
 screen_resize_to_pixel_perfect(struct screen *screen) {
-    if (!screen->fullscreen) {
-        SDL_SetWindowSize(screen->window, screen->frame_size.width,
-                          screen->frame_size.height);
-        LOGD("Resized to pixel-perfect");
+    if (screen->fullscreen) {
+        return;
+    }
+
+    if (screen->maximized) {
+        SDL_RestoreWindow(screen->window);
+        screen->maximized = false;
+    }
+
+    SDL_SetWindowSize(screen->window, screen->frame_size.width,
+                      screen->frame_size.height);
+    LOGD("Resized to pixel-perfect");
+}
+
+void
+screen_handle_window_event(struct screen *screen,
+                           const SDL_WindowEvent *event) {
+    switch (event->event) {
+        case SDL_WINDOWEVENT_EXPOSED:
+            screen_render(screen);
+            break;
+        case SDL_WINDOWEVENT_SIZE_CHANGED:
+            if (!screen->fullscreen && !screen->maximized) {
+                // Backup the previous size: if we receive the MAXIMIZED event,
+                // then the new size must be ignored (it's the maximized size).
+                // We could not rely on the window flags due to race conditions
+                // (they could be updated asynchronously, at least on X11).
+                screen->windowed_window_size_backup =
+                    screen->windowed_window_size;
+
+                // Save the windowed size, so that it is available once the
+                // window is maximized or fullscreen is enabled.
+                screen->windowed_window_size = get_window_size(screen->window);
+            }
+            screen_render(screen);
+            break;
+        case SDL_WINDOWEVENT_MAXIMIZED:
+            // The backup size must be non-nul.
+            assert(screen->windowed_window_size_backup.width);
+            assert(screen->windowed_window_size_backup.height);
+            // Revert the last size, it was updated while screen was maximized.
+            screen->windowed_window_size = screen->windowed_window_size_backup;
+#ifdef DEBUG
+            // Reset the backup to invalid values to detect unexpected usage
+            screen->windowed_window_size_backup.width = 0;
+            screen->windowed_window_size_backup.height = 0;
+#endif
+            screen->maximized = true;
+            break;
+        case SDL_WINDOWEVENT_RESTORED:
+            screen->maximized = false;
+            apply_windowed_size(screen);
+            break;
    }
 }
--- a/app/src/screen.h
+++ b/app/src/screen.h
@@ -15,28 +15,37 @@ struct screen {
    SDL_Renderer *renderer;
    SDL_Texture *texture;
    struct size frame_size;
-    //used only in fullscreen mode to know the windowed window size
+    // The window size the last time it was not maximized or fullscreen.
    struct size windowed_window_size;
+    // Since we receive the event SIZE_CHANGED before MAXIMIZED, we must be
+    // able to revert the size to its non-maximized value.
+    struct size windowed_window_size_backup;
    bool has_frame;
    bool fullscreen;
+    bool maximized;
    bool no_window;
 };

-#define SCREEN_INITIALIZER {  \
-    .window = NULL,           \
-    .renderer = NULL,         \
-    .texture = NULL,          \
-    .frame_size = {           \
-        .width = 0,           \
-        .height = 0,          \
-    },                        \
+#define SCREEN_INITIALIZER { \
+    .window = NULL, \
+    .renderer = NULL, \
+    .texture = NULL, \
+    .frame_size = { \
+        .width = 0,  \
+        .height = 0, \
+    }, \
    .windowed_window_size = { \
-        .width = 0,           \
-        .height = 0,          \
-    },                        \
-    .has_frame = false,   \
-    .fullscreen = false,  \
-    .no_window = false,   \
+        .width = 0, \
+        .height = 0, \
+    }, \
+    .windowed_window_size_backup = { \
+        .width = 0, \
+        .height = 0, \
+    }, \
+    .has_frame = false, \
+    .fullscreen = false, \
+    .maximized = false, \
+    .no_window = false, \
 }

 // initialize default values
@@ -46,7 +55,9 @@ screen_init(struct screen *screen);
 // initialize screen, create window, renderer and texture (window is hidden)
 bool
 screen_init_rendering(struct screen *screen, const char *window_title,
-                      struct size frame_size, bool always_on_top);
+                      struct size frame_size, bool always_on_top,
+                      int16_t window_x, int16_t window_y, uint16_t window_width,
+                      uint16_t window_height, bool window_borderless);

 // show the window
 void
@@ -76,4 +87,8 @@ screen_resize_to_fit(struct screen *screen);
 void
 screen_resize_to_pixel_perfect(struct screen *screen);

+// react to window events
+void
+screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);
+
 #endif
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -1,22 +1,22 @@
 #include "server.h"

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

 #include "config.h"
 #include "command.h"
-#include "log.h"
-#include "net.h"
+#include "util/log.h"
+#include "util/net.h"

 #define SOCKET_NAME "scrcpy"
 #define SERVER_FILENAME "scrcpy-server"

 #define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FILENAME
-#define DEVICE_SERVER_PATH "/data/local/tmp/" SERVER_FILENAME
+#define DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"

 static const char *
 get_server_path(void) {
@@ -118,11 +118,13 @@ static process_t
 execute_server(struct server *server, const struct server_params *params) {
    char max_size_string[6];
    char bit_rate_string[11];
+    char max_fps_string[6];
    sprintf(max_size_string, "%"PRIu16, params->max_size);
    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
+    sprintf(max_fps_string, "%"PRIu16, params->max_fps);
    const char *const cmd[] = {
        "shell",
-        "CLASSPATH=/data/local/tmp/" SERVER_FILENAME,
+        "CLASSPATH=" DEVICE_SERVER_PATH,
        "app_process",
 #ifdef SERVER_DEBUGGER
 # define SERVER_DEBUGGER_PORT "5005"
@@ -131,8 +133,10 @@ execute_server(struct server *server, const struct server_params *params) {
 #endif
        "/", // unused
        "com.genymobile.scrcpy.Server",
+        SCRCPY_VERSION,
        max_size_string,
        bit_rate_string,
+        max_fps_string,
        server->tunnel_forward ? "true" : "false",
        params->crop ? params->crop : "-",
        "true", // always send frame meta (packet boundaries + timestamp)
@@ -195,7 +199,7 @@ connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {

 static void
 close_socket(socket_t *socket) {
-    SDL_assert(*socket != INVALID_SOCKET);
+    assert(*socket != INVALID_SOCKET);
    net_shutdown(*socket, SHUT_RDWR);
    if (!net_close(*socket)) {
        LOGW("Could not close socket");
@@ -277,7 +281,7 @@ server_connect_to(struct server *server) {

        server->control_socket = net_accept(server->server_socket);
        if (server->control_socket == INVALID_SOCKET) {
-            // the video_socket will be clean up on destroy
+            // the video_socket will be cleaned up on destroy
            return false;
        }

@@ -319,7 +323,7 @@ server_stop(struct server *server) {
        close_socket(&server->control_socket);
    }

-    SDL_assert(server->process != PROCESS_NONE);
+    assert(server->process != PROCESS_NONE);

    if (!cmd_terminate(server->process)) {
        LOGW("Could not terminate server");
--- a/app/src/server.h
+++ b/app/src/server.h
@@ -6,7 +6,7 @@

 #include "config.h"
 #include "command.h"
-#include "net.h"
+#include "util/net.h"

 struct server {
    char *serial;
@@ -35,6 +35,7 @@ struct server_params {
    uint16_t local_port;
    uint16_t max_size;
    uint32_t bit_rate;
+    uint16_t max_fps;
    bool control;
 };

--- a/app/src/stream.c
+++ b/app/src/stream.c
@@ -1,8 +1,8 @@
 #include "stream.h"

+#include <assert.h>
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
-#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
@@ -10,12 +10,11 @@

 #include "config.h"
 #include "compat.h"
-#include "buffer_util.h"
 #include "decoder.h"
 #include "events.h"
-#include "lock_util.h"
-#include "log.h"
 #include "recorder.h"
+#include "util/buffer_util.h"
+#include "util/log.h"

 #define BUFSIZE 0x10000

@@ -44,7 +43,8 @@ stream_recv_packet(struct stream *stream, AVPacket *packet) {

    uint64_t pts = buffer_read64be(header);
    uint32_t len = buffer_read32be(&header[8]);
-    SDL_assert(len);
+    assert(pts == NO_PTS || (pts & 0x8000000000000000) == 0);
+    assert(len);

    if (av_new_packet(packet, len)) {
        LOGE("Could not allocate packet");
@@ -52,12 +52,12 @@ stream_recv_packet(struct stream *stream, AVPacket *packet) {
    }

    r = net_recv_all(stream->socket, packet->data, len);
-    if (r < len) {
+    if (r < 0 || ((uint32_t) r) < len) {
        av_packet_unref(packet);
        return false;
    }

-    packet->pts = pts != NO_PTS ? pts : AV_NOPTS_VALUE;
+    packet->pts = pts != NO_PTS ? (int64_t) pts : AV_NOPTS_VALUE;

    return true;
 }
@@ -107,8 +107,9 @@ stream_parse(struct stream *stream, AVPacket *packet) {
                             AV_NOPTS_VALUE, AV_NOPTS_VALUE, -1);

    // PARSER_FLAG_COMPLETE_FRAMES is set
-    SDL_assert(r == in_len);
-    SDL_assert(out_len == in_len);
+    assert(r == in_len);
+    (void) r;
+    assert(out_len == in_len);

    if (stream->parser->key_frame == 1) {
        packet->flags |= AV_PKT_FLAG_KEY;
--- a/app/src/stream.h
+++ b/app/src/stream.h
@@ -8,7 +8,7 @@
 #include <SDL2/SDL_thread.h>

 #include "config.h"
-#include "net.h"
+#include "util/net.h"

 struct video_buffer;

--- a/app/src/sys/unix/command.c
+++ b/app/src/sys/unix/command.c
@@ -17,10 +17,11 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
-#include "log.h"
+
+#include "util/log.h"

 enum process_result
-cmd_execute(const char *path, const char *const argv[], pid_t *pid) {
+cmd_execute(const char *const argv[], pid_t *pid) {
    int fd[2];

    if (pipe(fd) == -1) {
@@ -51,7 +52,7 @@ cmd_execute(const char *path, const char *const argv[], pid_t *pid) {
        // child close read side
        close(fd[0]);
        if (fcntl(fd[1], F_SETFD, FD_CLOEXEC) == 0) {
-            execvp(path, (char *const *)argv);
+            execvp(argv[0], (char *const *)argv);
            if (errno == ENOENT) {
                ret = PROCESS_ERROR_MISSING_BINARY;
            } else {
--- a/app/src/sys/unix/net.c
+++ b/app/src/sys/unix/net.c
@@ -1,4 +1,4 @@
-#include "net.h"
+#include "util/net.h"

 #include <unistd.h>

--- a/app/src/sys/win/command.c
+++ b/app/src/sys/win/command.c
@@ -1,8 +1,8 @@
 #include "command.h"

 #include "config.h"
-#include "log.h"
-#include "str_util.h"
+#include "util/log.h"
+#include "util/str_util.h"

 static int
 build_cmd(char *cmd, size_t len, const char *const argv[]) {
@@ -19,7 +19,7 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
 }

 enum process_result
-cmd_execute(const char *path, const char *const argv[], HANDLE *handle) {
+cmd_execute(const char *const argv[], HANDLE *handle) {
    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
    memset(&si, 0, sizeof(si));
--- a/app/src/sys/win/net.c
+++ b/app/src/sys/win/net.c
@@ -1,7 +1,7 @@
-#include "net.h"
+#include "util/net.h"

 #include "config.h"
-#include "log.h"
+#include "util/log.h"

 bool
 net_init(void) {
--- a/app/src/tiny_xpm.c
+++ b/app/src/tiny_xpm.c
@@ -1,12 +1,13 @@
 #include "tiny_xpm.h"

+#include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>

 #include "config.h"
-#include "log.h"
+#include "util/log.h"

 struct index {
    char c;
@@ -36,7 +37,7 @@ find_color(struct index *index, int len, char c, uint32_t *color) {
 // (non-const) "char *"
 SDL_Surface *
 read_xpm(char *xpm[]) {
-#if SDL_ASSERT_LEVEL >= 2
+#ifndef NDEBUG
    // patch the XPM to change the icon color in debug mode
    xpm[2] = ".	c #CC00CC";
 #endif
@@ -51,24 +52,26 @@ read_xpm(char *xpm[]) {
    int chars = strtol(endptr + 1, &endptr, 10);

    // sanity checks
-    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
+    assert(0 <= width && width < 256);
+    assert(0 <= height && height < 256);
+    assert(0 <= colors && colors < 256);
+    assert(chars == 1); // this implementation does not support more
+
+    (void) chars;

    // init index
    struct index index[colors];
    for (int i = 0; i < colors; ++i) {
        const char *line = xpm[1+i];
        index[i].c = line[0];
-        SDL_assert(line[1] == '\t');
-        SDL_assert(line[2] == 'c');
-        SDL_assert(line[3] == ' ');
+        assert(line[1] == '\t');
+        assert(line[2] == 'c');
+        assert(line[3] == ' ');
        if (line[4] == '#') {
            index[i].color = 0xff000000 | strtol(&line[5], &endptr, 0x10);
-            SDL_assert(*endptr == '\0');
+            assert(*endptr == '\0');
        } else {
-            SDL_assert(!strcmp("None", &line[4]));
+            assert(!strcmp("None", &line[4]));
            index[i].color = 0;
        }
    }
@@ -85,7 +88,8 @@ read_xpm(char *xpm[]) {
            char c = line[x];
            uint32_t color;
            bool color_found = find_color(index, colors, c, &color);
-            SDL_assert(color_found);
+            assert(color_found);
+            (void) color_found;
            pixels[y * width + x] = color;
        }
    }
--- a/app/src/util/buffer_util.h
+++ b/app/src/util/buffer_util.h
@@ -36,8 +36,8 @@ buffer_read32be(const uint8_t *buf) {
    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 }

-static inline
-uint64_t buffer_read64be(const uint8_t *buf) {
+static inline uint64_t
+buffer_read64be(const uint8_t *buf) {
    uint32_t msb = buffer_read32be(buf);
    uint32_t lsb = buffer_read32be(&buf[4]);
    return ((uint64_t) msb << 32) | lsb;
--- a/app/src/util/cbuf.h
+++ b/app/src/util/cbuf.h
--- a/app/src/util/lock.h
+++ b/app/src/util/lock.h
@@ -0,0 +1,74 @@
+#ifndef LOCK_H
+#define LOCK_H
+
+#include <stdint.h>
+#include <SDL2/SDL_mutex.h>
+
+#include "config.h"
+#include "log.h"
+
+static inline void
+mutex_lock(SDL_mutex *mutex) {
+    int r = SDL_LockMutex(mutex);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not lock mutex: %s", SDL_GetError());
+        abort();
+    }
+#else
+    (void) r;
+#endif
+}
+
+static inline void
+mutex_unlock(SDL_mutex *mutex) {
+    int r = SDL_UnlockMutex(mutex);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not unlock mutex: %s", SDL_GetError());
+        abort();
+    }
+#else
+    (void) r;
+#endif
+}
+
+static inline void
+cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
+    int r = SDL_CondWait(cond, mutex);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not wait on condition: %s", SDL_GetError());
+        abort();
+    }
+#else
+    (void) r;
+#endif
+}
+
+static inline int
+cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
+    int r = SDL_CondWaitTimeout(cond, mutex, ms);
+#ifndef NDEBUG
+    if (r < 0) {
+        LOGC("Could not wait on condition with timeout: %s", SDL_GetError());
+        abort();
+    }
+#endif
+    return r;
+}
+
+static inline void
+cond_signal(SDL_cond *cond) {
+    int r = SDL_CondSignal(cond);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not signal a condition: %s", SDL_GetError());
+        abort();
+    }
+#else
+    (void) r;
+#endif
+}
+
+#endif
--- a/app/src/util/log.h
+++ b/app/src/util/log.h
--- a/app/src/util/net.c
+++ b/app/src/util/net.c
--- a/app/src/util/net.h
+++ b/app/src/util/net.h
--- a/app/src/util/queue.h
+++ b/app/src/util/queue.h
@@ -2,9 +2,9 @@
 #ifndef QUEUE_H
 #define QUEUE_H

+#include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
-#include <SDL2/SDL_assert.h>

 #include "config.h"

@@ -67,7 +67,7 @@
 // type so that we can "return" it)
 #define queue_take(PQ, NEXTFIELD, PITEM) \
    (void) ({ \
-        SDL_assert(!queue_is_empty(PQ)); \
+        assert(!queue_is_empty(PQ)); \
        *(PITEM) = (PQ)->first; \
        (PQ)->first = (PQ)->first->NEXTFIELD; \
    })
--- a/app/src/util/str_util.c
+++ b/app/src/util/str_util.c
--- a/app/src/util/str_util.h
+++ b/app/src/util/str_util.h
--- a/app/src/video_buffer.c
+++ b/app/src/video_buffer.c
@@ -1,13 +1,13 @@
 #include "video_buffer.h"

-#include <SDL2/SDL_assert.h>
+#include <assert.h>
 #include <SDL2/SDL_mutex.h>
 #include <libavutil/avutil.h>
 #include <libavformat/avformat.h>

 #include "config.h"
-#include "lock_util.h"
-#include "log.h"
+#include "util/lock.h"
+#include "util/log.h"

 bool
 video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
@@ -91,7 +91,7 @@ video_buffer_offer_decoded_frame(struct video_buffer *vb,

 const AVFrame *
 video_buffer_consume_rendered_frame(struct video_buffer *vb) {
-    SDL_assert(!vb->rendering_frame_consumed);
+    assert(!vb->rendering_frame_consumed);
    vb->rendering_frame_consumed = true;
    fps_counter_add_rendered_frame(vb->fps_counter);
    if (vb->render_expired_frames) {
--- a/app/tests/test_buffer_util.c
+++ b/app/tests/test_buffer_util.c
@@ -0,0 +1,76 @@
+#include <assert.h>
+
+#include "util/buffer_util.h"
+
+static void test_buffer_write16be(void) {
+    uint16_t val = 0xABCD;
+    uint8_t buf[2];
+
+    buffer_write16be(buf, val);
+
+    assert(buf[0] == 0xAB);
+    assert(buf[1] == 0xCD);
+}
+
+static void test_buffer_write32be(void) {
+    uint32_t val = 0xABCD1234;
+    uint8_t buf[4];
+
+    buffer_write32be(buf, val);
+
+    assert(buf[0] == 0xAB);
+    assert(buf[1] == 0xCD);
+    assert(buf[2] == 0x12);
+    assert(buf[3] == 0x34);
+}
+
+static void test_buffer_write64be(void) {
+    uint64_t val = 0xABCD1234567890EF;
+    uint8_t buf[8];
+
+    buffer_write64be(buf, val);
+
+    assert(buf[0] == 0xAB);
+    assert(buf[1] == 0xCD);
+    assert(buf[2] == 0x12);
+    assert(buf[3] == 0x34);
+    assert(buf[4] == 0x56);
+    assert(buf[5] == 0x78);
+    assert(buf[6] == 0x90);
+    assert(buf[7] == 0xEF);
+}
+
+static void test_buffer_read16be(void) {
+    uint8_t buf[2] = {0xAB, 0xCD};
+
+    uint16_t val = buffer_read16be(buf);
+
+    assert(val == 0xABCD);
+}
+
+static void test_buffer_read32be(void) {
+    uint8_t buf[4] = {0xAB, 0xCD, 0x12, 0x34};
+
+    uint32_t val = buffer_read32be(buf);
+
+    assert(val == 0xABCD1234);
+}
+
+static void test_buffer_read64be(void) {
+    uint8_t buf[8] = {0xAB, 0xCD, 0x12, 0x34,
+                      0x56, 0x78, 0x90, 0xEF};
+
+    uint64_t val = buffer_read64be(buf);
+
+    assert(val == 0xABCD1234567890EF);
+}
+
+int main(void) {
+    test_buffer_write16be();
+    test_buffer_write32be();
+    test_buffer_write64be();
+    test_buffer_read16be();
+    test_buffer_read32be();
+    test_buffer_read64be();
+    return 0;
+}
--- a/app/tests/test_cbuf.c
+++ b/app/tests/test_cbuf.c
@@ -1,7 +1,7 @@
 #include <assert.h>
 #include <string.h>

-#include "cbuf.h"
+#include "util/cbuf.h"

 struct int_queue CBUF(int, 32);

--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@@ -236,6 +236,21 @@ static void test_serialize_set_screen_power_mode(void) {
    assert(!memcmp(buf, expected, sizeof(expected)));
 }

+static void test_serialize_rotate_device(void) {
+    struct control_msg msg = {
+        .type = CONTROL_MSG_TYPE_ROTATE_DEVICE,
+    };
+
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
+    int size = control_msg_serialize(&msg, buf);
+    assert(size == 1);
+
+    const unsigned char expected[] = {
+        CONTROL_MSG_TYPE_ROTATE_DEVICE,
+    };
+    assert(!memcmp(buf, expected, sizeof(expected)));
+}
+
 int main(void) {
    test_serialize_inject_keycode();
    test_serialize_inject_text();
@@ -248,5 +263,6 @@ int main(void) {
    test_serialize_get_clipboard();
    test_serialize_set_clipboard();
    test_serialize_set_screen_power_mode();
+    test_serialize_rotate_device();
    return 0;
 }
--- a/app/tests/test_queue.c
+++ b/app/tests/test_queue.c
@@ -1,6 +1,6 @@
 #include <assert.h>

-#include <queue.h>
+#include "util/queue.h"

 struct foo {
    int value;
--- a/app/tests/test_strutil.c
+++ b/app/tests/test_strutil.c
@@ -1,7 +1,8 @@
 #include <assert.h>
 #include <string.h>
+#include <SDL2/SDL.h>

-#include "str_util.h"
+#include "util/str_util.h"

 static void test_xstrncpy_simple(void) {
    char s[] = "xxxxxxxxxx";
@@ -126,6 +127,16 @@ static void test_xstrjoin_truncated_after_sep(void) {
    assert(!strcmp("abc de ", s));
 }

+static void test_strquote(void) {
+    const char *s = "abcde";
+    char *out = strquote(s);
+
+    // add '"' at the beginning and the end
+    assert(!strcmp("\"abcde\"", out));
+
+    SDL_free(out);
+}
+
 static void test_utf8_truncate(void) {
    const char *s = "aÉbÔc";
    assert(strlen(s) == 7); // É and Ô are 2 bytes-wide
@@ -166,6 +177,7 @@ int main(void) {
    test_xstrjoin_truncated_in_token();
    test_xstrjoin_truncated_before_sep();
    test_xstrjoin_truncated_after_sep();
+    test_strquote();
    test_utf8_truncate();
    return 0;
 }
--- a/config/checkstyle/checkstyle.xml
+++ b/config/checkstyle/checkstyle.xml
@@ -54,7 +54,7 @@ page at http://checkstyle.sourceforge.net/config.html -->
    <module name="SuppressWarningsHolder"/>

    <!-- Checks for imports                              -->
-    <!-- See http://checkstyle.sf.net/config_import.html -->
+    <!-- See http://checkstyle.sf.net/config_imports.html -->
    <module name="AvoidStarImport">
      <property name="allowStaticMemberImports" value="true" />
    </module>
@@ -99,7 +99,7 @@ page at http://checkstyle.sourceforge.net/config.html -->
    <module name="WhitespaceAround" />

    <!-- Modifier Checks                                    -->
-    <!-- See http://checkstyle.sf.net/config_modifiers.html -->
+    <!-- See http://checkstyle.sf.net/config_modifier.html -->
    <module name="ModifierOrder" />
    <module name="RedundantModifier" />

--- a/cross_win32.txt
+++ b/cross_win32.txt
@@ -15,6 +15,6 @@ cpu = 'i686'
 endian = 'little'

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

 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.1.4-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.1.4-win64-dev'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.2.1-win64-shared'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.2.1-win64-dev'
 prebuilt_sdl2 = 'SDL2-2.0.10/x86_64-w64-mingw32'
--- a/meson.build
+++ b/meson.build
@@ -1,7 +1,10 @@
 project('scrcpy', 'c',
-        version: '1.10',
+        version: '1.11',
        meson_version: '>= 0.37',
-        default_options: 'c_std=c11')
+        default_options: [
+            'c_std=c11',
+            'warning_level=2',
+        ])

 if get_option('compile_app')
    subdir('app')
--- a/prebuilt-deps/Makefile
+++ b/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.1.4-win32-shared.zip \
-		596608277f6b937c3dea7c46e854665d75b3de56790bae07f655ca331440f003 \
-		ffmpeg-4.1.4-win32-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.2.1-win32-shared.zip \
+		9208255f409410d95147151d7e829b5699bf8d91bfe1e81c3f470f47c2fa66d2 \
+		ffmpeg-4.2.1-win32-shared

 prepare-ffmpeg-dev-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.1.4-win32-dev.zip \
-		a80c86e263cfad26e202edfa5e6e939a2c88843ae26f031d3e0d981a39fd03fb \
-		ffmpeg-4.1.4-win32-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.2.1-win32-dev.zip \
+		c3469e6c5f031cbcc8cba88dee92d6548c5c6b6ff14f4097f18f72a92d0d70c4 \
+		ffmpeg-4.2.1-win32-dev

 prepare-ffmpeg-shared-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.1.4-win64-shared.zip \
-		a90889871de2cab8a79b392591313a188189a353f69dde1db98aebe20b280989 \
-		ffmpeg-4.1.4-win64-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.2.1-win64-shared.zip \
+		55063d3cf750a75485c7bf196031773d81a1b25d0980c7db48ecfc7701a42331 \
+		ffmpeg-4.2.1-win64-shared

 prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.1.4-win64-dev.zip \
-		6c9d53f9e94ce1821e975ec668e5b9d6e9deb4a45d0d7e30264685d3dfbbb068 \
-		ffmpeg-4.1.4-win64-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.2.1-win64-dev.zip \
+		5af393be5f25c0a71aa29efce768e477c35347f7f8e0d9696767d5b9d405b74e \
+		ffmpeg-4.2.1-win64-dev

 prepare-sdl2:
 	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.10-mingw.tar.gz \
@@ -35,6 +35,6 @@ prepare-sdl2:
 		SDL2-2.0.10

 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r29.0.2-windows.zip \
-		d78f02e5e2c9c4c1d046dcd4e6fbdf586e5f57ef66eb0da5c2b49d745d85d5ee \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r29.0.5-windows.zip \
+		2df06160056ec9a84c7334af2a1e42740befbb1a2e34370e7af544a2cc78152c \
 		platform-tools
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 29
-        versionCode 11
-        versionName "1.10"
+        versionCode 12
+        versionName "1.11"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
--- a/server/build_without_gradle.sh
+++ b/server/build_without_gradle.sh
@@ -11,6 +11,9 @@

 set -e

+SCRCPY_DEBUG=false
+SCRCPY_VERSION_NAME=1.11
+
 PLATFORM=${ANDROID_PLATFORM:-29}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-29.0.2}

@@ -30,13 +33,14 @@ mkdir -p "$CLASSES_DIR/com/genymobile/scrcpy"
 package com.genymobile.scrcpy;

 public final class BuildConfig {
-  public static final boolean DEBUG = false;
+  public static final boolean DEBUG = $SCRCPY_DEBUG;
+  public static final String VERSION_NAME = "$SCRCPY_VERSION_NAME";
 }
 EOF

 echo "Generating java from aidl..."
 cd "$SERVER_DIR/src/main/aidl"
-"$ANDROID_HOME/build-tools/$BUILD_TOOLS/aidl" -o "$CLASSES_DIR" \
+"$ANDROID_HOME/build-tools/$BUILD_TOOLS/aidl" -o"$CLASSES_DIR" \
    android/view/IRotationWatcher.aidl

 echo "Compiling java sources..."
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
@@ -15,6 +15,7 @@ public final class ControlMessage {
    public static final int TYPE_GET_CLIPBOARD = 7;
    public static final int TYPE_SET_CLIPBOARD = 8;
    public static final int TYPE_SET_SCREEN_POWER_MODE = 9;
+    public static final int TYPE_ROTATE_DEVICE = 10;

    private int type;
    private String text;
@@ -47,8 +48,7 @@ public final class ControlMessage {
        return msg;
    }

-    public static ControlMessage createInjectTouchEvent(int action, long pointerId, Position position, float pressure,
-            int buttons) {
+    public static ControlMessage createInjectTouchEvent(int action, long pointerId, Position position, float pressure, int buttons) {
        ControlMessage msg = new ControlMessage();
        msg.type = TYPE_INJECT_TOUCH_EVENT;
        msg.action = action;
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
@@ -76,6 +76,7 @@ public class ControlMessageReader {
            case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
            case ControlMessage.TYPE_COLLAPSE_NOTIFICATION_PANEL:
            case ControlMessage.TYPE_GET_CLIPBOARD:
+            case ControlMessage.TYPE_ROTATE_DEVICE:
                msg = ControlMessage.createEmpty(type);
                break;
            default:
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@@ -13,6 +13,8 @@ import java.io.IOException;

 public class Controller {

+    private static final int DEVICE_ID_VIRTUAL = -1;
+
    private final Device device;
    private final DesktopConnection connection;
    private final DeviceMessageSender sender;
@@ -21,10 +23,8 @@ public class Controller {

    private long lastTouchDown;
    private final PointersState pointersState = new PointersState();
-    private final MotionEvent.PointerProperties[] pointerProperties =
-            new MotionEvent.PointerProperties[PointersState.MAX_POINTERS];
-    private final MotionEvent.PointerCoords[] pointerCoords =
-            new MotionEvent.PointerCoords[PointersState.MAX_POINTERS];
+    private final MotionEvent.PointerProperties[] pointerProperties = new MotionEvent.PointerProperties[PointersState.MAX_POINTERS];
+    private final MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[PointersState.MAX_POINTERS];

    public Controller(Device device, DesktopConnection connection) {
        this.device = device;
@@ -106,6 +106,9 @@ public class Controller {
            case ControlMessage.TYPE_SET_SCREEN_POWER_MODE:
                device.setScreenPowerMode(msg.getAction());
                break;
+            case ControlMessage.TYPE_ROTATE_DEVICE:
+                device.rotateDevice();
+                break;
            default:
                // do nothing
        }
@@ -176,8 +179,9 @@ public class Controller {
            }
        }

-        MotionEvent event = MotionEvent.obtain(lastTouchDown, now, action, pointerCount, pointerProperties,
-                pointerCoords, 0, buttons, 1f, 1f, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
+        MotionEvent event = MotionEvent
+                .obtain(lastTouchDown, now, action, pointerCount, pointerProperties, pointerCoords, 0, buttons, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
+                        InputDevice.SOURCE_TOUCHSCREEN, 0);
        return injectEvent(event);
    }

@@ -198,15 +202,16 @@ public class Controller {
        coords.setAxisValue(MotionEvent.AXIS_HSCROLL, hScroll);
        coords.setAxisValue(MotionEvent.AXIS_VSCROLL, vScroll);

-        MotionEvent event = MotionEvent.obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties,
-                pointerCoords, 0, 0, 1f, 1f, 0, 0, InputDevice.SOURCE_MOUSE, 0);
+        MotionEvent event = MotionEvent
+                .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
+                        InputDevice.SOURCE_MOUSE, 0);
        return injectEvent(event);
    }

    private boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState) {
        long now = SystemClock.uptimeMillis();
-        KeyEvent event = new KeyEvent(now, now, action, keyCode, repeat, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD,
-                0, 0, InputDevice.SOURCE_KEYBOARD);
+        KeyEvent event = new KeyEvent(now, now, action, keyCode, repeat, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0,
+                InputDevice.SOURCE_KEYBOARD);
        return injectEvent(event);
    }

--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@@ -2,6 +2,7 @@ package com.genymobile.scrcpy;

 import com.genymobile.scrcpy.wrappers.ServiceManager;
 import com.genymobile.scrcpy.wrappers.SurfaceControl;
+import com.genymobile.scrcpy.wrappers.WindowManager;

 import android.graphics.Rect;
 import android.os.Build;
@@ -170,6 +171,27 @@ public final class Device {
        Ln.i("Device screen turned " + (mode == Device.POWER_MODE_OFF ? "off" : "on"));
    }

+    /**
+     * Disable auto-rotation (if enabled), set the screen rotation and re-enable auto-rotation (if it was enabled).
+     */
+    public void rotateDevice() {
+        WindowManager wm = serviceManager.getWindowManager();
+
+        boolean accelerometerRotation = !wm.isRotationFrozen();
+
+        int currentRotation = wm.getRotation();
+        int newRotation = (currentRotation & 1) ^ 1; // 0->1, 1->0, 2->1, 3->0
+        String newRotationString = newRotation == 0 ? "portrait" : "landscape";
+
+        Ln.i("Device rotation requested: " + newRotationString);
+        wm.freezeRotation(newRotation);
+
+        // restore auto-rotate if necessary
+        if (accelerometerRotation) {
+            wm.thawRotation();
+        }
+    }
+
    static Rect flipRect(Rect crop) {
        return new Rect(crop.top, crop.left, crop.bottom, crop.right);
    }
--- a/server/src/main/java/com/genymobile/scrcpy/Ln.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Ln.java
@@ -12,10 +12,7 @@ public final class Ln {
    private static final String PREFIX = "[server] ";

    enum Level {
-        DEBUG,
-        INFO,
-        WARN,
-        ERROR;
+        DEBUG, INFO, WARN, ERROR
    }

    private static final Level THRESHOLD = BuildConfig.DEBUG ? Level.DEBUG : Level.INFO;
--- a/server/src/main/java/com/genymobile/scrcpy/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@@ -5,6 +5,7 @@ import android.graphics.Rect;
 public class Options {
    private int maxSize;
    private int bitRate;
+    private int maxFps;
    private boolean tunnelForward;
    private Rect crop;
    private boolean sendFrameMeta; // send PTS so that the client may record properly
@@ -26,6 +27,14 @@ public class Options {
        this.bitRate = bitRate;
    }

+    public int getMaxFps() {
+        return maxFps;
+    }
+
+    public void setMaxFps(int maxFps) {
+        this.maxFps = maxFps;
+    }
+
    public boolean isTunnelForward() {
        return tunnelForward;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/Point.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Point.java
@@ -28,8 +28,7 @@ public class Point {
            return false;
        }
        Point point = (Point) o;
-        return x == point.x
-                && y == point.y;
+        return x == point.x && y == point.y;
    }

    @Override
@@ -39,9 +38,6 @@ public class Point {

    @Override
    public String toString() {
-        return "Point{"
-                + "x=" + x
-                + ", y=" + y
-                + '}';
+        return "Point{" + "x=" + x + ", y=" + y + '}';
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Position.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Position.java
@@ -32,8 +32,7 @@ public class Position {
            return false;
        }
        Position position = (Position) o;
-        return Objects.equals(point, position.point)
-                && Objects.equals(screenSize, position.screenSize);
+        return Objects.equals(point, position.point) && Objects.equals(screenSize, position.screenSize);
    }

    @Override
@@ -43,10 +42,7 @@ public class Position {

    @Override
    public String toString() {
-        return "Position{"
-                + "point=" + point
-                + ", screenSize=" + screenSize
-                + '}';
+        return "Position{" + "point=" + point + ", screenSize=" + screenSize + '}';
    }

 }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@@ -6,6 +6,7 @@ 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;

@@ -16,32 +17,29 @@ import java.util.concurrent.atomic.AtomicBoolean;

 public class ScreenEncoder implements Device.RotationListener {

-    private static final int DEFAULT_FRAME_RATE = 60; // fps
    private static final int DEFAULT_I_FRAME_INTERVAL = 10; // seconds
+    private static final int REPEAT_FRAME_DELAY_US = 100_000; // repeat after 100ms

-    private static final int REPEAT_FRAME_DELAY = 6; // repeat after 6 frames
-
-    private static final int MICROSECONDS_IN_ONE_SECOND = 1_000_000;
    private static final int NO_PTS = -1;

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

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

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

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

    @Override
@@ -54,7 +52,10 @@ public class ScreenEncoder implements Device.RotationListener {
    }

    public void streamScreen(Device device, FileDescriptor fd) throws IOException {
-        MediaFormat format = createFormat(bitRate, frameRate, iFrameInterval);
+        Workarounds.prepareMainLooper();
+        Workarounds.fillAppInfo();
+
+        MediaFormat format = createFormat(bitRate, maxFps, iFrameInterval);
        device.setRotationListener(this);
        boolean alive;
        try {
@@ -137,15 +138,24 @@ public class ScreenEncoder implements Device.RotationListener {
        return MediaCodec.createEncoderByType("video/avc");
    }

-    private static MediaFormat createFormat(int bitRate, int frameRate, int iFrameInterval) throws IOException {
+    @SuppressWarnings("checkstyle:MagicNumber")
+    private static MediaFormat createFormat(int bitRate, int maxFps, int iFrameInterval) {
        MediaFormat format = new MediaFormat();
        format.setString(MediaFormat.KEY_MIME, "video/avc");
        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
-        format.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate);
+        // must be present to configure the encoder, but does not impact the actual frame rate, which is variable
+        format.setInteger(MediaFormat.KEY_FRAME_RATE, 60);
        format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval);
        // display the very first frame, and recover from bad quality when no new frames
-        format.setLong(MediaFormat.KEY_REPEAT_PREVIOUS_FRAME_AFTER, MICROSECONDS_IN_ONE_SECOND * REPEAT_FRAME_DELAY / frameRate); // µs
+        format.setLong(MediaFormat.KEY_REPEAT_PREVIOUS_FRAME_AFTER, REPEAT_FRAME_DELAY_US); // µs
+        if (maxFps > 0) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                format.setFloat(MediaFormat.KEY_MAX_FPS_TO_ENCODER, maxFps);
+            } else {
+                Ln.w("Max FPS is only supported since Android 10, the option has been ignored");
+            }
+        }
        return format;
    }

--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@@ -1,13 +1,15 @@
 package com.genymobile.scrcpy;

 import android.graphics.Rect;
+import android.media.MediaCodec;
+import android.os.Build;

 import java.io.File;
 import java.io.IOException;

 public final class Server {

-    private static final String SERVER_PATH = "/data/local/tmp/scrcpy-server";
+    private static final String SERVER_PATH = "/data/local/tmp/scrcpy-server.jar";

    private Server() {
        // not instantiable
@@ -17,7 +19,7 @@ public final class Server {
        final Device device = new Device(options);
        boolean tunnelForward = options.isTunnelForward();
        try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward)) {
-            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate());
+            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps());

            if (options.getControl()) {
                Controller controller = new Controller(device, connection);
@@ -67,29 +69,42 @@ public final class Server {

    @SuppressWarnings("checkstyle:MagicNumber")
    private static Options createOptions(String... args) {
-        if (args.length != 6) {
-            throw new IllegalArgumentException("Expecting 6 parameters");
+        if (args.length < 1) {
+            throw new IllegalArgumentException("Missing client version");
+        }
+
+        String clientVersion = args[0];
+        if (!clientVersion.equals(BuildConfig.VERSION_NAME)) {
+            throw new IllegalArgumentException(
+                    "The server version (" + clientVersion + ") does not match the client " + "(" + BuildConfig.VERSION_NAME + ")");
+        }
+
+        if (args.length != 8) {
+            throw new IllegalArgumentException("Expecting 8 parameters");
        }

        Options options = new Options();

-        int maxSize = Integer.parseInt(args[0]) & ~7; // multiple of 8
+        int maxSize = Integer.parseInt(args[1]) & ~7; // multiple of 8
        options.setMaxSize(maxSize);

-        int bitRate = Integer.parseInt(args[1]);
+        int bitRate = Integer.parseInt(args[2]);
        options.setBitRate(bitRate);

+        int maxFps = Integer.parseInt(args[3]);
+        options.setMaxFps(maxFps);
+
        // use "adb forward" instead of "adb tunnel"? (so the server must listen)
-        boolean tunnelForward = Boolean.parseBoolean(args[2]);
+        boolean tunnelForward = Boolean.parseBoolean(args[4]);
        options.setTunnelForward(tunnelForward);

-        Rect crop = parseCrop(args[3]);
+        Rect crop = parseCrop(args[5]);
        options.setCrop(crop);

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

-        boolean control = Boolean.parseBoolean(args[5]);
+        boolean control = Boolean.parseBoolean(args[7]);
        options.setControl(control);

        return options;
@@ -120,11 +135,25 @@ public final class Server {
        }
    }

+    private static void suggestFix(Throwable e) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (e instanceof MediaCodec.CodecException) {
+                MediaCodec.CodecException mce = (MediaCodec.CodecException) e;
+                if (mce.getErrorCode() == 0xfffffc0e) {
+                    Ln.e("The hardware encoder is not able to encode at the given definition.");
+                    Ln.e("Try with a lower definition:");
+                    Ln.e("    scrcpy -m 1024");
+                }
+            }
+        }
+    }
+
    public static void main(String... args) throws Exception {
        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                Ln.e("Exception on thread " + t, e);
+                suggestFix(e);
            }
        });

--- a/server/src/main/java/com/genymobile/scrcpy/Size.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Size.java
@@ -38,8 +38,7 @@ public final class Size {
            return false;
        }
        Size size = (Size) o;
-        return width == size.width
-                && height == size.height;
+        return width == size.width && height == size.height;
    }

    @Override
@@ -49,9 +48,6 @@ public final class Size {

    @Override
    public String toString() {
-        return "Size{"
-                + "width=" + width
-                + ", height=" + height
-                + '}';
+        return "Size{" + "width=" + width + ", height=" + height + '}';
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
@@ -0,0 +1,79 @@
+package com.genymobile.scrcpy;
+
+import android.annotation.SuppressLint;
+import android.app.Application;
+import android.app.Instrumentation;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.os.Looper;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+public final class Workarounds {
+    private Workarounds() {
+        // not instantiable
+    }
+
+    public static void prepareMainLooper() {
+        // Some devices internally create a Handler when creating an input Surface, causing an exception:
+        //   "Can't create handler inside thread that has not called Looper.prepare()"
+        // <https://github.com/Genymobile/scrcpy/issues/240>
+        //
+        // Use Looper.prepareMainLooper() instead of Looper.prepare() to avoid a NullPointerException:
+        //   "Attempt to read from field 'android.os.MessageQueue android.os.Looper.mQueue'
+        //    on a null object reference"
+        // <https://github.com/Genymobile/scrcpy/issues/921>
+        Looper.prepareMainLooper();
+    }
+
+    @SuppressLint("PrivateApi")
+    public static void fillAppInfo() {
+        try {
+            // ActivityThread activityThread = new ActivityThread();
+            Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
+            Constructor<?> activityThreadConstructor = activityThreadClass.getDeclaredConstructor();
+            activityThreadConstructor.setAccessible(true);
+            Object activityThread = activityThreadConstructor.newInstance();
+
+            // ActivityThread.sCurrentActivityThread = activityThread;
+            Field sCurrentActivityThreadField = activityThreadClass.getDeclaredField("sCurrentActivityThread");
+            sCurrentActivityThreadField.setAccessible(true);
+            sCurrentActivityThreadField.set(null, activityThread);
+
+            // ActivityThread.AppBindData appBindData = new ActivityThread.AppBindData();
+            Class<?> appBindDataClass = Class.forName("android.app.ActivityThread$AppBindData");
+            Constructor<?> appBindDataConstructor = appBindDataClass.getDeclaredConstructor();
+            appBindDataConstructor.setAccessible(true);
+            Object appBindData = appBindDataConstructor.newInstance();
+
+            ApplicationInfo applicationInfo = new ApplicationInfo();
+            applicationInfo.packageName = "com.genymobile.scrcpy";
+
+            // appBindData.appInfo = applicationInfo;
+            Field appInfoField = appBindDataClass.getDeclaredField("appInfo");
+            appInfoField.setAccessible(true);
+            appInfoField.set(appBindData, applicationInfo);
+
+            // activityThread.mBoundApplication = appBindData;
+            Field mBoundApplicationField = activityThreadClass.getDeclaredField("mBoundApplication");
+            mBoundApplicationField.setAccessible(true);
+            mBoundApplicationField.set(activityThread, appBindData);
+
+            // Context ctx = activityThread.getSystemContext();
+            Method getSystemContextMethod = activityThreadClass.getDeclaredMethod("getSystemContext");
+            Context ctx = (Context) getSystemContextMethod.invoke(activityThread);
+
+            Application app = Instrumentation.newApplication(Application.class, ctx);
+
+            // activityThread.mInitialApplication = app;
+            Field mInitialApplicationField = activityThreadClass.getDeclaredField("mInitialApplication");
+            mInitialApplicationField.setAccessible(true);
+            mInitialApplicationField.set(activityThread, app);
+        } catch (Throwable throwable) {
+            // this is a workaround, so failing is not an error
+            Ln.w("Could not fill app info: " + throwable.getMessage());
+        }
+    }
+}
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
@@ -22,47 +22,37 @@ public class ClipboardManager {
        this.manager = manager;
    }

-    private Method getGetPrimaryClipMethod() {
+    private Method getGetPrimaryClipMethod() throws NoSuchMethodException {
        if (getPrimaryClipMethod == null) {
-            try {
-                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-                    getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class);
-                } else {
-                    getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, int.class);
-                }
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+                getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class);
+            } else {
+                getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class, int.class);
            }
        }
        return getPrimaryClipMethod;
    }

-    private Method getSetPrimaryClipMethod() {
+    private Method getSetPrimaryClipMethod() throws NoSuchMethodException {
        if (setPrimaryClipMethod == null) {
-            try {
-                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-                    setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class);
-                } else {
-                    setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class,
-                            String.class, int.class);
-                }
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+                setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class);
+            } else {
+                setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class, int.class);
            }
        }
        return setPrimaryClipMethod;
    }

-    private static ClipData getPrimaryClip(Method method, IInterface manager) throws InvocationTargetException,
-            IllegalAccessException {
+    private static ClipData getPrimaryClip(Method method, IInterface manager) throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
            return (ClipData) method.invoke(manager, PACKAGE_NAME);
        }
        return (ClipData) method.invoke(manager, PACKAGE_NAME, USER_ID);
    }

-    private static void setPrimaryClip(Method method, IInterface manager, ClipData clipData) throws InvocationTargetException,
-            IllegalAccessException {
+    private static void setPrimaryClip(Method method, IInterface manager, ClipData clipData)
+            throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
            method.invoke(manager, clipData, PACKAGE_NAME);
        } else {
@@ -71,32 +61,26 @@ public class ClipboardManager {
    }

    public CharSequence getText() {
-        Method method = getGetPrimaryClipMethod();
-        if (method == null) {
-            return null;
-        }
        try {
+            Method method = getGetPrimaryClipMethod();
            ClipData clipData = getPrimaryClip(method, manager);
            if (clipData == null || clipData.getItemCount() == 0) {
                return null;
            }
            return clipData.getItemAt(0).getText();
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
            return null;
        }
    }

    public void setText(CharSequence text) {
-        Method method = getSetPrimaryClipMethod();
-        if (method == null) {
-            return;
-        }
-        ClipData clipData = ClipData.newPlainText(null, text);
        try {
+            Method method = getSetPrimaryClipMethod();
+            ClipData clipData = ClipData.newPlainText(null, text);
            setPrimaryClip(method, manager, clipData);
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
        }
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
@@ -21,26 +21,19 @@ public final class InputManager {
        this.manager = manager;
    }

-    private Method getInjectInputEventMethod() {
+    private Method getInjectInputEventMethod() throws NoSuchMethodException {
        if (injectInputEventMethod == null) {
-            try {
-                injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
+            injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
        }
        return injectInputEventMethod;
    }

    public boolean injectInputEvent(InputEvent inputEvent, int mode) {
-        Method method = getInjectInputEventMethod();
-        if (method == null) {
-            return false;
-        }
        try {
-            return (Boolean) method.invoke(manager, inputEvent, mode);
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+            Method method = getInjectInputEventMethod();
+            return (boolean) method.invoke(manager, inputEvent, mode);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
            return false;
        }
    }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/PowerManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/PowerManager.java
@@ -17,28 +17,21 @@ public final class PowerManager {
        this.manager = manager;
    }

-    private Method getIsScreenOnMethod() {
+    private Method getIsScreenOnMethod() throws NoSuchMethodException {
        if (isScreenOnMethod == null) {
-            try {
-                @SuppressLint("ObsoleteSdkInt") // we may lower minSdkVersion in the future
-                        String methodName = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH ? "isInteractive" : "isScreenOn";
-                isScreenOnMethod = manager.getClass().getMethod(methodName);
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
+            @SuppressLint("ObsoleteSdkInt") // we may lower minSdkVersion in the future
+                    String methodName = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH ? "isInteractive" : "isScreenOn";
+            isScreenOnMethod = manager.getClass().getMethod(methodName);
        }
        return isScreenOnMethod;
    }

    public boolean isScreenOn() {
-        Method method = getIsScreenOnMethod();
-        if (method == null) {
-            return false;
-        }
        try {
-            return (Boolean) method.invoke(manager);
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+            Method method = getIsScreenOnMethod();
+            return (boolean) method.invoke(manager);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
            return false;
        }
    }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
@@ -17,49 +17,35 @@ public class StatusBarManager {
        this.manager = manager;
    }

-    private Method getExpandNotificationsPanelMethod() {
+    private Method getExpandNotificationsPanelMethod() throws NoSuchMethodException {
        if (expandNotificationsPanelMethod == null) {
-            try {
-                expandNotificationsPanelMethod = manager.getClass().getMethod("expandNotificationsPanel");
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
+            expandNotificationsPanelMethod = manager.getClass().getMethod("expandNotificationsPanel");
        }
        return expandNotificationsPanelMethod;
    }

-    private Method getCollapsePanelsMethod() {
+    private Method getCollapsePanelsMethod() throws NoSuchMethodException {
        if (collapsePanelsMethod == null) {
-            try {
-                collapsePanelsMethod = manager.getClass().getMethod("collapsePanels");
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
+            collapsePanelsMethod = manager.getClass().getMethod("collapsePanels");
        }
        return collapsePanelsMethod;
    }

    public void expandNotificationsPanel() {
-        Method method = getExpandNotificationsPanelMethod();
-        if (method == null) {
-            return;
-        }
        try {
+            Method method = getExpandNotificationsPanelMethod();
            method.invoke(manager);
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
        }
    }

    public void collapsePanels() {
-        Method method = getCollapsePanelsMethod();
-        if (method == null) {
-            return;
-        }
        try {
+            Method method = getCollapsePanelsMethod();
            method.invoke(manager);
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
        }
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java
@@ -84,29 +84,23 @@ public final class SurfaceControl {
        }
    }

-    private static Method getGetBuiltInDisplayMethod() {
+    private static Method getGetBuiltInDisplayMethod() throws NoSuchMethodException {
        if (getBuiltInDisplayMethod == null) {
-            try {
-                // the method signature has changed in Android Q
-                // <https://github.com/Genymobile/scrcpy/issues/586>
-                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-                    getBuiltInDisplayMethod = CLASS.getMethod("getBuiltInDisplay", int.class);
-                } else {
-                    getBuiltInDisplayMethod = CLASS.getMethod("getInternalDisplayToken");
-                }
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
+            // the method signature has changed in Android Q
+            // <https://github.com/Genymobile/scrcpy/issues/586>
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+                getBuiltInDisplayMethod = CLASS.getMethod("getBuiltInDisplay", int.class);
+            } else {
+                getBuiltInDisplayMethod = CLASS.getMethod("getInternalDisplayToken");
            }
        }
        return getBuiltInDisplayMethod;
    }

    public static IBinder getBuiltInDisplay() {
-        Method method = getGetBuiltInDisplayMethod();
-        if (method == null) {
-            return null;
-        }
+
        try {
+            Method method = getGetBuiltInDisplayMethod();
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                // call getBuiltInDisplay(0)
                return (IBinder) method.invoke(null, 0);
@@ -114,32 +108,25 @@ public final class SurfaceControl {

            // call getInternalDisplayToken()
            return (IBinder) method.invoke(null);
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
            return null;
        }
    }

-    private static Method getSetDisplayPowerModeMethod() {
+    private static Method getSetDisplayPowerModeMethod() throws NoSuchMethodException {
        if (setDisplayPowerModeMethod == null) {
-            try {
-                setDisplayPowerModeMethod = CLASS.getMethod("setDisplayPowerMode", IBinder.class, int.class);
-            } catch (NoSuchMethodException e) {
-                Ln.e("Could not find method", e);
-            }
+            setDisplayPowerModeMethod = CLASS.getMethod("setDisplayPowerMode", IBinder.class, int.class);
        }
        return setDisplayPowerModeMethod;
    }

    public static void setDisplayPowerMode(IBinder displayToken, int mode) {
-        Method method = getSetDisplayPowerModeMethod();
-        if (method == null) {
-            return;
-        }
        try {
+            Method method = getSetDisplayPowerModeMethod();
            method.invoke(null, displayToken, mode);
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            Ln.e("Could not invoke " + method.getName(), e);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
        }
    }

--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java
@@ -1,27 +1,95 @@
 package com.genymobile.scrcpy.wrappers;

+import com.genymobile.scrcpy.Ln;
+
 import android.os.IInterface;
 import android.view.IRotationWatcher;

+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
 public final class WindowManager {
    private final IInterface manager;
+    private Method getRotationMethod;
+    private Method freezeRotationMethod;
+    private Method isRotationFrozenMethod;
+    private Method thawRotationMethod;

    public WindowManager(IInterface manager) {
        this.manager = manager;
    }

-    public int getRotation() {
-        try {
+    private Method getGetRotationMethod() throws NoSuchMethodException {
+        if (getRotationMethod == null) {
            Class<?> cls = manager.getClass();
            try {
-                return (Integer) cls.getMethod("getRotation").invoke(manager);
-            } catch (NoSuchMethodException e) {
                // method changed since this commit:
                // https://android.googlesource.com/platform/frameworks/base/+/8ee7285128c3843401d4c4d0412cd66e86ba49e3%5E%21/#F2
-                return (Integer) cls.getMethod("getDefaultDisplayRotation").invoke(manager);
+                getRotationMethod = cls.getMethod("getDefaultDisplayRotation");
+            } catch (NoSuchMethodException e) {
+                // old version
+                getRotationMethod = cls.getMethod("getRotation");
            }
-        } catch (Exception e) {
-            throw new AssertionError(e);
+        }
+        return getRotationMethod;
+    }
+
+    private Method getFreezeRotationMethod() throws NoSuchMethodException {
+        if (freezeRotationMethod == null) {
+            freezeRotationMethod = manager.getClass().getMethod("freezeRotation", int.class);
+        }
+        return freezeRotationMethod;
+    }
+
+    private Method getIsRotationFrozenMethod() throws NoSuchMethodException {
+        if (isRotationFrozenMethod == null) {
+            isRotationFrozenMethod = manager.getClass().getMethod("isRotationFrozen");
+        }
+        return isRotationFrozenMethod;
+    }
+
+    private Method getThawRotationMethod() throws NoSuchMethodException {
+        if (thawRotationMethod == null) {
+            thawRotationMethod = manager.getClass().getMethod("thawRotation");
+        }
+        return thawRotationMethod;
+    }
+
+    public int getRotation() {
+        try {
+            Method method = getGetRotationMethod();
+            return (int) method.invoke(manager);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
+            return 0;
+        }
+    }
+
+    public void freezeRotation(int rotation) {
+        try {
+            Method method = getFreezeRotationMethod();
+            method.invoke(manager, rotation);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
+        }
+    }
+
+    public boolean isRotationFrozen() {
+        try {
+            Method method = getIsRotationFrozenMethod();
+            return (boolean) method.invoke(manager);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
+            return false;
+        }
+    }
+
+    public void thawRotation() {
+        try {
+            Method method = getThawRotationMethod();
+            method.invoke(manager);
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
        }
    }

@@ -29,11 +97,12 @@ public final class WindowManager {
        try {
            Class<?> cls = manager.getClass();
            try {
-                cls.getMethod("watchRotation", IRotationWatcher.class).invoke(manager, rotationWatcher);
-            } catch (NoSuchMethodException e) {
                // display parameter added since this commit:
                // https://android.googlesource.com/platform/frameworks/base/+/35fa3c26adcb5f6577849fd0df5228b1f67cf2c6%5E%21/#F1
                cls.getMethod("watchRotation", IRotationWatcher.class, int.class).invoke(manager, rotationWatcher, 0);
+            } catch (NoSuchMethodException e) {
+                // old version
+                cls.getMethod("watchRotation", IRotationWatcher.class).invoke(manager, rotationWatcher);
            }
        } catch (Exception e) {
            throw new AssertionError(e);
--- a/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
@@ -240,6 +240,22 @@ public class ControlMessageReaderTest {
        Assert.assertEquals(Device.POWER_MODE_NORMAL, event.getAction());
    }

+    @Test
+    public void testParseRotateDevice() throws IOException {
+        ControlMessageReader reader = new ControlMessageReader();
+
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        DataOutputStream dos = new DataOutputStream(bos);
+        dos.writeByte(ControlMessage.TYPE_ROTATE_DEVICE);
+
+        byte[] packet = bos.toByteArray();
+
+        reader.readFrom(new ByteArrayInputStream(packet));
+        ControlMessage event = reader.next();
+
+        Assert.assertEquals(ControlMessage.TYPE_ROTATE_DEVICE, event.getType());
+    }
+
    @Test
    public void testMultiEvents() throws IOException {
        ControlMessageReader reader = new ControlMessageReader();
Author	SHA1	Message	Date
Romain Vimont	eb0f339271	Add shortcut to rotate screen On Ctrl+r, disable auto-rotation (if enabled), set the screen rotation and re-enable auto-rotation (if it was enabled). Closes #11 <https://github.com/Genymobile/scrcpy/issues/11>	2019-12-04 22:03:25 +01:00
Romain Vimont	bdd05b4a16	Refactor wrappers for Android SDK classes Internally, a failure to invoke a method via reflection was partially managed using exceptions, partially using a null return value. Handle all errors at the same place, by not catching NoSuchMethodException too early.	2019-12-04 19:34:20 +01:00
Romain Vimont	525d6d4a75	Try new methods before legacy ones Use the legacy methods when the new ones do not exist.	2019-12-04 19:32:38 +01:00
Romain Vimont	4041043d1c	Merge pull request #967 into dev Add some tests <https://github.com/Genymobile/scrcpy/pull/967>	2019-12-04 19:25:58 +01:00
Yu-Chen Lin	fbc86a616c	Correct coding style Signed-off-by: Yu-Chen Lin <npes87184@gmail.com>	2019-12-04 19:24:59 +01:00
Yu-Chen Lin	b2bf25c52c	Add test_buffer_util Signed-off-by: Yu-Chen Lin <npes87184@gmail.com>	2019-12-04 19:24:59 +01:00
Yu-Chen Lin	5eeaed09ae	Add test_strquote Signed-off-by: Yu-Chen Lin <npes87184@gmail.com>	2019-12-04 19:24:59 +01:00
Romain Vimont	3100533e56	Fix "natural scrolling" > Movements down (scroll backward) generate negative y values and up > (scroll forward) generate positive y values. > If direction is SDL_MOUSEWHEEL_FLIPPED the values in x and y will be > opposite. Multiply by -1 to change them back. <https://wiki.libsdl.org/SDL_MouseWheelEvent#Remarks> The x and y values already take the scrolling configuration into account. Reversing the values when the direction is flipped cancels the scrolling configuration. Therefore, just ignore the direction field. Fixes <https://github.com/Genymobile/scrcpy/issues/966>	2019-12-03 21:10:43 +01:00
Romain Vimont	8a694a9785	Suggest workaround for error 0xfffffc0e When the hardware encoder is not able to encode at the given definition, it fails with an error 0xfffffc0e. It is documented in the FAQ: <https://github.com/Genymobile/scrcpy/blob/master/FAQ.md#i-get-an-error-could-not-open-video-stream> But it is better to directly suggest the workaround in the console.	2019-11-30 10:46:22 +01:00
Romain Vimont	26529d377f	Use virtual device id to avoid NPE Inject mouse events using id -1 (virtual device) instead of 0 which does not exist (and causes the InputDevice to be null). Fixes <https://github.com/Genymobile/scrcpy/issues/962>	2019-11-29 14:31:19 +01:00
Romain Vimont	15a206b7fc	Assert return value of mutex functions Mutex functions may only fail due to a programming error. Use assertions in debug builds, and ignore the value in release builds.	2019-11-27 21:40:58 +01:00
Romain Vimont	d0f5a7fd9f	Remove unused includes No mutex is used in decoder.c and stream.c.	2019-11-27 21:40:54 +01:00
Romain Vimont	510caff0cd	Replace SDL_assert() by assert() SDL_assert() open a dialog on assertion failure. There is no reason not to use assert() directly.	2019-11-27 21:19:46 +01:00
Romain Vimont	b5ebb234dd	Replace BUILD_DEBUG by NDEBUG Use the "standard" NDEBUG definition, which is used by assert().	2019-11-27 21:11:52 +01:00
Romain Vimont	73e8ec1b35	Remove path argument from cmd_execute() It is always equal to argv[0] (or not used on Windows).	2019-11-27 21:11:52 +01:00
Romain Vimont	8dc11a0286	Fix warnings on Windows fix warnings reported with -Dwarning_level=2 on Windows.	2019-11-27 21:11:52 +01:00
Romain Vimont	06104a701b	Fix windows build Utilities have been moved to util/, but includes had not been updated in Windows-specific files. Ref: `dfd0707a29`	2019-11-27 13:25:56 +01:00
Romain Vimont	7637a113e3	Compile with warning_level=2 by default	2019-11-26 09:22:20 +01:00
Romain Vimont	31d9d56117	Fix warnings Fix warnings reported with -Dwarning_level=2.	2019-11-26 09:10:41 +01:00
Romain Vimont	6abb8fd0cd	Reformat Java code Reformated by Android studio to match the 150 characters column defined in checkstyle.	2019-11-25 17:33:42 +01:00
Romain Vimont	2b845680b0	Initialize Application object to avoid NPE When an ApplicationInfo is set (commit `90293240cc`), some devices (Nvidia Shield TV) attempt to access the Application object, causing a NullPointerException. As a workaround, initialize an Application object. Fixes <https://github.com/Genymobile/scrcpy/issues/940>	2019-11-24 11:58:40 +01:00
Romain Vimont	ebdc2ee8b5	Rename variable for consistency Use suffix "Field" for fields variables.	2019-11-24 11:55:42 +01:00
Romain Vimont	dfd0707a29	Move utilities to util/	2019-11-24 11:53:23 +01:00
Romain Vimont	83ace84280	Restore the .jar extension on the device side Commit `3da95b52bd` renamed 'scrcpy-server.jar' to 'scrcpy-server' to avoid issues on the client side. However, removing the extension may cause issues with app_process, so restore the extension only on the device side. Fixes <https://github.com/Genymobile/scrcpy/issues/944>	2019-11-22 15:23:57 +01:00
Romain Vimont	c9d886f38b	Use the existing constants for device server path	2019-11-22 15:16:00 +01:00
yangfl	7d7f3daff2	Fix aidl option in build_without_gradle.sh Debian's aidl complains about the missing path for -o option. Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-11-20 17:16:46 +01:00
Romain Vimont	40c3c57613	Update links to v1.11 in README and BUILD	2019-11-19 23:39:30 +01:00
Romain Vimont	2aa65015bc	Bump version to 1.11	2019-11-19 23:05:39 +01:00
Romain Vimont	4906aff454	Upgrade platform-tools (29.0.5) for Windows Include the latest version of adb in Windows releases.	2019-11-19 23:05:39 +01:00
Romain Vimont	cb6b300483	Upgrade FFmpeg (4.2.1) for Windows Include the latest version of FFmpeg in Windows releases.	2019-11-19 23:05:39 +01:00
Romain Vimont	c2116082ab	Remove deprecated options from help and manpage Ref: `ff061b4f30`	2019-11-19 23:05:39 +01:00
Romain Vimont	3599fcaae5	Fix help for --window-width and --window-height The default value is 0 (automatic), not -1.	2019-11-19 22:58:18 +01:00
Romain Vimont	c610a6b3c7	Document scrcpy via SSH tunnel in README	2019-11-19 22:23:08 +01:00
Romain Vimont	704c0ff4dd	Document copy-paste and --prefer-text in README	2019-11-19 22:23:08 +01:00
Romain Vimont	b145b8d5f4	Reorganize features in README	2019-11-19 22:23:08 +01:00
act262	90293240cc	Fix meizu 16th NPE Fill AppInfo to avoid NullPointerException on some devices. Fixes <https://github.com/Genymobile/scrcpy/issues/365> Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-11-19 22:23:08 +01:00
Romain Vimont	213c468c20	Move workarounds to a separate class Extract workarounds (currently only one) to a separate class to avoid polluting the main code.	2019-11-19 22:23:08 +01:00
Romain Vimont	18f2e33a8b	Fix noconsole.exe The linker flag "-mwindows" has no effect on my current MinGW. Instead, passing "-Wl,--subsystem,windows" works. Fixes <https://github.com/Genymobile/scrcpy/issues/691>	2019-11-19 12:22:11 +01:00
senta2006	7aed5d5b60	Fix typos PR <https://github.com/Genymobile/scrcpy/pull/927> Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-11-18 17:45:52 +01:00
Romain Vimont	601b0fecdd	Extract DEBUG flag in build_without_gradle.sh	2019-11-18 14:33:14 +01:00
Romain Vimont	7fd800d583	Generate VERSION_NAME in build_without_gradle.sh Since commit `b963a3b9d5`, the server uses BuildConfig.VERSION_NAME. Generate this field manually for building without gradle.	2019-11-18 14:32:07 +01:00
Romain Vimont	1d97d7213d	Add option --max-fps Add an option to limit the capture frame rate. It only works for devices with Android >= 10. Fixes <https://github.com/Genymobile/scrcpy/issues/488>	2019-11-17 22:10:39 +01:00
Romain Vimont	fb976816f9	Do not expose frame rate in ScreenEncoder The KEY_FRAME_RATE parameter value is necessary for the configuration of the encoder, but its actual value does not impact the frame rate (only resources used by the encoder). Therefore, it's an internal detail and should not be exposed by the ScreenEncoder class.	2019-11-17 22:10:33 +01:00
Romain Vimont	1b78a77962	Fix error message	2019-11-17 22:08:34 +01:00
Romain Vimont	59073223aa	Update manpage for --window-borderless option	2019-11-15 18:59:47 +01:00
Diego Fernando Díaz A	59bc5bc1f5	Add option to disable window decoration Add --window-borderless parameter. Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-11-15 18:59:40 +01:00
Romain Vimont	9fd7a80a89	Add option to specify the initial window size Add --window-width and --window-height parameters. If only one is provided, the other is computed so that the aspect ratio is preserved.	2019-11-15 18:52:58 +01:00
Romain Vimont	b6e2f8ae00	Update manpage for --window-{x,y} options	2019-11-15 18:50:49 +01:00
Diego Fernando Díaz A	ce5635f28c	Add option to specify the initial window position Add --window-x and --window-y parameters. Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-11-15 18:50:49 +01:00
Romain Vimont	771bd8404d	Do not write invalid packet duration Configuration packets have no PTS. Do not compute a packet duration from their PTS. Fixes recording to mp4 on device rotation.	2019-11-13 16:14:46 +01:00
Romain Vimont	af3027a85b	Merge pull request #920 into dev Compare server and client version at the start of scrcpy	2019-11-13 12:01:02 +01:00
Yu-Chen Lin	b963a3b9d5	Check client and server mismatch Send client version as first parameter and check it at server start. Signed-off-by: Yu-Chen Lin <npes87184@gmail.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-11-13 12:00:50 +01:00
Romain Vimont	aa0f77c898	Accept resize shortcuts on maximized window Allow "resize to fit" and "resize to pixel-perfect" on maximized window: restore the window to normal size then resize.	2019-11-11 21:49:23 +01:00
Romain Vimont	35c05bb3ce	Fix rotation while the window is maximized Keep the windowed window size to handle maximized window the same way as fullscreen window. Fixes <https://github.com/Genymobile/scrcpy/issues/750>	2019-11-11 21:49:23 +01:00
Romain Vimont	f6f2868868	Handle window events from screen.c Only the screen knows what to do on window events. This paves the way to handle more window events.	2019-11-11 15:02:26 +01:00
Romain Vimont	6996cbf5d3	Log device disconnection If scrcpy closes due to socket disconnection, log a warning.	2019-11-09 21:17:03 +01:00
olbb	e282100d0b	Call Looper.prepareMainLooper() to avoid exception Some devices internally create a Handler when creating an input Surface, causing an exception: > Surface: java.lang.RuntimeException: Can't create handler inside > thread that has not called Looper.prepare() As a workaround, call Looper.prepareMainLooper() beforehand. Fixes: - <https://github.com/Genymobile/scrcpy/issues/240> - <https://github.com/Genymobile/scrcpy/issues/921> Signed-off-by: Romain Vimont <rom@rom1v.com>	2019-11-09 20:31:57 +01:00
Romain Vimont	b08a98324d	Fix segfault on empty file recorded Write the file trailer only if the file header have been written, to avoid a segfault in libav. Fixes <https://github.com/Genymobile/scrcpy/issues/918>.	2019-11-07 21:58:57 +01:00
Romain Vimont	c916af0984	Add --prefer-text option Expose an option to configure how key/text events are forwarded to the Android device. Enabling the option avoids issues when combining multiple keys to enter special characters, but breaks the expected behavior of alpha keys in games (typically WASD). Fixes <https://github.com/Genymobile/scrcpy/issues/650>	2019-11-07 19:01:35 +01:00
Romain Vimont	ff061b4f30	Deprecate short options for advanced features The short options will be removed in the future (and may be reused for other features).	2019-11-07 10:01:59 +01:00
Romain Vimont	157c60feb4	Fix indentation	2019-11-07 09:48:48 +01:00
Romain Vimont	2d90e1befd	Fix include recorder.h	2019-11-06 22:22:46 +01:00
Romain Vimont	0e301ddf19	Factorize scrcpy options and command-line args Do not duplicate all scrcpy options fields in the structure storing the parsed command-line arguments.	2019-11-06 22:06:54 +01:00