Add --scale, --position-x-offset, --position-y-offset and --rotation-offset

app/src/cli.c

@@ -93,6 +93,10 @@ enum {
     OPT_DISPLAY_ORIENTATION,
     OPT_RECORD_ORIENTATION,
     OPT_ORIENTATION,
+    OPT_ROTATION_OFFSET,
+    OPT_SCALE,
+    OPT_POSITION_X_OFFSET,
+    OPT_POSITION_Y_OFFSET,
 };
 
 struct sc_option {
@@ -837,6 +841,36 @@ static const struct sc_option options[] = {
         .text = "Set the initial window height.\n"
                 "Default is 0 (automatic).",
     },
+    {
+        .longopt_id = OPT_ROTATION_OFFSET,
+        .longopt = "rotation-offset",
+        .argdesc = "value",
+        .text = "Set the display rotation offset in degrees.\n"
+                "Positive values rotate clockwise, negative values "
+                "rotate counter-clockwise.\n"
+                "Default is 0 (automatic).",
+    },
+    {
+        .longopt_id = OPT_SCALE,
+        .longopt = "scale",
+        .argdesc = "value",
+        .text = "Set the display scale in integer percentage.\n"
+                "Default is 100 (automatic).",
+    },
+    {
+        .longopt_id = OPT_POSITION_X_OFFSET,
+        .longopt = "position-x-offset",
+        .argdesc = "value",
+        .text = "Set the display horizontal position offset.\n"
+                "Default is 0 (automatic).",
+    },
+    {
+        .longopt_id = OPT_POSITION_Y_OFFSET,
+        .longopt = "position-y-offset",
+        .argdesc = "value",
+        .text = "Set the display vertical position offset.\n"
+                "Default is 0 (automatic).",
+    },
 };
 
 static const struct sc_shortcut shortcuts[] = {
@@ -1937,6 +1971,32 @@ parse_pause_on_exit(const char *s, enum sc_pause_on_exit *pause_on_exit) {
 
 }
 
+static bool
+parse_rotation_offset(const char *s, int16_t *rotation_offset) {
+    long value;
+    bool ok = parse_integer_arg(s, &value, false, -360, 360,
+                                "display rotation offset");
+    if (!ok) {
+        return false;
+    }
+
+    *rotation_offset = (int16_t) value;
+    return true;
+}
+
+static bool
+parse_scale(const char *s, uint16_t *scale) {
+    long value;
+    bool ok = parse_integer_arg(s, &value, false, 1, 1000,
+                                "display scale");
+    if (!ok) {
+        return false;
+    }
+
+    *scale = (uint16_t) value;
+    return true;
+}
+
 static bool
 parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                        const char *optstring, const struct option *longopts) {
@@ -2359,6 +2419,26 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case OPT_CAMERA_HIGH_SPEED:
                 opts->camera_high_speed = true;
                 break;
+            case OPT_ROTATION_OFFSET:
+                if (!parse_rotation_offset(optarg, &opts->rotation_offset)) {
+                    return false;
+                }
+                break;
+            case OPT_SCALE:
+                if (!parse_scale(optarg, &opts->scale)) {
+                    return false;
+                }
+                break;
+            case OPT_POSITION_X_OFFSET:
+                if (!parse_window_position(optarg, &opts->position_x_offset)) {
+                    return false;
+                }
+                break;
+            case OPT_POSITION_Y_OFFSET:
+                if (!parse_window_position(optarg, &opts->position_y_offset)) {
+                    return false;
+                }
+                break;
             default:
                 // getopt prints the error message on stderr
                 return false;

app/src/coords.h

@@ -21,4 +21,10 @@ struct sc_position {
     struct sc_point point;
 };
 
+struct sc_transform {
+    int16_t rotation;
+    uint16_t scale;
+    struct sc_point position;
+};
+
 #endif

app/src/display.c

@@ -234,7 +234,7 @@ sc_display_update_texture(struct sc_display *display, const AVFrame *frame) {
 
 enum sc_display_result
 sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
-                  enum sc_orientation orientation) {
+                  enum sc_orientation orientation, struct sc_transform *transform_offsets) {
     SDL_RenderClear(display->renderer);
 
     if (display->pending.flags) {
@@ -247,37 +247,46 @@ sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
     SDL_Renderer *renderer = display->renderer;
     SDL_Texture *texture = display->texture;
 
-    if (orientation == SC_ORIENTATION_0) {
-        int ret = SDL_RenderCopy(renderer, texture, NULL, geometry);
-        if (ret) {
-            LOGE("Could not render texture: %s", SDL_GetError());
-            return SC_DISPLAY_RESULT_ERROR;
-        }
+    int16_t rotation_offset = transform_offsets->rotation;
+    if (rotation_offset < 0) {
+        rotation_offset = rotation_offset + 360;
+    }
+
+    unsigned cw_rotation = sc_orientation_get_rotation(orientation);
+    double angle = (90 * cw_rotation) + rotation_offset;
+
+    const SDL_Rect *dstrect = NULL;
+    SDL_Rect rect;
+
+    rect.x = geometry->x + transform_offsets->position.x;
+    rect.y = geometry->y + transform_offsets->position.y;
+
+    if (transform_offsets->scale != 100) {
+        rect.w = geometry->w * transform_offsets->scale / 100;
+        rect.h = geometry->h * transform_offsets->scale / 100;
     } else {
-        unsigned cw_rotation = sc_orientation_get_rotation(orientation);
-        double angle = 90 * cw_rotation;
-
-        const SDL_Rect *dstrect = NULL;
-        SDL_Rect rect;
-        if (sc_orientation_is_swap(orientation)) {
-            rect.x = geometry->x + (geometry->w - geometry->h) / 2;
-            rect.y = geometry->y + (geometry->h - geometry->w) / 2;
-            rect.w = geometry->h;
-            rect.h = geometry->w;
-            dstrect = &rect;
-        } else {
-            dstrect = geometry;
-        }
+        rect.w = geometry->w;
+        rect.h = geometry->h;
+    }
 
-        SDL_RendererFlip flip = sc_orientation_is_mirror(orientation)
-                              ? SDL_FLIP_HORIZONTAL : 0;
+    if (sc_orientation_is_swap(orientation)) {
+        rect.x = rect.x + (rect.w - rect.h) / 2;
+        rect.y = rect.y + (rect.h - rect.w) / 2;
+        int width = rect.w;
+        rect.w = rect.h;
+        rect.h = width;
+    }
 
-        int ret = SDL_RenderCopyEx(renderer, texture, NULL, dstrect, angle,
-                                   NULL, flip);
-        if (ret) {
-            LOGE("Could not render texture: %s", SDL_GetError());
-            return SC_DISPLAY_RESULT_ERROR;
-        }
+    dstrect = &rect;
+
+    SDL_RendererFlip flip = sc_orientation_is_mirror(orientation)
+                            ? SDL_FLIP_HORIZONTAL : 0;
+
+    int ret = SDL_RenderCopyEx(renderer, texture, NULL, dstrect, angle,
+                                NULL, flip);
+    if (ret) {
+        LOGE("Could not render texture: %s", SDL_GetError());
+        return SC_DISPLAY_RESULT_ERROR;
     }
 
     SDL_RenderPresent(display->renderer);

app/src/display.h

@@ -55,6 +55,6 @@ sc_display_update_texture(struct sc_display *display, const AVFrame *frame);
 
 enum sc_display_result
 sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
-                  enum sc_orientation orientation);
+                  enum sc_orientation orientation, struct sc_transform *transform_offsets);
 
 #endif

app/src/options.c

@@ -41,6 +41,10 @@ const struct scrcpy_options scrcpy_options_default = {
     .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
     .display_orientation = SC_ORIENTATION_0,
     .record_orientation = SC_ORIENTATION_0,
+    .rotation_offset = 0,
+    .scale = 100,
+    .position_x_offset = 0,
+    .position_y_offset = 0,
     .window_x = SC_WINDOW_POSITION_UNDEFINED,
     .window_y = SC_WINDOW_POSITION_UNDEFINED,
     .window_width = 0,

app/src/options.h

@@ -221,6 +221,10 @@ struct scrcpy_options {
     enum sc_lock_video_orientation lock_video_orientation;
     enum sc_orientation display_orientation;
     enum sc_orientation record_orientation;
+    int16_t rotation_offset;
+    uint16_t scale;
+    int16_t position_x_offset;
+    int16_t position_y_offset;
     int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
     int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
     uint16_t window_width;

app/src/scrcpy.c

@@ -702,6 +702,10 @@ scrcpy(struct scrcpy_options *options) {
             .window_height = options->window_height,
             .window_borderless = options->window_borderless,
             .orientation = options->display_orientation,
+            .rotation_offset = options->rotation_offset,
+            .scale = options->scale,
+            .position_x_offset = options->position_x_offset,
+            .position_y_offset = options->position_y_offset,
             .mipmaps = options->mipmaps,
             .fullscreen = options->fullscreen,
             .start_fps_counter = options->start_fps_counter,

app/src/screen.c

@@ -3,6 +3,7 @@
 #include <assert.h>
 #include <string.h>
 #include <SDL2/SDL.h>
+#include <math.h>
 
 #include "events.h"
 #include "icon.h"
@@ -251,7 +252,7 @@ sc_screen_render(struct sc_screen *screen, bool update_content_rect) {
     }
 
     enum sc_display_result res =
-        sc_display_render(&screen->display, &screen->rect, screen->orientation);
+        sc_display_render(&screen->display, &screen->rect, screen->orientation, &screen->transform_offsets);
     (void) res; // any error already logged
 }
 
@@ -380,6 +381,10 @@ sc_screen_init(struct sc_screen *screen,
     }
 
     screen->orientation = params->orientation;
+    screen->transform_offsets.rotation = params->rotation_offset;
+    screen->transform_offsets.scale = params->scale;
+    screen->transform_offsets.position.x = params->position_x_offset;
+    screen->transform_offsets.position.y = params->position_y_offset;
     if (screen->orientation != SC_ORIENTATION_0) {
         LOGI("Initial display orientation set to %s",
              sc_orientation_get_name(screen->orientation));
@@ -841,57 +846,103 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
     return true;
 }
 
+static void
+sc_rotate_point(struct sc_point *point,
+                struct sc_point *pivot,
+                int16_t angle_in_degrees) {
+    const double deg_to_rad = M_PI / 180.0;
+    float32_t angle_in_radians = (float32_t)angle_in_degrees * deg_to_rad;
+    float32_t cosine = (float32_t)cos(angle_in_radians);
+    float32_t sine = (float32_t)sin(angle_in_radians);
+
+    int32_t x = point->x;
+    int32_t y = point->y;
+    int32_t pivot_x = pivot->x;
+    int32_t pivot_y = pivot->y;
+
+    point->x = (int32_t)(((x - pivot_x) * cosine) + ((y - pivot_y) * -sine) + pivot_x);
+    point->y = (int32_t)(((x - pivot_x) * sine) + ((y - pivot_y) * cosine) + pivot_y);
+}
+
 struct sc_point
 sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen,
                                            int32_t x, int32_t y) {
     enum sc_orientation orientation = screen->orientation;
 
     int32_t w = screen->content_size.width;
     int32_t h = screen->content_size.height;
+    int32_t w_half = w >> 1;
+    int32_t h_half = h >> 1;
+    struct sc_point pivot = {
+        .x = w_half,
+        .y = h_half,
+    };
+    int8_t flip_factor = -1;
+    float32_t scale_factor = 100.0 / screen->transform_offsets.scale;
 
     // screen->rect must be initialized to avoid a division by zero
     assert(screen->rect.w && screen->rect.h);
 
-    x = (int64_t) (x - screen->rect.x) * w / screen->rect.w;
-    y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;
+    float32_t w_factor = w / (float32_t)screen->rect.w;
+    float32_t h_factor = h / (float32_t)screen->rect.h;
+    x = (int64_t) (x - screen->rect.x) * w_factor;
+    y = (int64_t) (y - screen->rect.y) * h_factor;
+    int32_t x_offset = screen->transform_offsets.position.x * w_factor;
+    int32_t y_offset = screen->transform_offsets.position.y * h_factor;
 
     struct sc_point result;
     switch (orientation) {
         case SC_ORIENTATION_0:
-            result.x = x;
-            result.y = y;
+            result.x = (x - x_offset) * scale_factor;
+            result.y = (y - y_offset) * scale_factor;
             break;
         case SC_ORIENTATION_90:
-            result.x = y;
-            result.y = w - x;
+            result.x = (y - y_offset) * scale_factor;
+            result.y = w + ((x_offset - x) * scale_factor);
+            pivot.x = h_half;
+            pivot.y = w_half;
             break;
         case SC_ORIENTATION_180:
-            result.x = w - x;
-            result.y = h - y;
+            result.x = w + ((x_offset - x) * scale_factor);
+            result.y = h + ((y_offset - y) * scale_factor);
             break;
         case SC_ORIENTATION_270:
-            result.x = h - y;
-            result.y = x;
+            result.x = h + ((y_offset - y) * scale_factor);
+            result.y = (x - x_offset) * scale_factor;
+            pivot.x = h_half;
+            pivot.y = w_half;
             break;
         case SC_ORIENTATION_FLIP_0:
-            result.x = w - x;
-            result.y = y;
+            result.x = w + ((x_offset - x) * scale_factor);
+            result.y = (y - y_offset) * scale_factor;
+            flip_factor = 1;
             break;
         case SC_ORIENTATION_FLIP_90:
-            result.x = h - y;
-            result.y = w - x;
+            result.x = h + ((y_offset - y) * scale_factor);
+            result.y = w + ((x_offset - x) * scale_factor);
+            pivot.x = h_half;
+            pivot.y = w_half;
+            flip_factor = 1;
             break;
         case SC_ORIENTATION_FLIP_180:
-            result.x = x;
-            result.y = h - y;
+            result.x = (x - x_offset) * scale_factor;
+            result.y = h + ((y_offset - y) * scale_factor);
+            flip_factor = 1;
             break;
         default:
             assert(orientation == SC_ORIENTATION_FLIP_270);
-            result.x = y;
-            result.y = x;
+            result.x = (y - y_offset) * scale_factor;
+            result.y = (x - x_offset) * scale_factor;
+            pivot.x = h_half;
+            pivot.y = w_half;
+            flip_factor = 1;
             break;
     }
 
+    if (screen->transform_offsets.rotation != 0) {
+        sc_rotate_point(&result, &pivot, flip_factor * screen->transform_offsets.rotation);
+    }
+
     return result;
 }