quickfix secure flag DONOTMERGE

It allows to send the video stream to /dev/videoN, so that it can be
captured (like a webcam) by any v4l2-capable tool.

PR #2232 <https://github.com/Genymobile/scrcpy/pull/2232>
PR #2233 <https://github.com/Genymobile/scrcpy/pull/2233>
PR #2268 <https://github.com/Genymobile/scrcpy/pull/2268>

Co-authored-by: Romain Vimont <rom@rom1v.com>

README.md

@@ -198,6 +198,7 @@ If `--max-size` is also specified, resizing is applied after cropping.
 To lock the orientation of the mirroring:
 
 ```bash
+scrcpy --lock-video-orientation     # initial (current) orientation
 scrcpy --lock-video-orientation 0   # natural orientation
 scrcpy --lock-video-orientation 1   # 90° counterclockwise
 scrcpy --lock-video-orientation 2   # 180°
@@ -225,7 +226,9 @@ error will give the available encoders:
 scrcpy --encoder _
 ```
 
-### Recording
+### Capture
+
+#### Recording
 
 It is possible to record the screen while mirroring:
 
@@ -249,6 +252,58 @@ variation] does not impact the recorded file.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 
 
+#### v4l2loopback
+
+On Linux, it is possible to send the video stream to a v4l2 loopback device, so
+that the Android device can be opened like a webcam by any v4l2-capable tool.
+
+The module `v4l2loopback` must be installed:
+
+```bash
+sudo apt install v4l2loopback-dkms
+```
+
+To create a v4l2 device:
+
+```bash
+sudo modprobe v4l2loopback
+```
+
+This will create a new video device in `/dev/videoN`, where `N` is an integer
+(more [options](https://github.com/umlaeute/v4l2loopback#options) are available
+to create several devices or devices with specific IDs).
+
+To list the enabled devices:
+
+```bash
+# requires v4l-utils package
+v4l2-ctl --list-devices
+
+# simple but might be sufficient
+ls /dev/video*
+```
+
+To start scrcpy using a v4l2 sink:
+
+```bash
+scrcpy --v4l2-sink=/dev/videoN
+scrcpy --v4l2-sink=/dev/videoN -N  # --no-display to disable mirroring window
+```
+
+(replace `N` by the device ID, check with `ls /dev/video*`)
+
+Once enabled, you can open your video stream with a v4l2-capable tool:
+
+```bash
+ffplay -i /dev/videoN
+vlc v4l2:///dev/videoN   # VLC might add some buffering delay
+```
+
+For example, you could capture the video within [OBS].
+
+[OBS]: https://obsproject.com/fr
+
+
 ### Connection
 
 #### Wireless
@@ -686,10 +741,10 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
  | Rotate display left                         | <kbd>MOD</kbd>+<kbd>←</kbd> _(left)_
  | Rotate display right                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(right)_
  | Resize window to 1:1 (pixel-perfect)        | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Resize window to remove black borders       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Double-click¹_
+ | Resize window to remove black borders       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Double-left-click¹_
  | Click on `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Middle-click_
  | Click on `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Right-click²_
- | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd>
+ | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4th-click³_
  | Click on `MENU` (unlock screen)             | <kbd>MOD</kbd>+<kbd>m</kbd>
  | Click on `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(up)_
  | Click on `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(down)_
@@ -698,18 +753,27 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
  | Turn device screen off (keep mirroring)     | <kbd>MOD</kbd>+<kbd>o</kbd>
  | Turn device screen on                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
  | Rotate device screen                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd>
+ | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5th-click³_
- | Collapse notification panel                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Expand settings panel                       |  <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Double-5th-click³_
- | Copy to clipboard³                          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Collapse panels                             | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Cut to clipboard³                           | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Copy to clipboard⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Synchronize clipboards and paste³           | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | Cut to clipboard⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Synchronize clipboards and paste⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>
  | Inject computer clipboard text              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
  | Enable/disable FPS counter (on stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
  | Pinch-to-zoom                               | <kbd>Ctrl</kbd>+_click-and-move_
 
 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._  
-_³Only on Android >= 7._
+_³4th and 5th mouse buttons, if your mouse has them._  
+_⁴Only on Android >= 7._
+
+Shortcuts with repeated keys are executted by releasing and pressing the key a
+second time. For example, to execute "Expand settings panel":
+
+ 1. Press and keep pressing <kbd>MOD</kbd>.
+ 2. Then double-press <kbd>n</kbd>.
+ 3. Finally, release <kbd>MOD</kbd>.
 
 All <kbd>Ctrl</kbd>+_key_ shortcuts are forwarded to the device, so they are
 handled by the active application.

app/scrcpy.1

@@ -83,10 +83,12 @@ Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+S
 This is a workaround for some devices not behaving as expected when setting the device clipboard programmatically.
 
 .TP
-.BI "\-\-lock\-video\-orientation " value
+.BI "\-\-lock\-video\-orientation " [value]
-Lock video orientation to \fIvalue\fR. Possible values are -1 (unlocked), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
+Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
 
-Default is -1 (unlocked).
+Default is "unlocked".
+
+Passing the option without argument is equivalent to passing "initial".
 
 .TP
 .BI "\-\-max\-fps " value
@@ -183,6 +185,12 @@ Enable "show touches" on start, restore the initial value on exit.
 
 It only shows physical touches (not clicks from scrcpy).
 
+.TP
+.BI "\-\-v4l2_sink " /dev/videoN
+Output to v4l2loopback device.
+
+It requires to lock the video orientation (see --lock-video-orientation).
+
 .TP
 .BI "\-V, \-\-verbosity " value
 Set the log level ("debug", "info", "warn" or "error").

app/src/cli.c

@@ -79,12 +79,15 @@ scrcpy_print_usage(const char *arg0) {
         "        This is a workaround for some devices not behaving as\n"
         "        expected when setting the device clipboard programmatically.\n"
         "\n"
-        "    --lock-video-orientation value\n"
+        "    --lock-video-orientation [value]\n"
         "        Lock video orientation to value.\n"
-        "        Possible values are -1 (unlocked), 0, 1, 2 and 3.\n"
+        "        Possible values are \"unlocked\", \"initial\" (locked to the\n"
+        "        initial orientation), 0, 1, 2 and 3.\n"
         "        Natural device orientation is 0, and each increment adds a\n"
         "        90 degrees rotation counterclockwise.\n"
-        "        Default is -1 (unlocked).\n"
+        "        Default is \"unlocked\".\n"
+        "        Passing the option without argument is equivalent to passing\n"
+        "        \"initial\".\n"
         "\n"
         "    --max-fps value\n"
         "        Limit the frame rate of screen capture (officially supported\n"
@@ -173,11 +176,13 @@ scrcpy_print_usage(const char *arg0) {
         "        on exit.\n"
         "        It only shows physical touches (not clicks from scrcpy).\n"
         "\n"
+#ifdef HAVE_V4L2
         "    --v4l2_sink /dev/videoN\n"
         "        Output to v4l2loopback device.\n"
         "        It requires to lock the video orientation (see\n"
         "        --lock-video-orientation).\n"
         "\n"
+#endif
         "    -V, --verbosity value\n"
         "        Set the log level (debug, info, warn or error).\n"
 #ifndef NDEBUG
@@ -388,15 +393,27 @@ parse_max_fps(const char *s, uint16_t *max_fps) {
 }
 
 static bool
-parse_lock_video_orientation(const char *s, int8_t *lock_video_orientation) {
+parse_lock_video_orientation(const char *s,
+                             enum sc_lock_video_orientation *lock_mode) {
+    if (!s || !strcmp(s, "initial")) {
+        // Without argument, lock the initial orientation
+        *lock_mode = SC_LOCK_VIDEO_ORIENTATION_INITIAL;
+        return true;
+    }
+
+    if (!strcmp(s, "unlocked")) {
+        *lock_mode = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED;
+        return true;
+    }
+
     long value;
-    bool ok = parse_integer_arg(s, &value, false, -1, 3,
+    bool ok = parse_integer_arg(s, &value, false, 0, 3,
                                 "lock video orientation");
     if (!ok) {
         return false;
     }
 
-    *lock_video_orientation = (int8_t) value;
+    *lock_mode = (enum sc_lock_video_orientation) value;
     return true;
 }
 
@@ -686,7 +703,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
         {"fullscreen",             no_argument,       NULL, 'f'},
         {"help",                   no_argument,       NULL, 'h'},
         {"legacy-paste",           no_argument,       NULL, OPT_LEGACY_PASTE},
-        {"lock-video-orientation", required_argument, NULL,
+        {"lock-video-orientation", optional_argument, NULL,
                                                   OPT_LOCK_VIDEO_ORIENTATION},
         {"max-fps",                required_argument, NULL, OPT_MAX_FPS},
         {"max-size",               required_argument, NULL, 'm'},
@@ -774,7 +791,8 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
                 }
                 break;
             case OPT_LOCK_VIDEO_ORIENTATION:
-                if (!parse_lock_video_orientation(optarg, &opts->lock_video_orientation)) {
+                if (!parse_lock_video_orientation(optarg,
+                        &opts->lock_video_orientation)) {
                     return false;
                 }
                 break;
@@ -894,29 +912,34 @@ 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;
+#ifdef HAVE_V4L2
             case OPT_V4L2_SINK:
                 opts->v4l2_device = optarg;
                 break;
+#endif
             default:
                 // getopt prints the error message on stderr
                 return false;
         }
     }
 
+#ifdef HAVE_V4L2
     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)");
-             " or sink to v4l2loopback device (--v4l2_sink)"
-#endif
-             );
         return false;
     }
 
-#ifdef HAVE_V4L2
+    if (opts->v4l2_device && opts->lock_video_orientation
-    if (opts->v4l2_device && opts->lock_video_orientation == -1) {
+                             == SC_LOCK_VIDEO_ORIENTATION_UNLOCKED) {
         LOGI("Video orientation is locked for v4l2 sink. "
              "See --lock-video-orientation.");
-        opts->lock_video_orientation = 0;
+        opts->lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_INITIAL;
+    }
+#else
+    if (!opts->display && !opts->record_filename) {
+        LOGE("-N/--no-display requires screen recording (-r/--record)");
+        return false;
     }
 #endif
 

app/src/control_msg.c

@@ -81,7 +81,8 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
             buf[1] = msg->set_screen_power_mode.mode;
             return 2;
         case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-        case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
+        case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
+        case CONTROL_MSG_TYPE_COLLAPSE_PANELS:
         case CONTROL_MSG_TYPE_GET_CLIPBOARD:
         case CONTROL_MSG_TYPE_ROTATE_DEVICE:
             // no additional data

app/src/control_msg.h

@@ -27,7 +27,8 @@ enum control_msg_type {
     CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
     CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
     CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
-    CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
+    CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+    CONTROL_MSG_TYPE_COLLAPSE_PANELS,
     CONTROL_MSG_TYPE_GET_CLIPBOARD,
     CONTROL_MSG_TYPE_SET_CLIPBOARD,
     CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,

app/src/input_manager.c

@@ -72,6 +72,10 @@ input_manager_init(struct input_manager *im,
     im->sdl_shortcut_mods.count = shortcut_mods->count;
 
     im->vfinger_down = false;
+
+    im->last_keycode = SDLK_UNKNOWN;
+    im->last_mod = 0;
+    im->key_repeat = 0;
 }
 
 static void
@@ -179,9 +183,19 @@ expand_notification_panel(struct controller *controller) {
 }
 
 static void
-collapse_notification_panel(struct controller *controller) {
+expand_settings_panel(struct controller *controller) {
     struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL;
+    msg.type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
+
+    if (!controller_push_msg(controller, &msg)) {
+        LOGW("Could not request 'expand settings panel'");
+    }
+}
+
+static void
+collapse_panels(struct controller *controller) {
+    struct control_msg msg;
+    msg.type = CONTROL_MSG_TYPE_COLLAPSE_PANELS;
 
     if (!controller_push_msg(controller, &msg)) {
         LOGW("Could not request 'collapse notification panel'");
@@ -384,16 +398,27 @@ input_manager_process_key(struct input_manager *im,
     // control: indicates the state of the command-line option --no-control
     bool control = im->control;
 
-    bool smod = is_shortcut_mod(im, event->keysym.mod);
-
     struct controller *controller = im->controller;
 
     SDL_Keycode keycode = event->keysym.sym;
+    uint16_t mod = event->keysym.mod;
     bool down = event->type == SDL_KEYDOWN;
     bool ctrl = event->keysym.mod & KMOD_CTRL;
     bool shift = event->keysym.mod & KMOD_SHIFT;
     bool repeat = event->repeat;
 
+    bool smod = is_shortcut_mod(im, mod);
+
+    if (down && !repeat) {
+        if (keycode == im->last_keycode && mod == im->last_mod) {
+            ++im->key_repeat;
+        } else {
+            im->key_repeat = 0;
+            im->last_keycode = keycode;
+            im->last_mod = mod;
+        }
+    }
+
     // The shortcut modifier is pressed
     if (smod) {
         int action = down ? ACTION_DOWN : ACTION_UP;
@@ -498,9 +523,11 @@ input_manager_process_key(struct input_manager *im,
             case SDLK_n:
                 if (control && !repeat && down) {
                     if (shift) {
-                        collapse_notification_panel(controller);
+                        collapse_panels(controller);
-                    } else {
+                    } else if (im->key_repeat == 0) {
                         expand_notification_panel(controller);
+                    } else {
+                        expand_settings_panel(controller);
                     }
                 }
                 return;
@@ -666,7 +693,11 @@ input_manager_process_mouse_button(struct input_manager *im,
             return;
         }
         if (control && event->button == SDL_BUTTON_X2 && down) {
+            if (event->clicks < 2) {
                 expand_notification_panel(im->controller);
+            } else {
+                expand_settings_panel(im->controller);
+            }
             return;
         }
         if (control && event->button == SDL_BUTTON_RIGHT) {

app/src/input_manager.h

@@ -33,6 +33,13 @@ struct input_manager {
     } sdl_shortcut_mods;
 
     bool vfinger_down;
+
+    // Tracks the number of identical consecutive shortcut key down events.
+    // Not to be confused with event->repeat, which counts the number of
+    // system-generated repeated key presses.
+    unsigned key_repeat;
+    SDL_Keycode last_keycode;
+    uint16_t last_mod;
 };
 
 void

app/src/scrcpy.c

@@ -304,7 +304,6 @@ scrcpy(const struct scrcpy_options *options) {
         goto end;
     }
 
-    struct decoder *dec = NULL;
     if (options->display) {
         if (!fps_counter_init(&fps_counter)) {
             goto end;
@@ -318,7 +317,14 @@ scrcpy(const struct scrcpy_options *options) {
             }
             file_handler_initialized = true;
         }
+    }
 
+    struct decoder *dec = NULL;
+    bool needs_decoder = options->display;
+#ifdef HAVE_V4L2
+    needs_decoder |= !!options->v4l2_device;
+#endif
+    if (needs_decoder) {
         decoder_init(&decoder);
         dec = &decoder;
     }

app/src/scrcpy.h

@@ -20,6 +20,16 @@ enum sc_record_format {
     SC_RECORD_FORMAT_MKV,
 };
 
+enum sc_lock_video_orientation {
+    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
+    // lock the current orientation when scrcpy starts
+    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
+    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
+    SC_LOCK_VIDEO_ORIENTATION_1,
+    SC_LOCK_VIDEO_ORIENTATION_2,
+    SC_LOCK_VIDEO_ORIENTATION_3,
+};
+
 #define SC_MAX_SHORTCUT_MODS 8
 
 enum sc_shortcut_mod {
@@ -60,7 +70,7 @@ struct scrcpy_options {
     uint16_t max_size;
     uint32_t bit_rate;
     uint16_t max_fps;
-    int8_t lock_video_orientation;
+    enum sc_lock_video_orientation lock_video_orientation;
     uint8_t rotation;
     int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
     int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
@@ -108,7 +118,7 @@ struct scrcpy_options {
     .max_size = 0, \
     .bit_rate = DEFAULT_BIT_RATE, \
     .max_fps = 0, \
-    .lock_video_orientation = -1, \
+    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED, \
     .rotation = 0, \
     .window_x = SC_WINDOW_POSITION_UNDEFINED, \
     .window_y = SC_WINDOW_POSITION_UNDEFINED, \

app/src/server.c

@@ -58,7 +58,7 @@ get_server_path(void) {
         LOGE("Could not get executable path, "
              "using " SERVER_FILENAME " from current directory");
         // not found, use current directory
-        return SERVER_FILENAME;
+        return strdup(SERVER_FILENAME);
     }
     char *dir = dirname(executable_path);
     size_t dirlen = strlen(dir);
@@ -70,7 +70,7 @@ get_server_path(void) {
         LOGE("Could not alloc server path string, "
              "using " SERVER_FILENAME " from current directory");
         free(executable_path);
-        return SERVER_FILENAME;
+        return strdup(SERVER_FILENAME);
     }
 
     memcpy(server_path, dir, dirlen);

app/src/v4l2_sink.c

@@ -6,6 +6,8 @@
 /** Downcast frame_sink to sc_v4l2_sink */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_v4l2_sink, frame_sink)
 
+static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
+
 static const AVOutputFormat *
 find_muxer(const char *name) {
 #ifdef SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
@@ -24,7 +26,60 @@ find_muxer(const char *name) {
 }
 
 static bool
-encode_and_send_frame(struct sc_v4l2_sink *vs, const AVFrame *frame) {
+write_header(struct sc_v4l2_sink *vs, const AVPacket *packet) {
+    AVStream *ostream = vs->format_ctx->streams[0];
+
+    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
+    if (!extradata) {
+        LOGC("Could not allocate extradata");
+        return false;
+    }
+
+    // copy the first packet to the extra data
+    memcpy(extradata, packet->data, packet->size);
+
+    ostream->codecpar->extradata = extradata;
+    ostream->codecpar->extradata_size = packet->size;
+
+    int ret = avformat_write_header(vs->format_ctx, NULL);
+    if (ret < 0) {
+        LOGE("Failed to write header to %s", vs->device_name);
+        return false;
+    }
+
+    return true;
+}
+
+static void
+rescale_packet(struct sc_v4l2_sink *vs, AVPacket *packet) {
+    AVStream *ostream = vs->format_ctx->streams[0];
+    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
+}
+
+static bool
+write_packet(struct sc_v4l2_sink *vs, AVPacket *packet) {
+    if (!vs->header_written) {
+        bool ok = write_header(vs, packet);
+        if (!ok) {
+            return false;
+        }
+        vs->header_written = true;
+        return true;
+    }
+
+    rescale_packet(vs, packet);
+
+    bool ok = av_write_frame(vs->format_ctx, packet) >= 0;
+
+    // Failing to write the last frame is not very serious, no future frame may
+    // depend on it, so the resulting file will still be valid
+    (void) ok;
+
+    return true;
+}
+
+static bool
+encode_and_write_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);
@@ -35,7 +90,12 @@ encode_and_send_frame(struct sc_v4l2_sink *vs, const AVFrame *frame) {
     ret = avcodec_receive_packet(vs->encoder_ctx, packet);
     if (ret == 0) {
         // A packet was received
-        av_write_frame(vs->format_ctx, packet);
+
+        bool ok = write_packet(vs, packet);
+        if (!ok) {
+            LOGW("Could not send packet to v4l2 sink");
+            return false;
+        }
         av_packet_unref(packet);
     } else if (ret != AVERROR(EAGAIN)) {
         LOGE("Could not receive v4l2 video packet: %d", ret);
@@ -64,7 +124,7 @@ run_v4l2_sink(void *data) {
         sc_mutex_unlock(&vs->mutex);
 
         video_buffer_consume(&vs->vb, vs->frame);
-        bool ok = encode_and_send_frame(vs, vs->frame);
+        bool ok = encode_and_write_frame(vs, vs->frame);
         if (!ok) {
             LOGE("Could not send frame to v4l2 sink");
             break;
@@ -119,6 +179,12 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
     // 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;
+    vs->format_ctx->url = strdup(vs->device_name);
+    if (!vs->format_ctx->url) {
+        LOGE("Could not strdup v4l2 device name");
+        goto error_avformat_free_context;
+        return false;
+    }
 
     AVStream *ostream = avformat_new_stream(vs->format_ctx, encoder);
     if (!ostream) {
@@ -170,6 +236,9 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
         goto error_av_frame_free;
     }
 
+    vs->header_written = false;
+    vs->stopped = false;
+
     LOGI("v4l2 sink started to device: %s", vs->device_name);
 
     return true;
@@ -196,6 +265,13 @@ error_video_buffer_destroy:
 
 static void
 sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
+    sc_mutex_lock(&vs->mutex);
+    vs->stopped = true;
+    sc_cond_signal(&vs->cond);
+    sc_mutex_unlock(&vs->mutex);
+
+    sc_thread_join(&vs->thread, NULL);
+
     av_frame_free(&vs->frame);
     avcodec_close(vs->encoder_ctx);
     avcodec_free_context(&vs->encoder_ctx);

app/src/v4l2_sink.h

@@ -23,6 +23,7 @@ struct sc_v4l2_sink {
     sc_mutex mutex;
     sc_cond cond;
     bool stopped;
+    bool header_written;
 
     AVFrame *frame;
     AVPacket packet;

app/tests/test_control_msg_serialize.c

@@ -177,9 +177,9 @@ static void test_serialize_expand_notification_panel(void) {
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
 
-static void test_serialize_collapse_notification_panel(void) {
+static void test_serialize_expand_settings_panel(void) {
     struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
+        .type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
     };
 
     unsigned char buf[CONTROL_MSG_MAX_SIZE];
@@ -187,7 +187,22 @@ static void test_serialize_collapse_notification_panel(void) {
     assert(size == 1);
 
     const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
+        CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
+    };
+    assert(!memcmp(buf, expected, sizeof(expected)));
+}
+
+static void test_serialize_collapse_panels(void) {
+    struct control_msg msg = {
+        .type = CONTROL_MSG_TYPE_COLLAPSE_PANELS,
+    };
+
+    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    size_t size = control_msg_serialize(&msg, buf);
+    assert(size == 1);
+
+    const unsigned char expected[] = {
+        CONTROL_MSG_TYPE_COLLAPSE_PANELS,
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
@@ -274,7 +289,8 @@ int main(int argc, char *argv[]) {
     test_serialize_inject_scroll_event();
     test_serialize_back_or_screen_on();
     test_serialize_expand_notification_panel();
-    test_serialize_collapse_notification_panel();
+    test_serialize_expand_settings_panel();
+    test_serialize_collapse_panels();
     test_serialize_get_clipboard();
     test_serialize_set_clipboard();
     test_serialize_set_screen_power_mode();

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

@@ -11,11 +11,12 @@ public final class ControlMessage {
     public static final int TYPE_INJECT_SCROLL_EVENT = 3;
     public static final int TYPE_BACK_OR_SCREEN_ON = 4;
     public static final int TYPE_EXPAND_NOTIFICATION_PANEL = 5;
-    public static final int TYPE_COLLAPSE_NOTIFICATION_PANEL = 6;
+    public static final int TYPE_EXPAND_SETTINGS_PANEL = 6;
-    public static final int TYPE_GET_CLIPBOARD = 7;
+    public static final int TYPE_COLLAPSE_PANELS = 7;
-    public static final int TYPE_SET_CLIPBOARD = 8;
+    public static final int TYPE_GET_CLIPBOARD = 8;
-    public static final int TYPE_SET_SCREEN_POWER_MODE = 9;
+    public static final int TYPE_SET_CLIPBOARD = 9;
-    public static final int TYPE_ROTATE_DEVICE = 10;
+    public static final int TYPE_SET_SCREEN_POWER_MODE = 10;
+    public static final int TYPE_ROTATE_DEVICE = 11;
 
     private int type;
     private String text;

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

@@ -77,7 +77,8 @@ public class ControlMessageReader {
                 msg = parseSetScreenPowerMode();
                 break;
             case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
-            case ControlMessage.TYPE_COLLAPSE_NOTIFICATION_PANEL:
+            case ControlMessage.TYPE_EXPAND_SETTINGS_PANEL:
+            case ControlMessage.TYPE_COLLAPSE_PANELS:
             case ControlMessage.TYPE_GET_CLIPBOARD:
             case ControlMessage.TYPE_ROTATE_DEVICE:
                 msg = ControlMessage.createEmpty(type);

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

@@ -107,7 +107,10 @@ public class Controller {
             case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
                 Device.expandNotificationPanel();
                 break;
-            case ControlMessage.TYPE_COLLAPSE_NOTIFICATION_PANEL:
+            case ControlMessage.TYPE_EXPAND_SETTINGS_PANEL:
+                Device.expandSettingsPanel();
+                break;
+            case ControlMessage.TYPE_COLLAPSE_PANELS:
                 Device.collapsePanels();
                 break;
             case ControlMessage.TYPE_GET_CLIPBOARD:

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

@@ -25,6 +25,9 @@ public final class Device {
     public static final int POWER_MODE_OFF = SurfaceControl.POWER_MODE_OFF;
     public static final int POWER_MODE_NORMAL = SurfaceControl.POWER_MODE_NORMAL;
 
+    public static final int LOCK_VIDEO_ORIENTATION_UNLOCKED = -1;
+    public static final int LOCK_VIDEO_ORIENTATION_INITIAL = -2;
+
     private static final ServiceManager SERVICE_MANAGER = new ServiceManager();
 
     public interface RotationListener {
@@ -227,6 +230,10 @@ public final class Device {
         SERVICE_MANAGER.getStatusBarManager().expandNotificationsPanel();
     }
 
+    public static void expandSettingsPanel() {
+        SERVICE_MANAGER.getStatusBarManager().expandSettingsPanel();
+    }
+
     public static void collapsePanels() {
         SERVICE_MANAGER.getStatusBarManager().collapsePanels();
     }

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

@@ -225,7 +225,7 @@ public class ScreenEncoder implements Device.RotationListener {
     }
 
     private static IBinder createDisplay() {
-        return SurfaceControl.createDisplay("scrcpy", true);
+        return SurfaceControl.createDisplay("scrcpy", false);
     }
 
     private static void configure(MediaCodec codec, MediaFormat format) {

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

@@ -82,6 +82,12 @@ public final class ScreenInfo {
 
     public static ScreenInfo computeScreenInfo(DisplayInfo displayInfo, Rect crop, int maxSize, int lockedVideoOrientation) {
         int rotation = displayInfo.getRotation();
+
+        if (lockedVideoOrientation == Device.LOCK_VIDEO_ORIENTATION_INITIAL) {
+            // The user requested to lock the video orientation to the current orientation
+            lockedVideoOrientation = rotation;
+        }
+
         Size deviceSize = displayInfo.getSize();
         Rect contentRect = new Rect(0, 0, deviceSize.getWidth(), deviceSize.getHeight());
         if (crop != null) {

server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java

@@ -14,7 +14,7 @@ public class ActivityManager {
 
     private final IInterface manager;
     private Method getContentProviderExternalMethod;
-    private boolean getContentProviderExternalMethodLegacy;
+    private boolean getContentProviderExternalMethodNewVersion = true;
     private Method removeContentProviderExternalMethod;
 
     public ActivityManager(IInterface manager) {
@@ -29,7 +29,7 @@ public class ActivityManager {
             } catch (NoSuchMethodException e) {
                 // old version
                 getContentProviderExternalMethod = manager.getClass().getMethod("getContentProviderExternal", String.class, int.class, IBinder.class);
-                getContentProviderExternalMethodLegacy = true;
+                getContentProviderExternalMethodNewVersion = false;
             }
         }
         return getContentProviderExternalMethod;
@@ -46,7 +46,7 @@ public class ActivityManager {
         try {
             Method method = getGetContentProviderExternalMethod();
             Object[] args;
-            if (!getContentProviderExternalMethodLegacy) {
+            if (getContentProviderExternalMethodNewVersion) {
                 // new version
                 args = new Object[]{name, ServiceManager.USER_ID, token, null};
             } else {

server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java

@@ -11,6 +11,8 @@ public class StatusBarManager {
 
     private final IInterface manager;
     private Method expandNotificationsPanelMethod;
+    private Method expandSettingsPanelMethod;
+    private boolean expandSettingsPanelMethodNewVersion = true;
     private Method collapsePanelsMethod;
 
     public StatusBarManager(IInterface manager) {
@@ -24,6 +26,20 @@ public class StatusBarManager {
         return expandNotificationsPanelMethod;
     }
 
+    private Method getExpandSettingsPanel() throws NoSuchMethodException {
+        if (expandSettingsPanelMethod == null) {
+            try {
+                // Since Android 7: https://android.googlesource.com/platform/frameworks/base.git/+/a9927325eda025504d59bb6594fee8e240d95b01%5E%21/
+                expandSettingsPanelMethod = manager.getClass().getMethod("expandSettingsPanel", String.class);
+            } catch (NoSuchMethodException e) {
+                // old version
+                expandSettingsPanelMethod = manager.getClass().getMethod("expandSettingsPanel");
+                expandSettingsPanelMethodNewVersion = false;
+            }
+        }
+        return expandSettingsPanelMethod;
+    }
+
     private Method getCollapsePanelsMethod() throws NoSuchMethodException {
         if (collapsePanelsMethod == null) {
             collapsePanelsMethod = manager.getClass().getMethod("collapsePanels");
@@ -40,6 +56,21 @@ public class StatusBarManager {
         }
     }
 
+    public void expandSettingsPanel() {
+        try {
+            Method method = getExpandSettingsPanel();
+            if (expandSettingsPanelMethodNewVersion) {
+                // new version
+                method.invoke(manager, (Object) null);
+            } else {
+                // old version
+                method.invoke(manager);
+            }
+        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+            Ln.e("Could not invoke method", e);
+        }
+    }
+
     public void collapsePanels() {
         try {
             Method method = getCollapsePanelsMethod();

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

@@ -162,7 +162,7 @@ public class ControlMessageReaderTest {
         ControlMessage event = reader.next();
 
         Assert.assertEquals(ControlMessage.TYPE_BACK_OR_SCREEN_ON, event.getType());
-        Assert.assertEquals(KeyEvent.ACTION_DOWN, event.getAction());
+        Assert.assertEquals(KeyEvent.ACTION_UP, event.getAction());
     }
 
     @Test
@@ -182,19 +182,35 @@ public class ControlMessageReaderTest {
     }
 
     @Test
-    public void testParseCollapseNotificationPanelEvent() throws IOException {
+    public void testParseExpandSettingsPanelEvent() throws IOException {
         ControlMessageReader reader = new ControlMessageReader();
 
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         DataOutputStream dos = new DataOutputStream(bos);
-        dos.writeByte(ControlMessage.TYPE_COLLAPSE_NOTIFICATION_PANEL);
+        dos.writeByte(ControlMessage.TYPE_EXPAND_SETTINGS_PANEL);
 
         byte[] packet = bos.toByteArray();
 
         reader.readFrom(new ByteArrayInputStream(packet));
         ControlMessage event = reader.next();
 
-        Assert.assertEquals(ControlMessage.TYPE_COLLAPSE_NOTIFICATION_PANEL, event.getType());
+        Assert.assertEquals(ControlMessage.TYPE_EXPAND_SETTINGS_PANEL, event.getType());
+    }
+
+    @Test
+    public void testParseCollapsePanelsEvent() throws IOException {
+        ControlMessageReader reader = new ControlMessageReader();
+
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        DataOutputStream dos = new DataOutputStream(bos);
+        dos.writeByte(ControlMessage.TYPE_COLLAPSE_PANELS);
+
+        byte[] packet = bos.toByteArray();
+
+        reader.readFrom(new ByteArrayInputStream(packet));
+        ControlMessage event = reader.next();
+
+        Assert.assertEquals(ControlMessage.TYPE_COLLAPSE_PANELS, event.getType());
     }
 
     @Test