Add server option raw_video_stream

For convenience, this new option forces the 3 following options:
 - send_device_meta=false
 - send_frame_meta=false
 - send_dummy_byte=false

This allows to send a raw H.264 stream on the video socket.

Concretely:

    adb push scrcpy-server /data/local/tmp/scrcpy-server.jar
    adb forward tcp:1234 localabstract:scrcpy
    adb shell CLASSPATH=/data/local/tmp/scrcpy-server.jar \
        app_process / com.genymobile.scrcpy.Server 1.21 \
        raw_video_stream=true tunnel_forward=true control=false

As soon as a client connects via TCP to localhost:1234, it will receive
the raw H.264 stream.

Refs #1419 comment <https://github.com/Genymobile/scrcpy/pull/1419#issuecomment-1013964650>
PR #2971 <https://github.com/Genymobile/scrcpy/pull/2971>

app/meson.build

@@ -11,7 +11,7 @@ src = [
     'src/decoder.c',
     'src/device_msg.c',
     'src/icon.c',
-    'src/file_handler.c',
+    'src/file_pusher.c',
     'src/fps_counter.c',
     'src/frame_buffer.c',
     'src/input_manager.c',

app/src/aoa_hid.c

@@ -56,14 +56,13 @@ accept_device(libusb_device *device, const char *serial) {
     // devices available on the computer have permission restrictions
 
     struct libusb_device_descriptor desc;
-    libusb_get_device_descriptor(device, &desc);
-
-    if (!desc.iSerialNumber) {
+    int result = libusb_get_device_descriptor(device, &desc);
+    if (result < 0 || !desc.iSerialNumber) {
         return false;
     }
 
     libusb_device_handle *handle;
-    int result = libusb_open(device, &handle);
+    result = libusb_open(device, &handle);
     if (result < 0) {
         return false;
     }
@@ -131,31 +130,22 @@ sc_aoa_init(struct sc_aoa *aoa, const char *serial,
     }
 
     if (!sc_cond_init(&aoa->event_cond)) {
-        sc_mutex_destroy(&aoa->mutex);
-        return false;
+        goto error_destroy_mutex;
     }
 
     if (libusb_init(&aoa->usb_context) != LIBUSB_SUCCESS) {
-        sc_cond_destroy(&aoa->event_cond);
-        sc_mutex_destroy(&aoa->mutex);
-        return false;
+        goto error_destroy_cond;
     }
 
     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);
-        sc_mutex_destroy(&aoa->mutex);
-        sc_cond_destroy(&aoa->event_cond);
-        return false;
+        goto error_exit_libusb;
     }
 
     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);
-        sc_cond_destroy(&aoa->event_cond);
-        sc_mutex_destroy(&aoa->mutex);
+        goto error_unref_device;
         return false;
     }
 
@@ -163,6 +153,16 @@ sc_aoa_init(struct sc_aoa *aoa, const char *serial,
     aoa->acksync = acksync;
 
     return true;
+
+error_unref_device:
+    libusb_unref_device(aoa->usb_device);
+error_exit_libusb:
+    libusb_exit(aoa->usb_context);
+error_destroy_cond:
+    sc_cond_destroy(&aoa->event_cond);
+error_destroy_mutex:
+    sc_mutex_destroy(&aoa->mutex);
+    return false;
 }
 
 void

app/src/cli.c

@@ -1320,12 +1320,12 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case 'K':
 #ifdef HAVE_AOA_HID
                 opts->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_HID;
+                break;
 #else
                 LOGE("HID over AOA (-K/--hid-keyboard) is not supported on "
                      "this platform. It is only available on Linux.");
                 return false;
 #endif
-                break;
             case OPT_MAX_FPS:
                 if (!parse_max_fps(optarg, &opts->max_fps)) {
                     return false;
@@ -1339,12 +1339,12 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case 'M':
 #ifdef HAVE_AOA_HID
                 opts->mouse_input_mode = SC_MOUSE_INPUT_MODE_HID;
+                break;
 #else
                 LOGE("HID over AOA (-M/--hid-mouse) is not supported on this"
                      "platform. It is only available on Linux.");
                 return false;
 #endif
-                break;
             case OPT_LOCK_VIDEO_ORIENTATION:
                 if (!parse_lock_video_orientation(optarg,
                         &opts->lock_video_orientation)) {
@@ -1503,21 +1503,21 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case OPT_V4L2_SINK:
 #ifdef HAVE_V4L2
                 opts->v4l2_device = optarg;
+                break;
 #else
                 LOGE("V4L2 (--v4l2-sink) is only available on Linux.");
                 return false;
 #endif
-                break;
             case OPT_V4L2_BUFFER:
 #ifdef HAVE_V4L2
                 if (!parse_buffering_time(optarg, &opts->v4l2_buffer)) {
                     return false;
                 }
+                break;
 #else
                 LOGE("V4L2 (--v4l2-buffer) is only available on Linux.");
                 return false;
 #endif
-                break;
             default:
                 // getopt prints the error message on stderr
                 return false;
@@ -1591,14 +1591,23 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         }
     }
 
-    if (!opts->control && opts->turn_screen_off) {
-        LOGE("Could not request to turn screen off if control is disabled");
-        return false;
-    }
-
-    if (!opts->control && opts->stay_awake) {
-        LOGE("Could not request to stay awake if control is disabled");
-        return false;
+    if (!opts->control) {
+        if (opts->turn_screen_off) {
+            LOGE("Could not request to turn screen off if control is disabled");
+            return false;
+        }
+        if (opts->stay_awake) {
+            LOGE("Could not request to stay awake if control is disabled");
+            return false;
+        }
+        if (opts->show_touches) {
+            LOGE("Could not request to show touches if control is disabled");
+            return false;
+        }
+        if (opts->power_off_on_close) {
+            LOGE("Could not request power off on close if control is disabled");
+            return false;
+        }
     }
 
     return true;

app/src/file_handler.c

@@ -1,178 +0,0 @@
-#include "file_handler.h"
-
-#include <assert.h>
-#include <string.h>
-
-#include "adb.h"
-#include "util/log.h"
-#include "util/process_intr.h"
-
-#define DEFAULT_PUSH_TARGET "/sdcard/Download/"
-
-static void
-file_handler_request_destroy(struct file_handler_request *req) {
-    free(req->file);
-}
-
-bool
-file_handler_init(struct file_handler *file_handler, const char *serial,
-                  const char *push_target) {
-    assert(serial);
-
-    cbuf_init(&file_handler->queue);
-
-    bool ok = sc_mutex_init(&file_handler->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&file_handler->event_cond);
-    if (!ok) {
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
-    }
-
-    ok = sc_intr_init(&file_handler->intr);
-    if (!ok) {
-        sc_cond_destroy(&file_handler->event_cond);
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
-    }
-
-    file_handler->serial = strdup(serial);
-    if (!file_handler->serial) {
-        LOG_OOM();
-        sc_intr_destroy(&file_handler->intr);
-        sc_cond_destroy(&file_handler->event_cond);
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
-    }
-
-    // lazy initialization
-    file_handler->initialized = false;
-
-    file_handler->stopped = false;
-
-    file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
-
-    return true;
-}
-
-void
-file_handler_destroy(struct file_handler *file_handler) {
-    sc_cond_destroy(&file_handler->event_cond);
-    sc_mutex_destroy(&file_handler->mutex);
-    sc_intr_destroy(&file_handler->intr);
-    free(file_handler->serial);
-
-    struct file_handler_request req;
-    while (cbuf_take(&file_handler->queue, &req)) {
-        file_handler_request_destroy(&req);
-    }
-}
-
-bool
-file_handler_request(struct file_handler *file_handler,
-                     file_handler_action_t action, char *file) {
-    // start file_handler if it's used for the first time
-    if (!file_handler->initialized) {
-        if (!file_handler_start(file_handler)) {
-            return false;
-        }
-        file_handler->initialized = true;
-    }
-
-    LOGI("Request to %s %s", action == ACTION_INSTALL_APK ? "install" : "push",
-                             file);
-    struct file_handler_request req = {
-        .action = action,
-        .file = file,
-    };
-
-    sc_mutex_lock(&file_handler->mutex);
-    bool was_empty = cbuf_is_empty(&file_handler->queue);
-    bool res = cbuf_push(&file_handler->queue, req);
-    if (was_empty) {
-        sc_cond_signal(&file_handler->event_cond);
-    }
-    sc_mutex_unlock(&file_handler->mutex);
-    return res;
-}
-
-static int
-run_file_handler(void *data) {
-    struct file_handler *file_handler = data;
-    struct sc_intr *intr = &file_handler->intr;
-
-    const char *serial = file_handler->serial;
-    assert(serial);
-
-    const char *push_target = file_handler->push_target;
-    assert(push_target);
-
-    for (;;) {
-        sc_mutex_lock(&file_handler->mutex);
-        while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
-            sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
-        }
-        if (file_handler->stopped) {
-            // stop immediately, do not process further events
-            sc_mutex_unlock(&file_handler->mutex);
-            break;
-        }
-        struct file_handler_request req;
-        bool non_empty = cbuf_take(&file_handler->queue, &req);
-        assert(non_empty);
-        (void) non_empty;
-        sc_mutex_unlock(&file_handler->mutex);
-
-        if (req.action == ACTION_INSTALL_APK) {
-            LOGI("Installing %s...", req.file);
-            bool ok = adb_install(intr, serial, req.file, 0);
-            if (ok) {
-                LOGI("%s successfully installed", req.file);
-            } else {
-                LOGE("Failed to install %s", req.file);
-            }
-        } else {
-            LOGI("Pushing %s...", req.file);
-            bool ok = adb_push(intr, serial, req.file, push_target, 0);
-            if (ok) {
-                LOGI("%s successfully pushed to %s", req.file, push_target);
-            } else {
-                LOGE("Failed to push %s to %s", req.file, push_target);
-            }
-        }
-
-        file_handler_request_destroy(&req);
-    }
-    return 0;
-}
-
-bool
-file_handler_start(struct file_handler *file_handler) {
-    LOGD("Starting file_handler thread");
-
-    bool ok = sc_thread_create(&file_handler->thread, run_file_handler,
-                               "scrcpy-file", file_handler);
-    if (!ok) {
-        LOGC("Could not start file_handler thread");
-        return false;
-    }
-
-    return true;
-}
-
-void
-file_handler_stop(struct file_handler *file_handler) {
-    sc_mutex_lock(&file_handler->mutex);
-    file_handler->stopped = true;
-    sc_cond_signal(&file_handler->event_cond);
-    sc_intr_interrupt(&file_handler->intr);
-    sc_mutex_unlock(&file_handler->mutex);
-}
-
-void
-file_handler_join(struct file_handler *file_handler) {
-    sc_thread_join(&file_handler->thread, NULL);
-}

app/src/file_handler.h

@@ -1,60 +0,0 @@
-#ifndef FILE_HANDLER_H
-#define FILE_HANDLER_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "adb.h"
-#include "util/cbuf.h"
-#include "util/thread.h"
-#include "util/intr.h"
-
-typedef enum {
-    ACTION_INSTALL_APK,
-    ACTION_PUSH_FILE,
-} file_handler_action_t;
-
-struct file_handler_request {
-    file_handler_action_t action;
-    char *file;
-};
-
-struct file_handler_request_queue CBUF(struct file_handler_request, 16);
-
-struct file_handler {
-    char *serial;
-    const char *push_target;
-    sc_thread thread;
-    sc_mutex mutex;
-    sc_cond event_cond;
-    bool stopped;
-    bool initialized;
-    struct file_handler_request_queue queue;
-
-    struct sc_intr intr;
-};
-
-bool
-file_handler_init(struct file_handler *file_handler, const char *serial,
-                  const char *push_target);
-
-void
-file_handler_destroy(struct file_handler *file_handler);
-
-bool
-file_handler_start(struct file_handler *file_handler);
-
-void
-file_handler_stop(struct file_handler *file_handler);
-
-void
-file_handler_join(struct file_handler *file_handler);
-
-// take ownership of file, and will free() it
-bool
-file_handler_request(struct file_handler *file_handler,
-                     file_handler_action_t action,
-                     char *file);
-
-#endif

app/src/file_pusher.c

@@ -0,0 +1,178 @@
+#include "file_pusher.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "adb.h"
+#include "util/log.h"
+#include "util/process_intr.h"
+
+#define DEFAULT_PUSH_TARGET "/sdcard/Download/"
+
+static void
+sc_file_pusher_request_destroy(struct sc_file_pusher_request *req) {
+    free(req->file);
+}
+
+bool
+sc_file_pusher_init(struct sc_file_pusher *fp, const char *serial,
+                    const char *push_target) {
+    assert(serial);
+
+    cbuf_init(&fp->queue);
+
+    bool ok = sc_mutex_init(&fp->mutex);
+    if (!ok) {
+        return false;
+    }
+
+    ok = sc_cond_init(&fp->event_cond);
+    if (!ok) {
+        sc_mutex_destroy(&fp->mutex);
+        return false;
+    }
+
+    ok = sc_intr_init(&fp->intr);
+    if (!ok) {
+        sc_cond_destroy(&fp->event_cond);
+        sc_mutex_destroy(&fp->mutex);
+        return false;
+    }
+
+    fp->serial = strdup(serial);
+    if (!fp->serial) {
+        LOG_OOM();
+        sc_intr_destroy(&fp->intr);
+        sc_cond_destroy(&fp->event_cond);
+        sc_mutex_destroy(&fp->mutex);
+        return false;
+    }
+
+    // lazy initialization
+    fp->initialized = false;
+
+    fp->stopped = false;
+
+    fp->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
+
+    return true;
+}
+
+void
+sc_file_pusher_destroy(struct sc_file_pusher *fp) {
+    sc_cond_destroy(&fp->event_cond);
+    sc_mutex_destroy(&fp->mutex);
+    sc_intr_destroy(&fp->intr);
+    free(fp->serial);
+
+    struct sc_file_pusher_request req;
+    while (cbuf_take(&fp->queue, &req)) {
+        sc_file_pusher_request_destroy(&req);
+    }
+}
+
+bool
+sc_file_pusher_request(struct sc_file_pusher *fp,
+                       enum sc_file_pusher_action action, char *file) {
+    // start file_pusher if it's used for the first time
+    if (!fp->initialized) {
+        if (!sc_file_pusher_start(fp)) {
+            return false;
+        }
+        fp->initialized = true;
+    }
+
+    LOGI("Request to %s %s", action == SC_FILE_PUSHER_ACTION_INSTALL_APK
+                                 ? "install" : "push",
+                             file);
+    struct sc_file_pusher_request req = {
+        .action = action,
+        .file = file,
+    };
+
+    sc_mutex_lock(&fp->mutex);
+    bool was_empty = cbuf_is_empty(&fp->queue);
+    bool res = cbuf_push(&fp->queue, req);
+    if (was_empty) {
+        sc_cond_signal(&fp->event_cond);
+    }
+    sc_mutex_unlock(&fp->mutex);
+    return res;
+}
+
+static int
+run_file_pusher(void *data) {
+    struct sc_file_pusher *fp = data;
+    struct sc_intr *intr = &fp->intr;
+
+    const char *serial = fp->serial;
+    assert(serial);
+
+    const char *push_target = fp->push_target;
+    assert(push_target);
+
+    for (;;) {
+        sc_mutex_lock(&fp->mutex);
+        while (!fp->stopped && cbuf_is_empty(&fp->queue)) {
+            sc_cond_wait(&fp->event_cond, &fp->mutex);
+        }
+        if (fp->stopped) {
+            // stop immediately, do not process further events
+            sc_mutex_unlock(&fp->mutex);
+            break;
+        }
+        struct sc_file_pusher_request req;
+        bool non_empty = cbuf_take(&fp->queue, &req);
+        assert(non_empty);
+        (void) non_empty;
+        sc_mutex_unlock(&fp->mutex);
+
+        if (req.action == SC_FILE_PUSHER_ACTION_INSTALL_APK) {
+            LOGI("Installing %s...", req.file);
+            bool ok = adb_install(intr, serial, req.file, 0);
+            if (ok) {
+                LOGI("%s successfully installed", req.file);
+            } else {
+                LOGE("Failed to install %s", req.file);
+            }
+        } else {
+            LOGI("Pushing %s...", req.file);
+            bool ok = adb_push(intr, serial, req.file, push_target, 0);
+            if (ok) {
+                LOGI("%s successfully pushed to %s", req.file, push_target);
+            } else {
+                LOGE("Failed to push %s to %s", req.file, push_target);
+            }
+        }
+
+        sc_file_pusher_request_destroy(&req);
+    }
+    return 0;
+}
+
+bool
+sc_file_pusher_start(struct sc_file_pusher *fp) {
+    LOGD("Starting file_pusher thread");
+
+    bool ok = sc_thread_create(&fp->thread, run_file_pusher, "scrcpy-file", fp);
+    if (!ok) {
+        LOGC("Could not start file_pusher thread");
+        return false;
+    }
+
+    return true;
+}
+
+void
+sc_file_pusher_stop(struct sc_file_pusher *fp) {
+    sc_mutex_lock(&fp->mutex);
+    fp->stopped = true;
+    sc_cond_signal(&fp->event_cond);
+    sc_intr_interrupt(&fp->intr);
+    sc_mutex_unlock(&fp->mutex);
+}
+
+void
+sc_file_pusher_join(struct sc_file_pusher *fp) {
+    sc_thread_join(&fp->thread, NULL);
+}

app/src/file_pusher.h

@@ -0,0 +1,59 @@
+#ifndef SC_FILE_PUSHER_H
+#define SC_FILE_PUSHER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "adb.h"
+#include "util/cbuf.h"
+#include "util/thread.h"
+#include "util/intr.h"
+
+enum sc_file_pusher_action {
+    SC_FILE_PUSHER_ACTION_INSTALL_APK,
+    SC_FILE_PUSHER_ACTION_PUSH_FILE,
+};
+
+struct sc_file_pusher_request {
+    enum sc_file_pusher_action action;
+    char *file;
+};
+
+struct sc_file_pusher_request_queue CBUF(struct sc_file_pusher_request, 16);
+
+struct sc_file_pusher {
+    char *serial;
+    const char *push_target;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond event_cond;
+    bool stopped;
+    bool initialized;
+    struct sc_file_pusher_request_queue queue;
+
+    struct sc_intr intr;
+};
+
+bool
+sc_file_pusher_init(struct sc_file_pusher *fp, const char *serial,
+                    const char *push_target);
+
+void
+sc_file_pusher_destroy(struct sc_file_pusher *fp);
+
+bool
+sc_file_pusher_start(struct sc_file_pusher *fp);
+
+void
+sc_file_pusher_stop(struct sc_file_pusher *fp);
+
+void
+sc_file_pusher_join(struct sc_file_pusher *fp);
+
+// take ownership of file, and will free() it
+bool
+sc_file_pusher_request(struct sc_file_pusher *fp,
+                       enum sc_file_pusher_action action, char *file);
+
+#endif

app/src/hid_mouse.c

@@ -262,6 +262,6 @@ void
 sc_hid_mouse_destroy(struct sc_hid_mouse *mouse) {
     bool ok = sc_aoa_unregister_hid(mouse->aoa, HID_MOUSE_ACCESSORY_ID);
     if (!ok) {
-        LOGW("Could not unregister HID");
+        LOGW("Could not unregister HID mouse");
     }
 }

app/src/hid_mouse.h

@@ -1,5 +1,5 @@
-#ifndef HID_MOUSE_H
-#define HID_MOUSE_H
+#ifndef SC_HID_MOUSE_H
+#define SC_HID_MOUSE_H
 
 #include "common.h"
 

app/src/input_manager.c

@@ -124,15 +124,15 @@ is_shortcut_mod(struct sc_input_manager *im, uint16_t sdl_mod) {
 void
 sc_input_manager_init(struct sc_input_manager *im,
                       const struct sc_input_manager_params *params) {
-    assert(!params->control || (params->kp && params->kp->ops));
-    assert(!params->control || (params->mp && params->mp->ops));
+    assert(!params->controller || (params->kp && params->kp->ops));
+    assert(!params->controller || (params->mp && params->mp->ops));
 
     im->controller = params->controller;
+    im->fp = params->fp;
     im->screen = params->screen;
     im->kp = params->kp;
     im->mp = params->mp;
 
-    im->control = params->control;
     im->forward_all_clicks = params->forward_all_clicks;
     im->legacy_paste = params->legacy_paste;
     im->clipboard_autosync = params->clipboard_autosync;
@@ -433,9 +433,7 @@ inverse_point(struct sc_point point, struct sc_size size) {
 static void
 sc_input_manager_process_key(struct sc_input_manager *im,
                              const SDL_KeyboardEvent *event) {
-    // control: indicates the state of the command-line option --no-control
-    bool control = im->control;
-
+    // controller is NULL if --no-control is requested
     struct sc_controller *controller = im->controller;
 
     SDL_Keycode keycode = event->keysym.sym;
@@ -462,33 +460,33 @@ sc_input_manager_process_key(struct sc_input_manager *im,
         enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
         switch (keycode) {
             case SDLK_h:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_home(controller, action);
                 }
                 return;
             case SDLK_b: // fall-through
             case SDLK_BACKSPACE:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_back(controller, action);
                 }
                 return;
             case SDLK_s:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_app_switch(controller, action);
                 }
                 return;
             case SDLK_m:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_menu(controller, action);
                 }
                 return;
             case SDLK_p:
-                if (control && !shift && !repeat) {
+                if (controller && !shift && !repeat) {
                     action_power(controller, action);
                 }
                 return;
             case SDLK_o:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                     enum screen_power_mode mode = shift
                                                 ? SCREEN_POWER_MODE_NORMAL
                                                 : SCREEN_POWER_MODE_OFF;
@@ -496,13 +494,13 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 }
                 return;
             case SDLK_DOWN:
-                if (control && !shift) {
+                if (controller && !shift) {
                     // forward repeated events
                     action_volume_down(controller, action);
                 }
                 return;
             case SDLK_UP:
-                if (control && !shift) {
+                if (controller && !shift) {
                     // forward repeated events
                     action_volume_up(controller, action);
                 }
@@ -518,19 +516,19 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 }
                 return;
             case SDLK_c:
-                if (control && !shift && !repeat && down) {
+                if (controller && !shift && !repeat && down) {
                     get_device_clipboard(controller,
                                          GET_CLIPBOARD_COPY_KEY_COPY);
                 }
                 return;
             case SDLK_x:
-                if (control && !shift && !repeat && down) {
+                if (controller && !shift && !repeat && down) {
                     get_device_clipboard(controller,
                                          GET_CLIPBOARD_COPY_KEY_CUT);
                 }
                 return;
             case SDLK_v:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                     if (shift || im->legacy_paste) {
                         // inject the text as input events
                         clipboard_paste(controller);
@@ -563,7 +561,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 }
                 return;
             case SDLK_n:
-                if (control && !repeat && down) {
+                if (controller && !repeat && down) {
                     if (shift) {
                         collapse_panels(controller);
                     } else if (im->key_repeat == 0) {
@@ -574,7 +572,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 }
                 return;
             case SDLK_r:
-                if (control && !shift && !repeat && down) {
+                if (controller && !shift && !repeat && down) {
                     rotate_device(controller);
                 }
                 return;
@@ -583,7 +581,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
         return;
     }
 
-    if (!control) {
+    if (!controller) {
         return;
     }
 
@@ -700,7 +698,7 @@ sc_input_manager_process_touch(struct sc_input_manager *im,
 static void
 sc_input_manager_process_mouse_button(struct sc_input_manager *im,
                                       const SDL_MouseButtonEvent *event) {
-    bool control = im->control;
+    struct sc_controller *controller = im->controller;
 
     if (event->which == SDL_TOUCH_MOUSEID) {
         // simulated from touch events, so it's a duplicate
@@ -709,27 +707,29 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
 
     bool down = event->type == SDL_MOUSEBUTTONDOWN;
     if (!im->forward_all_clicks) {
-        enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
+        if (controller) {
+            enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
 
-        if (control && event->button == SDL_BUTTON_X1) {
-            action_app_switch(im->controller, action);
-            return;
-        }
-        if (control && event->button == SDL_BUTTON_X2 && down) {
-            if (event->clicks < 2) {
-                expand_notification_panel(im->controller);
-            } else {
-                expand_settings_panel(im->controller);
+            if (event->button == SDL_BUTTON_X1) {
+                action_app_switch(controller, action);
+                return;
+            }
+            if (event->button == SDL_BUTTON_X2 && down) {
+                if (event->clicks < 2) {
+                    expand_notification_panel(controller);
+                } else {
+                    expand_settings_panel(controller);
+                }
+                return;
+            }
+            if (event->button == SDL_BUTTON_RIGHT) {
+                press_back_or_turn_screen_on(controller, action);
+                return;
+            }
+            if (event->button == SDL_BUTTON_MIDDLE) {
+                action_home(controller, action);
+                return;
             }
-            return;
-        }
-        if (control && event->button == SDL_BUTTON_RIGHT) {
-            press_back_or_turn_screen_on(im->controller, action);
-            return;
-        }
-        if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, action);
-            return;
         }
 
         // double-click on black borders resize to fit the device screen
@@ -750,7 +750,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
         // otherwise, send the click event to the device
     }
 
-    if (!control) {
+    if (!controller) {
         return;
     }
 
@@ -834,45 +834,81 @@ sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,
     im->mp->ops->process_mouse_scroll(im->mp, &evt);
 }
 
-bool
+static bool
+is_apk(const char *file) {
+    const char *ext = strrchr(file, '.');
+    return ext && !strcmp(ext, ".apk");
+}
+
+static void
+sc_input_manager_process_file(struct sc_input_manager *im,
+                              const SDL_DropEvent *event) {
+    char *file = strdup(event->file);
+    SDL_free(event->file);
+    if (!file) {
+        LOG_OOM();
+        return;
+    }
+
+    enum sc_file_pusher_action action;
+    if (is_apk(file)) {
+        action = SC_FILE_PUSHER_ACTION_INSTALL_APK;
+    } else {
+        action = SC_FILE_PUSHER_ACTION_PUSH_FILE;
+    }
+    bool ok = sc_file_pusher_request(im->fp, action, file);
+    if (!ok) {
+        free(file);
+    }
+}
+
+void
 sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event) {
+    bool control = im->controller;
     switch (event->type) {
         case SDL_TEXTINPUT:
-            if (!im->control) {
-                return true;
+            if (!control) {
+                break;
             }
             sc_input_manager_process_text_input(im, &event->text);
-            return true;
+            break;
         case SDL_KEYDOWN:
         case SDL_KEYUP:
             // some key events do not interact with the device, so process the
             // event even if control is disabled
             sc_input_manager_process_key(im, &event->key);
-            return true;
+            break;
         case SDL_MOUSEMOTION:
-            if (!im->control) {
+            if (!control) {
                 break;
             }
             sc_input_manager_process_mouse_motion(im, &event->motion);
-            return true;
+            break;
         case SDL_MOUSEWHEEL:
-            if (!im->control) {
+            if (!control) {
                 break;
             }
             sc_input_manager_process_mouse_wheel(im, &event->wheel);
-            return true;
+            break;
         case SDL_MOUSEBUTTONDOWN:
         case SDL_MOUSEBUTTONUP:
             // some mouse events do not interact with the device, so process
             // the event even if control is disabled
             sc_input_manager_process_mouse_button(im, &event->button);
-            return true;
+            break;
         case SDL_FINGERMOTION:
         case SDL_FINGERDOWN:
         case SDL_FINGERUP:
+            if (!control) {
+                break;
+            }
             sc_input_manager_process_touch(im, &event->tfinger);
-            return true;
+            break;
+        case SDL_DROPFILE: {
+            if (!control) {
+                break;
+            }
+            sc_input_manager_process_file(im, &event->drop);
+        }
     }
-
-    return false;
 }

app/src/input_manager.h

@@ -8,6 +8,7 @@
 #include <SDL2/SDL.h>
 
 #include "controller.h"
+#include "file_pusher.h"
 #include "fps_counter.h"
 #include "options.h"
 #include "trait/key_processor.h"
@@ -15,12 +16,12 @@
 
 struct sc_input_manager {
     struct sc_controller *controller;
+    struct sc_file_pusher *fp;
     struct sc_screen *screen;
 
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
 
-    bool control;
     bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
@@ -44,11 +45,11 @@ struct sc_input_manager {
 
 struct sc_input_manager_params {
     struct sc_controller *controller;
+    struct sc_file_pusher *fp;
     struct sc_screen *screen;
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
 
-    bool control;
     bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
@@ -59,7 +60,7 @@ void
 sc_input_manager_init(struct sc_input_manager *im,
                       const struct sc_input_manager_params *params);
 
-bool
+void
 sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event);
 
 #endif

app/src/scrcpy.c

@@ -16,7 +16,7 @@
 #include "controller.h"
 #include "decoder.h"
 #include "events.h"
-#include "file_handler.h"
+#include "file_pusher.h"
 #ifdef HAVE_AOA_HID
 # include "hid_keyboard.h"
 # include "hid_mouse.h"
@@ -44,7 +44,7 @@ struct scrcpy {
     struct sc_v4l2_sink v4l2_sink;
 #endif
     struct sc_controller controller;
-    struct file_handler file_handler;
+    struct sc_file_pusher file_pusher;
 #ifdef HAVE_AOA_HID
     struct sc_aoa aoa;
     // sequence/ack helper to synchronize clipboard and Ctrl+v via HID
@@ -149,68 +149,18 @@ sdl_configure(bool display, bool disable_screensaver) {
 }
 
 static bool
-is_apk(const char *file) {
-    const char *ext = strrchr(file, '.');
-    return ext && !strcmp(ext, ".apk");
-}
-
-enum event_result {
-    EVENT_RESULT_CONTINUE,
-    EVENT_RESULT_STOPPED_BY_USER,
-    EVENT_RESULT_STOPPED_BY_EOS,
-};
-
-static enum event_result
-handle_event(struct scrcpy *s, const struct scrcpy_options *options,
-             SDL_Event *event) {
-    switch (event->type) {
-        case EVENT_STREAM_STOPPED:
-            LOGD("Video stream stopped");
-            return EVENT_RESULT_STOPPED_BY_EOS;
-        case SDL_QUIT:
-            LOGD("User requested to quit");
-            return EVENT_RESULT_STOPPED_BY_USER;
-        case SDL_DROPFILE: {
-            if (!options->control) {
-                break;
-            }
-            char *file = strdup(event->drop.file);
-            SDL_free(event->drop.file);
-            if (!file) {
-                LOGW("Could not strdup drop filename\n");
-                break;
-            }
-
-            file_handler_action_t action;
-            if (is_apk(file)) {
-                action = ACTION_INSTALL_APK;
-            } else {
-                action = ACTION_PUSH_FILE;
-            }
-            file_handler_request(&s->file_handler, action, file);
-            goto end;
-        }
-    }
-
-    bool consumed = sc_screen_handle_event(&s->screen, event);
-    (void) consumed;
-
-end:
-    return EVENT_RESULT_CONTINUE;
-}
-
-static bool
-event_loop(struct scrcpy *s, const struct scrcpy_options *options) {
+event_loop(struct scrcpy *s) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
-        enum event_result result = handle_event(s, options, &event);
-        switch (result) {
-            case EVENT_RESULT_STOPPED_BY_USER:
-                return true;
-            case EVENT_RESULT_STOPPED_BY_EOS:
+        switch (event.type) {
+            case EVENT_STREAM_STOPPED:
                 LOGW("Device disconnected");
                 return false;
-            case EVENT_RESULT_CONTINUE:
+            case SDL_QUIT:
+                LOGD("User requested to quit");
+                return true;
+            default:
+                sc_screen_handle_event(&s->screen, &event);
                 break;
         }
     }
@@ -327,7 +277,7 @@ scrcpy(struct scrcpy_options *options) {
     bool ret = false;
 
     bool server_started = false;
-    bool file_handler_initialized = false;
+    bool file_pusher_initialized = false;
     bool recorder_initialized = false;
 #ifdef HAVE_V4L2
     bool v4l2_sink_initialized = false;
@@ -407,12 +357,15 @@ scrcpy(struct scrcpy_options *options) {
     const char *serial = s->server.params.serial;
     assert(serial);
 
+    struct sc_file_pusher *fp = NULL;
+
     if (options->display && options->control) {
-        if (!file_handler_init(&s->file_handler, serial,
-                               options->push_target)) {
+        if (!sc_file_pusher_init(&s->file_pusher, serial,
+                                 options->push_target)) {
             goto end;
         }
-        file_handler_initialized = true;
+        fp = &s->file_pusher;
+        file_pusher_initialized = true;
     }
 
     struct decoder *dec = NULL;
@@ -452,6 +405,7 @@ scrcpy(struct scrcpy_options *options) {
         stream_add_sink(&s->stream, &rec->packet_sink);
     }
 
+    struct sc_controller *controller = NULL;
     struct sc_key_processor *kp = NULL;
     struct sc_mouse_processor *mp = NULL;
 
@@ -557,6 +511,7 @@ aoa_hid_end:
             goto end;
         }
         controller_started = true;
+        controller = &s->controller;
 
         if (options->turn_screen_off) {
             struct sc_control_msg msg;
@@ -570,15 +525,18 @@ aoa_hid_end:
 
     }
 
+    // There is a controller if and only if control is enabled
+    assert(options->control == !!controller);
+
     if (options->display) {
         const char *window_title =
             options->window_title ? options->window_title : info->device_name;
 
         struct sc_screen_params screen_params = {
-            .controller = &s->controller,
+            .controller = controller,
+            .fp = fp,
             .kp = kp,
             .mp = mp,
-            .control = options->control,
             .forward_all_clicks = options->forward_all_clicks,
             .legacy_paste = options->legacy_paste,
             .clipboard_autosync = options->clipboard_autosync,
@@ -625,7 +583,7 @@ aoa_hid_end:
     }
     stream_started = true;
 
-    ret = event_loop(s, options);
+    ret = event_loop(s);
     LOGD("quit...");
 
     // Close the window immediately on closing, because screen_destroy() may
@@ -640,6 +598,9 @@ end:
         if (hid_keyboard_initialized) {
             sc_hid_keyboard_destroy(&s->keyboard_hid);
         }
+        if (hid_mouse_initialized) {
+            sc_hid_mouse_destroy(&s->mouse_hid);
+        }
         sc_aoa_stop(&s->aoa);
     }
     if (acksync) {
@@ -649,8 +610,8 @@ end:
     if (controller_started) {
         sc_controller_stop(&s->controller);
     }
-    if (file_handler_initialized) {
-        file_handler_stop(&s->file_handler);
+    if (file_pusher_initialized) {
+        sc_file_pusher_stop(&s->file_pusher);
     }
     if (screen_initialized) {
         sc_screen_interrupt(&s->screen);
@@ -698,9 +659,9 @@ end:
         recorder_destroy(&s->recorder);
     }
 
-    if (file_handler_initialized) {
-        file_handler_join(&s->file_handler);
-        file_handler_destroy(&s->file_handler);
+    if (file_pusher_initialized) {
+        sc_file_pusher_join(&s->file_pusher);
+        sc_file_pusher_destroy(&s->file_pusher);
     }
 
     sc_server_destroy(&s->server);

app/src/screen.c

@@ -156,7 +156,13 @@ get_initial_optimal_size(struct sc_size content_size, uint16_t req_width,
     return window_size;
 }
 
-static inline void
+static inline bool
+sc_screen_is_relative_mode(struct sc_screen *screen) {
+    // screen->im.mp may be NULL if --no-control
+    return screen->im.mp && screen->im.mp->relative_mode;
+}
+
+static void
 sc_screen_capture_mouse(struct sc_screen *screen, bool capture) {
     if (SDL_SetRelativeMouseMode(capture)) {
         LOGE("Could not set relative mouse mode to %s: %s",
@@ -485,10 +491,10 @@ sc_screen_init(struct sc_screen *screen,
 
     struct sc_input_manager_params im_params = {
         .controller = params->controller,
+        .fp = params->fp,
         .screen = screen,
         .kp = params->kp,
         .mp = params->mp,
-        .control = params->control,
         .forward_all_clicks = params->forward_all_clicks,
         .legacy_paste = params->legacy_paste,
         .clipboard_autosync = params->clipboard_autosync,
@@ -701,6 +707,11 @@ sc_screen_update_frame(struct sc_screen *screen) {
         screen->has_frame = true;
         // 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_screen_capture_mouse(screen, true);
+        }
     }
 
     sc_screen_render(screen, false);
@@ -770,20 +781,22 @@ sc_screen_is_mouse_capture_key(SDL_Keycode key) {
     return key == SDLK_LALT || key == SDLK_LGUI || key == SDLK_RGUI;
 }
 
-bool
+void
 sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event) {
+    bool relative_mode = sc_screen_is_relative_mode(screen);
+
     switch (event->type) {
         case EVENT_NEW_FRAME: {
             bool ok = sc_screen_update_frame(screen);
             if (!ok) {
                 LOGW("Frame update failed\n");
             }
-            return true;
+            return;
         }
         case SDL_WINDOWEVENT:
             if (!screen->has_frame) {
                 // Do nothing
-                return true;
+                return;
             }
             switch (event->window.event) {
                 case SDL_WINDOWEVENT_EXPOSED:
@@ -809,70 +822,72 @@ sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event) {
                     sc_screen_render(screen, true);
                     break;
                 case SDL_WINDOWEVENT_FOCUS_LOST:
-                    if (screen->im.mp->relative_mode) {
+                    if (relative_mode) {
                         sc_screen_capture_mouse(screen, false);
                     }
                     break;
             }
-            return true;
+            return;
         case SDL_KEYDOWN:
-            if (screen->im.mp->relative_mode) {
+            if (relative_mode) {
                 SDL_Keycode key = event->key.keysym.sym;
                 if (sc_screen_is_mouse_capture_key(key)) {
                     if (!screen->mouse_capture_key_pressed) {
                         screen->mouse_capture_key_pressed = key;
-                        return true;
                     } else {
                         // Another mouse capture key has been pressed, cancel
                         // mouse (un)capture
                         screen->mouse_capture_key_pressed = 0;
-                        // Do not return, the event must be forwarded to the
-                        // input manager
                     }
+                    // Mouse capture keys are never forwarded to the device
+                    return;
                 }
             }
             break;
         case SDL_KEYUP:
-            if (screen->im.mp->relative_mode) {
+            if (relative_mode) {
                 SDL_Keycode key = event->key.keysym.sym;
                 SDL_Keycode cap = screen->mouse_capture_key_pressed;
                 screen->mouse_capture_key_pressed = 0;
-                if (key == cap) {
-                    // A mouse capture key has been pressed then released:
-                    // toggle the capture mouse mode
-                    sc_screen_capture_mouse(screen, !screen->mouse_captured);
-                    return true;
+                if (sc_screen_is_mouse_capture_key(key)) {
+                    if (key == cap) {
+                        // A mouse capture key has been pressed then released:
+                        // toggle the capture mouse mode
+                        sc_screen_capture_mouse(screen,
+                                                !screen->mouse_captured);
+                    }
+                    // Mouse capture keys are never forwarded to the device
+                    return;
                 }
-                // Do not return, the event must be forwarded to the input
-                // manager
             }
             break;
         case SDL_MOUSEWHEEL:
         case SDL_MOUSEMOTION:
         case SDL_MOUSEBUTTONDOWN:
-            if (screen->im.mp->relative_mode && !screen->mouse_captured) {
+            if (relative_mode && !screen->mouse_captured) {
                 // Do not forward to input manager, the mouse will be captured
                 // on SDL_MOUSEBUTTONUP
-                return true;
+                return;
             }
             break;
         case SDL_FINGERMOTION:
         case SDL_FINGERDOWN:
         case SDL_FINGERUP:
-            if (screen->im.mp->relative_mode) {
+            if (relative_mode) {
                 // Touch events are not compatible with relative mode
                 // (coordinates are not relative)
-                return true;
+                return;
             }
             break;
         case SDL_MOUSEBUTTONUP:
-            if (screen->im.mp->relative_mode && !screen->mouse_captured) {
+            if (relative_mode && !screen->mouse_captured) {
                 sc_screen_capture_mouse(screen, true);
-                return true;
+                return;
             }
+            break;
     }
 
-    return sc_input_manager_handle_event(&screen->im, event);
+    sc_input_manager_handle_event(&screen->im, event);
 }
 
 struct sc_point

app/src/screen.h

@@ -70,10 +70,10 @@ struct sc_screen {
 
 struct sc_screen_params {
     struct sc_controller *controller;
+    struct sc_file_pusher *fp;
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
 
-    bool control;
     bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
@@ -139,7 +139,7 @@ void
 sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation);
 
 // react to SDL events
-bool
+void
 sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event);
 
 // convert point from window coordinates to frame coordinates

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

@@ -46,15 +46,17 @@ public final class DesktopConnection implements Closeable {
         return localSocket;
     }
 
-    public static DesktopConnection open(Device device, boolean tunnelForward, boolean control) throws IOException {
+    public static DesktopConnection open(boolean tunnelForward, boolean control, boolean sendDummyByte) throws IOException {
         LocalSocket videoSocket;
         LocalSocket controlSocket = null;
         if (tunnelForward) {
             LocalServerSocket localServerSocket = new LocalServerSocket(SOCKET_NAME);
             try {
                 videoSocket = localServerSocket.accept();
-                // send one byte so the client may read() to detect a connection error
-                videoSocket.getOutputStream().write(0);
+                if (sendDummyByte) {
+                    // send one byte so the client may read() to detect a connection error
+                    videoSocket.getOutputStream().write(0);
+                }
                 if (control) {
                     try {
                         controlSocket = localServerSocket.accept();
@@ -78,10 +80,7 @@ public final class DesktopConnection implements Closeable {
             }
         }
 
-        DesktopConnection connection = new DesktopConnection(videoSocket, controlSocket);
-        Size videoSize = device.getScreenInfo().getVideoSize();
-        connection.send(Device.getDeviceName(), videoSize.getWidth(), videoSize.getHeight());
-        return connection;
+        return new DesktopConnection(videoSocket, controlSocket);
     }
 
     public void close() throws IOException {
@@ -95,7 +94,7 @@ public final class DesktopConnection implements Closeable {
         }
     }
 
-    private void send(String deviceName, int width, int height) throws IOException {
+    public void sendDeviceMeta(String deviceName, int width, int height) throws IOException {
         byte[] buffer = new byte[DEVICE_NAME_FIELD_LENGTH + 4];
 
         byte[] deviceNameBytes = deviceName.getBytes(StandardCharsets.UTF_8);

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

@@ -12,7 +12,6 @@ public class Options {
     private int lockVideoOrientation = -1;
     private boolean tunnelForward;
     private Rect crop;
-    private boolean sendFrameMeta = true; // send PTS so that the client may record properly
     private boolean control = true;
     private int displayId;
     private boolean showTouches;
@@ -23,6 +22,11 @@ public class Options {
     private boolean clipboardAutosync = true;
     private boolean downsizeOnError = true;
 
+    // Options not used by the scrcpy client, but useful to use scrcpy-server directly
+    private boolean sendDeviceMeta = true; // send device name and size
+    private boolean sendFrameMeta = true; // send PTS so that the client may record properly
+    private boolean sendDummyByte = true; // write a byte on start to detect connection issues
+
     public Ln.Level getLogLevel() {
         return logLevel;
     }
@@ -79,14 +83,6 @@ public class Options {
         this.crop = crop;
     }
 
-    public boolean getSendFrameMeta() {
-        return sendFrameMeta;
-    }
-
-    public void setSendFrameMeta(boolean sendFrameMeta) {
-        this.sendFrameMeta = sendFrameMeta;
-    }
-
     public boolean getControl() {
         return control;
     }
@@ -158,4 +154,28 @@ public class Options {
     public void setDownsizeOnError(boolean downsizeOnError) {
         this.downsizeOnError = downsizeOnError;
     }
+
+    public boolean getSendDeviceMeta() {
+        return sendDeviceMeta;
+    }
+
+    public void setSendDeviceMeta(boolean sendDeviceMeta) {
+        this.sendDeviceMeta = sendDeviceMeta;
+    }
+
+    public boolean getSendFrameMeta() {
+        return sendFrameMeta;
+    }
+
+    public void setSendFrameMeta(boolean sendFrameMeta) {
+        this.sendFrameMeta = sendFrameMeta;
+    }
+
+    public boolean getSendDummyByte() {
+        return sendDummyByte;
+    }
+
+    public void setSendDummyByte(boolean sendDummyByte) {
+        this.sendDummyByte = sendDummyByte;
+    }
 }

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

@@ -99,7 +99,7 @@ public class ScreenEncoder implements Device.RotationListener {
                     alive = encode(codec, fd);
                     // do not call stop() on exception, it would trigger an IllegalStateException
                     codec.stop();
-                } catch (Exception e) {
+                } catch (IllegalStateException e) {
                     Ln.e("Encoding error: " + e.getClass().getName() + ": " + e.getMessage());
                     if (!downsizeOnError || firstFrameSent) {
                         // Fail immediately
@@ -159,7 +159,10 @@ public class ScreenEncoder implements Device.RotationListener {
                     }
 
                     IO.writeFully(fd, codecBuffer);
-                    firstFrameSent = true;
+                    if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
+                        // If this is not a config packet, then it contains a frame
+                        firstFrameSent = true;
+                    }
                 }
             } finally {
                 if (outputBufferId >= 0) {

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

@@ -66,8 +66,13 @@ public final class Server {
 
         boolean tunnelForward = options.isTunnelForward();
         boolean control = options.getControl();
+        boolean sendDummyByte = options.getSendDummyByte();
 
-        try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward, control)) {
+        try (DesktopConnection connection = DesktopConnection.open(tunnelForward, control, sendDummyByte)) {
+            if (options.getSendDeviceMeta()) {
+                Size videoSize = device.getScreenInfo().getVideoSize();
+                connection.sendDeviceMeta(Device.getDeviceName(), videoSize.getWidth(), videoSize.getHeight());
+            }
             ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(), codecOptions,
                     options.getEncoderName(), options.getDownsizeOnError());
 
@@ -199,10 +204,6 @@ public final class Server {
                     Rect crop = parseCrop(value);
                     options.setCrop(crop);
                     break;
-                case "send_frame_meta":
-                    boolean sendFrameMeta = Boolean.parseBoolean(value);
-                    options.setSendFrameMeta(sendFrameMeta);
-                    break;
                 case "control":
                     boolean control = Boolean.parseBoolean(value);
                     options.setControl(control);
@@ -240,6 +241,25 @@ public final class Server {
                     boolean downsizeOnError = Boolean.parseBoolean(value);
                     options.setDownsizeOnError(downsizeOnError);
                     break;
+                case "send_device_meta":
+                    boolean sendDeviceMeta = Boolean.parseBoolean(value);
+                    options.setSendDeviceMeta(sendDeviceMeta);
+                    break;
+                case "send_frame_meta":
+                    boolean sendFrameMeta = Boolean.parseBoolean(value);
+                    options.setSendFrameMeta(sendFrameMeta);
+                    break;
+                case "send_dummy_byte":
+                    boolean sendDummyByte = Boolean.parseBoolean(value);
+                    options.setSendDummyByte(sendDummyByte);
+                    break;
+                case "raw_video_stream":
+                    boolean rawVideoStream = Boolean.parseBoolean(value);
+                    if (rawVideoStream) {
+                        options.setSendDeviceMeta(false);
+                        options.setSendFrameMeta(false);
+                        options.setSendDummyByte(false);
+                    }
                 default:
                     Ln.w("Unknown server option: " + key);
                     break;