realfps

Makefile.CrossWindows

@@ -57,7 +57,7 @@ build-win32: prepare-deps-win32
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
 			-Dbuild_server=false \
-			-Dportable=true )
+			-Doverride_server_path=scrcpy-server.jar )
 	ninja -C "$(WIN32_BUILD_DIR)"
 
 build-win32-noconsole: prepare-deps-win32
@@ -68,7 +68,7 @@ build-win32-noconsole: prepare-deps-win32
 			-Dcrossbuild_windows=true \
 			-Dbuild_server=false \
 			-Dwindows_noconsole=true \
-			-Dportable=true )
+			-Doverride_server_path=scrcpy-server.jar )
 	ninja -C "$(WIN32_NOCONSOLE_BUILD_DIR)"
 
 prepare-deps-win64:
@@ -81,7 +81,7 @@ build-win64: prepare-deps-win64
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
 			-Dbuild_server=false \
-			-Dportable=true )
+			-Doverride_server_path=scrcpy-server.jar )
 	ninja -C "$(WIN64_BUILD_DIR)"
 
 build-win64-noconsole: prepare-deps-win64
@@ -92,7 +92,7 @@ build-win64-noconsole: prepare-deps-win64
 			-Dcrossbuild_windows=true \
 			-Dbuild_server=false \
 			-Dwindows_noconsole=true \
-			-Dportable=true )
+			-Doverride_server_path=scrcpy-server.jar )
 	ninja -C "$(WIN64_NOCONSOLE_BUILD_DIR)"
 
 dist-win32: build-server build-win32 build-win32-noconsole

app/meson.build

@@ -10,6 +10,7 @@ src = [
     'src/file_handler.c',
     'src/fps_counter.c',
     'src/input_manager.c',
+    'src/lock_util.c',
     'src/net.c',
     'src/receiver.c',
     'src/recorder.c',
@@ -93,9 +94,21 @@ conf.set_quoted('SCRCPY_VERSION', meson.project_version())
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))
 
-# build a "portable" version (with scrcpy-server.jar accessible from the same
-# directory as the executable)
-conf.set('PORTABLE', get_option('portable'))
+# the path of the server, which will be appended to the prefix
+# ignored if OVERRIDE_SERVER_PATH if defined
+# must be consistent with the install_dir in server/meson.build
+conf.set_quoted('PREFIXED_SERVER_PATH', '/share/scrcpy/scrcpy-server.jar')
+
+# the path of the server to be used "as is"
+# this is useful for building a "portable" version (with the server in the same
+# directory as the client)
+override_server_path = get_option('override_server_path')
+if override_server_path != ''
+    conf.set_quoted('OVERRIDE_SERVER_PATH', override_server_path)
+else
+    # undefine it
+    conf.set('OVERRIDE_SERVER_PATH', false)
+endif
 
 # the default client TCP port for the "adb reverse" tunnel
 # overridden by option --port

app/src/command.h

@@ -9,7 +9,6 @@
  // not needed here, but winsock2.h must never be included AFTER windows.h
 # include <winsock2.h>
 # include <windows.h>
-# define PATH_SEPARATOR '\\'
 # define PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
 # ifdef _WIN64
@@ -24,7 +23,6 @@
 #else
 
 # include <sys/types.h>
-# define PATH_SEPARATOR '/'
 # define PRIsizet "zu"
 # define PRIexitcode "d"
 # define PROCESS_NONE -1
@@ -78,9 +76,4 @@ adb_install(const char *serial, const char *local);
 bool
 process_check_success(process_t proc, const char *name);
 
-// return the absolute path of the executable (the scrcpy binary)
-// may be NULL on error; to be freed by SDL_free
-char *
-get_executable_path(void);
-
 #endif

app/src/fps_counter.c

@@ -1,12 +1,12 @@
 #include "fps_counter.h"
 
-#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>
+#include <SDL2/SDL_assert.h>
 
 #include "lock_util.h"
 #include "log.h"
 
-#define FPS_COUNTER_INTERVAL_MS 1000
+#define FPS_COUNTER_INTERVAL 1000
 
 bool
 fps_counter_init(struct fps_counter *counter) {
@@ -22,8 +22,11 @@ fps_counter_init(struct fps_counter *counter) {
     }
 
     counter->thread = NULL;
-    SDL_AtomicSet(&counter->started, 0);
-    // no need to initialize the other fields, they are unused until started
+    counter->started = false;
+    counter->interrupted = false;
+    counter->nr_rendered = 0;
+    counter->nr_skipped = 0;
+    // no need to initialize slice_start, it is meaningful only when started
 
     return true;
 }
@@ -34,48 +37,40 @@ fps_counter_destroy(struct fps_counter *counter) {
     SDL_DestroyMutex(counter->mutex);
 }
 
-// must be called with mutex locked
 static void
 display_fps(struct fps_counter *counter) {
     unsigned rendered_per_second =
-        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;
+        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL;
     if (counter->nr_skipped) {
+        unsigned skipped_per_second =
+            counter->nr_skipped * 1000 / FPS_COUNTER_INTERVAL;
         LOGI("%u fps (+%u frames skipped)", rendered_per_second,
-                                            counter->nr_skipped);
+                                            skipped_per_second);
     } else {
         LOGI("%u fps", rendered_per_second);
     }
 }
 
-// must be called with mutex locked
-static void
-check_interval_expired(struct fps_counter *counter, uint32_t now) {
-    if (now < counter->next_timestamp) {
-        return;
-    }
-
-    display_fps(counter);
-    counter->nr_rendered = 0;
-    counter->nr_skipped = 0;
-    // add a multiple of the interval
-    uint32_t elapsed_slices =
-        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL_MS + 1;
-    counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;
-}
-
 static int
 run_fps_counter(void *data) {
     struct fps_counter *counter = data;
 
     mutex_lock(counter->mutex);
     while (!counter->interrupted) {
-        while (!counter->interrupted && !SDL_AtomicGet(&counter->started)) {
+        while (!counter->interrupted && !counter->started) {
             cond_wait(counter->state_cond, counter->mutex);
         }
-        while (!counter->interrupted && SDL_AtomicGet(&counter->started)) {
+        while (!counter->interrupted && counter->started) {
             uint32_t now = SDL_GetTicks();
-            check_interval_expired(counter, now);
-
+            if (now >= counter->next_timestamp) {
+                display_fps(counter);
+                counter->nr_rendered = 0;
+                counter->nr_skipped = 0;
+                // add a multiple of the interval
+                uint32_t elapsed_slices =
+                    (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL + 1;
+                counter->next_timestamp += FPS_COUNTER_INTERVAL * elapsed_slices;
+            }
             SDL_assert(counter->next_timestamp > now);
             uint32_t remaining = counter->next_timestamp - now;
 
@@ -89,16 +84,6 @@ run_fps_counter(void *data) {
 
 bool
 fps_counter_start(struct fps_counter *counter) {
-    mutex_lock(counter->mutex);
-    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
-    counter->nr_rendered = 0;
-    counter->nr_skipped = 0;
-    mutex_unlock(counter->mutex);
-
-    SDL_AtomicSet(&counter->started, 1);
-    cond_signal(counter->state_cond);
-
-    // counter->thread is always accessed from the same thread, no need to lock
     if (!counter->thread) {
         counter->thread =
             SDL_CreateThread(run_fps_counter, "fps counter", counter);
@@ -108,31 +93,34 @@ fps_counter_start(struct fps_counter *counter) {
         }
     }
 
+    mutex_lock(counter->mutex);
+    counter->started = true;
+    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL;
+    counter->nr_rendered = 0;
+    counter->nr_skipped = 0;
+    mutex_unlock(counter->mutex);
+
+    cond_signal(counter->state_cond);
     return true;
 }
 
 void
 fps_counter_stop(struct fps_counter *counter) {
-    SDL_AtomicSet(&counter->started, 0);
+    mutex_lock(counter->mutex);
+    counter->started = false;
+    mutex_unlock(counter->mutex);
     cond_signal(counter->state_cond);
 }
 
-bool
-fps_counter_is_started(struct fps_counter *counter) {
-    return SDL_AtomicGet(&counter->started);
-}
-
 void
 fps_counter_interrupt(struct fps_counter *counter) {
-    if (!counter->thread) {
-        return;
+    if (counter->thread) {
+        mutex_lock(counter->mutex);
+        counter->interrupted = true;
+        mutex_unlock(counter->mutex);
+        // wake up blocking wait
+        cond_signal(counter->state_cond);
     }
-
-    mutex_lock(counter->mutex);
-    counter->interrupted = true;
-    mutex_unlock(counter->mutex);
-    // wake up blocking wait
-    cond_signal(counter->state_cond);
 }
 
 void
@@ -144,26 +132,10 @@ fps_counter_join(struct fps_counter *counter) {
 
 void
 fps_counter_add_rendered_frame(struct fps_counter *counter) {
-    if (!SDL_AtomicGet(&counter->started)) {
-        return;
-    }
-
-    mutex_lock(counter->mutex);
-    uint32_t now = SDL_GetTicks();
-    check_interval_expired(counter, now);
     ++counter->nr_rendered;
-    mutex_unlock(counter->mutex);
 }
 
 void
 fps_counter_add_skipped_frame(struct fps_counter *counter) {
-    if (!SDL_AtomicGet(&counter->started)) {
-        return;
-    }
-
-    mutex_lock(counter->mutex);
-    uint32_t now = SDL_GetTicks();
-    check_interval_expired(counter, now);
     ++counter->nr_skipped;
-    mutex_unlock(counter->mutex);
 }

app/src/fps_counter.h

@@ -11,12 +11,7 @@ struct fps_counter {
     SDL_Thread *thread;
     SDL_mutex *mutex;
     SDL_cond *state_cond;
-
-    // atomic so that we can check without locking the mutex
-    // if the FPS counter is disabled, we don't want to lock unnecessarily
-    SDL_atomic_t started;
-
-    // the following fields are protected by the mutex
+    bool started;
     bool interrupted;
     unsigned nr_rendered;
     unsigned nr_skipped;
@@ -35,9 +30,6 @@ fps_counter_start(struct fps_counter *counter);
 void
 fps_counter_stop(struct fps_counter *counter);
 
-bool
-fps_counter_is_started(struct fps_counter *counter);
-
 // request to stop the thread (on quit)
 // must be called before fps_counter_join()
 void

app/src/input_manager.c

@@ -173,9 +173,8 @@ set_screen_power_mode(struct controller *controller,
 
 static void
 switch_fps_counter_state(struct fps_counter *fps_counter) {
-    // the started state can only be written from the current thread, so there
-    // is no ToCToU issue
-    if (fps_counter_is_started(fps_counter)) {
+    mutex_lock(fps_counter->mutex);
+    if (fps_counter->started) {
         fps_counter_stop(fps_counter);
         LOGI("FPS counter stopped");
     } else {
@@ -185,6 +184,7 @@ switch_fps_counter_state(struct fps_counter *fps_counter) {
             LOGE("FPS counter starting failed");
         }
     }
+    mutex_unlock(fps_counter->mutex);
 }
 
 static void

app/src/lock_util.c

@@ -0,0 +1,48 @@
+#include <lock_util.h>
+#include <stdlib.h>
+#include <SDL2/SDL_mutex.h>
+
+#include "log.h"
+
+void
+mutex_lock(SDL_mutex *mutex) {
+    if (SDL_LockMutex(mutex)) {
+        LOGC("Could not lock mutex");
+        abort();
+    }
+}
+
+void
+mutex_unlock(SDL_mutex *mutex) {
+    if (SDL_UnlockMutex(mutex)) {
+        LOGC("Could not unlock mutex");
+        abort();
+    }
+}
+
+void
+cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
+    if (SDL_CondWait(cond, mutex)) {
+        LOGC("Could not wait on condition");
+        abort();
+    }
+}
+
+int
+cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
+    int r = SDL_CondWaitTimeout(cond, mutex, ms);
+    if (r < 0) {
+        LOGC("Could not wait on condition with timeout");
+        abort();
+    }
+    return r;
+}
+
+void
+cond_signal(SDL_cond *cond) {
+    if (SDL_CondSignal(cond)) {
+        LOGC("Could not signal a condition");
+        abort();
+    }
+}
+

app/src/lock_util.h

@@ -2,50 +2,25 @@
 #define LOCKUTIL_H
 
 #include <stdint.h>
-#include <SDL2/SDL_mutex.h>
 
-#include "log.h"
+// forward declarations
+typedef struct SDL_mutex SDL_mutex;
+typedef struct SDL_cond SDL_cond;
 
-static inline void
-mutex_lock(SDL_mutex *mutex) {
-    if (SDL_LockMutex(mutex)) {
-        LOGC("Could not lock mutex");
-        abort();
-    }
-}
+void
+mutex_lock(SDL_mutex *mutex);
 
-static inline void
-mutex_unlock(SDL_mutex *mutex) {
-    if (SDL_UnlockMutex(mutex)) {
-        LOGC("Could not unlock mutex");
-        abort();
-    }
-}
+void
+mutex_unlock(SDL_mutex *mutex);
 
-static inline void
-cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
-    if (SDL_CondWait(cond, mutex)) {
-        LOGC("Could not wait on condition");
-        abort();
-    }
-}
+void
+cond_wait(SDL_cond *cond, SDL_mutex *mutex);
 
-static inline int
-cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
-    int r = SDL_CondWaitTimeout(cond, mutex, ms);
-    if (r < 0) {
-        LOGC("Could not wait on condition with timeout");
-        abort();
-    }
-    return r;
-}
+// return 0 or SDL_MUTEX_TIMEDOUT
+int
+cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms);
 
-static inline void
-cond_signal(SDL_cond *cond) {
-    if (SDL_CondSignal(cond)) {
-        LOGC("Could not signal a condition");
-        abort();
-    }
-}
+void
+cond_signal(SDL_cond *cond);
 
 #endif

app/src/server.c

@@ -2,67 +2,31 @@
 
 #include <errno.h>
 #include <inttypes.h>
-#include <libgen.h>
 #include <stdio.h>
 #include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>
 
 #include "config.h"
-#include "command.h"
 #include "log.h"
 #include "net.h"
 
 #define SOCKET_NAME "scrcpy"
-#define SERVER_FILENAME "scrcpy-server.jar"
 
-#define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FLENAME
-#define DEVICE_SERVER_PATH "/data/local/tmp/" SERVER_FILENAME
+#ifdef OVERRIDE_SERVER_PATH
+# define DEFAULT_SERVER_PATH OVERRIDE_SERVER_PATH
+#else
+# define DEFAULT_SERVER_PATH PREFIX PREFIXED_SERVER_PATH
+#endif
+
+#define DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"
 
 static const char *
 get_server_path(void) {
-    const char *server_path_env = getenv("SCRCPY_SERVER_PATH");
-    if (server_path_env) {
-        LOGD("Using SCRCPY_SERVER_PATH: %s", server_path_env);
-        // if the envvar is set, use it
-        return server_path_env;
-    }
-
-#ifndef PORTABLE
-    LOGD("Using server: " DEFAULT_SERVER_PATH);
-    // the absolute path is hardcoded
-    return DEFAULT_SERVER_PATH;
-#else
-    // use scrcpy-server.jar in the same directory as the executable
-    char *executable_path = get_executable_path();
-    if (!executable_path) {
-        LOGE("Cannot get executable path, "
-             "using " SERVER_FILENAME " from current directory");
-        // not found, use current directory
-        return SERVER_FILENAME;
-    }
-    char *dir = dirname(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 = SDL_malloc(len);
+    const char *server_path = getenv("SCRCPY_SERVER_PATH");
     if (!server_path) {
-        LOGE("Cannot alloc server path string, "
-             "using " SERVER_FILENAME " from current directory");
-        SDL_free(executable_path);
-        return SERVER_FILENAME;
+        server_path = DEFAULT_SERVER_PATH;
     }
-
-    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
-
-    SDL_free(executable_path);
-
-    LOGD("Using server (portable): %s", server_path);
     return server_path;
-#endif
 }
 
 static bool
@@ -122,7 +86,7 @@ execute_server(struct server *server, const struct server_params *params) {
     sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
     const char *const cmd[] = {
         "shell",
-        "CLASSPATH=/data/local/tmp/" SERVER_FILENAME,
+        "CLASSPATH=/data/local/tmp/scrcpy-server.jar",
         "app_process",
         "/", // unused
         "com.genymobile.scrcpy.Server",

app/src/str_util.c

@@ -92,20 +92,4 @@ utf8_to_wide_char(const char *utf8) {
     return wide;
 }
 
-char *
-utf8_from_wide_char(const wchar_t *ws) {
-    int len = WideCharToMultiByte(CP_UTF8, 0, ws, -1, NULL, 0, NULL, NULL);
-    if (!len) {
-        return NULL;
-    }
-
-    char *utf8 = SDL_malloc(len);
-    if (!utf8) {
-        return NULL;
-    }
-
-    WideCharToMultiByte(CP_UTF8, 0, ws, -1, utf8, len, NULL, NULL);
-    return utf8;
-}
-
 #endif

app/src/str_util.h

@@ -32,9 +32,6 @@ utf8_truncation_index(const char *utf8, size_t max_len);
 // returns the new allocated string, to be freed by the caller
 wchar_t *
 utf8_to_wide_char(const char *utf8);
-
-char *
-utf8_from_wide_char(const wchar_t *s);
 #endif
 
 #endif

app/src/sys/unix/command.c

@@ -1,15 +1,9 @@
-// for portability
 #define _POSIX_SOURCE // for kill()
-#define _BSD_SOURCE // for readlink()
-
-// modern glibc will complain without this
-#define _DEFAULT_SOURCE
 
 #include "command.h"
 
 #include <errno.h>
 #include <fcntl.h>
-#include <limits.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ -104,15 +98,3 @@ cmd_simple_wait(pid_t pid, int *exit_code) {
     }
     return !code;
 }
-
-char *
-get_executable_path(void) {
-    char buf[PATH_MAX + 1]; // +1 for the null byte
-    ssize_t len = readlink("/proc/self/exe", buf, PATH_MAX);
-    if (len == -1) {
-        perror("readlink");
-        return NULL;
-    }
-    buf[len] = '\0';
-    return SDL_strdup(buf);
-}

app/src/sys/win/command.c

@@ -75,18 +75,3 @@ cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
     }
     return !code;
 }
-
-char *
-get_executable_path(void) {
-    HMODULE hModule = GetModuleHandleW(NULL);
-    if (!hModule) {
-        return NULL;
-    }
-    WCHAR buf[MAX_PATH + 1]; // +1 for the null byte
-    int len = GetModuleFileNameW(hModule, buf, MAX_PATH);
-    if (!len) {
-        return NULL;
-    }
-    buf[len] = '\0';
-    return utf8_from_wide_char(buf);
-}

app/src/video_buffer.c

@@ -77,8 +77,10 @@ video_buffer_offer_decoded_frame(struct video_buffer *vb,
         while (!vb->rendering_frame_consumed && !vb->interrupted) {
             cond_wait(vb->rendering_frame_consumed_cond, vb->mutex);
         }
-    } else if (!vb->rendering_frame_consumed) {
-        fps_counter_add_skipped_frame(vb->fps_counter);
+    } else {
+        if (vb->fps_counter->started && !vb->rendering_frame_consumed) {
+            fps_counter_add_skipped_frame(vb->fps_counter);
+        }
     }
 
     video_buffer_swap_frames(vb);
@@ -93,7 +95,9 @@ const AVFrame *
 video_buffer_consume_rendered_frame(struct video_buffer *vb) {
     SDL_assert(!vb->rendering_frame_consumed);
     vb->rendering_frame_consumed = true;
-    fps_counter_add_rendered_frame(vb->fps_counter);
+    if (vb->fps_counter->started) {
+        fps_counter_add_rendered_frame(vb->fps_counter);
+    }
     if (vb->render_expired_frames) {
         // unblock video_buffer_offer_decoded_frame()
         cond_signal(vb->rendering_frame_consumed_cond);

meson_options.txt

@@ -3,6 +3,6 @@ option('build_server', type: 'boolean', value: true, description: 'Build the ser
 option('crossbuild_windows', type: 'boolean', value: false, description: 'Build for Windows from Linux')
 option('windows_noconsole', type: 'boolean', value: false, description: 'Disable console on Windows (pass -mwindows flag)')
 option('prebuilt_server', type: 'string', description: 'Path of the prebuilt server')
-option('portable', type: 'boolean', description: 'Use scrcpy-server.jar from the same directory as the scrcpy executable')
+option('override_server_path', type: 'string', description: 'Hardcoded path to find the server at runtime')
 option('skip_frames', type: 'boolean', value: true, description: 'Always display the most recent frame')
 option('hidpi_support', type: 'boolean', value: true, description: 'Enable High DPI support')

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

@@ -89,7 +89,7 @@ public final class DesktopConnection implements Closeable {
         byte[] buffer = new byte[DEVICE_NAME_FIELD_LENGTH + 4];
 
         byte[] deviceNameBytes = deviceName.getBytes(StandardCharsets.UTF_8);
-        int len = StringUtils.getUtf8TruncationIndex(deviceNameBytes, DEVICE_NAME_FIELD_LENGTH - 1);
+        int len = Math.min(DEVICE_NAME_FIELD_LENGTH - 1, deviceNameBytes.length);
         System.arraycopy(deviceNameBytes, 0, buffer, 0, len);
         // byte[] are always 0-initialized in java, no need to set '\0' explicitly