Assert screen closed on destroy

The destruction order is important, but tricky, because the screen is
open/close by the decoder, but destroyed by scrcpy.c on the main thread.

Add assertions to guarantee that the screen is not destroyed before
being closed.

app/meson.build

@@ -33,11 +33,6 @@ else
     src += [ 'src/sys/unix/process.c' ]
 endif
 
-v4l2_support = host_machine.system() == 'linux'
-if v4l2_support
-    src += [ 'src/v4l2_sink.c' ]
-endif
-
 check_functions = [
     'strdup'
 ]
@@ -54,10 +49,6 @@ if not get_option('crossbuild_windows')
         dependency('sdl2'),
     ]
 
-    if v4l2_support
-        dependencies += dependency('libavdevice')
-    endif
-
 else
 
     # cross-compile mingw32 build (from Linux to Windows)
@@ -133,9 +124,6 @@ conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
 # select the debugger method ('old' for Android < 9, 'new' for Android >= 9)
 conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == 'new')
 
-# enable V4L2 support (linux only)
-conf.set('HAVE_V4L2', v4l2_support)
-
 configure_file(configuration: conf, output: 'config.h')
 
 src_dir = include_directories('src')

app/scrcpy.1

@@ -183,16 +183,16 @@ Enable "show touches" on start, restore the initial value on exit.
 
 It only shows physical touches (not clicks from scrcpy).
 
+.TP
+.B \-v, \-\-version
+Print the version of scrcpy.
+
 .TP
 .BI "\-V, \-\-verbosity " value
 Set the log level ("debug", "info", "warn" or "error").
 
 Default is "info" for release builds, "debug" for debug builds.
 
-.TP
-.B \-v, \-\-version
-Print the version of scrcpy.
-
 .TP
 .B \-w, \-\-stay-awake
 Keep the device on while scrcpy is running, when the device is plugged in.

app/src/cli.c

@@ -173,10 +173,8 @@ scrcpy_print_usage(const char *arg0) {
         "        on exit.\n"
         "        It only shows physical touches (not clicks from scrcpy).\n"
         "\n"
-        "    --v4l2_sink /dev/videoN\n"
-        "        Output to v4l2loopback device.\n"
-        "        It requires to lock the video orientation (see\n"
-        "        --lock-video-orientation).\n"
+        "    -v, --version\n"
+        "        Print the version of scrcpy.\n"
         "\n"
         "    -V, --verbosity value\n"
         "        Set the log level (debug, info, warn or error).\n"
@@ -185,9 +183,6 @@ scrcpy_print_usage(const char *arg0) {
 #else
         "        Default is info.\n"
 #endif
-        "\n"
-        "    -v, --version\n"
-        "        Print the version of scrcpy.\n"
         "\n"
         "    -w, --stay-awake\n"
         "        Keep the device on while scrcpy is running, when the device\n"
@@ -666,7 +661,6 @@ guess_record_format(const char *filename) {
 #define OPT_LEGACY_PASTE           1024
 #define OPT_ENCODER_NAME           1025
 #define OPT_POWER_OFF_ON_CLOSE     1026
-#define OPT_V4L2_SINK              1027
 
 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@@ -708,9 +702,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         {"show-touches",           no_argument,       NULL, 't'},
         {"stay-awake",             no_argument,       NULL, 'w'},
         {"turn-screen-off",        no_argument,       NULL, 'S'},
-#ifdef HAVE_V4L2
-        {"v4l2_sink",              required_argument, NULL, OPT_V4L2_SINK},
-#endif
         {"verbosity",              required_argument, NULL, 'V'},
         {"version",                no_argument,       NULL, 'v'},
         {"window-title",           required_argument, NULL, OPT_WINDOW_TITLE},
@@ -894,32 +885,17 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
             case OPT_POWER_OFF_ON_CLOSE:
                 opts->power_off_on_close = true;
                 break;
-            case OPT_V4L2_SINK:
-                opts->v4l2_device = optarg;
-                break;
             default:
                 // getopt prints the error message on stderr
                 return false;
         }
     }
 
-    if (!opts->display && !opts->record_filename && !opts->v4l2_device) {
-        LOGE("-N/--no-display requires either screen recording (-r/--record)"
-#ifdef HAVE_V4L2
-             " or sink to v4l2loopback device (--v4l2_sink)"
-#endif
-             );
+    if (!opts->display && !opts->record_filename) {
+        LOGE("-N/--no-display requires screen recording (-r/--record)");
         return false;
     }
 
-#ifdef HAVE_V4L2
-    if (opts->v4l2_device && opts->lock_video_orientation == -1) {
-        LOGI("Video orientation is locked for v4l2 sink. "
-             "See --lock-video-orientation.");
-        opts->lock_video_orientation = 0;
-    }
-#endif
-
     int index = optind;
     if (index < argc) {
         LOGE("Unexpected additional argument: %s", argv[index]);

app/src/control_msg.c

@@ -67,9 +67,6 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
             buffer_write32be(&buf[17],
                              (uint32_t) msg->inject_scroll_event.vscroll);
             return 21;
-        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
-            buf[1] = msg->inject_keycode.action;
-            return 2;
         case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
             buf[1] = !!msg->set_clipboard.paste;
             size_t len = write_string(msg->set_clipboard.text,
@@ -80,6 +77,7 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
         case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
             buf[1] = msg->set_screen_power_mode.mode;
             return 2;
+        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
         case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
         case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
         case CONTROL_MSG_TYPE_GET_CLIPBOARD:

app/src/control_msg.h

@@ -64,10 +64,6 @@ struct control_msg {
             int32_t hscroll;
             int32_t vscroll;
         } inject_scroll_event;
-        struct {
-            enum android_keyevent_action action; // action for the BACK key
-            // screen may only be turned on on ACTION_DOWN
-        } back_or_screen_on;
         struct {
             char *text; // owned, to be freed by free()
             bool paste;

app/src/decoder.c

@@ -64,7 +64,6 @@ decoder_open(struct decoder *decoder, const AVCodec *codec) {
         av_frame_free(&decoder->frame);
         avcodec_close(decoder->codec_ctx);
         avcodec_free_context(&decoder->codec_ctx);
-        return false;
     }
 
     return true;
@@ -99,8 +98,8 @@ decoder_push(struct decoder *decoder, const AVPacket *packet) {
         return true;
     }
 
-    int ret = avcodec_send_packet(decoder->codec_ctx, packet);
-    if (ret < 0 && ret != AVERROR(EAGAIN)) {
+    int ret;
+    if ((ret = avcodec_send_packet(decoder->codec_ctx, packet)) < 0) {
         LOGE("Could not send video packet: %d", ret);
         return false;
     }

app/src/decoder.h

@@ -8,7 +8,7 @@
 #include <stdbool.h>
 #include <libavformat/avformat.h>
 
-#define DECODER_MAX_SINKS 2
+#define DECODER_MAX_SINKS 1
 
 struct decoder {
     struct sc_packet_sink packet_sink; // packet sink trait

app/src/input_manager.c

@@ -146,25 +146,13 @@ action_cut(struct controller *controller, int actions) {
 }
 
 // turn the screen on if it was off, press BACK otherwise
-// If the screen is off, it is turned on only on ACTION_DOWN
 static void
-press_back_or_turn_screen_on(struct controller *controller, int actions) {
+press_back_or_turn_screen_on(struct controller *controller) {
     struct control_msg msg;
     msg.type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
 
-    if (actions & ACTION_DOWN) {
-        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_DOWN;
-        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'press back or turn screen on'");
-            return;
-        }
-    }
-
-    if (actions & ACTION_UP) {
-        msg.back_or_screen_on.action = AKEY_EVENT_ACTION_UP;
-        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'press back or turn screen on'");
-        }
+    if (!controller_push_msg(controller, &msg)) {
+        LOGW("Could not request 'press back or turn screen on'");
     }
 }
 
@@ -658,23 +646,13 @@ input_manager_process_mouse_button(struct input_manager *im,
     }
 
     bool down = event->type == SDL_MOUSEBUTTONDOWN;
-    if (!im->forward_all_clicks) {
-        int action = down ? ACTION_DOWN : ACTION_UP;
-
-        if (control && event->button == SDL_BUTTON_X1) {
-            action_app_switch(im->controller, action);
-            return;
-        }
-        if (control && event->button == SDL_BUTTON_X2 && down) {
-            expand_notification_panel(im->controller);
-            return;
-        }
+    if (!im->forward_all_clicks && down) {
         if (control && event->button == SDL_BUTTON_RIGHT) {
-            press_back_or_turn_screen_on(im->controller, action);
+            press_back_or_turn_screen_on(im->controller);
             return;
         }
         if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, action);
+            action_home(im->controller, ACTION_DOWN | ACTION_UP);
             return;
         }
 
@@ -687,9 +665,7 @@ input_manager_process_mouse_button(struct input_manager *im,
             bool outside = x < r->x || x >= r->x + r->w
                         || y < r->y || y >= r->y + r->h;
             if (outside) {
-                if (down) {
-                    screen_resize_to_fit(im->screen);
-                }
+                screen_resize_to_fit(im->screen);
                 return;
             }
         }

app/src/main.c

@@ -6,9 +6,6 @@
 #include <stdbool.h>
 #include <unistd.h>
 #include <libavformat/avformat.h>
-#ifdef HAVE_V4L2
-# include <libavdevice/avdevice.h>
-#endif
 #define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
 #include <SDL2/SDL.h>
 
@@ -31,11 +28,6 @@ print_version(void) {
     fprintf(stderr, " - libavutil %d.%d.%d\n", LIBAVUTIL_VERSION_MAJOR,
                                                LIBAVUTIL_VERSION_MINOR,
                                                LIBAVUTIL_VERSION_MICRO);
-#ifdef HAVE_V4L2
-    fprintf(stderr, " - libavdevice %d.%d.%d\n", LIBAVDEVICE_VERSION_MAJOR,
-                                                 LIBAVDEVICE_VERSION_MINOR,
-                                                 LIBAVDEVICE_VERSION_MICRO);
-#endif
 }
 
 static SDL_LogPriority
@@ -98,12 +90,6 @@ main(int argc, char *argv[]) {
     av_register_all();
 #endif
 
-#ifdef HAVE_V4L2
-    if (args.opts.v4l2_device) {
-        avdevice_register_all();
-    }
-#endif
-
     if (avformat_network_init()) {
         return 1;
     }

app/src/recorder.c

@@ -4,7 +4,6 @@
 #include <libavutil/time.h>
 
 #include "util/log.h"
-#include "util/str_util.h"
 
 /** Downcast packet_sink to recorder */
 #define DOWNCAST(SINK) container_of(SINK, struct recorder, packet_sink)
@@ -23,8 +22,8 @@ find_muxer(const char *name) {
 #else
         oformat = av_oformat_next(oformat);
 #endif
-        // until null or containing the requested name
-    } while (oformat && !strlist_contains(oformat->name, ',', name));
+        // until null or with name "mp4"
+    } while (oformat && strcmp(oformat->name, name));
     return oformat;
 }
 
@@ -219,36 +218,18 @@ run_recorder(void *data) {
 
 static bool
 recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
-    bool ok = sc_mutex_init(&recorder->mutex);
-    if (!ok) {
-        LOGC("Could not create mutex");
-        return false;
-    }
-
-    ok = sc_cond_init(&recorder->queue_cond);
-    if (!ok) {
-        LOGC("Could not create cond");
-        goto error_mutex_destroy;
-    }
-
-    queue_init(&recorder->queue);
-    recorder->stopped = false;
-    recorder->failed = false;
-    recorder->header_written = false;
-    recorder->previous = NULL;
-
     const char *format_name = recorder_get_format_name(recorder->format);
     assert(format_name);
     const AVOutputFormat *format = find_muxer(format_name);
     if (!format) {
         LOGE("Could not find muxer");
-        goto error_cond_destroy;
+        return false;
     }
 
     recorder->ctx = avformat_alloc_context();
     if (!recorder->ctx) {
         LOGE("Could not allocate output context");
-        goto error_cond_destroy;
+        return false;
     }
 
     // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
@@ -262,7 +243,8 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
 
     AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
     if (!ostream) {
-        goto error_avformat_free_context;
+        avformat_free_context(recorder->ctx);
+        return false;
     }
 
     ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
@@ -276,31 +258,22 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
     if (ret < 0) {
         LOGE("Failed to open output file: %s", recorder->filename);
         // ostream will be cleaned up during context cleaning
-        goto error_avformat_free_context;
+        avformat_free_context(recorder->ctx);
+        return false;
     }
 
     LOGD("Starting recorder thread");
-    ok = sc_thread_create(&recorder->thread, run_recorder, "recorder",
+    bool ok = sc_thread_create(&recorder->thread, run_recorder, "recorder",
                                recorder);
     if (!ok) {
         LOGC("Could not start recorder thread");
-        goto error_avio_close;
+        avformat_free_context(recorder->ctx);
+        return false;
     }
 
     LOGI("Recording started to %s file: %s", format_name, recorder->filename);
 
     return true;
-
-error_avio_close:
-    avio_close(recorder->ctx->pb);
-error_avformat_free_context:
-    avformat_free_context(recorder->ctx);
-error_cond_destroy:
-    sc_cond_destroy(&recorder->queue_cond);
-error_mutex_destroy:
-    sc_mutex_destroy(&recorder->mutex);
-
-    return false;
 }
 
 static void
@@ -314,8 +287,6 @@ recorder_close(struct recorder *recorder) {
 
     avio_close(recorder->ctx->pb);
     avformat_free_context(recorder->ctx);
-    sc_cond_destroy(&recorder->queue_cond);
-    sc_mutex_destroy(&recorder->mutex);
 }
 
 static bool
@@ -372,8 +343,28 @@ recorder_init(struct recorder *recorder,
         return false;
     }
 
+    bool ok = sc_mutex_init(&recorder->mutex);
+    if (!ok) {
+        LOGC("Could not create mutex");
+        free(recorder->filename);
+        return false;
+    }
+
+    ok = sc_cond_init(&recorder->queue_cond);
+    if (!ok) {
+        LOGC("Could not create cond");
+        sc_mutex_destroy(&recorder->mutex);
+        free(recorder->filename);
+        return false;
+    }
+
+    queue_init(&recorder->queue);
+    recorder->stopped = false;
+    recorder->failed = false;
     recorder->format = format;
     recorder->declared_frame_size = declared_frame_size;
+    recorder->header_written = false;
+    recorder->previous = NULL;
 
     static const struct sc_packet_sink_ops ops = {
         .open = recorder_packet_sink_open,
@@ -388,5 +379,7 @@ recorder_init(struct recorder *recorder,
 
 void
 recorder_destroy(struct recorder *recorder) {
+    sc_cond_destroy(&recorder->queue_cond);
+    sc_mutex_destroy(&recorder->mutex);
     free(recorder->filename);
 }

app/src/scrcpy.c

@@ -27,9 +27,6 @@
 #include "tiny_xpm.h"
 #include "util/log.h"
 #include "util/net.h"
-#ifdef HAVE_V4L2
-# include "v4l2_sink.h"
-#endif
 
 static struct server server;
 static struct screen screen;
@@ -37,9 +34,6 @@ static struct fps_counter fps_counter;
 static struct stream stream;
 static struct decoder decoder;
 static struct recorder recorder;
-#ifdef HAVE_V4L2
-static struct sc_v4l2_sink v4l2_sink;
-#endif
 static struct controller controller;
 static struct file_handler file_handler;
 
@@ -132,6 +126,30 @@ sdl_init_and_configure(bool display, const char *render_driver,
     return true;
 }
 
+
+#if defined(__APPLE__) || defined(__WINDOWS__)
+# define CONTINUOUS_RESIZING_WORKAROUND
+#endif
+
+#ifdef CONTINUOUS_RESIZING_WORKAROUND
+// On Windows and MacOS, resizing blocks the event loop, so resizing events are
+// not triggered. As a workaround, handle them in an event handler.
+//
+// <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
+// <https://stackoverflow.com/a/40693139/1987178>
+static int
+event_watcher(void *data, SDL_Event *event) {
+    (void) data;
+    if (event->type == SDL_WINDOWEVENT
+            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
+        // In practice, it seems to always be called from the same thread in
+        // that specific case. Anyway, it's just a workaround.
+        screen_render(&screen, true);
+    }
+    return 0;
+}
+#endif
+
 static bool
 is_apk(const char *file) {
     const char *ext = strrchr(file, '.');
@@ -171,7 +189,7 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
                 action = ACTION_PUSH_FILE;
             }
             file_handler_request(&file_handler, action, file);
-            goto end;
+            break;
         }
     }
 
@@ -189,6 +207,11 @@ end:
 
 static bool
 event_loop(const struct scrcpy_options *options) {
+#ifdef CONTINUOUS_RESIZING_WORKAROUND
+    if (options->display) {
+        SDL_AddEventWatch(event_watcher, NULL);
+    }
+#endif
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         enum event_result result = handle_event(&event, options);
@@ -253,9 +276,6 @@ scrcpy(const struct scrcpy_options *options) {
     bool fps_counter_initialized = false;
     bool file_handler_initialized = false;
     bool recorder_initialized = false;
-#ifdef HAVE_V4L2
-    bool v4l2_sink_initialized = false;
-#endif
     bool stream_started = false;
     bool controller_initialized = false;
     bool controller_started = false;
@@ -374,7 +394,6 @@ scrcpy(const struct scrcpy_options *options) {
             .window_borderless = options->window_borderless,
             .rotation = options->rotation,
             .mipmaps = options->mipmaps,
-            .fullscreen = options->fullscreen,
         };
 
         if (!screen_init(&screen, &fps_counter, &screen_params)) {
@@ -393,19 +412,11 @@ scrcpy(const struct scrcpy_options *options) {
                 LOGW("Could not request 'set screen power mode'");
             }
         }
-    }
 
-#ifdef HAVE_V4L2
-    if (options->v4l2_device) {
-        if (!sc_v4l2_sink_init(&v4l2_sink, options->v4l2_device, frame_size)) {
-            goto end;
+        if (options->fullscreen) {
+            screen_switch_fullscreen(&screen);
         }
-
-        decoder_add_sink(&decoder, &v4l2_sink.frame_sink);
-
-        v4l2_sink_initialized = true;
     }
-#endif
 
     // now we consumed the header values, the socket receives the video stream
     // start the stream
@@ -419,10 +430,6 @@ scrcpy(const struct scrcpy_options *options) {
     ret = event_loop(options);
     LOGD("quit...");
 
-    // Close the window immediately on closing, because screen_destroy() may
-    // only be called once the stream thread is joined (it may take time)
-    screen_hide_window(&screen);
-
 end:
     // The stream is not stopped explicitly, because it will stop by itself on
     // end-of-stream
@@ -447,12 +454,6 @@ end:
         stream_join(&stream);
     }
 
-#ifdef HAVE_V4L2
-    if (v4l2_sink_initialized) {
-        sc_v4l2_sink_destroy(&v4l2_sink);
-    }
-#endif
-
     // Destroy the screen only after the stream is guaranteed to be finished,
     // because otherwise the screen could receive new frames after destruction
     if (screen_initialized) {

app/src/scrcpy.h

@@ -52,7 +52,6 @@ struct scrcpy_options {
     const char *render_driver;
     const char *codec_options;
     const char *encoder_name;
-    const char *v4l2_device;
     enum sc_log_level log_level;
     enum sc_record_format record_format;
     struct sc_port_range port_range;
@@ -94,7 +93,6 @@ struct scrcpy_options {
     .render_driver = NULL, \
     .codec_options = NULL, \
     .encoder_name = NULL, \
-    .v4l2_device = NULL, \
     .log_level = SC_LOG_LEVEL_INFO, \
     .record_format = SC_RECORD_FORMAT_AUTO, \
     .port_range = { \

app/src/screen.c

@@ -220,29 +220,6 @@ create_texture(struct screen *screen) {
     return texture;
 }
 
-#if defined(__APPLE__) || defined(__WINDOWS__)
-# define CONTINUOUS_RESIZING_WORKAROUND
-#endif
-
-#ifdef CONTINUOUS_RESIZING_WORKAROUND
-// On Windows and MacOS, resizing blocks the event loop, so resizing events are
-// not triggered. As a workaround, handle them in an event handler.
-//
-// <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
-// <https://stackoverflow.com/a/40693139/1987178>
-static int
-event_watcher(void *data, SDL_Event *event) {
-    struct screen *screen = data;
-    if (event->type == SDL_WINDOWEVENT
-            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
-        // In practice, it seems to always be called from the same thread in
-        // that specific case. Anyway, it's just a workaround.
-        screen_render(screen, true);
-    }
-    return 0;
-}
-#endif
-
 static bool
 screen_frame_sink_open(struct sc_frame_sink *sink) {
     struct screen *screen = DOWNCAST(sink);
@@ -425,14 +402,6 @@ screen_init(struct screen *screen, struct fps_counter *fps_counter,
 
     screen_update_content_rect(screen);
 
-    if (params->fullscreen) {
-        screen_switch_fullscreen(screen);
-    }
-
-#ifdef CONTINUOUS_RESIZING_WORKAROUND
-    SDL_AddEventWatch(event_watcher, screen);
-#endif
-
     static const struct sc_frame_sink_ops ops = {
         .open = screen_frame_sink_open,
         .close = screen_frame_sink_close,
@@ -448,16 +417,11 @@ screen_init(struct screen *screen, struct fps_counter *fps_counter,
     return true;
 }
 
-static void
+void
 screen_show_window(struct screen *screen) {
     SDL_ShowWindow(screen->window);
 }
 
-void
-screen_hide_window(struct screen *screen) {
-    SDL_HideWindow(screen->window);
-}
-
 void
 screen_destroy(struct screen *screen) {
 #ifndef NDEBUG

app/src/screen.h

@@ -12,6 +12,8 @@
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
 
+struct video_buffer;
+
 struct screen {
     struct sc_frame_sink frame_sink; // frame sink trait
 
@@ -60,8 +62,6 @@ struct screen_params {
 
     uint8_t rotation;
     bool mipmaps;
-
-    bool fullscreen;
 };
 
 // initialize screen, create window, renderer and texture (window is hidden)
@@ -69,17 +69,14 @@ bool
 screen_init(struct screen *screen, struct fps_counter *fps_counter,
             const struct screen_params *params);
 
+// show the window
+void
+screen_show_window(struct screen *screen);
+
 // destroy window, renderer and texture (if any)
 void
 screen_destroy(struct screen *screen);
 
-// hide the window
-//
-// It is used to hide the window immediately on closing without waiting for
-// screen_destroy()
-void
-screen_hide_window(struct screen *screen);
-
 // render the texture to the renderer
 //
 // Set the update_content_rect flag if the window or content size may have

app/src/trait/frame_sink.h

@@ -6,8 +6,6 @@
 #include <assert.h>
 #include <stdbool.h>
 
-typedef struct AVFrame AVFrame;
-
 /**
  * Frame sink trait.
  *

app/src/trait/packet_sink.h

@@ -5,9 +5,7 @@
 
 #include <assert.h>
 #include <stdbool.h>
-
-typedef struct AVCodec AVCodec;
-typedef struct AVPacket AVPacket;
+#include <libavcodec/avcodec.h>
 
 /**
  * Packet sink trait.

app/src/util/str_util.c

@@ -140,24 +140,6 @@ parse_integer_with_suffix(const char *s, long *out) {
     return true;
 }
 
-bool
-strlist_contains(const char *list, char sep, const char *s) {
-    char *p;
-    do {
-        p = strchr(list, sep);
-
-        size_t token_len = p ? (size_t) (p - list) : strlen(list);
-        if (!strncmp(list, s, token_len)) {
-            return true;
-        }
-
-        if (p) {
-            list = p + 1;
-        }
-    } while (p);
-    return false;
-}
-
 size_t
 utf8_truncation_index(const char *utf8, size_t max_len) {
     size_t len = strlen(utf8);

app/src/util/str_util.h

@@ -43,11 +43,6 @@ parse_integers(const char *s, const char sep, size_t max_items, long *out);
 bool
 parse_integer_with_suffix(const char *s, long *out);
 
-// search s in the list separated by sep
-// for example, strlist_contains("a,bc,def", ',', "bc") returns true
-bool
-strlist_contains(const char *list, char sep, const char *s);
-
 // return the index to truncate a UTF-8 string at a valid position
 size_t
 utf8_truncation_index(const char *utf8, size_t max_len);

app/src/v4l2_sink.c

@@ -1,265 +0,0 @@
-#include "v4l2_sink.h"
-
-#include "util/log.h"
-#include "util/str_util.h"
-
-/** Downcast frame_sink to sc_v4l2_sink */
-#define DOWNCAST(SINK) container_of(SINK, struct sc_v4l2_sink, frame_sink)
-
-static const AVOutputFormat *
-find_muxer(const char *name) {
-#ifdef SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
-    void *opaque = NULL;
-#endif
-    const AVOutputFormat *oformat = NULL;
-    do {
-#ifdef SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
-        oformat = av_muxer_iterate(&opaque);
-#else
-        oformat = av_oformat_next(oformat);
-#endif
-        // until null or containing the requested name
-    } while (oformat && !strlist_contains(oformat->name, ',', name));
-    return oformat;
-}
-
-static bool
-encode_and_send_frame(struct sc_v4l2_sink *vs, const AVFrame *frame) {
-    int ret = avcodec_send_frame(vs->encoder_ctx, frame);
-    if (ret < 0 && ret != AVERROR(EAGAIN)) {
-        LOGE("Could not send v4l2 video frame: %d", ret);
-        return false;
-    }
-
-    AVPacket *packet = &vs->packet;
-    ret = avcodec_receive_packet(vs->encoder_ctx, packet);
-    if (ret == 0) {
-        // A packet was received
-        av_write_frame(vs->format_ctx, packet);
-        av_packet_unref(packet);
-    } else if (ret != AVERROR(EAGAIN)) {
-        LOGE("Could not receive v4l2 video packet: %d", ret);
-        return false;
-    }
-
-    return true;
-}
-
-static int
-run_v4l2_sink(void *data) {
-    struct sc_v4l2_sink *vs = data;
-
-    for (;;) {
-        sc_mutex_lock(&vs->mutex);
-
-        while (!vs->stopped && vs->vb.pending_frame_consumed) {
-            sc_cond_wait(&vs->cond, &vs->mutex);
-        }
-
-        if (vs->stopped) {
-            sc_mutex_unlock(&vs->mutex);
-            break;
-        }
-
-        sc_mutex_unlock(&vs->mutex);
-
-        video_buffer_consume(&vs->vb, vs->frame);
-        bool ok = encode_and_send_frame(vs, vs->frame);
-        if (!ok) {
-            LOGE("Could not send frame to v4l2 sink");
-            break;
-        }
-    }
-
-    LOGD("V4l2 thread ended");
-
-    return 0;
-}
-
-static bool
-sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
-    bool ok = video_buffer_init(&vs->vb);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_mutex_init(&vs->mutex);
-    if (!ok) {
-        LOGC("Could not create mutex");
-        goto error_video_buffer_destroy;
-    }
-
-    ok = sc_cond_init(&vs->cond);
-    if (!ok) {
-        LOGC("Could not create cond");
-        goto error_mutex_destroy;
-    }
-
-    // FIXME
-    const AVOutputFormat *format = find_muxer("video4linux2,v4l2");
-    if (!format) {
-        LOGE("Could not find v4l2 muxer");
-        goto error_cond_destroy;
-    }
-
-    const AVCodec *encoder = avcodec_find_encoder(AV_CODEC_ID_RAWVIDEO);
-    if (!encoder) {
-        LOGE("Raw video encoder not found");
-        return false;
-    }
-
-    vs->format_ctx = avformat_alloc_context();
-    if (!vs->format_ctx) {
-        LOGE("Could not allocate v4l2 output context");
-        return false;
-    }
-
-    // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
-    // returns (on purpose) a pointer-to-const, but AVFormatContext.oformat
-    // still expects a pointer-to-non-const (it has not be updated accordingly)
-    // <https://github.com/FFmpeg/FFmpeg/commit/0694d8702421e7aff1340038559c438b61bb30dd>
-    vs->format_ctx->oformat = (AVOutputFormat *) format;
-
-    AVStream *ostream = avformat_new_stream(vs->format_ctx, encoder);
-    if (!ostream) {
-        LOGE("Could not allocate new v4l2 stream");
-        goto error_avformat_free_context;
-        return false;
-    }
-
-    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
-    ostream->codecpar->codec_id = encoder->id;
-    ostream->codecpar->format = AV_PIX_FMT_YUV420P;
-    ostream->codecpar->width = vs->frame_size.width;
-    ostream->codecpar->height = vs->frame_size.height;
-
-    int ret = avio_open(&vs->format_ctx->pb, vs->device_name, AVIO_FLAG_WRITE);
-    if (ret < 0) {
-        LOGE("Failed to open output device: %s", vs->device_name);
-        // ostream will be cleaned up during context cleaning
-        goto error_avformat_free_context;
-    }
-
-    vs->encoder_ctx = avcodec_alloc_context3(encoder);
-    if (!vs->encoder_ctx) {
-        LOGC("Could not allocate codec context for v4l2");
-        goto error_avio_close;
-    }
-
-    vs->encoder_ctx->width = vs->frame_size.width;
-    vs->encoder_ctx->height = vs->frame_size.height;
-    vs->encoder_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
-    vs->encoder_ctx->time_base.num = 1;
-    vs->encoder_ctx->time_base.den = 1;
-
-    if (avcodec_open2(vs->encoder_ctx, encoder, NULL) < 0) {
-        LOGE("Could not open codec for v4l2");
-        goto error_avcodec_free_context;
-    }
-
-    vs->frame = av_frame_alloc();
-    if (!vs->frame) {
-        LOGE("Could not create v4l2 frame");
-        goto error_avcodec_close;
-    }
-
-    LOGD("Starting v4l2 thread");
-    ok = sc_thread_create(&vs->thread, run_v4l2_sink, "v4l2", vs);
-    if (!ok) {
-        LOGC("Could not start v4l2 thread");
-        goto error_av_frame_free;
-    }
-
-    LOGI("v4l2 sink started to device: %s", vs->device_name);
-
-    return true;
-
-error_av_frame_free:
-    av_frame_free(&vs->frame);
-error_avcodec_close:
-    avcodec_close(vs->encoder_ctx);
-error_avcodec_free_context:
-    avcodec_free_context(&vs->encoder_ctx);
-error_avio_close:
-    avio_close(vs->format_ctx->pb);
-error_avformat_free_context:
-    avformat_free_context(vs->format_ctx);
-error_cond_destroy:
-    sc_cond_destroy(&vs->cond);
-error_mutex_destroy:
-    sc_mutex_destroy(&vs->mutex);
-error_video_buffer_destroy:
-    video_buffer_destroy(&vs->vb);
-
-    return false;
-}
-
-static void
-sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
-    av_frame_free(&vs->frame);
-    avcodec_close(vs->encoder_ctx);
-    avcodec_free_context(&vs->encoder_ctx);
-    avio_close(vs->format_ctx->pb);
-    avformat_free_context(vs->format_ctx);
-    sc_cond_destroy(&vs->cond);
-    sc_mutex_destroy(&vs->mutex);
-    video_buffer_destroy(&vs->vb);
-}
-
-static bool
-sc_v4l2_sink_push(struct sc_v4l2_sink *vs, const AVFrame *frame) {
-    bool ok = video_buffer_push(&vs->vb, frame, NULL);
-    if (!ok) {
-        return false;
-    }
-
-    // signal possible change of vs->vb.pending_frame_consumed
-    sc_cond_signal(&vs->cond);
-
-    return true;
-}
-
-static bool
-sc_v4l2_frame_sink_open(struct sc_frame_sink *sink) {
-    struct sc_v4l2_sink *vs = DOWNCAST(sink);
-    return sc_v4l2_sink_open(vs);
-}
-
-static void
-sc_v4l2_frame_sink_close(struct sc_frame_sink *sink) {
-    struct sc_v4l2_sink *vs = DOWNCAST(sink);
-    sc_v4l2_sink_close(vs);
-}
-
-static bool
-sc_v4l2_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
-    struct sc_v4l2_sink *vs = DOWNCAST(sink);
-    return sc_v4l2_sink_push(vs, frame);
-}
-
-bool
-sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct size frame_size) {
-    vs->device_name = strdup(device_name);
-    if (!vs->device_name) {
-        LOGE("Could not strdup v4l2 device name");
-        return false;
-    }
-
-    vs->frame_size = frame_size;
-
-    static const struct sc_frame_sink_ops ops = {
-        .open = sc_v4l2_frame_sink_open,
-        .close = sc_v4l2_frame_sink_close,
-        .push = sc_v4l2_frame_sink_push,
-    };
-
-    vs->frame_sink.ops = &ops;
-
-    return true;
-}
-
-void
-sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs) {
-    free(vs->device_name);
-}

app/src/v4l2_sink.h

@@ -1,38 +0,0 @@
-#ifndef SC_V4L2_SINK_H
-#define SC_V4L2_SINK_H
-
-#include "common.h"
-
-#include "coords.h"
-#include "trait/frame_sink.h"
-#include "video_buffer.h"
-
-#include <libavformat/avformat.h>
-
-struct sc_v4l2_sink {
-    struct sc_frame_sink frame_sink; // frame sink trait
-
-    struct video_buffer vb;
-    AVFormatContext *format_ctx;
-    AVCodecContext *encoder_ctx;
-
-    char *device_name;
-    struct size frame_size;
-
-    sc_thread thread;
-    sc_mutex mutex;
-    sc_cond cond;
-    bool stopped;
-
-    AVFrame *frame;
-    AVPacket packet;
-};
-
-bool
-sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct size frame_size);
-
-void
-sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);
-
-#endif

app/tests/test_control_msg_serialize.c

@@ -146,18 +146,14 @@ static void test_serialize_inject_scroll_event(void) {
 static void test_serialize_back_or_screen_on(void) {
     struct control_msg msg = {
         .type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
-        .back_or_screen_on = {
-            .action = AKEY_EVENT_ACTION_UP,
-        },
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
     size_t size = control_msg_serialize(&msg, buf);
-    assert(size == 2);
+    assert(size == 1);
 
     const unsigned char expected[] = {
         CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
-        0x01, // AKEY_EVENT_ACTION_UP
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }

app/tests/test_strutil.c

@@ -287,18 +287,6 @@ static void test_parse_integer_with_suffix(void) {
     assert(!ok);
 }
 
-static void test_strlist_contains(void) {
-    assert(strlist_contains("a,bc,def", ',', "bc"));
-    assert(!strlist_contains("a,bc,def", ',', "b"));
-    assert(strlist_contains("", ',', ""));
-    assert(strlist_contains("abc,", ',', ""));
-    assert(strlist_contains(",abc", ',', ""));
-    assert(strlist_contains("abc,,def", ',', ""));
-    assert(!strlist_contains("abc", ',', ""));
-    assert(strlist_contains(",,|x", '|', ",,"));
-    assert(strlist_contains("xyz", '\0', "xyz"));
-}
-
 int main(int argc, char *argv[]) {
     (void) argc;
     (void) argv;
@@ -316,6 +304,5 @@ int main(int argc, char *argv[]) {
     test_parse_integer();
     test_parse_integers();
     test_parse_integer_with_suffix();
-    test_strlist_contains();
     return 0;
 }

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

@@ -71,13 +71,6 @@ public final class ControlMessage {
         return msg;
     }
 
-    public static ControlMessage createBackOrScreenOn(int action) {
-        ControlMessage msg = new ControlMessage();
-        msg.type = TYPE_BACK_OR_SCREEN_ON;
-        msg.action = action;
-        return msg;
-    }
-
     public static ControlMessage createSetClipboard(String text, boolean paste) {
         ControlMessage msg = new ControlMessage();
         msg.type = TYPE_SET_CLIPBOARD;

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

@@ -11,7 +11,6 @@ public class ControlMessageReader {
     static final int INJECT_KEYCODE_PAYLOAD_LENGTH = 13;
     static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 27;
     static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
-    static final int BACK_OR_SCREEN_ON_LENGTH = 1;
     static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
     static final int SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH = 1;
 
@@ -67,15 +66,13 @@ public class ControlMessageReader {
             case ControlMessage.TYPE_INJECT_SCROLL_EVENT:
                 msg = parseInjectScrollEvent();
                 break;
-            case ControlMessage.TYPE_BACK_OR_SCREEN_ON:
-                msg = parseBackOrScreenOnEvent();
-                break;
             case ControlMessage.TYPE_SET_CLIPBOARD:
                 msg = parseSetClipboard();
                 break;
             case ControlMessage.TYPE_SET_SCREEN_POWER_MODE:
                 msg = parseSetScreenPowerMode();
                 break;
+            case ControlMessage.TYPE_BACK_OR_SCREEN_ON:
             case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
             case ControlMessage.TYPE_COLLAPSE_NOTIFICATION_PANEL:
             case ControlMessage.TYPE_GET_CLIPBOARD:
@@ -153,14 +150,6 @@ public class ControlMessageReader {
         return ControlMessage.createInjectScrollEvent(position, hScroll, vScroll);
     }
 
-    private ControlMessage parseBackOrScreenOnEvent() {
-        if (buffer.remaining() < BACK_OR_SCREEN_ON_LENGTH) {
-            return null;
-        }
-        int action = toUnsigned(buffer.get());
-        return ControlMessage.createBackOrScreenOn(action);
-    }
-
     private ControlMessage parseSetClipboard() {
         if (buffer.remaining() < SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH) {
             return null;

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

@@ -101,7 +101,7 @@ public class Controller {
                 break;
             case ControlMessage.TYPE_BACK_OR_SCREEN_ON:
                 if (device.supportsInputEvents()) {
-                    pressBackOrTurnScreenOn(msg.getAction());
+                    pressBackOrTurnScreenOn();
                 }
                 break;
             case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
@@ -255,22 +255,12 @@ public class Controller {
         }, 200, TimeUnit.MILLISECONDS);
     }
 
-    private boolean pressBackOrTurnScreenOn(int action) {
-        if (Device.isScreenOn()) {
-            return device.injectKeyEvent(action, KeyEvent.KEYCODE_BACK, 0, 0);
-        }
-
-        // Screen is off
-        // Only press POWER on ACTION_DOWN
-        if (action != KeyEvent.ACTION_DOWN) {
-            // do nothing,
-            return true;
-        }
-
-        if (keepPowerModeOff) {
+    private boolean pressBackOrTurnScreenOn() {
+        int keycode = Device.isScreenOn() ? KeyEvent.KEYCODE_BACK : KeyEvent.KEYCODE_POWER;
+        if (keepPowerModeOff && keycode == KeyEvent.KEYCODE_POWER) {
             schedulePowerModeOff();
         }
-        return device.injectKeycode(KeyEvent.KEYCODE_POWER);
+        return device.injectKeycode(keycode);
     }
 
     private boolean setClipboard(String text, boolean paste) {

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

@@ -154,7 +154,6 @@ public class ControlMessageReaderTest {
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         DataOutputStream dos = new DataOutputStream(bos);
         dos.writeByte(ControlMessage.TYPE_BACK_OR_SCREEN_ON);
-        dos.writeByte(KeyEvent.ACTION_UP);
 
         byte[] packet = bos.toByteArray();
 
@@ -162,7 +161,6 @@ public class ControlMessageReaderTest {
         ControlMessage event = reader.next();
 
         Assert.assertEquals(ControlMessage.TYPE_BACK_OR_SCREEN_ON, event.getType());
-        Assert.assertEquals(KeyEvent.ACTION_DOWN, event.getAction());
     }
 
     @Test