Add shortcuts to rotate client window

Add Ctrl+Left and Ctrl+Right to rotate the scrcpy window.

Contrary to --lock-video-orientation, the rotation has no impact on
recording, and can be changed dynamically (and immediately).

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,25 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
- - [ ] I have read the [FAQ](https://github.com/Genymobile/scrcpy/blob/master/FAQ.md).
- - [ ] I have searched in existing [issues](https://github.com/Genymobile/scrcpy/issues).
-
-**Environment**
- - OS: [e.g. Debian, Windows, macOS...]
- - scrcpy version: [e.g. 1.12.1]
- - installation method: [e.g. manual build, apt, snap, brew, Windows release...]
- - device model:
- - Android version: [e.g. 10]
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-On errors, please provide the output of the console (and `adb logcat` if relevant).
-Format them between code blocks (delimited by ```).
-Please do not post screenshots of your terminal, just post the content as text instead.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,22 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
- - [ ] I have checked that a similar [feature request](https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3A%22feature+request%22) does not already exist.
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

BUILD.md

@@ -8,22 +8,6 @@ case, use the [prebuilt server] (so you will not need Java or the Android SDK).
 
 [prebuilt server]: #prebuilt-server
 
-## Branches
-
-### `master`
-
-The `master` branch concerns the latest release, and is the home page of the
-project on Github.
-
-
-### `dev`
-
-`dev` is the current development branch. Every commit present in `dev` will be
-in the next release.
-
-If you want to contribute code, please base your commits on the latest `dev`
-branch.
-
 
 ## Requirements
 
@@ -263,6 +247,3 @@ meson x --buildtype release --strip -Db_lto=true \
 ninja -Cx
 sudo ninja -Cx install
 ```
-
-The server only works with a matching client version (this server works with the
-`master` branch).

FAQ.md

@@ -3,102 +3,19 @@
 Here are the common reported problems and their status.
 
 
-## `adb` issues
+### On Windows, my device is not detected
 
-`scrcpy` execute `adb` commands to initialize the connection with the device. If
+The most common is your device not being detected by `adb`, or is unauthorized.
-`adb` fails, then scrcpy will not work.
+Check everything is ok by calling:
 
-In that case, it will print this error:
-
->     ERROR: "adb push" returned with value 1
-
-This is typically not a bug in _scrcpy_, but a problem in your environment.
-
-To find out the cause, execute:
-
-```bash
     adb devices
-```
 
-### `adb` not found
+Windows may need some [drivers] to detect your device.
-
-You need `adb` accessible from your `PATH`.
-
-On Windows, the current directory is in your `PATH`, and `adb.exe` is included
-in the release, so it should work out-of-the-box.
-
-
-### Device unauthorized
-
-Check [stackoverflow][device-unauthorized].
-
-[device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
-
-
-### Device not detected
-
-If your device is not detected, you may need some [drivers] (on Windows).
 
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
 
 
-### Several devices connected
+### I can only mirror, I cannot interact with the device
-
-If several devices are connected, you will encounter this error:
-
->     adb: error: failed to get feature set: more than one device/emulator
-
-the identifier of the device you want to mirror must be provided:
-
-```bash
-scrcpy -s 01234567890abcdef
-```
-
-Note that if your device is connected over TCP/IP, you'll get this message:
-
->     adb: error: more than one device/emulator
->     ERROR: "adb reverse" returned with value 1
->     WARN: 'adb reverse' failed, fallback to 'adb forward'
-
-This is expected (due to a bug on old Android versions, see [#5]), but in that
-case, scrcpy fallbacks to a different method, which should work.
-
-[#5]: https://github.com/Genymobile/scrcpy/issues/5
-
-
-### Conflicts between adb versions
-
->     adb server version (41) doesn't match this client (39); killing...
-
-This error occurs when you use several `adb` versions simultaneously. You must
-find the program using a different `adb` version, and use the same `adb` version
-everywhere.
-
-You could overwrite the `adb` binary in the other program, or ask _scrcpy_ to
-use a specific `adb` binary, by setting the `ADB` environment variable:
-
-```bash
-set ADB=/path/to/your/adb
-scrcpy
-```
-
-
-### Device disconnected
-
-If _scrcpy_ stops itself with the warning "Device disconnected", then the
-`adb` connection has been closed.
-
-Try with another USB cable or plug it into another USB port. See [#281] and
-[#283].
-
-[#281]: https://github.com/Genymobile/scrcpy/issues/281
-[#283]: https://github.com/Genymobile/scrcpy/issues/283
-
-
-
-## Control issues
-
-### Mouse and keyboard do not work
 
 On some devices, you may need to enable an option to allow [simulating input].
 In developer options, enable:
@@ -112,43 +29,22 @@ In developer options, enable:
 ### Mouse clicks at wrong location
 
 On MacOS, with HiDPI support and multiple screens, input location are wrongly
-scaled. See [#15].
+scaled. See [issue 15].
 
-[#15]: https://github.com/Genymobile/scrcpy/issues/15
+[issue 15]: https://github.com/Genymobile/scrcpy/issues/15
 
-Open _scrcpy_ directly on the monitor you use it.
+A workaround is to build with HiDPI support disabled:
 
-
+```bash
-### Special characters do not work
+meson x --buildtype release -Dhidpi_support=false
-
-Injecting text input is [limited to ASCII characters][text-input]. A trick
-allows to also inject some [accented characters][accented-characters], but
-that's all. See [#37].
-
-[text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
-[accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
-[#37]: https://github.com/Genymobile/scrcpy/issues/37
-
-
-## Client issues
-
-### The quality is low
-
-If the definition of your client window is smaller than that of your device
-screen, then you might get poor quality, especially visible on text (see [#40]).
-
-[#40]: https://github.com/Genymobile/scrcpy/issues/40
-
-To improve downscaling quality, trilinear filtering is enabled automatically
-if the renderer is OpenGL and if it supports mipmapping.
-
-On Windows, you might want to force OpenGL:
-
-```
-scrcpy --render-driver=opengl
 ```
 
-You may also need to configure the [scaling behavior]:
+However, the video will be displayed at lower resolution.
+
+
+### The quality is low on HiDPI display
+
+On Windows, you may need to configure the [scaling behavior].
 
 > `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
 > Override high DPI scaling behavior > Scaling performed by: _Application_.
@@ -156,7 +52,6 @@ You may also need to configure the [scaling behavior]:
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 
 
-
 ### KWin compositor crashes
 
 On Plasma Desktop, compositor is disabled while _scrcpy_ is running.
@@ -166,29 +61,19 @@ As a workaround, [disable "Block compositing"][kwin].
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
 
 
-## Crashes
+### I get an error "Could not open video stream"
-
-### Exception
 
 There may be many reasons. One common cause is that the hardware encoder of your
 device is not able to encode at the given definition:
 
-> ```
+```
-> ERROR: Exception on thread Thread[main,5,main]
+ERROR: Exception on thread Thread[main,5,main]
-> android.media.MediaCodec$CodecException: Error 0xfffffc0e
+android.media.MediaCodec$CodecException: Error 0xfffffc0e
-> ...
+...
-> Exit due to uncaughtException in main thread:
+Exit due to uncaughtException in main thread:
-> ERROR: Could not open video stream
+ERROR: Could not open video stream
-> INFO: Initial texture: 1080x2336
+INFO: Initial texture: 1080x2336
-> ```
+```
-
-or
-
-> ```
-> ERROR: Exception on thread Thread[main,5,main]
-> java.lang.IllegalStateException
->         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
-> ```
 
 Just try with a lower definition:
 

README.md

@@ -66,12 +66,15 @@ hard).
 
 ### Windows
 
-For Windows, for simplicity, a prebuilt archive with all the dependencies
+For Windows, for simplicity, prebuilt archives with all the dependencies
-(including `adb`) is available:
+(including `adb`) are available:
 
+ - [`scrcpy-win32-v1.12.1.zip`][direct-win32]  
+   _(SHA-256: 0f4b3b063536b50a2df05dc42c760f9cc0093a9a26dbdf02d8232c74dab43480)_
  - [`scrcpy-win64-v1.12.1.zip`][direct-win64]  
    _(SHA-256: 57d34b6d16cfd9fe169bc37c4df58ebd256d05c1ea3febc63d9cb0a027ab47c9)_
 
+[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win32-v1.12.1.zip
 [direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win64-v1.12.1.zip
 
 It is also available in [Chocolatey]:
@@ -80,18 +83,14 @@ It is also available in [Chocolatey]:
 
 ```bash
 choco install scrcpy
-choco install adb    # if you don't have it yet
 ```
 
-And in [Scoop]:
+You need `adb`, accessible from your `PATH`. If you don't have it yet:
 
 ```bash
-scoop install scrcpy
+choco install adb
-scoop install adb    # if you don't have it yet
 ```
 
-[Scoop]: https://scoop.sh
-
 You can also [build the app manually][BUILD].
 
 
@@ -341,33 +340,6 @@ scrcpy -f  # short version
 
 Fullscreen can then be toggled dynamically with `Ctrl`+`f`.
 
-#### Rotation
-
-The window may be rotated:
-
-```bash
-scrcpy --rotation 1
-```
-
-Possibles values are:
- - `0`: no rotation
- - `1`: 90 degrees counterclockwise
- - `2`: 180 degrees
- - `3`: 90 degrees clockwise
-
-The rotation can also be changed dynamically with `Ctrl`+`←` _(left)_ and
-`Ctrl`+`→` _(right)_.
-
-Note that _scrcpy_ manages 3 different rotations:
- - `Ctrl`+`r` requests the device to switch between portrait and landscape (the
-   current running app may refuse, if it does support the requested
-   orientation).
- - `--lock-video-orientation` changes the mirroring orientation (the orientation
-   of the video sent from the device to the computer). This affects the
-   recording.
- - `--rotation` (or `Ctrl`+`←`/`Ctrl`+`→`) rotates only the window content. This
-   affects only the display, not the recording.
-
 
 ### Other mirroring options
 
@@ -519,8 +491,8 @@ Also see [issue #14].
  | Action                                 |   Shortcut                    |   Shortcut (macOS)
  | -------------------------------------- |:----------------------------- |:-----------------------------
  | Switch fullscreen mode                 | `Ctrl`+`f`                    | `Cmd`+`f`
- | Rotate display left                    | `Ctrl`+`←` _(left)_           | `Cmd`+`←` _(left)_
+ | Rotate window left                     | `Ctrl`+`←` _(left)_           | `Cmd`+`←` _(left)_
- | Rotate display right                   | `Ctrl`+`→` _(right)_          | `Cmd`+`→` _(right)_
+ | Rotate window right                    | `Ctrl`+`→` _(right)_          | `Cmd`+`→` _(right)_
  | Resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`                    | `Cmd`+`g`
  | Resize window to remove black borders  | `Ctrl`+`x` \| _Double-click¹_ | `Cmd`+`x`  \| _Double-click¹_
  | Click on `HOME`                        | `Ctrl`+`h` \| _Middle-click_  | `Ctrl`+`h` \| _Middle-click_

app/meson.build

@@ -11,7 +11,6 @@ src = [
     'src/file_handler.c',
     'src/fps_counter.c',
     'src/input_manager.c',
-    'src/opengl.c',
     'src/receiver.c',
     'src/recorder.c',
     'src/scrcpy.c',

app/scrcpy.1

@@ -52,7 +52,7 @@ Print this help.
 
 .TP
 .BI "\-\-lock\-video\-orientation " value
-Lock video orientation to \fIvalue\fR. Possible values are -1 (unlocked), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
+Lock video orientation to \fIvalue\fR. Values are integers in the range [-1..3]. Natural device orientation is 0 and each increment adds 90 degrees counterclockwise.
 
 Default is -1 (unlocked).
 
@@ -74,10 +74,6 @@ Disable device control (mirror the device in read\-only).
 .B \-N, \-\-no\-display
 Do not display device (only when screen recording is enabled).
 
-.TP
-.B \-\-no\-mipmaps
-If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then mipmaps are automatically generated to improve downscaling quality. This option disables the generation of mipmaps.
-
 .TP
 .BI "\-p, \-\-port " port[:port]
 Set the TCP port (range) used by the client to listen.
@@ -110,22 +106,10 @@ option if set, or by the file extension (.mp4 or .mkv).
 .BI "\-\-record\-format " format
 Force recording format (either mp4 or mkv).
 
-.TP
-.BI "\-\-render\-driver " name
-Request SDL to use the given render driver (this is just a hint).
-
-Supported names are currently "direct3d", "opengl", "opengles2", "opengles", "metal" and "software".
-.UR https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER
-.UE
-
 .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.
 
-.TP
-.BI "\-\-rotation " value
-Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each increment adds a 90 degrees rotation counterclockwise.
-
 .TP
 .BI "\-s, \-\-serial " number
 The device serial number. Mandatory only if several devices are connected to adb.
@@ -180,23 +164,23 @@ Default is 0 (automatic).\n
 
 .TP
 .B Ctrl+f
-Switch fullscreen mode
+switch fullscreen mode
 
 .TP
 .B Ctrl+Left
-Rotate display left
+rotate window left
 
 .TP
 .B Ctrl+Right
-Rotate display right
+rotate window right
 
 .TP
 .B Ctrl+g
-Resize window to 1:1 (pixel\-perfect)
+resize window to 1:1 (pixel\-perfect)
 
 .TP
 .B Ctrl+x, Double\-click on black borders
-Resize window to remove black borders
+resize window to remove black borders
 
 .TP
 .B Ctrl+h, Home, Middle\-click
@@ -228,43 +212,43 @@ Click on POWER (turn screen on/off)
 
 .TP
 .B Right\-click (when screen is off)
-Turn screen on
+turn screen on
 
 .TP
 .B Ctrl+o
-Turn device screen off (keep mirroring)
+turn device screen off (keep mirroring)
 
 .TP
 .B Ctrl+r
-Rotate device screen
+rotate device screen
 
 .TP
 .B Ctrl+n
-Expand notification panel
+expand notification panel
 
 .TP
 .B Ctrl+Shift+n
-Collapse notification panel
+collapse notification panel
 
 .TP
 .B Ctrl+c
-Copy device clipboard to computer
+copy device clipboard to computer
 
 .TP
 .B Ctrl+v
-Paste computer clipboard to device
+paste computer clipboard to device
 
 .TP
 .B Ctrl+Shift+v
-Copy computer clipboard to device
+copy computer clipboard to device
 
 .TP
 .B Ctrl+i
-Enable/disable FPS counter (print frames/second in logs)
+enable/disable FPS counter (print frames/second in logs)
 
 .TP
 .B Drag & drop APK file
-Install APK from computer
+install APK from computer
 
 
 .SH Environment variables

app/src/cli.c

@@ -52,10 +52,9 @@ scrcpy_print_usage(const char *arg0) {
         "        Print this help.\n"
         "\n"
         "    --lock-video-orientation value\n"
-        "        Lock video orientation to value.\n"
+        "        Lock video orientation to value. Values are integers in the\n"
-        "        Possible values are -1 (unlocked), 0, 1, 2 and 3.\n"
+        "        range [-1..3]. Natural device orientation is 0 and each\n"
-        "        Natural device orientation is 0, and each increment adds a\n"
+        "        increment adds 90 degrees counterclockwise.\n"
-        "        90 degrees rotation counterclockwise.\n"
         "        Default is %d%s.\n"
         "\n"
         "    --max-fps value\n"
@@ -75,11 +74,6 @@ scrcpy_print_usage(const char *arg0) {
         "        Do not display device (only when screen recording is\n"
         "        enabled).\n"
         "\n"
-        "    --no-mipmaps\n"
-        "        If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then\n"
-        "        mipmaps are automatically generated to improve downscaling\n"
-        "        quality. This option disables the generation of mipmaps.\n"
-        "\n"
         "    -p, --port port[:port]\n"
         "        Set the TCP port (range) used by the client to listen.\n"
         "        Default is %d:%d.\n"
@@ -104,24 +98,12 @@ scrcpy_print_usage(const char *arg0) {
         "    --record-format format\n"
         "        Force recording format (either mp4 or mkv).\n"
         "\n"
-        "    --render-driver name\n"
-        "        Request SDL to use the given render driver (this is just a\n"
-        "        hint).\n"
-        "        Supported names are currently \"direct3d\", \"opengl\",\n"
-        "        \"opengles2\", \"opengles\", \"metal\" and \"software\".\n"
-        "        <https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER>\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"
         "        This flag forces to render all frames, at a cost of a\n"
         "        possible increased latency.\n"
         "\n"
-        "    --rotation value\n"
-        "        Set the initial display rotation.\n"
-        "        Possibles values are 0, 1, 2 and 3. Each increment adds a 90\n"
-        "        degrees rotation counterclockwise.\n"
-        "\n"
         "    -s, --serial serial\n"
         "        The device serial number. Mandatory only if several devices\n"
         "        are connected to adb.\n"
@@ -161,74 +143,74 @@ scrcpy_print_usage(const char *arg0) {
         "Shortcuts:\n"
         "\n"
         "    " CTRL_OR_CMD "+f\n"
-        "        Switch fullscreen mode\n"
+        "        switch fullscreen mode\n"
         "\n"
         "    " CTRL_OR_CMD "+Left\n"
-        "        Rotate display left\n"
+        "        rotate window left\n"
         "\n"
         "    " CTRL_OR_CMD "+Right\n"
-        "        Rotate display right\n"
+        "        rotate window right\n"
         "\n"
         "    " CTRL_OR_CMD "+g\n"
-        "        Resize window to 1:1 (pixel-perfect)\n"
+        "        resize window to 1:1 (pixel-perfect)\n"
         "\n"
         "    " CTRL_OR_CMD "+x\n"
         "    Double-click on black borders\n"
-        "        Resize window to remove black borders\n"
+        "        resize window to remove black borders\n"
         "\n"
         "    Ctrl+h\n"
         "    Middle-click\n"
-        "        Click on HOME\n"
+        "        click on HOME\n"
         "\n"
         "    " CTRL_OR_CMD "+b\n"
         "    " CTRL_OR_CMD "+Backspace\n"
         "    Right-click (when screen is on)\n"
-        "        Click on BACK\n"
+        "        click on BACK\n"
         "\n"
         "    " CTRL_OR_CMD "+s\n"
-        "        Click on APP_SWITCH\n"
+        "        click on APP_SWITCH\n"
         "\n"
         "    Ctrl+m\n"
-        "        Click on MENU\n"
+        "        click on MENU\n"
         "\n"
         "    " CTRL_OR_CMD "+Up\n"
-        "        Click on VOLUME_UP\n"
+        "        click on VOLUME_UP\n"
         "\n"
         "    " CTRL_OR_CMD "+Down\n"
-        "        Click on VOLUME_DOWN\n"
+        "        click on VOLUME_DOWN\n"
         "\n"
         "    " CTRL_OR_CMD "+p\n"
-        "        Click on POWER (turn screen on/off)\n"
+        "        click on POWER (turn screen on/off)\n"
         "\n"
         "    Right-click (when screen is off)\n"
-        "        Power on\n"
+        "        power on\n"
         "\n"
         "    " CTRL_OR_CMD "+o\n"
-        "        Turn device screen off (keep mirroring)\n"
+        "        turn device screen off (keep mirroring)\n"
         "\n"
         "    " CTRL_OR_CMD "+r\n"
-        "        Rotate device screen\n"
+        "        rotate device screen\n"
         "\n"
         "    " CTRL_OR_CMD "+n\n"
-        "        Expand notification panel\n"
+        "       expand notification panel\n"
         "\n"
         "    " CTRL_OR_CMD "+Shift+n\n"
-        "        Collapse notification panel\n"
+        "       collapse notification panel\n"
         "\n"
         "    " CTRL_OR_CMD "+c\n"
-        "        Copy device clipboard to computer\n"
+        "        copy device clipboard to computer\n"
         "\n"
         "    " CTRL_OR_CMD "+v\n"
-        "        Paste computer clipboard to device\n"
+        "        paste computer clipboard to device\n"
         "\n"
         "    " CTRL_OR_CMD "+Shift+v\n"
-        "        Copy computer clipboard to device\n"
+        "        copy computer clipboard to device\n"
         "\n"
         "    " CTRL_OR_CMD "+i\n"
-        "        Enable/disable FPS counter (print frames/second in logs)\n"
+        "        enable/disable FPS counter (print frames/second in logs)\n"
         "\n"
         "    Drag & drop APK file\n"
-        "        Install APK from computer\n"
+        "        install APK from computer\n"
         "\n",
         arg0,
         DEFAULT_BIT_RATE,
@@ -334,18 +316,6 @@ parse_lock_video_orientation(const char *s, int8_t *lock_video_orientation) {
     return true;
 }
 
-static bool
-parse_rotation(const char *s, uint8_t *rotation) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 3, "rotation");
-    if (!ok) {
-        return false;
-    }
-
-    *rotation = (uint8_t) value;
-    return true;
-}
-
 static bool
 parse_window_position(const char *s, int16_t *position) {
     // special value for "auto"
@@ -465,9 +435,6 @@ guess_record_format(const char *filename) {
 #define OPT_MAX_FPS                1012
 #define OPT_LOCK_VIDEO_ORIENTATION 1013
 #define OPT_DISPLAY_ID             1014
-#define OPT_ROTATION               1015
-#define OPT_RENDER_DRIVER          1016
-#define OPT_NO_MIPMAPS             1017
 
 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@@ -484,15 +451,12 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         {"max-size",               required_argument, NULL, 'm'},
         {"no-control",             no_argument,       NULL, 'n'},
         {"no-display",             no_argument,       NULL, 'N'},
-        {"no-mipmaps",             no_argument,       NULL, OPT_NO_MIPMAPS},
         {"port",                   required_argument, NULL, 'p'},
         {"push-target",            required_argument, NULL, OPT_PUSH_TARGET},
         {"record",                 required_argument, NULL, 'r'},
         {"record-format",          required_argument, NULL, OPT_RECORD_FORMAT},
-        {"render-driver",          required_argument, NULL, OPT_RENDER_DRIVER},
         {"render-expired-frames",  no_argument,       NULL,
                                                   OPT_RENDER_EXPIRED_FRAMES},
-        {"rotation",               required_argument, NULL, OPT_ROTATION},
         {"serial",                 required_argument, NULL, 's'},
         {"show-touches",           no_argument,       NULL, 't'},
         {"turn-screen-off",        no_argument,       NULL, 'S'},
@@ -628,17 +592,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
             case OPT_PREFER_TEXT:
                 opts->prefer_text = true;
                 break;
-            case OPT_ROTATION:
-                if (!parse_rotation(optarg, &opts->rotation)) {
-                    return false;
-                }
-                break;
-            case OPT_RENDER_DRIVER:
-                opts->render_driver = optarg;
-                break;
-            case OPT_NO_MIPMAPS:
-                opts->mipmaps = false;
-                break;
             default:
                 // getopt prints the error message on stderr
                 return false;
@@ -650,6 +603,11 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         return false;
     }
 
+    if (!opts->display && opts->fullscreen) {
+        LOGE("-f/--fullscreen-window is incompatible with -N/--no-display");
+        return false;
+    }
+
     int index = optind;
     if (index < argc) {
         LOGE("Unexpected additional argument: %s", argv[index]);

app/src/control_msg.c

@@ -45,9 +45,8 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
             buffer_write32be(&buf[6], msg->inject_keycode.metastate);
             return 10;
         case CONTROL_MSG_TYPE_INJECT_TEXT: {
-            size_t len =
+            size_t len = write_string(msg->inject_text.text,
-                write_string(msg->inject_text.text,
+                                      CONTROL_MSG_TEXT_MAX_LENGTH, &buf[1]);
-                             CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
             return 1 + len;
         }
         case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:

app/src/control_msg.h

@@ -10,7 +10,7 @@
 #include "android/keycodes.h"
 #include "common.h"
 
-#define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
+#define CONTROL_MSG_TEXT_MAX_LENGTH 300
 #define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH 4093
 #define CONTROL_MSG_SERIALIZED_MAX_SIZE \
     (3 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)

app/src/input_manager.c

@@ -7,6 +7,33 @@
 #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)
+//
+// See my question:
+// <https://stackoverflow.com/questions/49111054/how-to-get-mouse-position-on-mouse-wheel-event>
+static void
+convert_to_renderer_coordinates(SDL_Renderer *renderer, int *x, int *y) {
+    SDL_Rect viewport;
+    float scale_x, scale_y;
+    SDL_RenderGetViewport(renderer, &viewport);
+    SDL_RenderGetScale(renderer, &scale_x, &scale_y);
+    *x = (int) (*x / scale_x) - viewport.x;
+    *y = (int) (*y / scale_y) - viewport.y;
+}
+
+static struct point
+get_mouse_point(struct screen *screen) {
+    int x;
+    int y;
+    SDL_GetMouseState(&x, &y);
+    convert_to_renderer_coordinates(screen->renderer, &x, &y);
+    return (struct point) {
+        .x = x,
+        .y = y,
+    };
+}
+
 static const int ACTION_DOWN = 1;
 static const int ACTION_UP = 1 << 1;
 
@@ -196,13 +223,13 @@ rotate_device(struct controller *controller) {
 
 static void
 rotate_client_left(struct screen *screen) {
-    unsigned new_rotation = (screen->rotation + 1) % 4;
+    unsigned new_rotation = (screen->rotation + 3) % 4;
     screen_set_rotation(screen, new_rotation);
 }
 
 static void
 rotate_client_right(struct screen *screen) {
-    unsigned new_rotation = (screen->rotation + 3) % 4;
+    unsigned new_rotation = (screen->rotation + 1) % 4;
     screen_set_rotation(screen, new_rotation);
 }
 
@@ -422,8 +449,8 @@ convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
     to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
     to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
     to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
+    to->inject_touch_event.position.point.x = from->x;
-        screen_convert_to_frame_coords(screen, from->x, from->y);
+    to->inject_touch_event.position.point.y = from->y;
     to->inject_touch_event.pressure = 1.f;
     to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
 
@@ -458,19 +485,13 @@ convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
         return false;
     }
 
+    struct size frame_size = screen->frame_size;
+
     to->inject_touch_event.pointer_id = from->fingerId;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
+    to->inject_touch_event.position.screen_size = frame_size;
-
-    int ww;
-    int wh;
-    SDL_GL_GetDrawableSize(screen->window, &ww, &wh);
-
     // SDL touch event coordinates are normalized in the range [0; 1]
-    int32_t x = from->x * ww;
+    to->inject_touch_event.position.point.x = from->x * frame_size.width;
-    int32_t y = from->y * wh;
+    to->inject_touch_event.position.point.y = from->y * frame_size.height;
-    to->inject_touch_event.position.point =
-        screen_convert_to_frame_coords(screen, x, y);
-
     to->inject_touch_event.pressure = from->pressure;
     to->inject_touch_event.buttons = 0;
     return true;
@@ -487,6 +508,13 @@ input_manager_process_touch(struct input_manager *im,
     }
 }
 
+static bool
+is_outside_device_screen(struct input_manager *im, int x, int y)
+{
+    return x < 0 || x >= im->screen->frame_size.width ||
+           y < 0 || y >= im->screen->frame_size.height;
+}
+
 static bool
 convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
                      struct control_msg *to) {
@@ -498,8 +526,8 @@ convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
 
     to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
     to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
+    to->inject_touch_event.position.point.x = from->x;
-        screen_convert_to_frame_coords(screen, from->x, from->y);
+    to->inject_touch_event.position.point.y = from->y;
     to->inject_touch_event.pressure = 1.f;
     to->inject_touch_event.buttons =
         convert_mouse_buttons(SDL_BUTTON(from->button));
@@ -524,14 +552,10 @@ input_manager_process_mouse_button(struct input_manager *im,
             action_home(im->controller, ACTION_DOWN | ACTION_UP);
             return;
         }
-
         // double-click on black borders resize to fit the device screen
         if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
-            int x = event->x;
+            bool outside =
-            int y = event->y;
+                is_outside_device_screen(im, event->x, event->y);
-            SDL_Rect *r = &im->screen->rect;
-            bool outside = x < r->x || x >= r->x + r->w
-                        || y < r->y || y >= r->y + r->h;
             if (outside) {
                 screen_resize_to_fit(im->screen);
                 return;
@@ -555,15 +579,9 @@ input_manager_process_mouse_button(struct input_manager *im,
 static bool
 convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
                     struct control_msg *to) {
-
-    // mouse_x and mouse_y are expressed in pixels relative to the window
-    int mouse_x;
-    int mouse_y;
-    SDL_GetMouseState(&mouse_x, &mouse_y);
-
     struct position position = {
         .screen_size = screen->frame_size,
-        .point = screen_convert_to_frame_coords(screen, mouse_x, mouse_y),
+        .point = get_mouse_point(screen),
     };
 
     to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;

app/src/opengl.c

@@ -1,56 +0,0 @@
-#include "opengl.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include "SDL2/SDL.h"
-
-void
-sc_opengl_init(struct sc_opengl *gl) {
-    gl->GetString = SDL_GL_GetProcAddress("glGetString");
-    assert(gl->GetString);
-
-    gl->TexParameterf = SDL_GL_GetProcAddress("glTexParameterf");
-    assert(gl->TexParameterf);
-
-    gl->TexParameteri = SDL_GL_GetProcAddress("glTexParameteri");
-    assert(gl->TexParameteri);
-
-    // optional
-    gl->GenerateMipmap = SDL_GL_GetProcAddress("glGenerateMipmap");
-
-    const char *version = (const char *) gl->GetString(GL_VERSION);
-    assert(version);
-    gl->version = version;
-
-#define OPENGL_ES_PREFIX "OpenGL ES "
-    /* starts with "OpenGL ES " */
-    gl->is_opengles = !strncmp(gl->version, OPENGL_ES_PREFIX,
-                               sizeof(OPENGL_ES_PREFIX) - 1);
-    if (gl->is_opengles) {
-        /* skip the prefix */
-        version += sizeof(PREFIX) - 1;
-    }
-
-    int r = sscanf(version, "%d.%d", &gl->version_major, &gl->version_minor);
-    if (r != 2) {
-        // failed to parse the version
-        gl->version_major = 0;
-        gl->version_minor = 0;
-    }
-}
-
-bool
-sc_opengl_version_at_least(struct sc_opengl *gl,
-                           int minver_major, int minver_minor,
-                           int minver_es_major, int minver_es_minor)
-{
-    if (gl->is_opengles) {
-        return gl->version_major > minver_es_major
-            || (gl->version_major == minver_es_major
-             && gl->version_minor >= minver_es_minor);
-    }
-
-    return gl->version_major > minver_major
-        || (gl->version_major == minver_major
-         && gl->version_minor >= minver_minor);
-}

app/src/opengl.h

@@ -1,36 +0,0 @@
-#ifndef SC_OPENGL_H
-#define SC_OPENGL_H
-
-#include <stdbool.h>
-#include <SDL2/SDL_opengl.h>
-
-#include "config.h"
-
-struct sc_opengl {
-    const char *version;
-    bool is_opengles;
-    int version_major;
-    int version_minor;
-
-    const GLubyte *
-    (*GetString)(GLenum name);
-
-    void
-    (*TexParameterf)(GLenum target, GLenum pname, GLfloat param);
-
-    void
-    (*TexParameteri)(GLenum target, GLenum pname, GLint param);
-
-    void
-    (*GenerateMipmap)(GLenum target);
-};
-
-void
-sc_opengl_init(struct sc_opengl *gl);
-
-bool
-sc_opengl_version_at_least(struct sc_opengl *gl,
-                           int minver_major, int minver_minor,
-                           int minver_es_major, int minver_es_minor);
-
-#endif

app/src/scrcpy.c

@@ -47,7 +47,7 @@ static struct input_manager input_manager = {
 
 // init SDL and set appropriate hints
 static bool
-sdl_init_and_configure(bool display, const char *render_driver) {
+sdl_init_and_configure(bool display) {
     uint32_t flags = display ? SDL_INIT_VIDEO : SDL_INIT_EVENTS;
     if (SDL_Init(flags)) {
         LOGC("Could not initialize SDL: %s", SDL_GetError());
@@ -60,10 +60,6 @@ sdl_init_and_configure(bool display, const char *render_driver) {
         return true;
     }
 
-    if (render_driver && !SDL_SetHint(SDL_HINT_RENDER_DRIVER, render_driver)) {
-        LOGW("Could not set render driver");
-    }
-
     // Linear filtering
     if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
         LOGW("Could not enable linear filtering");
@@ -109,10 +105,9 @@ static int
 event_watcher(void *data, SDL_Event *event) {
     (void) data;
     if (event->type == SDL_WINDOWEVENT
-            && event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
+            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
-        // In practice, it seems to always be called from the same thread in
+        // called from another thread, not very safe, but it's a workaround!
-        // that specific case. Anyway, it's just a workaround.
+        screen_render(&screen);
-        screen_handle_window_event(&screen, &event->window);
     }
     return 0;
 }
@@ -315,7 +310,7 @@ scrcpy(const struct scrcpy_options *options) {
     bool controller_initialized = false;
     bool controller_started = false;
 
-    if (!sdl_init_and_configure(options->display, options->render_driver)) {
+    if (!sdl_init_and_configure(options->display)) {
         goto end;
     }
 
@@ -401,8 +396,7 @@ scrcpy(const struct scrcpy_options *options) {
                                    options->always_on_top, options->window_x,
                                    options->window_y, options->window_width,
                                    options->window_height,
-                                   options->window_borderless,
+                                   options->window_borderless)) {
-                                   options->rotation, options-> mipmaps)) {
             goto end;
         }
 

app/src/scrcpy.h

@@ -15,14 +15,12 @@ struct scrcpy_options {
     const char *record_filename;
     const char *window_title;
     const char *push_target;
-    const char *render_driver;
     enum recorder_format record_format;
     struct port_range port_range;
     uint16_t max_size;
     uint32_t bit_rate;
     uint16_t max_fps;
     int8_t lock_video_orientation;
-    uint8_t rotation;
     int16_t window_x; // WINDOW_POSITION_UNDEFINED for "auto"
     int16_t window_y; // WINDOW_POSITION_UNDEFINED for "auto"
     uint16_t window_width;
@@ -37,7 +35,6 @@ struct scrcpy_options {
     bool render_expired_frames;
     bool prefer_text;
     bool window_borderless;
-    bool mipmaps;
 };
 
 #define SCRCPY_OPTIONS_DEFAULT { \
@@ -46,7 +43,6 @@ struct scrcpy_options {
     .record_filename = NULL, \
     .window_title = NULL, \
     .push_target = NULL, \
-    .render_driver = NULL, \
     .record_format = RECORDER_FORMAT_AUTO, \
     .port_range = { \
         .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
@@ -56,7 +52,6 @@ struct scrcpy_options {
     .bit_rate = DEFAULT_BIT_RATE, \
     .max_fps = 0, \
     .lock_video_orientation = DEFAULT_LOCK_VIDEO_ORIENTATION, \
-    .rotation = 0, \
     .window_x = WINDOW_POSITION_UNDEFINED, \
     .window_y = WINDOW_POSITION_UNDEFINED, \
     .window_width = 0, \
@@ -71,7 +66,6 @@ struct scrcpy_options {
     .render_expired_frames = false, \
     .prefer_text = false, \
     .window_borderless = false, \
-    .mipmaps = true, \
 }
 
 bool

app/src/screen.c

@@ -87,16 +87,6 @@ get_preferred_display_bounds(struct size *bounds) {
     return true;
 }
 
-static bool
-is_optimal_size(struct size current_size, struct size content_size) {
-    // The size is optimal if we can recompute one dimension of the current
-    // size from the other
-    return current_size.height == current_size.width * content_size.height
-                                                     / content_size.width
-        || current_size.width == current_size.height * content_size.width
-                                                     / content_size.height;
-}
-
 // return the optimal size of the window, with the following constraints:
 //  - it attempts to keep at least one dimension of the current_size (i.e. it
 //    crops the black borders)
@@ -109,36 +99,33 @@ get_optimal_size(struct size current_size, struct size content_size) {
         return current_size;
     }
 
-    struct size window_size;
-
     struct size display_size;
+    // 32 bits because we need to multiply two 16 bits values
+    uint32_t w;
+    uint32_t h;
+
     if (!get_preferred_display_bounds(&display_size)) {
         // could not get display bounds, do not constraint the size
-        window_size.width = current_size.width;
+        w = current_size.width;
-        window_size.height = current_size.height;
+        h = current_size.height;
     } else {
-        window_size.width = MIN(current_size.width, display_size.width);
+        w = MIN(current_size.width, display_size.width);
-        window_size.height = MIN(current_size.height, display_size.height);
+        h = MIN(current_size.height, display_size.height);
     }
 
-    if (is_optimal_size(window_size, content_size)) {
+    bool keep_width = content_size.width * h > content_size.height * w;
-        return window_size;
-    }
-
-    bool keep_width = content_size.width * window_size.height
-                    > content_size.height * window_size.width;
     if (keep_width) {
         // remove black borders on top and bottom
-        window_size.height = content_size.height * window_size.width
+        h = content_size.height * w / content_size.width;
-                           / content_size.width;
     } else {
         // remove black borders on left and right (or none at all if it already
         // fits)
-        window_size.width = content_size.width * window_size.height
+        w = content_size.width * h / content_size.height;
-                          / content_size.height;
     }
 
-    return window_size;
+    // w and h must fit into 16 bits
+    assert(w < 0x10000 && h < 0x10000);
+    return (struct size) {w, h};
 }
 
 // same as get_optimal_size(), but read the current size from the window
@@ -175,88 +162,26 @@ get_initial_optimal_size(struct size content_size, uint16_t req_width,
     return window_size;
 }
 
-static void
-update_content_rect(struct screen *screen) {
-    int dw;
-    int dh;
-    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
-
-    struct size content_size = screen->content_size;
-    // The drawable size is the window size * the HiDPI scale
-    struct size drawable_size = {dw, dh};
-
-    SDL_Rect *rect = &screen->rect;
-
-    if (is_optimal_size(drawable_size, content_size)) {
-        rect->x = 0;
-        rect->y = 0;
-        rect->w = drawable_size.width;
-        rect->h = drawable_size.height;
-        return;
-    }
-
-    bool keep_width = content_size.width * drawable_size.height
-                    > content_size.height * drawable_size.width;
-    if (keep_width) {
-        rect->x = 0;
-        rect->w = drawable_size.width;
-        rect->h = drawable_size.width * content_size.height
-                                      / content_size.width;
-        rect->y = (drawable_size.height - rect->h) / 2;
-    } else {
-        rect->y = 0;
-        rect->h = drawable_size.height;
-        rect->w = drawable_size.height * content_size.width
-                                       / content_size.height;
-        rect->x = (drawable_size.width - rect->w) / 2;
-    }
-}
-
 void
 screen_init(struct screen *screen) {
     *screen = (struct screen) SCREEN_INITIALIZER;
 }
 
 static inline SDL_Texture *
-create_texture(struct screen *screen) {
+create_texture(SDL_Renderer *renderer, struct size frame_size) {
-    SDL_Renderer *renderer = screen->renderer;
+    return SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
-    struct size size = screen->frame_size;
-    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
                              SDL_TEXTUREACCESS_STREAMING,
-                                             size.width, size.height);
+                             frame_size.width, frame_size.height);
-    if (!texture) {
-        return NULL;
-    }
-
-    if (screen->mipmaps) {
-        struct sc_opengl *gl = &screen->gl;
-
-        SDL_GL_BindTexture(texture, NULL, NULL);
-
-        // Enable trilinear filtering for downscaling
-        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -.5f);
-
-        SDL_GL_UnbindTexture(texture);
-    }
-
-    return texture;
 }
 
 bool
 screen_init_rendering(struct screen *screen, const char *window_title,
                       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,
+                      uint16_t window_height, bool window_borderless) {
-                      uint8_t rotation, bool mipmaps) {
     screen->frame_size = frame_size;
-    screen->rotation = rotation;
+    struct size content_size =
-    if (rotation) {
+        get_rotated_size(frame_size, screen->rotation);
-        LOGI("Initial display rotation set to %u", rotation);
-    }
-    struct size content_size = get_rotated_size(frame_size, screen->rotation);
-    screen->content_size = content_size;
 
     struct size window_size =
         get_initial_optimal_size(content_size, window_width, window_height);
@@ -296,35 +221,11 @@ screen_init_rendering(struct screen *screen, const char *window_title,
         return false;
     }
 
-    SDL_RendererInfo renderer_info;
+    if (SDL_RenderSetLogicalSize(screen->renderer, content_size.width,
-    int r = SDL_GetRendererInfo(screen->renderer, &renderer_info);
+                                 content_size.height)) {
-    const char *renderer_name = r ? NULL : renderer_info.name;
+        LOGE("Could not set renderer logical size: %s", SDL_GetError());
-    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
+        screen_destroy(screen);
-
+        return false;
-    // starts with "opengl"
-    screen->use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (screen->use_opengl) {
-        struct sc_opengl *gl = &screen->gl;
-        sc_opengl_init(gl);
-
-        LOGI("OpenGL version: %s", gl->version);
-
-        if (mipmaps) {
-            bool supports_mipmaps =
-                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
-                                               2, 0  /* OpenGL ES 2.0+ */);
-            if (supports_mipmaps) {
-                LOGI("Trilinear filtering enabled");
-                screen->mipmaps = true;
-            } else {
-                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required)");
-            }
-        } else {
-            LOGI("Trilinear filtering disabled");
-        }
-    } else {
-        LOGW("Trilinear filtering disabled (not an OpenGL renderer)");
     }
 
     SDL_Surface *icon = read_xpm(icon_xpm);
@@ -337,15 +238,13 @@ screen_init_rendering(struct screen *screen, const char *window_title,
 
     LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width,
                                                   frame_size.height);
-    screen->texture = create_texture(screen);
+    screen->texture = create_texture(screen->renderer, frame_size);
     if (!screen->texture) {
         LOGC("Could not create texture: %s", SDL_GetError());
         screen_destroy(screen);
         return false;
     }
 
-    update_content_rect(screen);
-
     screen->windowed_window_size = window_size;
 
     return true;
@@ -376,10 +275,18 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
         return;
     }
 
-    struct size old_content_size = screen->content_size;
+    struct size old_content_size =
+        get_rotated_size(screen->frame_size, screen->rotation);
     struct size new_content_size =
         get_rotated_size(screen->frame_size, rotation);
 
+    if (SDL_RenderSetLogicalSize(screen->renderer,
+                                 new_content_size.width,
+                                 new_content_size.height)) {
+        LOGE("Could not set renderer logical size: %s", SDL_GetError());
+        return;
+    }
+
     struct size windowed_size = get_windowed_window_size(screen);
     struct size target_size = {
         .width = (uint32_t) windowed_size.width * new_content_size.width
@@ -390,11 +297,9 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
     target_size = get_optimal_size(target_size, new_content_size);
     set_window_size(screen, target_size);
 
-    screen->content_size = new_content_size;
     screen->rotation = rotation;
-    LOGI("Display rotation set to %u", rotation);
+    LOGI("Client rotation set to %u", rotation);
 
-    update_content_rect(screen);
     screen_render(screen);
 }
 
@@ -403,12 +308,20 @@ static bool
 prepare_for_frame(struct screen *screen, struct size new_frame_size) {
     if (screen->frame_size.width != new_frame_size.width
             || screen->frame_size.height != new_frame_size.height) {
+        struct size new_content_size =
+            get_rotated_size(new_frame_size, screen->rotation);
+        if (SDL_RenderSetLogicalSize(screen->renderer,
+                                     new_content_size.width,
+                                     new_content_size.height)) {
+            LOGE("Could not set renderer logical size: %s", SDL_GetError());
+            return false;
+        }
+
         // frame dimension changed, destroy texture
         SDL_DestroyTexture(screen->texture);
 
-        struct size new_content_size =
+        struct size content_size =
-            get_rotated_size(new_frame_size, screen->rotation);
+            get_rotated_size(screen->frame_size, screen->rotation);
-        struct size content_size = screen->content_size;
         struct size windowed_size = get_windowed_window_size(screen);
         struct size target_size = {
             (uint32_t) windowed_size.width * new_content_size.width
@@ -420,12 +333,10 @@ prepare_for_frame(struct screen *screen, struct size new_frame_size) {
         set_window_size(screen, target_size);
 
         screen->frame_size = new_frame_size;
-        screen->content_size = new_content_size;
-        update_content_rect(screen);
 
         LOGI("New texture: %" PRIu16 "x%" PRIu16,
                      screen->frame_size.width, screen->frame_size.height);
-        screen->texture = create_texture(screen);
+        screen->texture = create_texture(screen->renderer, new_frame_size);
         if (!screen->texture) {
             LOGC("Could not create texture: %s", SDL_GetError());
             return false;
@@ -442,13 +353,6 @@ update_texture(struct screen *screen, const AVFrame *frame) {
             frame->data[0], frame->linesize[0],
             frame->data[1], frame->linesize[1],
             frame->data[2], frame->linesize[2]);
-
-    if (screen->mipmaps) {
-        assert(screen->use_opengl);
-        SDL_GL_BindTexture(screen->texture, NULL, NULL);
-        screen->gl.GenerateMipmap(GL_TEXTURE_2D);
-        SDL_GL_UnbindTexture(screen->texture);
-    }
 }
 
 bool
@@ -471,26 +375,23 @@ void
 screen_render(struct screen *screen) {
     SDL_RenderClear(screen->renderer);
     if (screen->rotation == 0) {
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
+        SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
     } else {
-        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
+        double angle = 90 * screen->rotation;
-        // counterclockwise (to be consistent with --lock-video-orientation)
-        int cw_rotation = (4 - screen->rotation) % 4;
-        double angle = 90 * cw_rotation;
 
         SDL_Rect *dstrect = NULL;
         SDL_Rect rect;
         if (screen->rotation & 1) {
-            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
+            struct size size =
-            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
+                get_rotated_size(screen->frame_size, screen->rotation);
-            rect.w = screen->rect.h;
+            rect.x = (size.width - size.height) / 2;
-            rect.h = screen->rect.w;
+            rect.y = (size.height - size.width) / 2;
+            rect.w = size.height;
+            rect.h = size.width;
             dstrect = &rect;
-        } else {
-            assert(screen->rotation == 2);
-            dstrect = &screen->rect;
         }
 
+        // rotation in RenderCopyEx() is clockwise
         SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
                          angle, NULL, 0);
     }
@@ -509,7 +410,6 @@ screen_switch_fullscreen(struct screen *screen) {
     apply_windowed_size(screen);
 
     LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
-    update_content_rect(screen);
     screen_render(screen);
 }
 
@@ -524,11 +424,12 @@ screen_resize_to_fit(struct screen *screen) {
         screen->maximized = false;
     }
 
+    struct size content_size =
+        get_rotated_size(screen->frame_size, screen->rotation);
     struct size optimal_size =
-        get_optimal_window_size(screen, screen->content_size);
+        get_optimal_window_size(screen, content_size);
     SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
-    LOGD("Resized to optimal size: %ux%u", optimal_size.width,
+    LOGD("Resized to optimal size");
-                                           optimal_size.height);
 }
 
 void
@@ -542,10 +443,10 @@ screen_resize_to_pixel_perfect(struct screen *screen) {
         screen->maximized = false;
     }
 
-    struct size content_size = screen->content_size;
+    struct size content_size =
+        get_rotated_size(screen->frame_size, screen->rotation);
     SDL_SetWindowSize(screen->window, content_size.width, content_size.height);
-    LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
+    LOGD("Resized to pixel-perfect");
-                                            content_size.height);
 }
 
 void
@@ -553,7 +454,6 @@ screen_handle_window_event(struct screen *screen,
                            const SDL_WindowEvent *event) {
     switch (event->event) {
         case SDL_WINDOWEVENT_EXPOSED:
-            update_content_rect(screen);
             screen_render(screen);
             break;
         case SDL_WINDOWEVENT_SIZE_CHANGED:
@@ -569,7 +469,6 @@ screen_handle_window_event(struct screen *screen,
                 // window is maximized or fullscreen is enabled.
                 screen->windowed_window_size = get_window_size(screen->window);
             }
-            update_content_rect(screen);
             screen_render(screen);
             break;
         case SDL_WINDOWEVENT_MAXIMIZED:
@@ -591,52 +490,3 @@ screen_handle_window_event(struct screen *screen,
             break;
     }
 }
-
-struct point
-screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y) {
-    unsigned rotation = screen->rotation;
-    assert(rotation < 4);
-
-    int old_x = x;
-    int old_y = y;
-
-    int32_t w = screen->content_size.width;
-    int32_t h = screen->content_size.height;
-
-    // take the HiDPI scaling (dw/ww and dh/wh) into account
-    int ww, wh, dw, dh;
-    SDL_GetWindowSize(screen->window, &ww, &wh);
-    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
-
-    // scale (64 bits for intermediate multiplications)
-    x = (int64_t) (x - screen->rect.x) * w * dw / (screen->rect.w * ww);
-    y = (int64_t) (y - screen->rect.y) * h * dh / (screen->rect.h * wh);
-
-    LOGI("content=%dx%d, rect={%d, %d, %dx%d}: (%d, %d) -> (%d, %d)",
-         (int) w, (int) h,
-         screen->rect.x, screen->rect.y, screen->rect.w, screen->rect.h,
-         old_x, old_y, (int) x, (int) y);
-
-    // rotate
-    struct point result;
-    switch (rotation) {
-        case 0:
-            result.x = x;
-            result.y = y;
-            break;
-        case 1:
-            result.x = h - y;
-            result.y = x;
-            break;
-        case 2:
-            result.x = w - x;
-            result.y = h - y;
-            break;
-        default:
-            assert(rotation == 3);
-            result.x = y;
-            result.y = w - x;
-            break;
-    }
-    return result;
-}

app/src/screen.h

@@ -7,7 +7,6 @@
 
 #include "config.h"
 #include "common.h"
-#include "opengl.h"
 
 #define WINDOW_POSITION_UNDEFINED (-0x8000)
 
@@ -17,40 +16,28 @@ struct screen {
     SDL_Window *window;
     SDL_Renderer *renderer;
     SDL_Texture *texture;
-    bool use_opengl;
-    struct sc_opengl gl;
     struct size frame_size;
-    struct size content_size; // rotated frame_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;
-    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
+    // client rotation: 0, 1, 2 or 3 (x90 degrees clockwise)
     unsigned rotation;
-    // rectangle of the content (excluding black borders)
-    struct SDL_Rect rect;
     bool has_frame;
     bool fullscreen;
     bool maximized;
     bool no_window;
-    bool mipmaps;
 };
 
 #define SCREEN_INITIALIZER { \
     .window = NULL, \
     .renderer = NULL, \
     .texture = NULL, \
-    .use_opengl = false, \
-    .gl = {0}, \
     .frame_size = { \
         .width = 0,  \
         .height = 0, \
     }, \
-    .content_size = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
     .windowed_window_size = { \
         .width = 0, \
         .height = 0, \
@@ -60,17 +47,10 @@ struct screen {
         .height = 0, \
     }, \
     .rotation = 0, \
-    .rect = { \
-        .x = 0, \
-        .y = 0, \
-        .w = 0, \
-        .h = 0, \
-    }, \
     .has_frame = false, \
     .fullscreen = false, \
     .maximized = false, \
     .no_window = false, \
-    .mipmaps = false, \
 }
 
 // initialize default values
@@ -83,8 +63,7 @@ bool
 screen_init_rendering(struct screen *screen, const char *window_title,
                       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,
+                      uint16_t window_height, bool window_borderless);
-                      uint8_t rotation, bool mipmaps);
 
 // show the window
 void
@@ -114,7 +93,7 @@ screen_resize_to_fit(struct screen *screen);
 void
 screen_resize_to_pixel_perfect(struct screen *screen);
 
-// set the display rotation (0, 1, 2 or 3, x90 degrees counterclockwise)
+// change the client rotation (0, 1, 2 or 3, x90 degrees clockwise)
 void
 screen_set_rotation(struct screen *screen, unsigned rotation);
 
@@ -122,9 +101,4 @@ screen_set_rotation(struct screen *screen, unsigned rotation);
 void
 screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);
 
-// convert point from window coordinates to frame coordinates
-// x and y are expressed in pixels
-struct point
-screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y);
-
 #endif

app/src/server.c

@@ -172,7 +172,7 @@ enable_tunnel_reverse_any_port(struct server *server,
         // check before incrementing to avoid overflow on port 65535
         if (port < port_range.last) {
             LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
-                 port, (uint16_t) (port + 1));
+                 port, port + 1);
             port++;
             continue;
         }

app/src/sys/unix/command.c

@@ -14,7 +14,6 @@
 #include <limits.h>
 #include <signal.h>
 #include <stdlib.h>
-#include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/stat.h>

app/tests/test_control_msg_serialize.c

@@ -49,20 +49,20 @@ static void test_serialize_inject_text(void) {
 static void test_serialize_inject_text_long(void) {
     struct control_msg msg;
     msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    char text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1];
+    char text[CONTROL_MSG_TEXT_MAX_LENGTH + 1];
     memset(text, 'a', sizeof(text));
-    text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
+    text[CONTROL_MSG_TEXT_MAX_LENGTH] = '\0';
     msg.inject_text.text = text;
 
     unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
     int size = control_msg_serialize(&msg, buf);
-    assert(size == 3 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    assert(size == 3 + CONTROL_MSG_TEXT_MAX_LENGTH);
 
-    unsigned char expected[3 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
+    unsigned char expected[3 + CONTROL_MSG_TEXT_MAX_LENGTH];
     expected[0] = CONTROL_MSG_TYPE_INJECT_TEXT;
     expected[1] = 0x01;
     expected[2] = 0x2c; // text length (16 bits)
-    memset(&expected[3], 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    memset(&expected[3], 'a', CONTROL_MSG_TEXT_MAX_LENGTH);
 
     assert(!memcmp(buf, expected, sizeof(expected)));
 }

meson.build

@@ -1,6 +1,6 @@
 project('scrcpy', 'c',
         version: '1.12.1',
-        meson_version: '>= 0.48',
+        meson_version: '>= 0.37',
         default_options: [
             'c_std=c11',
             'warning_level=2',

server/meson.build

@@ -3,9 +3,7 @@
 prebuilt_server = get_option('prebuilt_server')
 if prebuilt_server == ''
     custom_target('scrcpy-server',
-                  # gradle is responsible for tracking source changes
+                  build_always: true,  # gradle is responsible for tracking source changes
-                  build_by_default: true,
-                  build_always_stale: true,
                   output: 'scrcpy-server',
                   command: [find_program('./scripts/build-wrapper.sh'), meson.current_source_dir(), '@OUTPUT@', get_option('buildtype')],
                   console: true,

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

@@ -13,8 +13,8 @@ public class ControlMessageReader {
     static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
     static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
 
+    public static final int TEXT_MAX_LENGTH = 300;
     public static final int CLIPBOARD_TEXT_MAX_LENGTH = 4093;
-    public static final int INJECT_TEXT_MAX_LENGTH = 300;
     private static final int RAW_BUFFER_SIZE = 1024;
 
     private final byte[] rawBuffer = new byte[RAW_BUFFER_SIZE];

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

@@ -36,7 +36,10 @@ public final class Device {
      */
     private final int layerStack;
 
-    private final boolean supportsInputEvents;
+    /**
+     * The FLAG_PRESENTATION from the DisplayInfo
+     */
+    private final boolean isPresentationDisplay;
 
     public Device(Options options) {
         displayId = options.getDisplayId();
@@ -50,6 +53,7 @@ public final class Device {
 
         screenInfo = ScreenInfo.computeScreenInfo(displayInfo, options.getCrop(), options.getMaxSize(), options.getLockedVideoOrientation());
         layerStack = displayInfo.getLayerStack();
+        isPresentationDisplay = (displayInfoFlags & DisplayInfo.FLAG_PRESENTATION) != 0;
 
         registerRotationWatcher(new IRotationWatcher.Stub() {
             @Override
@@ -63,16 +67,14 @@ public final class Device {
                     }
                 }
             }
-        }, displayId);
+        });
 
         if ((displayInfoFlags & DisplayInfo.FLAG_SUPPORTS_PROTECTED_BUFFERS) == 0) {
             Ln.w("Display doesn't have FLAG_SUPPORTS_PROTECTED_BUFFERS flag, mirroring can be restricted");
         }
 
-        // main display or any display on Android >= Q
+        if (!supportsInputEvents()) {
-        supportsInputEvents = displayId == 0 || Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q;
+            Ln.w("Input events are not supported for displays with FLAG_PRESENTATION enabled for devices with API lower than 29");
-        if (!supportsInputEvents) {
-            Ln.w("Input events are not supported for secondary displays before Android 10");
         }
     }
 
@@ -114,7 +116,10 @@ public final class Device {
     }
 
     public boolean supportsInputEvents() {
-        return supportsInputEvents;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            return true;
+        }
+        return !isPresentationDisplay;
     }
 
     public boolean injectInputEvent(InputEvent inputEvent, int mode) {
@@ -133,8 +138,8 @@ public final class Device {
         return serviceManager.getPowerManager().isScreenOn();
     }
 
-    public void registerRotationWatcher(IRotationWatcher rotationWatcher, int displayId) {
+    public void registerRotationWatcher(IRotationWatcher rotationWatcher) {
-        serviceManager.getWindowManager().registerRotationWatcher(rotationWatcher, displayId);
+        serviceManager.getWindowManager().registerRotationWatcher(rotationWatcher);
     }
 
     public synchronized void setRotationListener(RotationListener rotationListener) {

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

@@ -8,6 +8,7 @@ public final class DisplayInfo {
     private final int flags;
 
     public static final int FLAG_SUPPORTS_PROTECTED_BUFFERS = 0x00000001;
+    public static final int FLAG_PRESENTATION = 0x00000008;
 
     public DisplayInfo(int displayId, Size size, int rotation, int layerStack, int flags) {
         this.displayId = displayId;

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

@@ -27,13 +27,21 @@ public class ScreenEncoder implements Device.RotationListener {
 
     private int bitRate;
     private int maxFps;
+    private int lockedVideoOrientation;
+    private int iFrameInterval;
     private boolean sendFrameMeta;
     private long ptsOrigin;
 
-    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps) {
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, int lockedVideoOrientation, int iFrameInterval) {
         this.sendFrameMeta = sendFrameMeta;
         this.bitRate = bitRate;
         this.maxFps = maxFps;
+        this.lockedVideoOrientation = lockedVideoOrientation;
+        this.iFrameInterval = iFrameInterval;
+    }
+
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, int lockedVideoOrientation) {
+        this(sendFrameMeta, bitRate, maxFps, lockedVideoOrientation, DEFAULT_I_FRAME_INTERVAL);
     }
 
     @Override
@@ -49,7 +57,7 @@ public class ScreenEncoder implements Device.RotationListener {
         Workarounds.prepareMainLooper();
         Workarounds.fillAppInfo();
 
-        MediaFormat format = createFormat(bitRate, maxFps, DEFAULT_I_FRAME_INTERVAL);
+        MediaFormat format = createFormat(bitRate, maxFps, iFrameInterval);
         device.setRotationListener(this);
         boolean alive;
         try {
@@ -136,12 +144,12 @@ public class ScreenEncoder implements Device.RotationListener {
     }
 
     private static MediaCodec createCodec() throws IOException {
-        return MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
+        return MediaCodec.createEncoderByType("video/avc");
     }
 
     private static MediaFormat createFormat(int bitRate, int maxFps, int iFrameInterval) {
         MediaFormat format = new MediaFormat();
-        format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_AVC);
+        format.setString(MediaFormat.KEY_MIME, "video/avc");
         format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
         // 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);

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

@@ -20,7 +20,8 @@ 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(), options.getMaxFps());
+            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(),
+                    options.getLockedVideoOrientation());
 
             if (options.getControl()) {
                 Controller controller = new Controller(device, connection);

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

@@ -28,7 +28,7 @@ public final class Workarounds {
         Looper.prepareMainLooper();
     }
 
-    @SuppressLint("PrivateApi,DiscouragedPrivateApi")
+    @SuppressLint("PrivateApi")
     public static void fillAppInfo() {
         try {
             // ActivityThread activityThread = new ActivityThread();

server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java

@@ -53,7 +53,8 @@ public final class InputManager {
             method.invoke(inputEvent, displayId);
             return true;
         } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
-            Ln.e("Cannot associate a display id to the input event", e);
+            // just a warning, it might happen on old devices
+            Ln.w("Cannot associate a display id to the input event");
             return false;
         }
     }

server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java

@@ -6,7 +6,7 @@ import android.os.IInterface;
 
 import java.lang.reflect.Method;
 
-@SuppressLint("PrivateApi,DiscouragedPrivateApi")
+@SuppressLint("PrivateApi")
 public final class ServiceManager {
     private final Method getServiceMethod;
 

server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java

@@ -93,13 +93,13 @@ public final class WindowManager {
         }
     }
 
-    public void registerRotationWatcher(IRotationWatcher rotationWatcher, int displayId) {
+    public void registerRotationWatcher(IRotationWatcher rotationWatcher) {
         try {
             Class<?> cls = manager.getClass();
             try {
                 // 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, displayId);
+                cls.getMethod("watchRotation", IRotationWatcher.class, int.class).invoke(manager, rotationWatcher, 0);
             } catch (NoSuchMethodException e) {
                 // old version
                 cls.getMethod("watchRotation", IRotationWatcher.class).invoke(manager, rotationWatcher);

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

@@ -66,7 +66,7 @@ public class ControlMessageReaderTest {
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         DataOutputStream dos = new DataOutputStream(bos);
         dos.writeByte(ControlMessage.TYPE_INJECT_TEXT);
-        byte[] text = new byte[ControlMessageReader.INJECT_TEXT_MAX_LENGTH];
+        byte[] text = new byte[ControlMessageReader.TEXT_MAX_LENGTH];
         Arrays.fill(text, (byte) 'a');
         dos.writeShort(text.length);
         dos.write(text);