AudioEncoder WIP

audio demuxer
Rename demuxer to video_demuxer
2023-02-07 23:23:45 +01:00 · 2023-02-07 23:12:54 +01:00 · 2023-02-07 23:12:54 +01:00 · 2023-02-07 23:12:54 +01:00 · 2023-02-07 23:12:54 +01:00 · 2023-02-07 23:12:54 +01:00
86 changed files with 640 additions and 1957 deletions
--- a/app/meson.build
+++ b/app/meson.build
@@ -21,7 +21,6 @@ src = [
    'src/mouse_inject.c',
    'src/opengl.c',
    'src/options.c',
-    'src/packet_merger.c',
    'src/receiver.c',
    'src/recorder.c',
    'src/scrcpy.c',
@@ -201,6 +200,10 @@ conf.set('PORTABLE', get_option('portable'))
 conf.set('DEFAULT_LOCAL_PORT_RANGE_FIRST', '27183')
 conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')

+# the default video bitrate, in bits/second
+# overridden by option --bit-rate
+conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
+
 # run a server debugger and wait for a client to be attached
 conf.set('SERVER_DEBUGGER', get_option('server_debugger'))

--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -19,34 +19,16 @@ provides display and control of Android devices connected on USB (or over TCP/IP
 .B \-\-always\-on\-top
 Make scrcpy window always on top (above other windows).

-.TP
-.BI "\-\-audio\-bit\-rate " value
-Encode the audio at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
-
-Default is 196K (196000).
-
-.TP
-.BI "\-\-audio\-codec " name
-Select an audio codec (opus or aac).
-
-Default is opus.
-
-.TP
-.BI "\-\-audio\-encoder " name
-Use a specific MediaCodec audio encoder (depending on the codec provided by \fB\-\-audio\-codec\fR).
-
 .TP
 .BI "\-b, \-\-bit\-rate " value
 Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).

-Default is 8M (8000000).
+Default is 8000000.

 .TP
 .BI "\-\-codec " name
 Select a video codec (h264, h265 or av1).

-Default is h264.
-
 .TP
 .BI "\-\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
 Set a list of comma-separated key:type=value options for the device encoder.
@@ -98,7 +80,7 @@ Also see \fB\-d\fR (\fB\-\-select\-usb\fR).

 .TP
 .BI "\-\-encoder " name
-Use a specific MediaCodec encoder (depending on the codec provided by \fB\-\-codec\fR).
+Use a specific MediaCodec encoder (must be a H.264 encoder).

 .TP
 .B \-\-force\-adb\-forward
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -57,11 +57,8 @@
 #define OPT_NO_CLEANUP             1037
 #define OPT_PRINT_FPS              1038
 #define OPT_NO_POWER_ON            1039
-#define OPT_VIDEO_CODEC            1040
+#define OPT_CODEC                  1040
 #define OPT_NO_AUDIO               1041
-#define OPT_AUDIO_BIT_RATE         1042
-#define OPT_AUDIO_CODEC            1043
-#define OPT_AUDIO_ENCODER_NAME     1044

 struct sc_option {
    char shortopt;
@@ -102,43 +99,19 @@ static const struct sc_option options[] = {
        .longopt = "always-on-top",
        .text = "Make scrcpy window always on top (above other windows).",
    },
-    {
-        .longopt_id = OPT_AUDIO_BIT_RATE,
-        .longopt = "audio-bit-rate",
-        .argdesc = "value",
-        .text = "Encode the audio at the given bit-rate, expressed in bits/s. "
-                "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
-                "Default is 196K (196000).",
-    },
-    {
-        .longopt_id = OPT_AUDIO_CODEC,
-        .longopt = "audio-codec",
-        .argdesc = "name",
-        .text = "Select an audio codec (opus or aac).\n"
-                "Default is opus.",
-    },
-    {
-        .longopt_id = OPT_AUDIO_ENCODER_NAME,
-        .longopt = "audio-encoder",
-        .argdesc = "name",
-        .text = "Use a specific MediaCodec audio encoder (depending on the "
-                "codec provided by --audio-codec).",
-    },
    {
        .shortopt = 'b',
        .longopt = "bit-rate",
        .argdesc = "value",
-        .text = "Encode the video at the given bit-rate, expressed in bits/s. "
+        .text = "Encode the video at the gitven bit-rate, expressed in bits/s. "
                "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
-                "Default is 8M (8000000).",
+                "Default is " STR(DEFAULT_BIT_RATE) ".",
    },
-    // TODO keep OPT_CODEC to avoid partial matching with codec_options
    {
-        .longopt_id = OPT_VIDEO_CODEC,
-        .longopt = "video-codec",
+        .longopt_id = OPT_CODEC,
+        .longopt = "codec",
        .argdesc = "name",
-        .text = "Select a video codec (h264, h265 or av1).\n"
-                "Default is h264.",
+        .text = "Select a video codec (h264, h265 or av1).",
    },
    {
        .longopt_id = OPT_CODEC_OPTIONS,
@@ -200,8 +173,7 @@ static const struct sc_option options[] = {
        .longopt_id = OPT_ENCODER_NAME,
        .longopt = "encoder",
        .argdesc = "name",
-        .text = "Use a specific MediaCodec encoder (depending on the codec "
-                "provided by --codec).",
+        .text = "Use a specific MediaCodec encoder (must be a H.264 encoder).",
    },
    {
        .longopt_id = OPT_FORCE_ADB_FORWARD,
@@ -1419,7 +1391,7 @@ guess_record_format(const char *filename) {
 }

 static bool
-parse_video_codec(const char *optarg, enum sc_codec *codec) {
+parse_codec(const char *optarg, enum sc_codec *codec) {
    if (!strcmp(optarg, "h264")) {
        *codec = SC_CODEC_H264;
        return true;
@@ -1432,21 +1404,7 @@ parse_video_codec(const char *optarg, enum sc_codec *codec) {
        *codec = SC_CODEC_AV1;
        return true;
    }
-    LOGE("Unsupported video codec: %s (expected h264, h265 or av1)", optarg);
-    return false;
-}
-
-static bool
-parse_audio_codec(const char *optarg, enum sc_codec *codec) {
-    if (!strcmp(optarg, "opus")) {
-        *codec = SC_CODEC_OPUS;
-        return true;
-    }
-    if (!strcmp(optarg, "aac")) {
-        *codec = SC_CODEC_AAC;
-        return true;
-    }
-    LOGE("Unsupported audio codec: %s (expected opus)", optarg);
+    LOGE("Unsupported codec: %s (expected h264, h265 or av1)", optarg);
    return false;
 }

@@ -1465,11 +1423,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                    return false;
                }
                break;
-            case OPT_AUDIO_BIT_RATE:
-                if (!parse_bit_rate(optarg, &opts->audio_bit_rate)) {
-                    return false;
-                }
-                break;
            case OPT_CROP:
                opts->crop = optarg;
                break;
@@ -1644,9 +1597,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
            case OPT_ENCODER_NAME:
                opts->encoder_name = optarg;
                break;
-            case OPT_AUDIO_ENCODER_NAME:
-                opts->audio_encoder_name = optarg;
-                break;
            case OPT_FORCE_ADB_FORWARD:
                opts->force_adb_forward = true;
                break;
@@ -1694,13 +1644,8 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
            case OPT_PRINT_FPS:
                opts->start_fps_counter = true;
                break;
-            case OPT_VIDEO_CODEC:
-                if (!parse_video_codec(optarg, &opts->video_codec)) {
-                    return false;
-                }
-                break;
-            case OPT_AUDIO_CODEC:
-                if (!parse_audio_codec(optarg, &opts->audio_codec)) {
+            case OPT_CODEC:
+                if (!parse_codec(optarg, &opts->codec)) {
                    return false;
                }
                break;
@@ -1812,6 +1757,13 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
        }
    }

+    if (opts->record_format == SC_RECORD_FORMAT_MP4
+            && opts->codec == SC_CODEC_AV1) {
+        LOGE("Could not mux AV1 stream into MP4 container "
+             "(record to mkv or select another video codec)");
+        return false;
+    }
+
    if (!opts->control) {
        if (opts->turn_screen_off) {
            LOGE("Could not request to turn screen off if control is disabled");
--- a/app/src/controller.c
+++ b/app/src/controller.c
@@ -9,20 +9,20 @@ sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
                   struct sc_acksync *acksync) {
    cbuf_init(&controller->queue);

-    bool ok = sc_receiver_init(&controller->receiver, control_socket, acksync);
+    bool ok = receiver_init(&controller->receiver, control_socket, acksync);
    if (!ok) {
        return false;
    }

    ok = sc_mutex_init(&controller->mutex);
    if (!ok) {
-        sc_receiver_destroy(&controller->receiver);
+        receiver_destroy(&controller->receiver);
        return false;
    }

    ok = sc_cond_init(&controller->msg_cond);
    if (!ok) {
-        sc_receiver_destroy(&controller->receiver);
+        receiver_destroy(&controller->receiver);
        sc_mutex_destroy(&controller->mutex);
        return false;
    }
@@ -43,7 +43,7 @@ sc_controller_destroy(struct sc_controller *controller) {
        sc_control_msg_destroy(&msg);
    }

-    sc_receiver_destroy(&controller->receiver);
+    receiver_destroy(&controller->receiver);
 }

 bool
@@ -117,7 +117,7 @@ sc_controller_start(struct sc_controller *controller) {
        return false;
    }

-    if (!sc_receiver_start(&controller->receiver)) {
+    if (!receiver_start(&controller->receiver)) {
        sc_controller_stop(controller);
        sc_thread_join(&controller->thread, NULL);
        return false;
@@ -137,5 +137,5 @@ sc_controller_stop(struct sc_controller *controller) {
 void
 sc_controller_join(struct sc_controller *controller) {
    sc_thread_join(&controller->thread, NULL);
-    sc_receiver_join(&controller->receiver);
+    receiver_join(&controller->receiver);
 }
--- a/app/src/controller.h
+++ b/app/src/controller.h
@@ -21,7 +21,7 @@ struct sc_controller {
    sc_cond msg_cond;
    bool stopped;
    struct sc_control_msg_queue queue;
-    struct sc_receiver receiver;
+    struct receiver receiver;
 };

 bool
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@@ -29,6 +29,7 @@ sc_decoder_open_sinks(struct sc_decoder *decoder) {
    for (unsigned i = 0; i < decoder->sink_count; ++i) {
        struct sc_frame_sink *sink = decoder->sinks[i];
        if (!sink->ops->open(sink)) {
+            LOGE("Could not open frame sink %d", i);
            sc_decoder_close_first_sinks(decoder, i);
            return false;
        }
@@ -62,6 +63,7 @@ sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
    }

    if (!sc_decoder_open_sinks(decoder)) {
+        LOGE("Could not open decoder sinks");
        av_frame_free(&decoder->frame);
        avcodec_close(decoder->codec_ctx);
        avcodec_free_context(&decoder->codec_ctx);
@@ -84,6 +86,7 @@ push_frame_to_sinks(struct sc_decoder *decoder, const AVFrame *frame) {
    for (unsigned i = 0; i < decoder->sink_count; ++i) {
        struct sc_frame_sink *sink = decoder->sinks[i];
        if (!sink->ops->push(sink, frame)) {
+            LOGE("Could not send frame to sink %d", i);
            return false;
        }
    }
--- a/app/src/demuxer.c
+++ b/app/src/demuxer.c
@@ -6,7 +6,6 @@

 #include "decoder.h"
 #include "events.h"
-#include "packet_merger.h"
 #include "recorder.h"
 #include "util/binary.h"
 #include "util/log.h"
@@ -19,12 +18,17 @@
 #define SC_PACKET_PTS_MASK (SC_PACKET_FLAG_KEY_FRAME - 1)

 static enum AVCodecID
-sc_demuxer_to_avcodec_id(uint32_t codec_id) {
+sc_demuxer_recv_codec_id(struct sc_demuxer *demuxer) {
+    uint8_t data[4];
+    ssize_t r = net_recv_all(demuxer->socket, data, 4);
+    if (r < 4) {
+        return false;
+    }
+
 #define SC_CODEC_ID_H264 UINT32_C(0x68323634) // "h264" in ASCII
 #define SC_CODEC_ID_H265 UINT32_C(0x68323635) // "h265" in ASCII
 #define SC_CODEC_ID_AV1 UINT32_C(0x00617631) // "av1" in ASCII
-#define SC_CODEC_ID_OPUS UINT32_C(0x6f707573) // "opus" in ASCII
-#define SC_CODEC_ID_AAC UINT32_C(0x00616163) // "aac in ASCII"
+    uint32_t codec_id = sc_read32be(data);
    switch (codec_id) {
        case SC_CODEC_ID_H264:
            return AV_CODEC_ID_H264;
@@ -32,28 +36,12 @@ sc_demuxer_to_avcodec_id(uint32_t codec_id) {
            return AV_CODEC_ID_HEVC;
        case SC_CODEC_ID_AV1:
            return AV_CODEC_ID_AV1;
-        case SC_CODEC_ID_OPUS:
-            return AV_CODEC_ID_OPUS;
-        case SC_CODEC_ID_AAC:
-            return AV_CODEC_ID_AAC;
        default:
            LOGE("Unknown codec id 0x%08" PRIx32, codec_id);
            return AV_CODEC_ID_NONE;
    }
 }

-static bool
-sc_demuxer_recv_codec_id(struct sc_demuxer *demuxer, uint32_t *codec_id) {
-    uint8_t data[4];
-    ssize_t r = net_recv_all(demuxer->socket, data, 4);
-    if (r < 4) {
-        return false;
-    }
-
-    *codec_id = sc_read32be(data);
-    return true;
-}
-
 static bool
 sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
    // The video stream contains raw packets, without time information. When we
@@ -117,6 +105,7 @@ push_packet_to_sinks(struct sc_demuxer *demuxer, const AVPacket *packet) {
    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
        struct sc_packet_sink *sink = demuxer->sinks[i];
        if (!sink->ops->push(sink, packet)) {
+            LOGE("Could not send config packet to sink %d", i);
            return false;
        }
    }
@@ -126,9 +115,50 @@ push_packet_to_sinks(struct sc_demuxer *demuxer, const AVPacket *packet) {

 static bool
 sc_demuxer_push_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
+    bool is_config = packet->pts == AV_NOPTS_VALUE;
+
+    // A config packet must not be decoded immediately (it contains no
+    // frame); instead, it must be concatenated with the future data packet.
+    if (demuxer->pending || is_config) {
+        if (demuxer->pending) {
+            size_t offset = demuxer->pending->size;
+            if (av_grow_packet(demuxer->pending, packet->size)) {
+                LOG_OOM();
+                return false;
+            }
+
+            memcpy(demuxer->pending->data + offset, packet->data, packet->size);
+        } else {
+            demuxer->pending = av_packet_alloc();
+            if (!demuxer->pending) {
+                LOG_OOM();
+                return false;
+            }
+            if (av_packet_ref(demuxer->pending, packet)) {
+                LOG_OOM();
+                av_packet_free(&demuxer->pending);
+                return false;
+            }
+        }
+
+        if (!is_config) {
+            // prepare the concat packet to send to the decoder
+            demuxer->pending->pts = packet->pts;
+            demuxer->pending->dts = packet->dts;
+            demuxer->pending->flags = packet->flags;
+            packet = demuxer->pending;
+        }
+    }
+
    bool ok = push_packet_to_sinks(demuxer, packet);
+
+    if (!is_config && demuxer->pending) {
+        // the pending packet must be discarded (consumed or error)
+        av_packet_free(&demuxer->pending);
+    }
+
    if (!ok) {
-        LOGE("Demuxer '%s': could not process packet", demuxer->name);
+        LOGE("Could not process packet");
        return false;
    }

@@ -153,6 +183,7 @@ sc_demuxer_open_sinks(struct sc_demuxer *demuxer, const AVCodec *codec) {
    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
        struct sc_packet_sink *sink = demuxer->sinks[i];
        if (!sink->ops->open(sink, codec)) {
+            LOGE("Could not open packet sink %d", i);
            sc_demuxer_close_first_sinks(demuxer, i);
            return false;
        }
@@ -161,93 +192,56 @@ sc_demuxer_open_sinks(struct sc_demuxer *demuxer, const AVCodec *codec) {
    return true;
 }

-static void
-sc_demuxer_disable_sinks(struct sc_demuxer *demuxer) {
-    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
-        struct sc_packet_sink *sink = demuxer->sinks[i];
-        if (sink->ops->disable) {
-            sink->ops->disable(sink);
-        }
-    }
-}
-
 static int
 run_demuxer(void *data) {
    struct sc_demuxer *demuxer = data;

-    // Flag to report end-of-stream (i.e. device disconnected)
-    bool eos = false;
-
-    uint32_t raw_codec_id;
-    bool ok = sc_demuxer_recv_codec_id(demuxer, &raw_codec_id);
-    if (!ok) {
-        LOGE("Demuxer '%s': stream disabled due to connection error",
-             demuxer->name);
-        eos = true;
-        goto end;
-    }
-
-    if (raw_codec_id == 0) {
-        LOGW("Demuxer '%s': stream explicitly disabled by the device",
-             demuxer->name);
-        sc_demuxer_disable_sinks(demuxer);
-        eos = true;
-        goto end;
-    }
-
-    enum AVCodecID codec_id = sc_demuxer_to_avcodec_id(raw_codec_id);
+    enum AVCodecID codec_id = sc_demuxer_recv_codec_id(demuxer);
    if (codec_id == AV_CODEC_ID_NONE) {
-        LOGE("Demuxer '%s': stream disabled due to unsupported codec",
-             demuxer->name);
-        sc_demuxer_disable_sinks(demuxer);
+        // Error already logged
        goto end;
    }

    const AVCodec *codec = avcodec_find_decoder(codec_id);
    if (!codec) {
-        LOGE("Demuxer '%s': stream disabled due to missing decoder",
-             demuxer->name);
-        sc_demuxer_disable_sinks(demuxer);
+        LOGE("H.264 decoder not found");
+        goto end;
+    }
+
+    demuxer->codec_ctx = avcodec_alloc_context3(codec);
+    if (!demuxer->codec_ctx) {
+        LOG_OOM();
        goto end;
    }

    if (!sc_demuxer_open_sinks(demuxer, codec)) {
-        goto end;
+        LOGE("Could not open demuxer sinks");
+        goto finally_free_codec_ctx;
    }

-    // Config packets must be merged with the next non-config packet only for
-    // video streams
-    bool must_merge_config_packet = codec->type == AVMEDIA_TYPE_VIDEO;
-
-    struct sc_packet_merger merger;
-
-    if (must_merge_config_packet) {
-        sc_packet_merger_init(&merger);
+    demuxer->parser = av_parser_init(codec_id);
+    if (!demuxer->parser) {
+        LOGE("Could not initialize parser");
+        goto finally_close_sinks;
    }

+    // We must only pass complete frames to av_parser_parse2()!
+    // It's more complicated, but this allows to reduce the latency by 1 frame!
+    demuxer->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
+
    AVPacket *packet = av_packet_alloc();
    if (!packet) {
        LOG_OOM();
-        goto finally_close_sinks;
+        goto finally_close_parser;
    }

    for (;;) {
        bool ok = sc_demuxer_recv_packet(demuxer, packet);
        if (!ok) {
            // end of stream
-            eos = true;
            break;
        }

-        if (must_merge_config_packet) {
-            // Prepend any config packet to the next media packet
-            ok = sc_packet_merger_merge(&merger, packet);
-            if (!ok) {
-                av_packet_unref(packet);
-                break;
-            }
-        }
-
        ok = sc_demuxer_push_packet(demuxer, packet);
        av_packet_unref(packet);
        if (!ok) {
@@ -256,31 +250,35 @@ run_demuxer(void *data) {
        }
    }

-    LOGD("Demuxer '%s': end of frames", demuxer->name);
+    LOGD("End of frames");

-    if (must_merge_config_packet) {
-        sc_packet_merger_destroy(&merger);
+    if (demuxer->pending) {
+        av_packet_free(&demuxer->pending);
    }

    av_packet_free(&packet);
+finally_close_parser:
+    av_parser_close(demuxer->parser);
 finally_close_sinks:
    sc_demuxer_close_sinks(demuxer);
+finally_free_codec_ctx:
+    avcodec_free_context(&demuxer->codec_ctx);
 end:
-    demuxer->cbs->on_ended(demuxer, eos, demuxer->cbs_userdata);
+    demuxer->cbs->on_eos(demuxer, demuxer->cbs_userdata);

    return 0;
 }

 void
-sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
+sc_demuxer_init(struct sc_demuxer *demuxer, sc_socket socket,
                const struct sc_demuxer_callbacks *cbs, void *cbs_userdata) {
    assert(socket != SC_SOCKET_NONE);

-    demuxer->name = name; // statically allocated
    demuxer->socket = socket;
+    demuxer->pending = NULL;
    demuxer->sink_count = 0;

-    assert(cbs && cbs->on_ended);
+    assert(cbs && cbs->on_eos);

    demuxer->cbs = cbs;
    demuxer->cbs_userdata = cbs_userdata;
@@ -296,12 +294,12 @@ sc_demuxer_add_sink(struct sc_demuxer *demuxer, struct sc_packet_sink *sink) {

 bool
 sc_demuxer_start(struct sc_demuxer *demuxer) {
-    LOGD("Demuxer '%s': starting thread", demuxer->name);
+    LOGD("Starting demuxer thread");

    bool ok = sc_thread_create(&demuxer->thread, run_demuxer, "scrcpy-demuxer",
                               demuxer);
    if (!ok) {
-        LOGE("Demuxer '%s': could not start thread", demuxer->name);
+        LOGE("Could not start demuxer thread");
        return false;
    }
    return true;
--- a/app/src/demuxer.h
+++ b/app/src/demuxer.h
@@ -15,25 +15,28 @@
 #define SC_DEMUXER_MAX_SINKS 2

 struct sc_demuxer {
-    const char *name; // must be statically allocated (e.g. a string literal)
-
    sc_socket socket;
    sc_thread thread;

    struct sc_packet_sink *sinks[SC_DEMUXER_MAX_SINKS];
    unsigned sink_count;

+    AVCodecContext *codec_ctx;
+    AVCodecParserContext *parser;
+    // successive packets may need to be concatenated, until a non-config
+    // packet is available
+    AVPacket *pending;
+
    const struct sc_demuxer_callbacks *cbs;
    void *cbs_userdata;
 };

 struct sc_demuxer_callbacks {
-    void (*on_ended)(struct sc_demuxer *demuxer, bool eos, void *userdata);
+    void (*on_eos)(struct sc_demuxer *demuxer, void *userdata);
 };

-// The name must be statically allocated (e.g. a string literal)
 void
-sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
+sc_demuxer_init(struct sc_demuxer *demuxer, sc_socket socket,
                const struct sc_demuxer_callbacks *cbs, void *cbs_userdata);

 void
--- a/app/src/events.h
+++ b/app/src/events.h
@@ -1,7 +1,5 @@
-#define SC_EVENT_NEW_FRAME                 SDL_USEREVENT
-#define SC_EVENT_DEVICE_DISCONNECTED      (SDL_USEREVENT + 1)
-#define SC_EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
-#define SC_EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
-#define SC_EVENT_USB_DEVICE_DISCONNECTED  (SDL_USEREVENT + 4)
-#define SC_EVENT_DEMUXER_ERROR            (SDL_USEREVENT + 5)
-#define SC_EVENT_RECORDER_ERROR           (SDL_USEREVENT + 6)
+#define EVENT_NEW_FRAME                 SDL_USEREVENT
+#define EVENT_STREAM_STOPPED           (SDL_USEREVENT + 1)
+#define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
+#define EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
+#define EVENT_USB_DEVICE_DISCONNECTED  (SDL_USEREVENT + 4)
--- a/app/src/options.c
+++ b/app/src/options.c
@@ -13,8 +13,7 @@ const struct scrcpy_options scrcpy_options_default = {
    .v4l2_device = NULL,
 #endif
    .log_level = SC_LOG_LEVEL_INFO,
-    .video_codec = SC_CODEC_H264,
-    .audio_codec = SC_CODEC_OPUS,
+    .codec = SC_CODEC_H264,
    .record_format = SC_RECORD_FORMAT_AUTO,
    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
    .port_range = {
@@ -28,8 +27,7 @@ const struct scrcpy_options scrcpy_options_default = {
        .count = 2,
    },
    .max_size = 0,
-    .bit_rate = 0,
-    .audio_bit_rate = 0,
+    .bit_rate = DEFAULT_BIT_RATE,
    .max_fps = 0,
    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
    .rotation = 0,
--- a/app/src/options.h
+++ b/app/src/options.h
@@ -27,8 +27,6 @@ enum sc_codec {
    SC_CODEC_H264,
    SC_CODEC_H265,
    SC_CODEC_AV1,
-    SC_CODEC_OPUS,
-    SC_CODEC_AAC,
 };

 enum sc_lock_video_orientation {
@@ -97,13 +95,11 @@ struct scrcpy_options {
    const char *render_driver;
    const char *codec_options;
    const char *encoder_name;
-    const char *audio_encoder_name;
 #ifdef HAVE_V4L2
    const char *v4l2_device;
 #endif
    enum sc_log_level log_level;
-    enum sc_codec video_codec;
-    enum sc_codec audio_codec;
+    enum sc_codec codec;
    enum sc_record_format record_format;
    enum sc_keyboard_input_mode keyboard_input_mode;
    enum sc_mouse_input_mode mouse_input_mode;
@@ -113,7 +109,6 @@ struct scrcpy_options {
    struct sc_shortcut_mods shortcut_mods;
    uint16_t max_size;
    uint32_t bit_rate;
-    uint32_t audio_bit_rate;
    uint16_t max_fps;
    enum sc_lock_video_orientation lock_video_orientation;
    uint8_t rotation;
--- a/app/src/packet_merger.c
+++ b/app/src/packet_merger.c
@@ -1,48 +0,0 @@
-#include "packet_merger.h"
-
-#include "util/log.h"
-
-void
-sc_packet_merger_init(struct sc_packet_merger *merger) {
-    merger->config = NULL;
-}
-
-void
-sc_packet_merger_destroy(struct sc_packet_merger *merger) {
-    free(merger->config);
-}
-
-bool
-sc_packet_merger_merge(struct sc_packet_merger *merger, AVPacket *packet) {
-    bool is_config = packet->pts == AV_NOPTS_VALUE;
-
-    if (is_config) {
-        free(merger->config);
-
-        merger->config = malloc(packet->size);
-        if (!merger->config) {
-            LOG_OOM();
-            return false;
-        }
-
-        memcpy(merger->config, packet->data, packet->size);
-        merger->config_size = packet->size;
-    } else if (merger->config) {
-        size_t config_size = merger->config_size;
-        size_t media_size = packet->size;
-
-        if (av_grow_packet(packet, config_size)) {
-            LOG_OOM();
-            return false;
-        }
-
-        memmove(packet->data + config_size, packet->data, media_size);
-        memcpy(packet->data, merger->config, config_size);
-
-        free(merger->config);
-        merger->config = NULL;
-        // merger->size is meaningless when merger->config is NULL
-    }
-
-    return true;
-}
--- a/app/src/packet_merger.h
+++ b/app/src/packet_merger.h
@@ -1,43 +0,0 @@
-#ifndef SC_PACKET_MERGER_H
-#define SC_PACKET_MERGER_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <libavcodec/avcodec.h>
-
-/**
- * Config packets (containing the SPS/PPS) are sent in-band. A new config
- * packet is sent whenever a new encoding session is started (on start and on
- * device orientation change).
- *
- * Every time a config packet is received, it must be sent alone (for recorder
- * extradata), then concatenated to the next media packet (for correct decoding
- * and recording).
- *
- * This helper reads every input packet and modifies each media packet which
- * immediately follows a config packet to prepend the config packet payload.
- */
-
-struct sc_packet_merger {
-    uint8_t *config;
-    size_t config_size;
-};
-
-void
-sc_packet_merger_init(struct sc_packet_merger *merger);
-
-void
-sc_packet_merger_destroy(struct sc_packet_merger *merger);
-
-/**
- * If the packet is a config packet, then keep its data for later.
- * Otherwise (if the packet is a media packet), then if a config packet is
- * pending, prepend the config packet to this packet (so the packet is
- * modified!).
- */
-bool
-sc_packet_merger_merge(struct sc_packet_merger *merger, AVPacket *packet);
-
-#endif
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@@ -7,7 +7,7 @@
 #include "util/log.h"

 bool
-sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
+receiver_init(struct receiver *receiver, sc_socket control_socket,
              struct sc_acksync *acksync) {
    bool ok = sc_mutex_init(&receiver->mutex);
    if (!ok) {
@@ -21,12 +21,12 @@ sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
 }

 void
-sc_receiver_destroy(struct sc_receiver *receiver) {
+receiver_destroy(struct receiver *receiver) {
    sc_mutex_destroy(&receiver->mutex);
 }

 static void
-process_msg(struct sc_receiver *receiver, struct device_msg *msg) {
+process_msg(struct receiver *receiver, struct device_msg *msg) {
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
            char *current = SDL_GetClipboardText();
@@ -51,7 +51,7 @@ process_msg(struct sc_receiver *receiver, struct device_msg *msg) {
 }

 static ssize_t
-process_msgs(struct sc_receiver *receiver, const unsigned char *buf, size_t len) {
+process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
    size_t head = 0;
    for (;;) {
        struct device_msg msg;
@@ -76,7 +76,7 @@ process_msgs(struct sc_receiver *receiver, const unsigned char *buf, size_t len)

 static int
 run_receiver(void *data) {
-    struct sc_receiver *receiver = data;
+    struct receiver *receiver = data;

    static unsigned char buf[DEVICE_MSG_MAX_SIZE];
    size_t head = 0;
@@ -108,7 +108,7 @@ run_receiver(void *data) {
 }

 bool
-sc_receiver_start(struct sc_receiver *receiver) {
+receiver_start(struct receiver *receiver) {
    LOGD("Starting receiver thread");

    bool ok = sc_thread_create(&receiver->thread, run_receiver,
@@ -122,6 +122,6 @@ sc_receiver_start(struct sc_receiver *receiver) {
 }

 void
-sc_receiver_join(struct sc_receiver *receiver) {
+receiver_join(struct receiver *receiver) {
    sc_thread_join(&receiver->thread, NULL);
 }
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@@ -11,7 +11,7 @@

 // receive events from the device
 // managed by the controller
-struct sc_receiver {
+struct receiver {
    sc_socket control_socket;
    sc_thread thread;
    sc_mutex mutex;
@@ -20,18 +20,18 @@ struct sc_receiver {
 };

 bool
-sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
-                 struct sc_acksync *acksync);
+receiver_init(struct receiver *receiver, sc_socket control_socket,
+              struct sc_acksync *acksync);

 void
-sc_receiver_destroy(struct sc_receiver *receiver);
+receiver_destroy(struct receiver *receiver);

 bool
-sc_receiver_start(struct sc_receiver *receiver);
+receiver_start(struct receiver *receiver);

-// no sc_receiver_stop(), it will automatically stop on control_socket shutdown
+// no receiver_stop(), it will automatically stop on control_socket shutdown

 void
-sc_receiver_join(struct sc_receiver *receiver);
+receiver_join(struct receiver *receiver);

 #endif
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@@ -8,11 +8,10 @@
 #include "util/log.h"
 #include "util/str.h"

-/** Downcast packet sinks to recorder */
-#define DOWNCAST_VIDEO(SINK) \
-    container_of(SINK, struct sc_recorder, video_packet_sink)
-#define DOWNCAST_AUDIO(SINK) \
-    container_of(SINK, struct sc_recorder, audio_packet_sink)
+/** Downcast packet_sink to recorder */
+#define DOWNCAST(SINK) container_of(SINK, struct sc_recorder, packet_sink)
+
+#define SC_PTS_ORIGIN_NONE UINT64_C(-1)

 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us

@@ -81,7 +80,9 @@ sc_recorder_get_format_name(enum sc_record_format format) {
 }

 static bool
-sc_recorder_set_extradata(AVStream *ostream, const AVPacket *packet) {
+sc_recorder_write_header(struct sc_recorder *recorder, const AVPacket *packet) {
+    AVStream *ostream = recorder->ctx->streams[0];
+
    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
    if (!extradata) {
        LOG_OOM();
@@ -93,56 +94,183 @@ sc_recorder_set_extradata(AVStream *ostream, const AVPacket *packet) {

    ostream->codecpar->extradata = extradata;
    ostream->codecpar->extradata_size = packet->size;
+
+    int ret = avformat_write_header(recorder->ctx, NULL);
+    if (ret < 0) {
+        LOGE("Failed to write header to %s", recorder->filename);
+        return false;
+    }
+
    return true;
 }

-static inline void
-sc_recorder_rescale_packet(AVStream *stream, AVPacket *packet) {
-    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, stream->time_base);
+static void
+sc_recorder_rescale_packet(struct sc_recorder *recorder, AVPacket *packet) {
+    AVStream *ostream = recorder->ctx->streams[0];
+    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
 }

 static bool
-sc_recorder_write_stream(struct sc_recorder *recorder, int stream_index,
-                         AVPacket *packet) {
-    AVStream *stream = recorder->ctx->streams[stream_index];
-    sc_recorder_rescale_packet(stream, packet);
-    return av_interleaved_write_frame(recorder->ctx, packet) >= 0;
+sc_recorder_write(struct sc_recorder *recorder, AVPacket *packet) {
+    if (!recorder->header_written) {
+        if (packet->pts != AV_NOPTS_VALUE) {
+            LOGE("The first packet is not a config packet");
+            return false;
+        }
+        bool ok = sc_recorder_write_header(recorder, packet);
+        if (!ok) {
+            return false;
+        }
+        recorder->header_written = true;
+        return true;
+    }
+
+    if (packet->pts == AV_NOPTS_VALUE) {
+        // ignore config packets
+        return true;
+    }
+
+    sc_recorder_rescale_packet(recorder, packet);
+    return av_write_frame(recorder->ctx, packet) >= 0;
 }

-static inline bool
-sc_recorder_write_video(struct sc_recorder *recorder, AVPacket *packet) {
-    return sc_recorder_write_stream(recorder, recorder->video_stream_index,
-                                    packet);
-}
+static int
+run_recorder(void *data) {
+    struct sc_recorder *recorder = data;

-static inline bool
-sc_recorder_write_audio(struct sc_recorder *recorder, AVPacket *packet) {
-    return sc_recorder_write_stream(recorder, recorder->audio_stream_index,
-                                    packet);
+    for (;;) {
+        sc_mutex_lock(&recorder->mutex);
+
+        while (!recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
+            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
+        }
+
+        // if stopped is set, continue to process the remaining events (to
+        // finish the recording) before actually stopping
+
+        if (recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
+            sc_mutex_unlock(&recorder->mutex);
+            struct sc_record_packet *last = recorder->previous;
+            if (last) {
+                // assign an arbitrary duration to the last packet
+                last->packet->duration = 100000;
+                bool ok = sc_recorder_write(recorder, last->packet);
+                if (!ok) {
+                    // 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
+                    LOGW("Could not record last packet");
+                }
+                sc_record_packet_delete(last);
+            }
+            break;
+        }
+
+        struct sc_record_packet *rec;
+        sc_queue_take(&recorder->queue, next, &rec);
+
+        sc_mutex_unlock(&recorder->mutex);
+
+        if (recorder->pts_origin == SC_PTS_ORIGIN_NONE
+                && rec->packet->pts != AV_NOPTS_VALUE) {
+            // First PTS received
+            recorder->pts_origin = rec->packet->pts;
+        }
+
+        if (rec->packet->pts != AV_NOPTS_VALUE) {
+            // Set PTS relatve to the origin
+            rec->packet->pts -= recorder->pts_origin;
+            rec->packet->dts = rec->packet->pts;
+        }
+
+        // recorder->previous is only written from this thread, no need to lock
+        struct sc_record_packet *previous = recorder->previous;
+        recorder->previous = rec;
+
+        if (!previous) {
+            // we just received the first packet
+            continue;
+        }
+
+        // config packets have no PTS, we must ignore them
+        if (rec->packet->pts != AV_NOPTS_VALUE
+            && previous->packet->pts != AV_NOPTS_VALUE) {
+            // we now know the duration of the previous packet
+            previous->packet->duration =
+                rec->packet->pts - previous->packet->pts;
+        }
+
+        bool ok = sc_recorder_write(recorder, previous->packet);
+        sc_record_packet_delete(previous);
+        if (!ok) {
+            LOGE("Could not record packet");
+
+            sc_mutex_lock(&recorder->mutex);
+            recorder->failed = true;
+            // discard pending packets
+            sc_recorder_queue_clear(&recorder->queue);
+            sc_mutex_unlock(&recorder->mutex);
+            break;
+        }
+    }
+
+    if (!recorder->failed) {
+        if (recorder->header_written) {
+            int ret = av_write_trailer(recorder->ctx);
+            if (ret < 0) {
+                LOGE("Failed to write trailer to %s", recorder->filename);
+                recorder->failed = true;
+            }
+        } else {
+            // the recorded file is empty
+            recorder->failed = true;
+        }
+    }
+
+    if (recorder->failed) {
+        LOGE("Recording failed to %s", recorder->filename);
+    } else {
+        const char *format_name = sc_recorder_get_format_name(recorder->format);
+        LOGI("Recording complete to %s file: %s", format_name,
+                                                  recorder->filename);
+    }
+
+    LOGD("Recorder thread ended");
+
+    return 0;
 }

 static bool
-sc_recorder_open_output_file(struct sc_recorder *recorder) {
+sc_recorder_open(struct sc_recorder *recorder, const AVCodec *input_codec) {
+    bool ok = sc_mutex_init(&recorder->mutex);
+    if (!ok) {
+        return false;
+    }
+
+    ok = sc_cond_init(&recorder->queue_cond);
+    if (!ok) {
+        goto error_mutex_destroy;
+    }
+
+    sc_queue_init(&recorder->queue);
+    recorder->stopped = false;
+    recorder->failed = false;
+    recorder->header_written = false;
+    recorder->previous = NULL;
+    recorder->pts_origin = SC_PTS_ORIGIN_NONE;
+
    const char *format_name = sc_recorder_get_format_name(recorder->format);
    assert(format_name);
    const AVOutputFormat *format = find_muxer(format_name);
    if (!format) {
        LOGE("Could not find muxer");
-        return false;
+        goto error_cond_destroy;
    }

    recorder->ctx = avformat_alloc_context();
    if (!recorder->ctx) {
        LOG_OOM();
-        return false;
-    }
-
-    int ret = avio_open(&recorder->ctx->pb, recorder->filename,
-                        AVIO_FLAG_WRITE);
-    if (ret < 0) {
-        LOGE("Failed to open output file: %s", recorder->filename);
-        avformat_free_context(recorder->ctx);
-        return false;
+        goto error_cond_destroy;
    }

    // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
@@ -154,436 +282,71 @@ sc_recorder_open_output_file(struct sc_recorder *recorder) {
    av_dict_set(&recorder->ctx->metadata, "comment",
                "Recorded by scrcpy " SCRCPY_VERSION, 0);

+    AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
+    if (!ostream) {
+        goto error_avformat_free_context;
+    }
+
+    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
+    ostream->codecpar->codec_id = input_codec->id;
+    ostream->codecpar->format = AV_PIX_FMT_YUV420P;
+    ostream->codecpar->width = recorder->declared_frame_size.width;
+    ostream->codecpar->height = recorder->declared_frame_size.height;
+
+    int ret = avio_open(&recorder->ctx->pb, recorder->filename,
+                        AVIO_FLAG_WRITE);
+    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;
+    }
+
+    LOGD("Starting recorder thread");
+    ok = sc_thread_create(&recorder->thread, run_recorder, "scrcpy-recorder",
+                          recorder);
+    if (!ok) {
+        LOGE("Could not start recorder thread");
+        goto error_avio_close;
+    }
+
    LOGI("Recording started to %s file: %s", format_name, recorder->filename);
-    return true;
-}

-static void
-sc_recorder_close_output_file(struct sc_recorder *recorder) {
+    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);

-static bool
-sc_recorder_wait_video_stream(struct sc_recorder *recorder) {
-    sc_mutex_lock(&recorder->mutex);
-    while (!recorder->video_codec && !recorder->stopped) {
-        sc_cond_wait(&recorder->stream_cond, &recorder->mutex);
-    }
-    const AVCodec *codec = recorder->video_codec;
-    sc_mutex_unlock(&recorder->mutex);
-
-    if (codec) {
-        AVStream *stream = avformat_new_stream(recorder->ctx, codec);
-        if (!stream) {
-            return false;
-        }
-
-        stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
-        stream->codecpar->codec_id = codec->id;
-        stream->codecpar->format = AV_PIX_FMT_YUV420P;
-        stream->codecpar->width = recorder->declared_frame_size.width;
-        stream->codecpar->height = recorder->declared_frame_size.height;
-
-        recorder->video_stream_index = stream->index;
-    }
-
-    return true;
-}
-
-static bool
-sc_recorder_wait_audio_stream(struct sc_recorder *recorder) {
-    sc_mutex_lock(&recorder->mutex);
-    while (!recorder->audio_codec && !recorder->audio_disabled
-            && !recorder->stopped) {
-        sc_cond_wait(&recorder->stream_cond, &recorder->mutex);
-    }
-
-    if (recorder->audio_disabled) {
-        // Reset audio flag. From there, the recorder thread may access this
-        // flag without any mutex.
-        recorder->audio = false;
-    }
-
-    const AVCodec *codec = recorder->audio_codec;
-    sc_mutex_unlock(&recorder->mutex);
-
-    if (codec) {
-        AVStream *stream = avformat_new_stream(recorder->ctx, codec);
-        if (!stream) {
-            return false;
-        }
-
-        stream->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
-        stream->codecpar->codec_id = codec->id;
-        stream->codecpar->ch_layout.nb_channels = 2;
-        stream->codecpar->sample_rate = 48000;
-
-        recorder->audio_stream_index = stream->index;
-    }
-
-    return true;
-}
-
-static inline bool
-sc_recorder_has_empty_queues(struct sc_recorder *recorder) {
-    if (sc_queue_is_empty(&recorder->video_queue)) {
-        // The video queue is empty
-        return true;
-    }
-
-    if (recorder->audio && sc_queue_is_empty(&recorder->audio_queue)) {
-        // The audio queue is empty (when audio is enabled)
-        return true;
-    }
-
-    // No queue is empty
    return false;
 }

-static bool
-sc_recorder_process_header(struct sc_recorder *recorder) {
-    sc_mutex_lock(&recorder->mutex);
-
-    while (!recorder->stopped && sc_recorder_has_empty_queues(recorder)) {
-        sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
-    }
-
-    if (recorder->stopped && sc_queue_is_empty(&recorder->video_queue)) {
-        // If the recorder is stopped, don't process anything if there are not
-        // at least video packets
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
-    }
-
-    struct sc_record_packet *video_pkt;
-    sc_queue_take(&recorder->video_queue, next, &video_pkt);
-
-    struct sc_record_packet *audio_pkt = NULL;
-    if (!sc_queue_is_empty(&recorder->audio_queue)) {
-        assert(recorder->audio);
-        sc_queue_take(&recorder->audio_queue, next, &audio_pkt);
-    }
-
-    sc_mutex_unlock(&recorder->mutex);
-
-    int ret = false;
-
-    if (video_pkt->packet->pts != AV_NOPTS_VALUE) {
-        LOGE("The first video packet is not a config packet");
-        goto end;
-    }
-
-    assert(recorder->video_stream_index >= 0);
-    AVStream *video_stream =
-        recorder->ctx->streams[recorder->video_stream_index];
-    bool ok = sc_recorder_set_extradata(video_stream, video_pkt->packet);
-    if (!ok) {
-        goto end;
-    }
-
-    if (audio_pkt) {
-        if (audio_pkt->packet->pts != AV_NOPTS_VALUE) {
-            LOGE("The first audio packet is not a config packet");
-            goto end;
-        }
-
-        assert(recorder->audio_stream_index >= 0);
-        AVStream *audio_stream =
-            recorder->ctx->streams[recorder->audio_stream_index];
-        ok = sc_recorder_set_extradata(audio_stream, audio_pkt->packet);
-        if (!ok) {
-            goto end;
-        }
-    }
-
-    ok = avformat_write_header(recorder->ctx, NULL) >= 0;
-    if (!ok) {
-        LOGE("Failed to write header to %s", recorder->filename);
-        goto end;
-    }
-
-    ret = true;
-
-end:
-    sc_record_packet_delete(video_pkt);
-    if (audio_pkt) {
-        sc_record_packet_delete(audio_pkt);
-    }
-
-    return ret;
-}
-
-static bool
-sc_recorder_process_packets(struct sc_recorder *recorder) {
-    int64_t pts_origin = AV_NOPTS_VALUE;
-
-    bool header_written = sc_recorder_process_header(recorder);
-    if (!header_written) {
-        return false;
-    }
-
-    struct sc_record_packet *video_pkt = NULL;
-    struct sc_record_packet *audio_pkt = NULL;
-
-    // We can write a video packet only once we received the next one so that
-    // we can set its duration (next_pts - current_pts)
-    struct sc_record_packet *video_pkt_previous = NULL;
-
-    bool error = false;
-
-    for (;;) {
-        sc_mutex_lock(&recorder->mutex);
-
-        while (!recorder->stopped) {
-            if (!video_pkt && !sc_queue_is_empty(&recorder->video_queue)) {
-                // A new packet may be assigned to video_pkt and be processed
-                break;
-            }
-            if (recorder->audio && !audio_pkt
-                    && !sc_queue_is_empty(&recorder->audio_queue)) {
-                // A new packet may be assigned to audio_pkt and be processed
-                break;
-            }
-            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
-        }
-
-        // If stopped is set, continue to process the remaining events (to
-        // finish the recording) before actually stopping.
-
-        // If there is no audio, then the audio_queue will remain empty forever
-        // and audio_pkt will always be NULL.
-        assert(recorder->audio
-                || (!audio_pkt && sc_queue_is_empty(&recorder->audio_queue)));
-
-        if (!video_pkt && !sc_queue_is_empty(&recorder->video_queue)) {
-            sc_queue_take(&recorder->video_queue, next, &video_pkt);
-        }
-
-        if (!audio_pkt && !sc_queue_is_empty(&recorder->audio_queue)) {
-            sc_queue_take(&recorder->audio_queue, next, &audio_pkt);
-        }
-
-        if (recorder->stopped && !video_pkt && !audio_pkt) {
-            assert(sc_queue_is_empty(&recorder->video_queue));
-            assert(sc_queue_is_empty(&recorder->audio_queue));
-            sc_mutex_unlock(&recorder->mutex);
-            break;
-        }
-
-        assert(video_pkt || audio_pkt); // at least one
-
-        sc_mutex_unlock(&recorder->mutex);
-
-        // Ignore further config packets (e.g. on device orientation
-        // change). The next non-config packet will have the config packet
-        // data prepended.
-        if (video_pkt && video_pkt->packet->pts == AV_NOPTS_VALUE) {
-            sc_record_packet_delete(video_pkt);
-            video_pkt = NULL;
-        }
-
-        if (audio_pkt && audio_pkt->packet->pts == AV_NOPTS_VALUE) {
-            sc_record_packet_delete(audio_pkt);
-            audio_pkt= NULL;
-        }
-
-        if (pts_origin == AV_NOPTS_VALUE) {
-            if (!recorder->audio) {
-                assert(video_pkt);
-                pts_origin = video_pkt->packet->pts;
-            } else if (video_pkt && audio_pkt) {
-                pts_origin =
-                    MIN(video_pkt->packet->pts, audio_pkt->packet->pts);
-            } else if (recorder->stopped) {
-                if (video_pkt) {
-                    // The recorder is stopped without audio, record the video
-                    // packets
-                    pts_origin = video_pkt->packet->pts;
-                } else {
-                    // Fail if there is no video
-                    error = true;
-                    goto end;
-                }
-                // If the recorder is stopped while one of the streams has no
-                // packets, then we must avoid a live-loop and correctly record
-                // the stream having packets.
-                pts_origin = video_pkt ? video_pkt->packet->pts
-                                       : audio_pkt->packet->pts;
-            } else {
-                // We need both video and audio packets to initialize pts_origin
-                continue;
-            }
-        }
-
-        assert(pts_origin != AV_NOPTS_VALUE);
-
-        if (video_pkt) {
-            video_pkt->packet->pts -= pts_origin;
-            video_pkt->packet->dts = video_pkt->packet->pts;
-
-            if (video_pkt_previous) {
-                // we now know the duration of the previous packet
-                video_pkt_previous->packet->duration =
-                    video_pkt->packet->pts - video_pkt_previous->packet->pts;
-
-                bool ok = sc_recorder_write_video(recorder,
-                                                  video_pkt_previous->packet);
-                sc_record_packet_delete(video_pkt_previous);
-                if (!ok) {
-                    LOGE("Could not record video packet");
-                    error = true;
-                    goto end;
-                }
-            }
-
-            video_pkt_previous = video_pkt;
-            video_pkt = NULL;
-        }
-
-        if (audio_pkt) {
-            audio_pkt->packet->pts -= pts_origin;
-            audio_pkt->packet->dts = audio_pkt->packet->pts;
-
-            bool ok = sc_recorder_write_audio(recorder, audio_pkt->packet);
-            if (!ok) {
-                LOGE("Could not record audio packet");
-                error = true;
-                goto end;
-            }
-
-            sc_record_packet_delete(audio_pkt);
-            audio_pkt = NULL;
-        }
-    }
-
-    // Write the last video packet
-    struct sc_record_packet *last = video_pkt_previous;
-    if (last) {
-        // assign an arbitrary duration to the last packet
-        last->packet->duration = 100000;
-        bool ok = sc_recorder_write_video(recorder, last->packet);
-        if (!ok) {
-            // 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
-            LOGW("Could not record last packet");
-        }
-        sc_record_packet_delete(last);
-    }
-
-    int ret = av_write_trailer(recorder->ctx);
-    if (ret < 0) {
-        LOGE("Failed to write trailer to %s", recorder->filename);
-        error = false;
-    }
-
-end:
-    if (video_pkt) {
-        sc_record_packet_delete(video_pkt);
-    }
-    if (audio_pkt) {
-        sc_record_packet_delete(audio_pkt);
-    }
-
-    return !error;
-}
-
-static bool
-sc_recorder_record(struct sc_recorder *recorder) {
-    bool ok = sc_recorder_open_output_file(recorder);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_recorder_wait_video_stream(recorder);
-    if (!ok) {
-        sc_recorder_close_output_file(recorder);
-        return false;
-    }
-
-    if (recorder->audio) {
-        ok = sc_recorder_wait_audio_stream(recorder);
-        if (!ok) {
-            sc_recorder_close_output_file(recorder);
-            return false;
-        }
-    }
-
-    // If recorder->stopped, process any queued packet anyway
-
-    ok = sc_recorder_process_packets(recorder);
-    sc_recorder_close_output_file(recorder);
-    return ok;
-}
-
-static int
-run_recorder(void *data) {
-    struct sc_recorder *recorder = data;
-
-    bool success = sc_recorder_record(recorder);
-
-    sc_mutex_lock(&recorder->mutex);
-    // Prevent the producer to push any new packet
-    recorder->stopped = true;
-    // Discard pending packets
-    sc_recorder_queue_clear(&recorder->video_queue);
-    sc_mutex_unlock(&recorder->mutex);
-
-    if (success) {
-        const char *format_name = sc_recorder_get_format_name(recorder->format);
-        LOGI("Recording complete to %s file: %s", format_name,
-                                                  recorder->filename);
-    } else {
-        LOGE("Recording failed to %s", recorder->filename);
-    }
-
-    LOGD("Recorder thread ended");
-
-    recorder->cbs->on_ended(recorder, success, recorder->cbs_userdata);
-
-    return 0;
-}
-
-static bool
-sc_recorder_video_packet_sink_open(struct sc_packet_sink *sink,
-                                   const AVCodec *codec) {
-    struct sc_recorder *recorder = DOWNCAST_VIDEO(sink);
-    assert(codec);
-
-    sc_mutex_lock(&recorder->mutex);
-    if (recorder->stopped) {
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
-    }
-
-    recorder->video_codec = codec;
-    sc_cond_signal(&recorder->stream_cond);
-    sc_mutex_unlock(&recorder->mutex);
-
-    return true;
-}
-
 static void
-sc_recorder_video_packet_sink_close(struct sc_packet_sink *sink) {
-    struct sc_recorder *recorder = DOWNCAST_VIDEO(sink);
-
+sc_recorder_close(struct sc_recorder *recorder) {
    sc_mutex_lock(&recorder->mutex);
-    // EOS also stops the recorder
    recorder->stopped = true;
    sc_cond_signal(&recorder->queue_cond);
    sc_mutex_unlock(&recorder->mutex);
+
+    sc_thread_join(&recorder->thread, NULL);
+
+    avio_close(recorder->ctx->pb);
+    avformat_free_context(recorder->ctx);
+    sc_cond_destroy(&recorder->queue_cond);
+    sc_mutex_destroy(&recorder->mutex);
 }

 static bool
-sc_recorder_video_packet_sink_push(struct sc_packet_sink *sink,
-                                   const AVPacket *packet) {
-    struct sc_recorder *recorder = DOWNCAST_VIDEO(sink);
-
+sc_recorder_push(struct sc_recorder *recorder, const AVPacket *packet) {
    sc_mutex_lock(&recorder->mutex);
+    assert(!recorder->stopped);

-    if (recorder->stopped) {
-        // reject any new packet
+    if (recorder->failed) {
+        // reject any new packet (this will stop the stream)
        sc_mutex_unlock(&recorder->mutex);
        return false;
    }
@@ -595,9 +358,7 @@ sc_recorder_video_packet_sink_push(struct sc_packet_sink *sink,
        return false;
    }

-    rec->packet->stream_index = 0;
-
-    sc_queue_push(&recorder->video_queue, next, rec);
+    sc_queue_push(&recorder->queue, next, rec);
    sc_cond_signal(&recorder->queue_cond);

    sc_mutex_unlock(&recorder->mutex);
@@ -605,189 +366,51 @@ sc_recorder_video_packet_sink_push(struct sc_packet_sink *sink,
 }

 static bool
-sc_recorder_audio_packet_sink_open(struct sc_packet_sink *sink,
-                                   const AVCodec *codec) {
-    struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
-    assert(recorder->audio);
-    // only written from this thread, no need to lock
-    assert(!recorder->audio_disabled);
-    assert(codec);
-
-    sc_mutex_lock(&recorder->mutex);
-    recorder->audio_codec = codec;
-    sc_cond_signal(&recorder->stream_cond);
-    sc_mutex_unlock(&recorder->mutex);
-
-    return true;
+sc_recorder_packet_sink_open(struct sc_packet_sink *sink,
+                             const AVCodec *codec) {
+    struct sc_recorder *recorder = DOWNCAST(sink);
+    return sc_recorder_open(recorder, codec);
 }

 static void
-sc_recorder_audio_packet_sink_close(struct sc_packet_sink *sink) {
-    struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
-    assert(recorder->audio);
-    // only written from this thread, no need to lock
-    assert(!recorder->audio_disabled);
-
-    sc_mutex_lock(&recorder->mutex);
-    // EOS also stops the recorder
-    recorder->stopped = true;
-    sc_cond_signal(&recorder->queue_cond);
-    sc_mutex_unlock(&recorder->mutex);
+sc_recorder_packet_sink_close(struct sc_packet_sink *sink) {
+    struct sc_recorder *recorder = DOWNCAST(sink);
+    sc_recorder_close(recorder);
 }

 static bool
-sc_recorder_audio_packet_sink_push(struct sc_packet_sink *sink,
-                                   const AVPacket *packet) {
-    struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
-    assert(recorder->audio);
-    // only written from this thread, no need to lock
-    assert(!recorder->audio_disabled);
-
-    sc_mutex_lock(&recorder->mutex);
-
-    if (recorder->stopped) {
-        // reject any new packet
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
-    }
-
-    struct sc_record_packet *rec = sc_record_packet_new(packet);
-    if (!rec) {
-        LOG_OOM();
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
-    }
-
-    rec->packet->stream_index = 1;
-
-    sc_queue_push(&recorder->audio_queue, next, rec);
-    sc_cond_signal(&recorder->queue_cond);
-
-    sc_mutex_unlock(&recorder->mutex);
-    return true;
-}
-
-static void
-sc_recorder_audio_packet_sink_disable(struct sc_packet_sink *sink) {
-    struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
-    assert(recorder->audio);
-    // only written from this thread, no need to lock
-    assert(!recorder->audio_disabled);
-    assert(!recorder->audio_codec);
-
-    LOGW("Audio stream recording disabled");
-
-    sc_mutex_lock(&recorder->mutex);
-    recorder->audio_disabled = true;
-    sc_cond_signal(&recorder->stream_cond);
-    sc_mutex_unlock(&recorder->mutex);
+sc_recorder_packet_sink_push(struct sc_packet_sink *sink,
+                             const AVPacket *packet) {
+    struct sc_recorder *recorder = DOWNCAST(sink);
+    return sc_recorder_push(recorder, packet);
 }

 bool
-sc_recorder_init(struct sc_recorder *recorder, const char *filename,
-                 enum sc_record_format format, bool audio,
-                 struct sc_size declared_frame_size,
-                 const struct sc_recorder_callbacks *cbs, void *cbs_userdata) {
+sc_recorder_init(struct sc_recorder *recorder,
+                 const char *filename,
+                 enum sc_record_format format,
+                 struct sc_size declared_frame_size) {
    recorder->filename = strdup(filename);
    if (!recorder->filename) {
        LOG_OOM();
        return false;
    }

-    bool ok = sc_mutex_init(&recorder->mutex);
-    if (!ok) {
-        goto error_free_filename;
-    }
-
-    ok = sc_cond_init(&recorder->queue_cond);
-    if (!ok) {
-        goto error_mutex_destroy;
-    }
-
-    ok = sc_cond_init(&recorder->stream_cond);
-    if (!ok) {
-        goto error_queue_cond_destroy;
-    }
-
-    recorder->audio = audio;
-
-    sc_queue_init(&recorder->video_queue);
-    sc_queue_init(&recorder->audio_queue);
-    recorder->stopped = false;
-
-    recorder->video_codec = NULL;
-    recorder->audio_codec = NULL;
-    recorder->audio_disabled = false;
-
-    recorder->video_stream_index = -1;
-    recorder->audio_stream_index = -1;
-
    recorder->format = format;
    recorder->declared_frame_size = declared_frame_size;

-    assert(cbs && cbs->on_ended);
-
-    recorder->cbs = cbs;
-    recorder->cbs_userdata = cbs_userdata;
-
-    static const struct sc_packet_sink_ops video_ops = {
-        .open = sc_recorder_video_packet_sink_open,
-        .close = sc_recorder_video_packet_sink_close,
-        .push = sc_recorder_video_packet_sink_push,
+    static const struct sc_packet_sink_ops ops = {
+        .open = sc_recorder_packet_sink_open,
+        .close = sc_recorder_packet_sink_close,
+        .push = sc_recorder_packet_sink_push,
    };

-    recorder->video_packet_sink.ops = &video_ops;
-
-    if (audio) {
-        static const struct sc_packet_sink_ops audio_ops = {
-            .open = sc_recorder_audio_packet_sink_open,
-            .close = sc_recorder_audio_packet_sink_close,
-            .push = sc_recorder_audio_packet_sink_push,
-            .disable = sc_recorder_audio_packet_sink_disable,
-        };
-
-        recorder->audio_packet_sink.ops = &audio_ops;
-    }
-
-    ok = sc_thread_create(&recorder->thread, run_recorder, "scrcpy-recorder",
-                          recorder);
-    if (!ok) {
-        LOGE("Could not start recorder thread");
-        goto error_stream_cond_destroy;
-    }
+    recorder->packet_sink.ops = &ops;

    return true;
-
-error_stream_cond_destroy:
-    sc_cond_destroy(&recorder->stream_cond);
-error_queue_cond_destroy:
-    sc_cond_destroy(&recorder->queue_cond);
-error_mutex_destroy:
-    sc_mutex_destroy(&recorder->mutex);
-error_free_filename:
-    free(recorder->filename);
-
-    return false;
-}
-
-void
-sc_recorder_stop(struct sc_recorder *recorder) {
-    sc_mutex_lock(&recorder->mutex);
-    recorder->stopped = true;
-    sc_cond_signal(&recorder->queue_cond);
-    sc_cond_signal(&recorder->stream_cond);
-    sc_mutex_unlock(&recorder->mutex);
-}
-
-void
-sc_recorder_join(struct sc_recorder *recorder) {
-    sc_thread_join(&recorder->thread, NULL);
 }

 void
 sc_recorder_destroy(struct sc_recorder *recorder) {
-    sc_cond_destroy(&recorder->stream_cond);
-    sc_cond_destroy(&recorder->queue_cond);
-    sc_mutex_destroy(&recorder->mutex);
    free(recorder->filename);
 }
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@@ -20,63 +20,34 @@ struct sc_record_packet {
 struct sc_recorder_queue SC_QUEUE(struct sc_record_packet);

 struct sc_recorder {
-    struct sc_packet_sink video_packet_sink;
-    struct sc_packet_sink audio_packet_sink;
-
-    /* The audio flag is unprotected:
-     *  - it is initialized from sc_recorder_init() from the main thread;
-     *  - it may be reset once from the recorder thread if the audio is
-     *    disabled dynamically.
-     *
-     * Therefore, once the recorder thread is started, only the recorder thread
-     * may access it without data races.
-     */
-    bool audio;
+    struct sc_packet_sink packet_sink; // packet sink trait

    char *filename;
    enum sc_record_format format;
    AVFormatContext *ctx;
    struct sc_size declared_frame_size;
+    bool header_written;
+
+    uint64_t pts_origin;

    sc_thread thread;
    sc_mutex mutex;
    sc_cond queue_cond;
-    // set on sc_recorder_stop(), packet_sink close or recording failure
-    bool stopped;
-    struct sc_recorder_queue video_queue;
-    struct sc_recorder_queue audio_queue;
+    bool stopped; // set on recorder_close()
+    bool failed; // set on packet write failure
+    struct sc_recorder_queue queue;

-    // wake up the recorder thread once the video or audio codec is known
-    sc_cond stream_cond;
-    const AVCodec *video_codec;
-    const AVCodec *audio_codec;
-    // Instead of providing an audio_codec, the demuxer may notify that the
-    // stream is disabled if the device could not capture audio
-    bool audio_disabled;
-
-    int video_stream_index;
-    int audio_stream_index;
-
-    const struct sc_recorder_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct sc_recorder_callbacks {
-    void (*on_ended)(struct sc_recorder *recorder, bool success,
-                     void *userdata);
+    // we can write a packet only once we received the next one so that we can
+    // set its duration (next_pts - current_pts)
+    // "previous" is only accessed from the recorder thread, so it does not
+    // need to be protected by the mutex
+    struct sc_record_packet *previous;
 };

 bool
 sc_recorder_init(struct sc_recorder *recorder, const char *filename,
-                 enum sc_record_format format, bool audio,
-                 struct sc_size declared_frame_size,
-                 const struct sc_recorder_callbacks *cbs, void *cbs_userdata);
-
-void
-sc_recorder_stop(struct sc_recorder *recorder);
-
-void
-sc_recorder_join(struct sc_recorder *recorder);
+                 enum sc_record_format format,
+                 struct sc_size declared_frame_size);

 void
 sc_recorder_destroy(struct sc_recorder *recorder);
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -156,15 +156,9 @@ event_loop(struct scrcpy *s) {
    SDL_Event event;
    while (SDL_WaitEvent(&event)) {
        switch (event.type) {
-            case SC_EVENT_DEVICE_DISCONNECTED:
+            case EVENT_STREAM_STOPPED:
                LOGW("Device disconnected");
                return SCRCPY_EXIT_DISCONNECTED;
-            case SC_EVENT_DEMUXER_ERROR:
-                LOGE("Demuxer error");
-                return SCRCPY_EXIT_FAILURE;
-            case SC_EVENT_RECORDER_ERROR:
-                LOGE("Recorder error");
-                return SCRCPY_EXIT_FAILURE;
            case SDL_QUIT:
                LOGD("User requested to quit");
                return SCRCPY_EXIT_SUCCESS;
@@ -186,10 +180,10 @@ await_for_server(bool *connected) {
                LOGD("User requested to quit");
                *connected = false;
                return true;
-            case SC_EVENT_SERVER_CONNECTION_FAILED:
+            case EVENT_SERVER_CONNECTION_FAILED:
                LOGE("Server connection failed");
                return false;
-            case SC_EVENT_SERVER_CONNECTED:
+            case EVENT_SERVER_CONNECTED:
                LOGD("Server connected");
                *connected = true;
                return true;
@@ -240,37 +234,19 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
 }

 static void
-sc_recorder_on_ended(struct sc_recorder *recorder, bool success,
-                     void *userdata) {
-    (void) recorder;
-    (void) userdata;
-
-    if (!success) {
-        PUSH_EVENT(SC_EVENT_RECORDER_ERROR);
-    }
-}
-
-static void
-sc_video_demuxer_on_ended(struct sc_demuxer *demuxer, bool eos,
-                          void *userdata) {
+sc_video_demuxer_on_eos(struct sc_demuxer *demuxer, void *userdata) {
    (void) demuxer;
    (void) userdata;

-    if (eos) {
-        PUSH_EVENT(SC_EVENT_DEVICE_DISCONNECTED);
-    } else {
-        PUSH_EVENT(SC_EVENT_DEMUXER_ERROR);
-    }
+    PUSH_EVENT(EVENT_STREAM_STOPPED);
 }

 static void
-sc_audio_demuxer_on_ended(struct sc_demuxer *demuxer, bool eos,
-                          void *userdata) {
+sc_audio_demuxer_on_eos(struct sc_demuxer *demuxer, void *userdata) {
    (void) demuxer;
-    (void) eos;
    (void) userdata;

-    // Contrary to the video demuxer, keep mirroring if only the audio fails
+    // TODO
 }

 static void
@@ -278,7 +254,7 @@ sc_server_on_connection_failed(struct sc_server *server, void *userdata) {
    (void) server;
    (void) userdata;

-    PUSH_EVENT(SC_EVENT_SERVER_CONNECTION_FAILED);
+    PUSH_EVENT(EVENT_SERVER_CONNECTION_FAILED);
 }

 static void
@@ -286,7 +262,7 @@ sc_server_on_connected(struct sc_server *server, void *userdata) {
    (void) server;
    (void) userdata;

-    PUSH_EVENT(SC_EVENT_SERVER_CONNECTED);
+    PUSH_EVENT(EVENT_SERVER_CONNECTED);
 }

 static void
@@ -299,9 +275,8 @@ sc_server_on_disconnected(struct sc_server *server, void *userdata) {
    // event
 }

-// Generate a scrcpy id to differentiate multiple running scrcpy instances
 static uint32_t
-scrcpy_generate_scid() {
+scrcpy_generate_uid() {
    struct sc_rand rand;
    sc_rand_init(&rand);
    // Only use 31 bits to avoid issues with signed values on the Java-side
@@ -342,23 +317,21 @@ scrcpy(struct scrcpy_options *options) {

    struct sc_acksync *acksync = NULL;

-    uint32_t scid = scrcpy_generate_scid();
+    uint32_t uid = scrcpy_generate_uid();

    struct sc_server_params params = {
-        .scid = scid,
+        .uid = uid,
        .req_serial = options->serial,
        .select_usb = options->select_usb,
        .select_tcpip = options->select_tcpip,
        .log_level = options->log_level,
-        .video_codec = options->video_codec,
-        .audio_codec = options->audio_codec,
+        .codec = options->codec,
        .crop = options->crop,
        .port_range = options->port_range,
        .tunnel_host = options->tunnel_host,
        .tunnel_port = options->tunnel_port,
        .max_size = options->max_size,
        .bit_rate = options->bit_rate,
-        .audio_bit_rate = options->audio_bit_rate,
        .max_fps = options->max_fps,
        .lock_video_orientation = options->lock_video_orientation,
        .control = options->control,
@@ -368,7 +341,6 @@ scrcpy(struct scrcpy_options *options) {
        .stay_awake = options->stay_awake,
        .codec_options = options->codec_options,
        .encoder_name = options->encoder_name,
-        .audio_encoder_name = options->audio_encoder_name,
        .force_adb_forward = options->force_adb_forward,
        .power_off_on_close = options->power_off_on_close,
        .clipboard_autosync = options->clipboard_autosync,
@@ -447,12 +419,10 @@ scrcpy(struct scrcpy_options *options) {

    struct sc_recorder *rec = NULL;
    if (options->record_filename) {
-        static const struct sc_recorder_callbacks recorder_cbs = {
-            .on_ended = sc_recorder_on_ended,
-        };
-        if (!sc_recorder_init(&s->recorder, options->record_filename,
-                              options->record_format, options->audio,
-                              info->frame_size, &recorder_cbs, NULL)) {
+        if (!sc_recorder_init(&s->recorder,
+                              options->record_filename,
+                              options->record_format,
+                              info->frame_size)) {
            goto end;
        }
        rec = &s->recorder;
@@ -462,16 +432,16 @@ scrcpy(struct scrcpy_options *options) {
    av_log_set_callback(av_log_callback);

    static const struct sc_demuxer_callbacks video_demuxer_cbs = {
-        .on_ended = sc_video_demuxer_on_ended,
+        .on_eos = sc_video_demuxer_on_eos,
    };
-    sc_demuxer_init(&s->video_demuxer, "video", s->server.video_socket,
+    sc_demuxer_init(&s->video_demuxer, s->server.video_socket,
                    &video_demuxer_cbs, NULL);

    if (options->audio) {
        static const struct sc_demuxer_callbacks audio_demuxer_cbs = {
-            .on_ended = sc_audio_demuxer_on_ended,
+            .on_eos = sc_audio_demuxer_on_eos,
        };
-        sc_demuxer_init(&s->audio_demuxer, "audio", s->server.audio_socket,
+        sc_demuxer_init(&s->audio_demuxer, s->server.audio_socket,
                        &audio_demuxer_cbs, NULL);
    }

@@ -480,10 +450,7 @@ scrcpy(struct scrcpy_options *options) {
    }

    if (rec) {
-        sc_demuxer_add_sink(&s->video_demuxer, &rec->video_packet_sink);
-        if (options->audio) {
-            sc_demuxer_add_sink(&s->audio_demuxer, &rec->audio_packet_sink);
-        }
+        sc_demuxer_add_sink(&s->video_demuxer, &rec->packet_sink);
    }

    struct sc_controller *controller = NULL;
@@ -735,9 +702,6 @@ end:
    if (file_pusher_initialized) {
        sc_file_pusher_stop(&s->file_pusher);
    }
-    if (recorder_initialized) {
-        sc_recorder_stop(&s->recorder);
-    }
    if (screen_initialized) {
        sc_screen_interrupt(&s->screen);
    }
@@ -789,7 +753,6 @@ end:
    }

    if (recorder_initialized) {
-        sc_recorder_join(&s->recorder);
        sc_recorder_destroy(&s->recorder);
    }

--- a/app/src/screen.c
+++ b/app/src/screen.c
@@ -371,7 +371,7 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
    bool need_new_event;
    if (previous_skipped) {
        sc_fps_counter_add_skipped_frame(&screen->fps_counter);
-        // The SC_EVENT_NEW_FRAME triggered for the previous frame will consume
+        // The EVENT_NEW_FRAME triggered for the previous frame will consume
        // this new frame instead, unless the previous event failed
        need_new_event = screen->event_failed;
    } else {
@@ -380,7 +380,7 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,

    if (need_new_event) {
        static SDL_Event new_frame_event = {
-            .type = SC_EVENT_NEW_FRAME,
+            .type = EVENT_NEW_FRAME,
        };

        // Post the event on the UI thread
@@ -820,7 +820,7 @@ sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event) {
    bool relative_mode = sc_screen_is_relative_mode(screen);

    switch (event->type) {
-        case SC_EVENT_NEW_FRAME: {
+        case EVENT_NEW_FRAME: {
            bool ok = sc_screen_update_frame(screen);
            if (!ok) {
                LOGW("Frame update failed\n");
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -73,7 +73,6 @@ sc_server_params_destroy(struct sc_server_params *params) {
    free((char *) params->crop);
    free((char *) params->codec_options);
    free((char *) params->encoder_name);
-    free((char *) params->audio_encoder_name);
    free((char *) params->tcpip_dst);
 }

@@ -98,7 +97,6 @@ sc_server_params_copy(struct sc_server_params *dst,
    COPY(crop);
    COPY(codec_options);
    COPY(encoder_name);
-    COPY(audio_encoder_name);
    COPY(tcpip_dst);
 #undef COPY

@@ -167,10 +165,6 @@ sc_server_get_codec_name(enum sc_codec codec) {
            return "h265";
        case SC_CODEC_AV1:
            return "av1";
-        case SC_CODEC_OPUS:
-            return "opus";
-        case SC_CODEC_AAC:
-            return "aac";
        default:
            return NULL;
    }
@@ -219,24 +213,15 @@ execute_server(struct sc_server *server,
        cmd[count++] = p; \
    }

-    ADD_PARAM("scid=%08x", params->scid);
+    ADD_PARAM("uid=%08x", params->uid);
    ADD_PARAM("log_level=%s", log_level_to_server_string(params->log_level));
+    ADD_PARAM("bit_rate=%" PRIu32, params->bit_rate);

-    if (params->bit_rate) {
-        ADD_PARAM("bit_rate=%" PRIu32, params->bit_rate);
-    }
    if (!params->audio) {
        ADD_PARAM("audio=false");
-    } else if (params->audio_bit_rate) {
-        ADD_PARAM("audio_bit_rate=%" PRIu32, params->audio_bit_rate);
    }
-    if (params->video_codec != SC_CODEC_H264) {
-        ADD_PARAM("video_codec=%s",
-                  sc_server_get_codec_name(params->video_codec));
-    }
-    if (params->audio_codec != SC_CODEC_OPUS) {
-        ADD_PARAM("audio_codec=%s",
-            sc_server_get_codec_name(params->audio_codec));
+    if (params->codec != SC_CODEC_H264) {
+        ADD_PARAM("codec=%s", sc_server_get_codec_name(params->codec));
    }
    if (params->max_size) {
        ADD_PARAM("max_size=%" PRIu16, params->max_size);
@@ -273,9 +258,6 @@ execute_server(struct sc_server *server,
    if (params->encoder_name) {
        ADD_PARAM("encoder_name=%s", params->encoder_name);
    }
-    if (params->audio_encoder_name) {
-        ADD_PARAM("audio_encoder_name=%s", params->audio_encoder_name);
-    }
    if (params->power_off_on_close) {
        ADD_PARAM("power_off_on_close=true");
    }
@@ -839,7 +821,7 @@ run_server(void *data) {
    LOGD("Device serial: %s", serial);

    int r = asprintf(&server->device_socket_name, SC_SOCKET_NAME_PREFIX "%08x",
-                     params->scid);
+                     params->uid);
    if (r == -1) {
        LOG_OOM();
        goto error_connection_failed;
--- a/app/src/server.h
+++ b/app/src/server.h
@@ -22,21 +22,18 @@ struct sc_server_info {
 };

 struct sc_server_params {
-    uint32_t scid;
+    uint32_t uid;
    const char *req_serial;
    enum sc_log_level log_level;
-    enum sc_codec video_codec;
-    enum sc_codec audio_codec;
+    enum sc_codec codec;
    const char *crop;
    const char *codec_options;
    const char *encoder_name;
-    const char *audio_encoder_name;
    struct sc_port_range port_range;
    uint32_t tunnel_host;
    uint16_t tunnel_port;
    uint16_t max_size;
    uint32_t bit_rate;
-    uint32_t audio_bit_rate;
    uint16_t max_fps;
    int8_t lock_video_orientation;
    bool control;
--- a/app/src/trait/packet_sink.h
+++ b/app/src/trait/packet_sink.h
@@ -19,20 +19,9 @@ struct sc_packet_sink {
 };

 struct sc_packet_sink_ops {
-    /* The codec instance is static, it is valid until the end of the program */
    bool (*open)(struct sc_packet_sink *sink, const AVCodec *codec);
    void (*close)(struct sc_packet_sink *sink);
    bool (*push)(struct sc_packet_sink *sink, const AVPacket *packet);
-
-    /*/
-     * Called when the input stream has been disabled at runtime.
-     *
-     * If it is called, then open(), close() and push() will never be called.
-     *
-     * It is useful to notify the recorder that the requested audio stream has
-     * finally been disabled because the device could not capture it.
-     */
-    void (*disable)(struct sc_packet_sink *sink);
 };

 #endif
--- a/app/src/usb/scrcpy_otg.c
+++ b/app/src/usb/scrcpy_otg.c
@@ -22,7 +22,7 @@ sc_usb_on_disconnected(struct sc_usb *usb, void *userdata) {
    (void) userdata;

    SDL_Event event;
-    event.type = SC_EVENT_USB_DEVICE_DISCONNECTED;
+    event.type = EVENT_USB_DEVICE_DISCONNECTED;
    int ret = SDL_PushEvent(&event);
    if (ret < 0) {
        LOGE("Could not post USB disconnection event: %s", SDL_GetError());
@@ -34,7 +34,7 @@ event_loop(struct scrcpy_otg *s) {
    SDL_Event event;
    while (SDL_WaitEvent(&event)) {
        switch (event.type) {
-            case SC_EVENT_USB_DEVICE_DISCONNECTED:
+            case EVENT_USB_DEVICE_DISCONNECTED:
                LOGW("Device disconnected");
                return SCRCPY_EXIT_DISCONNECTED;
            case SDL_QUIT:
--- a/server/src/main/java/com/genymobile/scrcpy/AudioCodec.java
+++ b/server/src/main/java/com/genymobile/scrcpy/AudioCodec.java
@@ -3,8 +3,7 @@ package com.genymobile.scrcpy;
 import android.media.MediaFormat;

 public enum AudioCodec implements Codec {
-    OPUS(0x6f_70_75_73, "opus", MediaFormat.MIMETYPE_AUDIO_OPUS),
-    AAC(0x00_61_61_63, "aac", MediaFormat.MIMETYPE_AUDIO_AAC);
+    OPUS(0x6f_70_75_73, "opus", MediaFormat.MIMETYPE_AUDIO_OPUS);

    private final int id; // 4-byte ASCII representation of the name
    private final String name;
@@ -18,7 +17,7 @@ public enum AudioCodec implements Codec {

    @Override
    public Type getType() {
-        return Type.AUDIO;
+        return Type.VIDEO;
    }

    @Override
--- a/server/src/main/java/com/genymobile/scrcpy/AudioEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/AudioEncoder.java
@@ -11,17 +11,18 @@ import android.media.MediaRecorder;
 import android.os.Build;
 import android.os.Handler;
 import android.os.HandlerThread;
-import android.os.Looper;
+import android.os.SystemClock;

 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.atomic.AtomicBoolean;

 public final class AudioEncoder {

    private static class InputTask {
-        private final int index;
+        final int index;

        InputTask(int index) {
            this.index = index;
@@ -29,8 +30,8 @@ public final class AudioEncoder {
    }

    private static class OutputTask {
-        private final int index;
-        private final MediaCodec.BufferInfo bufferInfo;
+        final int index;
+        final MediaCodec.BufferInfo bufferInfo;

        OutputTask(int index, MediaCodec.BufferInfo bufferInfo) {
            this.index = index;
@@ -38,15 +39,18 @@ public final class AudioEncoder {
        }
    }

+    private static final String MIMETYPE = MediaFormat.MIMETYPE_AUDIO_OPUS;
    private static final int SAMPLE_RATE = 48000;
    private static final int CHANNELS = 2;
+    private static final int BIT_RATE = 128000;

-    private static final int BUFFER_MS = 15; // milliseconds
+    private static int BUFFER_MS = 15; // milliseconds
    private static final int BUFFER_SIZE = SAMPLE_RATE * CHANNELS * BUFFER_MS / 1000;

-    private final Streamer streamer;
-    private final int bitRate;
-    private final String encoderName;
+    private AudioRecord recorder;
+    private MediaCodec mediaCodec;
+
+    private final AtomicBoolean cleanUpDone = new AtomicBoolean(false);

    // Capacity of 64 is in practice "infinite" (it is limited by the number of available MediaCodec buffers, typically 4).
    // So many pending tasks would lead to an unacceptable delay anyway.
@@ -61,12 +65,6 @@ public final class AudioEncoder {

    private boolean ended;

-    public AudioEncoder(Streamer streamer, int bitRate, String encoderName) {
-        this.streamer = streamer;
-        this.bitRate = bitRate;
-        this.encoderName = encoderName;
-    }
-
    private static AudioFormat createAudioFormat() {
        AudioFormat.Builder builder = new AudioFormat.Builder();
        builder.setEncoding(AudioFormat.ENCODING_PCM_16BIT);
@@ -89,17 +87,17 @@ public final class AudioEncoder {
        return builder.build();
    }

-    private static MediaFormat createFormat(String mimeType, int bitRate) {
+    private static MediaFormat createFormat() {
        MediaFormat format = new MediaFormat();
-        format.setString(MediaFormat.KEY_MIME, mimeType);
-        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
+        format.setString(MediaFormat.KEY_MIME, MIMETYPE);
+        format.setInteger(MediaFormat.KEY_BIT_RATE, BIT_RATE);
        format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, CHANNELS);
        format.setInteger(MediaFormat.KEY_SAMPLE_RATE, SAMPLE_RATE);
        return format;
    }

    @TargetApi(Build.VERSION_CODES.N)
-    private void inputThread(MediaCodec mediaCodec, AudioRecord recorder) throws IOException, InterruptedException {
+    private void inputThread() throws IOException, InterruptedException {
        final AudioTimestamp timestamp = new AudioTimestamp();
        long previousPts = 0;
        long nextPts = 0;
@@ -143,14 +141,12 @@ public final class AudioEncoder {
        }
    }

-    private void outputThread(MediaCodec mediaCodec) throws IOException, InterruptedException {
-        streamer.writeHeader();
-
+    private void outputThread() throws IOException, InterruptedException {
        while (!Thread.currentThread().isInterrupted()) {
            OutputTask task = outputTasks.take();
            ByteBuffer buffer = mediaCodec.getOutputBuffer(task.index);
            try {
-                streamer.writePacket(buffer, task.bufferInfo);
+                Ln.i("Audio packet [pts=" + task.bufferInfo.presentationTimeUs + "] " + buffer.remaining() + " bytes");
            } finally {
                mediaCodec.releaseOutputBuffer(task.index, false);
            }
@@ -162,7 +158,7 @@ public final class AudioEncoder {
            try {
                encode();
            } catch (IOException e) {
-                Ln.e("Audio encoding error", e);
+                // this is expected on close
            } finally {
                Ln.d("Audio encoder stopped");
            }
@@ -200,39 +196,25 @@ public final class AudioEncoder {

    @TargetApi(Build.VERSION_CODES.M)
    public void encode() throws IOException {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
-            Ln.w("Audio disabled: it is not supported before Android 11");
-            streamer.writeDisableStream();
-            return;
-        }
+        mediaCodec = MediaCodec.createEncoderByType(MIMETYPE); // may throw IOException

-        MediaCodec mediaCodec = null;
-        AudioRecord recorder = null;
-
-        boolean mediaCodecStarted = false;
-        boolean recorderStarted = false;
        try {
-            Codec codec = streamer.getCodec();
-            mediaCodec = createMediaCodec(codec, encoderName);
            recorder = createAudioRecord();

            mediaCodecThread = new HandlerThread("AudioEncoder");
            mediaCodecThread.start();

-            MediaFormat format = createFormat(codec.getMimeType(), bitRate);
+            MediaFormat format = createFormat();
            mediaCodec.setCallback(new EncoderCallback(), new Handler(mediaCodecThread.getLooper()));
            mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);

            recorder.startRecording();
-            recorderStarted = true;

-            final MediaCodec mediaCodecRef = mediaCodec;
-            final AudioRecord recorderRef = recorder;
            inputThread = new Thread(() -> {
                try {
-                    inputThread(mediaCodecRef, recorderRef);
+                    inputThread();
                } catch (IOException | InterruptedException e) {
-                    Ln.e("Audio capture error", e);
+                    // this is expected on close
                } finally {
                    end();
                }
@@ -240,90 +222,50 @@ public final class AudioEncoder {

            outputThread = new Thread(() -> {
                try {
-                    outputThread(mediaCodecRef);
-                } catch (InterruptedException e) {
+                    outputThread();
+                } catch (IOException | InterruptedException e) {
                    // this is expected on close
-                } catch (IOException e) {
-                    // Broken pipe is expected on close, because the socket is closed by the client
-                    if (!IO.isBrokenPipe(e)) {
-                        Ln.e("Audio encoding error", e);
-                    }
                } finally {
                    end();
                }
            });

            mediaCodec.start();
-            mediaCodecStarted = true;
            inputThread.start();
            outputThread.start();
-
-            waitEnded();
-        } catch (ConfigurationException e) {
-            // Do not print stack trace, a user-friendly error-message has already been logged
-        } finally {
-            if (!recorderStarted) {
-                // Notify the client that the audio could not be captured
-                streamer.writeDisableStream();
-            }
-
-            // Cleanup everything (either at the end or on error at any step of the initialization)
-            if (mediaCodecThread != null) {
-                Looper looper = mediaCodecThread.getLooper();
-                if (looper != null) {
-                    looper.quitSafely();
-                }
-            }
-            if (inputThread != null) {
-                inputThread.interrupt();
-            }
-            if (outputThread != null) {
-                outputThread.interrupt();
-            }
-
-            try {
-                if (mediaCodecThread != null) {
-                    mediaCodecThread.join();
-                }
-                if (inputThread != null) {
-                    inputThread.join();
-                }
-                if (outputThread != null) {
-                    outputThread.join();
-                }
-            } catch (InterruptedException e) {
-                // Should never happen
-                throw new AssertionError(e);
-            }
-
-            if (mediaCodec != null) {
-                if (mediaCodecStarted) {
-                    mediaCodec.stop();
-                }
-                mediaCodec.release();
-            }
+        } catch (Throwable e) {
+            mediaCodec.release();
            if (recorder != null) {
-                if (recorderStarted) {
-                    recorder.stop();
-                }
                recorder.release();
            }
+            throw e;
+        }
+
+        try {
+            waitEnded();
+        } finally {
+            cleanUp();
        }
    }

-    private static MediaCodec createMediaCodec(Codec codec, String encoderName) throws IOException, ConfigurationException {
-        if (encoderName != null) {
-            Ln.d("Creating audio encoder by name: '" + encoderName + "'");
-            try {
-                return MediaCodec.createByCodecName(encoderName);
-            } catch (IllegalArgumentException e) {
-                Ln.e(CodecUtils.buildUnknownEncoderMessage(codec, encoderName));
-                throw new ConfigurationException("Unknown encoder: " + encoderName);
-            }
+    private void cleanUp() {
+        mediaCodecThread.getLooper().quit();
+        inputThread.interrupt();
+        outputThread.interrupt();
+
+        try {
+            mediaCodecThread.join();
+            inputThread.join();
+            outputThread.join();
+        } catch (InterruptedException e) {
+            // Should never happen
+            throw new AssertionError(e);
        }
-        MediaCodec mediaCodec = MediaCodec.createEncoderByType(codec.getMimeType());
-        Ln.d("Using audio encoder: '" + mediaCodec.getName() + "'");
-        return mediaCodec;
+
+        mediaCodec.stop();
+        mediaCodec.release();
+        recorder.stop();
+        recorder.release();
    }

    private class EncoderCallback extends MediaCodec.Callback {
--- a/server/src/main/java/com/genymobile/scrcpy/Codec.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Codec.java
@@ -2,16 +2,10 @@ package com.genymobile.scrcpy;

 public interface Codec {

-    enum Type {
-        VIDEO,
-        AUDIO,
-    }
+    enum Type {VIDEO}

    Type getType();
-
    int getId();
-
    String getName();
-
    String getMimeType();
 }
--- a/server/src/main/java/com/genymobile/scrcpy/CodecUtils.java
+++ b/server/src/main/java/com/genymobile/scrcpy/CodecUtils.java
@@ -1,40 +0,0 @@
-package com.genymobile.scrcpy;
-
-import android.media.MediaCodecInfo;
-import android.media.MediaCodecList;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-public final class CodecUtils {
-
-    private CodecUtils() {
-        // not instantiable
-    }
-
-    public static String buildUnknownEncoderMessage(Codec codec, String encoderName) {
-        StringBuilder msg = new StringBuilder("Encoder '").append(encoderName).append("' for ").append(codec.getName()).append(" not found");
-        MediaCodecInfo[] encoders = listEncoders(codec.getMimeType());
-        if (encoders != null && encoders.length > 0) {
-            msg.append("\nTry to use one of the available encoders:");
-            String codecOption = codec.getType() == Codec.Type.VIDEO ? "video-codec" : "audio-codec";
-            for (MediaCodecInfo encoder : encoders) {
-                msg.append("\n    scrcpy --").append(codecOption).append("=").append(codec.getName());
-                msg.append(" --encoder='").append(encoder.getName()).append("'");
-            }
-        }
-        return msg.toString();
-    }
-
-    private static MediaCodecInfo[] listEncoders(String mimeType) {
-        List<MediaCodecInfo> result = new ArrayList<>();
-        MediaCodecList list = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
-        for (MediaCodecInfo codecInfo : list.getCodecInfos()) {
-            if (codecInfo.isEncoder() && Arrays.asList(codecInfo.getSupportedTypes()).contains(mimeType)) {
-                result.add(codecInfo);
-            }
-        }
-        return result.toArray(new MediaCodecInfo[result.size()]);
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/ConfigurationException.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ConfigurationException.java
@@ -1,7 +0,0 @@
-package com.genymobile.scrcpy;
-
-public class ConfigurationException extends Exception {
-    public ConfigurationException(String message) {
-        super(message);
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
@@ -51,17 +51,17 @@ public final class DesktopConnection implements Closeable {
        return localSocket;
    }

-    private static String getSocketName(int scid) {
-        if (scid == -1) {
-            // If no SCID is set, use "scrcpy" to simplify using scrcpy-server alone
+    private static String getSocketName(int uid) {
+        if (uid == -1) {
+            // If no UID is set, use "scrcpy" to simplify using scrcpy-server alone
            return SOCKET_NAME_PREFIX;
        }

-        return SOCKET_NAME_PREFIX + String.format("_%08x", scid);
+        return SOCKET_NAME_PREFIX + String.format("_%08x", uid);
    }

-    public static DesktopConnection open(int scid, boolean tunnelForward, boolean audio, boolean control, boolean sendDummyByte) throws IOException {
-        String socketName = getSocketName(scid);
+    public static DesktopConnection open(int uid, boolean tunnelForward, boolean audio, boolean control, boolean sendDummyByte) throws IOException {
+        String socketName = getSocketName(uid);

        LocalSocket videoSocket = null;
        LocalSocket audioSocket = null;
--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@@ -61,12 +61,12 @@ public final class Device {

    private final boolean supportsInputEvents;

-    public Device(Options options) throws ConfigurationException {
+    public Device(Options options) {
        displayId = options.getDisplayId();
        DisplayInfo displayInfo = ServiceManager.getDisplayManager().getDisplayInfo(displayId);
        if (displayInfo == null) {
-            Ln.e(buildUnknownDisplayIdMessage(displayId));
-            throw new ConfigurationException("Unknown display id: " + displayId);
+            int[] displayIds = ServiceManager.getDisplayManager().getDisplayIds();
+            throw new InvalidDisplayIdException(displayId, displayIds);
        }

        int displayInfoFlags = displayInfo.getFlags();
@@ -130,18 +130,6 @@ public final class Device {
        }
    }

-    private static String buildUnknownDisplayIdMessage(int displayId) {
-        StringBuilder msg = new StringBuilder("Display ").append(displayId).append(" not found");
-        int[] displayIds = ServiceManager.getDisplayManager().getDisplayIds();
-        if (displayIds != null && displayIds.length > 0) {
-            msg.append("\nTry to use one of the available display ids:");
-            for (int id : displayIds) {
-                msg.append("\n    scrcpy --display=").append(id);
-            }
-        }
-        return msg.toString();
-    }
-
    public synchronized void setMaxSize(int newMaxSize) {
        maxSize = newMaxSize;
        screenInfo = ScreenInfo.computeScreenInfo(screenInfo.getReverseVideoRotation(), deviceSize, crop, newMaxSize, lockVideoOrientation);
--- a/server/src/main/java/com/genymobile/scrcpy/IO.java
+++ b/server/src/main/java/com/genymobile/scrcpy/IO.java
@@ -48,9 +48,4 @@ public final class IO {
        }
        return builder.toString();
    }
-
-    public static boolean isBrokenPipe(IOException e) {
-        Throwable cause = e.getCause();
-        return cause instanceof ErrnoException && ((ErrnoException) cause).errno == OsConstants.EPIPE;
-    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/InvalidDisplayIdException.java
+++ b/server/src/main/java/com/genymobile/scrcpy/InvalidDisplayIdException.java
@@ -0,0 +1,21 @@
+package com.genymobile.scrcpy;
+
+public class InvalidDisplayIdException extends RuntimeException {
+
+    private final int displayId;
+    private final int[] availableDisplayIds;
+
+    public InvalidDisplayIdException(int displayId, int[] availableDisplayIds) {
+        super("There is no display having id " + displayId);
+        this.displayId = displayId;
+        this.availableDisplayIds = availableDisplayIds;
+    }
+
+    public int getDisplayId() {
+        return displayId;
+    }
+
+    public int[] getAvailableDisplayIds() {
+        return availableDisplayIds;
+    }
+}
--- a/server/src/main/java/com/genymobile/scrcpy/InvalidEncoderException.java
+++ b/server/src/main/java/com/genymobile/scrcpy/InvalidEncoderException.java
@@ -0,0 +1,23 @@
+package com.genymobile.scrcpy;
+
+import android.media.MediaCodecInfo;
+
+public class InvalidEncoderException extends RuntimeException {
+
+    private final String name;
+    private final MediaCodecInfo[] availableEncoders;
+
+    public InvalidEncoderException(String name, MediaCodecInfo[] availableEncoders) {
+        super("There is no encoder having name '" + name + '"');
+        this.name = name;
+        this.availableEncoders = availableEncoders;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public MediaCodecInfo[] getAvailableEncoders() {
+        return availableEncoders;
+    }
+}
--- a/server/src/main/java/com/genymobile/scrcpy/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@@ -7,13 +7,11 @@ import java.util.List;
 public class Options {

    private Ln.Level logLevel = Ln.Level.DEBUG;
-    private int scid = -1; // 31-bit non-negative value, or -1
+    private int uid = -1; // 31-bit non-negative value, or -1
    private boolean audio = true;
    private int maxSize;
-    private VideoCodec videoCodec = VideoCodec.H264;
-    private AudioCodec audioCodec = AudioCodec.OPUS;
+    private VideoCodec codec = VideoCodec.H264;
    private int bitRate = 8000000;
-    private int audioBitRate = 196000;
    private int maxFps;
    private int lockVideoOrientation = -1;
    private boolean tunnelForward;
@@ -24,7 +22,6 @@ public class Options {
    private boolean stayAwake;
    private List<CodecOption> codecOptions;
    private String encoderName;
-    private String audioEncoderName;
    private boolean powerOffScreenOnClose;
    private boolean clipboardAutosync = true;
    private boolean downsizeOnError = true;
@@ -45,12 +42,12 @@ public class Options {
        this.logLevel = logLevel;
    }

-    public int getScid() {
-        return scid;
+    public int getUid() {
+        return uid;
    }

-    public void setScid(int scid) {
-        this.scid = scid;
+    public void setUid(int uid) {
+        this.uid = uid;
    }

    public boolean getAudio() {
@@ -69,20 +66,12 @@ public class Options {
        this.maxSize = maxSize;
    }

-    public VideoCodec getVideoCodec() {
-        return videoCodec;
+    public VideoCodec getCodec() {
+        return codec;
    }

-    public void setVideoCodec(VideoCodec videoCodec) {
-        this.videoCodec = videoCodec;
-    }
-
-    public AudioCodec getAudioCodec() {
-        return audioCodec;
-    }
-
-    public void setAudioCodec(AudioCodec audioCodec) {
-        this.audioCodec = audioCodec;
+    public void setCodec(VideoCodec codec) {
+        this.codec = codec;
    }

    public int getBitRate() {
@@ -93,14 +82,6 @@ public class Options {
        this.bitRate = bitRate;
    }

-    public int getAudioBitRate() {
-        return audioBitRate;
-    }
-
-    public void setAudioBitRate(int audioBitRate) {
-        this.audioBitRate = audioBitRate;
-    }
-
    public int getMaxFps() {
        return maxFps;
    }
@@ -181,14 +162,6 @@ public class Options {
        this.encoderName = encoderName;
    }

-    public String getAudioEncoderName() {
-        return audioEncoderName;
-    }
-
-    public void setAudioEncoderName(String audioEncoderName) {
-        this.audioEncoderName = audioEncoderName;
-    }
-
    public void setPowerOffScreenOnClose(boolean powerOffScreenOnClose) {
        this.powerOffScreenOnClose = powerOffScreenOnClose;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@@ -5,6 +5,7 @@ import com.genymobile.scrcpy.wrappers.SurfaceControl;
 import android.graphics.Rect;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
+import android.media.MediaCodecList;
 import android.media.MediaFormat;
 import android.os.Build;
 import android.os.IBinder;
@@ -13,6 +14,8 @@ import android.view.Surface;

 import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;

@@ -39,8 +42,8 @@ public class ScreenEncoder implements Device.RotationListener {
    private boolean firstFrameSent;
    private int consecutiveErrors;

-    public ScreenEncoder(Device device, Streamer streamer, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
-            boolean downsizeOnError) {
+    public ScreenEncoder(Device device, Streamer streamer, int bitRate, int maxFps, List<CodecOption> codecOptions,
+            String encoderName, boolean downsizeOnError) {
        this.device = device;
        this.streamer = streamer;
        this.bitRate = bitRate;
@@ -59,10 +62,10 @@ public class ScreenEncoder implements Device.RotationListener {
        return rotationChanged.getAndSet(false);
    }

-    public void streamScreen() throws IOException, ConfigurationException {
-        Codec codec = streamer.getCodec();
-        MediaCodec mediaCodec = createMediaCodec(codec, encoderName);
-        MediaFormat format = createFormat(codec.getMimeType(), bitRate, maxFps, codecOptions);
+    public void streamScreen() throws IOException {
+        String videoMimeType = streamer.getCodec().getMimeType();
+        MediaCodec codec = createCodec(videoMimeType, encoderName);
+        MediaFormat format = createFormat(videoMimeType, bitRate, maxFps, codecOptions);
        IBinder display = createDisplay();
        device.setRotationListener(this);

@@ -81,8 +84,8 @@ public class ScreenEncoder implements Device.RotationListener {

                Surface surface = null;
                try {
-                    mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
-                    surface = mediaCodec.createInputSurface();
+                    codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+                    surface = codec.createInputSurface();

                    // does not include the locked video orientation
                    Rect unlockedVideoRect = screenInfo.getUnlockedVideoSize().toRect();
@@ -90,11 +93,11 @@ public class ScreenEncoder implements Device.RotationListener {
                    int layerStack = device.getLayerStack();
                    setDisplaySurface(display, surface, videoRotation, contentRect, unlockedVideoRect, layerStack);

-                    mediaCodec.start();
+                    codec.start();

-                    alive = encode(mediaCodec, streamer);
+                    alive = encode(codec, streamer);
                    // do not call stop() on exception, it would trigger an IllegalStateException
-                    mediaCodec.stop();
+                    codec.stop();
                } catch (IllegalStateException | IllegalArgumentException e) {
                    Ln.e("Encoding error: " + e.getClass().getName() + ": " + e.getMessage());
                    if (!prepareRetry(device, screenInfo)) {
@@ -103,14 +106,14 @@ public class ScreenEncoder implements Device.RotationListener {
                    Ln.i("Retrying...");
                    alive = true;
                } finally {
-                    mediaCodec.reset();
+                    codec.reset();
                    if (surface != null) {
                        surface.release();
                    }
                }
            } while (alive);
        } finally {
-            mediaCodec.release();
+            codec.release();
            device.setRotationListener(null);
            SurfaceControl.destroyDisplay(display);
        }
@@ -196,19 +199,30 @@ public class ScreenEncoder implements Device.RotationListener {
        return !eof;
    }

-    private static MediaCodec createMediaCodec(Codec codec, String encoderName) throws IOException, ConfigurationException {
+    private static MediaCodecInfo[] listEncoders(String videoMimeType) {
+        List<MediaCodecInfo> result = new ArrayList<>();
+        MediaCodecList list = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
+        for (MediaCodecInfo codecInfo : list.getCodecInfos()) {
+            if (codecInfo.isEncoder() && Arrays.asList(codecInfo.getSupportedTypes()).contains(videoMimeType)) {
+                result.add(codecInfo);
+            }
+        }
+        return result.toArray(new MediaCodecInfo[result.size()]);
+    }
+
+    private static MediaCodec createCodec(String videoMimeType, String encoderName) throws IOException {
        if (encoderName != null) {
            Ln.d("Creating encoder by name: '" + encoderName + "'");
            try {
                return MediaCodec.createByCodecName(encoderName);
            } catch (IllegalArgumentException e) {
-                Ln.e(CodecUtils.buildUnknownEncoderMessage(codec, encoderName));
-                throw new ConfigurationException("Unknown encoder: " + encoderName);
+                MediaCodecInfo[] encoders = listEncoders(videoMimeType);
+                throw new InvalidEncoderException(encoderName, encoders);
            }
        }
-        MediaCodec mediaCodec = MediaCodec.createEncoderByType(codec.getMimeType());
-        Ln.d("Using encoder: '" + mediaCodec.getName() + "'");
-        return mediaCodec;
+        MediaCodec codec = MediaCodec.createEncoderByType(videoMimeType);
+        Ln.d("Using encoder: '" + codec.getName() + "'");
+        return codec;
    }

    private static void setCodecOption(MediaFormat format, CodecOption codecOption) {
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@@ -1,6 +1,7 @@
 package com.genymobile.scrcpy;

 import android.graphics.Rect;
+import android.media.MediaCodecInfo;
 import android.os.BatteryManager;
 import android.os.Build;

@@ -58,14 +59,14 @@ public final class Server {
        }
    }

-    private static void scrcpy(Options options) throws IOException, ConfigurationException {
+    private static void scrcpy(Options options) throws IOException {
        Ln.i("Device: " + Build.MANUFACTURER + " " + Build.MODEL + " (Android " + Build.VERSION.RELEASE + ")");
        final Device device = new Device(options);
        List<CodecOption> codecOptions = options.getCodecOptions();

        Thread initThread = startInitThread(options);

-        int scid = options.getScid();
+        int uid = options.getUid();
        boolean tunnelForward = options.isTunnelForward();
        boolean control = options.getControl();
        boolean audio = options.getAudio();
@@ -92,15 +93,14 @@ public final class Server {
            Workarounds.fillAppInfo();
        }

-        Controller controller = null;
-        AudioEncoder audioEncoder = null;
-
-        try (DesktopConnection connection = DesktopConnection.open(scid, tunnelForward, audio, control, sendDummyByte)) {
+        try (DesktopConnection connection = DesktopConnection.open(uid, tunnelForward, audio, control, sendDummyByte)) {
+            VideoCodec codec = options.getCodec();
            if (options.getSendDeviceMeta()) {
                Size videoSize = device.getScreenInfo().getVideoSize();
                connection.sendDeviceMeta(Device.getDeviceName(), videoSize.getWidth(), videoSize.getHeight());
            }

+            Controller controller = null;
            if (control) {
                controller = new Controller(device, connection, options.getClipboardAutosync(), options.getPowerOn());
                controller.start();
@@ -109,46 +109,41 @@ public final class Server {
                device.setClipboardListener(text -> controllerRef.getSender().pushClipboardText(text));
            }

+            AudioEncoder audioEncoder = null;
            if (audio) {
-                Streamer audioStreamer = new Streamer(connection.getAudioFd(), options.getAudioCodec(), options.getSendCodecId(),
-                        options.getSendFrameMeta());
-                audioEncoder = new AudioEncoder(audioStreamer, options.getAudioBitRate(), options.getAudioEncoderName());
+                audioEncoder = new AudioEncoder();
                audioEncoder.start();
            }

-            Streamer videoStreamer = new Streamer(connection.getVideoFd(), options.getVideoCodec(), options.getSendCodecId(),
-                    options.getSendFrameMeta());
-            ScreenEncoder screenEncoder = new ScreenEncoder(device, videoStreamer, options.getBitRate(), options.getMaxFps(), codecOptions,
-                    options.getEncoderName(), options.getDownsizeOnError());
+            Streamer videoStreamer = new Streamer(connection.getVideoFd(), codec, options.getSendCodecId(), options.getSendFrameMeta());
+            ScreenEncoder screenEncoder = new ScreenEncoder(device, videoStreamer, options.getBitRate(), options.getMaxFps(),
+                    codecOptions, options.getEncoderName(), options.getDownsizeOnError());
            try {
                // synchronous
                screenEncoder.streamScreen();
            } catch (IOException e) {
-                // Broken pipe is expected on close, because the socket is closed by the client
-                if (!IO.isBrokenPipe(e)) {
-                    Ln.e("Video encoding error", e);
-                }
-            }
-        } finally {
-            Ln.d("Screen streaming stopped");
-            initThread.interrupt();
-            if (audioEncoder != null) {
-                audioEncoder.stop();
-            }
-            if (controller != null) {
-                controller.stop();
-            }
-
-            try {
-                initThread.join();
+                // this is expected on close
+            } finally {
+                Ln.d("Screen streaming stopped");
+                initThread.interrupt();
                if (audioEncoder != null) {
-                    audioEncoder.join();
+                    audioEncoder.stop();
                }
                if (controller != null) {
-                    controller.join();
+                    controller.stop();
+                }
+
+                try {
+                    initThread.join();
+                    if (audioEncoder != null) {
+                        audioEncoder.join();
+                    }
+                    if (controller != null) {
+                        controller.join();
+                    }
+                } catch (InterruptedException e) {
+                    // ignore
                }
-            } catch (InterruptedException e) {
-                // ignore
            }
        }
    }
@@ -159,7 +154,6 @@ public final class Server {
        return thread;
    }

-    @SuppressWarnings("MethodLength")
    private static Options createOptions(String... args) {
        if (args.length < 1) {
            throw new IllegalArgumentException("Missing client version");
@@ -182,12 +176,12 @@ public final class Server {
            String key = arg.substring(0, equalIndex);
            String value = arg.substring(equalIndex + 1);
            switch (key) {
-                case "scid":
-                    int scid = Integer.parseInt(value, 0x10);
-                    if (scid < -1) {
-                        throw new IllegalArgumentException("scid may not be negative (except -1 for 'none'): " + scid);
+                case "uid":
+                    int uid = Integer.parseInt(value, 0x10);
+                    if (uid < -1) {
+                        throw new IllegalArgumentException("uid may not be negative (except -1 for 'none'): " + uid);
                    }
-                    options.setScid(scid);
+                    options.setUid(uid);
                    break;
                case "log_level":
                    Ln.Level level = Ln.Level.valueOf(value.toUpperCase(Locale.ENGLISH));
@@ -197,19 +191,12 @@ public final class Server {
                    boolean audio = Boolean.parseBoolean(value);
                    options.setAudio(audio);
                    break;
-                case "video_codec":
-                    VideoCodec videoCodec = VideoCodec.findByName(value);
-                    if (videoCodec == null) {
+                case "codec":
+                    VideoCodec codec = VideoCodec.findByName(value);
+                    if (codec == null) {
                        throw new IllegalArgumentException("Video codec " + value + " not supported");
                    }
-                    options.setVideoCodec(videoCodec);
-                    break;
-                case "audio_codec":
-                    AudioCodec audioCodec = AudioCodec.findByName(value);
-                    if (audioCodec == null) {
-                        throw new IllegalArgumentException("Audio codec " + value + " not supported");
-                    }
-                    options.setAudioCodec(audioCodec);
+                    options.setCodec(codec);
                    break;
                case "max_size":
                    int maxSize = Integer.parseInt(value) & ~7; // multiple of 8
@@ -219,10 +206,6 @@ public final class Server {
                    int bitRate = Integer.parseInt(value);
                    options.setBitRate(bitRate);
                    break;
-                case "audio_bit_rate":
-                    int audioBitRate = Integer.parseInt(value);
-                    options.setAudioBitRate(audioBitRate);
-                    break;
                case "max_fps":
                    int maxFps = Integer.parseInt(value);
                    options.setMaxFps(maxFps);
@@ -264,10 +247,6 @@ public final class Server {
                        options.setEncoderName(value);
                    }
                    break;
-                case "audio_encoder_name":
-                    if (!value.isEmpty()) {
-                        options.setAudioEncoderName(value);
-                    }
                case "power_off_on_close":
                    boolean powerOffScreenOnClose = Boolean.parseBoolean(value);
                    options.setPowerOffScreenOnClose(powerOffScreenOnClose);
@@ -338,19 +317,38 @@ public final class Server {
        return new Rect(x, y, x + width, y + height);
    }

+    private static void suggestFix(Throwable e) {
+        if (e instanceof InvalidDisplayIdException) {
+            InvalidDisplayIdException idie = (InvalidDisplayIdException) e;
+            int[] displayIds = idie.getAvailableDisplayIds();
+            if (displayIds != null && displayIds.length > 0) {
+                Ln.e("Try to use one of the available display ids:");
+                for (int id : displayIds) {
+                    Ln.e("    scrcpy --display " + id);
+                }
+            }
+        } else if (e instanceof InvalidEncoderException) {
+            InvalidEncoderException iee = (InvalidEncoderException) e;
+            MediaCodecInfo[] encoders = iee.getAvailableEncoders();
+            if (encoders != null && encoders.length > 0) {
+                Ln.e("Try to use one of the available encoders:");
+                for (MediaCodecInfo encoder : encoders) {
+                    Ln.e("    scrcpy --encoder '" + encoder.getName() + "'");
+                }
+            }
+        }
+    }
+
    public static void main(String... args) throws Exception {
        Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
            Ln.e("Exception on thread " + t, e);
+            suggestFix(e);
        });

        Options options = createOptions(args);

        Ln.initLogLevel(options.getLogLevel());

-        try {
-            scrcpy(options);
-        } catch (ConfigurationException e) {
-            // Do not print stack trace, a user-friendly error-message has already been logged
-        }
+        scrcpy(options);
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Streamer.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Streamer.java
@@ -11,8 +11,6 @@ public final class Streamer {
    private static final long PACKET_FLAG_CONFIG = 1L << 63;
    private static final long PACKET_FLAG_KEY_FRAME = 1L << 62;

-    private static final long AOPUSHDR = 0x5244485355504F41L; // "AOPUSHDR" in ASCII (little-endian)
-
    private final FileDescriptor fd;
    private final Codec codec;
    private final boolean sendCodecId;
@@ -40,17 +38,7 @@ public final class Streamer {
        }
    }

-    public void writeDisableStream() throws IOException {
-        // Writing 0 (32-bit) as codec-id means that the device disables the stream (because it could not capture)
-        byte[] zeros = new byte[4];
-        IO.writeFully(fd, zeros, 0, zeros.length);
-    }
-
    public void writePacket(ByteBuffer codecBuffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
-        if (codec == AudioCodec.OPUS) {
-            fixOpusConfigPacket(codecBuffer, bufferInfo);
-        }
-
        if (sendFrameMeta) {
            writeFrameMeta(fd, bufferInfo, codecBuffer.remaining());
        }
@@ -76,46 +64,4 @@ public final class Streamer {
        headerBuffer.flip();
        IO.writeFully(fd, headerBuffer);
    }
-
-    private static void fixOpusConfigPacket(ByteBuffer buffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
-        // Here is an example of the config packet received for an OPUS stream:
-        //
-        // 00000000  41 4f 50 55 53 48 44 52  13 00 00 00 00 00 00 00  |AOPUSHDR........|
-        // -------------- BELOW IS THE PART WE MUST PUT AS EXTRADATA  -------------------
-        // 00000010  4f 70 75 73 48 65 61 64  01 01 38 01 80 bb 00 00  |OpusHead..8.....|
-        // 00000020  00 00 00                                          |...             |
-        // ------------------------------------------------------------------------------
-        // 00000020           41 4f 50 55 53  44 4c 59 08 00 00 00 00  |   AOPUSDLY.....|
-        // 00000030  00 00 00 a0 2e 63 00 00  00 00 00 41 4f 50 55 53  |.....c.....AOPUS|
-        // 00000040  50 52 4c 08 00 00 00 00  00 00 00 00 b4 c4 04 00  |PRL.............|
-        // 00000050  00 00 00                                          |...|
-        //
-        // Each "section" is prefixed by a 64-bit ID and a 64-bit length.
-
-        boolean isConfig = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0;
-        if (!isConfig) {
-            return;
-        }
-
-        while (buffer.remaining() >= 16) {
-            long id = buffer.getLong();
-            long sizeLong = buffer.getLong();
-            if (sizeLong < 0 || sizeLong >= 0x7FFFFFFF) {
-                throw new IOException("Invalid block size in OPUS header: " + sizeLong);
-            }
-            int size = (int) sizeLong;
-            if (id == AOPUSHDR) {
-                if (buffer.remaining() < size) {
-                    throw new IOException("Not enough data in OPUS header (invalid size: " + size + ")");
-                }
-                // Set the buffer to point to the OPUS header slice
-                buffer.limit(buffer.position() + size);
-                return;
-            }
-
-            buffer.position(buffer.position() + size);
-        }
-
-        throw new IOException("OPUS header not found");
-    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
@@ -2,6 +2,7 @@ package com.genymobile.scrcpy;

 import android.annotation.SuppressLint;
 import android.app.Application;
+import android.app.Instrumentation;
 import android.content.ContextWrapper;
 import android.content.pm.ApplicationInfo;
 import android.os.Looper;
--- a/u/.ninja_deps
+++ b/u/.ninja_deps
--- a/u/.ninja_log
+++ b/u/.ninja_log
@@ -1,62 +0,0 @@
-# ninja log v5
-0	243	1542027815	build.ninja	ef03cd8523486e97
-0	58	1542027815	app/app@@scrcpy@exe/src_str_util.c.o	2aa692e7aa83914
-0	87	1542027815	app/app@@scrcpy@exe/src_sys_unix_net.c.o	7ea14bd07e90ff97
-0	91	1542027815	app/app@@scrcpy@exe/src_sys_unix_command.c.o	dd44ba15cc3d6a7e
-1	113	1542027815	app/app@@scrcpy@exe/src_command.c.o	1eaa0f061a5c0447
-0	114	1542027815	app/app@@scrcpy@exe/src_server.c.o	8b376071b5e0aaf1
-1	117	1542027815	app/app@@scrcpy@exe/src_controller.c.o	907de440054c77e7
-1	146	1542027815	app/app@@scrcpy@exe/src_control_event.c.o	fcfa5a6c322ebf8b
-91	202	1542027815	app/app@@scrcpy@exe/src_device.c.o	9ac9441f4f2e4d54
-58	215	1542027815	app/app@@scrcpy@exe/src_convert.c.o	9de268e9b915094e
-115	219	1542027815	app/app@@scrcpy@exe/src_fps_counter.c.o	22b968c51acd256b
-114	235	1542027815	app/app@@scrcpy@exe/src_file_handler.c.o	11e303a26f189d9a
-117	286	1542027815	app/app@@scrcpy@exe/src_frames.c.o	3c5c4dbee035e5ab
-88	319	1542027815	app/app@@scrcpy@exe/src_decoder.c.o	60c1438cf7786895
-202	338	1542027815	app/app@@scrcpy@exe/src_lock_util.c.o	9265bcc92f144427
-215	367	1542027815	app/app@@scrcpy@exe/src_net.c.o	718f65aa73583163
-220	408	1542027815	app/app@@scrcpy@exe/src_recorder.c.o	676a7500fb0d45cb
-1	470	1542027815	app/app@@scrcpy@exe/src_tiny_xpm.c.o	91851ad29940a4b1
-286	485	1542027815	app/app@@test_control_event_queue@exe/tests_test_control_event_queue.c.o	46bff52a98c0b5ca
-319	487	1542027815	app/app@@test_control_event_queue@exe/src_control_event.c.o	76492af89a914173
-1	488	1542027815	app/app@@scrcpy@exe/src_main.c.o	e7dc8583797471c5
-367	488	1542027815	app/app@@test_control_event_serialize@exe/src_control_event.c.o	fcff2e1105474edf
-0	497	1542027815	app/app@@scrcpy@exe/src_screen.c.o	329c18ec2111c8ff
-408	515	1542027815	app/app@@test_strutil@exe/tests_test_strutil.c.o	15440f4bca20c50d
-338	517	1542027815	app/app@@test_control_event_serialize@exe/tests_test_control_event_serialize.c.o	baa0b48891372fcc
-470	525	1542027815	app/app@@test_strutil@exe/src_str_util.c.o	fcb3a91d36e23e11
-525	561	1542027815	app/test_strutil	3448478dadf99adf
-487	582	1542027815	app/test_control_event_queue	bfca00bc894d3c4f
-517	606	1542027815	app/test_control_event_serialize	e06ab4ce04dd4fad
-147	638	1542027815	app/app@@scrcpy@exe/src_input_manager.c.o	1fe285b256bf5908
-236	713	1542027815	app/app@@scrcpy@exe/src_scrcpy.c.o	8b0bae90b272da98
-713	891	1542027816	app/scrcpy	8fba96817bb2802c
-485	5716	1542027820	server/scrcpy-server.jar	8511d30842df298f
-0	264	1542027826	build.ninja	ef03cd8523486e97
-1	31	1542027826	app/app@@scrcpy@exe/src_fps_counter.c.o	22b968c51acd256b
-1	44	1542027826	app/app@@scrcpy@exe/src_file_handler.c.o	11e303a26f189d9a
-1	47	1542027826	app/app@@scrcpy@exe/src_controller.c.o	907de440054c77e7
-2	50	1542027826	app/app@@scrcpy@exe/src_frames.c.o	3c5c4dbee035e5ab
-2	50	1542027826	app/app@@scrcpy@exe/src_recorder.c.o	676a7500fb0d45cb
-1	65	1542027826	app/app@@scrcpy@exe/src_decoder.c.o	60c1438cf7786895
-31	82	1542027826	app/app@@scrcpy@exe/src_server.c.o	8b376071b5e0aaf1
-2	108	1542027826	app/app@@scrcpy@exe/src_input_manager.c.o	1fe285b256bf5908
-2	129	1542027826	app/app@@scrcpy@exe/src_screen.c.o	329c18ec2111c8ff
-2	162	1542027826	app/app@@scrcpy@exe/src_scrcpy.c.o	8b0bae90b272da98
-1	339	1542027826	app/app@@scrcpy@exe/src_main.c.o	e7dc8583797471c5
-339	538	1542027827	app/scrcpy	8fba96817bb2802c
-44	753	1542027827	server/scrcpy-server.jar	8511d30842df298f
-0	276	1542027871	build.ninja	ef03cd8523486e97
-1	37	1542027872	app/app@@scrcpy@exe/src_file_handler.c.o	11e303a26f189d9a
-1	42	1542027872	app/app@@scrcpy@exe/src_controller.c.o	907de440054c77e7
-1	45	1542027872	app/app@@scrcpy@exe/src_fps_counter.c.o	22b968c51acd256b
-2	49	1542027872	app/app@@scrcpy@exe/src_recorder.c.o	676a7500fb0d45cb
-1	52	1542027872	app/app@@scrcpy@exe/src_frames.c.o	3c5c4dbee035e5ab
-0	64	1542027872	app/app@@scrcpy@exe/src_decoder.c.o	60c1438cf7786895
-37	80	1542027872	app/app@@scrcpy@exe/src_server.c.o	8b376071b5e0aaf1
-1	128	1542027872	app/app@@scrcpy@exe/src_input_manager.c.o	1fe285b256bf5908
-2	138	1542027872	app/app@@scrcpy@exe/src_screen.c.o	329c18ec2111c8ff
-2	150	1542027872	app/app@@scrcpy@exe/src_scrcpy.c.o	8b0bae90b272da98
-1	370	1542027872	app/app@@scrcpy@exe/src_main.c.o	e7dc8583797471c5
-370	578	1542027872	app/scrcpy	8fba96817bb2802c
-42	688	1542027872	server/scrcpy-server.jar	8511d30842df298f
--- a/u/app/app@@scrcpy@exe/src_command.c.o
+++ b/u/app/app@@scrcpy@exe/src_command.c.o
--- a/u/app/app@@scrcpy@exe/src_control_event.c.o
+++ b/u/app/app@@scrcpy@exe/src_control_event.c.o
--- a/u/app/app@@scrcpy@exe/src_controller.c.o
+++ b/u/app/app@@scrcpy@exe/src_controller.c.o
--- a/u/app/app@@scrcpy@exe/src_convert.c.o
+++ b/u/app/app@@scrcpy@exe/src_convert.c.o
--- a/u/app/app@@scrcpy@exe/src_decoder.c.o
+++ b/u/app/app@@scrcpy@exe/src_decoder.c.o
--- a/u/app/app@@scrcpy@exe/src_device.c.o
+++ b/u/app/app@@scrcpy@exe/src_device.c.o
--- a/u/app/app@@scrcpy@exe/src_file_handler.c.o
+++ b/u/app/app@@scrcpy@exe/src_file_handler.c.o
--- a/u/app/app@@scrcpy@exe/src_fps_counter.c.o
+++ b/u/app/app@@scrcpy@exe/src_fps_counter.c.o
--- a/u/app/app@@scrcpy@exe/src_frames.c.o
+++ b/u/app/app@@scrcpy@exe/src_frames.c.o
--- a/u/app/app@@scrcpy@exe/src_input_manager.c.o
+++ b/u/app/app@@scrcpy@exe/src_input_manager.c.o
--- a/u/app/app@@scrcpy@exe/src_lock_util.c.o
+++ b/u/app/app@@scrcpy@exe/src_lock_util.c.o
--- a/u/app/app@@scrcpy@exe/src_main.c.o
+++ b/u/app/app@@scrcpy@exe/src_main.c.o
--- a/u/app/app@@scrcpy@exe/src_net.c.o
+++ b/u/app/app@@scrcpy@exe/src_net.c.o
--- a/u/app/app@@scrcpy@exe/src_recorder.c.o
+++ b/u/app/app@@scrcpy@exe/src_recorder.c.o
--- a/u/app/app@@scrcpy@exe/src_scrcpy.c.o
+++ b/u/app/app@@scrcpy@exe/src_scrcpy.c.o
--- a/u/app/app@@scrcpy@exe/src_screen.c.o
+++ b/u/app/app@@scrcpy@exe/src_screen.c.o
--- a/u/app/app@@scrcpy@exe/src_server.c.o
+++ b/u/app/app@@scrcpy@exe/src_server.c.o
--- a/u/app/app@@scrcpy@exe/src_str_util.c.o
+++ b/u/app/app@@scrcpy@exe/src_str_util.c.o
--- a/u/app/app@@scrcpy@exe/src_sys_unix_command.c.o
+++ b/u/app/app@@scrcpy@exe/src_sys_unix_command.c.o
--- a/u/app/app@@scrcpy@exe/src_sys_unix_net.c.o
+++ b/u/app/app@@scrcpy@exe/src_sys_unix_net.c.o
--- a/u/app/app@@scrcpy@exe/src_tiny_xpm.c.o
+++ b/u/app/app@@scrcpy@exe/src_tiny_xpm.c.o
--- a/u/app/app@@test_control_event_queue@exe/src_control_event.c.o
+++ b/u/app/app@@test_control_event_queue@exe/src_control_event.c.o
--- a/u/app/app@@test_control_event_queue@exe/tests_test_control_event_queue.c.o
+++ b/u/app/app@@test_control_event_queue@exe/tests_test_control_event_queue.c.o
--- a/u/app/app@@test_control_event_serialize@exe/src_control_event.c.o
+++ b/u/app/app@@test_control_event_serialize@exe/src_control_event.c.o
--- a/u/app/app@@test_control_event_serialize@exe/tests_test_control_event_serialize.c.o
+++ b/u/app/app@@test_control_event_serialize@exe/tests_test_control_event_serialize.c.o
--- a/u/app/app@@test_strutil@exe/src_str_util.c.o
+++ b/u/app/app@@test_strutil@exe/src_str_util.c.o
--- a/u/app/app@@test_strutil@exe/tests_test_strutil.c.o
+++ b/u/app/app@@test_strutil@exe/tests_test_strutil.c.o
--- a/u/app/config.h
+++ b/u/app/config.h
@@ -1,29 +0,0 @@
-/*
- * Autogenerated by the Meson build system.
- * Do not edit, your changes will be lost.
- */
-
-#pragma once
-
-#define BUILD_DEBUG
-
-#define DEFAULT_BIT_RATE 8000000
-
-#define DEFAULT_LOCAL_PORT 27183
-
-#define DEFAULT_MAX_SIZE 0
-
-#define HIDPI_SUPPORT
-
-#undef OVERRIDE_SERVER_PATH
-
-#define PREFIX "/usr/local"
-
-#define PREFIXED_SERVER_PATH "/share/scrcpy/scrcpy-server.jar"
-
-#define SCRCPY_VERSION "1.6"
-
-#define SKIP_FRAMES
-
-#undef WINDOWS_NOCONSOLE
-
--- a/u/app/scrcpy
+++ b/u/app/scrcpy
--- a/u/app/test_control_event_queue
+++ b/u/app/test_control_event_queue
--- a/u/app/test_control_event_serialize
+++ b/u/app/test_control_event_serialize
--- a/u/app/test_strutil
+++ b/u/app/test_strutil
--- a/u/build.ninja
+++ b/u/build.ninja
@@ -1,263 +0,0 @@
-# This is the build file for project "scrcpy"
-# It is autogenerated by the Meson build system.
-# Do not edit by hand.
-
-ninja_required_version = 1.5.1
-
-# Rules for compiling.
-
-rule c_COMPILER
- command = ccache cc $ARGS  -MD -MQ $out -MF '$DEPFILE' -o $out -c $in
- deps = gcc
- depfile = $DEPFILE
- description = Compiling C object $out.
-
-rule c_PCH
- command = ccache cc $ARGS  -MD -MQ $out -MF '$DEPFILE' -o $out -c $in
- deps = gcc
- depfile = $DEPFILE
- description = Precompiling header $in.
-
-
-# Rules for linking.
-
-rule STATIC_LINKER
- command =  rm -f $out && gcc-ar $LINK_ARGS $out $in
- description = Linking static target $out.
-
-rule c_LINKER
- command = ccache cc $ARGS -o $out $in $LINK_ARGS  $aliasing
- description = Linking target $out.
-
-
-rule SHSYM
- command = /usr/bin/meson --internal symbolextractor $in $out $CROSS
- restat = 1
- description = Generating symbol file $out.
-
-# Other rules
-
-rule CUSTOM_COMMAND
- command = $COMMAND
- description = $DESC
- restat = 1
-
-rule CUSTOM_COMMAND_DEP
- command = $COMMAND
- description = $DESC
- deps = gcc
- depfile = $DEPFILE
- restat = 1
-
-rule REGENERATE_BUILD
- command = /usr/bin/meson --internal regenerate /home/rom/projects/scrcpy /home/rom/projects/scrcpy/u --backend ninja
- description = Regenerating build files.
- generator = 1
-
-
-# Phony build target, always out of date
-build PHONY: phony
-
-# Build rules for targets
-
-build app/app@@scrcpy@exe/src_main.c.o: c_COMPILER ../app/src/main.c
- DEPFILE = app/app@@scrcpy@exe/src_main.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_command.c.o: c_COMPILER ../app/src/command.c
- DEPFILE = app/app@@scrcpy@exe/src_command.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_control_event.c.o: c_COMPILER ../app/src/control_event.c
- DEPFILE = app/app@@scrcpy@exe/src_control_event.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_controller.c.o: c_COMPILER ../app/src/controller.c
- DEPFILE = app/app@@scrcpy@exe/src_controller.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_convert.c.o: c_COMPILER ../app/src/convert.c
- DEPFILE = app/app@@scrcpy@exe/src_convert.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_decoder.c.o: c_COMPILER ../app/src/decoder.c
- DEPFILE = app/app@@scrcpy@exe/src_decoder.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_device.c.o: c_COMPILER ../app/src/device.c
- DEPFILE = app/app@@scrcpy@exe/src_device.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_file_handler.c.o: c_COMPILER ../app/src/file_handler.c
- DEPFILE = app/app@@scrcpy@exe/src_file_handler.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_fps_counter.c.o: c_COMPILER ../app/src/fps_counter.c
- DEPFILE = app/app@@scrcpy@exe/src_fps_counter.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_frames.c.o: c_COMPILER ../app/src/frames.c
- DEPFILE = app/app@@scrcpy@exe/src_frames.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_input_manager.c.o: c_COMPILER ../app/src/input_manager.c
- DEPFILE = app/app@@scrcpy@exe/src_input_manager.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_lock_util.c.o: c_COMPILER ../app/src/lock_util.c
- DEPFILE = app/app@@scrcpy@exe/src_lock_util.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_net.c.o: c_COMPILER ../app/src/net.c
- DEPFILE = app/app@@scrcpy@exe/src_net.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_recorder.c.o: c_COMPILER ../app/src/recorder.c
- DEPFILE = app/app@@scrcpy@exe/src_recorder.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_scrcpy.c.o: c_COMPILER ../app/src/scrcpy.c
- DEPFILE = app/app@@scrcpy@exe/src_scrcpy.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_screen.c.o: c_COMPILER ../app/src/screen.c
- DEPFILE = app/app@@scrcpy@exe/src_screen.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_server.c.o: c_COMPILER ../app/src/server.c
- DEPFILE = app/app@@scrcpy@exe/src_server.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_str_util.c.o: c_COMPILER ../app/src/str_util.c
- DEPFILE = app/app@@scrcpy@exe/src_str_util.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_tiny_xpm.c.o: c_COMPILER ../app/src/tiny_xpm.c
- DEPFILE = app/app@@scrcpy@exe/src_tiny_xpm.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_sys_unix_command.c.o: c_COMPILER ../app/src/sys/unix/command.c
- DEPFILE = app/app@@scrcpy@exe/src_sys_unix_command.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@scrcpy@exe/src_sys_unix_net.c.o: c_COMPILER ../app/src/sys/unix/net.c
- DEPFILE = app/app@@scrcpy@exe/src_sys_unix_net.c.o.d
- ARGS = -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/scrcpy: c_LINKER app/app@@scrcpy@exe/src_main.c.o app/app@@scrcpy@exe/src_command.c.o app/app@@scrcpy@exe/src_control_event.c.o app/app@@scrcpy@exe/src_controller.c.o app/app@@scrcpy@exe/src_convert.c.o app/app@@scrcpy@exe/src_decoder.c.o app/app@@scrcpy@exe/src_device.c.o app/app@@scrcpy@exe/src_file_handler.c.o app/app@@scrcpy@exe/src_fps_counter.c.o app/app@@scrcpy@exe/src_frames.c.o app/app@@scrcpy@exe/src_input_manager.c.o app/app@@scrcpy@exe/src_lock_util.c.o app/app@@scrcpy@exe/src_net.c.o app/app@@scrcpy@exe/src_recorder.c.o app/app@@scrcpy@exe/src_scrcpy.c.o app/app@@scrcpy@exe/src_screen.c.o app/app@@scrcpy@exe/src_server.c.o app/app@@scrcpy@exe/src_str_util.c.o app/app@@scrcpy@exe/src_tiny_xpm.c.o app/app@@scrcpy@exe/src_sys_unix_command.c.o app/app@@scrcpy@exe/src_sys_unix_net.c.o | /usr/lib/x86_64-linux-gnu/libavformat.so /usr/lib/x86_64-linux-gnu/libavcodec.so /usr/lib/x86_64-linux-gnu/libavutil.so /usr/lib/x86_64-linux-gnu/libSDL2.so
- LINK_ARGS = -Wl,--no-undefined -Wl,--as-needed -Wl,--start-group /usr/lib/x86_64-linux-gnu/libavformat.so /usr/lib/x86_64-linux-gnu/libavcodec.so /usr/lib/x86_64-linux-gnu/libavutil.so /usr/lib/x86_64-linux-gnu/libSDL2.so -Wl,--end-group
-
-build app/app@@test_control_event_queue@exe/tests_test_control_event_queue.c.o: c_COMPILER ../app/tests/test_control_event_queue.c
- DEPFILE = app/app@@test_control_event_queue@exe/tests_test_control_event_queue.c.o.d
- ARGS = -Iapp/app@@test_control_event_queue@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@test_control_event_queue@exe/src_control_event.c.o: c_COMPILER ../app/src/control_event.c
- DEPFILE = app/app@@test_control_event_queue@exe/src_control_event.c.o.d
- ARGS = -Iapp/app@@test_control_event_queue@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/test_control_event_queue: c_LINKER app/app@@test_control_event_queue@exe/tests_test_control_event_queue.c.o app/app@@test_control_event_queue@exe/src_control_event.c.o | /usr/lib/x86_64-linux-gnu/libavformat.so /usr/lib/x86_64-linux-gnu/libavcodec.so /usr/lib/x86_64-linux-gnu/libavutil.so /usr/lib/x86_64-linux-gnu/libSDL2.so
- LINK_ARGS = -Wl,--no-undefined -Wl,--as-needed -Wl,--start-group /usr/lib/x86_64-linux-gnu/libavformat.so /usr/lib/x86_64-linux-gnu/libavcodec.so /usr/lib/x86_64-linux-gnu/libavutil.so /usr/lib/x86_64-linux-gnu/libSDL2.so -Wl,--end-group
-
-build app/app@@test_control_event_serialize@exe/tests_test_control_event_serialize.c.o: c_COMPILER ../app/tests/test_control_event_serialize.c
- DEPFILE = app/app@@test_control_event_serialize@exe/tests_test_control_event_serialize.c.o.d
- ARGS = -Iapp/app@@test_control_event_serialize@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@test_control_event_serialize@exe/src_control_event.c.o: c_COMPILER ../app/src/control_event.c
- DEPFILE = app/app@@test_control_event_serialize@exe/src_control_event.c.o.d
- ARGS = -Iapp/app@@test_control_event_serialize@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/test_control_event_serialize: c_LINKER app/app@@test_control_event_serialize@exe/tests_test_control_event_serialize.c.o app/app@@test_control_event_serialize@exe/src_control_event.c.o | /usr/lib/x86_64-linux-gnu/libavformat.so /usr/lib/x86_64-linux-gnu/libavcodec.so /usr/lib/x86_64-linux-gnu/libavutil.so /usr/lib/x86_64-linux-gnu/libSDL2.so
- LINK_ARGS = -Wl,--no-undefined -Wl,--as-needed -Wl,--start-group /usr/lib/x86_64-linux-gnu/libavformat.so /usr/lib/x86_64-linux-gnu/libavcodec.so /usr/lib/x86_64-linux-gnu/libavutil.so /usr/lib/x86_64-linux-gnu/libSDL2.so -Wl,--end-group
-
-build app/app@@test_strutil@exe/tests_test_strutil.c.o: c_COMPILER ../app/tests/test_strutil.c
- DEPFILE = app/app@@test_strutil@exe/tests_test_strutil.c.o.d
- ARGS = -Iapp/app@@test_strutil@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/app@@test_strutil@exe/src_str_util.c.o: c_COMPILER ../app/src/str_util.c
- DEPFILE = app/app@@test_strutil@exe/src_str_util.c.o.d
- ARGS = -Iapp/app@@test_strutil@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT
-
-build app/test_strutil: c_LINKER app/app@@test_strutil@exe/tests_test_strutil.c.o app/app@@test_strutil@exe/src_str_util.c.o | /usr/lib/x86_64-linux-gnu/libavformat.so /usr/lib/x86_64-linux-gnu/libavcodec.so /usr/lib/x86_64-linux-gnu/libavutil.so /usr/lib/x86_64-linux-gnu/libSDL2.so
- LINK_ARGS = -Wl,--no-undefined -Wl,--as-needed -Wl,--start-group /usr/lib/x86_64-linux-gnu/libavformat.so /usr/lib/x86_64-linux-gnu/libavcodec.so /usr/lib/x86_64-linux-gnu/libavutil.so /usr/lib/x86_64-linux-gnu/libSDL2.so -Wl,--end-group
-
-build server/scrcpy-server.jar: CUSTOM_COMMAND ../server/. | /home/rom/projects/scrcpy/server/./scripts/build-wrapper.sh PHONY
- COMMAND = /home/rom/projects/scrcpy/server/./scripts/build-wrapper.sh ../server/. server/scrcpy-server.jar debug
- description = Generating$ scrcpy-server$ with$ a$ custom$ command.
-
-build meson-run: CUSTOM_COMMAND 
- COMMAND = /usr/bin/meson --internal commandrunner /home/rom/projects/scrcpy /home/rom/projects/scrcpy/u '' /usr/bin/meson scripts/run-scrcpy.sh
- description = Running$ external$ command$ run.
- pool = console
-
-build run: phony meson-run
-
-# Test rules
-
-build meson-test: CUSTOM_COMMAND all PHONY
- COMMAND = /usr/bin/meson test --no-rebuild --print-errorlogs
- DESC = Running$ all$ tests.
- pool = console
-
-build test: phony meson-test
-
-build meson-benchmark: CUSTOM_COMMAND all PHONY
- COMMAND = /usr/bin/meson test --benchmark --logbase benchmarklog --num-processes=1 --no-rebuild
- DESC = Running$ benchmark$ suite.
- pool = console
-
-build benchmark: phony meson-benchmark
-
-# Install rules
-
-build meson-install: CUSTOM_COMMAND PHONY | all
- DESC = Installing$ files.
- COMMAND = /usr/bin/meson install --no-rebuild
- pool = console
-
-build install: phony meson-install
-
-build meson-dist: CUSTOM_COMMAND PHONY
- DESC = Creating$ source$ packages
- COMMAND = /usr/bin/meson --internal dist /home/rom/projects/scrcpy /home/rom/projects/scrcpy/u /usr/bin/meson
- pool = console
-
-build dist: phony meson-dist
-
-# Suffix
-
-build meson-scan-build: CUSTOM_COMMAND PHONY
- COMMAND = /usr/bin/meson --internal scanbuild /home/rom/projects/scrcpy /home/rom/projects/scrcpy/u /usr/bin/meson -Dbuild_app=true -Dbuild_server=true -Dcrossbuild_windows=false -Dhidpi_support=true -Doverride_server_path= -Dprebuilt_server= -Dskip_frames=true -Dwindows_noconsole=false
- pool = console
-
-build scan-build: phony meson-scan-build
-
-build meson-uninstall: CUSTOM_COMMAND PHONY
- COMMAND = /usr/bin/meson --internal uninstall
- pool = console
-
-build uninstall: phony meson-uninstall
-
-build all: phony app/scrcpy app/test_control_event_queue app/test_control_event_serialize app/test_strutil server/scrcpy-server.jar
-
-default all
-
-build clean: phony meson-clean
-
-build meson-clean-ctlist: CUSTOM_COMMAND PHONY
- COMMAND = /usr/bin/meson --internal cleantrees /home/rom/projects/scrcpy/u/meson-private/cleantrees.dat
- description = Cleaning$ custom$ target$ directories.
-
-build clean-ctlist: phony meson-clean-ctlist
-
-build meson-clean: CUSTOM_COMMAND PHONY | clean-ctlist
- COMMAND = ninja -t clean
- description = Cleaning.
-
-build build.ninja: REGENERATE_BUILD ../meson.build ../app/meson.build ../server/meson.build meson-private/coredata.dat ../meson_options.txt
- pool = console
-
-build reconfigure: REGENERATE_BUILD PHONY
- pool = console
-
-build ../meson.build ../app/meson.build ../server/meson.build meson-private/coredata.dat ../meson_options.txt: phony 
-
--- a/u/compile_commands.json
+++ b/u/compile_commands.json
@@ -1,137 +0,0 @@
-[
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_main.c.o' -MF 'app/app@@scrcpy@exe/src_main.c.o.d' -o 'app/app@@scrcpy@exe/src_main.c.o' -c ../app/src/main.c",
-    "file": "../app/src/main.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_command.c.o' -MF 'app/app@@scrcpy@exe/src_command.c.o.d' -o 'app/app@@scrcpy@exe/src_command.c.o' -c ../app/src/command.c",
-    "file": "../app/src/command.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_control_event.c.o' -MF 'app/app@@scrcpy@exe/src_control_event.c.o.d' -o 'app/app@@scrcpy@exe/src_control_event.c.o' -c ../app/src/control_event.c",
-    "file": "../app/src/control_event.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_controller.c.o' -MF 'app/app@@scrcpy@exe/src_controller.c.o.d' -o 'app/app@@scrcpy@exe/src_controller.c.o' -c ../app/src/controller.c",
-    "file": "../app/src/controller.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_convert.c.o' -MF 'app/app@@scrcpy@exe/src_convert.c.o.d' -o 'app/app@@scrcpy@exe/src_convert.c.o' -c ../app/src/convert.c",
-    "file": "../app/src/convert.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_decoder.c.o' -MF 'app/app@@scrcpy@exe/src_decoder.c.o.d' -o 'app/app@@scrcpy@exe/src_decoder.c.o' -c ../app/src/decoder.c",
-    "file": "../app/src/decoder.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_device.c.o' -MF 'app/app@@scrcpy@exe/src_device.c.o.d' -o 'app/app@@scrcpy@exe/src_device.c.o' -c ../app/src/device.c",
-    "file": "../app/src/device.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_file_handler.c.o' -MF 'app/app@@scrcpy@exe/src_file_handler.c.o.d' -o 'app/app@@scrcpy@exe/src_file_handler.c.o' -c ../app/src/file_handler.c",
-    "file": "../app/src/file_handler.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_fps_counter.c.o' -MF 'app/app@@scrcpy@exe/src_fps_counter.c.o.d' -o 'app/app@@scrcpy@exe/src_fps_counter.c.o' -c ../app/src/fps_counter.c",
-    "file": "../app/src/fps_counter.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_frames.c.o' -MF 'app/app@@scrcpy@exe/src_frames.c.o.d' -o 'app/app@@scrcpy@exe/src_frames.c.o' -c ../app/src/frames.c",
-    "file": "../app/src/frames.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_input_manager.c.o' -MF 'app/app@@scrcpy@exe/src_input_manager.c.o.d' -o 'app/app@@scrcpy@exe/src_input_manager.c.o' -c ../app/src/input_manager.c",
-    "file": "../app/src/input_manager.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_lock_util.c.o' -MF 'app/app@@scrcpy@exe/src_lock_util.c.o.d' -o 'app/app@@scrcpy@exe/src_lock_util.c.o' -c ../app/src/lock_util.c",
-    "file": "../app/src/lock_util.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_net.c.o' -MF 'app/app@@scrcpy@exe/src_net.c.o.d' -o 'app/app@@scrcpy@exe/src_net.c.o' -c ../app/src/net.c",
-    "file": "../app/src/net.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_recorder.c.o' -MF 'app/app@@scrcpy@exe/src_recorder.c.o.d' -o 'app/app@@scrcpy@exe/src_recorder.c.o' -c ../app/src/recorder.c",
-    "file": "../app/src/recorder.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_scrcpy.c.o' -MF 'app/app@@scrcpy@exe/src_scrcpy.c.o.d' -o 'app/app@@scrcpy@exe/src_scrcpy.c.o' -c ../app/src/scrcpy.c",
-    "file": "../app/src/scrcpy.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_screen.c.o' -MF 'app/app@@scrcpy@exe/src_screen.c.o.d' -o 'app/app@@scrcpy@exe/src_screen.c.o' -c ../app/src/screen.c",
-    "file": "../app/src/screen.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_server.c.o' -MF 'app/app@@scrcpy@exe/src_server.c.o.d' -o 'app/app@@scrcpy@exe/src_server.c.o' -c ../app/src/server.c",
-    "file": "../app/src/server.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_str_util.c.o' -MF 'app/app@@scrcpy@exe/src_str_util.c.o.d' -o 'app/app@@scrcpy@exe/src_str_util.c.o' -c ../app/src/str_util.c",
-    "file": "../app/src/str_util.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_tiny_xpm.c.o' -MF 'app/app@@scrcpy@exe/src_tiny_xpm.c.o.d' -o 'app/app@@scrcpy@exe/src_tiny_xpm.c.o' -c ../app/src/tiny_xpm.c",
-    "file": "../app/src/tiny_xpm.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_sys_unix_command.c.o' -MF 'app/app@@scrcpy@exe/src_sys_unix_command.c.o.d' -o 'app/app@@scrcpy@exe/src_sys_unix_command.c.o' -c ../app/src/sys/unix/command.c",
-    "file": "../app/src/sys/unix/command.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@scrcpy@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@scrcpy@exe/src_sys_unix_net.c.o' -MF 'app/app@@scrcpy@exe/src_sys_unix_net.c.o.d' -o 'app/app@@scrcpy@exe/src_sys_unix_net.c.o' -c ../app/src/sys/unix/net.c",
-    "file": "../app/src/sys/unix/net.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@test_control_event_queue@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@test_control_event_queue@exe/tests_test_control_event_queue.c.o' -MF 'app/app@@test_control_event_queue@exe/tests_test_control_event_queue.c.o.d' -o 'app/app@@test_control_event_queue@exe/tests_test_control_event_queue.c.o' -c ../app/tests/test_control_event_queue.c",
-    "file": "../app/tests/test_control_event_queue.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@test_control_event_queue@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@test_control_event_queue@exe/src_control_event.c.o' -MF 'app/app@@test_control_event_queue@exe/src_control_event.c.o.d' -o 'app/app@@test_control_event_queue@exe/src_control_event.c.o' -c ../app/src/control_event.c",
-    "file": "../app/src/control_event.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@test_control_event_serialize@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@test_control_event_serialize@exe/tests_test_control_event_serialize.c.o' -MF 'app/app@@test_control_event_serialize@exe/tests_test_control_event_serialize.c.o.d' -o 'app/app@@test_control_event_serialize@exe/tests_test_control_event_serialize.c.o' -c ../app/tests/test_control_event_serialize.c",
-    "file": "../app/tests/test_control_event_serialize.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@test_control_event_serialize@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@test_control_event_serialize@exe/src_control_event.c.o' -MF 'app/app@@test_control_event_serialize@exe/src_control_event.c.o.d' -o 'app/app@@test_control_event_serialize@exe/src_control_event.c.o' -c ../app/src/control_event.c",
-    "file": "../app/src/control_event.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@test_strutil@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@test_strutil@exe/tests_test_strutil.c.o' -MF 'app/app@@test_strutil@exe/tests_test_strutil.c.o.d' -o 'app/app@@test_strutil@exe/tests_test_strutil.c.o' -c ../app/tests/test_strutil.c",
-    "file": "../app/tests/test_strutil.c"
-  },
-  {
-    "directory": "/home/rom/projects/scrcpy/u",
-    "command": "ccache cc -Iapp/app@@test_strutil@exe -Iapp -I../app -I../app/src -I/usr/include/x86_64-linux-gnu -I/usr/include/SDL2 -fdiagnostics-color=always -pipe -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -std=c11 -g -D_REENTRANT  -MD -MQ 'app/app@@test_strutil@exe/src_str_util.c.o' -MF 'app/app@@test_strutil@exe/src_str_util.c.o.d' -o 'app/app@@test_strutil@exe/src_str_util.c.o' -c ../app/src/str_util.c",
-    "file": "../app/src/str_util.c"
-  }
-]
--- a/u/meson-logs/meson-log.txt
+++ b/u/meson-logs/meson-log.txt
@@ -1,38 +0,0 @@
-Build started at 2018-11-12T14:04:31.900569
-Main binary: /usr/bin/python3
-Python system: Linux
-The Meson build system
-Version: 0.48.1
-Source dir: /home/rom/projects/scrcpy
-Build dir: /home/rom/projects/scrcpy/u
-Build type: native build
-Project name: scrcpy
-Project version: 1.6
-Native C compiler: ccache cc (gcc 8.2.0 "cc (Debian 8.2.0-9) 8.2.0")
-Build machine cpu family: x86_64
-Build machine cpu: x86_64
-Dependency libavformat found: YES (cached)
-Dependency libavcodec found: YES (cached)
-Dependency libavutil found: YES (cached)
-Dependency sdl2 found: YES (cached)
-Configuring config.h using configuration
-Adding test "test_control_event_queue"
-Adding test "test_control_event_serialize"
-Adding test "test_strutil"
-Program ./scripts/build-wrapper.sh found: YES (/home/rom/projects/scrcpy/server/./scripts/build-wrapper.sh)
-DEPRECATION: build_always is deprecated. Combine build_by_default and build_always_stale instead.
-Build targets in project: 6
-Found ninja-1.8.2 at /usr/bin/ninja
-Running compile:
-Working directory:  /tmp/tmpk1bh9k5g
-Command line:  ccache cc /tmp/tmpk1bh9k5g/testfile.c -pipe -D_FILE_OFFSET_BITS=64 -c -o /tmp/tmpk1bh9k5g/output.obj -O0 --print-search-dirs 
-
-Code:
- 
-Compiler stdout:
- install: /usr/lib/gcc/x86_64-linux-gnu/8/
-programs: =/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/bin/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/bin/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/bin/
-libraries: =/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/lib/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/lib/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../lib/:/lib/x86_64-linux-gnu/8/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/8/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/lib/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../:/lib/:/usr/lib/
-
-Compiler stderr:
- 
--- a/u/meson-private/build.dat
+++ b/u/meson-private/build.dat
--- a/u/meson-private/cleantrees.dat
+++ b/u/meson-private/cleantrees.dat
--- a/u/meson-private/coredata.dat
+++ b/u/meson-private/coredata.dat
--- a/u/meson-private/coredata.dat.prev
+++ b/u/meson-private/coredata.dat.prev
--- a/u/meson-private/install.dat
+++ b/u/meson-private/install.dat
--- a/u/meson-private/meson.lock
+++ b/u/meson-private/meson.lock
--- a/u/meson-private/meson_benchmark_setup.dat
+++ b/u/meson-private/meson_benchmark_setup.dat
--- a/u/meson-private/meson_test_setup.dat
+++ b/u/meson-private/meson_test_setup.dat
--- a/u/meson-private/sanitycheckc.c
+++ b/u/meson-private/sanitycheckc.c
@@ -1 +0,0 @@
-int main(int argc, char **argv) { int class=0; return class; }
--- a/u/meson-private/sanitycheckc.exe
+++ b/u/meson-private/sanitycheckc.exe
--- a/u/server/scrcpy-server.jar
+++ b/u/server/scrcpy-server.jar
Author	SHA1	Message	Date
Romain Vimont	1dce6abf20	AudioEncoder WIP	2023-02-07 23:23:45 +01:00
Romain Vimont	dd4c5d3820	audio demuxer	2023-02-07 23:12:54 +01:00
Romain Vimont	fa1178195e	Rename demuxer to video_demuxer There will be another demuxer instance for audio.	2023-02-07 23:12:54 +01:00
Simon Chan	5dcce5f241	Capture device audio WIP Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-02-07 23:12:54 +01:00
Simon Chan	3f58dd22dc	socketwip Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-02-07 23:12:54 +01:00
Simon Chan	cbd75ff1fb	audio option Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-02-07 23:12:54 +01:00
Romain Vimont	39cdf68150	Use FakeContext for Application instance This will expose the correct package name and UID to the application context.	2023-02-07 23:12:54 +01:00
Romain Vimont	3492c5c963	Use shell package name for workarounds For consistency.	2023-02-07 23:12:54 +01:00
Romain Vimont	35f4040a78	Use PACKAGE_NAME from FakeContext Remove duplicated constant.	2023-02-07 23:12:54 +01:00
Romain Vimont	fd7d6f3822	Use AttributionSource from FakeContext FakeContext already provides an AttributeSource instance. Co-authored-by: Simon Chan <1330321+yume-chan@users.noreply.github.com>	2023-02-07 23:12:54 +01:00
Simon Chan	6c3e7f6b45	Add a fake Android Context Since scrcpy-server is not an Android application (it's a java executable), it has no Context. Some features will require a Context instance to get the package name and the UID. Add a FakeContext for this purpose. Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-02-07 23:12:54 +01:00
Romain Vimont	94d90927ad	Use Process.ROOT_UID Replace ServiceManager.USER_ID by existing constant Process.ROOT_UID.	2023-02-07 23:12:54 +01:00
Romain Vimont	93504f5f34	Make streamer independent of codec type Rename VideoStreamer to Streamer, and extract a Codec interface which will also support audio codecs.	2023-02-07 23:12:54 +01:00
Romain Vimont	a52b1f025d	Pass all args to ScreenEncoder constructor There is no good reason to pass some of them in the constructor and some others as parameters of the streamScreen() method.	2023-02-07 23:12:54 +01:00
Romain Vimont	46759d3f63	Move screen encoder initialization This prepares further refactors.	2023-02-07 23:12:54 +01:00
Romain Vimont	e37f9a4d7c	Write streamer header from ScreenEncoder The screen encoder is responsible to write data to the video streamer from its own thread (which will be added later).	2023-02-07 23:12:54 +01:00
Romain Vimont	842fdccaa9	Use VideoStreamer directly from ScreenEncoder The Callbacks interface notifies new packets. In addition, the screen encoder will need to write headers on start from its own thread (which will be added later). We could add a function onStart() instead, but for simplicity, just remove the interface, which brings no value, and call the streamer directly. Refs `87972e2022`	2023-02-07 23:12:54 +01:00
Romain Vimont	8cdae30b01	Simplify error handling on socket creation On any error, all previously closed sockets must be closed. Handle these errors in a single catch-block. Currently, there are only 2 sockets, but this will simplify even more with more sockets. Note: this commit is better displayed with --ignore-space-change (-b).	2023-02-07 23:12:54 +01:00
Romain Vimont	30b8d140e8	Log component stopped in finally clause The message must be logged even when no exception occurs.	2023-02-07 23:12:54 +01:00
Romain Vimont	4f986d4bbb	Join all threads before end of main Some calls run from separate threads may throw exceptions when the main() method has returned.	2023-02-07 23:12:51 +01:00
				`@@ -1 +0,0 @@`
				`int main(int argc, char **argv) { int class=0; return class; }`