Stop on decoder frame push error

On push, frame sinks report downstream errors to stop upstream
components. Do not ignore the error.

README.md

@@ -718,7 +718,7 @@ scrcpy --display=1
 The list of display ids can be retrieved by:
 
 ```bash
-scrcpy --list-displays
+adb shell dumpsys display   # search "mDisplayId=" in the output
 ```
 
 The secondary display may only be controlled if the device runs at least Android

app/data/bash-completion/scrcpy

@@ -45,7 +45,6 @@ _scrcpy() {
         -r --record=
         --record-format=
         --render-driver=
-        --require-audio
         --rotation=
         -s --serial=
         --shortcut-mod=
@@ -78,7 +77,7 @@ _scrcpy() {
             return
             ;;
         --audio-codec)
-            COMPREPLY=($(compgen -W 'opus aac raw' -- "$cur"))
+            COMPREPLY=($(compgen -W '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:(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]'
@@ -51,7 +51,6 @@ arguments=(
     {-r,--record=}'[Record screen to file]:record file:_files'
     '--record-format=[Force recording format]:format:(mp4 mkv)'
     '--render-driver=[Request SDL to use the given render driver]:driver name:(direct3d opengl opengles2 opengles metal software)'
-    '--require-audio=[Make scrcpy fail if audio is enabled but does not work]'
     '--rotation=[Set the initial display rotation]:rotation values:(0 1 2 3)'
     {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]:serial:($("${ADB-adb}" devices | awk '\''$2 == "device" {print $1}'\''))'
     '--shortcut-mod=[\[key1,key2+key3,...\] Specify the modifiers to use for scrcpy shortcuts]:shortcut mod:(lctrl rctrl lalt ralt lsuper rsuper)'

app/meson.build

@@ -136,19 +136,26 @@ else
     ffmpeg_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_ffmpeg + '/bin'
     ffmpeg_include_dir = 'prebuilt-deps/data/' + prebuilt_ffmpeg + '/include'
 
+    # ffmpeg versions are different for win32 and win64 builds
+    ffmpeg_avcodec = meson.get_cross_property('ffmpeg_avcodec')
+    ffmpeg_avformat = meson.get_cross_property('ffmpeg_avformat')
+    ffmpeg_avutil = meson.get_cross_property('ffmpeg_avutil')
+    ffmpeg_swresample = meson.get_cross_property('ffmpeg_swresample')
+
     ffmpeg = declare_dependency(
         dependencies: [
-            cc.find_library('avcodec-60', dirs: ffmpeg_bin_dir),
-            cc.find_library('avformat-60', dirs: ffmpeg_bin_dir),
-            cc.find_library('avutil-58', dirs: ffmpeg_bin_dir),
-            cc.find_library('swresample-4', dirs: ffmpeg_bin_dir),
+            cc.find_library(ffmpeg_avcodec, dirs: ffmpeg_bin_dir),
+            cc.find_library(ffmpeg_avformat, dirs: ffmpeg_bin_dir),
+            cc.find_library(ffmpeg_avutil, dirs: ffmpeg_bin_dir),
+            cc.find_library(ffmpeg_swresample, dirs: ffmpeg_bin_dir),
         ],
         include_directories: include_directories(ffmpeg_include_dir)
     )
 
     prebuilt_libusb = meson.get_cross_property('prebuilt_libusb')
-    libusb_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_libusb + '/bin'
-    libusb_include_dir = 'prebuilt-deps/data/' + prebuilt_libusb + '/include'
+    prebuilt_libusb_root = meson.get_cross_property('prebuilt_libusb_root')
+    libusb_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_libusb
+    libusb_include_dir = 'prebuilt-deps/data/' + prebuilt_libusb_root + '/include'
 
     libusb = declare_dependency(
         dependencies: [

app/prebuilt-deps/prepare-ffmpeg-win32.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -e
+DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DIR"
+. common
+mkdir -p "$PREBUILT_DATA_DIR"
+cd "$PREBUILT_DATA_DIR"
+
+DEP_DIR=ffmpeg-win32-4.3.1
+
+FILENAME_SHARED=ffmpeg-4.3.1-win32-shared.zip
+SHA256SUM_SHARED=357af9901a456f4dcbacd107e83a934d344c9cb07ddad8aaf80612eeab7d26d2
+
+FILENAME_DEV=ffmpeg-4.3.1-win32-dev.zip
+SHA256SUM_DEV=230efb08e9bcf225bd474da29676c70e591fc94d8790a740ca801408fddcb78b
+
+if [[ -d "$DEP_DIR" ]]
+then
+    echo "$DEP_DIR" found
+    exit 0
+fi
+
+get_file "https://github.com/Genymobile/scrcpy/releases/download/v1.16/$FILENAME_SHARED" \
+    "$FILENAME_SHARED" "$SHA256SUM_SHARED"
+get_file "https://github.com/Genymobile/scrcpy/releases/download/v1.16/$FILENAME_DEV" \
+    "$FILENAME_DEV" "$SHA256SUM_DEV"
+
+mkdir "$DEP_DIR"
+cd "$DEP_DIR"
+
+ZIP_PREFIX_SHARED=ffmpeg-4.3.1-win32-shared
+unzip "../$FILENAME_SHARED" \
+    "$ZIP_PREFIX_SHARED"/bin/avutil-56.dll \
+    "$ZIP_PREFIX_SHARED"/bin/avcodec-58.dll \
+    "$ZIP_PREFIX_SHARED"/bin/avformat-58.dll \
+    "$ZIP_PREFIX_SHARED"/bin/swresample-3.dll \
+    "$ZIP_PREFIX_SHARED"/bin/swscale-5.dll
+
+ZIP_PREFIX_DEV=ffmpeg-4.3.1-win32-dev
+unzip "../$FILENAME_DEV" \
+    "$ZIP_PREFIX_DEV/include/*"
+
+mv "$ZIP_PREFIX_SHARED"/* .
+mv "$ZIP_PREFIX_DEV"/* .
+rmdir "$ZIP_PREFIX_SHARED" "$ZIP_PREFIX_DEV"

app/prebuilt-deps/prepare-ffmpeg-win64.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+set -e
+DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DIR"
+. common
+mkdir -p "$PREBUILT_DATA_DIR"
+cd "$PREBUILT_DATA_DIR"
+
+VERSION=5.1.2
+DEP_DIR=ffmpeg-win64-$VERSION
+
+FILENAME=ffmpeg-$VERSION-full_build-shared.7z
+SHA256SUM=d9eb97b72d7cfdae4d0f7eaea59ccffb8c364d67d88018ea715d5e2e193f00e9
+
+if [[ -d "$DEP_DIR" ]]
+then
+    echo "$DEP_DIR" found
+    exit 0
+fi
+
+get_file "https://github.com/GyanD/codexffmpeg/releases/download/$VERSION/$FILENAME" \
+    "$FILENAME" "$SHA256SUM"
+
+mkdir "$DEP_DIR"
+cd "$DEP_DIR"
+
+ZIP_PREFIX=ffmpeg-$VERSION-full_build-shared
+7z x "../$FILENAME" \
+    "$ZIP_PREFIX"/bin/avutil-57.dll \
+    "$ZIP_PREFIX"/bin/avcodec-59.dll \
+    "$ZIP_PREFIX"/bin/avformat-59.dll \
+    "$ZIP_PREFIX"/bin/swresample-4.dll \
+    "$ZIP_PREFIX"/bin/swscale-6.dll \
+    "$ZIP_PREFIX"/include
+mv "$ZIP_PREFIX"/* .
+rmdir "$ZIP_PREFIX"

app/prebuilt-deps/prepare-ffmpeg.sh

@@ -1,30 +0,0 @@
-#!/usr/bin/env bash
-set -e
-DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DIR"
-. common
-mkdir -p "$PREBUILT_DATA_DIR"
-cd "$PREBUILT_DATA_DIR"
-
-VERSION=6.0-scrcpy-2
-DEP_DIR="ffmpeg-$VERSION"
-
-FILENAME="$DEP_DIR".7z
-SHA256SUM=98ef97f8607c97a5c4f9c5a0a991b78f105d002a3619145011d16ffb92501b14
-
-if [[ -d "$DEP_DIR" ]]
-then
-    echo "$DEP_DIR" found
-    exit 0
-fi
-
-get_file "https://github.com/rom1v/scrcpy-deps/releases/download/$VERSION/$FILENAME" \
-    "$FILENAME" "$SHA256SUM"
-
-mkdir "$DEP_DIR"
-cd "$DEP_DIR"
-
-ZIP_PREFIX=ffmpeg
-7z x "../$FILENAME"
-mv "$ZIP_PREFIX"/* .
-rmdir "$ZIP_PREFIX"

app/prebuilt-deps/prepare-libusb.sh

@@ -22,12 +22,13 @@ get_file "https://github.com/libusb/libusb/releases/download/v1.0.26/$FILENAME"
 mkdir "$DEP_DIR"
 cd "$DEP_DIR"
 
+# include/ is the same in all folders of the archive
 7z x "../$FILENAME" \
     libusb-1.0.26-binaries/libusb-MinGW-Win32/bin/msys-usb-1.0.dll \
-    libusb-1.0.26-binaries/libusb-MinGW-Win32/include/ \
     libusb-1.0.26-binaries/libusb-MinGW-x64/bin/msys-usb-1.0.dll \
     libusb-1.0.26-binaries/libusb-MinGW-x64/include/
 
-mv libusb-1.0.26-binaries/libusb-MinGW-Win32 .
-mv libusb-1.0.26-binaries/libusb-MinGW-x64 .
+mv libusb-1.0.26-binaries/libusb-MinGW-Win32/bin MinGW-Win32
+mv libusb-1.0.26-binaries/libusb-MinGW-x64/bin MinGW-x64
+mv libusb-1.0.26-binaries/libusb-MinGW-x64/include .
 rm -rf libusb-1.0.26-binaries

app/scrcpy.1

@@ -23,32 +23,20 @@ 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 (opus or aac).
 
 Default is opus.
 
-.TP
-.BI "\-\-audio\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
-Set a list of comma-separated key:type=value options for the device audio 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 "\-\-audio\-encoder " name
 Use a specific MediaCodec audio encoder (depending on the codec provided by \fB\-\-audio\-codec\fR).
@@ -282,7 +270,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,58 +45,33 @@ 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);
-
-        if (ap->received) {
-            // Inserting additional samples immediately increases buffering
-            ap->avg_buffering.avg += silence_samples;
-        }
+        // 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);
+        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) {
+    if (min_buf_size < ap->swr_buf_alloc_size) {
         size_t new_size = min_buf_size + 4096;
         uint8_t *buf = realloc(ap->swr_buf, new_size);
         if (!buf) {
@@ -102,186 +86,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 +124,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 +154,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 +171,11 @@ 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;
 
     SDL_PauseAudioDevice(ap->device, 0);
 
@@ -417,10 +204,162 @@ 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
+    LOGI("[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 = (sc_tick_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 (diff < ap->underflow) {
+                // Partially absorb underflow for clock compensation (only keep
+                // the diff with the target buffering level).
+                ap->underflow = diff;
+            }
+
+            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);
+
+    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
+        LOGI("[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,24 +31,20 @@ 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())
-    bool received;
+    // The last date a sample has been consumed by the audio output
+    sc_tick last_consumed;
 
-    // Set to true the first time the SDL callback is called (protected by
-    // SDL_AudioDeviceLock())
-    bool played;
+    // Number of silence samples inserted to be compensated
+    size_t underflow;
 
     const struct sc_audio_player_callbacks *cbs;
     void *cbs_userdata;
@@ -73,6 +55,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 (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,
@@ -1522,11 +1514,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 opus)", optarg);
     return false;
 }
 
@@ -1540,9 +1528,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;
@@ -1927,23 +1912,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         }
     }
 
-    if (opts->record_filename && opts->audio_codec == SC_CODEC_RAW) {
-        LOGW("Recording does not support RAW audio codec");
-        return false;
-    }
-
-    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

@@ -25,7 +25,6 @@ sc_demuxer_to_avcodec_id(uint32_t codec_id) {
 #define SC_CODEC_ID_AV1 UINT32_C(0x00617631) // "av1" in ASCII
 #define SC_CODEC_ID_OPUS UINT32_C(0x6f707573) // "opus" in ASCII
 #define SC_CODEC_ID_AAC UINT32_C(0x00616163) // "aac in ASCII"
-#define SC_CODEC_ID_RAW UINT32_C(0x00726177) // "raw" in ASCII
     switch (codec_id) {
         case SC_CODEC_ID_H264:
             return AV_CODEC_ID_H264;
@@ -37,8 +36,6 @@ sc_demuxer_to_avcodec_id(uint32_t codec_id) {
             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 +197,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

@@ -29,7 +29,6 @@ enum sc_codec {
     SC_CODEC_AV1,
     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

@@ -173,8 +173,6 @@ sc_server_get_codec_name(enum sc_codec codec) {
             return "opus";
         case SC_CODEC_AAC:
             return "aac";
-        case SC_CODEC_RAW:
-            return "raw";
         default:
             return NULL;
     }
@@ -216,7 +214,7 @@ execute_server(struct sc_server *server,
 
     unsigned dyn_idx = count; // from there, the strings are allocated
 #define ADD_PARAM(fmt, ...) { \
-        char *p; \
+        char *p = (char *) &cmd[count]; \
         if (asprintf(&p, fmt, ## __VA_ARGS__) == -1) { \
             goto end; \
         } \

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.
  */

cross_win32.txt

@@ -16,6 +16,11 @@ cpu = 'i686'
 endian = 'little'
 
 [properties]
-prebuilt_ffmpeg = 'ffmpeg-6.0-scrcpy-2/win32'
+ffmpeg_avcodec = 'avcodec-58'
+ffmpeg_avformat = 'avformat-58'
+ffmpeg_avutil = 'avutil-56'
+ffmpeg_swresample = 'swresample-3'
+prebuilt_ffmpeg = 'ffmpeg-win32-4.3.1'
 prebuilt_sdl2 = 'SDL2-2.26.1/i686-w64-mingw32'
-prebuilt_libusb = 'libusb-1.0.26/libusb-MinGW-Win32'
+prebuilt_libusb_root = 'libusb-1.0.26'
+prebuilt_libusb = 'libusb-1.0.26/MinGW-Win32'

cross_win64.txt

@@ -16,6 +16,11 @@ cpu = 'x86_64'
 endian = 'little'
 
 [properties]
-prebuilt_ffmpeg = 'ffmpeg-6.0-scrcpy-2/win64'
+ffmpeg_avcodec = 'avcodec-59'
+ffmpeg_avformat = 'avformat-59'
+ffmpeg_avutil = 'avutil-57'
+ffmpeg_swresample = 'swresample-4'
+prebuilt_ffmpeg = 'ffmpeg-win64-5.1.2'
 prebuilt_sdl2 = 'SDL2-2.26.1/x86_64-w64-mingw32'
-prebuilt_libusb = 'libusb-1.0.26/libusb-MinGW-x64'
+prebuilt_libusb_root = 'libusb-1.0.26'
+prebuilt_libusb = 'libusb-1.0.26/MinGW-x64'

release.mk

@@ -11,7 +11,7 @@
 .PHONY: default clean \
 	test \
 	build-server \
-	prepare-deps \
+	prepare-deps-win32 prepare-deps-win64 \
 	build-win32 build-win64 \
 	dist-win32 dist-win64 \
 	zip-win32 zip-win64 \
@@ -62,13 +62,19 @@ build-server:
 		meson setup "$(SERVER_BUILD_DIR)" --buildtype release -Dcompile_app=false )
 	ninja -C "$(SERVER_BUILD_DIR)"
 
-prepare-deps:
+prepare-deps-win32:
 	@app/prebuilt-deps/prepare-adb.sh
 	@app/prebuilt-deps/prepare-sdl.sh
-	@app/prebuilt-deps/prepare-ffmpeg.sh
+	@app/prebuilt-deps/prepare-ffmpeg-win32.sh
 	@app/prebuilt-deps/prepare-libusb.sh
 
-build-win32: prepare-deps
+prepare-deps-win64:
+	@app/prebuilt-deps/prepare-adb.sh
+	@app/prebuilt-deps/prepare-sdl.sh
+	@app/prebuilt-deps/prepare-ffmpeg-win64.sh
+	@app/prebuilt-deps/prepare-libusb.sh
+
+build-win32: prepare-deps-win32
 	[ -d "$(WIN32_BUILD_DIR)" ] || ( mkdir "$(WIN32_BUILD_DIR)" && \
 		meson setup "$(WIN32_BUILD_DIR)" \
 			--cross-file cross_win32.txt \
@@ -77,7 +83,7 @@ build-win32: prepare-deps
 			-Dportable=true )
 	ninja -C "$(WIN32_BUILD_DIR)"
 
-build-win64: prepare-deps
+build-win64: prepare-deps-win64
 	[ -d "$(WIN64_BUILD_DIR)" ] || ( mkdir "$(WIN64_BUILD_DIR)" && \
 		meson setup "$(WIN64_BUILD_DIR)" \
 			--cross-file cross_win64.txt \
@@ -94,16 +100,16 @@ dist-win32: build-server build-win32
 	cp app/data/scrcpy-noconsole.vbs "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp app/data/icon.png "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp app/data/open_a_terminal_here.bat "$(DIST)/$(WIN32_TARGET_DIR)"
-	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-2/win32/bin/avutil-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-2/win32/bin/avcodec-60.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-2/win32/bin/avformat-60.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-2/win32/bin/swresample-4.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-2/win32/bin/zlib1.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/platform-tools-33.0.3/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/SDL2-2.26.1/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/libusb-1.0.26/libusb-MinGW-Win32/bin/msys-usb-1.0.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/libusb-1.0.26/MinGW-Win32/msys-usb-1.0.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 
 dist-win64: build-server build-win64
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
@@ -113,16 +119,16 @@ dist-win64: build-server build-win64
 	cp app/data/scrcpy-noconsole.vbs "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp app/data/icon.png "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp app/data/open_a_terminal_here.bat "$(DIST)/$(WIN64_TARGET_DIR)"
-	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-2/win64/bin/avutil-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-2/win64/bin/avcodec-60.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-2/win64/bin/avformat-60.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-2/win64/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-2/win64/bin/zlib1.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/avutil-57.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/avcodec-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/avformat-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/swscale-6.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/platform-tools-33.0.3/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/SDL2-2.26.1/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/libusb-1.0.26/libusb-MinGW-x64/bin/msys-usb-1.0.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/libusb-1.0.26/MinGW-x64/msys-usb-1.0.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 
 zip-win32: dist-win32
 	cd "$(DIST)"; \

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

@@ -1,148 +0,0 @@
-package com.genymobile.scrcpy;
-
-import com.genymobile.scrcpy.wrappers.ServiceManager;
-
-import android.annotation.SuppressLint;
-import android.annotation.TargetApi;
-import android.content.ComponentName;
-import android.content.Intent;
-import android.media.AudioFormat;
-import android.media.AudioRecord;
-import android.media.AudioTimestamp;
-import android.media.MediaCodec;
-import android.media.MediaRecorder;
-import android.os.Build;
-import android.os.SystemClock;
-
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-public final class AudioCapture {
-
-    public static final int SAMPLE_RATE = 48000;
-    public static final int CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_STEREO;
-    public static final int CHANNELS = 2;
-    public static final int FORMAT = AudioFormat.ENCODING_PCM_16BIT;
-    public static final int BYTES_PER_SAMPLE = 2;
-
-    private AudioRecord recorder;
-
-    private final AudioTimestamp timestamp = new AudioTimestamp();
-    private long previousPts = 0;
-    private long nextPts = 0;
-
-    public static int millisToBytes(int millis) {
-        return SAMPLE_RATE * CHANNELS * BYTES_PER_SAMPLE * millis / 1000;
-    }
-
-    private static AudioFormat createAudioFormat() {
-        AudioFormat.Builder builder = new AudioFormat.Builder();
-        builder.setEncoding(FORMAT);
-        builder.setSampleRate(SAMPLE_RATE);
-        builder.setChannelMask(CHANNEL_CONFIG);
-        return builder.build();
-    }
-
-    @TargetApi(Build.VERSION_CODES.M)
-    @SuppressLint({"WrongConstant", "MissingPermission"})
-    private static AudioRecord createAudioRecord() {
-        AudioRecord.Builder builder = new AudioRecord.Builder();
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            // On older APIs, Workarounds.fillAppInfo() must be called beforehand
-            builder.setContext(FakeContext.get());
-        }
-        builder.setAudioSource(MediaRecorder.AudioSource.REMOTE_SUBMIX);
-        builder.setAudioFormat(createAudioFormat());
-        int minBufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_CONFIG, FORMAT);
-        // This buffer size does not impact latency
-        builder.setBufferSizeInBytes(8 * minBufferSize);
-        return builder.build();
-    }
-
-    private static void startWorkaroundAndroid11() {
-        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
-            // Android 11 requires Apps to be at foreground to record audio.
-            // Normally, each App has its own user ID, so Android checks whether the requesting App has the user ID that's at the foreground.
-            // But scrcpy server is NOT an App, it's a Java application started from Android shell, so it has the same user ID (2000) with Android
-            // shell ("com.android.shell").
-            // If there is an Activity from Android shell running at foreground, then the permission system will believe scrcpy is also in the
-            // foreground.
-            if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
-                Intent intent = new Intent(Intent.ACTION_MAIN);
-                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-                intent.addCategory(Intent.CATEGORY_LAUNCHER);
-                intent.setComponent(new ComponentName(FakeContext.PACKAGE_NAME, "com.android.shell.HeapDumpActivity"));
-                ServiceManager.getActivityManager().startActivityAsUserWithFeature(intent);
-                // Wait for activity to start
-                SystemClock.sleep(150);
-            }
-        }
-    }
-
-    private static void stopWorkaroundAndroid11() {
-        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
-            ServiceManager.getActivityManager().forceStopPackage(FakeContext.PACKAGE_NAME);
-        }
-    }
-
-    public void start() throws AudioCaptureForegroundException {
-        startWorkaroundAndroid11();
-        try {
-            recorder = createAudioRecord();
-            recorder.startRecording();
-        } catch (UnsupportedOperationException e) {
-            if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
-                Ln.e("Failed to start audio capture");
-                Ln.e("On Android 11, it is only possible to capture in foreground, make sure that the device is unlocked when starting scrcpy.");
-                throw new AudioCaptureForegroundException();
-            }
-            throw e;
-        } finally {
-            stopWorkaroundAndroid11();
-        }
-    }
-
-    public void stop() {
-        if (recorder != null) {
-            // Will call .stop() if necessary, without throwing an IllegalStateException
-            recorder.release();
-        }
-    }
-
-    @TargetApi(Build.VERSION_CODES.N)
-    public int read(ByteBuffer directBuffer, int size, MediaCodec.BufferInfo outBufferInfo) throws IOException {
-        int r = recorder.read(directBuffer, size);
-        if (r < 0) {
-            return r;
-        }
-
-        long pts;
-
-        int ret = recorder.getTimestamp(timestamp, AudioTimestamp.TIMEBASE_MONOTONIC);
-        if (ret == AudioRecord.SUCCESS) {
-            pts = timestamp.nanoTime / 1000;
-        } else {
-            if (nextPts == 0) {
-                Ln.w("Could not get any audio timestamp");
-            }
-            // compute from previous timestamp and packet size
-            pts = nextPts;
-        }
-
-        long durationUs = r * 1000000 / (CHANNELS * BYTES_PER_SAMPLE * SAMPLE_RATE);
-        nextPts = pts + durationUs;
-
-        if (previousPts != 0 && pts < previousPts) {
-            // Audio PTS may come from two sources:
-            //  - recorder.getTimestamp() if the call works;
-            //  - an estimation from the previous PTS and the packet size as a fallback.
-            //
-            // Therefore, the property that PTS are monotonically increasing is no guaranteed in corner cases, so enforce it.
-            pts = previousPts + 1;
-        }
-        previousPts = pts;
-
-        outBufferInfo.set(0, r, pts, 0);
-        return r;
-    }
-}

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

@@ -1,7 +0,0 @@
-package com.genymobile.scrcpy;
-
-/**
- * Exception thrown if audio capture failed on Android 11 specifically because the running App (shell) was not in foreground.
- */
-public class AudioCaptureForegroundException extends Exception {
-}

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

@@ -4,8 +4,7 @@ import android.media.MediaFormat;
 
 public enum AudioCodec implements Codec {
     OPUS(0x6f_70_75_73, "opus", MediaFormat.MIMETYPE_AUDIO_OPUS),
-    AAC(0x00_61_61_63, "aac", MediaFormat.MIMETYPE_AUDIO_AAC),
-    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

@@ -1,12 +1,22 @@
 package com.genymobile.scrcpy;
 
+import com.genymobile.scrcpy.wrappers.ServiceManager;
+
+import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.media.AudioFormat;
+import android.media.AudioRecord;
+import android.media.AudioTimestamp;
 import android.media.MediaCodec;
 import android.media.MediaFormat;
+import android.media.MediaRecorder;
 import android.os.Build;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
+import android.os.SystemClock;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
@@ -14,7 +24,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 {
 
     private static class InputTask {
         private final int index;
@@ -34,11 +44,14 @@ public final class AudioEncoder implements AsyncProcessor {
         }
     }
 
-    private static final int SAMPLE_RATE = AudioCapture.SAMPLE_RATE;
-    private static final int CHANNELS = AudioCapture.CHANNELS;
+    private static final int SAMPLE_RATE = 48000;
+    private static final int CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_STEREO;
+    private static final int CHANNELS = 2;
+    private static final int FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+    private static final int BYTES_PER_SAMPLE = 2;
 
-    private static final int READ_MS = 5; // milliseconds
-    private static final int READ_SIZE = AudioCapture.millisToBytes(READ_MS);
+    private static final int BUFFER_MS = 5; // milliseconds
+    private static final int BUFFER_SIZE = SAMPLE_RATE * CHANNELS * BYTES_PER_SAMPLE * BUFFER_MS / 1000;
 
     private final Streamer streamer;
     private final int bitRate;
@@ -65,6 +78,29 @@ public final class AudioEncoder implements AsyncProcessor {
         this.encoderName = encoderName;
     }
 
+    private static AudioFormat createAudioFormat() {
+        AudioFormat.Builder builder = new AudioFormat.Builder();
+        builder.setEncoding(FORMAT);
+        builder.setSampleRate(SAMPLE_RATE);
+        builder.setChannelMask(CHANNEL_CONFIG);
+        return builder.build();
+    }
+
+    @TargetApi(Build.VERSION_CODES.M)
+    @SuppressLint({"WrongConstant", "MissingPermission"})
+    private static AudioRecord createAudioRecord() {
+        AudioRecord.Builder builder = new AudioRecord.Builder();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            // On older APIs, Workarounds.fillAppInfo() must be called beforehand
+            builder.setContext(FakeContext.get());
+        }
+        builder.setAudioSource(MediaRecorder.AudioSource.REMOTE_SUBMIX);
+        builder.setAudioFormat(createAudioFormat());
+        int minBufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_CONFIG, FORMAT);
+        builder.setBufferSizeInBytes(minBufferSize);
+        return builder.build();
+    }
+
     private static MediaFormat createFormat(String mimeType, int bitRate, List<CodecOption> codecOptions) {
         MediaFormat format = new MediaFormat();
         format.setString(MediaFormat.KEY_MIME, mimeType);
@@ -85,18 +121,47 @@ public final class AudioEncoder implements AsyncProcessor {
     }
 
     @TargetApi(Build.VERSION_CODES.N)
-    private void inputThread(MediaCodec mediaCodec, AudioCapture capture) throws IOException, InterruptedException {
-        final MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+    private void inputThread(MediaCodec mediaCodec, AudioRecord recorder) throws IOException, InterruptedException {
+        final AudioTimestamp timestamp = new AudioTimestamp();
+        long previousPts = 0;
+        long nextPts = 0;
 
         while (!Thread.currentThread().isInterrupted()) {
             InputTask task = inputTasks.take();
             ByteBuffer buffer = mediaCodec.getInputBuffer(task.index);
-            int r = capture.read(buffer, READ_SIZE, bufferInfo);
+            int r = recorder.read(buffer, BUFFER_SIZE);
             if (r < 0) {
                 throw new IOException("Could not read audio: " + r);
             }
 
-            mediaCodec.queueInputBuffer(task.index, bufferInfo.offset, bufferInfo.size, bufferInfo.presentationTimeUs, bufferInfo.flags);
+            long pts;
+
+            int ret = recorder.getTimestamp(timestamp, AudioTimestamp.TIMEBASE_MONOTONIC);
+            if (ret == AudioRecord.SUCCESS) {
+                pts = timestamp.nanoTime / 1000;
+            } else {
+                if (nextPts == 0) {
+                    Ln.w("Could not get any audio timestamp");
+                }
+                // compute from previous timestamp and packet size
+                pts = nextPts;
+            }
+
+            long durationMs = r * 1000 / CHANNELS / SAMPLE_RATE;
+            nextPts = pts + durationMs;
+
+            if (previousPts != 0 && pts < previousPts) {
+                // Audio PTS may come from two sources:
+                //  - recorder.getTimestamp() if the call works;
+                //  - an estimation from the previous PTS and the packet size as a fallback.
+                //
+                // Therefore, the property that PTS are monotonically increasing is no guaranteed in corner cases, so enforce it.
+                pts = previousPts + 1;
+            }
+
+            mediaCodec.queueInputBuffer(task.index, 0, r, pts, 0);
+
+            previousPts = pts;
         }
     }
 
@@ -118,7 +183,7 @@ public final class AudioEncoder implements AsyncProcessor {
         thread = new Thread(() -> {
             try {
                 encode();
-            } catch (ConfigurationException | AudioCaptureForegroundException e) {
+            } catch (ConfigurationException e) {
                 // Do not print stack trace, a user-friendly error-message has already been logged
             } catch (IOException e) {
                 Ln.e("Audio encoding error", e);
@@ -157,8 +222,34 @@ public final class AudioEncoder implements AsyncProcessor {
         }
     }
 
+    private static void startWorkaroundAndroid11() {
+        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
+            // Android 11 requires Apps to be at foreground to record audio.
+            // Normally, each App has its own user ID, so Android checks whether the requesting App has the user ID that's at the foreground.
+            // But Scrcpy server is NOT an App, it's a Java application started from Android shell, so it has the same user ID (2000) with Android
+            // shell ("com.android.shell").
+            // If there is an Activity from Android shell running at foreground, then the permission system will believe Scrcpy is also in the
+            // foreground.
+            if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
+                Intent intent = new Intent(Intent.ACTION_MAIN);
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                intent.addCategory(Intent.CATEGORY_LAUNCHER);
+                intent.setComponent(new ComponentName(FakeContext.PACKAGE_NAME, "com.android.shell.HeapDumpActivity"));
+                ServiceManager.getActivityManager().startActivityAsUserWithFeature(intent);
+                // Wait for activity to start
+                SystemClock.sleep(150);
+            }
+        }
+    }
+
+    private static void stopWorkaroundAndroid11() {
+        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
+            ServiceManager.getActivityManager().forceStopPackage(FakeContext.PACKAGE_NAME);
+        }
+    }
+
     @TargetApi(Build.VERSION_CODES.M)
-    public void encode() throws IOException, ConfigurationException, AudioCaptureForegroundException {
+    public void encode() throws IOException, ConfigurationException {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
             Ln.w("Audio disabled: it is not supported before Android 11");
             streamer.writeDisableStream(false);
@@ -166,9 +257,10 @@ public final class AudioEncoder implements AsyncProcessor {
         }
 
         MediaCodec mediaCodec = null;
-        AudioCapture capture = new AudioCapture();
+        AudioRecord recorder = null;
 
         boolean mediaCodecStarted = false;
+        boolean recorderStarted = false;
         try {
             Codec codec = streamer.getCodec();
             mediaCodec = createMediaCodec(codec, encoderName);
@@ -180,13 +272,28 @@ public final class AudioEncoder implements AsyncProcessor {
             mediaCodec.setCallback(new EncoderCallback(), new Handler(mediaCodecThread.getLooper()));
             mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
 
-            capture.start();
+            startWorkaroundAndroid11();
+            try {
+                recorder = createAudioRecord();
+                recorder.startRecording();
+            } catch (UnsupportedOperationException e) {
+                if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
+                    Ln.e("Failed to start audio capture");
+                    Ln.e("On Android 11, it is only possible to capture in foreground, make sure that the device is unlocked when starting scrcpy.");
+                    // Continue to mirror without audio (configurationError is left to false)
+                    streamer.writeDisableStream(false);
+                    return;
+                }
+            } finally {
+                stopWorkaroundAndroid11();
+            }
+            recorderStarted = true;
 
             final MediaCodec mediaCodecRef = mediaCodec;
-            final AudioCapture captureRef = capture;
+            final AudioRecord recorderRef = recorder;
             inputThread = new Thread(() -> {
                 try {
-                    inputThread(mediaCodecRef, captureRef);
+                    inputThread(mediaCodecRef, recorderRef);
                 } catch (IOException | InterruptedException e) {
                     Ln.e("Audio capture error", e);
                 } finally {
@@ -259,8 +366,11 @@ public final class AudioEncoder implements AsyncProcessor {
                 }
                 mediaCodec.release();
             }
-            if (capture != null) {
-                capture.stop();
+            if (recorder != null) {
+                if (recorderStarted) {
+                    recorder.stop();
+                }
+                recorder.release();
             }
         }
     }

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

@@ -1,75 +0,0 @@
-package com.genymobile.scrcpy;
-
-import android.media.MediaCodec;
-
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-public final class AudioRawRecorder implements AsyncProcessor {
-
-    private final Streamer streamer;
-
-    private Thread thread;
-
-    private static final int READ_MS = 5; // milliseconds
-    private static final int READ_SIZE = AudioCapture.millisToBytes(READ_MS);
-
-    public AudioRawRecorder(Streamer streamer) {
-        this.streamer = streamer;
-    }
-
-    private void record() throws IOException, AudioCaptureForegroundException {
-        final ByteBuffer buffer = ByteBuffer.allocateDirect(READ_SIZE);
-        final MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
-
-        AudioCapture capture = new AudioCapture();
-        try {
-            capture.start();
-
-            streamer.writeHeader();
-            while (!Thread.currentThread().isInterrupted()) {
-                buffer.position(0);
-                int r = capture.read(buffer, READ_SIZE, bufferInfo);
-                if (r < 0) {
-                    throw new IOException("Could not read audio: " + r);
-                }
-                buffer.limit(r);
-
-                streamer.writePacket(buffer, bufferInfo);
-            }
-        } catch (Throwable e) {
-            // Notify the client that the audio could not be captured
-            streamer.writeDisableStream(false);
-            throw e;
-        } finally {
-            capture.stop();
-        }
-    }
-
-    public void start() {
-        thread = new Thread(() -> {
-            try {
-                record();
-            } catch (AudioCaptureForegroundException e) {
-                // Do not print stack trace, a user-friendly error-message has already been logged
-            } catch (IOException e) {
-                Ln.e("Audio recording error", e);
-            } finally {
-                Ln.d("Audio recorder stopped");
-            }
-        });
-        thread.start();
-    }
-
-    public void stop() {
-        if (thread != null) {
-            thread.interrupt();
-        }
-    }
-
-    public void join() throws InterruptedException {
-        if (thread != null) {
-            thread.join();
-        }
-    }
-}

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/DesktopConnection.java

@@ -110,11 +110,6 @@ public final class DesktopConnection implements Closeable {
         videoSocket.shutdownInput();
         videoSocket.shutdownOutput();
         videoSocket.close();
-        if (audioSocket != null) {
-            audioSocket.shutdownInput();
-            audioSocket.shutdownOutput();
-            audioSocket.close();
-        }
         if (controlSocket != null) {
             controlSocket.shutdownInput();
             controlSocket.shutdownOutput();

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;
+        AudioEncoder audioEncoder = null;
 
         try (DesktopConnection connection = DesktopConnection.open(scid, tunnelForward, audio, control, sendDummyByte)) {
             if (options.getSendDeviceMeta()) {
@@ -101,34 +101,24 @@ 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(),
+                Streamer audioStreamer = new Streamer(connection.getAudioFd(), options.getAudioCodec(), options.getSendCodecId(),
                         options.getSendFrameMeta());
-                AsyncProcessor audioRecorder;
-                if (audioCodec == AudioCodec.RAW) {
-                    audioRecorder = new AudioRawRecorder(audioStreamer);
-                } else {
-                    audioRecorder = new AudioEncoder(audioStreamer, options.getAudioBitRate(), options.getAudioCodecOptions(),
-                            options.getAudioEncoder());
-                }
-                asyncProcessors.add(audioRecorder);
+                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.getVideoBitRate(), options.getMaxFps(),
                     options.getVideoCodecOptions(), options.getVideoEncoder(), options.getDownsizeOnError());
-
-            for (AsyncProcessor asyncProcessor : asyncProcessors) {
-                asyncProcessor.start();
-            }
-
             try {
                 // synchronous
                 screenEncoder.streamScreen();
@@ -141,14 +131,20 @@ public final class Server {
         } finally {
             Ln.d("Screen streaming stopped");
             initThread.interrupt();
-            for (AsyncProcessor asyncProcessor : asyncProcessors) {
-                asyncProcessor.stop();
+            if (audioEncoder != null) {
+                audioEncoder.stop();
+            }
+            if (controller != null) {
+                controller.stop();
             }
 
             try {
                 initThread.join();
-                for (AsyncProcessor asyncProcessor : asyncProcessors) {
-                    asyncProcessor.join();
+                if (audioEncoder != null) {
+                    audioEncoder.join();
+                }
+                if (controller != null) {
+                    controller.join();
                 }
             } catch (InterruptedException e) {
                 // ignore

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

@@ -51,34 +51,27 @@ public final class Streamer {
         IO.writeFully(fd, code, 0, code.length);
     }
 
-    public void writePacket(ByteBuffer buffer, long pts, boolean config, boolean keyFrame) throws IOException {
-        if (config && codec == AudioCodec.OPUS) {
-            fixOpusConfigPacket(buffer);
+    public void writePacket(ByteBuffer codecBuffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
+        if (codec == AudioCodec.OPUS) {
+            fixOpusConfigPacket(codecBuffer, bufferInfo);
         }
 
         if (sendFrameMeta) {
-            writeFrameMeta(fd, buffer.remaining(), pts, config, keyFrame);
+            writeFrameMeta(fd, bufferInfo, codecBuffer.remaining());
         }
 
-        IO.writeFully(fd, buffer);
+        IO.writeFully(fd, codecBuffer);
     }
 
-    public void writePacket(ByteBuffer codecBuffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
-        long pts = bufferInfo.presentationTimeUs;
-        boolean config = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0;
-        boolean keyFrame = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) != 0;
-        writePacket(codecBuffer, pts, config, keyFrame);
-    }
-
-    private void writeFrameMeta(FileDescriptor fd, int packetSize, long pts, boolean config, boolean keyFrame) throws IOException {
+    private void writeFrameMeta(FileDescriptor fd, MediaCodec.BufferInfo bufferInfo, int packetSize) throws IOException {
         headerBuffer.clear();
 
         long ptsAndFlags;
-        if (config) {
+        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
             ptsAndFlags = PACKET_FLAG_CONFIG; // non-media data packet
         } else {
-            ptsAndFlags = pts;
-            if (keyFrame) {
+            ptsAndFlags = bufferInfo.presentationTimeUs;
+            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) != 0) {
                 ptsAndFlags |= PACKET_FLAG_KEY_FRAME;
             }
         }
@@ -89,7 +82,7 @@ public final class Streamer {
         IO.writeFully(fd, headerBuffer);
     }
 
-    private static void fixOpusConfigPacket(ByteBuffer buffer) throws IOException {
+    private static void fixOpusConfigPacket(ByteBuffer buffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
         // Here is an example of the config packet received for an OPUS stream:
         //
         // 00000000  41 4f 50 55 53 48 44 52  13 00 00 00 00 00 00 00  |AOPUSHDR........|
@@ -106,6 +99,11 @@ public final class Streamer {
         //
         // <https://developer.android.com/reference/android/media/MediaCodec#CSD>
 
+        boolean isConfig = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0;
+        if (!isConfig) {
+            return;
+        }
+
         if (buffer.remaining() < 16) {
             throw new IOException("Not enough data in OPUS config packet");
         }