audio_player WIP

Add two-step write feature to bytebuf
If there is exactly one producer, then it can assume that the remaining space in the buffer will only increase until it write something. This assumption may allow the producer to write to the buffer (up to a known safe size) without any synchronization mechanism, thus allowing to read and write different parts of the buffer in parallel. The producer can then commit the write with lock held, and update its knowledge of the safe empty remaining space.
2023-02-25 19:39:29 +01:00 · 2023-02-25 19:39:11 +01:00 · 2023-02-25 19:39:11 +01:00 · 2023-02-25 19:39:11 +01:00 · 2023-02-25 19:39:11 +01:00 · 2023-02-25 19:39:11 +01:00
37 changed files with 1364 additions and 385 deletions
--- a/README.md
+++ b/README.md
@@ -199,7 +199,7 @@ preserved. That way, a device in 1920×1080 will be mirrored at 1024×576.
 The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):

 ```bash
-scrcpy --bit-rate=2M
+scrcpy --video-bit-rate=2M
 scrcpy -b 2M  # short version
 ```

@@ -258,9 +258,9 @@ 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
+scrcpy --video-codec=h264  # default
+scrcpy --video-codec=h265
+scrcpy --video-codec=av1
 ```


@@ -270,15 +270,13 @@ 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:

 ```bash
-scrcpy --encoder=OMX.qcom.video.encoder.avc
+scrcpy --video-encoder=OMX.qcom.video.encoder.avc
 ```

-To list the available encoders, you can pass an invalid encoder name; the
-error will give the available encoders:
+To list the available encoders:

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

 ### Capture
@@ -444,7 +442,7 @@ none found, try running `adb disconnect`, and then run those two commands again.
 It may be useful to decrease the bit-rate and the resolution:

 ```bash
-scrcpy --bit-rate=2M --max-size=800
+scrcpy --video-bit-rate=2M --max-size=800
 scrcpy -b2M -m800  # short version
 ```

--- a/app/data/bash-completion/scrcpy
+++ b/app/data/bash-completion/scrcpy
@@ -2,28 +2,33 @@ _scrcpy() {
    local cur prev words cword
    local opts="
        --always-on-top
-        -b --bit-rate=
-        --codec-options=
+        --audio-bit-rate=
+        --audio-codec=
+        --audio-codec-options=
+        --audio-encoder=
+        -b --video-bit-rate=
        --crop=
        -d --select-usb
        --disable-screensaver
        --display=
        --display-buffer=
        -e --select-tcpip
-        --encoder=
        --force-adb-forward
        --forward-all-clicks
        -f --fullscreen
        -K --hid-keyboard
        -h --help
        --legacy-paste
+        --list-displays
+        --list-encoders
        --lock-video-orientation
        --lock-video-orientation=
        --max-fps=
        -M --hid-mouse
        -m --max-size=
+        --no-audio
        --no-cleanup
-        --no-clipboard-on-error
+        --no-clipboard-autosync
        --no-downsize-on-error
        -n --no-control
        -N --no-display
@@ -53,6 +58,9 @@ _scrcpy() {
        --v4l2-sink=
        -V --verbosity=
        -v --version
+        --video-codec=
+        --video-codec-options=
+        --video-encoder=
        -w --stay-awake
        --window-borderless
        --window-title=
@@ -64,6 +72,14 @@ _scrcpy() {
    _init_completion -s || return

    case "$prev" in
+        --video-codec)
+            COMPREPLY=($(compgen -W 'h264 h265 av1' -- "$cur"))
+            return
+            ;;
+        --audio-codec)
+            COMPREPLY=($(compgen -W 'opus aac' -- "$cur"))
+            return
+            ;;
        --lock-video-orientation)
            COMPREPLY=($(compgen -W 'unlocked initial 0 1 2 3' -- "$cur"))
            return
@@ -98,7 +114,7 @@ _scrcpy() {
            COMPREPLY=($(compgen -W "$("${ADB:-adb}" devices | awk '$2 == "device" {print $1}')" -- ${cur}))
            return
            ;;
-        -b|--bitrate \
+        -b|--video-bit-rate \
        |--codec-options \
        |--crop \
        |--display \
--- a/app/data/zsh-completion/_scrcpy
+++ b/app/data/zsh-completion/_scrcpy
@@ -9,25 +9,30 @@ local arguments

 arguments=(
    '--always-on-top[Make scrcpy window always on top \(above other windows\)]'
-    {-b,--bit-rate=}'[Encode the video at the given bit-rate]'
-    '--codec-options=[Set a list of comma-separated key\:type=value options for the device encoder]'
+    '--audio-bit-rate=[Encode the audio at the given bit-rate]'
+    '--audio-codec=[Select the audio codec]:codec:(opus aac)'
+    '--audio-codec-options=[Set a list of comma-separated key\:type=value options for the device audio encoder]'
+    '--audio-encoder=[Use a specific MediaCodec audio encoder]'
+    {-b,--video-bit-rate=}'[Encode the video at the given bit-rate]'
    '--crop=[\[width\:height\:x\:y\] Crop the device screen on the server]'
    {-d,--select-usb}'[Use USB device]'
    '--disable-screensaver[Disable screensaver while scrcpy is running]'
    '--display=[Specify the display id to mirror]'
    '--display-buffer=[Add a buffering delay \(in milliseconds\) before displaying]'
    {-e,--select-tcpip}'[Use TCP/IP device]'
-    '--encoder=[Use a specific MediaCodec encoder \(must be a H.264 encoder\)]'
    '--force-adb-forward[Do not attempt to use \"adb reverse\" to connect to the device]'
    '--forward-all-clicks[Forward clicks to device]'
    {-f,--fullscreen}'[Start in fullscreen]'
    {-K,--hid-keyboard}'[Simulate a physical keyboard by using HID over AOAv2]'
    {-h,--help}'[Print the help]'
    '--legacy-paste[Inject computer clipboard text as a sequence of key events on Ctrl+v]'
+    '--list-displays[List displays available on the device]'
+    '--list-encoders[List video and audio encoders available on the device]'
    '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 1 2 3)'
    '--max-fps=[Limit the frame rate of screen capture]'
    {-M,--hid-mouse}'[Simulate a physical mouse by using HID over AOAv2]'
    {-m,--max-size=}'[Limit both the width and height of the video to value]'
+    '--no-audio[Disable audio forwarding]'
    '--no-cleanup[Disable device cleanup actions on exit]'
    '--no-clipboard-autosync[Disable automatic clipboard synchronization]'
    '--no-downsize-on-error[Disable lowering definition on MediaCodec error]'
@@ -58,6 +63,9 @@ arguments=(
    '--v4l2-sink=[\[\/dev\/videoN\] Output to v4l2loopback device]'
    {-V,--verbosity=}'[Set the log level]:verbosity:(verbose debug info warn error)'
    {-v,--version}'[Print the version of scrcpy]'
+    '--video-codec=[Select the video codec]:codec:(h264 h265 av1)'
+    '--video-codec-options=[Set a list of comma-separated key\:type=value options for the device video encoder]'
+    '--video-encoder=[Use a specific MediaCodec video encoder]'
    {-w,--stay-awake}'[Keep the device on while scrcpy is running, when the device is plugged in]'
    '--window-borderless[Disable window decorations \(display borderless window\)]'
    '--window-title=[Set a custom window title]'
--- a/app/meson.build
+++ b/app/meson.build
@@ -4,6 +4,7 @@ src = [
    'src/adb/adb_device.c',
    'src/adb/adb_parser.c',
    'src/adb/adb_tunnel.c',
+    'src/audio_player.c',
    'src/cli.c',
    'src/clock.c',
    'src/compat.c',
@@ -30,6 +31,7 @@ src = [
    'src/version.c',
    'src/video_buffer.c',
    'src/util/acksync.c',
+    'src/util/bytebuf.c',
    'src/util/file.c',
    'src/util/intmap.c',
    'src/util/intr.c',
@@ -260,6 +262,10 @@ if get_option('buildtype') == 'debug'
        ['test_binary', [
            'tests/test_binary.c',
        ]],
+        ['test_bytebuf', [
+            'tests/test_bytebuf.c',
+            'src/util/bytebuf.c',
+        ]],
        ['test_cbuf', [
            'tests/test_cbuf.c',
        ]],
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -35,28 +35,14 @@ Default is opus.
 .BI "\-\-audio\-encoder " name
 Use a specific MediaCodec audio encoder (depending on the codec provided by \fB\-\-audio\-codec\fR).

+The available encoders can be listed by \-\-list\-encoders.
+
 .TP
-.BI "\-b, \-\-bit\-rate " value
+.BI "\-b, \-\-video\-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).

-.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.
-
-The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
-
-The list of possible codec options is available in the Android documentation
-.UR https://d.android.com/reference/android/media/MediaFormat
-.UE .
-
 .TP
 .BI "\-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
 Crop the device screen on the server.
@@ -77,10 +63,9 @@ Disable screensaver while scrcpy is running.

 .TP
 .BI "\-\-display " id
-Specify the display id to mirror.
+Specify the device display id to mirror.

-The list of possible display ids can be listed by "adb shell dumpsys display"
-(search "mDisplayId=" in the output).
+The available display ids can be listed by \-\-list\-displays.

 Default is 0.

@@ -96,10 +81,6 @@ Use TCP/IP device (if there is exactly one, like adb -e).

 Also see \fB\-d\fR (\fB\-\-select\-usb\fR).

-.TP
-.BI "\-\-encoder " name
-Use a specific MediaCodec encoder (depending on the codec provided by \fB\-\-codec\fR).
-
 .TP
 .B \-\-force\-adb\-forward
 Do not attempt to use "adb reverse" to connect to the device.
@@ -138,6 +119,14 @@ Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+S

 This is a workaround for some devices not behaving as expected when setting the device clipboard programmatically.

+.TP
+.B \-\-list\-encoders
+List video and audio encoders available on the device.
+
+.TP
+.B \-\-list\-displays
+List displays available on the device.
+
 .TP
 \fB\-\-lock\-video\-orientation\fR[=\fIvalue\fR]
 Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees rotation counterclockwise.
@@ -345,6 +334,28 @@ Default is "info" for release builds, "debug" for debug builds.
 .B \-v, \-\-version
 Print the version of scrcpy.

+.TP
+.BI "\-\-video\-codec " name
+Select a video codec (h264, h265 or av1).
+
+Default is h264.
+
+.TP
+.BI "\-\-video\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
+Set a list of comma-separated key:type=value options for the device video encoder.
+
+The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
+
+The list of possible codec options is available in the Android documentation
+.UR https://d.android.com/reference/android/media/MediaFormat
+.UE .
+
+.TP
+.BI "\-\-video\-encoder " name
+Use a specific MediaCodec video encoder (depending on the codec provided by \fB\-\-video\-codec\fR).
+
+The available encoders can be listed by \-\-list\-encoders.
+
 .TP
 .B \-w, \-\-stay-awake
 Keep the device on while scrcpy is running, when the device is plugged in.
--- a/app/src/audio_player.c
+++ b/app/src/audio_player.c
@@ -0,0 +1,150 @@
+#include "audio_player.h"
+
+#include "util/log.h"
+
+/** Downcast frame_sink to sc_v4l2_sink */
+#define DOWNCAST(SINK) container_of(SINK, struct sc_audio_player, frame_sink)
+
+void
+sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
+    struct sc_audio_player *ap = userdata;
+
+    // This callback is called with the lock used by SDL_AudioDeviceLock(), so
+    // the bytebuf is protected
+
+    assert(len_int > 0);
+    size_t len = len_int;
+
+    size_t read = sc_bytebuf_read_remaining(&ap->buf);
+    if (read) {
+        if (read > len) {
+            read = len;
+        }
+        sc_bytebuf_read(&ap->buf, stream, read);
+    }
+    if (read < len) {
+        // Insert silence
+        memset(stream + read, 0, len - read);
+    }
+}
+
+static SDL_AudioFormat
+sc_audio_player_ffmpeg_to_sdl_format(enum AVSampleFormat format) {
+    switch (format) {
+        case AV_SAMPLE_FMT_S16:
+            return AUDIO_S16;
+        case AV_SAMPLE_FMT_S32:
+            return AUDIO_S32;
+        case AV_SAMPLE_FMT_FLT:
+            return AUDIO_F32;
+        default:
+            LOGE("Unsupported FFmpeg sample format: %s",
+                 av_get_sample_fmt_name(format));
+            return 0;
+    }
+}
+
+static bool
+sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
+                                const AVCodecContext *ctx) {
+    struct sc_audio_player *ap = DOWNCAST(sink);
+
+    SDL_AudioFormat format =
+        sc_audio_player_ffmpeg_to_sdl_format(ctx->sample_fmt);
+    if (!format) {
+        // error already logged
+        //return false;
+        format = AUDIO_F32; // it's planar, but for now there is only 1 channel
+    }
+    LOGI("%d\n", ctx->sample_rate);
+
+    SDL_AudioSpec desired = {
+        .freq = ctx->sample_rate,
+        .format = format,
+        .channels = 1,
+        .samples = 2048,
+        .callback = sc_audio_player_sdl_callback,
+        .userdata = ap,
+    };
+    SDL_AudioSpec obtained;
+
+    ap->device = SDL_OpenAudioDevice(NULL, 0, &desired, &obtained, 0);
+    if (!ap->device) {
+        LOGE("Could not open audio device: %s", SDL_GetError());
+        return false;
+    }
+
+    SDL_PauseAudioDevice(ap->device, 0);
+
+    return true;
+}
+
+static void
+sc_audio_player_frame_sink_close(struct sc_frame_sink *sink) {
+    struct sc_audio_player *ap = DOWNCAST(sink);
+
+    assert(ap->device);
+    SDL_PauseAudioDevice(ap->device, 1);
+    SDL_CloseAudioDevice(ap->device);
+}
+
+static bool
+sc_audio_player_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
+    struct sc_audio_player *ap = DOWNCAST(sink);
+
+    const uint8_t *data = frame->data[0];
+    size_t size = frame->linesize[0];
+
+    // TODO convert to non planar format
+    // TODO then re-enable stereo
+    // TODO clock drift compensation
+
+    // It should almost always be possible to write without lock
+    bool can_write_without_lock = size <= ap->safe_empty_buffer;
+    if (can_write_without_lock) {
+        sc_bytebuf_prepare_write(&ap->buf, data, size);
+    }
+
+    SDL_LockAudioDevice(ap->device);
+    if (can_write_without_lock) {
+        sc_bytebuf_commit_write(&ap->buf, size);
+    } else {
+        sc_bytebuf_write(&ap->buf, data, size);
+    }
+
+    // The next time, it will remain at least the current empty space
+    ap->safe_empty_buffer = sc_bytebuf_write_remaining(&ap->buf);
+    SDL_UnlockAudioDevice(ap->device);
+
+    return true;
+}
+
+bool
+sc_audio_player_init(struct sc_audio_player *ap,
+                     const struct sc_audio_player_callbacks *cbs,
+                     void *cbs_userdata) {
+    bool ok = sc_bytebuf_init(&ap->buf, 128 * 1024);
+    if (!ok) {
+        return false;
+    }
+
+    ap->safe_empty_buffer = sc_bytebuf_write_remaining(&ap->buf);
+
+    assert(cbs && cbs->on_ended);
+    ap->cbs = cbs;
+    ap->cbs_userdata = cbs_userdata;
+
+    static const struct sc_frame_sink_ops ops = {
+        .open = sc_audio_player_frame_sink_open,
+        .close = sc_audio_player_frame_sink_close,
+        .push = sc_audio_player_frame_sink_push,
+    };
+
+    ap->frame_sink.ops = &ops;
+    return true;
+}
+
+void
+sc_audio_player_destroy(struct sc_audio_player *ap) {
+    sc_bytebuf_destroy(&ap->buf);
+}
--- a/app/src/audio_player.h
+++ b/app/src/audio_player.h
@@ -0,0 +1,40 @@
+#ifndef SC_AUDIO_PLAYER_H
+#define SC_AUDIO_PLAYER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include "trait/frame_sink.h"
+#include <util/bytebuf.h>
+#include <util/thread.h>
+
+#include <libavformat/avformat.h>
+#include <SDL2/SDL.h>
+
+struct sc_audio_player {
+    struct sc_frame_sink frame_sink;
+
+    SDL_AudioDeviceID device;
+
+    // protected by SDL_AudioDeviceLock()
+    struct sc_bytebuf buf;
+    // Number of bytes which could be written without locking
+    size_t safe_empty_buffer;
+
+    const struct sc_audio_player_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+struct sc_audio_player_callbacks {
+    void (*on_ended)(struct sc_audio_player *ap, bool success, void *userdata);
+};
+
+bool
+sc_audio_player_init(struct sc_audio_player *ap,
+                     const struct sc_audio_player_callbacks *cbs,
+                     void *cbs_userdata);
+
+void
+sc_audio_player_destroy(struct sc_audio_player *ap);
+
+#endif
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -17,51 +17,59 @@
 #define STR_IMPL_(x) #x
 #define STR(x) STR_IMPL_(x)

-#define OPT_RENDER_EXPIRED_FRAMES  1000
-#define OPT_WINDOW_TITLE           1001
-#define OPT_PUSH_TARGET            1002
-#define OPT_ALWAYS_ON_TOP          1003
-#define OPT_CROP                   1004
-#define OPT_RECORD_FORMAT          1005
-#define OPT_PREFER_TEXT            1006
-#define OPT_WINDOW_X               1007
-#define OPT_WINDOW_Y               1008
-#define OPT_WINDOW_WIDTH           1009
-#define OPT_WINDOW_HEIGHT          1010
-#define OPT_WINDOW_BORDERLESS      1011
-#define OPT_MAX_FPS                1012
-#define OPT_LOCK_VIDEO_ORIENTATION 1013
-#define OPT_DISPLAY_ID             1014
-#define OPT_ROTATION               1015
-#define OPT_RENDER_DRIVER          1016
-#define OPT_NO_MIPMAPS             1017
-#define OPT_CODEC_OPTIONS          1018
-#define OPT_FORCE_ADB_FORWARD      1019
-#define OPT_DISABLE_SCREENSAVER    1020
-#define OPT_SHORTCUT_MOD           1021
-#define OPT_NO_KEY_REPEAT          1022
-#define OPT_FORWARD_ALL_CLICKS     1023
-#define OPT_LEGACY_PASTE           1024
-#define OPT_ENCODER_NAME           1025
-#define OPT_POWER_OFF_ON_CLOSE     1026
-#define OPT_V4L2_SINK              1027
-#define OPT_DISPLAY_BUFFER         1028
-#define OPT_V4L2_BUFFER            1029
-#define OPT_TUNNEL_HOST            1030
-#define OPT_TUNNEL_PORT            1031
-#define OPT_NO_CLIPBOARD_AUTOSYNC  1032
-#define OPT_TCPIP                  1033
-#define OPT_RAW_KEY_EVENTS         1034
-#define OPT_NO_DOWNSIZE_ON_ERROR   1035
-#define OPT_OTG                    1036
-#define OPT_NO_CLEANUP             1037
-#define OPT_PRINT_FPS              1038
-#define OPT_NO_POWER_ON            1039
-#define OPT_VIDEO_CODEC            1040
-#define OPT_NO_AUDIO               1041
-#define OPT_AUDIO_BIT_RATE         1042
-#define OPT_AUDIO_CODEC            1043
-#define OPT_AUDIO_ENCODER_NAME     1044
+enum {
+    OPT_RENDER_EXPIRED_FRAMES = 1000,
+    OPT_WINDOW_TITLE,
+    OPT_PUSH_TARGET,
+    OPT_ALWAYS_ON_TOP,
+    OPT_CROP,
+    OPT_RECORD_FORMAT,
+    OPT_PREFER_TEXT,
+    OPT_WINDOW_X,
+    OPT_WINDOW_Y,
+    OPT_WINDOW_WIDTH,
+    OPT_WINDOW_HEIGHT,
+    OPT_WINDOW_BORDERLESS,
+    OPT_MAX_FPS,
+    OPT_LOCK_VIDEO_ORIENTATION,
+    OPT_DISPLAY_ID,
+    OPT_ROTATION,
+    OPT_RENDER_DRIVER,
+    OPT_NO_MIPMAPS,
+    OPT_CODEC_OPTIONS,
+    OPT_VIDEO_CODEC_OPTIONS,
+    OPT_FORCE_ADB_FORWARD,
+    OPT_DISABLE_SCREENSAVER,
+    OPT_SHORTCUT_MOD,
+    OPT_NO_KEY_REPEAT,
+    OPT_FORWARD_ALL_CLICKS,
+    OPT_LEGACY_PASTE,
+    OPT_ENCODER,
+    OPT_VIDEO_ENCODER,
+    OPT_POWER_OFF_ON_CLOSE,
+    OPT_V4L2_SINK,
+    OPT_DISPLAY_BUFFER,
+    OPT_V4L2_BUFFER,
+    OPT_TUNNEL_HOST,
+    OPT_TUNNEL_PORT,
+    OPT_NO_CLIPBOARD_AUTOSYNC,
+    OPT_TCPIP,
+    OPT_RAW_KEY_EVENTS,
+    OPT_NO_DOWNSIZE_ON_ERROR,
+    OPT_OTG,
+    OPT_NO_CLEANUP,
+    OPT_PRINT_FPS,
+    OPT_NO_POWER_ON,
+    OPT_CODEC,
+    OPT_VIDEO_CODEC,
+    OPT_NO_AUDIO,
+    OPT_AUDIO_BIT_RATE,
+    OPT_AUDIO_CODEC,
+    OPT_AUDIO_CODEC_OPTIONS,
+    OPT_AUDIO_ENCODER,
+    OPT_LIST_ENCODERS,
+    OPT_LIST_DISPLAYS,
+};

 struct sc_option {
    char shortopt;
@@ -118,40 +126,48 @@ static const struct sc_option options[] = {
                "Default is opus.",
    },
    {
-        .longopt_id = OPT_AUDIO_ENCODER_NAME,
-        .longopt = "audio-encoder",
-        .argdesc = "name",
-        .text = "Use a specific MediaCodec audio encoder (depending on the "
-                "codec provided by --audio-codec).",
-    },
-    {
-        .shortopt = 'b',
-        .longopt = "bit-rate",
-        .argdesc = "value",
-        .text = "Encode the video at the given bit-rate, expressed in bits/s. "
-                "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
-                "Default is 8M (8000000).",
-    },
-    // TODO keep OPT_CODEC to avoid partial matching with codec_options
-    {
-        .longopt_id = OPT_VIDEO_CODEC,
-        .longopt = "video-codec",
-        .argdesc = "name",
-        .text = "Select a video codec (h264, h265 or av1).\n"
-                "Default is h264.",
-    },
-    {
-        .longopt_id = OPT_CODEC_OPTIONS,
-        .longopt = "codec-options",
+        .longopt_id = OPT_AUDIO_CODEC_OPTIONS,
+        .longopt = "audio-codec-options",
        .argdesc = "key[:type]=value[,...]",
        .text = "Set a list of comma-separated key:type=value options for the "
-                "device encoder.\n"
+                "device audio encoder.\n"
                "The possible values for 'type' are 'int' (default), 'long', "
                "'float' and 'string'.\n"
                "The list of possible codec options is available in the "
                "Android documentation: "
                "<https://d.android.com/reference/android/media/MediaFormat>",
    },
+    {
+        .longopt_id = OPT_AUDIO_ENCODER,
+        .longopt = "audio-encoder",
+        .argdesc = "name",
+        .text = "Use a specific MediaCodec audio encoder (depending on the "
+                "codec provided by --audio-codec).\n"
+                "The available encoders can be listed by --list-encoders.",
+    },
+    {
+        .shortopt = 'b',
+        .longopt = "video-bit-rate",
+        .argdesc = "value",
+        .text = "Encode the video at the given bit-rate, expressed in bits/s. "
+                "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
+                "Default is 8M (8000000).",
+    },
+    {
+        // Not really deprecated (--codec has never been released), but without
+        // declaring an explicit --codec option, getopt_long() partial matching
+        // behavior would consider --codec to be equivalent to --codec-options,
+        // which would be confusing.
+        .longopt_id = OPT_CODEC,
+        .longopt = "codec",
+        .argdesc = "value",
+    },
+    {
+        // deprecated
+        .longopt_id = OPT_CODEC_OPTIONS,
+        .longopt = "codec-options",
+        .argdesc = "key[:type]=value[,...]",
+    },
    {
        .longopt_id = OPT_CROP,
        .longopt = "crop",
@@ -176,10 +192,9 @@ static const struct sc_option options[] = {
        .longopt_id = OPT_DISPLAY_ID,
        .longopt = "display",
        .argdesc = "id",
-        .text = "Specify the display id to mirror.\n"
-                "The list of possible display ids can be listed by:\n"
-                "    adb shell dumpsys display\n"
-                "(search \"mDisplayId=\" in the output)\n"
+        .text = "Specify the device display id to mirror.\n"
+                "The available display ids can be listed by:\n"
+                "    scrcpy --list-displays\n"
                "Default is 0.",
    },
    {
@@ -197,11 +212,10 @@ static const struct sc_option options[] = {
                "Also see -d (--select-usb).",
    },
    {
-        .longopt_id = OPT_ENCODER_NAME,
+        // deprecated
+        .longopt_id = OPT_ENCODER,
        .longopt = "encoder",
        .argdesc = "name",
-        .text = "Use a specific MediaCodec encoder (depending on the codec "
-                "provided by --codec).",
    },
    {
        .longopt_id = OPT_FORCE_ADB_FORWARD,
@@ -251,6 +265,16 @@ static const struct sc_option options[] = {
                "This is a workaround for some devices not behaving as "
                "expected when setting the device clipboard programmatically.",
    },
+    {
+        .longopt_id = OPT_LIST_DISPLAYS,
+        .longopt = "list-displays",
+        .text = "List device displays.",
+    },
+    {
+        .longopt_id = OPT_LIST_ENCODERS,
+        .longopt = "list-encoders",
+        .text = "List video and audio encoders available on the device.",
+    },
    {
        .longopt_id = OPT_LOCK_VIDEO_ORIENTATION,
        .longopt = "lock-video-orientation",
@@ -292,6 +316,11 @@ static const struct sc_option options[] = {
                "is preserved.\n"
                "Default is 0 (unlimited).",
    },
+    {
+        .longopt_id = OPT_NO_AUDIO,
+        .longopt = "no-audio",
+        .text = "Disable audio forwarding.",
+    },
    {
        .longopt_id = OPT_NO_CLEANUP,
        .longopt = "no-cleanup",
@@ -327,11 +356,6 @@ static const struct sc_option options[] = {
        .text = "Do not display device (only when screen recording or V4L2 "
                "sink is enabled).",
    },
-    {
-        .longopt_id = OPT_NO_AUDIO,
-        .longopt = "no-audio",
-        .text = "Disable audio forwarding.",
-    },
    {
        .longopt_id = OPT_NO_KEY_REPEAT,
        .longopt = "no-key-repeat",
@@ -543,6 +567,33 @@ static const struct sc_option options[] = {
        .longopt = "version",
        .text = "Print the version of scrcpy.",
    },
+    {
+        .longopt_id = OPT_VIDEO_CODEC,
+        .longopt = "video-codec",
+        .argdesc = "name",
+        .text = "Select a video codec (h264, h265 or av1).\n"
+                "Default is h264.",
+    },
+    {
+        .longopt_id = OPT_VIDEO_CODEC_OPTIONS,
+        .longopt = "video-codec-options",
+        .argdesc = "key[:type]=value[,...]",
+        .text = "Set a list of comma-separated key:type=value options for the "
+                "device video encoder.\n"
+                "The possible values for 'type' are 'int' (default), 'long', "
+                "'float' and 'string'.\n"
+                "The list of possible codec options is available in the "
+                "Android documentation: "
+                "<https://d.android.com/reference/android/media/MediaFormat>",
+    },
+    {
+        .longopt_id = OPT_VIDEO_ENCODER,
+        .longopt = "video-encoder",
+        .argdesc = "name",
+        .text = "Use a specific MediaCodec video encoder (depending on the "
+                "codec provided by --video-codec).\n"
+                "The available encoders can be listed by --list-encoders.",
+    },
    {
        .shortopt = 'w',
        .longopt = "stay-awake",
@@ -1461,7 +1512,7 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
    while ((c = getopt_long(argc, argv, optstring, longopts, NULL)) != -1) {
        switch (c) {
            case 'b':
-                if (!parse_bit_rate(optarg, &opts->bit_rate)) {
+                if (!parse_bit_rate(optarg, &opts->video_bit_rate)) {
                    return false;
                }
                break;
@@ -1639,13 +1690,23 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                opts->forward_key_repeat = false;
                break;
            case OPT_CODEC_OPTIONS:
-                opts->codec_options = optarg;
+                LOGW("--codec-options is deprecated, use --video-codec-options "
+                     "instead.");
+                // fall through
+            case OPT_VIDEO_CODEC_OPTIONS:
+                opts->video_codec_options = optarg;
                break;
-            case OPT_ENCODER_NAME:
-                opts->encoder_name = optarg;
+            case OPT_AUDIO_CODEC_OPTIONS:
+                opts->audio_codec_options = optarg;
                break;
-            case OPT_AUDIO_ENCODER_NAME:
-                opts->audio_encoder_name = optarg;
+            case OPT_ENCODER:
+                LOGW("--encoder is deprecated, use --video-encoder instead.");
+                // fall through
+            case OPT_VIDEO_ENCODER:
+                opts->video_encoder = optarg;
+                break;
+            case OPT_AUDIO_ENCODER:
+                opts->audio_encoder = optarg;
                break;
            case OPT_FORCE_ADB_FORWARD:
                opts->force_adb_forward = true;
@@ -1694,6 +1755,9 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
            case OPT_PRINT_FPS:
                opts->start_fps_counter = true;
                break;
+            case OPT_CODEC:
+                LOGW("--codec is deprecated, use --video-codec instead.");
+                // fall through
            case OPT_VIDEO_CODEC:
                if (!parse_video_codec(optarg, &opts->video_codec)) {
                    return false;
@@ -1731,6 +1795,12 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                LOGE("V4L2 (--v4l2-buffer) is only available on Linux.");
                return false;
 #endif
+            case OPT_LIST_ENCODERS:
+                opts->list_encoders = true;
+                break;
+            case OPT_LIST_DISPLAYS:
+                opts->list_displays = true;
+                break;
            default:
                // getopt prints the error message on stderr
                return false;
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@@ -25,10 +25,10 @@ sc_decoder_close_sinks(struct sc_decoder *decoder) {
 }

 static bool
-sc_decoder_open_sinks(struct sc_decoder *decoder) {
+sc_decoder_open_sinks(struct sc_decoder *decoder, const AVCodecContext *ctx) {
    for (unsigned i = 0; i < decoder->sink_count; ++i) {
        struct sc_frame_sink *sink = decoder->sinks[i];
-        if (!sink->ops->open(sink)) {
+        if (!sink->ops->open(sink, ctx)) {
            sc_decoder_close_first_sinks(decoder, i);
            return false;
        }
@@ -47,8 +47,13 @@ sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {

    decoder->codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;

+    if (codec->type == AVMEDIA_TYPE_VIDEO) {
+        // Only YUV 4:2:0 is supported, hardcode it
+        decoder->codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
+    }
+
    if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
-        LOGE("Could not open codec");
+        LOGE("Decoder '%s': could not open codec", decoder->name);
        avcodec_free_context(&decoder->codec_ctx);
        return false;
    }
@@ -61,7 +66,7 @@ sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
        return false;
    }

-    if (!sc_decoder_open_sinks(decoder)) {
+    if (!sc_decoder_open_sinks(decoder, decoder->codec_ctx)) {
        av_frame_free(&decoder->frame);
        avcodec_close(decoder->codec_ctx);
        avcodec_free_context(&decoder->codec_ctx);
@@ -101,7 +106,8 @@ sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {

    int ret = avcodec_send_packet(decoder->codec_ctx, packet);
    if (ret < 0 && ret != AVERROR(EAGAIN)) {
-        LOGE("Could not send video packet: %d", ret);
+        LOGE("Decoder '%s': could not send video packet: %d",
+             decoder->name, ret);
        return false;
    }
    ret = avcodec_receive_frame(decoder->codec_ctx, decoder->frame);
@@ -114,7 +120,8 @@ sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {

        av_frame_unref(decoder->frame);
    } else if (ret != AVERROR(EAGAIN)) {
-        LOGE("Could not receive video frame: %d", ret);
+        LOGE("Decoder '%s', could not receive video frame: %d",
+             decoder->name, ret);
        return false;
    }
    return true;
@@ -140,7 +147,8 @@ sc_decoder_packet_sink_push(struct sc_packet_sink *sink,
 }

 void
-sc_decoder_init(struct sc_decoder *decoder) {
+sc_decoder_init(struct sc_decoder *decoder, const char *name) {
+    decoder->name = name; // statically allocated
    decoder->sink_count = 0;

    static const struct sc_packet_sink_ops ops = {
--- a/app/src/decoder.h
+++ b/app/src/decoder.h
@@ -14,6 +14,8 @@
 struct sc_decoder {
    struct sc_packet_sink packet_sink; // packet sink trait

+    const char *name; // must be statically allocated (e.g. a string literal)
+
    struct sc_frame_sink *sinks[SC_DECODER_MAX_SINKS];
    unsigned sink_count;

@@ -21,8 +23,9 @@ struct sc_decoder {
    AVFrame *frame;
 };

+// The name must be statically allocated (e.g. a string literal)
 void
-sc_decoder_init(struct sc_decoder *decoder);
+sc_decoder_init(struct sc_decoder *decoder, const char *name);

 void
 sc_decoder_add_sink(struct sc_decoder *decoder, struct sc_frame_sink *sink);
--- a/app/src/demuxer.c
+++ b/app/src/demuxer.c
@@ -195,6 +195,12 @@ run_demuxer(void *data) {
        goto end;
    }

+    if (raw_codec_id == 1) {
+        LOGE("Demuxer '%s': stream configuration error on the device",
+             demuxer->name);
+        goto end;
+    }
+
    enum AVCodecID codec_id = sc_demuxer_to_avcodec_id(raw_codec_id);
    if (codec_id == AV_CODEC_ID_NONE) {
        LOGE("Demuxer '%s': stream disabled due to unsupported codec",
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -73,6 +73,8 @@ main_scrcpy(int argc, char *argv[]) {
        return SCRCPY_EXIT_FAILURE;
    }

+    sc_log_configure();
+
 #ifdef HAVE_USB
    enum scrcpy_exit_code ret = args.opts.otg ? scrcpy_otg(&args.opts)
                                              : scrcpy(&args.opts);
--- a/app/src/options.c
+++ b/app/src/options.c
@@ -7,8 +7,10 @@ const struct scrcpy_options scrcpy_options_default = {
    .window_title = NULL,
    .push_target = NULL,
    .render_driver = NULL,
-    .codec_options = NULL,
-    .encoder_name = NULL,
+    .video_codec_options = NULL,
+    .audio_codec_options = NULL,
+    .video_encoder = NULL,
+    .audio_encoder = NULL,
 #ifdef HAVE_V4L2
    .v4l2_device = NULL,
 #endif
@@ -17,6 +19,7 @@ const struct scrcpy_options scrcpy_options_default = {
    .audio_codec = SC_CODEC_OPUS,
    .record_format = SC_RECORD_FORMAT_AUTO,
    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
+    .mouse_input_mode = SC_MOUSE_INPUT_MODE_INJECT,
    .port_range = {
        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
        .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
@@ -28,7 +31,7 @@ const struct scrcpy_options scrcpy_options_default = {
        .count = 2,
    },
    .max_size = 0,
-    .bit_rate = 0,
+    .video_bit_rate = 0,
    .audio_bit_rate = 0,
    .max_fps = 0,
    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
@@ -69,4 +72,6 @@ const struct scrcpy_options scrcpy_options_default = {
    .start_fps_counter = false,
    .power_on = true,
    .audio = true,
+    .list_encoders = false,
+    .list_displays = false,
 };
--- a/app/src/options.h
+++ b/app/src/options.h
@@ -95,9 +95,10 @@ struct scrcpy_options {
    const char *window_title;
    const char *push_target;
    const char *render_driver;
-    const char *codec_options;
-    const char *encoder_name;
-    const char *audio_encoder_name;
+    const char *video_codec_options;
+    const char *audio_codec_options;
+    const char *video_encoder;
+    const char *audio_encoder;
 #ifdef HAVE_V4L2
    const char *v4l2_device;
 #endif
@@ -112,7 +113,7 @@ struct scrcpy_options {
    uint16_t tunnel_port;
    struct sc_shortcut_mods shortcut_mods;
    uint16_t max_size;
-    uint32_t bit_rate;
+    uint32_t video_bit_rate;
    uint32_t audio_bit_rate;
    uint16_t max_fps;
    enum sc_lock_video_orientation lock_video_orientation;
@@ -153,6 +154,8 @@ struct scrcpy_options {
    bool start_fps_counter;
    bool power_on;
    bool audio;
+    bool list_encoders;
+    bool list_displays;
 };

 extern const struct scrcpy_options scrcpy_options_default;
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@@ -726,7 +726,6 @@ sc_recorder_init(struct sc_recorder *recorder, const char *filename,
    recorder->declared_frame_size = declared_frame_size;

    assert(cbs && cbs->on_ended);
-
    recorder->cbs = cbs;
    recorder->cbs_userdata = cbs_userdata;

@@ -749,17 +748,8 @@ sc_recorder_init(struct sc_recorder *recorder, const char *filename,
        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;
-    }
-
    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:
@@ -770,6 +760,18 @@ error_free_filename:
    return false;
 }

+bool
+sc_recorder_start(struct sc_recorder *recorder) {
+    bool ok = sc_thread_create(&recorder->thread, run_recorder,
+                               "scrcpy-recorder", recorder);
+    if (!ok) {
+        LOGE("Could not start recorder thread");
+        return false;
+    }
+
+    return true;
+}
+
 void
 sc_recorder_stop(struct sc_recorder *recorder) {
    sc_mutex_lock(&recorder->mutex);
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@@ -72,6 +72,9 @@ sc_recorder_init(struct sc_recorder *recorder, const char *filename,
                 struct sc_size declared_frame_size,
                 const struct sc_recorder_callbacks *cbs, void *cbs_userdata);

+bool
+sc_recorder_start(struct sc_recorder *recorder);
+
 void
 sc_recorder_stop(struct sc_recorder *recorder);

--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -13,6 +13,7 @@
 # include <windows.h>
 #endif

+#include "audio_player.h"
 #include "controller.h"
 #include "decoder.h"
 #include "demuxer.h"
@@ -40,9 +41,11 @@
 struct scrcpy {
    struct sc_server server;
    struct sc_screen screen;
+    struct sc_audio_player audio_player;
    struct sc_demuxer video_demuxer;
    struct sc_demuxer audio_demuxer;
-    struct sc_decoder decoder;
+    struct sc_decoder video_decoder;
+    struct sc_decoder audio_decoder;
    struct sc_recorder recorder;
 #ifdef HAVE_V4L2
    struct sc_v4l2_sink v4l2_sink;
@@ -183,15 +186,16 @@ await_for_server(bool *connected) {
    while (SDL_WaitEvent(&event)) {
        switch (event.type) {
            case SDL_QUIT:
-                LOGD("User requested to quit");
-                *connected = false;
+                if (connected) {
+                    *connected = false;
+                }
                return true;
            case SC_EVENT_SERVER_CONNECTION_FAILED:
-                LOGE("Server connection failed");
                return false;
            case SC_EVENT_SERVER_CONNECTED:
-                LOGD("Server connected");
-                *connected = true;
+                if (connected) {
+                    *connected = true;
+                }
                return true;
            default:
                break;
@@ -202,43 +206,6 @@ await_for_server(bool *connected) {
    return false;
 }

-static SDL_LogPriority
-sdl_priority_from_av_level(int level) {
-    switch (level) {
-        case AV_LOG_PANIC:
-        case AV_LOG_FATAL:
-            return SDL_LOG_PRIORITY_CRITICAL;
-        case AV_LOG_ERROR:
-            return SDL_LOG_PRIORITY_ERROR;
-        case AV_LOG_WARNING:
-            return SDL_LOG_PRIORITY_WARN;
-        case AV_LOG_INFO:
-            return SDL_LOG_PRIORITY_INFO;
-    }
-    // do not forward others, which are too verbose
-    return 0;
-}
-
-static void
-av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
-    (void) avcl;
-    SDL_LogPriority priority = sdl_priority_from_av_level(level);
-    if (priority == 0) {
-        return;
-    }
-
-    size_t fmt_len = strlen(fmt);
-    char *local_fmt = malloc(fmt_len + 10);
-    if (!local_fmt) {
-        LOG_OOM();
-        return;
-    }
-    memcpy(local_fmt, "[FFmpeg] ", 9); // do not write the final '\0'
-    memcpy(local_fmt + 9, fmt, fmt_len + 1); // include '\0'
-    SDL_LogMessageV(SDL_LOG_CATEGORY_VIDEO, priority, local_fmt, vl);
-    free(local_fmt);
-}
-
 static void
 sc_recorder_on_ended(struct sc_recorder *recorder, bool success,
                     void *userdata) {
@@ -250,6 +217,17 @@ sc_recorder_on_ended(struct sc_recorder *recorder, bool success,
    }
 }

+static void
+sc_audio_player_on_ended(struct sc_audio_player *ap, bool success,
+                         void *userdata) {
+    (void) ap;
+    (void) userdata;
+
+    if (!success) {
+        // TODO
+    }
+}
+
 static void
 sc_video_demuxer_on_ended(struct sc_demuxer *demuxer, bool eos,
                          void *userdata) {
@@ -267,10 +245,19 @@ 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
+    // Contrary to the video demuxer, keep mirroring if only the audio fails.
+    // 'eos' is true on end-of-stream, including when audio capture is not
+    // possible on the device (so that scrcpy continue to mirror video without
+    // failing).
+    // However, if an audio configuration failure occurs (for example the user
+    // explicitly selected an unknown audio encoder), 'eos' is false and scrcpy
+    // must exit.
+
+    if (!eos) {
+        PUSH_EVENT(SC_EVENT_DEMUXER_ERROR);
+    }
 }

 static void
@@ -326,6 +313,8 @@ scrcpy(struct scrcpy_options *options) {
    bool server_started = false;
    bool file_pusher_initialized = false;
    bool recorder_initialized = false;
+    bool recorder_started = false;
+    bool audio_player_initialized = false;
 #ifdef HAVE_V4L2
    bool v4l2_sink_initialized = false;
 #endif
@@ -357,7 +346,7 @@ scrcpy(struct scrcpy_options *options) {
        .tunnel_host = options->tunnel_host,
        .tunnel_port = options->tunnel_port,
        .max_size = options->max_size,
-        .bit_rate = options->bit_rate,
+        .video_bit_rate = options->video_bit_rate,
        .audio_bit_rate = options->audio_bit_rate,
        .max_fps = options->max_fps,
        .lock_video_orientation = options->lock_video_orientation,
@@ -366,9 +355,10 @@ scrcpy(struct scrcpy_options *options) {
        .audio = options->audio,
        .show_touches = options->show_touches,
        .stay_awake = options->stay_awake,
-        .codec_options = options->codec_options,
-        .encoder_name = options->encoder_name,
-        .audio_encoder_name = options->audio_encoder_name,
+        .video_codec_options = options->video_codec_options,
+        .audio_codec_options = options->audio_codec_options,
+        .video_encoder = options->video_encoder,
+        .audio_encoder = options->audio_encoder,
        .force_adb_forward = options->force_adb_forward,
        .power_off_on_close = options->power_off_on_close,
        .clipboard_autosync = options->clipboard_autosync,
@@ -377,6 +367,8 @@ scrcpy(struct scrcpy_options *options) {
        .tcpip_dst = options->tcpip_dst,
        .cleanup = options->cleanup,
        .power_on = options->power_on,
+        .list_encoders = options->list_encoders,
+        .list_displays = options->list_displays,
    };

    static const struct sc_server_callbacks cbs = {
@@ -394,14 +386,27 @@ scrcpy(struct scrcpy_options *options) {

    server_started = true;

+    if (options->list_encoders || options->list_displays) {
+        bool ok = await_for_server(NULL);
+        ret = ok ? SCRCPY_EXIT_SUCCESS : SCRCPY_EXIT_FAILURE;
+        goto end;
+    }
+
    if (options->display) {
        sdl_set_hints(options->render_driver);
    }

    // Initialize SDL video in addition if display is enabled
-    if (options->display && SDL_Init(SDL_INIT_VIDEO)) {
-        LOGE("Could not initialize SDL: %s", SDL_GetError());
-        goto end;
+    if (options->display) {
+        if (SDL_Init(SDL_INIT_VIDEO)) {
+            LOGE("Could not initialize SDL video: %s", SDL_GetError());
+            goto end;
+        }
+
+        if (options->audio && SDL_Init(SDL_INIT_AUDIO)) {
+            LOGE("Could not initialize SDL audio: %s", SDL_GetError());
+            goto end;
+        }
    }

    sdl_configure(options->display, options->disable_screensaver);
@@ -409,15 +414,19 @@ scrcpy(struct scrcpy_options *options) {
    // Await for server without blocking Ctrl+C handling
    bool connected;
    if (!await_for_server(&connected)) {
+        LOGE("Server connection failed");
        goto end;
    }

    if (!connected) {
        // This is not an error, user requested to quit
+        LOGD("User requested to quit");
        ret = SCRCPY_EXIT_SUCCESS;
        goto end;
    }

+    LOGD("Server connected");
+
    // It is necessarily initialized here, since the device is connected
    struct sc_server_info *info = &s->server.info;

@@ -435,32 +444,6 @@ scrcpy(struct scrcpy_options *options) {
        file_pusher_initialized = true;
    }

-    struct sc_decoder *dec = NULL;
-    bool needs_decoder = options->display;
-#ifdef HAVE_V4L2
-    needs_decoder |= !!options->v4l2_device;
-#endif
-    if (needs_decoder) {
-        sc_decoder_init(&s->decoder);
-        dec = &s->decoder;
-    }
-
-    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)) {
-            goto end;
-        }
-        rec = &s->recorder;
-        recorder_initialized = true;
-    }
-
-    av_log_set_callback(av_log_callback);
-
    static const struct sc_demuxer_callbacks video_demuxer_cbs = {
        .on_ended = sc_video_demuxer_on_ended,
    };
@@ -475,14 +458,40 @@ scrcpy(struct scrcpy_options *options) {
                        &audio_demuxer_cbs, NULL);
    }

-    if (dec) {
-        sc_demuxer_add_sink(&s->video_demuxer, &dec->packet_sink);
+    bool needs_video_decoder = options->display;
+    bool needs_audio_decoder = options->audio && options->display;
+#ifdef HAVE_V4L2
+    needs_video_decoder |= !!options->v4l2_device;
+#endif
+    if (needs_video_decoder) {
+        sc_decoder_init(&s->video_decoder, "video");
+        sc_demuxer_add_sink(&s->video_demuxer, &s->video_decoder.packet_sink);
+    }
+    if (needs_audio_decoder) {
+        sc_decoder_init(&s->audio_decoder, "audio");
+        sc_demuxer_add_sink(&s->audio_demuxer, &s->audio_decoder.packet_sink);
    }

-    if (rec) {
-        sc_demuxer_add_sink(&s->video_demuxer, &rec->video_packet_sink);
+    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)) {
+            goto end;
+        }
+        recorder_initialized = true;
+
+        if (!sc_recorder_start(&s->recorder)) {
+            goto end;
+        }
+        recorder_started = true;
+
+        sc_demuxer_add_sink(&s->video_demuxer, &s->recorder.video_packet_sink);
        if (options->audio) {
-            sc_demuxer_add_sink(&s->audio_demuxer, &rec->audio_packet_sink);
+            sc_demuxer_add_sink(&s->audio_demuxer,
+                                &s->recorder.audio_packet_sink);
        }
    }

@@ -674,7 +683,20 @@ aoa_hid_end:
        }
        screen_initialized = true;

-        sc_decoder_add_sink(&s->decoder, &s->screen.frame_sink);
+        sc_decoder_add_sink(&s->video_decoder, &s->screen.frame_sink);
+
+        if (options->audio) {
+            static const struct sc_audio_player_callbacks audio_player_cbs = {
+                .on_ended = sc_audio_player_on_ended,
+            };
+            if (!sc_audio_player_init(&s->audio_player,
+                                      &audio_player_cbs, NULL)) {
+                goto end;
+            }
+            audio_player_initialized = true;
+
+            sc_decoder_add_sink(&s->audio_decoder, &s->audio_player.frame_sink);
+        }
    }

 #ifdef HAVE_V4L2
@@ -684,7 +706,7 @@ aoa_hid_end:
            goto end;
        }

-        sc_decoder_add_sink(&s->decoder, &s->v4l2_sink.frame_sink);
+        sc_decoder_add_sink(&s->video_decoder, &s->v4l2_sink.frame_sink);

        v4l2_sink_initialized = true;
    }
@@ -788,16 +810,26 @@ end:
        sc_controller_destroy(&s->controller);
    }

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

+    if (audio_player_initialized) {
+        sc_audio_player_destroy(&s->audio_player);
+    }
+
    if (file_pusher_initialized) {
        sc_file_pusher_join(&s->file_pusher);
        sc_file_pusher_destroy(&s->file_pusher);
    }

+    if (server_started) {
+        sc_server_join(&s->server);
+    }
+
    sc_server_destroy(&s->server);

    return ret;
--- a/app/src/screen.c
+++ b/app/src/screen.c
@@ -330,7 +330,10 @@ event_watcher(void *data, SDL_Event *event) {
 #endif

 static bool
-sc_screen_frame_sink_open(struct sc_frame_sink *sink) {
+sc_screen_frame_sink_open(struct sc_frame_sink *sink,
+                          const AVCodecContext *ctx) {
+    assert(ctx->pix_fmt == AV_PIX_FMT_YUV420P);
+
    struct sc_screen *screen = DOWNCAST(sink);
    (void) screen;
 #ifndef NDEBUG
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -71,9 +71,10 @@ sc_server_params_destroy(struct sc_server_params *params) {
    // The server stores a copy of the params provided by the user
    free((char *) params->req_serial);
    free((char *) params->crop);
-    free((char *) params->codec_options);
-    free((char *) params->encoder_name);
-    free((char *) params->audio_encoder_name);
+    free((char *) params->video_codec_options);
+    free((char *) params->audio_codec_options);
+    free((char *) params->video_encoder);
+    free((char *) params->audio_encoder);
    free((char *) params->tcpip_dst);
 }

@@ -96,9 +97,10 @@ sc_server_params_copy(struct sc_server_params *dst,

    COPY(req_serial);
    COPY(crop);
-    COPY(codec_options);
-    COPY(encoder_name);
-    COPY(audio_encoder_name);
+    COPY(video_codec_options);
+    COPY(audio_codec_options);
+    COPY(video_encoder);
+    COPY(audio_encoder);
    COPY(tcpip_dst);
 #undef COPY

@@ -222,8 +224,8 @@ execute_server(struct sc_server *server,
    ADD_PARAM("scid=%08x", params->scid);
    ADD_PARAM("log_level=%s", log_level_to_server_string(params->log_level));

-    if (params->bit_rate) {
-        ADD_PARAM("bit_rate=%" PRIu32, params->bit_rate);
+    if (params->video_bit_rate) {
+        ADD_PARAM("video_bit_rate=%" PRIu32, params->video_bit_rate);
    }
    if (!params->audio) {
        ADD_PARAM("audio=false");
@@ -267,14 +269,17 @@ execute_server(struct sc_server *server,
    if (params->stay_awake) {
        ADD_PARAM("stay_awake=true");
    }
-    if (params->codec_options) {
-        ADD_PARAM("codec_options=%s", params->codec_options);
+    if (params->video_codec_options) {
+        ADD_PARAM("video_codec_options=%s", params->video_codec_options);
    }
-    if (params->encoder_name) {
-        ADD_PARAM("encoder_name=%s", params->encoder_name);
+    if (params->audio_codec_options) {
+        ADD_PARAM("audio_codec_options=%s", params->audio_codec_options);
    }
-    if (params->audio_encoder_name) {
-        ADD_PARAM("audio_encoder_name=%s", params->audio_encoder_name);
+    if (params->video_encoder) {
+        ADD_PARAM("video_encoder=%s", params->video_encoder);
+    }
+    if (params->audio_encoder) {
+        ADD_PARAM("audio_encoder=%s", params->audio_encoder);
    }
    if (params->power_off_on_close) {
        ADD_PARAM("power_off_on_close=true");
@@ -295,6 +300,12 @@ execute_server(struct sc_server *server,
        // By default, power_on is true
        ADD_PARAM("power_on=false");
    }
+    if (params->list_encoders) {
+        ADD_PARAM("list_encoders=true");
+    }
+    if (params->list_displays) {
+        ADD_PARAM("list_displays=true");
+    }

 #undef ADD_PARAM

@@ -838,6 +849,25 @@ run_server(void *data) {
    assert(serial);
    LOGD("Device serial: %s", serial);

+    ok = push_server(&server->intr, serial);
+    if (!ok) {
+        goto error_connection_failed;
+    }
+
+    // If --list-* is passed, then the server just prints the requested data
+    // then exits.
+    if (params->list_encoders || params->list_displays) {
+        sc_pid pid = execute_server(server, params);
+        if (pid == SC_PROCESS_NONE) {
+            goto error_connection_failed;
+        }
+        sc_process_wait(pid, NULL); // ignore exit code
+        sc_process_close(pid);
+        // Wake up await_for_server()
+        server->cbs->on_connected(server, server->cbs_userdata);
+        return 0;
+    }
+
    int r = asprintf(&server->device_socket_name, SC_SOCKET_NAME_PREFIX "%08x",
                     params->scid);
    if (r == -1) {
@@ -847,11 +877,6 @@ run_server(void *data) {
    assert(r == sizeof(SC_SOCKET_NAME_PREFIX) - 1 + 8);
    assert(server->device_socket_name);

-    ok = push_server(&server->intr, serial);
-    if (!ok) {
-        goto error_connection_failed;
-    }
-
    ok = sc_adb_tunnel_open(&server->tunnel, &server->intr, serial,
                            server->device_socket_name, params->port_range,
                            params->force_adb_forward);
@@ -961,7 +986,10 @@ sc_server_stop(struct sc_server *server) {
    sc_cond_signal(&server->cond_stopped);
    sc_intr_interrupt(&server->intr);
    sc_mutex_unlock(&server->mutex);
+}

+void
+sc_server_join(struct sc_server *server) {
    sc_thread_join(&server->thread, NULL);
 }

--- a/app/src/server.h
+++ b/app/src/server.h
@@ -28,14 +28,15 @@ struct sc_server_params {
    enum sc_codec video_codec;
    enum sc_codec audio_codec;
    const char *crop;
-    const char *codec_options;
-    const char *encoder_name;
-    const char *audio_encoder_name;
+    const char *video_codec_options;
+    const char *audio_codec_options;
+    const char *video_encoder;
+    const char *audio_encoder;
    struct sc_port_range port_range;
    uint32_t tunnel_host;
    uint16_t tunnel_port;
    uint16_t max_size;
-    uint32_t bit_rate;
+    uint32_t video_bit_rate;
    uint32_t audio_bit_rate;
    uint16_t max_fps;
    int8_t lock_video_orientation;
@@ -54,6 +55,8 @@ struct sc_server_params {
    bool select_tcpip;
    bool cleanup;
    bool power_on;
+    bool list_encoders;
+    bool list_displays;
 };

 struct sc_server {
@@ -113,6 +116,10 @@ sc_server_start(struct sc_server *server);
 void
 sc_server_stop(struct sc_server *server);

+// join the server thread
+void
+sc_server_join(struct sc_server *server);
+
 // close and release sockets
 void
 sc_server_destroy(struct sc_server *server);
--- a/app/src/trait/frame_sink.h
+++ b/app/src/trait/frame_sink.h
@@ -5,6 +5,7 @@

 #include <assert.h>
 #include <stdbool.h>
+#include <libavcodec/avcodec.h>

 typedef struct AVFrame AVFrame;

@@ -18,7 +19,7 @@ struct sc_frame_sink {
 };

 struct sc_frame_sink_ops {
-    bool (*open)(struct sc_frame_sink *sink);
+    bool (*open)(struct sc_frame_sink *sink, const AVCodecContext *ctx);
    void (*close)(struct sc_frame_sink *sink);
    bool (*push)(struct sc_frame_sink *sink, const AVFrame *frame);
 };
--- a/app/src/util/bytebuf.c
+++ b/app/src/util/bytebuf.c
@@ -0,0 +1,114 @@
+#include "bytebuf.h"
+
+#include <assert.h>
+
+#include "util/log.h"
+
+bool
+sc_bytebuf_init(struct sc_bytebuf *buf, size_t alloc_size) {
+    assert(alloc_size);
+    // sufficient, but use more for alignment.
+    buf->data = malloc(alloc_size);
+    if (!buf->data) {
+        LOG_OOM();
+        return false;
+    }
+
+    buf->alloc_size = alloc_size;
+    buf->head = 0;
+    buf->tail = 0;
+
+    return true;
+}
+
+void
+sc_bytebuf_destroy(struct sc_bytebuf *buf) {
+    free(buf->data);
+}
+
+void
+sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len) {
+    assert(len);
+    assert(sc_bytebuf_read_remaining(buf) >= len);
+    assert(buf->tail != buf->head); // the buffer could not be empty
+
+    size_t right_limit = buf->tail < buf->head ? buf->head : buf->alloc_size;
+    size_t right_len = right_limit - buf->tail;
+    if (len < right_len) {
+        right_len = len;
+    }
+    memcpy(to, buf->data + buf->tail, right_len);
+
+    if (len > right_len) {
+        memcpy(to + right_len, buf->data, len - right_len);
+    }
+
+    buf->tail = (buf->tail + len) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len) {
+    assert(len);
+    assert(sc_bytebuf_read_remaining(buf) >= len);
+    assert(buf->tail != buf->head); // the buffer could not be empty
+
+    buf->tail = (buf->tail + len) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len) {
+    assert(len);
+
+    size_t max_len = buf->alloc_size - 1;
+    if (len >= max_len) {
+        // Copy only the right-most bytes
+        memcpy(buf->data, from + len - max_len, max_len);
+        buf->tail = 0;
+        buf->head = max_len;
+        return;
+    }
+
+    size_t right_limit = buf->head < buf->tail ? buf->tail : buf->alloc_size;
+    size_t right_len = right_limit - buf->head;
+    if (len < right_len) {
+        right_len = len;
+    }
+    memcpy(buf->data + buf->head, from, right_len);
+    if (len > right_len) {
+        memcpy(buf->data, from + right_len, len - right_len);
+    }
+
+    size_t empty_space = sc_bytebuf_write_remaining(buf);
+    if (len > empty_space) {
+        buf->tail = (buf->tail + len - empty_space) % buf->alloc_size;
+    }
+    buf->head = (buf->head + len) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_prepare_write(struct sc_bytebuf *buf, const uint8_t *from,
+                         size_t len) {
+    // *This function MUST NOT access buf->tail (even in assert()).*
+    // The purpose of this function is to allow a reader and a writer to access
+    // different parts of the buffer in parallel simultaneously. It is intended
+    // to be called without lock (only sc_bytebuf_commit_write() is intended to
+    // be called with lock held).
+
+    assert(len < buf->alloc_size - 1);
+
+    size_t right_len = buf->alloc_size - buf->head;
+    if (len < right_len) {
+        right_len = len;
+    }
+
+    memcpy(buf->data + buf->head, from, right_len);
+    if (len > right_len) {
+        memcpy(buf->data, from + right_len, len - right_len);
+    }
+}
+
+void
+sc_bytebuf_commit_write(struct sc_bytebuf *buf, size_t len) {
+    assert(len <= sc_bytebuf_write_remaining(buf));
+    buf->head = (buf->head + len) % buf->alloc_size;
+}
--- a/app/src/util/bytebuf.h
+++ b/app/src/util/bytebuf.h
@@ -0,0 +1,104 @@
+#ifndef SC_BYTEBUF_H
+#define SC_BYTEBUF_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+struct sc_bytebuf {
+    uint8_t *data;
+    // The actual capacity is (allocated - 1) so that head == tail is
+    // non-ambiguous
+    size_t alloc_size;
+    size_t head;
+    size_t tail;
+    // empty: tail == head
+    // full: (tail + 1) % allocated == head
+};
+
+bool
+sc_bytebuf_init(struct sc_bytebuf *buf, size_t alloc_size);
+
+/**
+ * Copy from the bytebuf to a user-provided array
+ *
+ * The caller must check that len <= buf->len (it is an error to attempt to read
+ * more bytes than available).
+ *
+ * This function is guaranteed to not change the head.
+ */
+void
+sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len);
+
+/**
+ * Drop len bytes from the buffer
+ *
+ * The caller must check that len <= buf->len (it is an error to attempt to skip
+ * more bytes than available).
+ *
+ * This function is guaranteed to not change the head.
+ *
+ * It is equivalent to call sc_bytebuf_read() to some array and discard the
+ * array (but more efficient since there is no copy).
+ */
+void
+sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len);
+
+/**
+ * Copy the user-provided array to the bytebuf
+ *
+ * The length of the input array is not restricted:
+ * if len >= sc_bytebuf_write_remaining(buf), then the excessive input bytes
+ * will overwrite the oldest bytes in the buffer.
+ */
+void
+sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len);
+
+/**
+ * Copy the user-provided array to the bytebuf, but do not advance the cursor
+ *
+ * The caller must check that len <= buf->len (it is an error to attempt to
+ * write more bytes than available).
+ *
+ * After this function is called, the write must be committed with
+ * sc_bytebuf_commit_write().
+ *
+ * The purpose of this mechanism is to acquire a lock only to commit the write,
+ * but not to perform the actual copy.
+ */
+void
+sc_bytebuf_prepare_write(struct sc_bytebuf *buf, const uint8_t *from,
+                         size_t len);
+
+/**
+ * Commit a prepared write
+ */
+void
+sc_bytebuf_commit_write(struct sc_bytebuf *buf, size_t len);
+
+/**
+ * Return the number of bytes which can be read
+ *
+ * It is an error to read more bytes than available.
+ */
+static inline size_t
+sc_bytebuf_read_remaining(struct sc_bytebuf *buf) {
+    return (buf->alloc_size + buf->head - buf->tail) % buf->alloc_size;
+}
+
+/**
+ * Return the number of bytes which can be written without overwriting
+ *
+ * It is not an error to write more bytes than the available space, but this
+ * would overwrite the oldest bytes in the buffer.
+ */
+static inline size_t
+sc_bytebuf_write_remaining(struct sc_bytebuf *buf) {
+    return (buf->alloc_size + buf->tail - buf->head - 1) % buf->alloc_size;
+}
+
+void
+sc_bytebuf_destroy(struct sc_bytebuf *buf);
+
+#endif
--- a/app/src/util/log.c
+++ b/app/src/util/log.c
@@ -4,6 +4,7 @@
 # include <windows.h>
 #endif
 #include <assert.h>
+#include <libavformat/avformat.h>

 static SDL_LogPriority
 log_level_sc_to_sdl(enum sc_log_level level) {
@@ -47,6 +48,7 @@ void
 sc_set_log_level(enum sc_log_level level) {
    SDL_LogPriority sdl_log = log_level_sc_to_sdl(level);
    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, sdl_log);
+    SDL_LogSetPriority(SDL_LOG_CATEGORY_CUSTOM, sdl_log);
 }

 enum sc_log_level
@@ -85,3 +87,46 @@ sc_log_windows_error(const char *prefix, int error) {
    return true;
 }
 #endif
+
+static SDL_LogPriority
+sdl_priority_from_av_level(int level) {
+    switch (level) {
+        case AV_LOG_PANIC:
+        case AV_LOG_FATAL:
+            return SDL_LOG_PRIORITY_CRITICAL;
+        case AV_LOG_ERROR:
+            return SDL_LOG_PRIORITY_ERROR;
+        case AV_LOG_WARNING:
+            return SDL_LOG_PRIORITY_WARN;
+        case AV_LOG_INFO:
+            return SDL_LOG_PRIORITY_INFO;
+    }
+    // do not forward others, which are too verbose
+    return 0;
+}
+
+static void
+sc_av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
+    (void) avcl;
+    SDL_LogPriority priority = sdl_priority_from_av_level(level);
+    if (priority == 0) {
+        return;
+    }
+
+    size_t fmt_len = strlen(fmt);
+    char *local_fmt = malloc(fmt_len + 10);
+    if (!local_fmt) {
+        LOG_OOM();
+        return;
+    }
+    memcpy(local_fmt, "[FFmpeg] ", 9); // do not write the final '\0'
+    memcpy(local_fmt + 9, fmt, fmt_len + 1); // include '\0'
+    SDL_LogMessageV(SDL_LOG_CATEGORY_CUSTOM, priority, local_fmt, vl);
+    free(local_fmt);
+}
+
+void
+sc_log_configure() {
+    // Redirect FFmpeg logs to SDL logs
+    av_log_set_callback(sc_av_log_callback);
+}
--- a/app/src/util/log.h
+++ b/app/src/util/log.h
@@ -35,4 +35,7 @@ bool
 sc_log_windows_error(const char *prefix, int error);
 #endif

+void
+sc_log_configure();
+
 #endif
--- a/app/src/v4l2_sink.c
+++ b/app/src/v4l2_sink.c
@@ -156,7 +156,9 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
 }

 static bool
-sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
+sc_v4l2_sink_open(struct sc_v4l2_sink *vs, const AVCodecContext *ctx) {
+    assert(ctx->pix_fmt == AV_PIX_FMT_YUV420P);
+
    static const struct sc_video_buffer_callbacks cbs = {
        .on_new_frame = sc_video_buffer_on_new_frame,
    };
--- a/app/tests/test_bytebuf.c
+++ b/app/tests/test_bytebuf.c
@@ -0,0 +1,154 @@
+#include "common.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "util/bytebuf.h"
+
+void test_bytebuf_simple(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[20];
+
+    bool ok = sc_bytebuf_init(&buf, 20);
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello", sizeof("hello") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 5);
+
+    sc_bytebuf_read(&buf, data, 4);
+    assert(!strncmp((char *) data, "hell", 4));
+
+    sc_bytebuf_write(&buf, (uint8_t *) " world", sizeof(" world") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 7);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 8);
+
+    sc_bytebuf_read(&buf, &data[4], 8);
+    assert(sc_bytebuf_read_remaining(&buf) == 0);
+
+    data[12] = '\0';
+    assert(!strcmp((char *) data, "hello world!"));
+    assert(sc_bytebuf_read_remaining(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+void test_bytebuf_boundaries(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[20];
+
+    bool ok = sc_bytebuf_init(&buf, 20);
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 6);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 12);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 18);
+
+    sc_bytebuf_read(&buf, data, 9);
+    assert(!strncmp((char *) data, "hello hel", 9));
+    assert(sc_bytebuf_read_remaining(&buf) == 9);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "world", sizeof("world") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 14);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 15);
+
+    sc_bytebuf_skip(&buf, 3);
+    assert(sc_bytebuf_read_remaining(&buf) == 12);
+
+    sc_bytebuf_read(&buf, data, 12);
+    data[12] = '\0';
+    assert(!strcmp((char *) data, "hello world!"));
+    assert(sc_bytebuf_read_remaining(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+void test_bytebuf_overwrite(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[10];
+
+    bool ok = sc_bytebuf_init(&buf, 10); // so actual capacity is 9
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 6);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "abcdef", sizeof("abcdef") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 9);
+
+    sc_bytebuf_read(&buf, data, 9);
+    assert(!strncmp((char *) data, "lo abcdef", 9));
+
+    sc_bytebuf_write(&buf, (uint8_t *) "a very big buffer",
+                     sizeof("a very big buffer") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 9);
+
+    sc_bytebuf_read(&buf, data, 9);
+    assert(!strncmp((char *) data, "ig buffer", 9));
+    assert(sc_bytebuf_read_remaining(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+void test_bytebuf_two_steps_write(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[20];
+
+    bool ok = sc_bytebuf_init(&buf, 20);
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 6);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 12);
+
+    sc_bytebuf_prepare_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 12); // write not committed yet
+
+    sc_bytebuf_read(&buf, data, 9);
+    assert(!strncmp((char *) data, "hello hel", 3));
+    assert(sc_bytebuf_read_remaining(&buf) == 3);
+
+    sc_bytebuf_commit_write(&buf, sizeof("hello ") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 9);
+
+    sc_bytebuf_prepare_write(&buf, (uint8_t *) "world", sizeof("world") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 9); // write not committed yet
+
+    sc_bytebuf_commit_write(&buf, sizeof("world") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 14);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 15);
+
+    sc_bytebuf_skip(&buf, 3);
+    assert(sc_bytebuf_read_remaining(&buf) == 12);
+
+    sc_bytebuf_read(&buf, data, 12);
+    data[12] = '\0';
+    assert(!strcmp((char *) data, "hello world!"));
+    assert(sc_bytebuf_read_remaining(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+int main(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_bytebuf_simple();
+    test_bytebuf_boundaries();
+    test_bytebuf_overwrite();
+    test_bytebuf_two_steps_write();
+
+    return 0;
+}
--- a/app/tests/test_cli.c
+++ b/app/tests/test_cli.c
@@ -46,7 +46,7 @@ static void test_options(void) {
    char *argv[] = {
        "scrcpy",
        "--always-on-top",
-        "--bit-rate", "5M",
+        "--video-bit-rate", "5M",
        "--crop", "100:200:300:400",
        "--fullscreen",
        "--max-fps", "30",
@@ -75,7 +75,7 @@ static void test_options(void) {

    const struct scrcpy_options *opts = &args.opts;
    assert(opts->always_on_top);
-    assert(opts->bit_rate == 5000000);
+    assert(opts->video_bit_rate == 5000000);
    assert(!strcmp(opts->crop, "100:200:300:400"));
    assert(opts->fullscreen);
    assert(opts->max_fps == 30);
--- a/server/src/main/java/com/genymobile/scrcpy/AudioEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/AudioEncoder.java
@@ -15,6 +15,7 @@ import android.os.Looper;

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

@@ -39,13 +40,14 @@ public final class AudioEncoder {
    }

    private static final int SAMPLE_RATE = 48000;
-    private static final int CHANNELS = 2;
+    private static final int CHANNELS = 1;

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

    private final Streamer streamer;
    private final int bitRate;
+    private final List<CodecOption> codecOptions;
    private final String encoderName;

    // Capacity of 64 is in practice "infinite" (it is limited by the number of available MediaCodec buffers, typically 4).
@@ -61,9 +63,10 @@ public final class AudioEncoder {

    private boolean ended;

-    public AudioEncoder(Streamer streamer, int bitRate, String encoderName) {
+    public AudioEncoder(Streamer streamer, int bitRate, List<CodecOption> codecOptions, String encoderName) {
        this.streamer = streamer;
        this.bitRate = bitRate;
+        this.codecOptions = codecOptions;
        this.encoderName = encoderName;
    }

@@ -89,12 +92,22 @@ public final class AudioEncoder {
        return builder.build();
    }

-    private static MediaFormat createFormat(String mimeType, int bitRate) {
+    private static MediaFormat createFormat(String mimeType, int bitRate, List<CodecOption> codecOptions) {
        MediaFormat format = new MediaFormat();
        format.setString(MediaFormat.KEY_MIME, mimeType);
        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
        format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, CHANNELS);
        format.setInteger(MediaFormat.KEY_SAMPLE_RATE, SAMPLE_RATE);
+
+        if (codecOptions != null) {
+            for (CodecOption option : codecOptions) {
+                String key = option.getKey();
+                Object value = option.getValue();
+                CodecUtils.setCodecOption(format, key, value);
+                Ln.d("Audio codec option set: " + key + " (" + value.getClass().getSimpleName() + ") = " + value);
+            }
+        }
+
        return format;
    }

@@ -202,7 +215,7 @@ public final class AudioEncoder {
    public void encode() throws IOException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
            Ln.w("Audio disabled: it is not supported before Android 11");
-            streamer.writeDisableStream();
+            streamer.writeDisableStream(false);
            return;
        }

@@ -211,6 +224,7 @@ public final class AudioEncoder {

        boolean mediaCodecStarted = false;
        boolean recorderStarted = false;
+        boolean configurationError = false;
        try {
            Codec codec = streamer.getCodec();
            mediaCodec = createMediaCodec(codec, encoderName);
@@ -219,7 +233,7 @@ public final class AudioEncoder {
            mediaCodecThread = new HandlerThread("AudioEncoder");
            mediaCodecThread.start();

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

@@ -261,10 +275,12 @@ public final class AudioEncoder {
            waitEnded();
        } catch (ConfigurationException e) {
            // Do not print stack trace, a user-friendly error-message has already been logged
+            // Notify the error to scrcpy to make it exit
+            configurationError = true;
        } finally {
            if (!recorderStarted) {
                // Notify the client that the audio could not be captured
-                streamer.writeDisableStream();
+                streamer.writeDisableStream(configurationError);
            }

            // Cleanup everything (either at the end or on error at any step of the initialization)
@@ -317,7 +333,7 @@ public final class AudioEncoder {
            try {
                return MediaCodec.createByCodecName(encoderName);
            } catch (IllegalArgumentException e) {
-                Ln.e(CodecUtils.buildUnknownEncoderMessage(codec, encoderName));
+                Ln.e("Encoder '" + encoderName + "' for " + codec.getName() + " not found\n" + LogUtils.buildAudioEncoderListMessage());
                throw new ConfigurationException("Unknown encoder: " + encoderName);
            }
        }
--- a/server/src/main/java/com/genymobile/scrcpy/CleanUp.java
+++ b/server/src/main/java/com/genymobile/scrcpy/CleanUp.java
@@ -139,7 +139,7 @@ public final class CleanUp {
        builder.start();
    }

-    private static void unlinkSelf() {
+    public static void unlinkSelf() {
        try {
            new File(SERVER_PATH).delete();
        } catch (Exception e) {
--- a/server/src/main/java/com/genymobile/scrcpy/CodecUtils.java
+++ b/server/src/main/java/com/genymobile/scrcpy/CodecUtils.java
@@ -2,6 +2,7 @@ package com.genymobile.scrcpy;

 import android.media.MediaCodecInfo;
 import android.media.MediaCodecList;
+import android.media.MediaFormat;

 import java.util.ArrayList;
 import java.util.Arrays;
@@ -9,32 +10,69 @@ import java.util.List;

 public final class CodecUtils {

+    public static final class DeviceEncoder {
+        private final Codec codec;
+        private final MediaCodecInfo info;
+
+        DeviceEncoder(Codec codec, MediaCodecInfo info) {
+            this.codec = codec;
+            this.info = info;
+        }
+
+        public Codec getCodec() {
+            return codec;
+        }
+
+        public MediaCodecInfo getInfo() {
+            return info;
+        }
+    }
+
    private CodecUtils() {
        // not instantiable
    }

-    public static String buildUnknownEncoderMessage(Codec codec, String encoderName) {
-        StringBuilder msg = new StringBuilder("Encoder '").append(encoderName).append("' for ").append(codec.getName()).append(" not found");
-        MediaCodecInfo[] encoders = listEncoders(codec.getMimeType());
-        if (encoders != null && encoders.length > 0) {
-            msg.append("\nTry to use one of the available encoders:");
-            String codecOption = codec.getType() == Codec.Type.VIDEO ? "video-codec" : "audio-codec";
-            for (MediaCodecInfo encoder : encoders) {
-                msg.append("\n    scrcpy --").append(codecOption).append("=").append(codec.getName());
-                msg.append(" --encoder='").append(encoder.getName()).append("'");
-            }
+    public static void setCodecOption(MediaFormat format, String key, Object value) {
+        if (value instanceof Integer) {
+            format.setInteger(key, (Integer) value);
+        } else if (value instanceof Long) {
+            format.setLong(key, (Long) value);
+        } else if (value instanceof Float) {
+            format.setFloat(key, (Float) value);
+        } else if (value instanceof String) {
+            format.setString(key, (String) value);
        }
-        return msg.toString();
    }

-    private static MediaCodecInfo[] listEncoders(String mimeType) {
+    private static MediaCodecInfo[] getEncoders(MediaCodecList codecs, String mimeType) {
        List<MediaCodecInfo> result = new ArrayList<>();
-        MediaCodecList list = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
-        for (MediaCodecInfo codecInfo : list.getCodecInfos()) {
+        for (MediaCodecInfo codecInfo : codecs.getCodecInfos()) {
            if (codecInfo.isEncoder() && Arrays.asList(codecInfo.getSupportedTypes()).contains(mimeType)) {
                result.add(codecInfo);
            }
        }
        return result.toArray(new MediaCodecInfo[result.size()]);
    }
+
+    public static List<DeviceEncoder> listVideoEncoders() {
+        List<DeviceEncoder> encoders = new ArrayList<>();
+        MediaCodecList codecs = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
+        for (VideoCodec codec : VideoCodec.values()) {
+            for (MediaCodecInfo info : getEncoders(codecs, codec.getMimeType())) {
+                encoders.add(new DeviceEncoder(codec, info));
+            }
+        }
+        return encoders;
+    }
+
+    public static List<DeviceEncoder> listAudioEncoders() {
+        List<DeviceEncoder> encoders = new ArrayList<>();
+        MediaCodecList codecs = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
+        for (AudioCodec codec : AudioCodec.values()) {
+            for (MediaCodecInfo info : getEncoders(codecs, codec.getMimeType())) {
+                encoders.add(new DeviceEncoder(codec, info));
+            }
+        }
+        return encoders;
+    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@@ -65,7 +65,7 @@ public final class Device {
        displayId = options.getDisplayId();
        DisplayInfo displayInfo = ServiceManager.getDisplayManager().getDisplayInfo(displayId);
        if (displayInfo == null) {
-            Ln.e(buildUnknownDisplayIdMessage(displayId));
+            Ln.e("Display " + displayId + " not found\n" + LogUtils.buildDisplayListMessage());
            throw new ConfigurationException("Unknown display id: " + displayId);
        }

@@ -130,18 +130,6 @@ public final class Device {
        }
    }

-    private static String buildUnknownDisplayIdMessage(int displayId) {
-        StringBuilder msg = new StringBuilder("Display ").append(displayId).append(" not found");
-        int[] displayIds = ServiceManager.getDisplayManager().getDisplayIds();
-        if (displayIds != null && displayIds.length > 0) {
-            msg.append("\nTry to use one of the available display ids:");
-            for (int id : displayIds) {
-                msg.append("\n    scrcpy --display=").append(id);
-            }
-        }
-        return msg.toString();
-    }
-
    public synchronized void setMaxSize(int newMaxSize) {
        maxSize = newMaxSize;
        screenInfo = ScreenInfo.computeScreenInfo(screenInfo.getReverseVideoRotation(), deviceSize, crop, newMaxSize, lockVideoOrientation);
--- a/server/src/main/java/com/genymobile/scrcpy/LogUtils.java
+++ b/server/src/main/java/com/genymobile/scrcpy/LogUtils.java
@@ -0,0 +1,63 @@
+package com.genymobile.scrcpy;
+
+import com.genymobile.scrcpy.wrappers.DisplayManager;
+import com.genymobile.scrcpy.wrappers.ServiceManager;
+
+import java.util.List;
+
+public final class LogUtils {
+
+    private LogUtils() {
+        // not instantiable
+    }
+
+    public static String buildVideoEncoderListMessage() {
+        StringBuilder builder = new StringBuilder("List of video encoders:");
+        List<CodecUtils.DeviceEncoder> videoEncoders = CodecUtils.listVideoEncoders();
+        if (videoEncoders.isEmpty()) {
+            builder.append("\n    (none)");
+        } else {
+            for (CodecUtils.DeviceEncoder encoder : videoEncoders) {
+                builder.append("\n    --video-codec=").append(encoder.getCodec().getName());
+                builder.append(" --video-encoder='").append(encoder.getInfo().getName()).append("'");
+            }
+        }
+        return builder.toString();
+    }
+
+    public static String buildAudioEncoderListMessage() {
+        StringBuilder builder = new StringBuilder("List of audio encoders:");
+        List<CodecUtils.DeviceEncoder> audioEncoders = CodecUtils.listAudioEncoders();
+        if (audioEncoders.isEmpty()) {
+            builder.append("\n    (none)");
+        } else {
+            for (CodecUtils.DeviceEncoder encoder : audioEncoders) {
+                builder.append("\n    --audio-codec=").append(encoder.getCodec().getName());
+                builder.append(" --audio-encoder='").append(encoder.getInfo().getName()).append("'");
+            }
+        }
+        return builder.toString();
+    }
+
+    public static String buildDisplayListMessage() {
+        StringBuilder builder = new StringBuilder("List of displays:");
+        DisplayManager displayManager = ServiceManager.getDisplayManager();
+        int[] displayIds = displayManager.getDisplayIds();
+        if (displayIds == null || displayIds.length == 0) {
+            builder.append("\n    (none)");
+        } else {
+            for (int id : displayIds) {
+                builder.append("\n    --display=").append(id).append("    (");
+                DisplayInfo displayInfo = displayManager.getDisplayInfo(id);
+                if (displayInfo != null) {
+                    Size size = displayInfo.getSize();
+                    builder.append(size.getWidth()).append("x").append(size.getHeight());
+                } else {
+                    builder.append("size unknown");
+                }
+                builder.append(")");
+            }
+        }
+        return builder.toString();
+    }
+}
--- a/server/src/main/java/com/genymobile/scrcpy/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@@ -12,7 +12,7 @@ public class Options {
    private int maxSize;
    private VideoCodec videoCodec = VideoCodec.H264;
    private AudioCodec audioCodec = AudioCodec.OPUS;
-    private int bitRate = 8000000;
+    private int videoBitRate = 8000000;
    private int audioBitRate = 196000;
    private int maxFps;
    private int lockVideoOrientation = -1;
@@ -22,15 +22,20 @@ public class Options {
    private int displayId;
    private boolean showTouches;
    private boolean stayAwake;
-    private List<CodecOption> codecOptions;
-    private String encoderName;
-    private String audioEncoderName;
+    private List<CodecOption> videoCodecOptions;
+    private List<CodecOption> audioCodecOptions;
+
+    private String videoEncoder;
+    private String audioEncoder;
    private boolean powerOffScreenOnClose;
    private boolean clipboardAutosync = true;
    private boolean downsizeOnError = true;
    private boolean cleanup = true;
    private boolean powerOn = true;

+    private boolean listEncoders;
+    private boolean listDisplays;
+
    // Options not used by the scrcpy client, but useful to use scrcpy-server directly
    private boolean sendDeviceMeta = true; // send device name and size
    private boolean sendFrameMeta = true; // send PTS so that the client may record properly
@@ -85,12 +90,12 @@ public class Options {
        this.audioCodec = audioCodec;
    }

-    public int getBitRate() {
-        return bitRate;
+    public int getVideoBitRate() {
+        return videoBitRate;
    }

-    public void setBitRate(int bitRate) {
-        this.bitRate = bitRate;
+    public void setVideoBitRate(int videoBitRate) {
+        this.videoBitRate = videoBitRate;
    }

    public int getAudioBitRate() {
@@ -165,28 +170,36 @@ public class Options {
        this.stayAwake = stayAwake;
    }

-    public List<CodecOption> getCodecOptions() {
-        return codecOptions;
+    public List<CodecOption> getVideoCodecOptions() {
+        return videoCodecOptions;
    }

-    public void setCodecOptions(List<CodecOption> codecOptions) {
-        this.codecOptions = codecOptions;
+    public void setVideoCodecOptions(List<CodecOption> videoCodecOptions) {
+        this.videoCodecOptions = videoCodecOptions;
    }

-    public String getEncoderName() {
-        return encoderName;
+    public List<CodecOption> getAudioCodecOptions() {
+        return audioCodecOptions;
    }

-    public void setEncoderName(String encoderName) {
-        this.encoderName = encoderName;
+    public void setAudioCodecOptions(List<CodecOption> audioCodecOptions) {
+        this.audioCodecOptions = audioCodecOptions;
    }

-    public String getAudioEncoderName() {
-        return audioEncoderName;
+    public String getVideoEncoder() {
+        return videoEncoder;
    }

-    public void setAudioEncoderName(String audioEncoderName) {
-        this.audioEncoderName = audioEncoderName;
+    public void setVideoEncoder(String videoEncoder) {
+        this.videoEncoder = videoEncoder;
+    }
+
+    public String getAudioEncoder() {
+        return audioEncoder;
+    }
+
+    public void setAudioEncoder(String audioEncoder) {
+        this.audioEncoder = audioEncoder;
    }

    public void setPowerOffScreenOnClose(boolean powerOffScreenOnClose) {
@@ -229,6 +242,22 @@ public class Options {
        this.powerOn = powerOn;
    }

+    public boolean getListEncoders() {
+        return listEncoders;
+    }
+
+    public void setListEncoders(boolean listEncoders) {
+        this.listEncoders = listEncoders;
+    }
+
+    public boolean getListDisplays() {
+        return listDisplays;
+    }
+
+    public void setListDisplays(boolean listDisplays) {
+        this.listDisplays = listDisplays;
+    }
+
    public boolean getSendDeviceMeta() {
        return sendDeviceMeta;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@@ -32,18 +32,18 @@ public class ScreenEncoder implements Device.RotationListener {
    private final Streamer streamer;
    private final String encoderName;
    private final List<CodecOption> codecOptions;
-    private final int bitRate;
+    private final int videoBitRate;
    private final int maxFps;
    private final boolean downsizeOnError;

    private boolean firstFrameSent;
    private int consecutiveErrors;

-    public ScreenEncoder(Device device, Streamer streamer, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
+    public ScreenEncoder(Device device, Streamer streamer, int videoBitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
            boolean downsizeOnError) {
        this.device = device;
        this.streamer = streamer;
-        this.bitRate = bitRate;
+        this.videoBitRate = videoBitRate;
        this.maxFps = maxFps;
        this.codecOptions = codecOptions;
        this.encoderName = encoderName;
@@ -62,7 +62,7 @@ public class ScreenEncoder implements Device.RotationListener {
    public void streamScreen() throws IOException, ConfigurationException {
        Codec codec = streamer.getCodec();
        MediaCodec mediaCodec = createMediaCodec(codec, encoderName);
-        MediaFormat format = createFormat(codec.getMimeType(), bitRate, maxFps, codecOptions);
+        MediaFormat format = createFormat(codec.getMimeType(), videoBitRate, maxFps, codecOptions);
        IBinder display = createDisplay();
        device.setRotationListener(this);

@@ -202,7 +202,7 @@ public class ScreenEncoder implements Device.RotationListener {
            try {
                return MediaCodec.createByCodecName(encoderName);
            } catch (IllegalArgumentException e) {
-                Ln.e(CodecUtils.buildUnknownEncoderMessage(codec, encoderName));
+                Ln.e("Encoder '" + encoderName + "' for " + codec.getName() + " not found\n" + LogUtils.buildVideoEncoderListMessage());
                throw new ConfigurationException("Unknown encoder: " + encoderName);
            }
        }
@@ -211,23 +211,6 @@ public class ScreenEncoder implements Device.RotationListener {
        return mediaCodec;
    }

-    private static void setCodecOption(MediaFormat format, CodecOption codecOption) {
-        String key = codecOption.getKey();
-        Object value = codecOption.getValue();
-
-        if (value instanceof Integer) {
-            format.setInteger(key, (Integer) value);
-        } else if (value instanceof Long) {
-            format.setLong(key, (Long) value);
-        } else if (value instanceof Float) {
-            format.setFloat(key, (Float) value);
-        } else if (value instanceof String) {
-            format.setString(key, (String) value);
-        }
-
-        Ln.d("Codec option set: " + key + " (" + value.getClass().getSimpleName() + ") = " + value);
-    }
-
    private static MediaFormat createFormat(String videoMimeType, int bitRate, int maxFps, List<CodecOption> codecOptions) {
        MediaFormat format = new MediaFormat();
        format.setString(MediaFormat.KEY_MIME, videoMimeType);
@@ -247,7 +230,10 @@ public class ScreenEncoder implements Device.RotationListener {

        if (codecOptions != null) {
            for (CodecOption option : codecOptions) {
-                setCodecOption(format, option);
+                String key = option.getKey();
+                Object value = option.getValue();
+                CodecUtils.setCodecOption(format, key, value);
+                Ln.d("Video codec option set: " + key + " (" + value.getClass().getSimpleName() + ") = " + value);
            }
        }

--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@@ -61,7 +61,6 @@ public final class Server {
    private static void scrcpy(Options options) throws IOException, ConfigurationException {
        Ln.i("Device: " + Build.MANUFACTURER + " " + Build.MODEL + " (Android " + Build.VERSION.RELEASE + ")");
        final Device device = new Device(options);
-        List<CodecOption> codecOptions = options.getCodecOptions();

        Thread initThread = startInitThread(options);

@@ -112,14 +111,14 @@ public final class Server {
            if (audio) {
                Streamer audioStreamer = new Streamer(connection.getAudioFd(), options.getAudioCodec(), options.getSendCodecId(),
                        options.getSendFrameMeta());
-                audioEncoder = new AudioEncoder(audioStreamer, options.getAudioBitRate(), options.getAudioEncoderName());
+                audioEncoder = new AudioEncoder(audioStreamer, options.getAudioBitRate(), options.getAudioCodecOptions(), options.getAudioEncoder());
                audioEncoder.start();
            }

            Streamer videoStreamer = new Streamer(connection.getVideoFd(), options.getVideoCodec(), options.getSendCodecId(),
                    options.getSendFrameMeta());
-            ScreenEncoder screenEncoder = new ScreenEncoder(device, videoStreamer, options.getBitRate(), options.getMaxFps(), codecOptions,
-                    options.getEncoderName(), options.getDownsizeOnError());
+            ScreenEncoder screenEncoder = new ScreenEncoder(device, videoStreamer, options.getVideoBitRate(), options.getMaxFps(),
+                    options.getVideoCodecOptions(), options.getVideoEncoder(), options.getDownsizeOnError());
            try {
                // synchronous
                screenEncoder.streamScreen();
@@ -215,9 +214,9 @@ public final class Server {
                    int maxSize = Integer.parseInt(value) & ~7; // multiple of 8
                    options.setMaxSize(maxSize);
                    break;
-                case "bit_rate":
-                    int bitRate = Integer.parseInt(value);
-                    options.setBitRate(bitRate);
+                case "video_bit_rate":
+                    int videoBitRate = Integer.parseInt(value);
+                    options.setVideoBitRate(videoBitRate);
                    break;
                case "audio_bit_rate":
                    int audioBitRate = Integer.parseInt(value);
@@ -255,18 +254,22 @@ public final class Server {
                    boolean stayAwake = Boolean.parseBoolean(value);
                    options.setStayAwake(stayAwake);
                    break;
-                case "codec_options":
-                    List<CodecOption> codecOptions = CodecOption.parse(value);
-                    options.setCodecOptions(codecOptions);
+                case "video_codec_options":
+                    List<CodecOption> videoCodecOptions = CodecOption.parse(value);
+                    options.setVideoCodecOptions(videoCodecOptions);
                    break;
-                case "encoder_name":
+                case "audio_codec_options":
+                    List<CodecOption> audioCodecOptions = CodecOption.parse(value);
+                    options.setAudioCodecOptions(audioCodecOptions);
+                    break;
+                case "video_encoder":
                    if (!value.isEmpty()) {
-                        options.setEncoderName(value);
+                        options.setVideoEncoder(value);
                    }
                    break;
-                case "audio_encoder_name":
+                case "audio_encoder":
                    if (!value.isEmpty()) {
-                        options.setAudioEncoderName(value);
+                        options.setAudioEncoder(value);
                    }
                case "power_off_on_close":
                    boolean powerOffScreenOnClose = Boolean.parseBoolean(value);
@@ -288,6 +291,14 @@ public final class Server {
                    boolean powerOn = Boolean.parseBoolean(value);
                    options.setPowerOn(powerOn);
                    break;
+                case "list_encoders":
+                    boolean listEncoders = Boolean.parseBoolean(value);
+                    options.setListEncoders(listEncoders);
+                    break;
+                case "list_displays":
+                    boolean listDisplays = Boolean.parseBoolean(value);
+                    options.setListDisplays(listDisplays);
+                    break;
                case "send_device_meta":
                    boolean sendDeviceMeta = Boolean.parseBoolean(value);
                    options.setSendDeviceMeta(sendDeviceMeta);
@@ -347,6 +358,22 @@ public final class Server {

        Ln.initLogLevel(options.getLogLevel());

+        if (options.getListEncoders() || options.getListDisplays()) {
+            if (options.getCleanup()) {
+                CleanUp.unlinkSelf();
+            }
+
+            if (options.getListEncoders()) {
+                Ln.i(LogUtils.buildVideoEncoderListMessage());
+                Ln.i(LogUtils.buildAudioEncoderListMessage());
+            }
+            if (options.getListDisplays()) {
+                Ln.i(LogUtils.buildDisplayListMessage());
+            }
+            // Just print the requested data, do not mirror
+            return;
+        }
+
        try {
            scrcpy(options);
        } catch (ConfigurationException e) {
--- a/server/src/main/java/com/genymobile/scrcpy/Streamer.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Streamer.java
@@ -40,10 +40,15 @@ public final class Streamer {
        }
    }

-    public void writeDisableStream() throws IOException {
-        // Writing 0 (32-bit) as codec-id means that the device disables the stream (because it could not capture)
-        byte[] zeros = new byte[4];
-        IO.writeFully(fd, zeros, 0, zeros.length);
+    public void writeDisableStream(boolean error) throws IOException {
+        // Writing a specific code as codec-id means that the device disables the stream
+        //   code 0: it explicitly disables the stream (because it could not capture audio), scrcpy should continue mirroring video only
+        //   code 1: a configuration error occurred, scrcpy must be stopped
+        byte[] code = new byte[4];
+        if (error) {
+            code[3] = 1;
+        }
+        IO.writeFully(fd, code, 0, code.length);
    }

    public void writePacket(ByteBuffer codecBuffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
@@ -91,31 +96,34 @@ public final class Streamer {
        // 00000050  00 00 00                                          |...|
        //
        // Each "section" is prefixed by a 64-bit ID and a 64-bit length.
+        //
+        // <https://developer.android.com/reference/android/media/MediaCodec#CSD>

        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);
+        if (buffer.remaining() < 16) {
+            throw new IOException("Not enough data in OPUS config packet");
        }

-        throw new IOException("OPUS header not found");
+        long id = buffer.getLong();
+        if (id != AOPUSHDR) {
+            throw new IOException("OPUS header not found");
+        }
+
+        long sizeLong = buffer.getLong();
+        if (sizeLong < 0 || sizeLong >= 0x7FFFFFFF) {
+            throw new IOException("Invalid block size in OPUS header: " + sizeLong);
+        }
+
+        int size = (int) sizeLong;
+        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);
    }
 }
Author	SHA1	Message	Date
Romain Vimont	a68500aa13	audio_player WIP	2023-02-25 19:39:29 +01:00
Romain Vimont	dd32e53ad6	Add two-step write feature to bytebuf If there is exactly one producer, then it can assume that the remaining space in the buffer will only increase until it write something. This assumption may allow the producer to write to the buffer (up to a known safe size) without any synchronization mechanism, thus allowing to read and write different parts of the buffer in parallel. The producer can then commit the write with lock held, and update its knowledge of the safe empty remaining space.	2023-02-25 19:39:11 +01:00
Romain Vimont	96a05383b9	Introduce bytebuf util Add a ring-buffer for bytes. It will be useful for buffering audio.	2023-02-25 19:39:11 +01:00
Romain Vimont	048ff837f7	Pass AVCodecContext to frame sinks Frame consumers may need details about the frame format.	2023-02-25 19:39:11 +01:00
Romain Vimont	84703fe6af	Add an audio decoder	2023-02-25 19:39:11 +01:00
Romain Vimont	4f0f0e9412	Give a name to decoder instances This will be useful in logs.	2023-02-25 19:39:11 +01:00
Romain Vimont	5648d9a7ee	Rename decoder to video_decoder	2023-02-25 19:39:11 +01:00
Romain Vimont	b0f4857ca1	Log display sizes in display list This is more convenient than just the display id alone.	2023-02-25 19:39:11 +01:00
Romain Vimont	e1146666dc	Add --list-device-displays	2023-02-25 19:39:11 +01:00
Romain Vimont	2109d15e6c	Move log message helpers to LogUtils This class will also contain other log helpers.	2023-02-25 19:39:11 +01:00
Romain Vimont	f91f5ad637	Quit on audio configuration failure When audio capture fails on the device, scrcpy continue mirroring the video stream. This allows to enable audio by default only when supported. However, if an audio configuration occurs (for example the user explicitly selected an unknown audio encoder), this must be treated as an error and scrcpy must exit.	2023-02-25 19:39:11 +01:00
Romain Vimont	4b710b5307	Add --list-encoders Add an option to list the device encoders properly.	2023-02-25 19:39:11 +01:00
Romain Vimont	09c3ef52b7	Move await_for_server() logs Print the logs on the caller side. This will allow to call the function in another context without printing the logs.	2023-02-25 19:39:11 +01:00
Romain Vimont	a388caafe9	Add --audio-encoder Similar to --video-encoder, but for audio.	2023-02-25 19:39:11 +01:00
Romain Vimont	82d92948d5	Extract unknown encoder error message This will allow to reuse the same code for audio encoder selection.	2023-02-25 19:39:11 +01:00
Romain Vimont	0d72399bc1	Add --audio-codec-options Similar to --video-codec-options, but for audio.	2023-02-25 19:39:11 +01:00
Romain Vimont	24ae14cf46	Extract application of codec options This will allow to reuse the same code for audio codec options.	2023-02-25 19:39:11 +01:00
Romain Vimont	269bffdbf9	Add support for AAC audio codec Add option --audio-codec=aac.	2023-02-25 19:39:11 +01:00
Romain Vimont	ed1de493f9	Add --audio-codec Introduce the selection mechanism. Alternative codecs will be added later.	2023-02-25 19:39:11 +01:00
Romain Vimont	00c8d9e289	Add --audio-bit-rate Add an option to configure the audio bit-rate.	2023-02-25 19:39:11 +01:00
Romain Vimont	39dd5da9cd	Disable MethodLength checkstyle on createOptions() This method will grow as needed to initialize options.	2023-02-25 19:39:11 +01:00
Romain Vimont	4294573225	Rename --encoder to --video-encoder This prepares the introduction of --audio-encoder.	2023-02-25 19:39:11 +01:00
Romain Vimont	ea32ed6444	Rename --codec-options to --video-codec-options This prepares the introduction of --audio-codec-options.	2023-02-25 19:39:11 +01:00
Romain Vimont	802fdf3e0b	Rename --bit-rate to --video-bit-rate This prepares the introduction of --audio-bit-rate.	2023-02-25 19:39:11 +01:00
Romain Vimont	e565d31c59	Rename --codec to --video-codec This prepares the introduction of --audio-codec.	2023-02-25 19:39:11 +01:00
Romain Vimont	1de01c1c0e	Remove default bit-rate on client side If no bit-rate is passed, let the server use the default value (8Mbps). This avoids to define a default value on both sides, and to pass the default bit-rate as an argument when starting the server.	2023-02-25 19:39:11 +01:00
Romain Vimont	35c032267c	Record at least video packets on stop If the recorder is stopped while it has not received any audio packet yet, make sure the video stream is correctly recorded.	2023-02-25 19:39:11 +01:00
Romain Vimont	c7324e16c7	Disable audio before Android 11 The permission "android.permission.RECORD_AUDIO" has been added for shell in Android 11. Moreover, on lower versions, it may make the server segfault on the device (happened on a Nexus 5 with Android 6.0.1). Refs <`4feeee8891`%5E%21/>	2023-02-25 19:39:11 +01:00
Romain Vimont	0e84fe12d6	Disable audio on initialization error By default, audio is enabled (--no-audio must be explicitly passed to disable it). However, some devices may not support audio capture (typically devices below Android 11, or Android 11 when the shell application is not foreground on start). In that case, make the server notify the client to dynamically disable audio forwarding so that it does not wait indefinitely for an audio stream. Also disable audio on unknown codec or missing decoder on the client-side, for the same reasons.	2023-02-25 19:39:11 +01:00
Romain Vimont	66fe1fa003	Add record audio support Make the recorder accept two input sources (video and audio), and mux them into a single file.	2023-02-25 19:39:11 +01:00
Romain Vimont	0058b9e191	Rename video-specific variables in recorder This paves the way to add audio-specific variables.	2023-02-25 19:39:11 +01:00
Romain Vimont	a5384efd9e	Do not merge config audio packets For video streams (at least H.264 and H.265), the config packet containing SPS/PPS must be prepended to the next packet (the following keyframe). For audio streams (at least OPUS), they must not be merged.	2023-02-25 19:39:11 +01:00
Romain Vimont	696d61e6d9	Add an audio demuxer Add a demuxer which will read the stream from the audio socket.	2023-02-25 19:39:11 +01:00
Romain Vimont	9a10a1dc06	Give a name to demuxer instances This will be useful in logs.	2023-02-25 19:39:11 +01:00
Romain Vimont	12de66cf25	Rename demuxer to video_demuxer There will be another demuxer instance for audio.	2023-02-25 19:39:11 +01:00
Romain Vimont	92b4ee21fe	Extract OPUS extradata For OPUS codec, FFmpeg expects the raw extradata, but MediaCodec wraps it in some structure. Fix the config packet to send only the raw extradata.	2023-02-25 19:39:11 +01:00
Romain Vimont	c8749db90b	Use a streamer to send the audio stream Send each encoded audio packet using a streamer.	2023-02-25 19:39:11 +01:00
Romain Vimont	57b6110e72	Encode recorded audio on the device For now, the encoded packets are just logged into the console.	2023-02-25 19:39:11 +01:00
Simon Chan	f479beef83	Capture device audio Create an AudioRecorder to capture the audio source REMOTE_SUBMIX. For now, the captured packets are just logged into the console. Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-02-24 21:29:30 +01:00
Simon Chan	114e226164	Add a new socket for audio stream When audio is enabled, open a new socket to send the audio stream from the device to the client. Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-02-24 21:29:30 +01:00
Simon Chan	241d41b683	Add --no-audio option Audio will be enabled by default (when supported). Add an option to disable it. Co-authored-by: Romain Vimont <rom@rom1v.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2023-02-24 21:29:30 +01:00
Romain Vimont	4997a2e6a3	Use FakeContext for Application instance This will expose the correct package name and UID to the application context.	2023-02-24 21:29:30 +01:00
Romain Vimont	453eca7c18	Use shell package name for workarounds For consistency.	2023-02-24 21:29:30 +01:00
Romain Vimont	de31f4e9a5	Use PACKAGE_NAME from FakeContext Remove duplicated constant.	2023-02-24 21:29:30 +01:00
Romain Vimont	6dacd1ad62	Use AttributionSource from FakeContext FakeContext already provides an AttributeSource instance. Co-authored-by: Simon Chan <1330321+yume-chan@users.noreply.github.com>	2023-02-24 21:29:30 +01:00
Simon Chan	0e8705f611	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-24 21:29:30 +01:00
Romain Vimont	e982679166	Use Process.ROOT_UID Replace ServiceManager.USER_ID by existing constant Process.ROOT_UID.	2023-02-24 21:29:30 +01:00
Romain Vimont	bcd6a998b8	Improve error message for unknown encoder The provided encoder name depends on the selected codec. Improve the error message and the suggestions.	2023-02-24 21:29:30 +01:00
Romain Vimont	23a6b3e6c2	Rename "codec" variable to "mediaCodec" This will allow to use "codec" for the Codec type.	2023-02-24 21:29:30 +01:00
Romain Vimont	91e2e8a5a5	Make streamer independent of codec type Rename VideoStreamer to Streamer, and extract a Codec interface which will also support audio codecs.	2023-02-24 21:29:30 +01:00
Romain Vimont	f5d0e3211c	Pass all args to ScreenEncoder constructor There is no good reason to pass some of them in the constructor and some others as parameters of the streamScreen() method.	2023-02-24 21:29:30 +01:00
Romain Vimont	260d411c34	Move screen encoder initialization This prepares further refactors.	2023-02-24 21:29:30 +01:00
Romain Vimont	92098d2a06	Write streamer header from ScreenEncoder The screen encoder is responsible to write data to the video streamer.	2023-02-24 21:29:30 +01:00
Romain Vimont	768f5714d2	Use VideoStreamer directly from ScreenEncoder The Callbacks interface notifies new packets. But in addition, the screen encoder will need to write headers on start. We could add a function onStart(), but for simplicity, just remove the interface, which brings no value, and call the streamer directly. Refs `87972e2022`	2023-02-24 21:29:30 +01:00
Romain Vimont	7650f41aad	Simplify error handling on socket creation On any error, all previously opened 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-24 21:29:30 +01:00
Romain Vimont	0d5e3afdf5	Reorder initialization Initialize components in the pipeline order: demuxer first, decoder and recorder second.	2023-02-24 21:29:30 +01:00
Romain Vimont	947df80a01	Refactor recorder logic Process the initial config packet (necessary to write the header) separately.	2023-02-24 21:29:30 +01:00
Romain Vimont	9e47989d86	Move last packet recording Write the last packet at the end.	2023-02-24 21:29:30 +01:00
Romain Vimont	2b6642807e	Add start() function for recorder For consistency with the other components, do not start the internal thread from an init() function.	2023-02-24 21:29:30 +01:00
Romain Vimont	9c72cecfef	Open recording file from the recorder thread The recorder opened the target file from the packet sink open() callback, called by the demuxer. Only then the recorder thread was started. One golden rule for the recorder is to never block the demuxer for I/O, because it would impact mirroring. This rule is respected on recording packets, but not for the initial recorder opening. Therefore, start the recorder thread from sc_recorder_init(), open the file immediately from the recorder thread, then make it wait for the stream to start (on packet sink open()). Now that the recorder can report errors directly (rather than making the demuxer call fail), it is possible to report file opening error even before the packet sink is open.	2023-02-24 21:29:30 +01:00
Romain Vimont	4dc76e58bc	Inline packet_sink impl in recorder Remove useless wrappers.	2023-02-24 21:29:30 +01:00
Romain Vimont	9e455b803d	Initialize recorder fields from init() The recorder has two initialization phases: one to initialize the concrete recorder object, and one to open its packet_sink trait. Initialize mutex and condvar as part of the object initialization. If there were several packet_sink traits, the mutex and condvar would still be initialized only once.	2023-02-24 21:29:30 +01:00
Romain Vimont	4f992519a5	Report recorder errors Stop scrcpy on recorder errors. It was previously indirectly stopped by the demuxer, which failed to push packets to a recorder in error. Report it directly instead: - it avoids to wait for the next demuxer call; - it will allow to open the target file from a separate thread and stop immediately on any I/O error.	2023-02-24 21:29:28 +01:00
Romain Vimont	359a8cbed5	Move previous packet to a local variable It is only used from run_recorder().	2023-02-23 13:27:34 +01:00
Romain Vimont	3910033e36	Move pts_origin to a local variable It is only used from run_recorder().	2023-02-23 13:27:34 +01:00
Romain Vimont	94be1730f2	Change PTS origin type from uint64_t to int64_t It is initialized from AVPacket.pts, which is an int64_t.	2023-02-23 13:27:34 +01:00
Romain Vimont	d0cd5e536e	Fix --encoder documentation Mention that it depends on the codec provided by --codec (which is not necessarily H264 anymore).	2023-02-23 13:27:34 +01:00
Romain Vimont	bdfb8ae725	Do not print stacktraces when unnecessary User-friendly error messages are printed on specific configuration exceptions. In that case, do not print the stacktrace. Also handle the user-friendly error message directly where the error occurs, and print multiline messages in a single log call, to avoid confusing interleaving.	2023-02-23 13:27:34 +01:00
Romain Vimont	2b69eecc90	Fix --no-clipboard-autosync bash completion Fix typo.	2023-02-23 13:27:34 +01:00
Romain Vimont	97bbbb81ad	Split server stop() and join() For consistency with the other components, call stop() and join() separately. This allows to stop all components, then join them all.	2023-02-23 13:27:34 +01:00
Romain Vimont	ca24b3a8c8	Print FFmpeg logs FFmpeg logs are redirected to a specific SDL log category. Initialize the log level for this category to print them as expected.	2023-02-23 13:26:36 +01:00
Romain Vimont	5563676946	Move FFmpeg callback initialization Configure FFmpeg log redirection on start from a log helper.	2023-02-23 13:07:13 +01:00
Romain Vimont	3d10fbd9b4	Fix --bit-rate option in bash completion script The option is --bit-rate, not --bitrate.	2023-02-21 19:50:01 +01:00
Romain Vimont	3e3756a323	Add auto-completion for --codec option Add missing command to bash and zsh completion scripts.	2023-02-21 19:48:28 +01:00
Romain Vimont	5d6bcc5966	Use enum for long options constants This avoids to manually assign values.	2023-02-21 19:47:27 +01:00
Romain Vimont	5973d4cdd7	Initialize mouse_input_mode explicitly The explicit initialization was missing. It had no consequences because SC_MOUSE_INPUT_MODE_INJECT == 0. Fixes #3749 <https://github.com/Genymobile/scrcpy/issues/3749>	2023-02-21 12:11:39 +01:00