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)
Add socket wrapper
2021-10-26 23:01:51 +02:00 · 2021-10-26 22:49:57 +02:00 · 2021-10-26 22:49:45 +02:00 · 2021-10-26 22:49:45 +02:00 · 2021-10-26 22:49:45 +02:00 · 2021-10-26 21:30:04 +02:00
31 changed files with 810 additions and 586 deletions
--- a/README.md
+++ b/README.md
@@ -1,5 +1,7 @@
 # scrcpy (v1.19)

+![icon](data/icon.png)
+
 [Read in another language](#translations)

 This application provides display and control of Android devices connected on
@@ -688,7 +690,7 @@ supported on Linux.
 To enable this mode:

 ```bash
-scrcpy --keyboard-hid
+scrcpy --hid-keyboard
 scrcpy -K  # short version
 ```

@@ -865,7 +867,7 @@ ADB=/path/to/adb scrcpy
 To override the path of the `scrcpy-server` file, configure its path in
 `SCRCPY_SERVER_PATH`.

-[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
+To override the icon, configure its path in `SCRCPY_ICON_PATH`.


 ## Why _scrcpy_?
--- a/app/meson.build
+++ b/app/meson.build
@@ -8,6 +8,7 @@ src = [
    'src/controller.c',
    'src/decoder.c',
    'src/device_msg.c',
+    'src/icon.c',
    'src/file_handler.c',
    'src/fps_counter.c',
    'src/frame_buffer.c',
@@ -21,7 +22,6 @@ src = [
    'src/screen.c',
    'src/server.c',
    'src/stream.c',
-    'src/tiny_xpm.c',
    'src/video_buffer.c',
    'src/util/log.c',
    'src/util/net.c',
@@ -165,6 +165,9 @@ executable('scrcpy', src,
           c_args: [])

 install_man('scrcpy.1')
+install_data('../data/icon.png',
+             rename: 'scrcpy.png',
+             install_dir: 'share/icons/hicolor/256x256/apps')


 ### TESTS
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -83,7 +83,7 @@ Start in fullscreen.
 Print this help.

 .TP
-.B \-K, \-\-keyboard\-hid
+.B \-K, \-\-hid\-keyboard
 Simulate a physical keyboard by using HID over AOAv2.

 This provides a better experience for IME users, and allows to generate non-ASCII characters, contrary to the default injection method.
--- a/app/src/aoa_hid.c
+++ b/app/src/aoa_hid.c
@@ -14,7 +14,7 @@
 #define DEFAULT_TIMEOUT 1000

 static void
-hid_event_log(const struct hid_event *event) {
+sc_hid_event_log(const struct sc_hid_event *event) {
    // HID Event: [00] FF FF FF FF...
    assert(event->size);
    unsigned buffer_size = event->size * 3 + 1;
@@ -25,25 +25,25 @@ hid_event_log(const struct hid_event *event) {
    for (unsigned i = 0; i < event->size; ++i) {
        snprintf(buffer + i * 3, 4, " %02x", event->buffer[i]);
    }
-    LOGV("HID Event: [%d]%s", event->from_accessory_id, buffer);
+    LOGV("HID Event: [%d]%s", event->accessory_id, buffer);
    free(buffer);
 }

 void
-hid_event_init(struct hid_event *hid_event, uint16_t accessory_id,
-               unsigned char *buffer, uint16_t buffer_size) {
-    hid_event->from_accessory_id = accessory_id;
+sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
+                  unsigned char *buffer, uint16_t buffer_size) {
+    hid_event->accessory_id = accessory_id;
    hid_event->buffer = buffer;
    hid_event->size = buffer_size;
    hid_event->delay = 0;
 }

 void
-hid_event_destroy(struct hid_event *event) {
-    free(event->buffer);
+sc_hid_event_destroy(struct sc_hid_event *hid_event) {
+    free(hid_event->buffer);
 }

-static void
+static inline void
 log_libusb_error(enum libusb_error errcode) {
    LOGW("libusb error: %s", libusb_strerror(errcode));
 }
@@ -82,7 +82,7 @@ accept_device(libusb_device *device, const char *serial) {
 }

 static libusb_device *
-aoa_find_usb_device(const char *serial) {
+sc_aoa_find_usb_device(const char *serial) {
    if (!serial) {
        return NULL;
    }
@@ -108,7 +108,7 @@ aoa_find_usb_device(const char *serial) {
 }

 static int
-aoa_open_usb_handle(libusb_device *device, libusb_device_handle **handle) {
+sc_aoa_open_usb_handle(libusb_device *device, libusb_device_handle **handle) {
    int result = libusb_open(device, handle);
    if (result < 0) {
        log_libusb_error((enum libusb_error) result);
@@ -118,7 +118,7 @@ aoa_open_usb_handle(libusb_device *device, libusb_device_handle **handle) {
 }

 bool
-aoa_init(struct aoa *aoa, const char *serial) {
+sc_aoa_init(struct sc_aoa *aoa, const char *serial) {
    cbuf_init(&aoa->queue);

    if (!sc_mutex_init(&aoa->mutex)) {
@@ -136,7 +136,7 @@ aoa_init(struct aoa *aoa, const char *serial) {
        return false;
    }

-    aoa->usb_device = aoa_find_usb_device(serial);
+    aoa->usb_device = sc_aoa_find_usb_device(serial);
    if (!aoa->usb_device) {
        LOGW("USB device of serial %s not found", serial);
        libusb_exit(aoa->usb_context);
@@ -145,7 +145,7 @@ aoa_init(struct aoa *aoa, const char *serial) {
        return false;
    }

-    if (aoa_open_usb_handle(aoa->usb_device, &aoa->usb_handle) < 0) {
+    if (sc_aoa_open_usb_handle(aoa->usb_device, &aoa->usb_handle) < 0) {
        LOGW("Open USB handle failed");
        libusb_unref_device(aoa->usb_device);
        libusb_exit(aoa->usb_context);
@@ -160,11 +160,11 @@ aoa_init(struct aoa *aoa, const char *serial) {
 }

 void
-aoa_destroy(struct aoa *aoa) {
+sc_aoa_destroy(struct sc_aoa *aoa) {
    // Destroy remaining events
-    struct hid_event event;
+    struct sc_hid_event event;
    while (cbuf_take(&aoa->queue, &event)) {
-        hid_event_destroy(&event);
+        sc_hid_event_destroy(&event);
    }

    libusb_close(aoa->usb_handle);
@@ -175,8 +175,8 @@ aoa_destroy(struct aoa *aoa) {
 }

 static bool
-aoa_register_hid(struct aoa *aoa, uint16_t accessory_id,
-                 uint16_t report_desc_size) {
+sc_aoa_register_hid(struct sc_aoa *aoa, uint16_t accessory_id,
+                    uint16_t report_desc_size) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_REGISTER_HID;
    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
@@ -198,9 +198,9 @@ aoa_register_hid(struct aoa *aoa, uint16_t accessory_id,
 }

 static bool
-aoa_set_hid_report_desc(struct aoa *aoa, uint16_t accessory_id,
-                        const unsigned char *report_desc,
-                        uint16_t report_desc_size) {
+sc_aoa_set_hid_report_desc(struct sc_aoa *aoa, uint16_t accessory_id,
+                           const unsigned char *report_desc,
+                           uint16_t report_desc_size) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_SET_HID_REPORT_DESC;
    /**
@@ -234,17 +234,17 @@ aoa_set_hid_report_desc(struct aoa *aoa, uint16_t accessory_id,
 }

 bool
-aoa_setup_hid(struct aoa *aoa, uint16_t accessory_id,
-              const unsigned char *report_desc, uint16_t report_desc_size) {
-    bool ok = aoa_register_hid(aoa, accessory_id, report_desc_size);
+sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
+                 const unsigned char *report_desc, uint16_t report_desc_size) {
+    bool ok = sc_aoa_register_hid(aoa, accessory_id, report_desc_size);
    if (!ok) {
        return false;
    }

-    ok = aoa_set_hid_report_desc(aoa, accessory_id, report_desc,
-                                 report_desc_size);
+    ok = sc_aoa_set_hid_report_desc(aoa, accessory_id, report_desc,
+                                    report_desc_size);
    if (!ok) {
-        if (!aoa_unregister_hid(aoa, accessory_id)) {
+        if (!sc_aoa_unregister_hid(aoa, accessory_id)) {
            LOGW("Could not unregister HID");
        }
        return false;
@@ -254,13 +254,13 @@ aoa_setup_hid(struct aoa *aoa, uint16_t accessory_id,
 }

 static bool
-aoa_send_hid_event(struct aoa *aoa, const struct hid_event *event) {
+sc_aoa_send_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_SEND_HID_EVENT;
    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
    // value (arg0): accessory assigned ID for the HID device
    // index (arg1): 0 (unused)
-    uint16_t value = event->from_accessory_id;
+    uint16_t value = event->accessory_id;
    uint16_t index = 0;
    unsigned char *buffer = event->buffer;
    uint16_t length = event->size;
@@ -276,7 +276,7 @@ aoa_send_hid_event(struct aoa *aoa, const struct hid_event *event) {
 }

 bool
-aoa_unregister_hid(struct aoa *aoa, const uint16_t accessory_id) {
+sc_aoa_unregister_hid(struct sc_aoa *aoa, const uint16_t accessory_id) {
    uint8_t request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR;
    uint8_t request = ACCESSORY_UNREGISTER_HID;
    // <https://source.android.com/devices/accessories/aoa2.html#hid-support>
@@ -298,8 +298,11 @@ aoa_unregister_hid(struct aoa *aoa, const uint16_t accessory_id) {
 }

 bool
-aoa_push_hid_event(struct aoa *aoa, const struct hid_event *event) {
-    hid_event_log(event);
+sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
+    if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
+        sc_hid_event_log(event);
+    }
+
    sc_mutex_lock(&aoa->mutex);
    bool was_empty = cbuf_is_empty(&aoa->queue);
    bool res = cbuf_push(&aoa->queue, *event);
@@ -312,7 +315,7 @@ aoa_push_hid_event(struct aoa *aoa, const struct hid_event *event) {

 static int
 run_aoa_thread(void *data) {
-    struct aoa *aoa = data;
+    struct sc_aoa *aoa = data;

    for (;;) {
        sc_mutex_lock(&aoa->mutex);
@@ -324,7 +327,7 @@ run_aoa_thread(void *data) {
            sc_mutex_unlock(&aoa->mutex);
            break;
        }
-        struct hid_event event;
+        struct sc_hid_event event;
        bool non_empty = cbuf_take(&aoa->queue, &event);
        assert(non_empty);
        (void) non_empty;
@@ -346,8 +349,8 @@ run_aoa_thread(void *data) {

        sc_mutex_unlock(&aoa->mutex);

-        bool ok = aoa_send_hid_event(aoa, &event);
-        hid_event_destroy(&event);
+        bool ok = sc_aoa_send_hid_event(aoa, &event);
+        sc_hid_event_destroy(&event);
        if (!ok) {
            LOGW("Could not send HID event to USB device");
        }
@@ -356,7 +359,7 @@ run_aoa_thread(void *data) {
 }

 bool
-aoa_start(struct aoa *aoa) {
+sc_aoa_start(struct sc_aoa *aoa) {
    LOGD("Starting AOA thread");

    bool ok = sc_thread_create(&aoa->thread, run_aoa_thread, "aoa_thread", aoa);
@@ -369,7 +372,7 @@ aoa_start(struct aoa *aoa) {
 }

 void
-aoa_stop(struct aoa *aoa) {
+sc_aoa_stop(struct sc_aoa *aoa) {
    sc_mutex_lock(&aoa->mutex);
    aoa->stopped = true;
    sc_cond_signal(&aoa->event_cond);
@@ -377,6 +380,6 @@ aoa_stop(struct aoa *aoa) {
 }

 void
-aoa_join(struct aoa *aoa) {
+sc_aoa_join(struct sc_aoa *aoa) {
    sc_thread_join(&aoa->thread, NULL);
 }
--- a/app/src/aoa_hid.h
+++ b/app/src/aoa_hid.h
@@ -1,5 +1,5 @@
-#ifndef AOA_HID_H
-#define AOA_HID_H
+#ifndef SC_AOA_HID_H
+#define SC_AOA_HID_H

 #include <stdint.h>
 #include <stdbool.h>
@@ -11,8 +11,8 @@
 #include "util/thread.h"
 #include "util/tick.h"

-struct hid_event {
-    uint16_t from_accessory_id;
+struct sc_hid_event {
+    uint16_t accessory_id;
    unsigned char *buffer;
    uint16_t size;
    sc_tick delay;
@@ -20,15 +20,15 @@ struct hid_event {

 // Takes ownership of buffer
 void
-hid_event_init(struct hid_event *hid_event, uint16_t accessory_id,
-               unsigned char *buffer, uint16_t buffer_size);
+sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
+                  unsigned char *buffer, uint16_t buffer_size);

 void
-hid_event_destroy(struct hid_event *hid_event);
+sc_hid_event_destroy(struct sc_hid_event *hid_event);

-struct hid_event_queue CBUF(struct hid_event, 64);
+struct sc_hid_event_queue CBUF(struct sc_hid_event, 64);

-struct aoa {
+struct sc_aoa {
    libusb_context *usb_context;
    libusb_device *usb_device;
    libusb_device_handle *usb_handle;
@@ -36,32 +36,32 @@ struct aoa {
    sc_mutex mutex;
    sc_cond event_cond;
    bool stopped;
-    struct hid_event_queue queue;
+    struct sc_hid_event_queue queue;
 };

 bool
-aoa_init(struct aoa *aoa, const char *serial);
+sc_aoa_init(struct sc_aoa *aoa, const char *serial);

 void
-aoa_destroy(struct aoa *aoa);
+sc_aoa_destroy(struct sc_aoa *aoa);

 bool
-aoa_start(struct aoa *aoa);
+sc_aoa_start(struct sc_aoa *aoa);

 void
-aoa_stop(struct aoa *aoa);
+sc_aoa_stop(struct sc_aoa *aoa);

 void
-aoa_join(struct aoa *aoa);
+sc_aoa_join(struct sc_aoa *aoa);

 bool
-aoa_setup_hid(struct aoa *aoa, uint16_t accessory_id,
+sc_aoa_setup_hid(struct sc_aoa *aoa, uint16_t accessory_id,
              const unsigned char *report_desc, uint16_t report_desc_size);

 bool
-aoa_unregister_hid(struct aoa *aoa, uint16_t accessory_id);
+sc_aoa_unregister_hid(struct sc_aoa *aoa, uint16_t accessory_id);

 bool
-aoa_push_hid_event(struct aoa *aoa, const struct hid_event *event);
+sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event);

 #endif
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -76,7 +76,7 @@ scrcpy_print_usage(const char *arg0) {
        "    -f, --fullscreen\n"
        "        Start in fullscreen.\n"
        "\n"
-        "    -K, --keyboard-hid\n"
+        "    -K, --hid-keyboard\n"
        "        Simulate a physical keyboard by using HID over AOAv2.\n"
        "        It provides a better experience for IME users, and allows to\n"
        "        generate non-ASCII characters, contrary to the default\n"
@@ -746,7 +746,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
                                                  OPT_FORWARD_ALL_CLICKS},
        {"fullscreen",             no_argument,       NULL, 'f'},
        {"help",                   no_argument,       NULL, 'h'},
-        {"keyboard-hid",           no_argument,       NULL, 'K'},
+        {"hid-keyboard",           no_argument,       NULL, 'K'},
        {"legacy-paste",           no_argument,       NULL, OPT_LEGACY_PASTE},
        {"lock-video-orientation", optional_argument, NULL,
                                                  OPT_LOCK_VIDEO_ORIENTATION},
--- a/app/src/controller.c
+++ b/app/src/controller.c
@@ -5,7 +5,7 @@
 #include "util/log.h"

 bool
-controller_init(struct controller *controller, socket_t control_socket) {
+controller_init(struct controller *controller, sc_socket control_socket) {
    cbuf_init(&controller->queue);

    bool ok = receiver_init(&controller->receiver, control_socket);
--- a/app/src/controller.h
+++ b/app/src/controller.h
@@ -14,7 +14,7 @@
 struct control_msg_queue CBUF(struct control_msg, 64);

 struct controller {
-    socket_t control_socket;
+    sc_socket control_socket;
    sc_thread thread;
    sc_mutex mutex;
    sc_cond msg_cond;
@@ -24,7 +24,7 @@ struct controller {
 };

 bool
-controller_init(struct controller *controller, socket_t control_socket);
+controller_init(struct controller *controller, sc_socket control_socket);

 void
 controller_destroy(struct controller *controller);
--- a/app/src/hid_keyboard.c
+++ b/app/src/hid_keyboard.c
@@ -6,20 +6,19 @@
 #include "util/log.h"

 /** Downcast key processor to hid_keyboard */
-#define DOWNCAST(KP) \
-    container_of(KP, struct hid_keyboard, key_processor)
+#define DOWNCAST(KP) container_of(KP, struct sc_hid_keyboard, key_processor)

 #define HID_KEYBOARD_ACCESSORY_ID 1

-#define HID_KEYBOARD_MODIFIER_NONE 0x00
-#define HID_KEYBOARD_MODIFIER_LEFT_CONTROL (1 << 0)
-#define HID_KEYBOARD_MODIFIER_LEFT_SHIFT (1 << 1)
-#define HID_KEYBOARD_MODIFIER_LEFT_ALT (1 << 2)
-#define HID_KEYBOARD_MODIFIER_LEFT_GUI (1 << 3)
-#define HID_KEYBOARD_MODIFIER_RIGHT_CONTROL (1 << 4)
-#define HID_KEYBOARD_MODIFIER_RIGHT_SHIFT (1 << 5)
-#define HID_KEYBOARD_MODIFIER_RIGHT_ALT (1 << 6)
-#define HID_KEYBOARD_MODIFIER_RIGHT_GUI (1 << 7)
+#define HID_MODIFIER_NONE 0x00
+#define HID_MODIFIER_LEFT_CONTROL (1 << 0)
+#define HID_MODIFIER_LEFT_SHIFT (1 << 1)
+#define HID_MODIFIER_LEFT_ALT (1 << 2)
+#define HID_MODIFIER_LEFT_GUI (1 << 3)
+#define HID_MODIFIER_RIGHT_CONTROL (1 << 4)
+#define HID_MODIFIER_RIGHT_SHIFT (1 << 5)
+#define HID_MODIFIER_RIGHT_ALT (1 << 6)
+#define HID_MODIFIER_RIGHT_GUI (1 << 7)

 #define HID_KEYBOARD_INDEX_MODIFIER 0
 #define HID_KEYBOARD_INDEX_KEYS 2
@@ -30,8 +29,8 @@
 #define HID_KEYBOARD_MAX_KEYS 6
 #define HID_KEYBOARD_EVENT_SIZE (2 + HID_KEYBOARD_MAX_KEYS)

-#define HID_KEYBOARD_RESERVED 0x00
-#define HID_KEYBOARD_ERROR_ROLL_OVER 0x01
+#define HID_RESERVED 0x00
+#define HID_ERROR_ROLL_OVER 0x01

 /**
 * For HID over AOAv2, only report descriptor is needed.
@@ -111,11 +110,11 @@ static const unsigned char keyboard_report_desc[]  = {
    // Usage Minimum (0)
    0x19, 0x00,
    // Usage Maximum (101)
-    0x29, HID_KEYBOARD_KEYS - 1,
+    0x29, SC_HID_KEYBOARD_KEYS - 1,
    // Logical Minimum (0)
    0x15, 0x00,
    // Logical Maximum(101)
-    0x25, HID_KEYBOARD_KEYS - 1,
+    0x25, SC_HID_KEYBOARD_KEYS - 1,
    // Report Size (8)
    0x75, 0x08,
    // Report Count (6)
@@ -129,47 +128,47 @@ static const unsigned char keyboard_report_desc[]  = {

 static unsigned char
 sdl_keymod_to_hid_modifiers(SDL_Keymod mod) {
-    unsigned char modifiers = HID_KEYBOARD_MODIFIER_NONE;
+    unsigned char modifiers = HID_MODIFIER_NONE;
    if (mod & KMOD_LCTRL) {
-        modifiers |= HID_KEYBOARD_MODIFIER_LEFT_CONTROL;
+        modifiers |= HID_MODIFIER_LEFT_CONTROL;
    }
    if (mod & KMOD_LSHIFT) {
-        modifiers |= HID_KEYBOARD_MODIFIER_LEFT_SHIFT;
+        modifiers |= HID_MODIFIER_LEFT_SHIFT;
    }
    if (mod & KMOD_LALT) {
-        modifiers |= HID_KEYBOARD_MODIFIER_LEFT_ALT;
+        modifiers |= HID_MODIFIER_LEFT_ALT;
    }
    if (mod & KMOD_LGUI) {
-        modifiers |= HID_KEYBOARD_MODIFIER_LEFT_GUI;
+        modifiers |= HID_MODIFIER_LEFT_GUI;
    }
    if (mod & KMOD_RCTRL) {
-        modifiers |= HID_KEYBOARD_MODIFIER_RIGHT_CONTROL;
+        modifiers |= HID_MODIFIER_RIGHT_CONTROL;
    }
    if (mod & KMOD_RSHIFT) {
-        modifiers |= HID_KEYBOARD_MODIFIER_RIGHT_SHIFT;
+        modifiers |= HID_MODIFIER_RIGHT_SHIFT;
    }
    if (mod & KMOD_RALT) {
-        modifiers |= HID_KEYBOARD_MODIFIER_RIGHT_ALT;
+        modifiers |= HID_MODIFIER_RIGHT_ALT;
    }
    if (mod & KMOD_RGUI) {
-        modifiers |= HID_KEYBOARD_MODIFIER_RIGHT_GUI;
+        modifiers |= HID_MODIFIER_RIGHT_GUI;
    }
    return modifiers;
 }

 static bool
-hid_keyboard_event_init(struct hid_event *hid_event) {
+sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) {
    unsigned char *buffer = malloc(HID_KEYBOARD_EVENT_SIZE);
    if (!buffer) {
        return false;
    }

-    buffer[HID_KEYBOARD_INDEX_MODIFIER] = HID_KEYBOARD_MODIFIER_NONE;
-    buffer[1] = HID_KEYBOARD_RESERVED;
+    buffer[HID_KEYBOARD_INDEX_MODIFIER] = HID_MODIFIER_NONE;
+    buffer[1] = HID_RESERVED;
    memset(&buffer[HID_KEYBOARD_INDEX_KEYS], 0, HID_KEYBOARD_MAX_KEYS);

-    hid_event_init(hid_event, HID_KEYBOARD_ACCESSORY_ID, buffer,
-                   HID_KEYBOARD_EVENT_SIZE);
+    sc_hid_event_init(hid_event, HID_KEYBOARD_ACCESSORY_ID, buffer,
+                      HID_KEYBOARD_EVENT_SIZE);
    return true;
 }

@@ -179,35 +178,28 @@ scancode_is_modifier(SDL_Scancode scancode) {
 }

 static bool
-convert_hid_keyboard_event(struct hid_keyboard *kb, struct hid_event *hid_event,
+convert_hid_keyboard_event(struct sc_hid_keyboard *kb,
+                           struct sc_hid_event *hid_event,
                           const SDL_KeyboardEvent *event) {
-    LOGV(
-        "Type: %s, Repeat: %s, Modifiers: %02x, Key: %02x",
-        event->type == SDL_KEYDOWN ? "down" : "up",
-        event->repeat != 0 ? "true" : "false",
-        sdl_keymod_to_hid_modifiers(event->keysym.mod),
-        event->keysym.scancode
-    );
-
    SDL_Scancode scancode = event->keysym.scancode;
    assert(scancode >= 0);

    // SDL also generates events when only modifiers are pressed, we cannot
    // ignore them totally, for example press 'a' first then press 'Control',
    // if we ignore 'Control' event, only 'a' is sent.
-    if (scancode >= HID_KEYBOARD_KEYS && !scancode_is_modifier(scancode)) {
+    if (scancode >= SC_HID_KEYBOARD_KEYS && !scancode_is_modifier(scancode)) {
        // Scancode to ignore
        return false;
    }

-    if (!hid_keyboard_event_init(hid_event)) {
-        LOGW("Could not initialize HID event");
+    if (!sc_hid_keyboard_event_init(hid_event)) {
+        LOGW("Could not initialize HID keyboard event");
        return false;
    }

    unsigned char modifiers = sdl_keymod_to_hid_modifiers(event->keysym.mod);

-    if (scancode < HID_KEYBOARD_KEYS) {
+    if (scancode < SC_HID_KEYBOARD_KEYS) {
        // Pressed is true and released is false
        kb->keys[scancode] = (event->type == SDL_KEYDOWN);
        LOGV("keys[%02x] = %s", scancode,
@@ -216,9 +208,10 @@ convert_hid_keyboard_event(struct hid_keyboard *kb, struct hid_event *hid_event,

    hid_event->buffer[HID_KEYBOARD_INDEX_MODIFIER] = modifiers;

+    unsigned char *keys_buffer = &hid_event->buffer[HID_KEYBOARD_INDEX_KEYS];
    // Re-calculate pressed keys every time
    int keys_pressed_count = 0;
-    for (int i = 0; i < HID_KEYBOARD_KEYS; ++i) {
+    for (int i = 0; i < SC_HID_KEYBOARD_KEYS; ++i) {
        if (kb->keys[i]) {
            // USB HID protocol says that if keys exceeds report count, a
            // phantom state should be reported
@@ -226,23 +219,27 @@ convert_hid_keyboard_event(struct hid_keyboard *kb, struct hid_event *hid_event,
                // Pantom state:
                //  - Modifiers
                //  - Reserved
-                //  - ErrorRollOver * HID_KEYBOARD_MAX_KEYS
-                memset(&hid_event->buffer[HID_KEYBOARD_INDEX_KEYS],
-                       HID_KEYBOARD_ERROR_ROLL_OVER, HID_KEYBOARD_MAX_KEYS);
-                return true;
+                //  - ErrorRollOver * HID_MAX_KEYS
+                memset(keys_buffer, HID_ERROR_ROLL_OVER, HID_KEYBOARD_MAX_KEYS);
+                goto end;
            }

-            hid_event->buffer[HID_KEYBOARD_INDEX_KEYS + keys_pressed_count] = i;
+            keys_buffer[keys_pressed_count] = i;
            ++keys_pressed_count;
        }
    }

+end:
+    LOGV("hid keyboard: key %-4s scancode=%02x (%u) mod=%02x",
+         event->type == SDL_KEYDOWN ? "down" : "up", event->keysym.scancode,
+         event->keysym.scancode, modifiers);
+
    return true;
 }


 static bool
-push_mod_lock_state(struct hid_keyboard *kb, uint16_t sdl_mod) {
+push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) {
    bool capslock = sdl_mod & KMOD_CAPS;
    bool numlock = sdl_mod & KMOD_NUM;
    if (!capslock && !numlock) {
@@ -250,9 +247,9 @@ push_mod_lock_state(struct hid_keyboard *kb, uint16_t sdl_mod) {
        return true;
    }

-    struct hid_event hid_event;
-    if (!hid_keyboard_event_init(&hid_event)) {
-        LOGW("Could not initialize HID event");
+    struct sc_hid_event hid_event;
+    if (!sc_hid_keyboard_event_init(&hid_event)) {
+        LOGW("Could not initialize HID keyboard event");
        return false;
    }

@@ -268,7 +265,8 @@ push_mod_lock_state(struct hid_keyboard *kb, uint16_t sdl_mod) {
        ++i;
    }

-    if (!aoa_push_hid_event(kb->aoa, &hid_event)) {
+    if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
+        sc_hid_event_destroy(&hid_event);
        LOGW("Could request HID event");
        return false;
    }
@@ -287,9 +285,9 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
        return;
    }

-    struct hid_keyboard *kb = DOWNCAST(kp);
+    struct sc_hid_keyboard *kb = DOWNCAST(kp);

-    struct hid_event hid_event;
+    struct sc_hid_event hid_event;
    // Not all keys are supported, just ignore unsupported keys
    if (convert_hid_keyboard_event(kb, &hid_event, event)) {
        if (!kb->mod_lock_synchronized) {
@@ -312,8 +310,8 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
            hid_event.delay = SC_TICK_FROM_MS(2);
        }

-        if (!aoa_push_hid_event(kb->aoa, &hid_event)) {
-            hid_event_destroy(&hid_event);
+        if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
+            sc_hid_event_destroy(&hid_event);
            LOGW("Could request HID event");
        }
    }
@@ -329,19 +327,19 @@ sc_key_processor_process_text(struct sc_key_processor *kp,
 }

 bool
-hid_keyboard_init(struct hid_keyboard *kb, struct aoa *aoa) {
+sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa) {
    kb->aoa = aoa;

-    bool ok = aoa_setup_hid(aoa, HID_KEYBOARD_ACCESSORY_ID,
-                            keyboard_report_desc,
-                            ARRAY_LEN(keyboard_report_desc));
+    bool ok = sc_aoa_setup_hid(aoa, HID_KEYBOARD_ACCESSORY_ID,
+                               keyboard_report_desc,
+                               ARRAY_LEN(keyboard_report_desc));
    if (!ok) {
-        LOGW("Register HID for keyboard failed");
+        LOGW("Register HID keyboard failed");
        return false;
    }

    // Reset all states
-    memset(kb->keys, false, HID_KEYBOARD_KEYS);
+    memset(kb->keys, false, SC_HID_KEYBOARD_KEYS);

    kb->mod_lock_synchronized = false;

@@ -356,10 +354,10 @@ hid_keyboard_init(struct hid_keyboard *kb, struct aoa *aoa) {
 }

 void
-hid_keyboard_destroy(struct hid_keyboard *kb) {
+sc_hid_keyboard_destroy(struct sc_hid_keyboard *kb) {
    // Unregister HID keyboard so the soft keyboard shows again on Android
-    bool ok = aoa_unregister_hid(kb->aoa, HID_KEYBOARD_ACCESSORY_ID);
+    bool ok = sc_aoa_unregister_hid(kb->aoa, HID_KEYBOARD_ACCESSORY_ID);
    if (!ok) {
-        LOGW("Could not unregister HID");
+        LOGW("Could not unregister HID keyboard");
    }
 }
--- a/app/src/hid_keyboard.h
+++ b/app/src/hid_keyboard.h
@@ -1,12 +1,10 @@
-#ifndef HID_KEYBOARD_H
-#define HID_KEYBOARD_H
+#ifndef SC_HID_KEYBOARD_H
+#define SC_HID_KEYBOARD_H

 #include "common.h"

 #include <stdbool.h>

-#include <SDL2/SDL.h>
-
 #include "aoa_hid.h"
 #include "trait/key_processor.h"

@@ -14,7 +12,7 @@
 // Maybe SDL_Keycode is used by most people, but SDL_Scancode is taken from USB
 // HID protocol.
 // 0x65 is Application, typically AT-101 Keyboard ends here.
-#define HID_KEYBOARD_KEYS 0x66
+#define SC_HID_KEYBOARD_KEYS 0x66

 /**
 * HID keyboard events are sequence-based, every time keyboard state changes
@@ -28,19 +26,19 @@
 * phantom state. Don't forget that modifiers should be updated too, even for
 * phantom state.
 */
-struct hid_keyboard {
+struct sc_hid_keyboard {
    struct sc_key_processor key_processor; // key processor trait

-    struct aoa *aoa;
-    bool keys[HID_KEYBOARD_KEYS];
+    struct sc_aoa *aoa;
+    bool keys[SC_HID_KEYBOARD_KEYS];

    bool mod_lock_synchronized;
 };

 bool
-hid_keyboard_init(struct hid_keyboard *kb, struct aoa *aoa);
+sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa);

 void
-hid_keyboard_destroy(struct hid_keyboard *kb);
+sc_hid_keyboard_destroy(struct sc_hid_keyboard *kb);

 #endif
--- a/app/src/icon.c
+++ b/app/src/icon.c
@@ -0,0 +1,282 @@
+#include "icon.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <libavformat/avformat.h>
+#include <libavutil/pixdesc.h>
+#include <libavutil/pixfmt.h>
+
+#include "config.h"
+#include "compat.h"
+#include "util/log.h"
+#include "util/process.h"
+#include "util/str_util.h"
+
+#define SCRCPY_PORTABLE_ICON_FILENAME "icon.png"
+#define SCRCPY_DEFAULT_ICON_PATH \
+    PREFIX "/share/icons/hicolor/256x256/apps/scrcpy.png"
+
+static char *
+get_icon_path(void) {
+#ifdef __WINDOWS__
+    const wchar_t *icon_path_env = _wgetenv(L"SCRCPY_ICON_PATH");
+#else
+    const char *icon_path_env = getenv("SCRCPY_ICON_PATH");
+#endif
+    if (icon_path_env) {
+        // if the envvar is set, use it
+#ifdef __WINDOWS__
+        char *icon_path = utf8_from_wide_char(icon_path_env);
+#else
+        char *icon_path = strdup(icon_path_env);
+#endif
+        if (!icon_path) {
+            LOGE("Could not allocate memory");
+            return NULL;
+        }
+        LOGD("Using SCRCPY_ICON_PATH: %s", icon_path);
+        return icon_path;
+    }
+
+#ifndef PORTABLE
+    LOGD("Using icon: " SCRCPY_DEFAULT_ICON_PATH);
+    char *icon_path = strdup(SCRCPY_DEFAULT_ICON_PATH);
+    if (!icon_path) {
+        LOGE("Could not allocate memory");
+        return NULL;
+    }
+#else
+    char *icon_path = get_local_file_path(SCRCPY_PORTABLE_ICON_FILENAME);
+    if (!icon_path) {
+        LOGE("Could not get icon path");
+        return NULL;
+    }
+    LOGD("Using icon (portable): %s", icon_path);
+#endif
+
+    return icon_path;
+}
+
+static AVFrame *
+decode_image(const char *path) {
+    AVFrame *result = NULL;
+
+    AVFormatContext *ctx = avformat_alloc_context();
+    if (!ctx) {
+        LOGE("Could not allocate image decoder context");
+        return NULL;
+    }
+
+    if (avformat_open_input(&ctx, path, NULL, NULL) < 0) {
+        LOGE("Could not open image codec: %s", path);
+        goto free_ctx;
+    }
+
+    if (avformat_find_stream_info(ctx, NULL) < 0) {
+        LOGE("Could not find image stream info");
+        goto close_input;
+    }
+
+    int stream = av_find_best_stream(ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
+    if (stream < 0 ) {
+        LOGE("Could not find best image stream");
+        goto close_input;
+    }
+
+    AVCodecParameters *params = ctx->streams[stream]->codecpar;
+
+    AVCodec *codec = avcodec_find_decoder(params->codec_id);
+    if (!codec) {
+        LOGE("Could not find image decoder");
+        goto close_input;
+    }
+
+    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
+    if (!codec_ctx) {
+        LOGE("Could not allocate codec context");
+        goto close_input;
+    }
+
+    if (avcodec_parameters_to_context(codec_ctx, params) < 0) {
+        LOGE("Could not fill codec context");
+        goto free_codec_ctx;
+    }
+
+    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
+        LOGE("Could not open image codec");
+        goto free_codec_ctx;
+    }
+
+    AVFrame *frame = av_frame_alloc();
+    if (!frame) {
+        LOGE("Could not allocate frame");
+        goto close_codec;
+    }
+
+    AVPacket *packet = av_packet_alloc();
+    if (!packet) {
+        LOGE("Could not allocate packet");
+        av_frame_free(&frame);
+        goto close_codec;
+    }
+
+    if (av_read_frame(ctx, packet) < 0) {
+        LOGE("Could not read frame");
+        av_packet_free(&packet);
+        av_frame_free(&frame);
+        goto close_codec;
+    }
+
+    int ret;
+    if ((ret = avcodec_send_packet(codec_ctx, packet)) < 0) {
+        LOGE("Could not send icon packet: %d", ret);
+        av_packet_free(&packet);
+        av_frame_free(&frame);
+        goto close_codec;
+    }
+
+    if ((ret = avcodec_receive_frame(codec_ctx, frame)) != 0) {
+        LOGE("Could not receive icon frame: %d", ret);
+        av_packet_free(&packet);
+        av_frame_free(&frame);
+        goto close_codec;
+    }
+
+    av_packet_free(&packet);
+
+    result = frame;
+
+close_codec:
+    avcodec_close(codec_ctx);
+free_codec_ctx:
+    avcodec_free_context(&codec_ctx);
+close_input:
+    avformat_close_input(&ctx);
+free_ctx:
+    avformat_free_context(ctx);
+
+    return result;
+}
+
+static SDL_PixelFormatEnum
+to_sdl_pixel_format(enum AVPixelFormat fmt) {
+    switch (fmt) {
+        case AV_PIX_FMT_RGB24: return SDL_PIXELFORMAT_RGB24;
+        case AV_PIX_FMT_BGR24: return SDL_PIXELFORMAT_BGR24;
+        case AV_PIX_FMT_ARGB: return SDL_PIXELFORMAT_ARGB32;
+        case AV_PIX_FMT_RGBA: return SDL_PIXELFORMAT_RGBA32;
+        case AV_PIX_FMT_ABGR: return SDL_PIXELFORMAT_ABGR32;
+        case AV_PIX_FMT_BGRA: return SDL_PIXELFORMAT_BGRA32;
+        case AV_PIX_FMT_RGB565BE: return SDL_PIXELFORMAT_RGB565;
+        case AV_PIX_FMT_RGB555BE: return SDL_PIXELFORMAT_RGB555;
+        case AV_PIX_FMT_BGR565BE: return SDL_PIXELFORMAT_BGR565;
+        case AV_PIX_FMT_BGR555BE: return SDL_PIXELFORMAT_BGR555;
+        case AV_PIX_FMT_RGB444BE: return SDL_PIXELFORMAT_RGB444;
+        case AV_PIX_FMT_BGR444BE: return SDL_PIXELFORMAT_BGR444;
+        case AV_PIX_FMT_PAL8: return SDL_PIXELFORMAT_INDEX8;
+        default: return SDL_PIXELFORMAT_UNKNOWN;
+    }
+}
+
+static SDL_Surface *
+load_from_path(const char *path) {
+    AVFrame *frame = decode_image(path);
+    if (!frame) {
+        return NULL;
+    }
+
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
+    if (!desc) {
+        LOGE("Could not get icon format descriptor");
+        goto error;
+    }
+
+    bool is_packed = !(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
+    if (!is_packed) {
+        LOGE("Could not load non-packed icon");
+        goto error;
+    }
+
+    SDL_PixelFormatEnum format = to_sdl_pixel_format(frame->format);
+    if (format == SDL_PIXELFORMAT_UNKNOWN) {
+        LOGE("Unsupported icon pixel format: %s (%d)", desc->name,
+                                                       frame->format);
+        goto error;
+    }
+
+    int bits_per_pixel = av_get_bits_per_pixel(desc);
+    SDL_Surface *surface =
+        SDL_CreateRGBSurfaceWithFormatFrom(frame->data[0],
+                                           frame->width, frame->height,
+                                           bits_per_pixel,
+                                           frame->linesize[0],
+                                           format);
+
+    if (!surface) {
+        LOGE("Could not create icon surface");
+        goto error;
+    }
+
+    if (frame->format == AV_PIX_FMT_PAL8) {
+        // Initialize the SDL palette
+        uint8_t *data = frame->data[1];
+        SDL_Color colors[256];
+        for (int i = 0; i < 256; ++i) {
+            SDL_Color *color = &colors[i];
+
+            // The palette is transported in AVFrame.data[1], is 1024 bytes
+            // long (256 4-byte entries) and is formatted the same as in
+            // AV_PIX_FMT_RGB32 described above (i.e., it is also
+            // endian-specific).
+            // <https://ffmpeg.org/doxygen/4.1/pixfmt_8h.html#a9a8e335cf3be472042bc9f0cf80cd4c5>
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+            color->a = data[i * 4];
+            color->r = data[i * 4 + 1];
+            color->g = data[i * 4 + 2];
+            color->b = data[i * 4 + 3];
+#else
+            color->a = data[i * 4 + 3];
+            color->r = data[i * 4 + 2];
+            color->g = data[i * 4 + 1];
+            color->b = data[i * 4];
+#endif
+        }
+
+        SDL_Palette *palette = surface->format->palette;
+        assert(palette);
+        int ret = SDL_SetPaletteColors(palette, colors, 0, 256);
+        if (ret) {
+            LOGE("Could not set palette colors");
+            SDL_FreeSurface(surface);
+            goto error;
+        }
+    }
+
+    surface->userdata = frame; // frame owns the data
+
+    return surface;
+
+error:
+    av_frame_free(&frame);
+    return NULL;
+}
+
+SDL_Surface *
+scrcpy_icon_load() {
+    char *icon_path = get_icon_path();
+    if (!icon_path) {
+        return NULL;
+    }
+
+    SDL_Surface *icon = load_from_path(icon_path);
+    free(icon_path);
+    return icon;
+}
+
+void
+scrcpy_icon_destroy(SDL_Surface *icon) {
+    AVFrame *frame = icon->userdata;
+    assert(frame);
+    av_frame_free(&frame);
+    SDL_FreeSurface(icon);
+}
--- a/app/src/icon.h
+++ b/app/src/icon.h
@@ -0,0 +1,16 @@
+#ifndef ICON_H
+#define ICON_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <SDL2/SDL.h>
+#include <libavformat/avformat.h>
+
+SDL_Surface *
+scrcpy_icon_load(void);
+
+void
+scrcpy_icon_destroy(SDL_Surface *icon);
+
+#endif
--- a/app/src/icon.xpm
+++ b/app/src/icon.xpm
@@ -1,53 +0,0 @@
-/* XPM */
-static char * icon_xpm[] = {
-"48 48 2 1",
-" 	c None",
-".	c #96C13E",
-"              ..                ..              ",
-"              ...              ...              ",
-"               ...   ......   ...               ",
-"                ................                ",
-"                 ..............                 ",
-"                ................                ",
-"               ..................               ",
-"              ....................              ",
-"             .....  ........  .....             ",
-"             .....  ........  .....             ",
-"             ......................             ",
-"            ........................            ",
-"            ........................            ",
-"            ........................            ",
-"                                                ",
-"                                                ",
-"     ....   ........................   ....     ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"    ......  ........................  ......    ",
-"     ....   ........................   ....     ",
-"            ........................            ",
-"             ......................             ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                ......    ......                ",
-"                 ....      ....                 "};
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@@ -7,7 +7,7 @@
 #include "util/log.h"

 bool
-receiver_init(struct receiver *receiver, socket_t control_socket) {
+receiver_init(struct receiver *receiver, sc_socket control_socket) {
    bool ok = sc_mutex_init(&receiver->mutex);
    if (!ok) {
        return false;
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@@ -11,13 +11,13 @@
 // receive events from the device
 // managed by the controller
 struct receiver {
-    socket_t control_socket;
+    sc_socket control_socket;
    sc_thread thread;
    sc_mutex mutex;
 };

 bool
-receiver_init(struct receiver *receiver, socket_t control_socket);
+receiver_init(struct receiver *receiver, sc_socket control_socket);

 void
 receiver_destroy(struct receiver *receiver);
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -27,7 +27,6 @@
 #include "screen.h"
 #include "server.h"
 #include "stream.h"
-#include "tiny_xpm.h"
 #include "util/log.h"
 #include "util/net.h"
 #ifdef HAVE_V4L2
@@ -46,12 +45,12 @@ struct scrcpy {
    struct controller controller;
    struct file_handler file_handler;
 #ifdef HAVE_AOA_HID
-    struct aoa aoa;
+    struct sc_aoa aoa;
 #endif
    union {
        struct sc_keyboard_inject keyboard_inject;
 #ifdef HAVE_AOA_HID
-        struct hid_keyboard keyboard_hid;
+        struct sc_hid_keyboard keyboard_hid;
 #endif
    };
    struct sc_mouse_inject mouse_inject;
@@ -451,20 +450,20 @@ scrcpy(struct scrcpy_options *options) {
                LOGI("Device serial: %s", serial);
            }

-            bool ok = aoa_init(&s->aoa, serial);
+            bool ok = sc_aoa_init(&s->aoa, serial);
            free(serialno);
            if (!ok) {
                goto aoa_hid_end;
            }

-            if (!hid_keyboard_init(&s->keyboard_hid, &s->aoa)) {
-                aoa_destroy(&s->aoa);
+            if (!sc_hid_keyboard_init(&s->keyboard_hid, &s->aoa)) {
+                sc_aoa_destroy(&s->aoa);
                goto aoa_hid_end;
            }

-            if (!aoa_start(&s->aoa)) {
-                hid_keyboard_destroy(&s->keyboard_hid);
-                aoa_destroy(&s->aoa);
+            if (!sc_aoa_start(&s->aoa)) {
+                sc_hid_keyboard_destroy(&s->keyboard_hid);
+                sc_aoa_destroy(&s->aoa);
                goto aoa_hid_end;
            }

@@ -477,13 +476,13 @@ aoa_hid_end:
            if (!aoa_hid_ok) {
                LOGE("Failed to enable HID over AOA, "
                     "fallback to default keyboard injection method "
-                     "(-K/--keyboard-hid ignored)");
+                     "(-K/--hid-keyboard ignored)");
                options->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT;
            }
 #else
            LOGE("HID over AOA is not supported on this platform, "
                 "fallback to default keyboard injection method "
-                 "(-K/--keyboard-hid ignored)");
+                 "(-K/--hid-keyboard ignored)");
            options->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT;
 #endif
        }
@@ -514,8 +513,8 @@ end:
    // end-of-stream
 #ifdef HAVE_AOA_HID
    if (aoa_hid_initialized) {
-        hid_keyboard_destroy(&s->keyboard_hid);
-        aoa_stop(&s->aoa);
+        sc_hid_keyboard_destroy(&s->keyboard_hid);
+        sc_aoa_stop(&s->aoa);
    }
 #endif
    if (controller_started) {
@@ -547,8 +546,8 @@ end:

 #ifdef HAVE_AOA_HID
    if (aoa_hid_initialized) {
-        aoa_join(&s->aoa);
-        aoa_destroy(&s->aoa);
+        sc_aoa_join(&s->aoa);
+        sc_aoa_destroy(&s->aoa);
    }
 #endif

--- a/app/src/screen.c
+++ b/app/src/screen.c
@@ -5,9 +5,8 @@
 #include <SDL2/SDL.h>

 #include "events.h"
-#include "icon.xpm"
+#include "icon.h"
 #include "scrcpy.h"
-#include "tiny_xpm.h"
 #include "video_buffer.h"
 #include "util/log.h"

@@ -405,10 +404,10 @@ screen_init(struct screen *screen, const struct screen_params *params) {
        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
    }

-    SDL_Surface *icon = read_xpm(icon_xpm);
+    SDL_Surface *icon = scrcpy_icon_load();
    if (icon) {
        SDL_SetWindowIcon(screen->window, icon);
-        SDL_FreeSurface(icon);
+        scrcpy_icon_destroy(icon);
    } else {
        LOGW("Could not load icon");
    }
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -3,7 +3,6 @@
 #include <assert.h>
 #include <errno.h>
 #include <inttypes.h>
-#include <libgen.h>
 #include <stdio.h>
 #include <SDL2/SDL_timer.h>
 #include <SDL2/SDL_platform.h>
@@ -48,54 +47,18 @@ get_server_path(void) {
        LOGE("Could not allocate memory");
        return NULL;
    }
-    // the absolute path is hardcoded
-    return server_path;
 #else
-
-    // use scrcpy-server in the same directory as the executable
-    char *executable_path = get_executable_path();
-    if (!executable_path) {
-        LOGE("Could not get executable path, "
-             "using " SERVER_FILENAME " from current directory");
-        // not found, use current directory
-        return strdup(SERVER_FILENAME);
-    }
-
-    // dirname() does not work correctly everywhere, so get the parent
-    // directory manually.
-    // See <https://github.com/Genymobile/scrcpy/issues/2619>
-    char *p = strrchr(executable_path, PATH_SEPARATOR);
-    if (!p) {
-        LOGE("Unexpected executable path: \"%s\" (it should contain a '%c')",
-             executable_path, PATH_SEPARATOR);
-        free(executable_path);
-        return strdup(SERVER_FILENAME);
-    }
-
-    *p = '\0'; // modify executable_path in place
-    char *dir = executable_path;
-    size_t dirlen = strlen(dir);
-
-    // sizeof(SERVER_FILENAME) gives statically the size including the null byte
-    size_t len = dirlen + 1 + sizeof(SERVER_FILENAME);
-    char *server_path = malloc(len);
+    char *server_path = get_local_file_path(SERVER_FILENAME);
    if (!server_path) {
-        LOGE("Could not alloc server path string, "
+        LOGE("Could not get local file path, "
             "using " SERVER_FILENAME " from current directory");
-        free(executable_path);
        return strdup(SERVER_FILENAME);
    }

-    memcpy(server_path, dir, dirlen);
-    server_path[dirlen] = PATH_SEPARATOR;
-    memcpy(&server_path[dirlen + 1], SERVER_FILENAME, sizeof(SERVER_FILENAME));
-    // the final null byte has been copied with SERVER_FILENAME
-
-    free(executable_path);
-
    LOGD("Using server (portable): %s", server_path);
-    return server_path;
 #endif
+
+    return server_path;
 }

 static bool
@@ -146,7 +109,7 @@ disable_tunnel(struct server *server) {
    return disable_tunnel_reverse(server->serial);
 }

-static socket_t
+static sc_socket
 listen_on_port(uint16_t port) {
 #define IPV4_LOCALHOST 0x7F000001
    return net_listen(IPV4_LOCALHOST, port, 1);
@@ -169,7 +132,7 @@ enable_tunnel_reverse_any_port(struct server *server,
        // need to try to connect until the server socket is listening on the
        // device.
        server->server_socket = listen_on_port(port);
-        if (server->server_socket != INVALID_SOCKET) {
+        if (server->server_socket != SC_INVALID_SOCKET) {
            // success
            server->local_port = port;
            return true;
@@ -326,11 +289,11 @@ execute_server(struct server *server, const struct server_params *params) {
    return adb_execute(server->serial, cmd, ARRAY_LEN(cmd));
 }

-static socket_t
+static sc_socket
 connect_and_read_byte(uint16_t port) {
-    socket_t socket = net_connect(IPV4_LOCALHOST, port);
-    if (socket == INVALID_SOCKET) {
-        return INVALID_SOCKET;
+    sc_socket socket = net_connect(IPV4_LOCALHOST, port);
+    if (socket == SC_INVALID_SOCKET) {
+        return SC_INVALID_SOCKET;
    }

    char byte;
@@ -339,17 +302,17 @@ connect_and_read_byte(uint16_t port) {
    if (net_recv(socket, &byte, 1) != 1) {
        // the server is not listening yet behind the adb tunnel
        net_close(socket);
-        return INVALID_SOCKET;
+        return SC_INVALID_SOCKET;
    }
    return socket;
 }

-static socket_t
+static sc_socket
 connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
    do {
        LOGD("Remaining connection attempts: %d", (int) attempts);
-        socket_t socket = connect_and_read_byte(port);
-        if (socket != INVALID_SOCKET) {
+        sc_socket socket = connect_and_read_byte(port);
+        if (socket != SC_INVALID_SOCKET) {
            // it worked!
            return socket;
        }
@@ -357,24 +320,13 @@ connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
            SDL_Delay(delay);
        }
    } while (--attempts > 0);
-    return INVALID_SOCKET;
-}
-
-static void
-close_socket(socket_t socket) {
-    assert(socket != INVALID_SOCKET);
-    net_shutdown(socket, SHUT_RDWR);
-    if (!net_close(socket)) {
-        LOGW("Could not close socket");
-    }
+    return SC_INVALID_SOCKET;
 }

 bool
 server_init(struct server *server) {
    server->serial = NULL;
    server->process = PROCESS_NONE;
-    atomic_flag_clear_explicit(&server->server_socket_closed,
-                               memory_order_relaxed);

    bool ok = sc_mutex_init(&server->mutex);
    if (!ok) {
@@ -389,9 +341,9 @@ server_init(struct server *server) {

    server->process_terminated = false;

-    server->server_socket = INVALID_SOCKET;
-    server->video_socket = INVALID_SOCKET;
-    server->control_socket = INVALID_SOCKET;
+    server->server_socket = SC_INVALID_SOCKET;
+    server->video_socket = SC_INVALID_SOCKET;
+    server->control_socket = SC_INVALID_SOCKET;

    server->local_port = 0;

@@ -413,12 +365,11 @@ run_wait_server(void *data) {

    // no need for synchronization, server_socket is initialized before this
    // thread was created
-    if (server->server_socket != INVALID_SOCKET
-            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
-        // On Linux, accept() is unblocked by shutdown(), but on Windows, it is
-        // unblocked by closesocket(). Therefore, call both (close_socket()).
-        close_socket(server->server_socket);
+    if (server->server_socket != SC_INVALID_SOCKET) {
+        // Unblock any accept()
+        net_interrupt(server->server_socket);
    }
+
    LOGD("Server terminated");
    return 0;
 }
@@ -467,21 +418,16 @@ server_start(struct server *server, const struct server_params *params) {
    return true;

 error:
-    if (!server->tunnel_forward) {
-        bool was_closed =
-            atomic_flag_test_and_set(&server->server_socket_closed);
-        // the thread is not started, the flag could not be already set
-        assert(!was_closed);
-        (void) was_closed;
-        close_socket(server->server_socket);
-    }
+    // The server socket (if any) will be closed on server_destroy()
+
    disable_tunnel(server);

    return false;
 }

 static bool
-device_read_info(socket_t device_socket, char *device_name, struct size *size) {
+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) {
@@ -504,35 +450,35 @@ bool
 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 == INVALID_SOCKET) {
+        if (server->video_socket == SC_INVALID_SOCKET) {
            return false;
        }

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

        // we don't need the server socket anymore
-        if (!atomic_flag_test_and_set(&server->server_socket_closed)) {
-            // close it from here
-            close_socket(server->server_socket);
-            // otherwise, it is closed by run_wait_server()
+        if (!net_close(server->server_socket)) {
+            LOGW("Could not close server socket on connect");
        }
+        // Do not attempt to close it again on server_destroy()
+        server->server_socket = SC_INVALID_SOCKET;
    } else {
        uint32_t attempts = 100;
        uint32_t delay = 100; // ms
        server->video_socket =
            connect_to_server(server->local_port, attempts, delay);
-        if (server->video_socket == INVALID_SOCKET) {
+        if (server->video_socket == SC_INVALID_SOCKET) {
            return false;
        }

        // we know that the device is listening, we don't need several attempts
        server->control_socket =
            net_connect(IPV4_LOCALHOST, server->local_port);
-        if (server->control_socket == INVALID_SOCKET) {
+        if (server->control_socket == SC_INVALID_SOCKET) {
            return false;
        }
    }
@@ -547,15 +493,20 @@ server_connect_to(struct server *server, char *device_name, struct size *size) {

 void
 server_stop(struct server *server) {
-    if (server->server_socket != INVALID_SOCKET
-            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
-        close_socket(server->server_socket);
+    if (server->server_socket != SC_INVALID_SOCKET) {
+        if (!net_interrupt(server->server_socket)) {
+            LOGW("Could not interrupt server socket");
+        }
    }
-    if (server->video_socket != INVALID_SOCKET) {
-        close_socket(server->video_socket);
+    if (server->video_socket != SC_INVALID_SOCKET) {
+        if (!net_interrupt(server->video_socket)) {
+            LOGW("Could not interrupt video socket");
+        }
    }
-    if (server->control_socket != INVALID_SOCKET) {
-        close_socket(server->control_socket);
+    if (server->control_socket != SC_INVALID_SOCKET) {
+        if (!net_interrupt(server->control_socket)) {
+            LOGW("Could not interrupt control socket");
+        }
    }

    assert(server->process != PROCESS_NONE);
@@ -592,6 +543,21 @@ server_stop(struct server *server) {

 void
 server_destroy(struct server *server) {
+    if (server->server_socket != SC_INVALID_SOCKET) {
+        if (!net_close(server->server_socket)) {
+            LOGW("Could not close server socket");
+        }
+    }
+    if (server->video_socket != SC_INVALID_SOCKET) {
+        if (!net_close(server->video_socket)) {
+            LOGW("Could not close video socket");
+        }
+    }
+    if (server->control_socket != SC_INVALID_SOCKET) {
+        if (!net_close(server->control_socket)) {
+            LOGW("Could not close control socket");
+        }
+    }
    free(server->serial);
    sc_cond_destroy(&server->process_terminated_cond);
    sc_mutex_destroy(&server->mutex);
--- a/app/src/server.h
+++ b/app/src/server.h
@@ -18,15 +18,14 @@ struct server {
    char *serial;
    process_t process;
    sc_thread wait_server_thread;
-    atomic_flag server_socket_closed;

    sc_mutex mutex;
    sc_cond process_terminated_cond;
    bool process_terminated;

-    socket_t server_socket; // only used if !tunnel_forward
-    socket_t video_socket;
-    socket_t control_socket;
+    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"
--- a/app/src/stream.c
+++ b/app/src/stream.c
@@ -260,7 +260,7 @@ end:
 }

 void
-stream_init(struct stream *stream, socket_t socket,
+stream_init(struct stream *stream, sc_socket socket,
            const struct stream_callbacks *cbs, void *cbs_userdata) {
    stream->socket = socket;
    stream->pending = NULL;
--- a/app/src/stream.h
+++ b/app/src/stream.h
@@ -14,7 +14,7 @@
 #define STREAM_MAX_SINKS 2

 struct stream {
-    socket_t socket;
+    sc_socket socket;
    sc_thread thread;

    struct sc_packet_sink *sinks[STREAM_MAX_SINKS];
@@ -35,7 +35,7 @@ struct stream_callbacks {
 };

 void
-stream_init(struct stream *stream, socket_t socket,
+stream_init(struct stream *stream, sc_socket socket,
            const struct stream_callbacks *cbs, void *cbs_userdata);

 void
--- a/app/src/tiny_xpm.c
+++ b/app/src/tiny_xpm.c
@@ -1,119 +0,0 @@
-#include "tiny_xpm.h"
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "util/log.h"
-
-struct index {
-    char c;
-    uint32_t color;
-};
-
-static bool
-find_color(struct index *index, int len, char c, uint32_t *color) {
-    // there are typically very few color, so it's ok to iterate over the array
-    for (int i = 0; i < len; ++i) {
-        if (index[i].c == c) {
-            *color = index[i].color;
-            return true;
-        }
-    }
-    *color = 0;
-    return false;
-}
-
-// We encounter some problems with SDL2_image on MSYS2 (Windows),
-// so here is our own XPM parsing not to depend on SDL_image.
-//
-// We do not hardcode the binary image to keep some flexibility to replace the
-// icon easily (just by replacing icon.xpm).
-//
-// Parameter is not "const char *" because XPM formats are generally stored in a
-// (non-const) "char *"
-SDL_Surface *
-read_xpm(char *xpm[]) {
-#ifndef NDEBUG
-    // patch the XPM to change the icon color in debug mode
-    xpm[2] = ".	c #CC00CC";
-#endif
-
-    char *endptr;
-    // *** No error handling, assume the XPM source is valid ***
-    // (it's in our source repo)
-    // Assertions are only checked in debug
-    int width = strtol(xpm[0], &endptr, 10);
-    int height = strtol(endptr + 1, &endptr, 10);
-    int colors = strtol(endptr + 1, &endptr, 10);
-    int chars = strtol(endptr + 1, &endptr, 10);
-
-    // sanity checks
-    assert(0 <= width && width < 256);
-    assert(0 <= height && height < 256);
-    assert(0 <= colors && colors < 256);
-    assert(chars == 1); // this implementation does not support more
-
-    (void) chars;
-
-    // init index
-    struct index index[colors];
-    for (int i = 0; i < colors; ++i) {
-        const char *line = xpm[1+i];
-        index[i].c = line[0];
-        assert(line[1] == '\t');
-        assert(line[2] == 'c');
-        assert(line[3] == ' ');
-        if (line[4] == '#') {
-            index[i].color = 0xff000000 | strtol(&line[5], &endptr, 0x10);
-            assert(*endptr == '\0');
-        } else {
-            assert(!strcmp("None", &line[4]));
-            index[i].color = 0;
-        }
-    }
-
-    // parse image
-    uint32_t *pixels = SDL_malloc(4 * width * height);
-    if (!pixels) {
-        LOGE("Could not allocate icon memory");
-        return NULL;
-    }
-    for (int y = 0; y < height; ++y) {
-        const char *line = xpm[1 + colors + y];
-        for (int x = 0; x < width; ++x) {
-            char c = line[x];
-            uint32_t color;
-            bool color_found = find_color(index, colors, c, &color);
-            assert(color_found);
-            (void) color_found;
-            pixels[y * width + x] = color;
-        }
-    }
-
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    uint32_t amask = 0x000000ff;
-    uint32_t rmask = 0x0000ff00;
-    uint32_t gmask = 0x00ff0000;
-    uint32_t bmask = 0xff000000;
-#else // little endian, like x86
-    uint32_t amask = 0xff000000;
-    uint32_t rmask = 0x00ff0000;
-    uint32_t gmask = 0x0000ff00;
-    uint32_t bmask = 0x000000ff;
-#endif
-
-    SDL_Surface *surface = SDL_CreateRGBSurfaceFrom(pixels,
-                                                    width, height,
-                                                    32, 4 * width,
-                                                    rmask, gmask, bmask, amask);
-    if (!surface) {
-        LOGE("Could not create icon surface");
-        return NULL;
-    }
-    // make the surface own the raw pixels
-    surface->flags &= ~SDL_PREALLOC;
-    return surface;
-}
--- a/app/src/tiny_xpm.h
+++ b/app/src/tiny_xpm.h
@@ -1,11 +0,0 @@
-#ifndef TINYXPM_H
-#define TINYXPM_H
-
-#include "common.h"
-
-#include <SDL2/SDL.h>
-
-SDL_Surface *
-read_xpm(char *xpm[]);
-
-#endif
--- a/app/src/util/net.c
+++ b/app/src/util/net.c
@@ -1,5 +1,6 @@
 #include "net.h"

+#include <assert.h>
 #include <stdio.h>
 #include <SDL2/SDL_platform.h>

@@ -7,6 +8,7 @@

 #ifdef __WINDOWS__
  typedef int socklen_t;
+  typedef SOCKET sc_raw_socket;
 #else
 # include <sys/types.h>
 # include <sys/socket.h>
@@ -17,122 +19,9 @@
  typedef struct sockaddr_in SOCKADDR_IN;
  typedef struct sockaddr SOCKADDR;
  typedef struct in_addr IN_ADDR;
+  typedef int sc_raw_socket;
 #endif

-static void
-net_perror(const char *s) {
-#ifdef _WIN32
-    int error = WSAGetLastError();
-    char *wsa_message;
-    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
-            NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-            (char *) &wsa_message, 0, NULL);
-    // no explicit '\n', wsa_message already contains a trailing '\n'
-    fprintf(stderr, "%s: [%d] %s", s, error, wsa_message);
-    LocalFree(wsa_message);
-#else
-    perror(s);
-#endif
-}
-
-socket_t
-net_connect(uint32_t addr, uint16_t port) {
-    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
-    if (sock == INVALID_SOCKET) {
-        net_perror("socket");
-        return INVALID_SOCKET;
-    }
-
-    SOCKADDR_IN sin;
-    sin.sin_family = AF_INET;
-    sin.sin_addr.s_addr = htonl(addr);
-    sin.sin_port = htons(port);
-
-    if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
-        net_perror("connect");
-        net_close(sock);
-        return INVALID_SOCKET;
-    }
-
-    return sock;
-}
-
-socket_t
-net_listen(uint32_t addr, uint16_t port, int backlog) {
-    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
-    if (sock == INVALID_SOCKET) {
-        net_perror("socket");
-        return INVALID_SOCKET;
-    }
-
-    int reuse = 1;
-    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
-                   sizeof(reuse)) == -1) {
-        net_perror("setsockopt(SO_REUSEADDR)");
-    }
-
-    SOCKADDR_IN sin;
-    sin.sin_family = AF_INET;
-    sin.sin_addr.s_addr = htonl(addr); // htonl() harmless on INADDR_ANY
-    sin.sin_port = htons(port);
-
-    if (bind(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
-        net_perror("bind");
-        net_close(sock);
-        return INVALID_SOCKET;
-    }
-
-    if (listen(sock, backlog) == SOCKET_ERROR) {
-        net_perror("listen");
-        net_close(sock);
-        return INVALID_SOCKET;
-    }
-
-    return sock;
-}
-
-socket_t
-net_accept(socket_t server_socket) {
-    SOCKADDR_IN csin;
-    socklen_t sinsize = sizeof(csin);
-    return accept(server_socket, (SOCKADDR *) &csin, &sinsize);
-}
-
-ssize_t
-net_recv(socket_t socket, void *buf, size_t len) {
-    return recv(socket, buf, len, 0);
-}
-
-ssize_t
-net_recv_all(socket_t socket, void *buf, size_t len) {
-    return recv(socket, buf, len, MSG_WAITALL);
-}
-
-ssize_t
-net_send(socket_t socket, const void *buf, size_t len) {
-    return send(socket, buf, len, 0);
-}
-
-ssize_t
-net_send_all(socket_t socket, const void *buf, size_t len) {
-    size_t copied = 0;
-    while (len > 0) {
-        ssize_t w = send(socket, buf, len, 0);
-        if (w == -1) {
-            return copied ? (ssize_t) copied : -1;
-        }
-        len -= w;
-        buf = (char *) buf + w;
-        copied += w;
-    }
-    return copied;
-}
-
-bool
-net_shutdown(socket_t socket, int how) {
-    return !shutdown(socket, how);
-}
-
 bool
 net_init(void) {
 #ifdef __WINDOWS__
@@ -153,11 +42,189 @@ net_cleanup(void) {
 #endif
 }

-bool
-net_close(socket_t socket) {
+static inline sc_socket
+wrap(sc_raw_socket sock) {
 #ifdef __WINDOWS__
-    return !closesocket(socket);
+    if (sock == INVALID_SOCKET) {
+        return SC_INVALID_SOCKET;
+    }
+
+    struct sc_socket_windows *socket = malloc(sizeof(*socket));
+    if (!socket) {
+        closesocket(sock);
+        return SC_INVALID_SOCKET;
+    }
+
+    socket->socket = sock;
+    socket->closed = (atomic_flag) ATOMIC_FLAG_INIT;
+
+    return socket;
 #else
-    return !close(socket);
+    return sock;
+#endif
+}
+
+static inline sc_raw_socket
+unwrap(sc_socket socket) {
+#ifdef __WINDOWS__
+    if (socket == SC_INVALID_SOCKET) {
+        return INVALID_SOCKET;
+    }
+
+    return socket->socket;
+#else
+    return socket;
+#endif
+}
+
+static void
+net_perror(const char *s) {
+#ifdef _WIN32
+    int error = WSAGetLastError();
+    char *wsa_message;
+    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+            NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+            (char *) &wsa_message, 0, NULL);
+    // no explicit '\n', wsa_message already contains a trailing '\n'
+    fprintf(stderr, "%s: [%d] %s", s, error, wsa_message);
+    LocalFree(wsa_message);
+#else
+    perror(s);
+#endif
+}
+
+sc_socket
+net_connect(uint32_t addr, uint16_t port) {
+    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
+    sc_socket sock = wrap(raw_sock);
+    if (sock == SC_INVALID_SOCKET) {
+        net_perror("socket");
+        return SC_INVALID_SOCKET;
+    }
+
+    SOCKADDR_IN sin;
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = htonl(addr);
+    sin.sin_port = htons(port);
+
+    if (connect(raw_sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
+        net_perror("connect");
+        net_close(sock);
+        return SC_INVALID_SOCKET;
+    }
+
+    return sock;
+}
+
+sc_socket
+net_listen(uint32_t addr, uint16_t port, int backlog) {
+    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
+    sc_socket sock = wrap(raw_sock);
+    if (sock == SC_INVALID_SOCKET) {
+        net_perror("socket");
+        return SC_INVALID_SOCKET;
+    }
+
+    int reuse = 1;
+    if (setsockopt(raw_sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
+                   sizeof(reuse)) == -1) {
+        net_perror("setsockopt(SO_REUSEADDR)");
+    }
+
+    SOCKADDR_IN sin;
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = htonl(addr); // htonl() harmless on INADDR_ANY
+    sin.sin_port = htons(port);
+
+    if (bind(raw_sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
+        net_perror("bind");
+        net_close(sock);
+        return SC_INVALID_SOCKET;
+    }
+
+    if (listen(raw_sock, backlog) == SOCKET_ERROR) {
+        net_perror("listen");
+        net_close(sock);
+        return SC_INVALID_SOCKET;
+    }
+
+    return sock;
+}
+
+sc_socket
+net_accept(sc_socket server_socket) {
+    sc_raw_socket raw_server_socket = unwrap(server_socket);
+
+    SOCKADDR_IN csin;
+    socklen_t sinsize = sizeof(csin);
+    sc_raw_socket raw_sock =
+        accept(raw_server_socket, (SOCKADDR *) &csin, &sinsize);
+
+    return wrap(raw_sock);
+}
+
+ssize_t
+net_recv(sc_socket socket, void *buf, size_t len) {
+    sc_raw_socket raw_sock = unwrap(socket);
+    return recv(raw_sock, buf, len, 0);
+}
+
+ssize_t
+net_recv_all(sc_socket socket, void *buf, size_t len) {
+    sc_raw_socket raw_sock = unwrap(socket);
+    return recv(raw_sock, buf, len, MSG_WAITALL);
+}
+
+ssize_t
+net_send(sc_socket socket, const void *buf, size_t len) {
+    sc_raw_socket raw_sock = unwrap(socket);
+    return send(raw_sock, buf, len, 0);
+}
+
+ssize_t
+net_send_all(sc_socket socket, const void *buf, size_t len) {
+    size_t copied = 0;
+    while (len > 0) {
+        ssize_t w = net_send(socket, buf, len);
+        if (w == -1) {
+            return copied ? (ssize_t) copied : -1;
+        }
+        len -= w;
+        buf = (char *) buf + w;
+        copied += w;
+    }
+    return copied;
+}
+
+bool
+net_interrupt(sc_socket socket) {
+    assert(socket != SC_INVALID_SOCKET);
+
+    sc_raw_socket raw_sock = unwrap(socket);
+
+#ifdef __WINDOWS__
+    if (!atomic_flag_test_and_set(&socket->closed)) {
+        return !closesocket(raw_sock);
+    }
+    return true;
+#else
+    return !shutdown(raw_sock, SHUT_RDWR);
+#endif
+}
+
+#include <errno.h>
+bool
+net_close(sc_socket socket) {
+    sc_raw_socket raw_sock = unwrap(socket);
+
+#ifdef __WINDOWS__
+    bool ret = true;
+    if (!atomic_flag_test_and_set(&socket->closed)) {
+        ret = !closesocket(raw_sock);
+    }
+    free(socket);
+    return ret;
+#else
+    return !close(raw_sock);
 #endif
 }
--- a/app/src/util/net.h
+++ b/app/src/util/net.h
@@ -8,15 +8,20 @@
 #include <SDL2/SDL_platform.h>

 #ifdef __WINDOWS__
+
 # include <winsock2.h>
-  #define SHUT_RD SD_RECEIVE
-  #define SHUT_WR SD_SEND
-  #define SHUT_RDWR SD_BOTH
-  typedef SOCKET socket_t;
-#else
+# include <stdatomic.h>
+# define SC_INVALID_SOCKET NULL
+  typedef struct sc_socket_windows {
+      SOCKET socket;
+      atomic_flag closed;
+  } *sc_socket;
+
+#else // not __WINDOWS__
+
 # include <sys/socket.h>
-# define INVALID_SOCKET -1
-  typedef int socket_t;
+# define SC_INVALID_SOCKET -1
+  typedef int sc_socket;
 #endif

 bool
@@ -25,33 +30,36 @@ net_init(void);
 void
 net_cleanup(void);

-socket_t
+sc_socket
 net_connect(uint32_t addr, uint16_t port);

-socket_t
+sc_socket
 net_listen(uint32_t addr, uint16_t port, int backlog);

-socket_t
-net_accept(socket_t server_socket);
+sc_socket
+net_accept(sc_socket server_socket);

 // the _all versions wait/retry until len bytes have been written/read
 ssize_t
-net_recv(socket_t socket, void *buf, size_t len);
+net_recv(sc_socket socket, void *buf, size_t len);

 ssize_t
-net_recv_all(socket_t socket, void *buf, size_t len);
+net_recv_all(sc_socket socket, void *buf, size_t len);

 ssize_t
-net_send(socket_t socket, const void *buf, size_t len);
+net_send(sc_socket socket, const void *buf, size_t len);

 ssize_t
-net_send_all(socket_t socket, const void *buf, size_t len);
+net_send_all(sc_socket socket, const void *buf, size_t len);

-// how is SHUT_RD (read), SHUT_WR (write) or SHUT_RDWR (both)
+// Shutdown the socket (or close on Windows) so that any blocking send() or
+// recv() are interrupted
 bool
-net_shutdown(socket_t socket, int how);
+net_interrupt(sc_socket socket);

+// Close the socket.
+// A socket must always be closed, even if net_interrupt() has been called.
 bool
-net_close(socket_t socket);
+net_close(sc_socket socket);

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

+#include <libgen.h>
 #include "log.h"

 bool
@@ -20,6 +21,47 @@ process_check_success(process_t proc, const char *name, bool close) {
    return true;
 }

+char *
+get_local_file_path(const char *name) {
+    char *executable_path = get_executable_path();
+    if (!executable_path) {
+        return NULL;
+    }
+
+    // dirname() does not work correctly everywhere, so get the parent
+    // directory manually.
+    // See <https://github.com/Genymobile/scrcpy/issues/2619>
+    char *p = strrchr(executable_path, PATH_SEPARATOR);
+    if (!p) {
+        LOGE("Unexpected executable path: \"%s\" (it should contain a '%c')",
+             executable_path, PATH_SEPARATOR);
+        free(executable_path);
+        return NULL;
+    }
+
+    *p = '\0'; // modify executable_path in place
+    char *dir = executable_path;
+    size_t dirlen = strlen(dir);
+    size_t namelen = strlen(name);
+
+    size_t len = dirlen + namelen + 2; // +2: '/' and '\0'
+    char *file_path = malloc(len);
+    if (!file_path) {
+        LOGE("Could not alloc path");
+        free(executable_path);
+        return NULL;
+    }
+
+    memcpy(file_path, dir, dirlen);
+    file_path[dirlen] = PATH_SEPARATOR;
+    // namelen + 1 to copy the final '\0'
+    memcpy(&file_path[dirlen + 1], name, namelen + 1);
+
+    free(executable_path);
+
+    return file_path;
+}
+
 ssize_t
 read_pipe_all(pipe_t pipe, char *data, size_t len) {
    size_t copied = 0;
--- a/app/src/util/process.h
+++ b/app/src/util/process.h
@@ -84,6 +84,11 @@ search_executable(const char *file);
 char *
 get_executable_path(void);

+// Return the absolute path of a file in the same directory as he executable.
+// May be NULL on error. To be freed by free().
+char *
+get_local_file_path(const char *name);
+
 // returns true if the file exists and is not a directory
 bool
 is_regular_file(const char *path);
--- a/data/icon.png
+++ b/data/icon.png
--- a/data/icon.svg
+++ b/data/icon.svg
@@ -0,0 +1,16 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" version="1.1">
+ <path style="opacity:0.2" d="m 16.846877,12 c -1.116351,0 -2.227419,0.912229 -2.015075,2 l 3.122973,16 -5.596557,11.109375 C 11.959876,41.871734 11.885244,42.336988 12.177176,43 c 0.278672,0.632897 0.998812,1 1.747448,1 H 24 34.075375 c 0.748637,0 1.468777,-0.367103 1.747448,-1 0.291932,-0.663012 0.217302,-1.128266 -0.181041,-1.890625 L 30.045225,30 33.168198,14 c 0.212344,-1.087771 -0.898724,-2 -2.015075,-2 H 24 Z"/>
+ <path style="fill:#cccccc" d="m 16.846877,11 c -1.116351,0 -2.227419,0.912229 -2.015075,2 l 3.122973,16 -5.596557,11.109375 C 11.959876,40.871734 11.885244,41.336988 12.177176,42 c 0.278672,0.632897 0.998812,1 1.747448,1 H 24 34.075375 c 0.748637,0 1.468777,-0.367103 1.747448,-1 0.291932,-0.663012 0.217302,-1.128266 -0.181041,-1.890625 L 30.045225,29 33.168198,13 c 0.212344,-1.087771 -0.898724,-2 -2.015075,-2 H 24 Z"/>
+ <rect style="opacity:0.2" width="40" height="32" x="4" y="6" rx="2" ry="2"/>
+ <path style="fill:#e4e4e4" d="m 4,33 v 2 c 0,1.108 0.892,2 2,2 h 36 c 1.108,0 2,-0.892 2,-2 v -2 z"/>
+ <path style="opacity:0.1" d="m 11.494141,15 a 1.5,1.5 0 0 0 -0.832032,0.255859 1.5,1.5 0 0 0 -0.40625,2.082032 l 3.13086,4.654297 C 10.404945,24.606192 8.4012371,28.299159 8.0019531,32.460938 7.9284599,34.000879 9.5546875,34 9.5546875,34 H 38.40625 c 0,0 1.672856,-3.38e-4 1.591797,-1.617188 -0.416529,-4.131451 -2.415618,-7.796833 -5.380859,-10.394531 l 3.126953,-4.65039 a 1.5,1.5 0 0 0 -0.40625,-2.082032 1.5,1.5 0 0 0 -1.125,-0.228515 1.5,1.5 0 0 0 -0.957032,0.634765 l -3.072265,4.566407 C 29.78649,18.814887 26.990024,18 24.001953,18 c -2.989385,0 -5.786177,0.815488 -8.183594,2.230469 l -3.074218,-4.56836 A 1.5,1.5 0 0 0 11.787109,15.027344 1.5,1.5 0 0 0 11.494141,15 Z"/>
+ <path style="fill:#077063" d="M 6,5 C 4.892,5 4,5.892 4,7 V 33 H 44 V 7 C 44,5.892 43.108,5 42,5 Z"/>
+ <path style="opacity:0.1;fill:#ffffff" d="M 6,5 C 4.892,5 4,5.892 4,7 V 8 C 4,6.892 4.892,6 6,6 h 36 c 1.108,0 2,0.892 2,2 V 7 C 44,5.892 43.108,5 42,5 Z"/>
+ <path style="fill:none;stroke:#30dd81;stroke-width:3;stroke-linecap:round" d="M 15.1998,21.000026 11.5,15.5"/>
+ <path style="fill:none;stroke:#30dd81;stroke-width:3;stroke-linecap:round" d="M 32.799764,21.000026 36.5,15.5"/>
+ <path style="fill:#30dd81" d="m 24.002386,17.000034 c -8.355868,0 -15.2214979,6.346843 -15.9999669,14.460906 C 7.9289259,33.000882 9.5544999,33 9.5544999,33 H 38.406003 c 0,0 1.672201,-3.35e-4 1.591142,-1.617185 C 39.182807,23.305596 32.331836,17.000034 24.002386,17.000034 Z"/>
+ <path style="opacity:0.2" d="m 16,25 a 1.9999959,1.9999959 0 0 0 -2,2 1.9999959,1.9999959 0 0 0 2,2 1.9999959,1.9999959 0 0 0 2,-2 1.9999959,1.9999959 0 0 0 -2,-2 z m 16,0 a 1.9999959,1.9999959 0 0 0 -2,2 1.9999959,1.9999959 0 0 0 2,2 1.9999959,1.9999959 0 0 0 2,-2 1.9999959,1.9999959 0 0 0 -2,-2 z"/>
+ <path style="fill:#ffffff" d="M 15.999996,24.000008 A 1.9999959,1.9999959 0 0 1 17.999992,26.000004 1.9999959,1.9999959 0 0 1 15.999996,28 1.9999959,1.9999959 0 0 1 14,26.000004 1.9999959,1.9999959 0 0 1 15.999996,24.000008 Z"/>
+ <path style="fill:#ffffff" d="M 31.999996,24.000008 A 1.9999959,1.9999959 0 0 1 33.999991,26.000004 1.9999959,1.9999959 0 0 1 31.999996,28 1.9999959,1.9999959 0 0 1 30,26.000004 1.9999959,1.9999959 0 0 1 31.999996,24.000008 Z"/>
+ <path style="fill:#ffffff;opacity:0.2" d="M 11.494141 14 A 1.5 1.5 0 0 0 10.662109 14.255859 A 1.5 1.5 0 0 0 10.115234 16.001953 A 1.5 1.5 0 0 1 10.662109 15.255859 A 1.5 1.5 0 0 1 11.494141 15 A 1.5 1.5 0 0 1 11.787109 15.027344 A 1.5 1.5 0 0 1 12.744141 15.662109 L 15.818359 20.230469 C 18.215776 18.815488 21.012568 18 24.001953 18 C 26.990024 18 29.78649 18.814887 32.183594 20.228516 L 35.255859 15.662109 A 1.5 1.5 0 0 1 36.212891 15.027344 A 1.5 1.5 0 0 1 37.337891 15.255859 A 1.5 1.5 0 0 1 37.910156 16.001953 A 1.5 1.5 0 0 0 37.337891 14.255859 A 1.5 1.5 0 0 0 36.212891 14.027344 A 1.5 1.5 0 0 0 35.255859 14.662109 L 32.183594 19.228516 C 29.78649 17.814887 26.990024 17 24.001953 17 C 21.012568 17 18.215776 17.815488 15.818359 19.230469 L 12.744141 14.662109 A 1.5 1.5 0 0 0 11.787109 14.027344 A 1.5 1.5 0 0 0 11.494141 14 z M 35.033203 21.369141 L 34.617188 21.988281 C 37.477056 24.493668 39.433905 27.993356 39.943359 31.945312 C 39.986866 31.783283 40.008864 31.598575 39.998047 31.382812 C 39.601372 27.448291 37.768055 23.938648 35.033203 21.369141 z M 12.970703 21.373047 C 10.220358 23.959215 8.3822757 27.496796 8.0019531 31.460938 C 7.9920657 31.668114 8.0150508 31.844846 8.0585938 32 C 8.5570234 28.027243 10.515755 24.509049 13.386719 21.992188 L 12.970703 21.373047 z"/>
+</svg>
--- a/release.mk
+++ b/release.mk
@@ -94,6 +94,7 @@ dist-win32: build-server build-win32
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp data/scrcpy-console.bat "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp data/scrcpy-noconsole.vbs "$(DIST)/$(WIN32_TARGET_DIR)"
+	cp data/icon.png "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
@@ -110,6 +111,7 @@ dist-win64: build-server build-win64
 	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp data/scrcpy-console.bat "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp data/scrcpy-noconsole.vbs "$(DIST)/$(WIN64_TARGET_DIR)"
+	cp data/icon.png "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
--- a/4
+++ b/4
@@ -20,4 +20,6 @@ then
    exit 1
 fi

-SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server" "$BUILDDIR/app/scrcpy" "$@"
+SCRCPY_ICON_PATH="data/icon.png" \
+SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server" \
+"$BUILDDIR/app/scrcpy" "$@"
Author	SHA1	Message	Date
Romain Vimont	106a3dfa19	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)	2021-10-26 23:01:51 +02:00
Romain Vimont	e5ea13770b	Add socket wrapper This paves the way to store an additional "closed" flag on Windows to interrupt and close properly.	2021-10-26 22:49:57 +02:00
Romain Vimont	3eac212af1	Use net_send() from net_send_all() This will make net_send_all() continue to work even if net_send() behavior is changed.	2021-10-26 22:49:45 +02:00
Romain Vimont	3adff37c2d	Use sc_ prefix for sockets Rename: - socket_t to sc_socket - INVALID_SOCKET to SC_INVALID_SOCKET	2021-10-26 22:49:45 +02:00
Romain Vimont	eb6afe7669	Move net_init() and net_cleanup() upwards These two functions are global, define them at the top of the implementation file. This is consistent with the header file.	2021-10-26 22:49:45 +02:00
Romain Vimont	5222f213f4	Update FAQ to mention HID keyboard	2021-10-26 21:30:04 +02:00
Romain Vimont	e4163321f0	Delay HID events on Ctrl+v When Ctrl+v is pressed, a control is sent to the device to set the device clipboard before injecting Ctrl+v. With the InputManager method, it is guaranteed that the device synchronization is executed before handling Ctrl+v, since the commands are executed on the device in sequence. However, HID are injected from the computer, so there is no such guarantee. As a consequence, on Android, Ctrl+v triggers a paste with the old clipboard content. To workaround the issue, wait a bit (2 milliseconds) from the AOA thread before injecting the event, to leave enough time for the clipboard to be set before injecting Ctrl+v.	2021-10-26 21:30:04 +02:00
Romain Vimont	c96874b257	Synchronize HID keyboard state on first event When an AOA HID keyboard is registered, CAPSLOCK and NUMLOCK are both disabled, regardless of the state of the computer keyboard. To synchronize the state, on first key event, inject CAPSLOCK and/or NUMLOCK if necessary.	2021-10-26 21:30:04 +02:00
Romain Vimont	511356710d	Retrieve device serial for AOA The serial is necessary to find the correct Android device for AOA. If it is not explicitly provided by the user via -s, then execute "adb getserialno" to retrieve it.	2021-10-26 21:30:04 +02:00
Romain Vimont	d55015e4cf	Expose function to get the device serial Expose adb_get_serialno() to retrieve the device serial via the command "adb getserialno".	2021-10-26 21:30:04 +02:00
Romain Vimont	0681480809	Add read_pipe_all() Add a convenience function to read from a pipe until all requested data has been read.	2021-10-26 21:30:04 +02:00
Romain Vimont	96b18dabaa	Expose adb execution with redirection Expose the redirection feature to the adb API.	2021-10-26 21:30:04 +02:00
Romain Vimont	eaf4afaad9	Add command execution with redirection Expose command execution with pipes to stdin, stdout and stderr. This will allow to read the result of adb commands.	2021-10-26 21:30:04 +02:00
Alynx Zhou	207082977a	Add support for USB HID keyboard over AOAv2 This provides a better input experience, by simulating a physical keyboard. It converts SDL keyboard events to proper HID events, and send them over AOAv2. This is a rewriting and bugfix of the origin code from @amosbird: <https://github.com/Genymobile/scrcpy/issues/279#issuecomment-453819354> The feature is enabled the command line option -K or --hid-keyboard, and is only available on Linux, over USB. Refs <https://source.android.com/devices/accessories/aoa2#hid-support> Refs <https://www.usb.org/sites/default/files/hid1_11.pdf> PR #2632 <https://github.com/Genymobile/scrcpy/pull/2632> Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-10-26 21:30:04 +02:00
Romain Vimont	f7d1efdf1d	Extract mouse processor trait Mainly for consistency with the keyboard processor trait. This could allow to provide alternative mouse processors.	2021-10-26 21:30:04 +02:00
Romain Vimont	bcf5a9750f	Extract keyboard processor trait This will allow to provide alternative key processors.	2021-10-26 21:30:04 +02:00
Romain Vimont	056d36ce4a	Fix trait header guards	2021-10-26 21:30:04 +02:00
Romain Vimont	bea3197c3f	Remove unused markdown link in README	2021-10-25 18:22:48 +02:00
Romain Vimont	d6568f64af	Mention SCRCPY_ICON_PATH envvar in README	2021-10-25 18:22:17 +02:00
Romain Vimont	580f5d8bb9	Add scrcpy icon to README	2021-10-25 18:08:37 +02:00
Romain Vimont	1e340caf76	Remove legacy scrcpy icon Remove the old icon in XPM format and the code to load it.	2021-10-25 18:08:37 +02:00
Romain Vimont	3d5b31e0cb	Add icon source in SVG format Scrcpy only uses the PNG format (because SDL only supports bitmap icons), but keep the SVG source in the repo.	2021-10-25 18:08:37 +02:00
Romain Vimont	6004f0b6b0	Use a new scrcpy icon Use the new icon designed by @varlesh: <https://github.com/Genymobile/scrcpy/pull/1987#issuecomment-949684080> Load it from a PNG file (SDL only supports bitmap icons).	2021-10-25 18:08:37 +02:00
Romain Vimont	12ed2f2402	Add support for palette icon formats To support more icon formats.	2021-10-25 18:08:37 +02:00
Romain Vimont	0e4564da03	Add icon loader Add helper to load icons from image files via FFmpeg.	2021-10-25 18:08:37 +02:00
Romain Vimont	156d958e77	Move common instruction out of ifdef Both ifdef-branches return server_path.	2021-10-25 18:08:31 +02:00
Romain Vimont	7229e3cce0	Extract util function to build a local file path Finding a local file in the scrcpy directory may be useful for files other than scrcpy-server in the future.	2021-10-25 16:29:43 +02:00