Draw a dark square when no texture is rendered

Draw a dark 10x10 square in the top-right corner to distinguish a black
frame from the absence of a frame (useful for debugging).

app/meson.build

@@ -15,7 +15,6 @@ src = [
     'src/delay_buffer.c',
     'src/demuxer.c',
     'src/device_msg.c',
-    'src/disconnect.c',
     'src/events.c',
     'src/icon.c',
     'src/file_pusher.c',
@@ -192,7 +191,8 @@ executable('scrcpy', src,
 datadir = get_option('datadir') # by default 'share'
 
 install_man('scrcpy.1')
-install_data('data/scrcpy.png',
+install_data('data/icon.png',
+             rename: 'scrcpy.png',
              install_dir: datadir / 'icons/hicolor/256x256/apps')
 install_data('data/zsh-completion/_scrcpy',
              install_dir: datadir / 'zsh/site-functions')
@@ -289,6 +289,6 @@ endif
 
 if meson.version().version_compare('>= 0.58.0')
        devenv = environment()
-       devenv.set('SCRCPY_ICON_DIR', meson.current_source_dir() / 'data')
+       devenv.set('SCRCPY_ICON_PATH', meson.current_source_dir() / 'data/icon.png')
        meson.add_devenv(devenv)
 endif

app/scrcpy.1

@@ -851,8 +851,8 @@ Path to adb.
 Device serial to use if no selector (\fB-s\fR, \fB-d\fR, \fB-e\fR or \fB\-\-tcpip=\fIaddr\fR) is specified.
 
 .TP
-.B SCRCPY_ICON_DIR
-Path to the icon directory.
+.B SCRCPY_ICON_PATH
+Path to the program icon.
 
 .TP
 .B SCRCPY_SERVER_PATH

app/src/cli.c

@@ -1249,8 +1249,8 @@ static const struct sc_envvar envvars[] = {
                 "--tcpip=<addr>) is specified",
     },
     {
-        .name = "SCRCPY_ICON_DIR",
-        .text = "Path to the icon directory",
+        .name = "SCRCPY_ICON_PATH",
+        .text = "Path to the program icon",
     },
     {
         .name = "SCRCPY_SERVER_PATH",

app/src/disconnect.c

@@ -1,88 +0,0 @@
-#include "disconnect.h"
-
-#include <assert.h>
-
-#include "icon.h"
-#include "util/log.h"
-
-static int
-run(void *userdata) {
-    struct sc_disconnect *d = userdata;
-
-    SDL_Surface *icon = sc_icon_load(SC_ICON_FILENAME_DISCONNECTED);
-    if (icon) {
-        d->cbs->on_icon_loaded(d, icon, d->cbs_userdata);
-    } else {
-        LOGE("Could not load disconnected icon");
-    }
-
-    sc_mutex_lock(&d->mutex);
-    bool timed_out = false;
-    while (!d->interrupted && !timed_out) {
-        timed_out = !sc_cond_timedwait(&d->cond, &d->mutex, d->deadline);
-    }
-    bool interrupted = d->interrupted;
-    sc_mutex_unlock(&d->mutex);
-
-    if (!interrupted) {
-        d->cbs->on_timeout(d, d->cbs_userdata);
-    }
-
-    return 0;
-}
-
-bool
-sc_disconnect_start(struct sc_disconnect *d, sc_tick deadline,
-                    const struct sc_disconnect_callbacks *cbs,
-                    void *cbs_userdata) {
-    bool ok = sc_mutex_init(&d->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&d->cond);
-    if (!ok) {
-        goto error_destroy_mutex;
-    }
-
-    d->deadline = deadline;
-    d->interrupted = false;
-
-    assert(cbs && cbs->on_icon_loaded && cbs->on_timeout);
-    d->cbs = cbs;
-    d->cbs_userdata = cbs_userdata;
-
-    ok = sc_thread_create(&d->thread, run, "scrcpy-dis", d);
-    if (!ok) {
-        goto error_destroy_cond;
-    }
-
-    return true;
-
-error_destroy_cond:
-    sc_cond_destroy(&d->cond);
-error_destroy_mutex:
-    sc_mutex_destroy(&d->mutex);
-
-    return false;
-}
-
-void
-sc_disconnect_interrupt(struct sc_disconnect *d) {
-    sc_mutex_lock(&d->mutex);
-    d->interrupted = true;
-    sc_mutex_unlock(&d->mutex);
-    // wake up blocking wait
-    sc_cond_signal(&d->cond);
-}
-
-void
-sc_disconnect_join(struct sc_disconnect *d) {
-    sc_thread_join(&d->thread, NULL);
-}
-
-void
-sc_disconnect_destroy(struct sc_disconnect *d) {
-    sc_cond_destroy(&d->cond);
-    sc_mutex_destroy(&d->mutex);
-}

app/src/disconnect.h

@@ -1,47 +0,0 @@
-#ifndef SC_DISCONNECT
-#define SC_DISCONNECT
-
-#include "common.h"
-
-#include "SDL3/SDL_surface.h"
-#include "util/tick.h"
-#include "util/thread.h"
-
-// Tool to handle loading the icon and signal timeout when the device is
-// unexpectedly disconnected
-struct sc_disconnect {
-    sc_tick deadline;
-
-    struct sc_thread thread;
-    struct sc_mutex mutex;
-    struct sc_cond cond;
-    bool interrupted;
-
-    const struct sc_disconnect_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct sc_disconnect_callbacks {
-    // Called when the disconnected icon is loaded
-    void (*on_icon_loaded)(struct sc_disconnect *d, SDL_Surface *icon,
-                           void *userdata);
-
-    // Called when the timeout expired (the scrcpy window must be closed)
-    void (*on_timeout)(struct sc_disconnect *d, void *userdata);
-};
-
-bool
-sc_disconnect_start(struct sc_disconnect *d, sc_tick deadline,
-                    const struct sc_disconnect_callbacks *cbs,
-                    void *cbs_userdata);
-
-void
-sc_disconnect_interrupt(struct sc_disconnect *d);
-
-void
-sc_disconnect_join(struct sc_disconnect *d);
-
-void
-sc_disconnect_destroy(struct sc_disconnect *d);
-
-#endif

app/src/events.c

@@ -6,13 +6,9 @@
 #include "util/thread.h"
 
 bool
-sc_push_event_impl(uint32_t type, void* ptr, const char *name) {
-    SDL_Event event = {
-        .user = {
-            .type = type,
-            .data1 = ptr,
-        }
-    };
+sc_push_event_impl(uint32_t type, const char *name) {
+    SDL_Event event;
+    event.type = type;
     bool ok = SDL_PushEvent(&event);
     if (!ok) {
         LOGE("Could not post %s event: %s", name, SDL_GetError());

app/src/events.h

@@ -9,24 +9,23 @@
 
 enum {
     SC_EVENT_NEW_FRAME = SDL_EVENT_USER,
+    SC_EVENT_OPEN_WINDOW,
     SC_EVENT_RUN_ON_MAIN_THREAD,
     SC_EVENT_DEVICE_DISCONNECTED,
     SC_EVENT_SERVER_CONNECTION_FAILED,
     SC_EVENT_SERVER_CONNECTED,
+    SC_EVENT_USB_DEVICE_DISCONNECTED,
     SC_EVENT_DEMUXER_ERROR,
     SC_EVENT_RECORDER_ERROR,
     SC_EVENT_TIME_LIMIT_REACHED,
     SC_EVENT_CONTROLLER_ERROR,
     SC_EVENT_AOA_OPEN_ERROR,
-    SC_EVENT_DISCONNECTED_ICON_LOADED,
-    SC_EVENT_DISCONNECTED_TIMEOUT,
 };
 
 bool
-sc_push_event_impl(uint32_t type, void* ptr, const char *name);
+sc_push_event_impl(uint32_t type, const char *name);
 
-#define sc_push_event(TYPE) sc_push_event_impl(TYPE, NULL, # TYPE)
-#define sc_push_event_with_data(TYPE, PTR) sc_push_event_impl(TYPE, PTR, # TYPE)
+#define sc_push_event(TYPE) sc_push_event_impl(TYPE, # TYPE)
 
 typedef void (*sc_runnable_fn)(void *userdata);
 

app/src/icon.c

@@ -14,37 +14,33 @@
 
 #include "config.h"
 #include "util/env.h"
-#include "util/file.h"
+#ifdef PORTABLE
+# include "util/file.h"
+#endif
 #include "util/log.h"
 
-#define SCRCPY_DEFAULT_ICON_DIR PREFIX "/share/icons/hicolor/256x256/apps"
+#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(const char *filename) {
-    char *icon_path;
-
-    char *icon_dir = sc_get_env("SCRCPY_ICON_DIR");
-    if (icon_dir) {
+get_icon_path(void) {
+    char *icon_path = sc_get_env("SCRCPY_ICON_PATH");
+    if (icon_path) {
         // if the envvar is set, use it
-        icon_path = sc_file_build_path(icon_dir, filename);
-        free(icon_dir);
-        if (!icon_path) {
-            LOG_OOM();
-            return NULL;
-        }
-        LOGD("Using icon from SCRCPY_ICON_DIR: %s", icon_path);
+        LOGD("Using SCRCPY_ICON_PATH: %s", icon_path);
         return icon_path;
     }
 
 #ifndef PORTABLE
-    icon_path = sc_file_build_path(SCRCPY_DEFAULT_ICON_DIR, filename);
+    LOGD("Using icon: " SCRCPY_DEFAULT_ICON_PATH);
+    icon_path = strdup(SCRCPY_DEFAULT_ICON_PATH);
     if (!icon_path) {
         LOG_OOM();
         return NULL;
     }
-    LOGD("Using icon: %s", icon_path);
 #else
-    icon_path = sc_file_get_local_path(filename);
+    icon_path = sc_file_get_local_path(SCRCPY_PORTABLE_ICON_FILENAME);
     if (!icon_path) {
         LOGE("Could not get icon path");
         return NULL;
@@ -181,7 +177,7 @@ to_sdl_pixel_format(enum AVPixelFormat fmt) {
 }
 
 static SDL_Surface *
-sc_icon_load_from_full_path(const char *path) {
+load_from_path(const char *path) {
     AVFrame *frame = decode_image(path);
     if (!frame) {
         return NULL;
@@ -278,19 +274,19 @@ error:
 }
 
 SDL_Surface *
-sc_icon_load(const char *filename) {
-    char *icon_path = get_icon_path(filename);
+scrcpy_icon_load(void) {
+    char *icon_path = get_icon_path();
     if (!icon_path) {
         return NULL;
     }
 
-    SDL_Surface *icon = sc_icon_load_from_full_path(icon_path);
+    SDL_Surface *icon = load_from_path(icon_path);
     free(icon_path);
     return icon;
 }
 
 void
-sc_icon_destroy(SDL_Surface *icon) {
+scrcpy_icon_destroy(SDL_Surface *icon) {
     SDL_PropertiesID props = SDL_GetSurfaceProperties(icon);
     assert(props);
     AVFrame *frame = SDL_GetPointerProperty(props, "sc_frame", NULL);

app/src/icon.h

@@ -5,13 +5,10 @@
 
 #include <SDL3/SDL_surface.h>
 
-#define SC_ICON_FILENAME_SCRCPY "scrcpy.png"
-#define SC_ICON_FILENAME_DISCONNECTED "disconnected.png"
-
 SDL_Surface *
-sc_icon_load(const char *filename);
+scrcpy_icon_load(void);
 
 void
-sc_icon_destroy(SDL_Surface *icon);
+scrcpy_icon_destroy(SDL_Surface *icon);
 
 #endif

app/src/scrcpy.c

@@ -173,9 +173,6 @@ event_loop(struct scrcpy *s, bool has_screen) {
         switch (event.type) {
             case SC_EVENT_DEVICE_DISCONNECTED:
                 LOGW("Device disconnected");
-                if (has_screen) {
-                    sc_screen_handle_event(&s->screen, &event);
-                }
                 return SCRCPY_EXIT_DISCONNECTED;
             case SC_EVENT_DEMUXER_ERROR:
                 LOGE("Demuxer error");
@@ -212,18 +209,17 @@ event_loop(struct scrcpy *s, bool has_screen) {
 }
 
 static void
-terminate_runnables_on_event_loop(void) {
+terminate_event_loop(void) {
     sc_reject_new_runnables();
 
     SDL_Event event;
-    while (SDL_PeepEvents(&event, 1, SDL_GETEVENT,
-                          SC_EVENT_RUN_ON_MAIN_THREAD,
-                          SC_EVENT_RUN_ON_MAIN_THREAD) == 1) {
-        assert(event.type == SC_EVENT_RUN_ON_MAIN_THREAD);
-        // Make sure all posted runnables are run, to avoid memory leaks
-        sc_runnable_fn run = event.user.data1;
-        void *userdata = event.user.data2;
-        run(userdata);
+    while (SDL_PollEvent(&event)) {
+        if (event.type == SC_EVENT_RUN_ON_MAIN_THREAD) {
+            // Make sure all posted runnables are run, to avoid memory leaks
+            sc_runnable_fn run = event.user.data1;
+            void *userdata = event.user.data2;
+            run(userdata);
+        }
     }
 }
 
@@ -418,7 +414,6 @@ scrcpy(struct scrcpy_options *options) {
     bool screen_initialized = false;
     bool timeout_initialized = false;
     bool timeout_started = false;
-    bool disconnected = false;
 
     struct sc_acksync *acksync = NULL;
 
@@ -951,8 +946,15 @@ aoa_complete:
     }
 
     ret = event_loop(s, options->window);
-    terminate_runnables_on_event_loop();
-    disconnected = ret == SCRCPY_EXIT_DISCONNECTED;
+    terminate_event_loop();
+    LOGD("quit...");
+
+    if (options->window) {
+        // Close the window immediately on closing, because screen_destroy()
+        // may only be called once the video demuxer thread is joined (it may
+        // take time)
+        sc_screen_hide_window(&s->screen);
+    }
 
 end:
     if (timeout_started) {
@@ -997,17 +999,6 @@ end:
         sc_server_stop(&s->server);
     }
 
-    if (screen_initialized) {
-        if (disconnected) {
-            sc_screen_handle_disconnection(&s->screen);
-        }
-        LOGD("Quit...");
-
-        // Close the window immediately, because sc_screen_destroy() may only be
-        // called once the video demuxer thread is joined (it may take time)
-        sc_screen_hide_window(&s->screen);
-    }
-
     if (timeout_started) {
         sc_timeout_join(&s->timeout);
     }

app/src/screen.c

@@ -184,7 +184,7 @@ compute_content_rect(struct sc_size render_size, struct sc_size content_size,
 static void
 sc_screen_update_content_rect(struct sc_screen *screen) {
     // Only upscale video frames, not icon
-    bool can_upscale = screen->video && !screen->disconnected;
+    bool can_upscale = screen->video;
 
     struct sc_size render_size =
         sc_sdl_get_render_output_size(screen->renderer);
@@ -205,14 +205,23 @@ sc_screen_render(struct sc_screen *screen, bool update_content_rect) {
     }
 
     SDL_Renderer *renderer = screen->renderer;
+    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
     sc_sdl_render_clear(renderer);
 
     bool ok = false;
     SDL_Texture *texture = screen->tex.texture;
     if (!texture) {
-        if (!screen->disconnected) {
-            LOGW("No texture to render");
-        }
+        // Draw a dark 10x10 square in the top-right corner to distinguish a
+        // black frame from the absence of a frame
+        struct sc_size render_size = sc_sdl_get_render_output_size(renderer);
+        SDL_SetRenderDrawColor(renderer, 0, 0, 0x33, 0xff);
+        SDL_FRect rect = {
+            .x = render_size.width - 20,
+            .y = 10,
+            .w = 10,
+            .h = 10,
+        };
+        SDL_RenderFillRect(renderer, &rect);
         goto end;
     }
 
@@ -282,11 +291,8 @@ sc_screen_frame_sink_open(struct sc_frame_sink *sink,
                           const AVCodecContext *ctx,
                           const struct sc_stream_session *session) {
     assert(ctx->pix_fmt == AV_PIX_FMT_YUV420P);
-    (void) ctx;
-    (void) session;
 
     struct sc_screen *screen = DOWNCAST(sink);
-    (void) screen;
 
     if (ctx->width <= 0 || ctx->width > 0xFFFF
             || ctx->height <= 0 || ctx->height > 0xFFFF) {
@@ -294,6 +300,19 @@ sc_screen_frame_sink_open(struct sc_frame_sink *sink,
         return false;
     }
 
+    // content_size can be written from this thread, because it is never read
+    // from the main thread before handling SC_EVENT_OPEN_WINDOW (which acts as
+    // a synchronization point) when video is enabled
+    screen->frame_size.width = session->video.width;
+    screen->frame_size.height = session->video.height;
+    screen->content_size = get_oriented_size(screen->frame_size,
+                                             screen->orientation);
+
+    bool ok = sc_push_event(SC_EVENT_OPEN_WINDOW);
+    if (!ok) {
+        return false;
+    }
+
 #ifndef NDEBUG
     screen->open = true;
 #endif
@@ -343,13 +362,10 @@ bool
 sc_screen_init(struct sc_screen *screen,
                const struct sc_screen_params *params) {
     screen->resize_pending = false;
-    screen->has_frame = false;
     screen->window_shown = false;
     screen->paused = false;
     screen->resume_frame = NULL;
     screen->orientation = SC_ORIENTATION_0;
-    screen->disconnected = false;
-    screen->disconnect_started = false;
 
     screen->video = params->video;
     screen->camera = params->camera;
@@ -461,7 +477,7 @@ sc_screen_init(struct sc_screen *screen,
         goto error_destroy_texture;
     }
 
-    SDL_Surface *icon = sc_icon_load(SC_ICON_FILENAME_SCRCPY);
+    SDL_Surface *icon = scrcpy_icon_load();
     if (icon) {
         if (!SDL_SetWindowIcon(screen->window, icon)) {
             LOGW("Could not set window icon: %s", SDL_GetError());
@@ -476,7 +492,7 @@ sc_screen_init(struct sc_screen *screen,
             }
         }
 
-        sc_icon_destroy(icon);
+        scrcpy_icon_destroy(icon);
     } else {
         // not fatal
         LOGE("Could not load icon");
@@ -610,19 +626,9 @@ sc_screen_interrupt(struct sc_screen *screen) {
     sc_fps_counter_interrupt(&screen->fps_counter);
 }
 
-static void
-sc_screen_interrupt_disconnect(struct sc_screen *screen) {
-    if (screen->disconnect_started) {
-        sc_disconnect_interrupt(&screen->disconnect);
-    }
-}
-
 void
 sc_screen_join(struct sc_screen *screen) {
     sc_fps_counter_join(&screen->fps_counter);
-    if (screen->disconnect_started) {
-        sc_disconnect_join(&screen->disconnect);
-    }
 }
 
 void
@@ -630,9 +636,6 @@ sc_screen_destroy(struct sc_screen *screen) {
 #ifndef NDEBUG
     assert(!screen->open);
 #endif
-    if (screen->disconnect_started) {
-        sc_disconnect_destroy(&screen->disconnect);
-    }
     sc_texture_destroy(&screen->tex);
     av_frame_free(&screen->frame);
 #ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
@@ -642,17 +645,6 @@ sc_screen_destroy(struct sc_screen *screen) {
     SDL_DestroyWindow(screen->window);
     sc_fps_counter_destroy(&screen->fps_counter);
     sc_frame_buffer_destroy(&screen->fb);
-
-    SDL_Event event;
-    int nevents = SDL_PeepEvents(&event, 1, SDL_GETEVENT,
-                                 SC_EVENT_DISCONNECTED_ICON_LOADED,
-                                 SC_EVENT_DISCONNECTED_ICON_LOADED);
-    if (nevents == 1) {
-        assert(event.type == SC_EVENT_DISCONNECTED_ICON_LOADED);
-        // The event was posted, but not handled, the icon must be freed
-        SDL_Surface *dangling_icon = event.user.data1;
-        sc_icon_destroy(dangling_icon);
-    }
 }
 
 static void
@@ -723,14 +715,14 @@ sc_screen_set_orientation(struct sc_screen *screen,
 static bool
 sc_screen_apply_frame(struct sc_screen *screen) {
     assert(screen->video);
+    assert(screen->window_shown);
 
     sc_fps_counter_add_rendered_frame(&screen->fps_counter);
 
     AVFrame *frame = screen->frame;
     struct sc_size new_frame_size = {frame->width, frame->height};
 
-    if (!screen->has_frame
-            || screen->frame_size.width != new_frame_size.width
+    if (screen->frame_size.width != new_frame_size.width
             || screen->frame_size.height != new_frame_size.height) {
 
         // frame dimension changed
@@ -738,14 +730,8 @@ sc_screen_apply_frame(struct sc_screen *screen) {
 
         struct sc_size new_content_size =
             get_oriented_size(new_frame_size, screen->orientation);
-        if (screen->has_frame) {
-            set_content_size(screen, new_content_size);
-            sc_screen_update_content_rect(screen);
-        } else {
-            // This is the first frame
-            screen->has_frame = true;
-            screen->content_size = new_content_size;
-        }
+        set_content_size(screen, new_content_size);
+        sc_screen_update_content_rect(screen);
     }
 
     bool ok = sc_texture_set_from_frame(&screen->tex, frame);
@@ -753,17 +739,6 @@ sc_screen_apply_frame(struct sc_screen *screen) {
         return false;
     }
 
-    assert(screen->has_frame);
-    if (!screen->window_shown) {
-        // this is the very first frame, show the window
-        sc_screen_show_initial_window(screen);
-
-        if (sc_screen_is_relative_mode(screen)) {
-            // Capture mouse on start
-            sc_mouse_capture_set_active(&screen->mc, true);
-        }
-    }
-
     sc_screen_render(screen, false);
     return true;
 }
@@ -882,30 +857,19 @@ sc_screen_resize_to_pixel_perfect(struct sc_screen *screen) {
                                             content_size.height);
 }
 
-static void
-sc_disconnect_on_icon_loaded(struct sc_disconnect *d, SDL_Surface *icon,
-                             void *userdata) {
-    (void) d;
-    (void) userdata;
-
-    bool ok = sc_push_event_with_data(SC_EVENT_DISCONNECTED_ICON_LOADED, icon);
-    if (!ok) {
-        sc_icon_destroy(icon);
-    }
-}
-
-static void
-sc_disconnect_on_timeout(struct sc_disconnect *d, void *userdata) {
-    (void) d;
-    (void) userdata;
-
-    bool ok = sc_push_event(SC_EVENT_DISCONNECTED_TIMEOUT);
-    (void) ok; // ignore failure
-}
-
 void
 sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
     switch (event->type) {
+        case SC_EVENT_OPEN_WINDOW:
+            sc_screen_show_initial_window(screen);
+
+            if (sc_screen_is_relative_mode(screen)) {
+                // Capture mouse on start
+                sc_mouse_capture_set_active(&screen->mc, true);
+            }
+
+            sc_screen_render(screen, false);
+            return;
         case SC_EVENT_NEW_FRAME: {
             bool ok = sc_screen_update_frame(screen);
             if (!ok) {
@@ -939,29 +903,6 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
                 apply_pending_resize(screen);
                 sc_screen_render(screen, true);
             }
-            return;
-        case SC_EVENT_DEVICE_DISCONNECTED:
-            assert(!screen->disconnected);
-            screen->disconnected = true;
-            if (!screen->window_shown) {
-                // No window open
-                return;
-            }
-
-            sc_texture_reset(&screen->tex);
-            sc_screen_render(screen, true);
-
-            sc_tick deadline = sc_tick_now() + SC_TICK_FROM_SEC(2);
-            static const struct sc_disconnect_callbacks cbs = {
-                .on_icon_loaded = sc_disconnect_on_icon_loaded,
-                .on_timeout = sc_disconnect_on_timeout,
-            };
-            bool ok =
-                sc_disconnect_start(&screen->disconnect, deadline, &cbs, NULL);
-            if (ok) {
-                screen->disconnect_started = true;
-            }
-
             return;
     }
 
@@ -974,52 +915,6 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
     sc_input_manager_handle_event(&screen->im, event);
 }
 
-void
-sc_screen_handle_disconnection(struct sc_screen *screen) {
-    if (!screen->window_shown) {
-        // No window open, quit immediately
-        return;
-    }
-
-    if (!screen->disconnect_started) {
-        // If sc_disconnect_start() failed, quit immediately
-        return;
-    }
-
-    SDL_Event event;
-    while (SDL_WaitEvent(&event)) {
-        switch (event.type) {
-            case SC_EVENT_DISCONNECTED_ICON_LOADED: {
-                SDL_Surface *icon_disconnected = event.user.data1;
-                assert(icon_disconnected);
-
-                bool ok = sc_texture_set_from_surface(&screen->tex, icon_disconnected);
-                if (ok) {
-                    screen->content_size.width = icon_disconnected->w;
-                    screen->content_size.height = icon_disconnected->h;
-                    sc_screen_render(screen, true);
-                } else {
-                    // not fatal
-                    LOGE("Could not set disconnected icon");
-                }
-
-                sc_icon_destroy(icon_disconnected);
-                break;
-            }
-            case SDL_EVENT_WINDOW_EXPOSED:
-                sc_screen_render(screen, true);
-                break;
-            case SC_EVENT_DISCONNECTED_TIMEOUT:
-                LOGD("Closing after device disconnection");
-                return;
-            case SDL_EVENT_QUIT:
-                LOGD("User requested to quit");
-                sc_screen_interrupt_disconnect(screen);
-                return;
-        }
-    }
-}
-
 struct sc_point
 sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen,
                                            int32_t x, int32_t y) {

app/src/screen.h

@@ -12,7 +12,6 @@
 
 #include "controller.h"
 #include "coords.h"
-#include "disconnect.h"
 #include "fps_counter.h"
 #include "frame_buffer.h"
 #include "input_manager.h"
@@ -71,17 +70,12 @@ struct sc_screen {
     enum sc_orientation orientation;
     // rectangle of the content (excluding black borders)
     struct SDL_FRect rect;
-    bool has_frame;
     bool window_shown;
 
     AVFrame *frame;
 
     bool paused;
     AVFrame *resume_frame;
-
-    bool disconnected;
-    bool disconnect_started;
-    struct sc_disconnect disconnect;
 };
 
 struct sc_screen_params {
@@ -121,7 +115,7 @@ bool
 sc_screen_init(struct sc_screen *screen, const struct sc_screen_params *params);
 
 // request to interrupt any inner thread
-// must be called before sc_screen_join()
+// must be called before screen_join()
 void
 sc_screen_interrupt(struct sc_screen *screen);
 
@@ -165,10 +159,6 @@ sc_screen_set_paused(struct sc_screen *screen, bool paused);
 void
 sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event);
 
-// run the event loop once the device is disconnected
-void
-sc_screen_handle_disconnection(struct sc_screen *screen);
-
 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels
 struct sc_point

app/src/texture.c

@@ -225,11 +225,3 @@ sc_texture_set_from_surface(struct sc_texture *tex, SDL_Surface *surface) {
 
     return true;
 }
-
-void
-sc_texture_reset(struct sc_texture *tex) {
-    if (tex->texture) {
-        SDL_DestroyTexture(tex->texture);
-        tex->texture = NULL;
-    }
-}

app/src/texture.h

@@ -41,7 +41,4 @@ sc_texture_set_from_frame(struct sc_texture *tex, const AVFrame *frame);
 bool
 sc_texture_set_from_surface(struct sc_texture *tex, SDL_Surface *surface);
 
-void
-sc_texture_reset(struct sc_texture *tex);
-
 #endif

app/src/usb/scrcpy_otg.c

@@ -31,7 +31,7 @@ sc_usb_on_disconnected(struct sc_usb *usb, void *userdata) {
     (void) usb;
     (void) userdata;
 
-    sc_push_event(SC_EVENT_DEVICE_DISCONNECTED);
+    sc_push_event(SC_EVENT_USB_DEVICE_DISCONNECTED);
 }
 
 static enum scrcpy_exit_code
@@ -39,9 +39,8 @@ event_loop(struct scrcpy_otg *s) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         switch (event.type) {
-            case SC_EVENT_DEVICE_DISCONNECTED:
+            case SC_EVENT_USB_DEVICE_DISCONNECTED:
                 LOGW("Device disconnected");
-                sc_screen_handle_event(&s->screen, &event);
                 return SCRCPY_EXIT_DISCONNECTED;
             case SC_EVENT_AOA_OPEN_ERROR:
                 LOGE("AOA open error");
@@ -97,7 +96,6 @@ scrcpy_otg(struct scrcpy_options *options) {
     bool aoa_started = false;
     bool aoa_initialized = false;
     bool screen_initialized = false;
-    bool disconnected = false;
 
 #ifdef _WIN32
     // On Windows, only one process could open a USB device
@@ -223,7 +221,7 @@ scrcpy_otg(struct scrcpy_options *options) {
     usb_device_initialized = false;
 
     ret = event_loop(s);
-    disconnected = ret == SCRCPY_EXIT_DISCONNECTED;
+    LOGD("quit...");
 
 end:
     if (aoa_started) {
@@ -233,14 +231,6 @@ end:
 
     if (screen_initialized) {
         sc_screen_interrupt(&s->screen);
-
-        if (disconnected) {
-            sc_screen_handle_disconnection(&s->screen);
-        }
-        LOGD("Quit...");
-
-        // Close the window immediately
-        sc_screen_hide_window(&s->screen);
     }
 
     if (mp) {

app/src/util/file.c

@@ -5,25 +5,6 @@
 
 #include "util/log.h"
 
-char *
-sc_file_build_path(const char *dir, const char *name) {
-    size_t dir_len = strlen(dir);
-    size_t name_len = strlen(name);
-
-    size_t len = dir_len + name_len + 2; // +2: '/' and '\0'
-    char *path = malloc(len);
-    if (!path) {
-        LOG_OOM();
-        return NULL;
-    }
-
-    memcpy(path, dir, dir_len);
-    path[dir_len] = SC_PATH_SEPARATOR;
-    // namelen + 1 to copy the final '\0'
-    memcpy(&path[dir_len + 1], name, name_len + 1);
-    return path;
-}
-
 char *
 sc_file_get_local_path(const char *name) {
     char *executable_path = sc_file_get_executable_path();
@@ -44,9 +25,24 @@ sc_file_get_local_path(const char *name) {
 
     *p = '\0'; // modify executable_path in place
     char *dir = executable_path;
-    char *file_path = sc_file_build_path(dir, name);
+    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) {
+        LOG_OOM();
+        free(executable_path);
+        return NULL;
+    }
+
+    memcpy(file_path, dir, dirlen);
+    file_path[dirlen] = SC_PATH_SEPARATOR;
+    // namelen + 1 to copy the final '\0'
+    memcpy(&file_path[dirlen + 1], name, namelen + 1);
 
     free(executable_path);
 
     return file_path;
 }
+

app/src/util/file.h

@@ -40,15 +40,6 @@ sc_file_get_executable_path(void);
 char *
 sc_file_get_local_path(const char *name);
 
-/**
- * Return the concatenation of dir, the path separator and the filename.
- *
- * The result must be freed by the caller using free(). It may return NULL on
- * error.
- */
-char *
-sc_file_build_path(const char *dir, const char *filename);
-
 /**
  * Indicate if the file exists and is not a directory
  */

release/build_linux.sh

@@ -41,6 +41,6 @@ ninja -C "$LINUX_BUILD_DIR"
 # Group intermediate outputs into a 'dist' directory
 mkdir -p "$LINUX_BUILD_DIR/dist"
 cp "$LINUX_BUILD_DIR"/app/scrcpy "$LINUX_BUILD_DIR/dist/"
-cp app/data/scrcpy.png "$LINUX_BUILD_DIR/dist/"
+cp app/data/icon.png "$LINUX_BUILD_DIR/dist/"
 cp app/scrcpy.1 "$LINUX_BUILD_DIR/dist/"
 cp -r "$ADB_INSTALL_DIR"/. "$LINUX_BUILD_DIR/dist/"

release/build_macos.sh

@@ -41,6 +41,6 @@ ninja -C "$MACOS_BUILD_DIR"
 # Group intermediate outputs into a 'dist' directory
 mkdir -p "$MACOS_BUILD_DIR/dist"
 cp "$MACOS_BUILD_DIR"/app/scrcpy "$MACOS_BUILD_DIR/dist/"
-cp app/data/scrcpy.png "$MACOS_BUILD_DIR/dist/"
+cp app/data/icon.png "$MACOS_BUILD_DIR/dist/"
 cp app/scrcpy.1 "$MACOS_BUILD_DIR/dist/"
 cp -r "$ADB_INSTALL_DIR"/. "$MACOS_BUILD_DIR/dist/"

release/build_windows.sh

@@ -49,7 +49,7 @@ ninja -C "$WINXX_BUILD_DIR"
 mkdir -p "$WINXX_BUILD_DIR/dist"
 cp "$WINXX_BUILD_DIR"/app/scrcpy.exe "$WINXX_BUILD_DIR/dist/"
 cp app/data/scrcpy-noconsole.vbs "$WINXX_BUILD_DIR/dist/"
-cp app/data/scrcpy.png "$WINXX_BUILD_DIR/dist/"
+cp app/data/icon.png "$WINXX_BUILD_DIR/dist/"
 cp app/data/open_a_terminal_here.bat "$WINXX_BUILD_DIR/dist/"
 cp "$DEPS_INSTALL_DIR"/bin/*.dll "$WINXX_BUILD_DIR/dist/"
 cp -r "$ADB_INSTALL_DIR"/. "$WINXX_BUILD_DIR/dist/"

run

@@ -20,6 +20,6 @@ then
     exit 1
 fi
 
-SCRCPY_ICON_DIR="app/data" \
+SCRCPY_ICON_PATH="app/data/icon.png" \
 SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server" \
 "$BUILDDIR/app/scrcpy" "$@"