Enforce monotonical PTS

Audio PTS may come from two sources: - recorder.getTimestamp() if the call works; - an estimation from the previous PTS and the packet size as a fallback. Therefore, the property that PTS are monotonically increasing is no guaranteed in corner cases, so enforce it.
AudioEncoder WIP
2023-02-03 17:07:49 +01:00 · 2023-02-03 17:07:49 +01:00 · 2023-02-03 17:07:49 +01:00 · 2023-02-03 17:07:37 +01:00 · 2023-02-03 17:06:00 +01:00 · 2023-02-03 17:06:00 +01:00
40 changed files with 672 additions and 1693 deletions
--- a/README.md
+++ b/README.md
@@ -194,6 +194,18 @@ The other dimension is computed so that the Android device aspect ratio is
 preserved. That way, a device in 1920×1080 will be mirrored at 1024×576.


+#### Select codec
+
+The video codec can be selected. The possible values are `h264` (default),
+`h265` and `av1`:
+
+```bash
+scrcpy --codec=h264  # default
+scrcpy --codec=h265
+scrcpy --codec=av1
+```
+
+
 #### Change bit-rate

 The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):
@@ -252,19 +264,7 @@ This affects recording orientation.
 The [window may also be rotated](#rotation) independently.


-#### Codec
-
-The video codec can be selected. The possible values are `h264` (default),
-`h265` and `av1`:
-
-```bash
-scrcpy --codec=h264  # default
-scrcpy --codec=h265
-scrcpy --codec=av1
-```
-
-
-##### Encoder
+#### Encoder

 Some devices have more than one encoder for a specific codec, and some of them
 may cause issues or crash. It is possible to select a different encoder:
@@ -277,10 +277,11 @@ To list the available encoders, you can pass an invalid encoder name; the
 error will give the available encoders:

 ```bash
-scrcpy --encoder=_               # for the default codec
-scrcpy --codec=h265 --encoder=_  # for a specific codec
+scrcpy --encoder=_
 ```

+Note that you can also select a different [codec](#select-codec).
+
 ### Capture

 #### Recording
--- 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,30 +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 "\-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.
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -59,8 +59,6 @@
 #define OPT_NO_POWER_ON            1039
 #define OPT_CODEC                  1040
 #define OPT_NO_AUDIO               1041
-#define OPT_AUDIO_BIT_RATE         1042
-#define OPT_AUDIO_CODEC            1043

 struct sc_option {
    char shortopt;
@@ -101,35 +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.",
-    },
    {
        .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) ".",
    },
    {
        .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,
@@ -1426,20 +1408,6 @@ parse_codec(const char *optarg, enum sc_codec *codec) {
    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);
-    return false;
-}
-
 static bool
 parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                       const char *optstring, const struct option *longopts) {
@@ -1455,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;
@@ -1686,11 +1649,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                    return false;
                }
                break;
-            case OPT_AUDIO_CODEC:
-                if (!parse_audio_codec(optarg, &opts->audio_codec)) {
-                    return false;
-                }
-                break;
            case OPT_OTG:
 #ifdef HAVE_USB
                opts->otg = true;
--- 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,33 @@ 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 +292,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
@@ -14,7 +14,6 @@ const struct scrcpy_options scrcpy_options_default = {
 #endif
    .log_level = SC_LOG_LEVEL_INFO,
    .codec = SC_CODEC_H264,
-    .audio_codec = SC_CODEC_OPUS,
    .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 {
@@ -102,7 +100,6 @@ struct scrcpy_options {
 #endif
    enum sc_log_level log_level;
    enum sc_codec codec;
-    enum sc_codec audio_codec;
    enum sc_record_format record_format;
    enum sc_keyboard_input_mode keyboard_input_mode;
    enum sc_mouse_input_mode mouse_input_mode;
@@ -112,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,190 +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
-    // TODO must stop only once both video and audio stream are complete
-    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
@@ -40,8 +40,7 @@
 struct scrcpy {
    struct sc_server server;
    struct sc_screen screen;
-    struct sc_demuxer video_demuxer;
-    struct sc_demuxer audio_demuxer;
+    struct sc_demuxer demuxer;
    struct sc_decoder decoder;
    struct sc_recorder recorder;
 #ifdef HAVE_V4L2
@@ -156,15 +155,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 +179,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 +233,11 @@ 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_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);
-    }
-}
-
-static void
-sc_audio_demuxer_on_ended(struct sc_demuxer *demuxer, bool eos,
-                          void *userdata) {
-    (void) demuxer;
-    (void) eos;
-    (void) userdata;
-
-    // Contrary to the video demuxer, keep mirroring if only the audio fails
+    PUSH_EVENT(EVENT_STREAM_STOPPED);
 }

 static void
@@ -278,7 +245,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 +253,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 +266,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
@@ -329,8 +295,7 @@ scrcpy(struct scrcpy_options *options) {
 #ifdef HAVE_V4L2
    bool v4l2_sink_initialized = false;
 #endif
-    bool video_demuxer_started = false;
-    bool audio_demuxer_started = false;
+    bool demuxer_started = false;
 #ifdef HAVE_USB
    bool aoa_hid_initialized = false;
    bool hid_keyboard_initialized = false;
@@ -342,23 +307,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,
        .codec = options->codec,
-        .audio_codec = options->audio_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,
@@ -446,12 +409,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;
@@ -460,29 +421,17 @@ 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,
+    static const struct sc_demuxer_callbacks demuxer_cbs = {
+        .on_eos = sc_demuxer_on_eos,
    };
-    sc_demuxer_init(&s->video_demuxer, "video", 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,
-        };
-        sc_demuxer_init(&s->audio_demuxer, "audio", s->server.audio_socket,
-                        &audio_demuxer_cbs, NULL);
-    }
+    sc_demuxer_init(&s->demuxer, s->server.video_socket, &demuxer_cbs, NULL);

    if (dec) {
-        sc_demuxer_add_sink(&s->video_demuxer, &dec->packet_sink);
+        sc_demuxer_add_sink(&s->demuxer, &dec->packet_sink);
    }

    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->demuxer, &rec->packet_sink);
    }

    struct sc_controller *controller = NULL;
@@ -690,24 +639,17 @@ aoa_hid_end:
 #endif

    // now we consumed the header values, the socket receives the video stream
-    // start the video demuxer
-    if (!sc_demuxer_start(&s->video_demuxer)) {
+    // start the demuxer
+    if (!sc_demuxer_start(&s->demuxer)) {
        goto end;
    }
-    video_demuxer_started = true;
-
-    if (options->audio) {
-        if (!sc_demuxer_start(&s->audio_demuxer)) {
-            goto end;
-        }
-        audio_demuxer_started = true;
-    }
+    demuxer_started = true;

    ret = event_loop(s);
    LOGD("quit...");

    // Close the window immediately on closing, because screen_destroy() may
-    // only be called once the video demuxer thread is joined (it may take time)
+    // only be called once the demuxer thread is joined (it may take time)
    sc_screen_hide_window(&s->screen);

 end:
@@ -734,9 +676,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);
    }
@@ -748,12 +687,8 @@ end:

    // now that the sockets are shutdown, the demuxer and controller are
    // interrupted, we can join them
-    if (video_demuxer_started) {
-        sc_demuxer_join(&s->video_demuxer);
-    }
-
-    if (audio_demuxer_started) {
-        sc_demuxer_join(&s->audio_demuxer);
+    if (demuxer_started) {
+        sc_demuxer_join(&s->demuxer);
    }

 #ifdef HAVE_V4L2
@@ -772,9 +707,8 @@ end:
    }
 #endif

-    // Destroy the screen only after the video demuxer is guaranteed to be
-    // finished, because otherwise the screen could receive new frames after
-    // destruction
+    // Destroy the screen only after the demuxer is guaranteed to be finished,
+    // because otherwise the screen could receive new frames after destruction
    if (screen_initialized) {
        sc_screen_join(&s->screen);
        sc_screen_destroy(&s->screen);
@@ -788,7 +722,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
@@ -165,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;
    }
@@ -217,24 +213,16 @@ 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->codec != SC_CODEC_H264) {
        ADD_PARAM("codec=%s", sc_server_get_codec_name(params->codec));
    }
-    if (params->audio_codec != SC_CODEC_OPUS) {
-        ADD_PARAM("audio_codec=%s",
-            sc_server_get_codec_name(params->audio_codec));
-    }
    if (params->max_size) {
        ADD_PARAM("max_size=%" PRIu16, params->max_size);
    }
@@ -833,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,11 +22,10 @@ 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 codec;
-    enum sc_codec audio_codec;
    const char *crop;
    const char *codec_options;
    const char *encoder_name;
@@ -35,7 +34,6 @@ struct sc_server_params {
    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
@@ -1,47 +0,0 @@
-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);
-
-    private final int id; // 4-byte ASCII representation of the name
-    private final String name;
-    private final String mimeType;
-
-    AudioCodec(int id, String name, String mimeType) {
-        this.id = id;
-        this.name = name;
-        this.mimeType = mimeType;
-    }
-
-    @Override
-    public Type getType() {
-        return Type.AUDIO;
-    }
-
-    @Override
-    public int getId() {
-        return id;
-    }
-
-    @Override
-    public String getName() {
-        return name;
-    }
-
-    @Override
-    public String getMimeType() {
-        return mimeType;
-    }
-
-    public static AudioCodec findByName(String name) {
-        for (AudioCodec codec : values()) {
-            if (codec.name.equals(name)) {
-                return codec;
-            }
-        }
-        return null;
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/AudioEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/AudioEncoder.java
@@ -1,7 +1,11 @@
 package com.genymobile.scrcpy;

+import com.genymobile.scrcpy.wrappers.ServiceManager;
+
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
+import android.content.ComponentName;
+import android.content.Intent;
 import android.media.AudioFormat;
 import android.media.AudioRecord;
 import android.media.AudioTimestamp;
@@ -11,61 +15,28 @@ import android.media.MediaRecorder;
 import android.os.Build;
 import android.os.Handler;
 import android.os.HandlerThread;
+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.Semaphore;
+import java.util.concurrent.atomic.AtomicBoolean;

 public final class AudioEncoder {

-    private static class InputTask {
-        private final int index;
-
-        InputTask(int index) {
-            this.index = index;
-        }
-    }
-
-    private static class OutputTask {
-        private final int index;
-        private final MediaCodec.BufferInfo bufferInfo;
-
-        OutputTask(int index, MediaCodec.BufferInfo bufferInfo) {
-            this.index = index;
-            this.bufferInfo = bufferInfo;
-        }
-    }
-
+    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 AudioRecord recorder;
    private MediaCodec mediaCodec;
-
-    // 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.
-    private final BlockingQueue<InputTask> inputTasks = new ArrayBlockingQueue<>(64);
-    private final BlockingQueue<OutputTask> outputTasks = new ArrayBlockingQueue<>(64);
-
-    private Thread thread;
-    private HandlerThread mediaCodecThread;
-
-    private Thread inputThread;
-    private Thread outputThread;
-
-    private boolean ended;
-
-    public AudioEncoder(Streamer streamer, int bitRate) {
-        this.streamer = streamer;
-        this.bitRate = bitRate;
-    }
+    private HandlerThread thread;
+    private final AtomicBoolean interrupted = new AtomicBoolean();
+    private final Semaphore endSemaphore = new Semaphore(0); // blocks until encoding is ended

    private static AudioFormat createAudioFormat() {
        AudioFormat.Builder builder = new AudioFormat.Builder();
@@ -89,232 +60,148 @@ 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() throws IOException, InterruptedException {
-        final AudioTimestamp timestamp = new AudioTimestamp();
-        long previousPts = 0;
-        long nextPts = 0;

-        while (!Thread.currentThread().isInterrupted()) {
-            InputTask task = inputTasks.take();
-            ByteBuffer buffer = mediaCodec.getInputBuffer(task.index);
-            int r = recorder.read(buffer, BUFFER_SIZE);
-            if (r < 0) {
-                throw new IOException("Could not read audio: " + r);
-            }
+    @TargetApi(Build.VERSION_CODES.M)
+    public void start() throws IOException {
+        mediaCodec = MediaCodec.createEncoderByType(MIMETYPE); // may throw IOException

-            long pts;
+        recorder = createAudioRecord();

-            int ret = recorder.getTimestamp(timestamp, AudioTimestamp.TIMEBASE_MONOTONIC);
-            if (ret == AudioRecord.SUCCESS) {
-                pts = timestamp.nanoTime / 1000;
-            } else {
-                if (nextPts == 0) {
-                    Ln.w("Could not get any audio timestamp");
-                }
-                // compute from previous timestamp and packet size
-                pts = nextPts;
-            }
+        MediaFormat format = createFormat();
+        mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);

-            long durationMs = r * 1000 / CHANNELS / SAMPLE_RATE;
-            nextPts = pts + durationMs;
+        recorder.startRecording();

-            if (previousPts != 0 && pts < previousPts) {
-                // Audio PTS may come from two sources:
-                //  - recorder.getTimestamp() if the call works;
-                //  - an estimation from the previous PTS and the packet size as a fallback.
-                //
-                // Therefore, the property that PTS are monotonically increasing is no guaranteed in corner cases, so enforce it.
-                pts = previousPts + 1;
-            }
-
-            mediaCodec.queueInputBuffer(task.index, 0, r, pts, 0);
-
-            previousPts = pts;
-        }
-    }
-
-    private void outputThread() throws IOException, InterruptedException {
-        streamer.writeHeader();
-
-        while (!Thread.currentThread().isInterrupted()) {
-            OutputTask task = outputTasks.take();
-            ByteBuffer buffer = mediaCodec.getOutputBuffer(task.index);
-            try {
-                streamer.writePacket(buffer, task.bufferInfo);
-            } finally {
-                mediaCodec.releaseOutputBuffer(task.index, false);
-            }
-        }
-    }
-
-    public void start() {
-        thread = new Thread(() -> {
-            try {
-                encode();
-            } catch (IOException e) {
-                Ln.e("Audio encoding error", e);
-            } finally {
-                Ln.d("Audio encoder stopped");
-            }
-        });
+        thread = new HandlerThread("AudioEncoder");
        thread.start();
+
+        class AudioEncoderCallbacks extends MediaCodec.Callback {
+
+            private final AudioTimestamp timestamp = new AudioTimestamp();
+            private long previousPts;
+            private long nextPts;
+            private boolean eofSignaled;
+            private boolean ended;
+
+            private void notifyEnded() {
+                assert !ended;
+                ended = true;
+                endSemaphore.release();
+            }
+
+            @TargetApi(Build.VERSION_CODES.N)
+            @Override
+            public void onInputBufferAvailable(MediaCodec codec, int index) {
+                if (eofSignaled) {
+                    return;
+                }
+
+                ByteBuffer inputBuffer = codec.getInputBuffer(index);
+                int r = recorder.read(inputBuffer, BUFFER_SIZE);
+
+                long pts;
+
+                int ret = recorder.getTimestamp(timestamp, AudioTimestamp.TIMEBASE_MONOTONIC);
+                if (ret == AudioRecord.SUCCESS) {
+                    pts = timestamp.nanoTime / 1000;
+                } else {
+                    if (nextPts == 0) {
+                        Ln.w("Could not get any audio timestamp");
+                    }
+                    // compute from previous timestamp and packet size
+                    pts = nextPts;
+                }
+
+                long durationMs = r * 1000 / CHANNELS / SAMPLE_RATE;
+                nextPts = pts + durationMs;
+
+                int flags = 0;
+                if (interrupted.get()) {
+                    flags = flags | MediaCodec.BUFFER_FLAG_END_OF_STREAM;
+                    eofSignaled = true;
+                }
+
+                if (previousPts != 0 && pts < previousPts) {
+                    // Audio PTS may come from two sources:
+                    //  - recorder.getTimestamp() if the call works;
+                    //  - an estimation from the previous PTS and the packet size as a fallback.
+                    //
+                    // Therefore, the property that PTS are monotonically increasing is no guaranteed in corner cases, so enforce it.
+                    pts = previousPts + 1;
+                }
+
+                codec.queueInputBuffer(index, 0, r, pts, flags);
+
+                previousPts = pts;
+            }
+
+            @Override
+            public void onOutputBufferAvailable(MediaCodec codec, int index, MediaCodec.BufferInfo bufferInfo) {
+                if (ended) {
+                    return;
+                }
+
+                ByteBuffer codecBuffer = codec.getOutputBuffer(index);
+                try {
+                    boolean isConfig = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0;
+                    long pts = bufferInfo.presentationTimeUs;
+                    Ln.i("Audio packet: pts=" + pts + " " + codecBuffer.remaining() + " bytes");
+                } finally {
+                    codec.releaseOutputBuffer(index, false);
+                }
+
+                boolean eof = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
+                if (eof) {
+                    notifyEnded();
+                }
+            }
+
+            @Override
+            public void onError(MediaCodec codec, MediaCodec.CodecException e) {
+                Ln.e("MediaCodec error", e);
+                if (!ended) {
+                    notifyEnded();
+                }
+            }
+
+            @Override
+            public void onOutputFormatChanged(MediaCodec codec, MediaFormat format) {
+                // ignore
+            }
+        }
+
+        mediaCodec.setCallback(new AudioEncoderCallbacks(), new Handler(thread.getLooper()));
+        mediaCodec.start();
+    }
+
+    private void waitEnded() {
+        try {
+            endSemaphore.acquire();
+        } catch (InterruptedException e) {
+            // ignore
+        }
    }

    public void stop() {
+        Ln.i("==== STOP");
        if (thread != null) {
-            // Just wake up the blocking wait from the thread, so that it properly releases all its resources and terminates
-            end();
-        }
-    }
-
-    public void join() throws InterruptedException {
-        if (thread != null) {
-            thread.join();
-        }
-    }
-
-    private synchronized void end() {
-        ended = true;
-        notify();
-    }
-
-    private synchronized void waitEnded() {
-        try {
-            while (!ended) {
-                wait();
-            }
-        } catch (InterruptedException e) {
-            // ignore
-        }
-    }
-
-    @TargetApi(Build.VERSION_CODES.M)
-    public void encode() throws IOException {
-        try {
-            try {
-                String mimeType = streamer.getCodec().getMimeType();
-
-                mediaCodec = MediaCodec.createEncoderByType(mimeType); // may throw IOException
-                recorder = createAudioRecord();
-
-                mediaCodecThread = new HandlerThread("AudioEncoder");
-                mediaCodecThread.start();
-
-                MediaFormat format = createFormat(mimeType, bitRate);
-                mediaCodec.setCallback(new EncoderCallback(), new Handler(mediaCodecThread.getLooper()));
-                mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
-
-                recorder.startRecording();
-            } catch (Throwable e) {
-                // Notify the client that the audio could not be captured
-                streamer.writeDisableStream();
-                throw e;
-            }
-
-            inputThread = new Thread(() -> {
-                try {
-                    inputThread();
-                } catch (IOException | InterruptedException e) {
-                    Ln.e("Audio capture error", e);
-                } finally {
-                    end();
-                }
-            });
-
-            outputThread = new Thread(() -> {
-                try {
-                    outputThread();
-                } catch (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();
-            inputThread.start();
-            outputThread.start();
-        } catch (Throwable e) {
-            if (mediaCodec != null) {
-                mediaCodec.release();
-            }
-            if (recorder != null) {
-                recorder.release();
-            }
-            throw e;
-        }
-
-        try {
+            interrupted.set(true);
            waitEnded();
-        } finally {
-            cleanUp();
-        }
-    }
-
-    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.stop();
-        mediaCodec.release();
-        recorder.stop();
-        recorder.release();
-    }
-
-    private class EncoderCallback extends MediaCodec.Callback {
-        @TargetApi(Build.VERSION_CODES.N)
-        @Override
-        public void onInputBufferAvailable(MediaCodec codec, int index) {
-            try {
-                inputTasks.put(new InputTask(index));
-            } catch (InterruptedException e) {
-                end();
-            }
-        }
-
-        @Override
-        public void onOutputBufferAvailable(MediaCodec codec, int index, MediaCodec.BufferInfo bufferInfo) {
-            try {
-                outputTasks.put(new OutputTask(index, bufferInfo));
-            } catch (InterruptedException e) {
-                end();
-            }
-        }
-
-        @Override
-        public void onError(MediaCodec codec, MediaCodec.CodecException e) {
-            Ln.e("MediaCodec error", e);
-            end();
-        }
-
-        @Override
-        public void onOutputFormatChanged(MediaCodec codec, MediaFormat format) {
-            // ignore
+            thread.interrupt();
+            thread = null;
+            mediaCodec.stop();
+            mediaCodec.release();
+            recorder.stop();
+            Ln.i("==== STOPPED");
        }
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Codec.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Codec.java
@@ -1,17 +0,0 @@
-package com.genymobile.scrcpy;
-
-public interface Codec {
-
-    enum Type {
-        VIDEO,
-        AUDIO,
-    }
-
-    Type getType();
-
-    int getId();
-
-    String getName();
-
-    String getMimeType();
-}
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@@ -90,7 +90,6 @@ public class Controller {
                control();
            } catch (IOException e) {
                // this is expected on close
-            } finally {
                Ln.d("Controller stopped");
            }
        });
@@ -101,17 +100,11 @@ public class Controller {
    public void stop() {
        if (thread != null) {
            thread.interrupt();
+            thread = null;
        }
        sender.stop();
    }

-    public void join() throws InterruptedException {
-        if (thread != null) {
-            thread.join();
-        }
-        sender.join();
-    }
-
    public DeviceMessageSender getSender() {
        return sender;
    }
--- 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;
@@ -83,9 +83,6 @@ public final class DesktopConnection implements Closeable {
                }
            } else {
                videoSocket = connect(socketName);
-                if (audio) {
-                    audioSocket = connect(socketName);
-                }
                if (control) {
                    controlSocket = connect(socketName);
                }
--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@@ -277,26 +277,6 @@ public final class Device {
     * @param mode one of the {@code POWER_MODE_*} constants
     */
    public static boolean setScreenPowerMode(int mode) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            // Change the power mode for all physical displays
-            long[] physicalDisplayIds = SurfaceControl.getPhysicalDisplayIds();
-            if (physicalDisplayIds == null) {
-                Ln.e("Could not get physical display ids");
-                return false;
-            }
-
-            boolean allOk = true;
-            for (long physicalDisplayId : physicalDisplayIds) {
-                IBinder binder = SurfaceControl.getPhysicalDisplayToken(physicalDisplayId);
-                boolean ok = SurfaceControl.setDisplayPowerMode(binder, mode);
-                if (!ok) {
-                    allOk = false;
-                }
-            }
-            return allOk;
-        }
-
-        // Older Android versions, only 1 display
        IBinder d = SurfaceControl.getBuiltInDisplay();
        if (d == null) {
            Ln.e("Could not get built-in display");
--- a/server/src/main/java/com/genymobile/scrcpy/DeviceMessageSender.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DeviceMessageSender.java
@@ -57,7 +57,6 @@ public final class DeviceMessageSender {
                loop();
            } catch (IOException | InterruptedException e) {
                // this is expected on close
-            } finally {
                Ln.d("Device message sender stopped");
            }
        });
@@ -67,12 +66,7 @@ public final class DeviceMessageSender {
    public void stop() {
        if (thread != null) {
            thread.interrupt();
-        }
-    }
-
-    public void join() throws InterruptedException {
-        if (thread != null) {
-            thread.join();
+            thread = null;
        }
    }
 }
--- 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/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@@ -5,15 +5,14 @@ import android.graphics.Rect;
 import java.util.List;

 public class Options {
+    private static final String VIDEO_CODEC_H264 = "h264";

    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 codec = VideoCodec.H264;
-    private AudioCodec audioCodec = AudioCodec.OPUS;
    private int bitRate = 8000000;
-    private int audioBitRate = 196000;
    private int maxFps;
    private int lockVideoOrientation = -1;
    private boolean tunnelForward;
@@ -44,12 +43,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() {
@@ -76,14 +75,6 @@ public class Options {
        this.codec = codec;
    }

-    public AudioCodec getAudioCodec() {
-        return audioCodec;
-    }
-
-    public void setAudioCodec(AudioCodec audioCodec) {
-        this.audioCodec = audioCodec;
-    }
-
    public int getBitRate() {
        return bitRate;
    }
@@ -92,14 +83,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;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@@ -21,6 +21,10 @@ import java.util.concurrent.atomic.AtomicBoolean;

 public class ScreenEncoder implements Device.RotationListener {

+    public interface Callbacks {
+        void onPacket(ByteBuffer codecBuffer, MediaCodec.BufferInfo bufferInfo) throws IOException;
+    }
+
    private static final int DEFAULT_I_FRAME_INTERVAL = 10; // seconds
    private static final int REPEAT_FRAME_DELAY_US = 100_000; // repeat after 100ms
    private static final String KEY_MAX_FPS_TO_ENCODER = "max-fps-to-encoder";
@@ -31,8 +35,7 @@ public class ScreenEncoder implements Device.RotationListener {

    private final AtomicBoolean rotationChanged = new AtomicBoolean();

-    private final Device device;
-    private final Streamer streamer;
+    private final String videoMimeType;
    private final String encoderName;
    private final List<CodecOption> codecOptions;
    private final int bitRate;
@@ -42,10 +45,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) {
-        this.device = device;
-        this.streamer = streamer;
+    public ScreenEncoder(String videoMimeType, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName, boolean downsizeOnError) {
+        this.videoMimeType = videoMimeType;
        this.bitRate = bitRate;
        this.maxFps = maxFps;
        this.codecOptions = codecOptions;
@@ -62,15 +63,11 @@ public class ScreenEncoder implements Device.RotationListener {
        return rotationChanged.getAndSet(false);
    }

-    public void streamScreen() throws IOException {
-        String videoMimeType = streamer.getCodec().getMimeType();
+    public void streamScreen(Device device, Callbacks callbacks) throws IOException {
        MediaCodec codec = createCodec(videoMimeType, encoderName);
        MediaFormat format = createFormat(videoMimeType, bitRate, maxFps, codecOptions);
        IBinder display = createDisplay();
        device.setRotationListener(this);
-
-        streamer.writeHeader();
-
        boolean alive;
        try {
            do {
@@ -95,7 +92,7 @@ public class ScreenEncoder implements Device.RotationListener {

                    codec.start();

-                    alive = encode(codec, streamer);
+                    alive = encode(codec, callbacks);
                    // do not call stop() on exception, it would trigger an IllegalStateException
                    codec.stop();
                } catch (IllegalStateException | IllegalArgumentException e) {
@@ -164,7 +161,7 @@ public class ScreenEncoder implements Device.RotationListener {
        return 0;
    }

-    private boolean encode(MediaCodec codec, Streamer streamer) throws IOException {
+    private boolean encode(MediaCodec codec, Callbacks callbacks) throws IOException {
        boolean eof = false;
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();

@@ -187,7 +184,7 @@ public class ScreenEncoder implements Device.RotationListener {
                        consecutiveErrors = 0;
                    }

-                    streamer.writePacket(codecBuffer, bufferInfo);
+                    callbacks.onPacket(codecBuffer, bufferInfo);
                }
            } finally {
                if (outputBufferId >= 0) {
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@@ -66,7 +66,7 @@ public final class Server {

        Thread initThread = startInitThread(options);

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

-        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());
            }
+            ScreenEncoder screenEncoder = new ScreenEncoder(codec.getMimeType(), options.getBitRate(), options.getMaxFps(), codecOptions,
+                    options.getEncoderName(), options.getDownsizeOnError());

            Controller controller = null;
            if (control) {
@@ -111,43 +113,27 @@ public final class Server {

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

-            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();
+                VideoStreamer videoStreamer = new VideoStreamer(connection.getVideoFd(), options.getSendFrameMeta());
+                if (options.getSendCodecId()) {
+                    videoStreamer.writeHeader(codec.getId());
+                }
+                screenEncoder.streamScreen(device, videoStreamer);
            } 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 {
+                // this is expected on close
                Ln.d("Screen streaming stopped");
+            } finally {
                initThread.interrupt();
-                if (audioEncoder != null) {
-                    audioEncoder.stop();
-                }
                if (controller != null) {
                    controller.stop();
                }
-
-                try {
-                    initThread.join();
-                    if (audioEncoder != null) {
-                        audioEncoder.join();
-                    }
-                    if (controller != null) {
-                        controller.join();
-                    }
-                } catch (InterruptedException e) {
-                    // ignore
+                if (audioEncoder != null) {
+                    audioEncoder.stop();
                }
            }
        }
@@ -159,7 +145,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 +167,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));
@@ -204,13 +189,6 @@ public final class Server {
                    }
                    options.setCodec(codec);
                    break;
-                case "audio_codec":
-                    AudioCodec audioCodec = AudioCodec.findByName(value);
-                    if (audioCodec == null) {
-                        throw new IllegalArgumentException("Audio codec " + value + " not supported");
-                    }
-                    options.setAudioCodec(audioCodec);
-                    break;
                case "max_size":
                    int maxSize = Integer.parseInt(value) & ~7; // multiple of 8
                    options.setMaxSize(maxSize);
@@ -219,10 +197,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);
--- a/server/src/main/java/com/genymobile/scrcpy/Streamer.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Streamer.java
@@ -1,121 +0,0 @@
-package com.genymobile.scrcpy;
-
-import android.media.MediaCodec;
-
-import java.io.FileDescriptor;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-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;
-    private final boolean sendFrameMeta;
-
-    private final ByteBuffer headerBuffer = ByteBuffer.allocate(12);
-
-    public Streamer(FileDescriptor fd, Codec codec, boolean sendCodecId, boolean sendFrameMeta) {
-        this.fd = fd;
-        this.codec = codec;
-        this.sendCodecId = sendCodecId;
-        this.sendFrameMeta = sendFrameMeta;
-    }
-
-    public Codec getCodec() {
-        return codec;
-    }
-
-    public void writeHeader() throws IOException {
-        if (sendCodecId) {
-            ByteBuffer buffer = ByteBuffer.allocate(4);
-            buffer.putInt(codec.getId());
-            buffer.flip();
-            IO.writeFully(fd, buffer);
-        }
-    }
-
-    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());
-        }
-
-        IO.writeFully(fd, codecBuffer);
-    }
-
-    private void writeFrameMeta(FileDescriptor fd, MediaCodec.BufferInfo bufferInfo, int packetSize) throws IOException {
-        headerBuffer.clear();
-
-        long ptsAndFlags;
-        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
-            ptsAndFlags = PACKET_FLAG_CONFIG; // non-media data packet
-        } else {
-            ptsAndFlags = bufferInfo.presentationTimeUs;
-            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) != 0) {
-                ptsAndFlags |= PACKET_FLAG_KEY_FRAME;
-            }
-        }
-
-        headerBuffer.putLong(ptsAndFlags);
-        headerBuffer.putInt(packetSize);
-        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/VideoCodec.java
+++ b/server/src/main/java/com/genymobile/scrcpy/VideoCodec.java
@@ -2,7 +2,7 @@ package com.genymobile.scrcpy;

 import android.media.MediaFormat;

-public enum VideoCodec implements Codec {
+public enum VideoCodec {
    H264(0x68_32_36_34, "h264", MediaFormat.MIMETYPE_VIDEO_AVC),
    H265(0x68_32_36_35, "h265", MediaFormat.MIMETYPE_VIDEO_HEVC),
    AV1(0x00_61_76_31, "av1", MediaFormat.MIMETYPE_VIDEO_AV1);
@@ -17,22 +17,10 @@ public enum VideoCodec implements Codec {
        this.mimeType = mimeType;
    }

-    @Override
-    public Type getType() {
-        return Type.VIDEO;
-    }
-
-    @Override
    public int getId() {
        return id;
    }

-    @Override
-    public String getName() {
-        return name;
-    }
-
-    @Override
    public String getMimeType() {
        return mimeType;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/VideoStreamer.java
+++ b/server/src/main/java/com/genymobile/scrcpy/VideoStreamer.java
@@ -0,0 +1,58 @@
+package com.genymobile.scrcpy;
+
+import android.media.MediaCodec;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+public final class VideoStreamer implements ScreenEncoder.Callbacks {
+
+    private static final long PACKET_FLAG_CONFIG = 1L << 63;
+    private static final long PACKET_FLAG_KEY_FRAME = 1L << 62;
+
+    private final FileDescriptor fd;
+    private final boolean sendFrameMeta;
+
+    private final ByteBuffer headerBuffer = ByteBuffer.allocate(12);
+
+    public VideoStreamer(FileDescriptor fd, boolean sendFrameMeta) {
+        this.fd = fd;
+        this.sendFrameMeta = sendFrameMeta;
+    }
+
+    public void writeHeader(int codecId) throws IOException {
+        ByteBuffer buffer = ByteBuffer.allocate(4);
+        buffer.putInt(codecId);
+        buffer.flip();
+        IO.writeFully(fd, buffer);
+    }
+
+    @Override
+    public void onPacket(ByteBuffer codecBuffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
+        if (sendFrameMeta) {
+            writeFrameMeta(fd, bufferInfo, codecBuffer.remaining());
+        }
+
+        IO.writeFully(fd, codecBuffer);
+    }
+
+    private void writeFrameMeta(FileDescriptor fd, MediaCodec.BufferInfo bufferInfo, int packetSize) throws IOException {
+        headerBuffer.clear();
+
+        long ptsAndFlags;
+        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
+            ptsAndFlags = PACKET_FLAG_CONFIG; // non-media data packet
+        } else {
+            ptsAndFlags = bufferInfo.presentationTimeUs;
+            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) != 0) {
+                ptsAndFlags |= PACKET_FLAG_KEY_FRAME;
+            }
+        }
+
+        headerBuffer.putLong(ptsAndFlags);
+        headerBuffer.putInt(packetSize);
+        headerBuffer.flip();
+        IO.writeFully(fd, headerBuffer);
+    }
+}
--- 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/server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java
@@ -30,8 +30,6 @@ public final class SurfaceControl {

    private static Method getBuiltInDisplayMethod;
    private static Method setDisplayPowerModeMethod;
-    private static Method getPhysicalDisplayTokenMethod;
-    private static Method getPhysicalDisplayIdsMethod;

    private SurfaceControl() {
        // only static methods
@@ -100,6 +98,7 @@ public final class SurfaceControl {
    }

    public static IBinder getBuiltInDisplay() {
+
        try {
            Method method = getGetBuiltInDisplayMethod();
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
@@ -115,40 +114,6 @@ public final class SurfaceControl {
        }
    }

-    private static Method getGetPhysicalDisplayTokenMethod() throws NoSuchMethodException {
-        if (getPhysicalDisplayTokenMethod == null) {
-            getPhysicalDisplayTokenMethod = CLASS.getMethod("getPhysicalDisplayToken", long.class);
-        }
-        return getPhysicalDisplayTokenMethod;
-    }
-
-    public static IBinder getPhysicalDisplayToken(long physicalDisplayId) {
-        try {
-            Method method = getGetPhysicalDisplayTokenMethod();
-            return (IBinder) method.invoke(null, physicalDisplayId);
-        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
-            Ln.e("Could not invoke method", e);
-            return null;
-        }
-    }
-
-    private static Method getGetPhysicalDisplayIdsMethod() throws NoSuchMethodException {
-        if (getPhysicalDisplayIdsMethod == null) {
-            getPhysicalDisplayIdsMethod = CLASS.getMethod("getPhysicalDisplayIds");
-        }
-        return getPhysicalDisplayIdsMethod;
-    }
-
-    public static long[] getPhysicalDisplayIds() {
-        try {
-            Method method = getGetPhysicalDisplayIdsMethod();
-            return (long[]) method.invoke(null);
-        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
-            Ln.e("Could not invoke method", e);
-            return null;
-        }
-    }
-
    private static Method getSetDisplayPowerModeMethod() throws NoSuchMethodException {
        if (setDisplayPowerModeMethod == null) {
            setDisplayPowerModeMethod = CLASS.getMethod("setDisplayPowerMode", IBinder.class, int.class);
Author	SHA1	Message	Date
Romain Vimont	422f15c595	Enforce monotonical PTS Audio PTS may come from two sources: - recorder.getTimestamp() if the call works; - an estimation from the previous PTS and the packet size as a fallback. Therefore, the property that PTS are monotonically increasing is no guaranteed in corner cases, so enforce it.	2023-02-03 17:07:49 +01:00
Romain Vimont	7ebaf5fe87	AudioEncoder WIP	2023-02-03 17:07:49 +01:00
Simon Chan	de95b61f81	Capture device audio WIP Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-02-03 17:07:49 +01:00
Simon Chan	18082bd7ab	socketwip Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-02-03 17:07:37 +01:00
Simon Chan	9654e0920b	audio option Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-02-03 17:06:00 +01:00
Romain Vimont	3f69e73722	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-03 17:06:00 +01:00
Romain Vimont	eb1830449e	Use FakeContext for Application instance This will expose the correct package name and UID to the application context.	2023-02-03 12:59:01 +01:00
Romain Vimont	56df8cd48f	Use shell package name for workarounds For consistency.	2023-02-03 12:58:57 +01:00
Romain Vimont	6c406c9319	Use PACKAGE_NAME from FakeContext Remove duplicated constant.	2023-02-03 12:58:54 +01:00
Romain Vimont	44e697cd9a	Use AttributionSource from FakeContext FakeContext already provides an AttributeSource instance. Co-authored-by: Simon Chan <1330321+yume-chan@users.noreply.github.com>	2023-02-03 12:58:52 +01:00
Simon Chan	132be1a81b	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-03 12:58:45 +01:00
Romain Vimont	5138ce75aa	Use Process.ROOT_UID Replace ServiceManager.USER_ID by existing constant Process.ROOT_UID.	2023-02-03 12:58:36 +01:00
Romain Vimont	ff3c3670b2	Add support for AV1 Add option --codec=av1.	2023-02-03 12:54:44 +01:00
Romain Vimont	e50e409405	Add support for H265 Add option --codec=h265.	2023-02-03 12:54:44 +01:00
Romain Vimont	07b65038a1	Add option to select video codec Introduce the selection mechanism. Alternative codecs will be added in further commits.	2023-02-03 12:54:27 +01:00