Merge branch 'record' into dev (#292)

Record screen to file

Author: rom1v

app/meson.build

@@ -12,6 +12,7 @@ src = [
     'src/input_manager.c',
     'src/lock_util.c',
     'src/net.c',
+    'src/recorder.c',
     'src/scrcpy.c',
     'src/screen.c',
     'src/server.c',

app/src/buffer_util.h

@@ -15,4 +15,14 @@ static inline void buffer_write32be(Uint8 *buf, Uint32 value) {
     buf[3] = value;
 }
 
+static inline Uint32 buffer_read32be(Uint8 *buf) {
+    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+}
+
+static inline Uint64 buffer_read64be(Uint8 *buf) {
+    Uint32 msb = buffer_read32be(buf);
+    Uint32 lsb = buffer_read32be(&buf[4]);
+    return ((Uint64) msb << 32) | lsb;
+}
+
 #endif

app/src/decoder.c

@@ -1,20 +1,119 @@
 #include "decoder.h"
 
 #include <libavformat/avformat.h>
+#include <libavutil/time.h>
+#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
 #include <unistd.h>
 
 #include "config.h"
+#include "buffer_util.h"
 #include "events.h"
 #include "frames.h"
 #include "lock_util.h"
 #include "log.h"
+#include "recorder.h"
 
 #define BUFSIZE 0x10000
 
-static int read_packet(void *opaque, uint8_t *buf, int buf_size) {
+#define HEADER_SIZE 12
+#define NO_PTS UINT64_C(-1)
+
+static struct frame_meta *frame_meta_new(uint64_t pts) {
+    struct frame_meta *meta = malloc(sizeof(*meta));
+    if (!meta) {
+        return meta;
+    }
+    meta->pts = pts;
+    meta->next = NULL;
+    return meta;
+}
+
+static void frame_meta_delete(struct frame_meta *frame_meta) {
+    free(frame_meta);
+}
+
+static SDL_bool receiver_state_push_meta(struct receiver_state *state,
+                                         uint64_t pts) {
+    struct frame_meta *frame_meta = frame_meta_new(pts);
+    if (!frame_meta) {
+        return SDL_FALSE;
+    }
+
+    // append to the list
+    // (iterate to find the last item, in practice the list should be tiny)
+    struct frame_meta **p = &state->frame_meta_queue;
+    while (*p) {
+        p = &(*p)->next;
+    }
+    *p = frame_meta;
+    return SDL_TRUE;
+}
+
+static uint64_t receiver_state_take_meta(struct receiver_state *state) {
+    struct frame_meta *frame_meta = state->frame_meta_queue; // first item
+    SDL_assert(frame_meta); // must not be empty
+    uint64_t pts = frame_meta->pts;
+    state->frame_meta_queue = frame_meta->next; // remove the item
+    frame_meta_delete(frame_meta);
+    return pts;
+}
+
+static int read_packet_with_meta(void *opaque, uint8_t *buf, int buf_size) {
+    struct decoder *decoder = opaque;
+    struct receiver_state *state = &decoder->receiver_state;
+
+    // The video stream contains raw packets, without time information. When we
+    // record, we retrieve the timestamps separately, from a "meta" header
+    // added by the server before each raw packet.
+    //
+    // The "meta" header length is 12 bytes:
+    // [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
+    //  <-------------> <-----> <-----------------------------...
+    //        PTS        packet        raw packet
+    //                    size
+    //
+    // It is followed by <packet_size> bytes containing the packet/frame.
+
+    if (!state->remaining) {
+#define HEADER_SIZE 12
+        uint8_t header[HEADER_SIZE];
+        ssize_t ret = net_recv_all(decoder->video_socket, header, HEADER_SIZE);
+        if (ret <= 0) {
+            return ret;
+        }
+        // no partial read (net_recv_all())
+        SDL_assert_release(ret == HEADER_SIZE);
+
+        uint64_t pts = buffer_read64be(header);
+        state->remaining = buffer_read32be(&header[8]);
+
+        if (pts != NO_PTS && !receiver_state_push_meta(state, pts)) {
+            LOGE("Could not store PTS for recording");
+            // we cannot save the PTS, the recording would be broken
+            return -1;
+        }
+    }
+
+    SDL_assert(state->remaining);
+
+    if (buf_size > state->remaining)
+        buf_size = state->remaining;
+
+    ssize_t ret = net_recv(decoder->video_socket, buf, buf_size);
+    if (ret <= 0) {
+        return ret;
+    }
+
+    SDL_assert(state->remaining >= ret);
+    state->remaining -= ret;
+
+    return ret;
+}
+
+static int read_raw_packet(void *opaque, uint8_t *buf, int buf_size) {
     struct decoder *decoder = opaque;
     return net_recv(decoder->video_socket, buf, buf_size);
 }
@@ -70,7 +169,15 @@ static int run_decoder(void *data) {
         goto run_finally_free_format_ctx;
     }
 
-    AVIOContext *avio_ctx = avio_alloc_context(buffer, BUFSIZE, 0, decoder, read_packet, NULL, NULL);
+    // initialize the receiver state
+    decoder->receiver_state.frame_meta_queue = NULL;
+    decoder->receiver_state.remaining = 0;
+
+    // if recording is enabled, a "header" is sent between raw packets
+    int (*read_packet)(void *, uint8_t *, int) =
+            decoder->recorder ? read_packet_with_meta : read_raw_packet;
+    AVIOContext *avio_ctx = avio_alloc_context(buffer, BUFSIZE, 0, decoder,
+                                               read_packet, NULL, NULL);
     if (!avio_ctx) {
         LOGC("Could not allocate avio context");
         // avformat_open_input takes ownership of 'buffer'
@@ -86,6 +193,12 @@ static int run_decoder(void *data) {
         goto run_finally_free_avio_ctx;
     }
 
+    if (decoder->recorder &&
+            !recorder_open(decoder->recorder, codec)) {
+        LOGE("Could not open recorder");
+        goto run_finally_close_input;
+    }
+
     AVPacket packet;
     av_init_packet(&packet);
     packet.data = NULL;
@@ -125,6 +238,23 @@ static int run_decoder(void *data) {
             packet.data += len;
         }
 #endif
+
+        if (decoder->recorder) {
+            // we retrieve the PTS in order they were received, so they will
+            // be assigned to the correct frame
+            uint64_t pts = receiver_state_take_meta(&decoder->receiver_state);
+            packet.pts = pts;
+            packet.dts = pts;
+
+            // no need to rescale with av_packet_rescale_ts(), the timestamps
+            // are in microseconds both in input and output
+            if (!recorder_write(decoder->recorder, &packet)) {
+                LOGE("Could not write frame to output file");
+                av_packet_unref(&packet);
+                goto run_quit;
+            }
+        }
+
         av_packet_unref(&packet);
 
         if (avio_ctx->eof_reached) {
@@ -135,6 +265,10 @@ static int run_decoder(void *data) {
     LOGD("End of frames");
 
 run_quit:
+    if (decoder->recorder) {
+        recorder_close(decoder->recorder);
+    }
+run_finally_close_input:
     avformat_close_input(&format_ctx);
 run_finally_free_avio_ctx:
     av_freep(&avio_ctx);
@@ -149,9 +283,11 @@ static int run_decoder(void *data) {
     return 0;
 }
 
-void decoder_init(struct decoder *decoder, struct frames *frames, socket_t video_socket) {
+void decoder_init(struct decoder *decoder, struct frames *frames,
+                  socket_t video_socket, struct recorder *recorder) {
     decoder->frames = frames;
     decoder->video_socket = video_socket;
+    decoder->recorder = recorder;
 }
 
 SDL_bool decoder_start(struct decoder *decoder) {
@@ -162,7 +298,6 @@ SDL_bool decoder_start(struct decoder *decoder) {
         LOGC("Could not start decoder thread");
         return SDL_FALSE;
     }
-
     return SDL_TRUE;
 }
 

app/src/decoder.h

@@ -4,18 +4,31 @@
 #include <SDL2/SDL_stdinc.h>
 #include <SDL2/SDL_thread.h>
 
+#include "common.h"
 #include "net.h"
 
 struct frames;
 
+struct frame_meta {
+    uint64_t pts;
+    struct frame_meta *next;
+};
+
 struct decoder {
     struct frames *frames;
     socket_t video_socket;
     SDL_Thread *thread;
     SDL_mutex *mutex;
+    struct recorder *recorder;
+    struct receiver_state {
+        // meta (in order) for frames not consumed yet
+        struct frame_meta *frame_meta_queue;
+        size_t remaining; // remaining bytes to receive for the current frame
+    } receiver_state;
 };
 
-void decoder_init(struct decoder *decoder, struct frames *frames, socket_t video_socket);
+void decoder_init(struct decoder *decoder, struct frames *frames,
+                  socket_t video_socket, struct recorder *recoder);
 SDL_bool decoder_start(struct decoder *decoder);
 void decoder_stop(struct decoder *decoder);
 void decoder_join(struct decoder *decoder);

app/src/main.c

@@ -11,6 +11,7 @@
 struct args {
     const char *serial;
     const char *crop;
+    const char *record_filename;
     SDL_bool fullscreen;
     SDL_bool help;
     SDL_bool version;
@@ -53,6 +54,9 @@ static void usage(const char *arg0) {
         "        Set the TCP port the client listens on.\n"
         "        Default is %d.\n"
         "\n"
+        "    -r, --record file.mp4\n"
+        "        Record screen to file.\n"
+        "\n"
         "    -s, --serial\n"
         "        The device serial number. Mandatory only if several devices\n"
         "        are connected to adb.\n"
@@ -208,13 +212,14 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
         {"help",         no_argument,       NULL, 'h'},
         {"max-size",     required_argument, NULL, 'm'},
         {"port",         required_argument, NULL, 'p'},
+        {"record",       required_argument, NULL, 'r'},
         {"serial",       required_argument, NULL, 's'},
         {"show-touches", no_argument,       NULL, 't'},
         {"version",      no_argument,       NULL, 'v'},
         {NULL,           0,                 NULL, 0  },
     };
     int c;
-    while ((c = getopt_long(argc, argv, "b:c:fhm:p:s:tv", long_options, NULL)) != -1) {
+    while ((c = getopt_long(argc, argv, "b:c:fhm:p:r:s:tv", long_options, NULL)) != -1) {
         switch (c) {
             case 'b':
                 if (!parse_bit_rate(optarg, &args->bit_rate)) {
@@ -240,6 +245,9 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
                     return SDL_FALSE;
                 }
                 break;
+            case 'r':
+                args->record_filename = optarg;
+                break;
             case 's':
                 args->serial = optarg;
                 break;
@@ -273,6 +281,7 @@ int main(int argc, char *argv[]) {
     struct args args = {
         .serial = NULL,
         .crop = NULL,
+        .record_filename = NULL,
         .help = SDL_FALSE,
         .version = SDL_FALSE,
         .show_touches = SDL_FALSE,
@@ -310,6 +319,7 @@ int main(int argc, char *argv[]) {
         .serial = args.serial,
         .crop = args.crop,
         .port = args.port,
+        .record_filename = args.record_filename,
         .max_size = args.max_size,
         .bit_rate = args.bit_rate,
         .show_touches = args.show_touches,