Expose socket interruption

On Linux, socket functions are unblocked by shutdown(), but on Windows
they are unblocked by closesocket().

Expose net_interrupt() and net_close() to abstract these differences:
 - net_interrupt() calls shutdown() on Linux and closesocket() on
   Windows (if not already called);
 - net_close() calls close() on Linux and closesocket() on Windows (if
   not already called).

This simplifies the server code, and prevents a data race on close
(reported by TSAN) on Linux (but does not fix it on Windows):

    WARNING: ThreadSanitizer: data race (pid=836124)
      Write of size 8 at 0x7ba0000000d0 by main thread:
        #0 close ../../../../src/libsanitizer/tsan/tsan_interceptors_posix.cpp:1690 (libtsan.so.0+0x359d8)
        #1 net_close ../app/src/util/net.c:211 (scrcpy+0x1c76b)
        #2 close_socket ../app/src/server.c:330 (scrcpy+0x19442)
        #3 server_stop ../app/src/server.c:522 (scrcpy+0x19e33)
        #4 scrcpy ../app/src/scrcpy.c:532 (scrcpy+0x156fc)
        #5 main ../app/src/main.c:92 (scrcpy+0x622a)

      Previous read of size 8 at 0x7ba0000000d0 by thread T6:
        #0 recv ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:6603 (libtsan.so.0+0x4f4a6)
        #1 net_recv ../app/src/util/net.c:167 (scrcpy+0x1c5a7)
        #2 run_receiver ../app/src/receiver.c:76 (scrcpy+0x12819)
        #3 <null> <null> (libSDL2-2.0.so.0+0x84f40)

app/meson.build

@@ -16,7 +16,6 @@ src = [
     'src/keyboard_inject.c',
     'src/mouse_inject.c',
     'src/opengl.c',
-    'src/options.c',
     'src/receiver.c',
     'src/recorder.c',
     'src/scrcpy.c',
@@ -185,7 +184,6 @@ if get_option('buildtype') == 'debug'
         ['test_cli', [
             'tests/test_cli.c',
             'src/cli.c',
-            'src/options.c',
             'src/util/str_util.c',
         ]],
         ['test_clock', [

app/src/aoa_hid.h

@@ -6,6 +6,7 @@
 
 #include <libusb-1.0/libusb.h>
 
+#include "scrcpy.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
 #include "util/tick.h"

app/src/cli.c

@@ -6,7 +6,7 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#include "options.h"
+#include "scrcpy.h"
 #include "util/log.h"
 #include "util/str_util.h"
 

app/src/cli.h

@@ -5,7 +5,7 @@
 
 #include <stdbool.h>
 
-#include "options.h"
+#include "scrcpy.h"
 
 struct scrcpy_cli_args {
     struct scrcpy_options opts;

app/src/clock.h

@@ -26,7 +26,7 @@ struct sc_clock_point {
  * array.
  *
  * To estimate the slope, it splits the last SC_CLOCK_RANGE points into two
- * sets of SC_CLOCK_RANGE/2 points, and computes their centroid ("average
+ * sets of SC_CLOCK_RANGE/2 points, and compute their centroid ("average
  * point"). The slope of the estimated affine function is that of the line
  * passing through these two points.
  *

app/src/control_msg.c

@@ -56,7 +56,7 @@ static const char *const screen_power_mode_labels[] = {
 };
 
 static void
-write_position(uint8_t *buf, const struct sc_position *position) {
+write_position(uint8_t *buf, const struct position *position) {
     buffer_write32be(&buf[0], position->point.x);
     buffer_write32be(&buf[4], position->point.y);
     buffer_write16be(&buf[8], position->screen_size.width);

app/src/control_msg.h

@@ -57,11 +57,11 @@ struct control_msg {
             enum android_motionevent_action action;
             enum android_motionevent_buttons buttons;
             uint64_t pointer_id;
-            struct sc_position position;
+            struct position position;
             float pressure;
         } inject_touch_event;
         struct {
-            struct sc_position position;
+            struct position position;
             int32_t hscroll;
             int32_t vscroll;
         } inject_scroll_event;

app/src/coords.h

@@ -3,22 +3,22 @@
 
 #include <stdint.h>
 
-struct sc_size {
+struct size {
     uint16_t width;
     uint16_t height;
 };
 
-struct sc_point {
+struct point {
     int32_t x;
     int32_t y;
 };
 
-struct sc_position {
+struct position {
     // The video screen size may be different from the real device screen size,
     // so store to which size the absolute position apply, to scale it
     // accordingly.
-    struct sc_size screen_size;
-    struct sc_point point;
+    struct size screen_size;
+    struct point point;
 };
 
 #endif

app/src/events.h

@@ -1,5 +1,2 @@
-#define EVENT_NEW_FRAME                 SDL_USEREVENT
-#define EVENT_STREAM_STOPPED           (SDL_USEREVENT + 1)
-#define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
-#define EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
-#define EVENT_SERVER_DISCONNECTED      (SDL_USEREVENT + 4)
+#define EVENT_NEW_FRAME       SDL_USEREVENT
+#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 1)

app/src/input_manager.c

@@ -332,7 +332,7 @@ input_manager_process_text_input(struct input_manager *im,
 static bool
 simulate_virtual_finger(struct input_manager *im,
                         enum android_motionevent_action action,
-                        struct sc_point point) {
+                        struct point point) {
     bool up = action == AMOTION_EVENT_ACTION_UP;
 
     struct control_msg msg;
@@ -352,8 +352,8 @@ simulate_virtual_finger(struct input_manager *im,
     return true;
 }
 
-static struct sc_point
-inverse_point(struct sc_point point, struct sc_size size) {
+static struct point
+inverse_point(struct point point, struct size size) {
     point.x = size.width - point.x;
     point.y = size.height - point.y;
     return point;
@@ -545,10 +545,10 @@ input_manager_process_mouse_motion(struct input_manager *im,
     im->mp->ops->process_mouse_motion(im->mp, event);
 
     if (im->vfinger_down) {
-        struct sc_point mouse =
+        struct point mouse =
             screen_convert_window_to_frame_coords(im->screen, event->x,
                                                   event->y);
-        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
+        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
         simulate_virtual_finger(im, AMOTION_EVENT_ACTION_MOVE, vfinger);
     }
 }
@@ -630,10 +630,10 @@ input_manager_process_mouse_button(struct input_manager *im,
 #define CTRL_PRESSED (SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL))
     if ((down && !im->vfinger_down && CTRL_PRESSED)
             || (!down && im->vfinger_down)) {
-        struct sc_point mouse =
+        struct point mouse =
             screen_convert_window_to_frame_coords(im->screen, event->x,
                                                               event->y);
-        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
+        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
         enum android_motionevent_action action = down
                                                ? AMOTION_EVENT_ACTION_DOWN
                                                : AMOTION_EVENT_ACTION_UP;

app/src/input_manager.h

@@ -9,7 +9,7 @@
 
 #include "controller.h"
 #include "fps_counter.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "screen.h"
 #include "trait/key_processor.h"
 #include "trait/mouse_processor.h"

app/src/keyboard_inject.h

@@ -6,7 +6,7 @@
 #include <stdbool.h>
 
 #include "controller.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "trait/key_processor.h"
 
 struct sc_keyboard_inject {

app/src/main.c

@@ -1,3 +1,5 @@
+#include "scrcpy.h"
+
 #include "common.h"
 
 #include <assert.h>
@@ -11,8 +13,6 @@
 #include <SDL2/SDL.h>
 
 #include "cli.h"
-#include "options.h"
-#include "scrcpy.h"
 #include "util/log.h"
 
 static void
@@ -48,7 +48,7 @@ main(int argc, char *argv[]) {
 #endif
 
     struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
         .help = false,
         .version = false,
     };

app/src/mouse_inject.c

@@ -125,7 +125,7 @@ convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
     int mouse_y;
     SDL_GetMouseState(&mouse_x, &mouse_y);
 
-    struct sc_position position = {
+    struct position position = {
         .screen_size = screen->frame_size,
         .point = screen_convert_window_to_frame_coords(screen,
                                                        mouse_x, mouse_y),

app/src/mouse_inject.h

@@ -6,6 +6,7 @@
 #include <stdbool.h>
 
 #include "controller.h"
+#include "scrcpy.h"
 #include "screen.h"
 #include "trait/mouse_processor.h"
 

app/src/options.c

@@ -1,54 +0,0 @@
-#include "options.h"
-
-const struct scrcpy_options scrcpy_options_default = {
-    .serial = NULL,
-    .crop = NULL,
-    .record_filename = NULL,
-    .window_title = NULL,
-    .push_target = NULL,
-    .render_driver = NULL,
-    .codec_options = NULL,
-    .encoder_name = NULL,
-#ifdef HAVE_V4L2
-    .v4l2_device = NULL,
-#endif
-    .log_level = SC_LOG_LEVEL_INFO,
-    .record_format = SC_RECORD_FORMAT_AUTO,
-    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
-    .port_range = {
-        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
-        .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
-    },
-    .shortcut_mods = {
-        .data = {SC_MOD_LALT, SC_MOD_LSUPER},
-        .count = 2,
-    },
-    .max_size = 0,
-    .bit_rate = DEFAULT_BIT_RATE,
-    .max_fps = 0,
-    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
-    .rotation = 0,
-    .window_x = SC_WINDOW_POSITION_UNDEFINED,
-    .window_y = SC_WINDOW_POSITION_UNDEFINED,
-    .window_width = 0,
-    .window_height = 0,
-    .display_id = 0,
-    .display_buffer = 0,
-    .v4l2_buffer = 0,
-    .show_touches = false,
-    .fullscreen = false,
-    .always_on_top = false,
-    .control = true,
-    .display = true,
-    .turn_screen_off = false,
-    .prefer_text = false,
-    .window_borderless = false,
-    .mipmaps = true,
-    .stay_awake = false,
-    .force_adb_forward = false,
-    .disable_screensaver = false,
-    .forward_key_repeat = true,
-    .forward_all_clicks = false,
-    .legacy_paste = false,
-    .power_off_on_close = false,
-};

app/src/options.h

@@ -1,113 +0,0 @@
-#ifndef SCRCPY_OPTIONS_H
-#define SCRCPY_OPTIONS_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "util/tick.h"
-
-enum sc_log_level {
-    SC_LOG_LEVEL_VERBOSE,
-    SC_LOG_LEVEL_DEBUG,
-    SC_LOG_LEVEL_INFO,
-    SC_LOG_LEVEL_WARN,
-    SC_LOG_LEVEL_ERROR,
-};
-
-enum sc_record_format {
-    SC_RECORD_FORMAT_AUTO,
-    SC_RECORD_FORMAT_MP4,
-    SC_RECORD_FORMAT_MKV,
-};
-
-enum sc_lock_video_orientation {
-    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
-    // lock the current orientation when scrcpy starts
-    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
-    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
-    SC_LOCK_VIDEO_ORIENTATION_1,
-    SC_LOCK_VIDEO_ORIENTATION_2,
-    SC_LOCK_VIDEO_ORIENTATION_3,
-};
-
-enum sc_keyboard_input_mode {
-    SC_KEYBOARD_INPUT_MODE_INJECT,
-    SC_KEYBOARD_INPUT_MODE_HID,
-};
-
-#define SC_MAX_SHORTCUT_MODS 8
-
-enum sc_shortcut_mod {
-    SC_MOD_LCTRL = 1 << 0,
-    SC_MOD_RCTRL = 1 << 1,
-    SC_MOD_LALT = 1 << 2,
-    SC_MOD_RALT = 1 << 3,
-    SC_MOD_LSUPER = 1 << 4,
-    SC_MOD_RSUPER = 1 << 5,
-};
-
-struct sc_shortcut_mods {
-    unsigned data[SC_MAX_SHORTCUT_MODS];
-    unsigned count;
-};
-
-struct sc_port_range {
-    uint16_t first;
-    uint16_t last;
-};
-
-#define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
-
-struct scrcpy_options {
-    const char *serial;
-    const char *crop;
-    const char *record_filename;
-    const char *window_title;
-    const char *push_target;
-    const char *render_driver;
-    const char *codec_options;
-    const char *encoder_name;
-#ifdef HAVE_V4L2
-    const char *v4l2_device;
-#endif
-    enum sc_log_level log_level;
-    enum sc_record_format record_format;
-    enum sc_keyboard_input_mode keyboard_input_mode;
-    struct sc_port_range port_range;
-    struct sc_shortcut_mods shortcut_mods;
-    uint16_t max_size;
-    uint32_t bit_rate;
-    uint16_t max_fps;
-    enum sc_lock_video_orientation lock_video_orientation;
-    uint8_t rotation;
-    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
-    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
-    uint16_t window_width;
-    uint16_t window_height;
-    uint32_t display_id;
-    sc_tick display_buffer;
-    sc_tick v4l2_buffer;
-    bool show_touches;
-    bool fullscreen;
-    bool always_on_top;
-    bool control;
-    bool display;
-    bool turn_screen_off;
-    bool prefer_text;
-    bool window_borderless;
-    bool mipmaps;
-    bool stay_awake;
-    bool force_adb_forward;
-    bool disable_screensaver;
-    bool forward_key_repeat;
-    bool forward_all_clicks;
-    bool legacy_paste;
-    bool power_off_on_close;
-};
-
-extern const struct scrcpy_options scrcpy_options_default;
-
-#endif

app/src/recorder.c

@@ -372,7 +372,7 @@ bool
 recorder_init(struct recorder *recorder,
               const char *filename,
               enum sc_record_format format,
-              struct sc_size declared_frame_size) {
+              struct size declared_frame_size) {
     recorder->filename = strdup(filename);
     if (!recorder->filename) {
         LOGE("Could not strdup filename");

app/src/recorder.h

@@ -7,7 +7,7 @@
 #include <libavformat/avformat.h>
 
 #include "coords.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "trait/packet_sink.h"
 #include "util/queue.h"
 #include "util/thread.h"
@@ -25,7 +25,7 @@ struct recorder {
     char *filename;
     enum sc_record_format format;
     AVFormatContext *ctx;
-    struct sc_size declared_frame_size;
+    struct size declared_frame_size;
     bool header_written;
 
     sc_thread thread;
@@ -44,7 +44,7 @@ struct recorder {
 
 bool
 recorder_init(struct recorder *recorder, const char *filename,
-              enum sc_record_format format, struct sc_size declared_frame_size);
+              enum sc_record_format format, struct size declared_frame_size);
 
 void
 recorder_destroy(struct recorder *recorder);

app/src/scrcpy.c

@@ -57,22 +57,12 @@ struct scrcpy {
     struct input_manager input_manager;
 };
 
-static inline void
-push_event(uint32_t type, const char *name) {
-    SDL_Event event;
-    event.type = type;
-    int ret = SDL_PushEvent(&event);
-    if (ret < 0) {
-        LOGE("Could not post %s event: %s", name, SDL_GetError());
-        // What could we do?
-    }
-}
-#define PUSH_EVENT(TYPE) push_event(TYPE, # TYPE)
-
 #ifdef _WIN32
 BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
     if (ctrl_type == CTRL_C_EVENT) {
-        PUSH_EVENT(SDL_QUIT);
+        SDL_Event event;
+        event.type = SDL_QUIT;
+        SDL_PushEvent(&event);
         return TRUE;
     }
     return FALSE;
@@ -158,10 +148,6 @@ static enum event_result
 handle_event(struct scrcpy *s, const struct scrcpy_options *options,
              SDL_Event *event) {
     switch (event->type) {
-        case EVENT_SERVER_DISCONNECTED:
-            LOGD("Server disconnected");
-            // Do nothing, will be managed by the "stream stopped" event
-            break;
         case EVENT_STREAM_STOPPED:
             LOGD("Video stream stopped");
             return EVENT_RESULT_STOPPED_BY_EOS;
@@ -220,32 +206,6 @@ event_loop(struct scrcpy *s, const struct scrcpy_options *options) {
     return false;
 }
 
-static bool
-await_for_server(void) {
-    SDL_Event event;
-    while (SDL_WaitEvent(&event)) {
-        // Should never receive disconnected event before connected
-        assert(event.type != EVENT_SERVER_DISCONNECTED);
-
-        switch (event.type) {
-            case SDL_QUIT:
-                LOGD("User requested to quit");
-                return false;
-            case EVENT_SERVER_CONNECTION_FAILED:
-                LOGE("Server connection failed");
-                return false;
-            case EVENT_SERVER_CONNECTED:
-                LOGD("Server connected");
-                return true;
-            default:
-                break;
-        }
-    }
-
-    LOGE("SDL_WaitEvent() error: %s", SDL_GetError());
-    return false;
-}
-
 static SDL_LogPriority
 sdl_priority_from_av_level(int level) {
     switch (level) {
@@ -288,31 +248,9 @@ stream_on_eos(struct stream *stream, void *userdata) {
     (void) stream;
     (void) userdata;
 
-    PUSH_EVENT(EVENT_STREAM_STOPPED);
-}
-
-static void
-server_on_connection_failed(struct server *server, void *userdata) {
-    (void) server;
-    (void) userdata;
-
-    PUSH_EVENT(EVENT_SERVER_CONNECTION_FAILED);
-}
-
-static void
-server_on_connected(struct server *server, void *userdata) {
-    (void) server;
-    (void) userdata;
-
-    PUSH_EVENT(EVENT_SERVER_CONNECTED);
-}
-
-static void
-server_on_disconnected(struct server *server, void *userdata) {
-    (void) server;
-    (void) userdata;
-
-    PUSH_EVENT(EVENT_SERVER_DISCONNECTED);
+    SDL_Event stop_event;
+    stop_event.type = EVENT_STREAM_STOPPED;
+    SDL_PushEvent(&stop_event);
 }
 
 bool
@@ -320,6 +258,10 @@ scrcpy(struct scrcpy_options *options) {
     static struct scrcpy scrcpy;
     struct scrcpy *s = &scrcpy;
 
+    if (!server_init(&s->server)) {
+        return false;
+    }
+
     bool ret = false;
 
     bool server_started = false;
@@ -355,18 +297,7 @@ scrcpy(struct scrcpy_options *options) {
         .force_adb_forward = options->force_adb_forward,
         .power_off_on_close = options->power_off_on_close,
     };
-
-    static const struct server_callbacks cbs = {
-        .on_connection_failed = server_on_connection_failed,
-        .on_connected = server_on_connected,
-        .on_disconnected = server_on_disconnected,
-    };
-    if (!server_init(&s->server, &params, &cbs, NULL)) {
-        return false;
-    }
-
-    // TODO SDL_Init(SDL_INIT_EVENTS) before starting server
-    if (!server_start(&s->server)) {
+    if (!server_start(&s->server, &params)) {
         goto end;
     }
 
@@ -377,15 +308,15 @@ scrcpy(struct scrcpy_options *options) {
         goto end;
     }
 
-    // Await for server without blocking Ctrl+C handling
-    if (!await_for_server()) {
+    char device_name[DEVICE_NAME_FIELD_LENGTH];
+    struct size frame_size;
+
+    if (!server_connect_to(&s->server, device_name, &frame_size)) {
         goto end;
     }
 
-    struct server_info *info = &s->server.info;
-
     if (options->display && options->control) {
-        if (!file_handler_init(&s->file_handler, options->serial,
+        if (!file_handler_init(&s->file_handler, s->server.serial,
                                options->push_target)) {
             goto end;
         }
@@ -407,7 +338,7 @@ scrcpy(struct scrcpy_options *options) {
         if (!recorder_init(&s->recorder,
                            options->record_filename,
                            options->record_format,
-                           info->frame_size)) {
+                           frame_size)) {
             goto end;
         }
         rec = &s->recorder;
@@ -453,11 +384,11 @@ scrcpy(struct scrcpy_options *options) {
 
     if (options->display) {
         const char *window_title =
-            options->window_title ? options->window_title : info->device_name;
+            options->window_title ? options->window_title : device_name;
 
         struct screen_params screen_params = {
             .window_title = window_title,
-            .frame_size = info->frame_size,
+            .frame_size = frame_size,
             .always_on_top = options->always_on_top,
             .window_x = options->window_x,
             .window_y = options->window_y,
@@ -480,8 +411,8 @@ scrcpy(struct scrcpy_options *options) {
 
 #ifdef HAVE_V4L2
     if (options->v4l2_device) {
-        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device,
-                               info->frame_size, options->v4l2_buffer)) {
+        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device, frame_size,
+                               options->v4l2_buffer)) {
             goto end;
         }
 

app/src/scrcpy.h

@@ -4,7 +4,158 @@
 #include "common.h"
 
 #include <stdbool.h>
-#include "options.h"
+#include <stddef.h>
+#include <stdint.h>
+
+#include "util/tick.h"
+
+enum sc_log_level {
+    SC_LOG_LEVEL_VERBOSE,
+    SC_LOG_LEVEL_DEBUG,
+    SC_LOG_LEVEL_INFO,
+    SC_LOG_LEVEL_WARN,
+    SC_LOG_LEVEL_ERROR,
+};
+
+enum sc_record_format {
+    SC_RECORD_FORMAT_AUTO,
+    SC_RECORD_FORMAT_MP4,
+    SC_RECORD_FORMAT_MKV,
+};
+
+enum sc_lock_video_orientation {
+    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
+    // lock the current orientation when scrcpy starts
+    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
+    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
+    SC_LOCK_VIDEO_ORIENTATION_1,
+    SC_LOCK_VIDEO_ORIENTATION_2,
+    SC_LOCK_VIDEO_ORIENTATION_3,
+};
+
+enum sc_keyboard_input_mode {
+    SC_KEYBOARD_INPUT_MODE_INJECT,
+    SC_KEYBOARD_INPUT_MODE_HID,
+};
+
+#define SC_MAX_SHORTCUT_MODS 8
+
+enum sc_shortcut_mod {
+    SC_MOD_LCTRL = 1 << 0,
+    SC_MOD_RCTRL = 1 << 1,
+    SC_MOD_LALT = 1 << 2,
+    SC_MOD_RALT = 1 << 3,
+    SC_MOD_LSUPER = 1 << 4,
+    SC_MOD_RSUPER = 1 << 5,
+};
+
+struct sc_shortcut_mods {
+    unsigned data[SC_MAX_SHORTCUT_MODS];
+    unsigned count;
+};
+
+struct sc_port_range {
+    uint16_t first;
+    uint16_t last;
+};
+
+#define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
+
+struct scrcpy_options {
+    const char *serial;
+    const char *crop;
+    const char *record_filename;
+    const char *window_title;
+    const char *push_target;
+    const char *render_driver;
+    const char *codec_options;
+    const char *encoder_name;
+    const char *v4l2_device;
+    enum sc_log_level log_level;
+    enum sc_record_format record_format;
+    enum sc_keyboard_input_mode keyboard_input_mode;
+    struct sc_port_range port_range;
+    struct sc_shortcut_mods shortcut_mods;
+    uint16_t max_size;
+    uint32_t bit_rate;
+    uint16_t max_fps;
+    enum sc_lock_video_orientation lock_video_orientation;
+    uint8_t rotation;
+    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
+    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
+    uint16_t window_width;
+    uint16_t window_height;
+    uint32_t display_id;
+    sc_tick display_buffer;
+    sc_tick v4l2_buffer;
+    bool show_touches;
+    bool fullscreen;
+    bool always_on_top;
+    bool control;
+    bool display;
+    bool turn_screen_off;
+    bool prefer_text;
+    bool window_borderless;
+    bool mipmaps;
+    bool stay_awake;
+    bool force_adb_forward;
+    bool disable_screensaver;
+    bool forward_key_repeat;
+    bool forward_all_clicks;
+    bool legacy_paste;
+    bool power_off_on_close;
+};
+
+#define SCRCPY_OPTIONS_DEFAULT { \
+    .serial = NULL, \
+    .crop = NULL, \
+    .record_filename = NULL, \
+    .window_title = NULL, \
+    .push_target = NULL, \
+    .render_driver = NULL, \
+    .codec_options = NULL, \
+    .encoder_name = NULL, \
+    .v4l2_device = NULL, \
+    .log_level = SC_LOG_LEVEL_INFO, \
+    .record_format = SC_RECORD_FORMAT_AUTO, \
+    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT, \
+    .port_range = { \
+        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
+        .last = DEFAULT_LOCAL_PORT_RANGE_LAST, \
+    }, \
+    .shortcut_mods = { \
+        .data = {SC_MOD_LALT, SC_MOD_LSUPER}, \
+        .count = 2, \
+    }, \
+    .max_size = 0, \
+    .bit_rate = DEFAULT_BIT_RATE, \
+    .max_fps = 0, \
+    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED, \
+    .rotation = 0, \
+    .window_x = SC_WINDOW_POSITION_UNDEFINED, \
+    .window_y = SC_WINDOW_POSITION_UNDEFINED, \
+    .window_width = 0, \
+    .window_height = 0, \
+    .display_id = 0, \
+    .display_buffer = 0, \
+    .v4l2_buffer = 0, \
+    .show_touches = false, \
+    .fullscreen = false, \
+    .always_on_top = false, \
+    .control = true, \
+    .display = true, \
+    .turn_screen_off = false, \
+    .prefer_text = false, \
+    .window_borderless = false, \
+    .mipmaps = true, \
+    .stay_awake = false, \
+    .force_adb_forward = false, \
+    .disable_screensaver = false, \
+    .forward_key_repeat = true, \
+    .forward_all_clicks = false, \
+    .legacy_paste = false, \
+    .power_off_on_close = false, \
+}
 
 bool
 scrcpy(struct scrcpy_options *options);

app/src/screen.c

@@ -6,7 +6,7 @@
 
 #include "events.h"
 #include "icon.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "video_buffer.h"
 #include "util/log.h"
 
@@ -14,9 +14,9 @@
 
 #define DOWNCAST(SINK) container_of(SINK, struct screen, frame_sink)
 
-static inline struct sc_size
-get_rotated_size(struct sc_size size, int rotation) {
-    struct sc_size rotated_size;
+static inline struct size
+get_rotated_size(struct size size, int rotation) {
+    struct size rotated_size;
     if (rotation & 1) {
         rotated_size.width = size.height;
         rotated_size.height = size.width;
@@ -27,26 +27,26 @@ get_rotated_size(struct sc_size size, int rotation) {
     return rotated_size;
 }
 
-// get the window size in a struct sc_size
-static struct sc_size
+// get the window size in a struct size
+static struct size
 get_window_size(const struct screen *screen) {
     int width;
     int height;
     SDL_GetWindowSize(screen->window, &width, &height);
 
-    struct sc_size size;
+    struct size size;
     size.width = width;
     size.height = height;
     return size;
 }
 
-static struct sc_point
+static struct point
 get_window_position(const struct screen *screen) {
     int x;
     int y;
     SDL_GetWindowPosition(screen->window, &x, &y);
 
-    struct sc_point point;
+    struct point point;
     point.x = x;
     point.y = y;
     return point;
@@ -54,7 +54,7 @@ get_window_position(const struct screen *screen) {
 
 // set the window size to be applied when fullscreen is disabled
 static void
-set_window_size(struct screen *screen, struct sc_size new_size) {
+set_window_size(struct screen *screen, struct size new_size) {
     assert(!screen->fullscreen);
     assert(!screen->maximized);
     SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
@@ -62,7 +62,7 @@ set_window_size(struct screen *screen, struct sc_size new_size) {
 
 // get the preferred display bounds (i.e. the screen bounds with some margins)
 static bool
-get_preferred_display_bounds(struct sc_size *bounds) {
+get_preferred_display_bounds(struct size *bounds) {
     SDL_Rect rect;
 #ifdef SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
 # define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayUsableBounds((i), (r))
@@ -80,7 +80,7 @@ get_preferred_display_bounds(struct sc_size *bounds) {
 }
 
 static bool
-is_optimal_size(struct sc_size current_size, struct sc_size content_size) {
+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
@@ -94,16 +94,16 @@ is_optimal_size(struct sc_size current_size, struct sc_size content_size) {
 //    crops the black borders)
 //  - it keeps the aspect ratio
 //  - it scales down to make it fit in the display_size
-static struct sc_size
-get_optimal_size(struct sc_size current_size, struct sc_size content_size) {
+static struct size
+get_optimal_size(struct size current_size, struct size content_size) {
     if (content_size.width == 0 || content_size.height == 0) {
         // avoid division by 0
         return current_size;
     }
 
-    struct sc_size window_size;
+    struct size window_size;
 
-    struct sc_size display_size;
+    struct size display_size;
     if (!get_preferred_display_bounds(&display_size)) {
         // could not get display bounds, do not constraint the size
         window_size.width = current_size.width;
@@ -135,10 +135,10 @@ get_optimal_size(struct sc_size current_size, struct sc_size content_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 sc_size
-get_initial_optimal_size(struct sc_size content_size, uint16_t req_width,
+static inline struct size
+get_initial_optimal_size(struct size content_size, uint16_t req_width,
                          uint16_t req_height) {
-    struct sc_size window_size;
+    struct size window_size;
     if (!req_width && !req_height) {
         window_size = get_optimal_size(content_size, content_size);
     } else {
@@ -166,9 +166,9 @@ screen_update_content_rect(struct screen *screen) {
     int dh;
     SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
 
-    struct sc_size content_size = screen->content_size;
+    struct size content_size = screen->content_size;
     // The drawable size is the window size * the HiDPI scale
-    struct sc_size drawable_size = {dw, dh};
+    struct size drawable_size = {dw, dh};
 
     SDL_Rect *rect = &screen->rect;
 
@@ -200,7 +200,7 @@ screen_update_content_rect(struct screen *screen) {
 static inline SDL_Texture *
 create_texture(struct screen *screen) {
     SDL_Renderer *renderer = screen->renderer;
-    struct sc_size size = screen->frame_size;
+    struct size size = screen->frame_size;
     SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
                                              SDL_TEXTUREACCESS_STREAMING,
                                              size.width, size.height);
@@ -282,33 +282,17 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
     (void) vb;
     struct screen *screen = userdata;
 
-    // event_failed implies previous_skipped (the previous frame may not have
-    // been consumed if the event was not sent)
-    assert(!screen->event_failed || previous_skipped);
-
-    bool need_new_event;
     if (previous_skipped) {
         fps_counter_add_skipped_frame(&screen->fps_counter);
         // The EVENT_NEW_FRAME triggered for the previous frame will consume
-        // this new frame instead, unless the previous event failed
-        need_new_event = screen->event_failed;
+        // this new frame instead
     } else {
-        need_new_event = true;
-    }
-
-    if (need_new_event) {
         static SDL_Event new_frame_event = {
             .type = EVENT_NEW_FRAME,
         };
 
         // Post the event on the UI thread
-        int ret = SDL_PushEvent(&new_frame_event);
-        if (ret < 0) {
-            LOGW("Could not post new frame event: %s", SDL_GetError());
-            screen->event_failed = true;
-        } else {
-            screen->event_failed = false;
-        }
+        SDL_PushEvent(&new_frame_event);
     }
 }
 
@@ -318,7 +302,6 @@ screen_init(struct screen *screen, const struct screen_params *params) {
     screen->has_frame = false;
     screen->fullscreen = false;
     screen->maximized = false;
-    screen->event_failed = false;
 
     static const struct sc_video_buffer_callbacks cbs = {
         .on_new_frame = sc_video_buffer_on_new_frame,
@@ -347,13 +330,13 @@ screen_init(struct screen *screen, const struct screen_params *params) {
     if (screen->rotation) {
         LOGI("Initial display rotation set to %u", screen->rotation);
     }
-    struct sc_size content_size =
+    struct size content_size =
         get_rotated_size(screen->frame_size, screen->rotation);
     screen->content_size = content_size;
 
-    struct sc_size window_size =
-        get_initial_optimal_size(content_size,params->window_width,
-                                 params->window_height);
+    struct size window_size = get_initial_optimal_size(content_size,
+                                                       params->window_width,
+                                                       params->window_height);
     uint32_t window_flags = SDL_WINDOW_HIDDEN
                           | SDL_WINDOW_RESIZABLE
                           | SDL_WINDOW_ALLOW_HIGHDPI;
@@ -525,10 +508,10 @@ screen_destroy(struct screen *screen) {
 }
 
 static void
-resize_for_content(struct screen *screen, struct sc_size old_content_size,
-                   struct sc_size new_content_size) {
-    struct sc_size window_size = get_window_size(screen);
-    struct sc_size target_size = {
+resize_for_content(struct screen *screen, struct size old_content_size,
+                                                 struct size new_content_size) {
+    struct size window_size = get_window_size(screen);
+    struct size target_size = {
         .width = (uint32_t) window_size.width * new_content_size.width
                 / old_content_size.width,
         .height = (uint32_t) window_size.height * new_content_size.height
@@ -539,7 +522,7 @@ resize_for_content(struct screen *screen, struct sc_size old_content_size,
 }
 
 static void
-set_content_size(struct screen *screen, struct sc_size new_content_size) {
+set_content_size(struct screen *screen, struct size new_content_size) {
     if (!screen->fullscreen && !screen->maximized) {
         resize_for_content(screen, screen->content_size, new_content_size);
     } else if (!screen->resize_pending) {
@@ -570,7 +553,7 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
         return;
     }
 
-    struct sc_size new_content_size =
+    struct size new_content_size =
         get_rotated_size(screen->frame_size, rotation);
 
     set_content_size(screen, new_content_size);
@@ -583,7 +566,7 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
 
 // recreate the texture and resize the window if the frame size has changed
 static bool
-prepare_for_frame(struct screen *screen, struct sc_size new_frame_size) {
+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) {
         // frame dimension changed, destroy texture
@@ -591,7 +574,7 @@ prepare_for_frame(struct screen *screen, struct sc_size new_frame_size) {
 
         screen->frame_size = new_frame_size;
 
-        struct sc_size new_content_size =
+        struct size new_content_size =
             get_rotated_size(new_frame_size, screen->rotation);
         set_content_size(screen, new_content_size);
 
@@ -632,7 +615,7 @@ screen_update_frame(struct screen *screen) {
 
     fps_counter_add_rendered_frame(&screen->fps_counter);
 
-    struct sc_size new_frame_size = {frame->width, frame->height};
+    struct size new_frame_size = {frame->width, frame->height};
     if (!prepare_for_frame(screen, new_frame_size)) {
         return false;
     }
@@ -699,10 +682,10 @@ screen_resize_to_fit(struct screen *screen) {
         return;
     }
 
-    struct sc_point point = get_window_position(screen);
-    struct sc_size window_size = get_window_size(screen);
+    struct point point = get_window_position(screen);
+    struct size window_size = get_window_size(screen);
 
-    struct sc_size optimal_size =
+    struct size optimal_size =
         get_optimal_size(window_size, screen->content_size);
 
     // Center the window related to the device screen
@@ -728,7 +711,7 @@ screen_resize_to_pixel_perfect(struct screen *screen) {
         screen->maximized = false;
     }
 
-    struct sc_size content_size = screen->content_size;
+    struct size content_size = screen->content_size;
     SDL_SetWindowSize(screen->window, content_size.width, content_size.height);
     LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
                                             content_size.height);
@@ -783,7 +766,7 @@ screen_handle_event(struct screen *screen, SDL_Event *event) {
     return false;
 }
 
-struct sc_point
+struct point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                         int32_t x, int32_t y) {
     unsigned rotation = screen->rotation;
@@ -797,7 +780,7 @@ screen_convert_drawable_to_frame_coords(struct screen *screen,
     y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;
 
     // rotate
-    struct sc_point result;
+    struct point result;
     switch (rotation) {
         case 0:
             result.x = x;
@@ -820,7 +803,7 @@ screen_convert_drawable_to_frame_coords(struct screen *screen,
     return result;
 }
 
-struct sc_point
+struct point
 screen_convert_window_to_frame_coords(struct screen *screen,
                                       int32_t x, int32_t y) {
     screen_hidpi_scale_coords(screen, &x, &y);

app/src/screen.h

@@ -27,13 +27,13 @@ struct screen {
     SDL_Renderer *renderer;
     SDL_Texture *texture;
     struct sc_opengl gl;
-    struct sc_size frame_size;
-    struct sc_size content_size; // rotated frame_size
+    struct size frame_size;
+    struct size content_size; // rotated frame_size
 
     bool resize_pending; // resize requested while fullscreen or maximized
     // The content size the last time the window was not maximized or
     // fullscreen (meaningful only when resize_pending is true)
-    struct sc_size windowed_content_size;
+    struct size windowed_content_size;
 
     // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
     unsigned rotation;
@@ -44,14 +44,12 @@ struct screen {
     bool maximized;
     bool mipmaps;
 
-    bool event_failed; // in case SDL_PushEvent() returned an error
-
     AVFrame *frame;
 };
 
 struct screen_params {
     const char *window_title;
-    struct sc_size frame_size;
+    struct size frame_size;
     bool always_on_top;
 
     int16_t window_x;
@@ -122,13 +120,13 @@ screen_handle_event(struct screen *screen, SDL_Event *event);
 
 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels
-struct sc_point
+struct point
 screen_convert_window_to_frame_coords(struct screen *screen,
                                       int32_t x, int32_t y);
 
 // convert point from drawable coordinates to frame coordinates
 // x and y are expressed in pixels
-struct sc_point
+struct point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                         int32_t x, int32_t y);
 

app/src/server.c

@@ -61,44 +61,6 @@ get_server_path(void) {
     return server_path;
 }
 
-static void
-server_params_destroy(struct server_params *params) {
-    // The server stores a copy of the params provided by the user
-    free((char *) params->serial);
-    free((char *) params->crop);
-    free((char *) params->codec_options);
-    free((char *) params->encoder_name);
-}
-
-static bool
-server_params_copy(struct server_params *dst, const struct server_params *src) {
-    *dst = *src;
-
-    // The params reference user-allocated memory, so we must copy them to
-    // handle them from another thread
-
-#define COPY(FIELD) \
-    dst->FIELD = NULL; \
-    if (src->FIELD) { \
-        dst->FIELD = strdup(src->FIELD); \
-        if (!dst->FIELD) { \
-            goto error; \
-        } \
-    }
-
-    COPY(serial);
-    COPY(crop);
-    COPY(codec_options);
-    COPY(encoder_name);
-#undef COPY
-
-    return true;
-
-error:
-    server_params_destroy(dst);
-    return false;
-}
-
 static bool
 push_server(const char *serial) {
     char *server_path = get_server_path();
@@ -141,11 +103,10 @@ disable_tunnel_forward(const char *serial, uint16_t local_port) {
 
 static bool
 disable_tunnel(struct server *server) {
-    const char *serial = server->params.serial;
     if (server->tunnel_forward) {
-        return disable_tunnel_forward(serial, server->local_port);
+        return disable_tunnel_forward(server->serial, server->local_port);
     }
-    return disable_tunnel_reverse(serial);
+    return disable_tunnel_reverse(server->serial);
 }
 
 static sc_socket
@@ -157,10 +118,9 @@ listen_on_port(uint16_t port) {
 static bool
 enable_tunnel_reverse_any_port(struct server *server,
                                struct sc_port_range port_range) {
-    const char *serial = server->params.serial;
     uint16_t port = port_range.first;
     for (;;) {
-        if (!enable_tunnel_reverse(serial, port)) {
+        if (!enable_tunnel_reverse(server->serial, port)) {
             // the command itself failed, it will fail on any port
             return false;
         }
@@ -179,7 +139,7 @@ enable_tunnel_reverse_any_port(struct server *server,
         }
 
         // failure, disable tunnel and try another port
-        if (!disable_tunnel_reverse(serial)) {
+        if (!disable_tunnel_reverse(server->serial)) {
             LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
         }
 
@@ -205,11 +165,9 @@ static bool
 enable_tunnel_forward_any_port(struct server *server,
                                struct sc_port_range port_range) {
     server->tunnel_forward = true;
-
-    const char *serial = server->params.serial;
     uint16_t port = port_range.first;
     for (;;) {
-        if (enable_tunnel_forward(serial, port)) {
+        if (enable_tunnel_forward(server->serial, port)) {
             // success
             server->local_port = port;
             return true;
@@ -271,8 +229,6 @@ log_level_to_server_string(enum sc_log_level level) {
 
 static process_t
 execute_server(struct server *server, const struct server_params *params) {
-    const char *serial = server->params.serial;
-
     char max_size_string[6];
     char bit_rate_string[11];
     char max_fps_string[6];
@@ -330,7 +286,7 @@ execute_server(struct server *server, const struct server_params *params) {
     //     Port: 5005
     // Then click on "Debug"
 #endif
-    return adb_execute(serial, cmd, ARRAY_LEN(cmd));
+    return adb_execute(server->serial, cmd, ARRAY_LEN(cmd));
 }
 
 static sc_socket
@@ -360,7 +316,6 @@ connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
             // it worked!
             return socket;
         }
-        // TODO use mutex + condvar + bool stopped
         if (attempts) {
             SDL_Delay(delay);
         }
@@ -369,31 +324,22 @@ connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
 }
 
 bool
-server_init(struct server *server, const struct server_params *params,
-            const struct server_callbacks *cbs, void *cbs_userdata) {
-    bool ok = server_params_copy(&server->params, params);
-    if (!ok) {
-        LOGE("Could not copy server params");
-        return false;
-    }
-
+server_init(struct server *server) {
+    server->serial = NULL;
     server->process = PROCESS_NONE;
 
-    ok = sc_mutex_init(&server->mutex);
+    bool ok = sc_mutex_init(&server->mutex);
     if (!ok) {
-        server_params_destroy(&server->params);
         return false;
     }
 
     ok = sc_cond_init(&server->process_terminated_cond);
     if (!ok) {
         sc_mutex_destroy(&server->mutex);
-        server_params_destroy(&server->params);
         return false;
     }
 
     server->process_terminated = false;
-    server->connected = false;
 
     server->server_socket = SC_INVALID_SOCKET;
     server->video_socket = SC_INVALID_SOCKET;
@@ -404,69 +350,13 @@ server_init(struct server *server, const struct server_params *params,
     server->tunnel_enabled = false;
     server->tunnel_forward = false;
 
-    assert(cbs);
-    assert(cbs->on_connection_failed);
-    assert(cbs->on_connected);
-    assert(cbs->on_disconnected);
-
-    server->cbs = cbs;
-    server->cbs_userdata = cbs_userdata;
-
     return true;
 }
 
 static int
-run_server_connect(void *data) {
+run_wait_server(void *data) {
     struct server *server = data;
-
-    if (!server_connect_to(server, &server->info)) {
-        server->cbs->on_connection_failed(server, server->cbs_userdata);
-        goto end;
-    }
-
-    server->connected = true;
-    server->cbs->on_connected(server, server->cbs_userdata);
-
-end:
-    return 0;
-}
-
-static int
-run_server(void *data) {
-    struct server *server = data;
-
-    const struct server_params *params = &server->params;
-
-    if (!push_server(params->serial)) {
-        server->cbs->on_connection_failed(server, server->cbs_userdata);
-        goto end;
-    }
-
-    if (!enable_tunnel_any_port(server, params->port_range,
-                                params->force_adb_forward)) {
-        server->cbs->on_connection_failed(server, server->cbs_userdata);
-        goto end;
-    }
-
-    server->process = execute_server(server, params);
-    if (server->process == PROCESS_NONE) {
-        server->cbs->on_connection_failed(server, server->cbs_userdata);
-        goto end;
-    }
-
-    sc_thread connect_thread;
-    bool ok = sc_thread_create(&connect_thread, run_server_connect,
-                               "server-connect", server);
-    if (!ok) {
-        LOGW("Could not create thread, killing the server...");
-        process_terminate(server->process);
-        server->cbs->on_connection_failed(server, server->cbs_userdata);
-        process_wait(server->process, false); // ignore exit code
-        goto end;
-    }
-
     process_wait(server->process, false); // ignore exit code
-    LOGD("Server terminated");
 
     sc_mutex_lock(&server->mutex);
     server->process_terminated = true;
@@ -480,26 +370,64 @@ run_server(void *data) {
         net_interrupt(server->server_socket);
     }
 
-    sc_thread_join(&connect_thread, NULL);
-
-    // Written by connect_thread, sc_thread_join() provides the necessary
-    // memory barrier
-    if (server->connected) {
-        server->cbs->on_disconnected(server, server->cbs_userdata);
-    }
-    // Otherwise, ->on_connection_failed() is already called
-
-end:
+    LOGD("Server terminated");
     return 0;
 }
 
 bool
-server_start(struct server *server) {
-    return sc_thread_create(&server->thread, run_server, "server", server);
+server_start(struct server *server, const struct server_params *params) {
+    if (params->serial) {
+        server->serial = strdup(params->serial);
+        if (!server->serial) {
+            return false;
+        }
+    }
+
+    if (!push_server(params->serial)) {
+        /* server->serial will be freed on server_destroy() */
+        return false;
+    }
+
+    if (!enable_tunnel_any_port(server, params->port_range,
+                                params->force_adb_forward)) {
+        return false;
+    }
+
+    // server will connect to our server socket
+    server->process = execute_server(server, params);
+    if (server->process == PROCESS_NONE) {
+        goto error;
+    }
+
+    // If the server process dies before connecting to the server socket, then
+    // the client will be stuck forever on accept(). To avoid the problem, we
+    // must be able to wake up the accept() call when the server dies. To keep
+    // things simple and multiplatform, just spawn a new thread waiting for the
+    // server process and calling shutdown()/close() on the server socket if
+    // necessary to wake up any accept() blocking call.
+    bool ok = sc_thread_create(&server->wait_server_thread, run_wait_server,
+                               "wait-server", server);
+    if (!ok) {
+        process_terminate(server->process);
+        process_wait(server->process, true); // ignore exit code
+        goto error;
+    }
+
+    server->tunnel_enabled = true;
+
+    return true;
+
+error:
+    // The server socket (if any) will be closed on server_destroy()
+
+    disable_tunnel(server);
+
+    return false;
 }
 
 static bool
-device_read_info(sc_socket device_socket, struct server_info *info) {
+device_read_info(sc_socket device_socket, char *device_name,
+                 struct size *size) {
     unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
     ssize_t r = net_recv_all(device_socket, buf, sizeof(buf));
     if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
@@ -508,17 +436,18 @@ device_read_info(sc_socket device_socket, struct server_info *info) {
     }
     // in case the client sends garbage
     buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
-    memcpy(info->device_name, (char *) buf, sizeof(info->device_name));
-
-    info->frame_size.width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
-                           | buf[DEVICE_NAME_FIELD_LENGTH + 1];
-    info->frame_size.height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
-                            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
+    // strcpy is safe here, since name contains at least
+    // DEVICE_NAME_FIELD_LENGTH bytes and strlen(buf) < DEVICE_NAME_FIELD_LENGTH
+    strcpy(device_name, (char *) buf);
+    size->width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
+            | buf[DEVICE_NAME_FIELD_LENGTH + 1];
+    size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
+            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
     return true;
 }
 
 bool
-server_connect_to(struct server *server, struct server_info *info) {
+server_connect_to(struct server *server, char *device_name, struct size *size) {
     if (!server->tunnel_forward) {
         server->video_socket = net_accept(server->server_socket);
         if (server->video_socket == SC_INVALID_SOCKET) {
@@ -559,7 +488,7 @@ server_connect_to(struct server *server, struct server_info *info) {
     server->tunnel_enabled = false;
 
     // The sockets will be closed on stop if device_read_info() fails
-    return device_read_info(server->video_socket, info);
+    return device_read_info(server->video_socket, device_name, size);
 }
 
 void
@@ -608,7 +537,7 @@ server_stop(struct server *server) {
         process_terminate(server->process);
     }
 
-    sc_thread_join(&server->thread, NULL);
+    sc_thread_join(&server->wait_server_thread, NULL);
     process_close(server->process);
 }
 
@@ -629,8 +558,7 @@ server_destroy(struct server *server) {
             LOGW("Could not close control socket");
         }
     }
-
-    server_params_destroy(&server->params);
+    free(server->serial);
     sc_cond_destroy(&server->process_terminated_cond);
     sc_mutex_destroy(&server->mutex);
 }

app/src/server.h

@@ -9,15 +9,26 @@
 
 #include "adb.h"
 #include "coords.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/thread.h"
 
-#define DEVICE_NAME_FIELD_LENGTH 64
-struct server_info {
-    char device_name[DEVICE_NAME_FIELD_LENGTH];
-    struct sc_size frame_size;
+struct server {
+    char *serial;
+    process_t process;
+    sc_thread wait_server_thread;
+
+    sc_mutex mutex;
+    sc_cond process_terminated_cond;
+    bool process_terminated;
+
+    sc_socket server_socket; // only used if !tunnel_forward
+    sc_socket video_socket;
+    sc_socket control_socket;
+    uint16_t local_port; // selected from port_range
+    bool tunnel_enabled;
+    bool tunnel_forward; // use "adb forward" instead of "adb reverse"
 };
 
 struct server_params {
@@ -39,50 +50,19 @@ struct server_params {
     bool power_off_on_close;
 };
 
-struct server {
-    // The internal allocated strings are copies owned by the server
-    struct server_params params;
-
-    process_t process;
-    sc_thread thread;
-
-    sc_mutex mutex;
-    sc_cond process_terminated_cond;
-    bool process_terminated;
-
-    bool connected; // written by connect_thread
-    struct server_info info; // initialized once connected
-
-    sc_socket server_socket; // only used if !tunnel_forward
-    sc_socket video_socket;
-    sc_socket control_socket;
-    uint16_t local_port; // selected from port_range
-    bool tunnel_enabled;
-    bool tunnel_forward; // use "adb forward" instead of "adb reverse"
-
-    const struct server_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct server_callbacks {
-    void (*on_connection_failed)(struct server *server, void *userdata);
-    void (*on_connected)(struct server *server, void *userdata);
-    void (*on_disconnected)(struct server *server, void *userdata);
-};
-
-// init the server with the given params
+// init default values
 bool
-server_init(struct server *server, const struct server_params *params,
-            const struct server_callbacks *cbs, void *cbs_userdata);
+server_init(struct server *server);
 
 // push, enable tunnel et start the server
 bool
-server_start(struct server *server);
+server_start(struct server *server, const struct server_params *params);
 
+#define DEVICE_NAME_FIELD_LENGTH 64
 // block until the communication with the server is established
 // device_name must point to a buffer of at least DEVICE_NAME_FIELD_LENGTH bytes
 bool
-server_connect_to(struct server *server, struct server_info *info);
+server_connect_to(struct server *server, char *device_name, struct size *size);
 
 // disconnect and kill the server process
 void

app/src/util/log.h

@@ -5,7 +5,7 @@
 
 #include <SDL2/SDL_log.h>
 
-#include "options.h"
+#include "scrcpy.h"
 
 #define LOGV(...) SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)

app/src/util/net.h

@@ -53,7 +53,7 @@ ssize_t
 net_send_all(sc_socket socket, const void *buf, size_t len);
 
 // Shutdown the socket (or close on Windows) so that any blocking send() or
-// recv() are interrupted.
+// recv() are interrupted
 bool
 net_interrupt(sc_socket socket);
 

app/src/v4l2_sink.c

@@ -359,7 +359,7 @@ sc_v4l2_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
 
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct sc_size frame_size, sc_tick buffering_time) {
+                  struct size frame_size, sc_tick buffering_time) {
     vs->device_name = strdup(device_name);
     if (!vs->device_name) {
         LOGE("Could not strdup v4l2 device name");

app/src/v4l2_sink.h

@@ -18,7 +18,7 @@ struct sc_v4l2_sink {
     AVCodecContext *encoder_ctx;
 
     char *device_name;
-    struct sc_size frame_size;
+    struct size frame_size;
     sc_tick buffering_time;
 
     sc_thread thread;
@@ -34,7 +34,7 @@ struct sc_v4l2_sink {
 
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct sc_size frame_size, sc_tick buffering_time);
+                  struct size frame_size, sc_tick buffering_time);
 
 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);

app/tests/test_cli.c

@@ -4,11 +4,11 @@
 #include <string.h>
 
 #include "cli.h"
-#include "options.h"
+#include "scrcpy.h"
 
 static void test_flag_version(void) {
     struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
         .help = false,
         .version = false,
     };
@@ -23,7 +23,7 @@ static void test_flag_version(void) {
 
 static void test_flag_help(void) {
     struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
         .help = false,
         .version = false,
     };
@@ -38,7 +38,7 @@ static void test_flag_help(void) {
 
 static void test_options(void) {
     struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
         .help = false,
         .version = false,
     };
@@ -100,7 +100,7 @@ static void test_options(void) {
 
 static void test_options2(void) {
     struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
         .help = false,
         .version = false,
     };

build.gradle

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

config/android-checkstyle.gradle

@@ -2,7 +2,7 @@ apply plugin: 'checkstyle'
 check.dependsOn 'checkstyle'
 
 checkstyle {
-    toolVersion = '9.0.1'
+    toolVersion = '6.19'
 }
 
 task checkstyle(type: Checkstyle) {

config/checkstyle/checkstyle.xml

@@ -37,14 +37,6 @@ page at http://checkstyle.sourceforge.net/config.html -->
 
   <module name="SuppressWarningsFilter"/>
 
-  <module name="LineLength">
-    <!-- what is a good max value? -->
-    <property name="max" value="150" />
-    <!-- ignore lines like "$File: //depot/... $" -->
-    <property name="ignorePattern" value="\$File.*\$" />
-    <property name="severity" value="info" />
-  </module>
-
   <module name="TreeWalker">
 
     <!-- Checks for Naming Conventions.                  -->
@@ -80,6 +72,13 @@ page at http://checkstyle.sourceforge.net/config.html -->
 
     <!-- Checks for Size Violations.                    -->
     <!-- See http://checkstyle.sf.net/config_sizes.html -->
+    <module name="LineLength">
+      <!-- what is a good max value? -->
+      <property name="max" value="150" />
+      <!-- ignore lines like "$File: //depot/... $" -->
+      <property name="ignorePattern" value="\$File.*\$" />
+      <property name="severity" value="info" />
+    </module>
     <module name="MethodLength" />
     <module name="ParameterNumber">
       <property name="ignoreOverriddenMethods" value="true"/>
@@ -153,6 +152,26 @@ page at http://checkstyle.sourceforge.net/config.html -->
     </module>
     <module name="UpperEll" />
 
+    <module name="FileContentsHolder" />
+    <!-- Required by comment suppression filters -->
+
+  </module>
+
+  <module name="SuppressionFilter">
+    <!--<property name="file" value="team-props/checkstyle/checkstyle-suppressions.xml" />-->
+  </module>
+
+  <!-- Enable suppression comments -->
+  <module name="SuppressionCommentFilter">
+    <property name="offCommentFormat" value="CHECKSTYLE IGNORE\s+(\S+)" />
+    <property name="onCommentFormat" value="CHECKSTYLE END IGNORE\s+(\S+)" />
+    <property name="checkFormat" value="$1" />
+  </module>
+  <module name="SuppressWithNearbyCommentFilter">
+    <!-- Syntax is "SUPPRESS CHECKSTYLE name" -->
+    <property name="commentFormat" value="SUPPRESS CHECKSTYLE (\w+)" />
+    <property name="checkFormat" value="$1" />
+    <property name="influenceFormat" value="1" />
   </module>
 
 </module>

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

server/build.gradle

@@ -1,11 +1,11 @@
 apply plugin: 'com.android.application'
 
 android {
-    compileSdkVersion 31
+    compileSdkVersion 30
     defaultConfig {
         applicationId "com.genymobile.scrcpy"
         minSdkVersion 21
-        targetSdkVersion 31
+        targetSdkVersion 30
         versionCode 11900
         versionName "1.19"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

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

@@ -2,6 +2,7 @@ package com.genymobile.scrcpy;
 
 import android.view.KeyEvent;
 import android.view.MotionEvent;
+
 import org.junit.Assert;
 import org.junit.Test;