Warn on ignored audio options

For raw audio codec, some audio options are ignored.

PR #3757 <https://github.com/Genymobile/scrcpy/pull/3757>

app/data/bash-completion/scrcpy

@@ -78,7 +78,7 @@ _scrcpy() {
             return
             ;;
         --audio-codec)
-            COMPREPLY=($(compgen -W 'opus aac raw' -- "$cur"))
+            COMPREPLY=($(compgen -W 'raw opus aac' -- "$cur"))
             return
             ;;
         --lock-video-orientation)

app/data/zsh-completion/_scrcpy

@@ -10,7 +10,7 @@ local arguments
 arguments=(
     '--always-on-top[Make scrcpy window always on top \(above other windows\)]'
     '--audio-bit-rate=[Encode the audio at the given bit-rate]'
-    '--audio-codec=[Select the audio codec]:codec:(opus aac raw)'
+    '--audio-codec=[Select the audio codec]:codec:(raw 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]'

app/scrcpy.1

@@ -23,19 +23,17 @@ Make scrcpy window always on top (above other windows).
 .BI "\-\-audio\-bit\-rate " value
 Encode the audio at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
 
-Default is 128K (128000).
+Default is 196K (196000).
 
 .TP
 .BI "\-\-audio\-buffer ms
-Configure the audio buffering delay (in milliseconds).
+Add a buffering delay (in milliseconds) before playing audio. This increases latency to compensate for jitter.
 
-Lower values decrease the latency, but increase the likelyhood of buffer underrun (causing audio glitches).
-
-Default is 50.
+Default is 0 (no buffering).
 
 .TP
 .BI "\-\-audio\-codec " name
-Select an audio codec (opus, aac or raw).
+Select an audio codec (raw, opus or aac).
 
 Default is opus.
 
@@ -282,7 +280,7 @@ Supported names are currently "direct3d", "opengl", "opengles2", "opengles", "me
 
 .TP
 .B \-\-require\-audio
-By default, scrcpy mirrors only the video if audio capture fails on the device. This option makes scrcpy fail if audio is enabled but does not work.
+By default, scrcpy mirrors only the video if audio capture fails on the device. This flag makes scrcpy fail if audio is enabled but does not work.
 
 .TP
 .BI "\-\-rotation " value

app/src/audio_player.c

@@ -4,7 +4,7 @@
 
 #include "util/log.h"
 
-#define SC_AUDIO_PLAYER_NDEBUG // comment to debug
+//#define SC_AUDIO_PLAYER_NDEBUG // comment to debug
 
 /** Downcast frame_sink to sc_audio_player */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_audio_player, frame_sink)
@@ -12,20 +12,29 @@
 #define SC_AV_SAMPLE_FMT AV_SAMPLE_FMT_FLT
 #define SC_SDL_SAMPLE_FMT AUDIO_F32
 
-#define SC_AUDIO_OUTPUT_BUFFER_SAMPLES 240 // 5ms at 48000Hz
+#define SC_AUDIO_OUTPUT_BUFFER_SAMPLES 480 // 10ms at 48000Hz
 
-static inline uint32_t
+// The target number of buffered samples between the producer and the consumer.
+// This value is directly use for compensation.
+#define SC_TARGET_BUFFERED_SAMPLES (3 * SC_AUDIO_OUTPUT_BUFFER_SAMPLES)
+
+// Use a ring-buffer of 1 second (at 48000Hz) between the producer and the
+// consumer. It too big, but it guarantees that the producer and the consumer
+// will be able to access it in parallel without locking.
+#define SC_BYTEBUF_SIZE_IN_SAMPLES 48000
+
+static inline size_t
 bytes_to_samples(struct sc_audio_player *ap, size_t bytes) {
     assert(bytes % (ap->nb_channels * ap->out_bytes_per_sample) == 0);
     return bytes / (ap->nb_channels * ap->out_bytes_per_sample);
 }
 
 static inline size_t
-samples_to_bytes(struct sc_audio_player *ap, uint32_t samples) {
+samples_to_bytes(struct sc_audio_player *ap, size_t samples) {
     return samples * ap->nb_channels * ap->out_bytes_per_sample;
 }
 
-static void SDLCALL
+void
 sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
     struct sc_audio_player *ap = userdata;
 
@@ -36,56 +45,34 @@ sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
     size_t len = len_int;
 
 #ifndef SC_AUDIO_PLAYER_NDEBUG
-    LOGD("[Audio] SDL callback requests %" PRIu32 " samples",
+    LOGD("[Audio] SDL callback requests %" SC_PRIsizet " samples",
          bytes_to_samples(ap, len));
 #endif
 
     size_t read_avail = sc_bytebuf_read_available(&ap->buf);
-    if (!ap->played) {
-        uint32_t buffered_samples = bytes_to_samples(ap, read_avail);
-
-        // Part of the buffering is handled by inserting initial silence. The
-        // remaining (margin) last samples will be handled by compensation.
-        uint32_t margin = 30 * ap->sample_rate / 1000; // 30ms
-        if (buffered_samples + margin < ap->target_buffering) {
-            LOGV("[Audio] Inserting initial buffering silence: %" PRIu32
-                 " samples", bytes_to_samples(ap, len));
-            // Delay playback starting to reach the target buffering. Fill the
-            // whole buffer with silence (len is small compared to the
-            // arbitrary margin value).
-            memset(stream, 0, len);
-            return;
-        }
-    }
-
     size_t read = MIN(read_avail, len);
     if (read) {
         sc_bytebuf_read(&ap->buf, stream, read);
     }
 
     if (read < len) {
-        size_t silence_bytes = len - read;
-        uint32_t silence_samples = bytes_to_samples(ap, silence_bytes);
-        // Insert silence. In theory, the inserted silent samples replace the
-        // missing real samples, which will arrive later, so they should be
-        // dropped to keep the latency minimal. However, this would cause very
-        // audible glitches, so let the clock compensation restore the target
-        // latency.
-        LOGD("[Audio] Buffer underflow, inserting silence: %" PRIu32 " samples",
-             silence_samples);
-        memset(stream + read, 0, silence_bytes);
-
+        // Insert silence
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+        LOGD("[Audio] Buffer underflow, inserting silence: %" SC_PRIsizet
+             " samples", bytes_to_samples(ap, len - read));
+#endif
+        memset(stream + read, 0, len - read);
+        // If the first frame has not been received yet, it's not an underflow
         if (ap->received) {
-            // Inserting additional samples immediately increases buffering
-            ap->avg_buffering.avg += silence_samples;
+            ap->underflow += bytes_to_samples(ap, len - read);
         }
     }
 
-    ap->played = true;
+    ap->last_consumed = sc_tick_now();
 }
 
 static uint8_t *
-sc_audio_player_get_swr_buf(struct sc_audio_player *ap, uint32_t min_samples) {
+sc_audio_player_get_swr_buf(struct sc_audio_player *ap, size_t min_samples) {
     size_t min_buf_size = samples_to_bytes(ap, min_samples);
     if (min_buf_size > ap->swr_buf_alloc_size) {
         size_t new_size = min_buf_size + 4096;
@@ -102,186 +89,6 @@ sc_audio_player_get_swr_buf(struct sc_audio_player *ap, uint32_t min_samples) {
     return ap->swr_buf;
 }
 
-static bool
-sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
-                                const AVFrame *frame) {
-    struct sc_audio_player *ap = DOWNCAST(sink);
-
-    SwrContext *swr_ctx = ap->swr_ctx;
-
-    int64_t swr_delay = swr_get_delay(swr_ctx, ap->sample_rate);
-    // No need to av_rescale_rnd(), input and output sample rates are the same.
-    // Add more space (256) for clock compensation.
-    int dst_nb_samples = swr_delay + frame->nb_samples + 256;
-
-    uint8_t *swr_buf = sc_audio_player_get_swr_buf(ap, dst_nb_samples);
-    if (!swr_buf) {
-        return false;
-    }
-
-    int ret = swr_convert(swr_ctx, &swr_buf, dst_nb_samples,
-                          (const uint8_t **) frame->data, frame->nb_samples);
-    if (ret < 0) {
-        LOGE("Resampling failed: %d", ret);
-        return false;
-    }
-
-    // swr_convert() returns the number of samples which would have been
-    // written if the buffer was big enough.
-    uint32_t samples_written = MIN(ret, dst_nb_samples);
-    size_t swr_buf_size = samples_to_bytes(ap, samples_written);
-#ifndef SC_AUDIO_PLAYER_NDEBUG
-    LOGD("[Audio] %" PRIu32 " samples written to buffer", samples_written);
-#endif
-
-    // Since this function is the only writer, the current available space is
-    // at least the previous available space. In practice, it should almost
-    // always be possible to write without lock.
-    bool lockless_write = swr_buf_size <= ap->previous_write_avail;
-    if (lockless_write) {
-        sc_bytebuf_prepare_write(&ap->buf, swr_buf, swr_buf_size);
-    }
-
-    SDL_LockAudioDevice(ap->device);
-
-    size_t read_avail = sc_bytebuf_read_available(&ap->buf);
-    uint32_t buffered_samples = bytes_to_samples(ap, read_avail);
-
-    if (lockless_write) {
-        sc_bytebuf_commit_write(&ap->buf, swr_buf_size);
-    } else {
-        // Take care to keep full samples
-        size_t align = ap->nb_channels * ap->out_bytes_per_sample;
-        size_t write_avail =
-            sc_bytebuf_write_available(&ap->buf) / align * align;
-        if (swr_buf_size > write_avail) {
-            // Entering this branch is very unlikely, the ring-buffer (bytebuf)
-            // is allocated with a size sufficient to store 1 second more than
-            // the target buffering. If this happens, though, we have to skip
-            // old samples.
-            size_t cap = sc_bytebuf_capacity(&ap->buf) / align * align;
-            if (swr_buf_size > cap) {
-                // Very very unlikely: a single resampled frame should never
-                // exceed the ring-buffer size (or something is very wrong).
-                // Ignore the first bytes in swr_buf
-                swr_buf += swr_buf_size - cap;
-                swr_buf_size = cap;
-                // This change in samples_written will impact the
-                // instant_compensation below
-                samples_written -= bytes_to_samples(ap, swr_buf_size - cap);
-            }
-
-            assert(swr_buf_size >= write_avail);
-            if (swr_buf_size > write_avail) {
-                sc_bytebuf_skip(&ap->buf, swr_buf_size - write_avail);
-                uint32_t skip_samples =
-                    bytes_to_samples(ap, swr_buf_size - write_avail);
-                assert(buffered_samples >= skip_samples);
-                buffered_samples -= skip_samples;
-                if (ap->played) {
-                    // Dropping input samples instantly decreases buffering
-                    ap->avg_buffering.avg -= skip_samples;
-                }
-            }
-
-            // It should remain exactly the expected size to write the new
-            // samples.
-            assert((sc_bytebuf_write_available(&ap->buf) / align * align)
-                    == swr_buf_size);
-        }
-
-        sc_bytebuf_write(&ap->buf, swr_buf, swr_buf_size);
-    }
-
-    buffered_samples += samples_written;
-    assert(samples_to_bytes(ap, buffered_samples)
-            == sc_bytebuf_read_available(&ap->buf));
-
-    // Read with lock held, to be used after unlocking
-    bool played = ap->played;
-    if (played) {
-        uint32_t max_buffered_samples = ap->target_buffering
-                                      + 12 * SC_AUDIO_OUTPUT_BUFFER_SAMPLES
-                                      + ap->target_buffering / 10;
-        if (buffered_samples > max_buffered_samples) {
-            uint32_t skip_samples = buffered_samples - max_buffered_samples;
-            size_t skip_bytes = samples_to_bytes(ap, skip_samples);
-            sc_bytebuf_skip(&ap->buf, skip_bytes);
-#ifndef SC_AUDIO_PLAYER_NDEBUG
-            LOGD("[Audio] Buffering threshold exceeded, skipping %" PRIu32
-                 " samples", skip_samples);
-#endif
-        }
-
-        // Number of samples added (or removed, if negative) for compensation
-        int32_t instant_compensation =
-            (int32_t) samples_written - frame->nb_samples;
-
-        // The compensation must apply instantly, it must not be smoothed
-        ap->avg_buffering.avg += instant_compensation;
-
-        // However, the buffering level must be smoothed
-        sc_average_push(&ap->avg_buffering, buffered_samples);
-
-#ifndef SC_AUDIO_PLAYER_NDEBUG
-        LOGD("[Audio] buffered_samples=%" PRIu32 " avg_buffering=%f",
-             buffered_samples, sc_average_get(&ap->avg_buffering));
-#endif
-    } else {
-        // SDL playback not started yet, do not accumulate more than
-        // max_initial_buffering samples, this would cause unnecessary delay
-        // (and glitches to compensate) on start.
-        uint32_t max_initial_buffering = ap->target_buffering
-                                       + 2 * SC_AUDIO_OUTPUT_BUFFER_SAMPLES;
-        if (buffered_samples > max_initial_buffering) {
-            uint32_t skip_samples = buffered_samples - max_initial_buffering;
-            size_t skip_bytes = samples_to_bytes(ap, skip_samples);
-            sc_bytebuf_skip(&ap->buf, skip_bytes);
-#ifndef SC_AUDIO_PLAYER_NDEBUG
-            LOGD("[Audio] Playback not started, skipping %" PRIu32 " samples",
-                 skip_samples);
-#endif
-        }
-    }
-
-    ap->previous_write_avail = sc_bytebuf_write_available(&ap->buf);
-    ap->received = true;
-
-    SDL_UnlockAudioDevice(ap->device);
-
-    if (played) {
-        ap->samples_since_resync += samples_written;
-        if (ap->samples_since_resync >= ap->sample_rate) {
-            // Recompute compensation every second
-            ap->samples_since_resync = 0;
-
-            float avg = sc_average_get(&ap->avg_buffering);
-            int diff = ap->target_buffering - avg;
-            if (diff < 0 && buffered_samples < ap->target_buffering) {
-                // Do not accelerate if the instant buffering level is below
-                // the average, this would increase underflow
-                diff = 0;
-            }
-            // Compensate the diff over 4 seconds (but will be recomputed after
-            // 1 second)
-            int distance = 4 * ap->sample_rate;
-            // Limit compensation rate to 2%
-            int abs_max_diff = distance / 50;
-            diff = CLAMP(diff, -abs_max_diff, abs_max_diff);
-            LOGV("[Audio] Buffering: target=%" PRIu32 " avg=%f cur=%" PRIu32
-                 " compensation=%d", ap->target_buffering, avg,
-                 buffered_samples, diff);
-            int ret = swr_set_compensation(swr_ctx, diff, distance);
-            if (ret < 0) {
-                LOGW("Resampling compensation failed: %d", ret);
-                // not fatal
-            }
-        }
-    }
-
-    return true;
-}
-
 static bool
 sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
                                 const AVCodecContext *ctx) {
@@ -320,6 +127,7 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
 
     assert(ctx->sample_rate > 0);
     assert(!av_sample_fmt_is_planar(SC_AV_SAMPLE_FMT));
+
     int out_bytes_per_sample = av_get_bytes_per_sample(SC_AV_SAMPLE_FMT);
     assert(out_bytes_per_sample > 0);
 
@@ -349,15 +157,7 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
     ap->nb_channels = nb_channels;
     ap->out_bytes_per_sample = out_bytes_per_sample;
 
-    ap->target_buffering = ap->target_buffering_delay * ap->sample_rate
-                                                      / SC_TICK_FREQ;
-
-    // Use a ring-buffer of the target buffering size plus 1 second between the
-    // producer and the consumer. It's too big on purpose, to guarantee that
-    // the producer and the consumer will be able to access it in parallel
-    // without locking.
-    size_t bytebuf_samples = ap->target_buffering + ap->sample_rate;
-    size_t bytebuf_size = samples_to_bytes(ap, bytebuf_samples);
+    size_t bytebuf_size = samples_to_bytes(ap, SC_BYTEBUF_SIZE_IN_SAMPLES);
 
     bool ok = sc_bytebuf_init(&ap->buf, bytebuf_size);
     if (!ok) {
@@ -374,21 +174,12 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
 
     ap->previous_write_avail = sc_bytebuf_write_available(&ap->buf);
 
-    // Samples are produced and consumed by blocks, so the buffering must be
-    // smoothed to get a relatively stable value.
-    sc_average_init(&ap->avg_buffering, 32);
+    sc_average_init(&ap->avg_buffering, 8);
     ap->samples_since_resync = 0;
 
-    ap->received = false;
-    ap->played = false;
-
-    // The thread calling open() is the thread calling push(), which fills the
-    // audio buffer consumed by the SDL audio thread.
-    ok = sc_thread_set_priority(SC_THREAD_PRIORITY_TIME_CRITICAL);
-    if (!ok) {
-        ok = sc_thread_set_priority(SC_THREAD_PRIORITY_HIGH);
-        (void) ok; // We don't care if it worked, at least we tried
-    }
+    ap->last_consumed = 0;
+    ap->underflow = 0;
+    ap->received = 0;
 
     SDL_PauseAudioDevice(ap->device, 0);
 
@@ -417,10 +208,166 @@ sc_audio_player_frame_sink_close(struct sc_frame_sink *sink) {
     swr_free(&ap->swr_ctx);
 }
 
-void
-sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering) {
-    ap->target_buffering_delay = target_buffering;
+static bool
+sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
+                                const AVFrame *frame) {
+    struct sc_audio_player *ap = DOWNCAST(sink);
 
+    SwrContext *swr_ctx = ap->swr_ctx;
+
+    int64_t delay = swr_get_delay(swr_ctx, ap->sample_rate);
+    // No need to av_rescale_rnd(), input and output sample rates are the same
+    // Add more space (256) for clock compensation
+    int dst_nb_samples = delay + frame->nb_samples + 256;
+
+    uint8_t *swr_buf = sc_audio_player_get_swr_buf(ap, dst_nb_samples);
+    if (!swr_buf) {
+        return false;
+    }
+
+    int ret = swr_convert(swr_ctx, &swr_buf, dst_nb_samples,
+                          (const uint8_t **) frame->data, frame->nb_samples);
+    if (ret < 0) {
+        LOGE("Resampling failed: %d", ret);
+        return false;
+    }
+
+    // swr_convert() returns the number of samples which would have been
+    // written if the buffer was big enough.
+    size_t samples_written = MIN(ret, dst_nb_samples);
+    size_t swr_buf_size = samples_to_bytes(ap, samples_written);
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+    LOGD("[Audio] %" SC_PRIsizet " samples written to buffer", samples_written);
+#endif
+
+    // Since this function is the only writer, the current available space is
+    // at least the previous available space. In practice, it should almost
+    // always be possible to write without lock.
+    bool lockless_write = swr_buf_size <= ap->previous_write_avail;
+    if (lockless_write) {
+        sc_bytebuf_prepare_write(&ap->buf, swr_buf, swr_buf_size);
+    }
+
+    SDL_LockAudioDevice(ap->device);
+
+    // The consumer requests audio samples blocks (e.g. 480 samples).
+    // Convert the duration since the last consumption into samples.
+    size_t extrapolated = 0;
+    if (ap->last_consumed) {
+        sc_tick now = sc_tick_now();
+        assert(now >= ap->last_consumed);
+        extrapolated = (now - ap->last_consumed) * ap->sample_rate
+                                                 / SC_TICK_FREQ;
+    }
+
+    size_t read_avail = sc_bytebuf_read_available(&ap->buf);
+
+    // The consumer may not increase underflow value if there are still samples
+    // available
+    assert(read_avail == 0 || ap->underflow == 0);
+
+    size_t buffered_samples = bytes_to_samples(ap, read_avail);
+    // Underflow caused silence samples in excess (so it adds buffering).
+    // Extrapolated samples must be considered consumed for smoothing (so it
+    // removes buffering).
+    float buffering = (float) buffered_samples + ap->underflow - extrapolated;
+    sc_average_push(&ap->avg_buffering, buffering);
+
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+    LOGD("[Audio] buffered_samples=%" SC_PRIsizet
+                " underflow=%" SC_PRIsizet
+                " extrapolated=%" SC_PRIsizet
+                " buffering=%f avg_buffering=%f",
+         buffered_samples, ap->underflow, extrapolated, buffering,
+         sc_average_get(&ap->avg_buffering));
+#endif
+
+    if (lockless_write) {
+        sc_bytebuf_commit_write(&ap->buf, swr_buf_size);
+    } else {
+        // Take care to keep full samples
+        size_t align = ap->nb_channels * ap->out_bytes_per_sample;
+        size_t write_avail =
+            sc_bytebuf_write_available(&ap->buf) / align * align;
+        if (swr_buf_size > write_avail) {
+            // Skip old samples
+            size_t cap = sc_bytebuf_capacity(&ap->buf) / align * align;
+            if (swr_buf_size > cap) {
+                // Ignore the first bytes in swr_buf
+                swr_buf += swr_buf_size - cap;
+                swr_buf_size = cap;
+            }
+            assert(swr_buf_size > write_avail);
+            if (swr_buf_size - write_avail > 0) {
+                sc_bytebuf_skip(&ap->buf, swr_buf_size - write_avail);
+            }
+        }
+        sc_bytebuf_write(&ap->buf, swr_buf, swr_buf_size);
+    }
+
+    // On buffer underflow, typically because a packet is late, silence is
+    // inserted. In that case, the late samples must be ignored when they
+    // arrive, otherwise they will delay playback.
+    //
+    // As an improvement, instead of naively skipping the silence duration, we
+    // can absorb it if it helps clock compensation.
+    if (ap->underflow) {
+        size_t avg = sc_average_get(&ap->avg_buffering);
+        if (avg > SC_TARGET_BUFFERED_SAMPLES) {
+            size_t diff = SC_TARGET_BUFFERED_SAMPLES - avg;
+            if (ap->underflow > diff) {
+                // Partially absorb underflow for clock compensation (only keep
+                // the diff with the target buffering level).
+                ap->underflow -= diff;
+            } else {
+                // Totally absorb underflow for clock compensation
+                ap->underflow = 0;
+            }
+
+            size_t skip_samples = MIN(ap->underflow, buffered_samples);
+            if (skip_samples) {
+                size_t skip_bytes = samples_to_bytes(ap, skip_samples);
+                sc_bytebuf_skip(&ap->buf, skip_bytes);
+                read_avail -= skip_bytes;
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+                LOGD("[Audio] Skipping %" SC_PRIsizet " samples", skip_samples);
+#endif
+            }
+        } else {
+            // Totally absorb underflow for clock compensation
+            ap->underflow = 0;
+        }
+    }
+
+    ap->previous_write_avail = sc_bytebuf_write_available(&ap->buf);
+    ap->received = true;
+
+    SDL_UnlockAudioDevice(ap->device);
+
+    ap->samples_since_resync += samples_written;
+    if (ap->samples_since_resync >= ap->sample_rate) {
+        // Resync every second
+        ap->samples_since_resync = 0;
+
+        float avg = sc_average_get(&ap->avg_buffering);
+        int diff = SC_TARGET_BUFFERED_SAMPLES - avg;
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+        LOGD("[Audio] Average buffering=%f, compensation %d", avg, diff);
+#endif
+        // Compensate the diff over 3 seconds (but will be recomputed after
+        // 1 second)
+        int ret = swr_set_compensation(swr_ctx, diff, 3 * ap->sample_rate);
+        if (ret < 0) {
+            LOGW("Resampling compensation failed: %d", ret);
+            // not fatal
+        }
+    }
+
+    return true;
+}
+
+void
+sc_audio_player_init(struct sc_audio_player *ap) {
     static const struct sc_frame_sink_ops ops = {
         .open = sc_audio_player_frame_sink_open,
         .close = sc_audio_player_frame_sink_close,

app/src/audio_player.h

@@ -8,7 +8,6 @@
 #include <util/average.h>
 #include <util/bytebuf.h>
 #include <util/thread.h>
-#include <util/tick.h>
 
 #include <libavformat/avformat.h>
 #include <libswresample/swresample.h>
@@ -19,23 +18,10 @@ struct sc_audio_player {
 
     SDL_AudioDeviceID device;
 
-    // The target buffering between the producer and the consumer. This value
-    // is directly use for compensation.
-    // Since audio capture and/or encoding on the device typically produce
-    // blocks of 960 samples (20ms) or 1024 samples (~21.3ms), this target
-    // value should be higher.
-    sc_tick target_buffering_delay;
-    uint32_t target_buffering; // in samples
-
-    // Audio buffer to communicate between the receiver and the SDL audio
-    // callback (protected by SDL_AudioDeviceLock())
+    // protected by SDL_AudioDeviceLock()
     struct sc_bytebuf buf;
-
-    // The previous number of bytes available in the buffer (only used by the
-    // receiver thread)
     size_t previous_write_avail;
 
-    // Resampler (only used from the receiver thread)
     struct SwrContext *swr_ctx;
 
     // The sample rate is the same for input and output
@@ -45,25 +31,22 @@ struct sc_audio_player {
     // The number of bytes per sample for a single channel
     unsigned out_bytes_per_sample;
 
-    // Target buffer for resampling (only used by the receiver thread)
+    // Target buffer for resampling
     uint8_t *swr_buf;
     size_t swr_buf_alloc_size;
 
-    // Number of buffered samples (may be negative on underflow) (only used by
-    // the receiver thread)
+    // Number of buffered samples (may be negative on underflow)
     struct sc_average avg_buffering;
     // Count the number of samples to trigger a compensation update regularly
-    // (only used by the receiver thread)
-    uint32_t samples_since_resync;
+    size_t samples_since_resync;
 
-    // Set to true the first time a sample is received (protected by
-    // SDL_AudioDeviceLock())
+    // The last date a sample has been consumed by the audio output
+    sc_tick last_consumed;
+
+    // Number of silence samples inserted to be compensated
+    size_t underflow;
     bool received;
 
-    // Set to true the first time the SDL callback is called (protected by
-    // SDL_AudioDeviceLock())
-    bool played;
-
     const struct sc_audio_player_callbacks *cbs;
     void *cbs_userdata;
 };
@@ -73,6 +56,6 @@ struct sc_audio_player_callbacks {
 };
 
 void
-sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering);
+sc_audio_player_init(struct sc_audio_player *ap);
 
 #endif

app/src/cli.c

@@ -19,7 +19,6 @@
 
 enum {
     OPT_RENDER_EXPIRED_FRAMES = 1000,
-    OPT_BIT_RATE,
     OPT_WINDOW_TITLE,
     OPT_PUSH_TARGET,
     OPT_ALWAYS_ON_TOP,
@@ -119,22 +118,21 @@ static const struct sc_option options[] = {
         .argdesc = "value",
         .text = "Encode the audio at the given bit-rate, expressed in bits/s. "
                 "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
-                "Default is 128K (128000).",
+                "Default is 196K (196000).",
     },
     {
         .longopt_id = OPT_AUDIO_BUFFER,
         .longopt = "audio-buffer",
         .argdesc = "ms",
-        .text = "Configure the audio buffering delay (in milliseconds).\n"
-                "Lower values decrease the latency, but increase the "
-                "likelyhood of buffer underrun (causing audio glitches).\n"
-                "Default is 50.",
+        .text = "Add a buffering delay (in milliseconds) before playing audio. "
+                "This increases latency to compensate for jitter.\n"
+                "Default is 0 (no buffering).",
     },
     {
         .longopt_id = OPT_AUDIO_CODEC,
         .longopt = "audio-codec",
         .argdesc = "name",
-        .text = "Select an audio codec (opus, aac or raw).\n"
+        .text = "Select an audio codec (raw, opus or aac).\n"
                 "Default is opus.",
     },
     {
@@ -165,12 +163,6 @@ static const struct sc_option options[] = {
                 "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
                 "Default is 8M (8000000).",
     },
-    {
-        // deprecated
-        .longopt_id = OPT_BIT_RATE,
-        .longopt = "bit-rate",
-        .argdesc = "value",
-    },
     {
         // Not really deprecated (--codec has never been released), but without
         // declaring an explicit --codec option, getopt_long() partial matching
@@ -480,8 +472,8 @@ static const struct sc_option options[] = {
         .longopt_id = OPT_REQUIRE_AUDIO,
         .longopt = "require-audio",
         .text = "By default, scrcpy mirrors only the video when audio capture "
-                "fails on the device. This option makes scrcpy fail if audio "
-                "is enabled but does not work."
+                "fails on the device. This flag makes scrcpy fail if audio is "
+                "enabled but does not work."
     },
     {
         .longopt_id = OPT_ROTATION,
@@ -1514,6 +1506,10 @@ parse_video_codec(const char *optarg, enum sc_codec *codec) {
 
 static bool
 parse_audio_codec(const char *optarg, enum sc_codec *codec) {
+    if (!strcmp(optarg, "raw")) {
+        *codec = SC_CODEC_RAW;
+        return true;
+    }
     if (!strcmp(optarg, "opus")) {
         *codec = SC_CODEC_OPUS;
         return true;
@@ -1522,11 +1518,7 @@ parse_audio_codec(const char *optarg, enum sc_codec *codec) {
         *codec = SC_CODEC_AAC;
         return true;
     }
-    if (!strcmp(optarg, "raw")) {
-        *codec = SC_CODEC_RAW;
-        return true;
-    }
-    LOGE("Unsupported audio codec: %s (expected opus, aac or raw)", optarg);
+    LOGE("Unsupported audio codec: %s (expected raw, opus or aac)", optarg);
     return false;
 }
 
@@ -1540,9 +1532,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
     int c;
     while ((c = getopt_long(argc, argv, optstring, longopts, NULL)) != -1) {
         switch (c) {
-            case OPT_BIT_RATE:
-                LOGW("--bit-rate is deprecated, use --video-bit-rate instead.");
-                // fall through
             case 'b':
                 if (!parse_bit_rate(optarg, &opts->video_bit_rate)) {
                     return false;
@@ -1944,6 +1933,18 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         }
     }
 
+    if (opts->audio_codec == SC_CODEC_RAW) {
+        if (opts->audio_bit_rate) {
+            LOGW("--audio-bit-rate is ignored for raw audio codec");
+        }
+        if (opts->audio_codec_options) {
+            LOGW("--audio-codec-options is ignored for raw audio codec");
+        }
+        if (opts->audio_encoder) {
+            LOGW("--audio-encoder is ignored for raw audio codec");
+        }
+    }
+
     if (!opts->control) {
         if (opts->turn_screen_off) {
             LOGE("Could not request to turn screen off if control is disabled");

app/src/clock.c

@@ -105,7 +105,8 @@ sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
     sc_clock_estimate(clock, &clock->slope, &clock->offset);
 
 #ifndef SC_CLOCK_NDEBUG
-    LOGD("Clock estimation: %f * pts + %" PRItick, clock->slope, clock->offset);
+    LOGD("Clock estimation: %f * pts + %" PRItick,
+         clock->slope, clock->offset);
 #endif
 }
 

app/src/compat.h

@@ -54,10 +54,6 @@
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
 #endif
 
-#if SDL_VERSION_ATLEAST(2, 0, 16)
-# define SCRCPY_SDL_HAS_THREAD_PRIORITY_TIME_CRITICAL
-#endif
-
 #ifndef HAVE_STRDUP
 char *strdup(const char *s);
 #endif

app/src/delay_buffer.c

@@ -58,7 +58,7 @@ run_buffering(void *data) {
 
         sc_tick max_deadline = sc_tick_now() + db->delay;
         // PTS (written by the server) are expressed in microseconds
-        sc_tick pts = SC_TICK_FROM_US(dframe.frame->pts);
+        sc_tick pts = SC_TICK_TO_US(dframe.frame->pts);
 
         bool timed_out = false;
         while (!db->stopped && !timed_out) {

app/src/demuxer.c

@@ -23,9 +23,9 @@ sc_demuxer_to_avcodec_id(uint32_t codec_id) {
 #define SC_CODEC_ID_H264 UINT32_C(0x68323634) // "h264" in ASCII
 #define SC_CODEC_ID_H265 UINT32_C(0x68323635) // "h265" in ASCII
 #define SC_CODEC_ID_AV1 UINT32_C(0x00617631) // "av1" in ASCII
+#define SC_CODEC_ID_RAW UINT32_C(0x00726177) // "raw" in ASCII
 #define SC_CODEC_ID_OPUS UINT32_C(0x6f707573) // "opus" in ASCII
 #define SC_CODEC_ID_AAC UINT32_C(0x00616163) // "aac in ASCII"
-#define SC_CODEC_ID_RAW UINT32_C(0x00726177) // "raw" in ASCII
     switch (codec_id) {
         case SC_CODEC_ID_H264:
             return AV_CODEC_ID_H264;
@@ -33,12 +33,12 @@ sc_demuxer_to_avcodec_id(uint32_t codec_id) {
             return AV_CODEC_ID_HEVC;
         case SC_CODEC_ID_AV1:
             return AV_CODEC_ID_AV1;
+        case SC_CODEC_ID_RAW:
+            return AV_CODEC_ID_PCM_S16LE;
         case SC_CODEC_ID_OPUS:
             return AV_CODEC_ID_OPUS;
         case SC_CODEC_ID_AAC:
             return AV_CODEC_ID_AAC;
-        case SC_CODEC_ID_RAW:
-            return AV_CODEC_ID_PCM_S16LE;
         default:
             LOGE("Unknown codec id 0x%08" PRIx32, codec_id);
             return AV_CODEC_ID_NONE;
@@ -200,7 +200,7 @@ run_demuxer(void *data) {
         ok = sc_packet_source_sinks_push(&demuxer->packet_source, packet);
         av_packet_unref(packet);
         if (!ok) {
-            // The sink already logged its concrete error
+            LOGE("Demuxer '%s': could not process packet", demuxer->name);
             break;
         }
     }

app/src/options.c

@@ -43,7 +43,7 @@ const struct scrcpy_options scrcpy_options_default = {
     .display_id = 0,
     .display_buffer = 0,
     .v4l2_buffer = 0,
-    .audio_buffer = SC_TICK_FROM_MS(50),
+    .audio_buffer = 0,
 #ifdef HAVE_USB
     .otg = false,
 #endif

app/src/options.h

@@ -27,9 +27,9 @@ enum sc_codec {
     SC_CODEC_H264,
     SC_CODEC_H265,
     SC_CODEC_AV1,
+    SC_CODEC_RAW,
     SC_CODEC_OPUS,
     SC_CODEC_AAC,
-    SC_CODEC_RAW,
 };
 
 enum sc_lock_video_orientation {

app/src/recorder.c

@@ -240,8 +240,7 @@ sc_recorder_process_header(struct sc_recorder *recorder) {
         sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
     }
 
-    if (sc_vecdeque_is_empty(&recorder->video_queue)) {
-        assert(recorder->stopped);
+    if (recorder->stopped && sc_vecdeque_is_empty(&recorder->video_queue)) {
         // If the recorder is stopped, don't process anything if there are not
         // at least video packets
         sc_mutex_unlock(&recorder->mutex);
@@ -395,6 +394,10 @@ sc_recorder_process_packets(struct sc_recorder *recorder) {
                     error = true;
                     goto end;
                 }
+                // If the recorder is stopped while one of the streams has no
+                // packets, then we must avoid a live-loop and correctly record
+                // the stream having packets.
+                pts_origin = video_pkt ? video_pkt->pts : audio_pkt->pts;
             } else {
                 // We need both video and audio packets to initialize pts_origin
                 continue;
@@ -505,10 +508,6 @@ static int
 run_recorder(void *data) {
     struct sc_recorder *recorder = data;
 
-    // Recording is a background task
-    bool ok = sc_thread_set_priority(SC_THREAD_PRIORITY_LOW);
-    (void) ok; // We don't care if it worked
-
     bool success = sc_recorder_record(recorder);
 
     sc_mutex_lock(&recorder->mutex);
@@ -584,7 +583,7 @@ sc_recorder_video_packet_sink_push(struct sc_packet_sink *sink,
         return false;
     }
 
-    rec->stream_index = recorder->video_stream_index;
+    rec->stream_index = 0;
 
     bool ok = sc_vecdeque_push(&recorder->video_queue, rec);
     if (!ok) {
@@ -653,7 +652,7 @@ sc_recorder_audio_packet_sink_push(struct sc_packet_sink *sink,
         return false;
     }
 
-    rec->stream_index = recorder->audio_stream_index;
+    rec->stream_index = 1;
 
     bool ok = sc_vecdeque_push(&recorder->audio_queue, rec);
     if (!ok) {

app/src/scrcpy.c

@@ -43,6 +43,7 @@ struct scrcpy {
     struct sc_server server;
     struct sc_screen screen;
     struct sc_audio_player audio_player;
+    struct sc_delay_buffer audio_buffer;
     struct sc_demuxer video_demuxer;
     struct sc_demuxer audio_demuxer;
     struct sc_decoder video_decoder;
@@ -245,6 +246,13 @@ sc_audio_demuxer_on_ended(struct sc_demuxer *demuxer,
 
     // Contrary to the video demuxer, keep mirroring if only the audio fails
     // (unless --require-audio is set).
+    // '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 (status == SC_DEMUXER_STATUS_ERROR
             || (status == SC_DEMUXER_STATUS_DISABLED
                 && options->require_audio)) {
@@ -687,9 +695,16 @@ aoa_hid_end:
         sc_frame_source_add_sink(src, &s->screen.frame_sink);
 
         if (options->audio) {
-            sc_audio_player_init(&s->audio_player, options->audio_buffer);
-            sc_frame_source_add_sink(&s->audio_decoder.frame_source,
-                                     &s->audio_player.frame_sink);
+            struct sc_frame_source *src = &s->audio_decoder.frame_source;
+            if (options->audio_buffer) {
+                sc_delay_buffer_init(&s->audio_buffer, options->audio_buffer,
+                                     false);
+                sc_frame_source_add_sink(src, &s->audio_buffer.frame_sink);
+                src = &s->audio_buffer.frame_source;
+            }
+
+            sc_audio_player_init(&s->audio_player);
+            sc_frame_source_add_sink(src, &s->audio_player.frame_sink);
         }
     }
 

app/src/server.c

@@ -169,12 +169,12 @@ sc_server_get_codec_name(enum sc_codec codec) {
             return "h265";
         case SC_CODEC_AV1:
             return "av1";
+        case SC_CODEC_RAW:
+            return "raw";
         case SC_CODEC_OPUS:
             return "opus";
         case SC_CODEC_AAC:
             return "aac";
-        case SC_CODEC_RAW:
-            return "raw";
         default:
             return NULL;
     }

app/src/util/bytebuf.c

@@ -9,6 +9,7 @@
 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();
@@ -63,8 +64,8 @@ sc_bytebuf_write_step0(struct sc_bytebuf *buf, const uint8_t *from,
     if (len < right_len) {
         right_len = len;
     }
-    memcpy(buf->data + buf->head, from, right_len);
 
+    memcpy(buf->data + buf->head, from, right_len);
     if (len > right_len) {
         memcpy(buf->data, from + right_len, len - right_len);
     }

app/src/util/bytebuf.h

@@ -14,7 +14,7 @@ struct sc_bytebuf {
     size_t head; // writter cursor
     size_t tail; // reader cursor
     // empty: tail == head
-    // full: ((tail + 1) % alloc_size) == head
+    // full: (tail + 1) % allocated == head
 };
 
 bool
@@ -37,10 +37,12 @@ sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len);
  * The caller must check that len <= sc_bytebuf_read_available() (it is an
  * error to attempt to skip more bytes than available).
  *
- * This function is guaranteed not to write to buf->head.
+ * This function is guaranteed not to change the head.
+ *
+ * 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 this function is more efficient since there is no copy).
+ * array (but more efficient since there is no copy).
  */
 void
 sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len);

app/src/util/log.c

@@ -125,30 +125,8 @@ sc_av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
     free(local_fmt);
 }
 
-static const char *const sc_sdl_log_priority_names[SDL_NUM_LOG_PRIORITIES] = {
-    [SDL_LOG_PRIORITY_VERBOSE] = "VERBOSE",
-    [SDL_LOG_PRIORITY_DEBUG] = "DEBUG",
-    [SDL_LOG_PRIORITY_INFO] = "INFO",
-    [SDL_LOG_PRIORITY_WARN] = "WARN",
-    [SDL_LOG_PRIORITY_ERROR] = "ERROR",
-    [SDL_LOG_PRIORITY_CRITICAL] = "CRITICAL",
-};
-
-static void SDLCALL
-sc_sdl_log_print(void *userdata, int category, SDL_LogPriority priority,
-                 const char *message) {
-    (void) userdata;
-    (void) category;
-
-    FILE *out = priority < SDL_LOG_PRIORITY_WARN ? stdout : stderr;
-    assert(priority < SDL_NUM_LOG_PRIORITIES);
-    const char *prio_name = sc_sdl_log_priority_names[priority];
-    fprintf(out, "%s: %s\n", prio_name, message);
-}
-
 void
 sc_log_configure() {
-    SDL_LogSetOutputFunction(sc_sdl_log_print, NULL);
     // Redirect FFmpeg logs to SDL logs
     av_log_set_callback(sc_av_log_callback);
 }

app/src/util/memory.h

@@ -3,10 +3,7 @@
 
 #include <stddef.h>
 
-/**
- * Allocate an array of `nmemb` items of `size` bytes each
- *
- * Like calloc(), but without initialization.
+/* Like calloc(), but without initialization.
  * Like reallocarray(), but without reallocation.
  */
 void *

app/src/util/thread.c

@@ -23,39 +23,6 @@ sc_thread_create(sc_thread *thread, sc_thread_fn fn, const char *name,
     return true;
 }
 
-static SDL_ThreadPriority
-to_sdl_thread_priority(enum sc_thread_priority priority) {
-    switch (priority) {
-        case SC_THREAD_PRIORITY_TIME_CRITICAL:
-#ifdef SCRCPY_SDL_HAS_THREAD_PRIORITY_TIME_CRITICAL
-            return SDL_THREAD_PRIORITY_TIME_CRITICAL;
-#else
-            // fall through
-#endif
-        case SC_THREAD_PRIORITY_HIGH:
-            return SDL_THREAD_PRIORITY_HIGH;
-        case SC_THREAD_PRIORITY_NORMAL:
-            return SDL_THREAD_PRIORITY_NORMAL;
-        case SC_THREAD_PRIORITY_LOW:
-            return SDL_THREAD_PRIORITY_LOW;
-        default:
-            assert(!"Unknown thread priority");
-            return 0;
-    }
-}
-
-bool
-sc_thread_set_priority(enum sc_thread_priority priority) {
-    SDL_ThreadPriority sdl_priority = to_sdl_thread_priority(priority);
-    int r = SDL_SetThreadPriority(sdl_priority);
-    if (r) {
-        LOGD("Could not set thread priority: %s", SDL_GetError());
-        return false;
-    }
-
-    return true;
-}
-
 void
 sc_thread_join(sc_thread *thread, int *status) {
     SDL_WaitThread(thread->thread, status);

app/src/util/thread.h

@@ -21,13 +21,6 @@ typedef struct sc_thread {
     SDL_Thread *thread;
 } sc_thread;
 
-enum sc_thread_priority {
-    SC_THREAD_PRIORITY_LOW,
-    SC_THREAD_PRIORITY_NORMAL,
-    SC_THREAD_PRIORITY_HIGH,
-    SC_THREAD_PRIORITY_TIME_CRITICAL,
-};
-
 typedef struct sc_mutex {
     SDL_mutex *mutex;
 #ifndef NDEBUG
@@ -46,9 +39,6 @@ sc_thread_create(sc_thread *thread, sc_thread_fn fn, const char *name,
 void
 sc_thread_join(sc_thread *thread, int *status);
 
-bool
-sc_thread_set_priority(enum sc_thread_priority priority);
-
 bool
 sc_mutex_init(sc_mutex *mutex);
 

app/src/util/vecdeque.h

@@ -52,10 +52,10 @@
  */
 #define sc_vecdeque_init(pv) \
 ({ \
+    (pv)->data = NULL; \
     (pv)->cap = 0; \
     (pv)->origin = 0; \
     (pv)->size = 0; \
-    (pv)->data = NULL; \
 })
 
 /**
@@ -128,7 +128,7 @@
  * \param item_size the size of one item (the generic type is unknown from this
  *                  function)
  * \param pcap a pointer to the `cap` field of the SC_VECDEQUE [IN/OUT]
- * \param porigin a pointer to pv->origin [IN/OUT]
+ * \param porigin a pointer to pv->origin (will be read and updated)
  * \param size the `size` field of the SC_VECDEQUE
  * \return the new array to assign to the `data` field of the SC_VECDEQUE (if
  *         not NULL)
@@ -312,7 +312,7 @@ sc_vecdeque_growsize_(size_t value)
  *
  * If the VecDeque is full, it is resized.
  *
- * This function returns either a valid non-NULL pointer to the uninitialized
+ * This function returns either a valid non-nULL pointer to the uninitialized
  * item just pushed, or NULL on reallocation failure.
  */
 #define sc_vecdeque_push_hole(pv) \
@@ -369,7 +369,7 @@ sc_vecdeque_growsize_(size_t value)
 })
 
 /**
- * Pop an item and return it
+ * Pop an item and returns it
  *
  * It is an error to call this function if the VecDeque is empty.
  */

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

@@ -1,7 +0,0 @@
-package com.genymobile.scrcpy;
-
-public interface AsyncProcessor {
-    void start();
-    void stop();
-    void join() throws InterruptedException;
-}

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

@@ -129,8 +129,8 @@ public final class AudioCapture {
             pts = nextPts;
         }
 
-        long durationUs = r * 1000000 / (CHANNELS * BYTES_PER_SAMPLE * SAMPLE_RATE);
-        nextPts = pts + durationUs;
+        long durationMs = r * 1000 / CHANNELS / SAMPLE_RATE;
+        nextPts = pts + durationMs;
 
         if (previousPts != 0 && pts < previousPts) {
             // Audio PTS may come from two sources:

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

@@ -3,9 +3,9 @@ package com.genymobile.scrcpy;
 import android.media.MediaFormat;
 
 public enum AudioCodec implements Codec {
+    RAW(0x00_72_61_77, "raw", MediaFormat.MIMETYPE_AUDIO_RAW),
     OPUS(0x6f_70_75_73, "opus", MediaFormat.MIMETYPE_AUDIO_OPUS),
-    AAC(0x00_61_61_63, "aac", MediaFormat.MIMETYPE_AUDIO_AAC),
-    RAW(0x00_72_61_77, "raw", MediaFormat.MIMETYPE_AUDIO_RAW);
+    AAC(0x00_61_61_63, "aac", MediaFormat.MIMETYPE_AUDIO_AAC);
 
     private final int id; // 4-byte ASCII representation of the name
     private final String name;

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

@@ -14,7 +14,7 @@ import java.util.List;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
 
-public final class AudioEncoder implements AsyncProcessor {
+public final class AudioEncoder implements AudioRecorder {
 
     private static class InputTask {
         private final int index;

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

@@ -5,7 +5,7 @@ import android.media.MediaCodec;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 
-public final class AudioRawRecorder implements AsyncProcessor {
+public final class AudioRawRecorder implements AudioRecorder {
 
     private final Streamer streamer;
 

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

@@ -0,0 +1,12 @@
+package com.genymobile.scrcpy;
+
+/**
+ * A component able to record audio asynchronously
+ *
+ * The implementation is responsible to send packets.
+ */
+public interface AudioRecorder {
+    void start();
+    void stop();
+    void join() throws InterruptedException;
+}

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

@@ -14,7 +14,7 @@ import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
-public class Controller implements AsyncProcessor {
+public class Controller {
 
     private static final int DEFAULT_DEVICE_ID = 0;
 

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

@@ -39,28 +39,28 @@ public final class Ln {
     public static void v(String message) {
         if (isEnabled(Level.VERBOSE)) {
             Log.v(TAG, message);
-            System.out.print(PREFIX + "VERBOSE: " + message + '\n');
+            System.out.println(PREFIX + "VERBOSE: " + message);
         }
     }
 
     public static void d(String message) {
         if (isEnabled(Level.DEBUG)) {
             Log.d(TAG, message);
-            System.out.print(PREFIX + "DEBUG: " + message + '\n');
+            System.out.println(PREFIX + "DEBUG: " + message);
         }
     }
 
     public static void i(String message) {
         if (isEnabled(Level.INFO)) {
             Log.i(TAG, message);
-            System.out.print(PREFIX + "INFO: " + message + '\n');
+            System.out.println(PREFIX + "INFO: " + message);
         }
     }
 
     public static void w(String message, Throwable throwable) {
         if (isEnabled(Level.WARN)) {
             Log.w(TAG, message, throwable);
-            System.err.print(PREFIX + "WARN: " + message + '\n');
+            System.out.println(PREFIX + "WARN: " + message);
             if (throwable != null) {
                 throwable.printStackTrace();
             }
@@ -74,7 +74,7 @@ public final class Ln {
     public static void e(String message, Throwable throwable) {
         if (isEnabled(Level.ERROR)) {
             Log.e(TAG, message, throwable);
-            System.err.print(PREFIX + "ERROR: " + message + "\n");
+            System.out.println(PREFIX + "ERROR: " + message);
             if (throwable != null) {
                 throwable.printStackTrace();
             }

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

@@ -13,7 +13,7 @@ public class Options {
     private VideoCodec videoCodec = VideoCodec.H264;
     private AudioCodec audioCodec = AudioCodec.OPUS;
     private int videoBitRate = 8000000;
-    private int audioBitRate = 128000;
+    private int audioBitRate = 196000;
     private int maxFps;
     private int lockVideoOrientation = -1;
     private boolean tunnelForward;

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

@@ -5,7 +5,6 @@ import android.os.BatteryManager;
 import android.os.Build;
 
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 
@@ -92,7 +91,8 @@ public final class Server {
             Workarounds.fillAppInfo();
         }
 
-        List<AsyncProcessor> asyncProcessors = new ArrayList<>();
+        Controller controller = null;
+        AudioRecorder audioRecorder = null;
 
         try (DesktopConnection connection = DesktopConnection.open(scid, tunnelForward, audio, control, sendDummyByte)) {
             if (options.getSendDeviceMeta()) {
@@ -101,34 +101,29 @@ public final class Server {
             }
 
             if (control) {
-                Controller controller = new Controller(device, connection, options.getClipboardAutosync(), options.getPowerOn());
-                device.setClipboardListener(text -> controller.getSender().pushClipboardText(text));
-                asyncProcessors.add(controller);
+                controller = new Controller(device, connection, options.getClipboardAutosync(), options.getPowerOn());
+                controller.start();
+
+                final Controller controllerRef = controller;
+                device.setClipboardListener(text -> controllerRef.getSender().pushClipboardText(text));
             }
 
             if (audio) {
                 AudioCodec audioCodec = options.getAudioCodec();
-                Streamer audioStreamer = new Streamer(connection.getAudioFd(), audioCodec, options.getSendCodecId(),
-                        options.getSendFrameMeta());
-                AsyncProcessor audioRecorder;
+                Streamer audioStreamer = new Streamer(connection.getAudioFd(), audioCodec, options.getSendCodecId(), options.getSendFrameMeta());
                 if (audioCodec == AudioCodec.RAW) {
                     audioRecorder = new AudioRawRecorder(audioStreamer);
                 } else {
                     audioRecorder = new AudioEncoder(audioStreamer, options.getAudioBitRate(), options.getAudioCodecOptions(),
                             options.getAudioEncoder());
                 }
-                asyncProcessors.add(audioRecorder);
+                audioRecorder.start();
             }
 
             Streamer videoStreamer = new Streamer(connection.getVideoFd(), options.getVideoCodec(), options.getSendCodecId(),
                     options.getSendFrameMeta());
             ScreenEncoder screenEncoder = new ScreenEncoder(device, videoStreamer, options.getVideoBitRate(), options.getMaxFps(),
                     options.getVideoCodecOptions(), options.getVideoEncoder(), options.getDownsizeOnError());
-
-            for (AsyncProcessor asyncProcessor : asyncProcessors) {
-                asyncProcessor.start();
-            }
-
             try {
                 // synchronous
                 screenEncoder.streamScreen();
@@ -141,14 +136,20 @@ public final class Server {
         } finally {
             Ln.d("Screen streaming stopped");
             initThread.interrupt();
-            for (AsyncProcessor asyncProcessor : asyncProcessors) {
-                asyncProcessor.stop();
+            if (audioRecorder != null) {
+                audioRecorder.stop();
+            }
+            if (controller != null) {
+                controller.stop();
             }
 
             try {
                 initThread.join();
-                for (AsyncProcessor asyncProcessor : asyncProcessors) {
-                    asyncProcessor.join();
+                if (audioRecorder != null) {
+                    audioRecorder.join();
+                }
+                if (controller != null) {
+                    controller.join();
                 }
             } catch (InterruptedException e) {
                 // ignore