Detect codec/encoder mismatch

Fail with an explicit error when the requested encoder does not match
the requested codec.

Refs #5066 <https://github.com/Genymobile/scrcpy/issues/5066>

.github/workflows/release.yml

@@ -1,147 +0,0 @@
-name: Build
-
-on:
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'Version name (default is ref name)'
-
-jobs:
-  build-scrcpy-server:
-    runs-on: ubuntu-latest
-    env:
-      GRADLE: gradle  # use native gradle instead of ./gradlew in release.mk
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup JDK
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'zulu'
-          java-version: '17'
-
-      - name: Test scrcpy-server
-        run: make -f release.mk test-server
-
-      - name: Build scrcpy-server
-        run: make -f release.mk build-server
-
-      - name: Upload scrcpy-server artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: scrcpy-server
-          path: build-server/server/scrcpy-server
-
-  test-client:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y meson ninja-build nasm ffmpeg libsdl2-2.0-0 \
-             libsdl2-dev libavcodec-dev libavdevice-dev libavformat-dev \
-             libavutil-dev libswresample-dev libusb-1.0-0 libusb-1.0-0-dev
-
-      - name: Build
-        run: |
-          meson setup d -Db_sanitize=address,undefined
-
-      - name: Test
-        run: |
-          meson test -Cd
-
-  build-win32:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y meson ninja-build nasm ffmpeg libsdl2-2.0-0 \
-             libsdl2-dev libavcodec-dev libavdevice-dev libavformat-dev \
-             libavutil-dev libswresample-dev libusb-1.0-0 libusb-1.0-0-dev \
-             mingw-w64 mingw-w64-tools libz-mingw-w64-dev
-
-      - name: Workaround for old meson version run by Github Actions
-        run: sed -i 's/^pkg-config/pkgconfig/' cross_win32.txt
-
-      - name: Build scrcpy win32
-        run: make -f release.mk build-win32
-
-      - name: Upload build-win32 artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: build-win32-intermediate
-          path: build-win32/dist/
-
-  build-win64:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y meson ninja-build nasm ffmpeg libsdl2-2.0-0 \
-             libsdl2-dev libavcodec-dev libavdevice-dev libavformat-dev \
-             libavutil-dev libswresample-dev libusb-1.0-0 libusb-1.0-0-dev \
-             mingw-w64 mingw-w64-tools libz-mingw-w64-dev
-
-      - name: Workaround for old meson version run by Github Actions
-        run: sed -i 's/^pkg-config/pkgconfig/' cross_win64.txt
-
-      - name: Build scrcpy win64
-        run: make -f release.mk build-win64
-
-      - name: Upload build-win64 artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: build-win64-intermediate
-          path: build-win64/dist/
-
-  package:
-    needs:
-      - build-scrcpy-server
-      - build-win32
-      - build-win64
-    runs-on: ubuntu-latest
-    env:
-      # $VERSION is used by release.mk
-      VERSION: ${{ github.event.inputs.name || github.ref_name }}
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Download scrcpy-server
-        uses: actions/download-artifact@v4
-        with:
-          name: scrcpy-server
-          path: build-server/server/
-
-      - name: Download build-win32
-        uses: actions/download-artifact@v4
-        with:
-          name: build-win32-intermediate
-          path: build-win32/dist/
-
-      - name: Download build-win64
-        uses: actions/download-artifact@v4
-        with:
-          name: build-win64-intermediate
-          path: build-win64/dist/
-
-      - name: Package
-        run: make -f release.mk package
-
-      - name: Upload release artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: scrcpy-release-${{ env.VERSION }}
-          path: release-${{ env.VERSION }}

app/meson.build

@@ -5,7 +5,6 @@ src = [
     'src/adb/adb_parser.c',
     'src/adb/adb_tunnel.c',
     'src/audio_player.c',
-    'src/audio_regulator.c',
     'src/cli.c',
     'src/clock.c',
     'src/compat.c',
@@ -23,7 +22,6 @@ src = [
     'src/frame_buffer.c',
     'src/input_manager.c',
     'src/keyboard_sdk.c',
-    'src/mouse_capture.c',
     'src/mouse_sdk.c',
     'src/opengl.c',
     'src/options.c',

app/scrcpy.1

@@ -727,11 +727,7 @@ Pinch-to-zoom and rotate from the center of the screen
 
 .TP
 .B Shift+click-and-move
-Tilt vertically (slide with 2 fingers)
-
-.TP
-.B Ctrl+Shift+click-and-move
-Tilt horizontally (slide with 2 fingers)
+Tilt (slide vertically with two fingers)
 
 .TP
 .B Drag & drop APK file

app/src/audio_player.c

@@ -1,23 +1,138 @@
 #include "audio_player.h"
 
+#include <libavcodec/avcodec.h>
+#include <libavutil/opt.h>
+
 #include "util/log.h"
 
+//#define SC_AUDIO_PLAYER_DEBUG // uncomment to debug
+
+/**
+ * Real-time audio player with configurable latency
+ *
+ * As input, the player regularly receives AVFrames of decoded audio samples.
+ * As output, an SDL callback regularly requests audio samples to be played.
+ * In the middle, an audio buffer stores the samples produced but not consumed
+ * yet.
+ *
+ * The goal of the player is to feed the audio output with a latency as low as
+ * possible while avoiding buffer underrun (i.e. not being able to provide
+ * samples when requested).
+ *
+ * The player aims to feed the audio output with as little latency as possible
+ * while avoiding buffer underrun. To achieve this, it attempts to maintain the
+ * average buffering (the number of samples present in the buffer) around a
+ * target value. If this target buffering is too low, then buffer underrun will
+ * occur frequently. If it is too high, then latency will become unacceptable.
+ * This target value is configured using the scrcpy option --audio-buffer.
+ *
+ * The player cannot adjust the sample input rate (it receives samples produced
+ * in real-time) or the sample output rate (it must provide samples as
+ * requested by the audio output callback). Therefore, it may only apply
+ * compensation by resampling (converting _m_ input samples to _n_ output
+ * samples).
+ *
+ * The compensation itself is applied by libswresample (FFmpeg). It is
+ * configured using swr_set_compensation(). An important work for the player
+ * is to estimate the compensation value regularly and apply it.
+ *
+ * The estimated buffering level is the result of averaging the "natural"
+ * buffering (samples are produced and consumed by blocks, so it must be
+ * smoothed), and making instant adjustments resulting of its own actions
+ * (explicit compensation and silence insertion on underflow), which are not
+ * smoothed.
+ *
+ * Buffer underflow events can occur when packets arrive too late. In that case,
+ * the player inserts silence. Once the packets finally arrive (late), one
+ * strategy could be to drop the samples that were replaced by silence, in
+ * order to keep a minimal latency. However, dropping samples in case of buffer
+ * underflow is inadvisable, as it would temporarily increase the underflow
+ * even more and cause very noticeable audio glitches.
+ *
+ * Therefore, the player doesn't drop any sample on underflow. The compensation
+ * mechanism will absorb the delay introduced by the inserted silence.
+ */
+
 /** Downcast frame_sink to sc_audio_player */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_audio_player, frame_sink)
 
+#define SC_AV_SAMPLE_FMT AV_SAMPLE_FMT_FLT
 #define SC_SDL_SAMPLE_FMT AUDIO_F32
 
+#define TO_BYTES(SAMPLES) sc_audiobuf_to_bytes(&ap->buf, (SAMPLES))
+#define TO_SAMPLES(BYTES) sc_audiobuf_to_samples(&ap->buf, (BYTES))
+
 static void SDLCALL
 sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
     struct sc_audio_player *ap = userdata;
 
+    // This callback is called with the lock used by SDL_LockAudioDevice()
+
     assert(len_int > 0);
     size_t len = len_int;
+    uint32_t count = TO_SAMPLES(len);
 
-    assert(len % ap->audioreg.sample_size == 0);
-    uint32_t out_samples = len / ap->audioreg.sample_size;
+#ifdef SC_AUDIO_PLAYER_DEBUG
+    LOGD("[Audio] SDL callback requests %" PRIu32 " samples", count);
+#endif
 
-    sc_audio_regulator_pull(&ap->audioreg, stream, out_samples);
+    bool played = atomic_load_explicit(&ap->played, memory_order_relaxed);
+    if (!played) {
+        uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
+        // Wait until the buffer is filled up to at least target_buffering
+        // before playing
+        if (buffered_samples < ap->target_buffering) {
+            LOGV("[Audio] Inserting initial buffering silence: %" PRIu32
+                 " samples", count);
+            // 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;
+        }
+    }
+
+    uint32_t read = sc_audiobuf_read(&ap->buf, stream, count);
+
+    if (read < count) {
+        uint32_t silence = count - read;
+        // 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);
+        memset(stream + TO_BYTES(read), 0, TO_BYTES(silence));
+
+        bool received = atomic_load_explicit(&ap->received,
+                                             memory_order_relaxed);
+        if (received) {
+            // Inserting additional samples immediately increases buffering
+            atomic_fetch_add_explicit(&ap->underflow, silence,
+                                      memory_order_relaxed);
+        }
+    }
+
+    atomic_store_explicit(&ap->played, true, memory_order_relaxed);
+}
+
+static uint8_t *
+sc_audio_player_get_swr_buf(struct sc_audio_player *ap, uint32_t min_samples) {
+    size_t min_buf_size = TO_BYTES(min_samples);
+    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) {
+            LOG_OOM();
+            // Could not realloc to the requested size
+            return NULL;
+        }
+        ap->swr_buf = buf;
+        ap->swr_buf_alloc_size = new_size;
+    }
+
+    return ap->swr_buf;
 }
 
 static bool
@@ -25,21 +140,209 @@ sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
                                 const AVFrame *frame) {
     struct sc_audio_player *ap = DOWNCAST(sink);
 
-    return sc_audio_regulator_push(&ap->audioreg, frame);
+    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 = MIN(ret, dst_nb_samples);
+#ifdef SC_AUDIO_PLAYER_DEBUG
+    LOGD("[Audio] %" PRIu32 " samples written to buffer", samples);
+#endif
+
+    uint32_t cap = sc_audiobuf_capacity(&ap->buf);
+    if (samples > cap) {
+        // Very very unlikely: a single resampled frame should never
+        // exceed the audio buffer size (or something is very wrong).
+        // Ignore the first bytes in swr_buf to avoid memory corruption anyway.
+        swr_buf += TO_BYTES(samples - cap);
+        samples = cap;
+    }
+
+    uint32_t skipped_samples = 0;
+
+    uint32_t written = sc_audiobuf_write(&ap->buf, swr_buf, samples);
+    if (written < samples) {
+        uint32_t remaining = samples - written;
+
+        // All samples that could be written without locking have been written,
+        // now we need to lock to drop/consume old samples
+        SDL_LockAudioDevice(ap->device);
+
+        // Retry with the lock
+        written += sc_audiobuf_write(&ap->buf,
+                                     swr_buf + TO_BYTES(written),
+                                     remaining);
+        if (written < samples) {
+            remaining = samples - written;
+            // Still insufficient, drop old samples to make space
+            skipped_samples = sc_audiobuf_read(&ap->buf, NULL, remaining);
+            assert(skipped_samples == remaining);
+        }
+
+        SDL_UnlockAudioDevice(ap->device);
+
+        if (written < samples) {
+            // Now there is enough space
+            uint32_t w = sc_audiobuf_write(&ap->buf,
+                                           swr_buf + TO_BYTES(written),
+                                           remaining);
+            assert(w == remaining);
+            (void) w;
+        }
+    }
+
+    uint32_t underflow = 0;
+    uint32_t max_buffered_samples;
+    bool played = atomic_load_explicit(&ap->played, memory_order_relaxed);
+    if (played) {
+        underflow = atomic_exchange_explicit(&ap->underflow, 0,
+                                             memory_order_relaxed);
+
+        max_buffered_samples = ap->target_buffering
+                               + 12 * ap->output_buffer
+                               + ap->target_buffering / 10;
+    } 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.
+        max_buffered_samples = ap->target_buffering + 2 * ap->output_buffer;
+    }
+
+    uint32_t can_read = sc_audiobuf_can_read(&ap->buf);
+    if (can_read > max_buffered_samples) {
+        uint32_t skip_samples = 0;
+
+        SDL_LockAudioDevice(ap->device);
+        can_read = sc_audiobuf_can_read(&ap->buf);
+        if (can_read > max_buffered_samples) {
+            skip_samples = can_read - max_buffered_samples;
+            uint32_t r = sc_audiobuf_read(&ap->buf, NULL, skip_samples);
+            assert(r == skip_samples);
+            (void) r;
+            skipped_samples += skip_samples;
+        }
+        SDL_UnlockAudioDevice(ap->device);
+
+        if (skip_samples) {
+            if (played) {
+                LOGD("[Audio] Buffering threshold exceeded, skipping %" PRIu32
+                     " samples", skip_samples);
+#ifdef SC_AUDIO_PLAYER_DEBUG
+            } else {
+                LOGD("[Audio] Playback not started, skipping %" PRIu32
+                     " samples", skip_samples);
+#endif
+            }
+        }
+    }
+
+    atomic_store_explicit(&ap->received, true, memory_order_relaxed);
+    if (!played) {
+        // Nothing more to do
+        return true;
+    }
+
+    // Number of samples added (or removed, if negative) for compensation
+    int32_t instant_compensation = (int32_t) written - frame->nb_samples;
+    // Inserting silence instantly increases buffering
+    int32_t inserted_silence = (int32_t) underflow;
+    // Dropping input samples instantly decreases buffering
+    int32_t dropped = (int32_t) skipped_samples;
+
+    // The compensation must apply instantly, it must not be smoothed
+    ap->avg_buffering.avg += instant_compensation + inserted_silence - dropped;
+    if (ap->avg_buffering.avg < 0) {
+        // Since dropping samples instantly reduces buffering, the difference
+        // is applied immediately to the average value, assuming that the delay
+        // between the producer and the consumer will be caught up.
+        //
+        // However, when this assumption is not valid, the average buffering
+        // may decrease indefinitely. Prevent it to become negative to limit
+        // the consequences.
+        ap->avg_buffering.avg = 0;
+    }
+
+    // However, the buffering level must be smoothed
+    sc_average_push(&ap->avg_buffering, can_read);
+
+#ifdef SC_AUDIO_PLAYER_DEBUG
+    LOGD("[Audio] can_read=%" PRIu32 " avg_buffering=%f",
+         can_read, sc_average_get(&ap->avg_buffering));
+#endif
+
+    ap->samples_since_resync += 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;
+
+        // Enable compensation when the difference exceeds +/- 4ms.
+        // Disable compensation when the difference is lower than +/- 1ms.
+        int threshold = ap->compensation != 0
+                      ? ap->sample_rate     / 1000  /* 1ms */
+                      : ap->sample_rate * 4 / 1000; /* 4ms */
+
+        if (abs(diff) < threshold) {
+            // Do not compensate for small values, the error is just noise
+            diff = 0;
+        } else if (diff < 0 && can_read < ap->target_buffering) {
+            // Do not accelerate if the instant buffering level is below the
+            // target, 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, can_read, diff);
+
+        if (diff != ap->compensation) {
+            int ret = swr_set_compensation(swr_ctx, diff, distance);
+            if (ret < 0) {
+                LOGW("Resampling compensation failed: %d", ret);
+                // not fatal
+            } else {
+                ap->compensation = diff;
+            }
+        }
+    }
+
+    return true;
 }
 
 static bool
 sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
                                 const AVCodecContext *ctx) {
     struct sc_audio_player *ap = DOWNCAST(sink);
-
 #ifdef SCRCPY_LAVU_HAS_CHLAYOUT
-    assert(ctx->ch_layout.nb_channels > 0 && ctx->ch_layout.nb_channels < 256);
-    uint8_t nb_channels = ctx->ch_layout.nb_channels;
+    assert(ctx->ch_layout.nb_channels > 0);
+    unsigned nb_channels = ctx->ch_layout.nb_channels;
 #else
     int tmp = av_get_channel_layout_nb_channels(ctx->channel_layout);
-    assert(tmp > 0 && tmp < 256);
-    uint8_t nb_channels = tmp;
+    assert(tmp > 0);
+    unsigned nb_channels = tmp;
 #endif
 
     assert(ctx->sample_rate > 0);
@@ -47,19 +350,17 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
     int out_bytes_per_sample = av_get_bytes_per_sample(SC_AV_SAMPLE_FMT);
     assert(out_bytes_per_sample > 0);
 
-    uint32_t target_buffering_samples =
-        ap->target_buffering_delay * ctx->sample_rate / SC_TICK_FREQ;
+    ap->sample_rate = ctx->sample_rate;
+    ap->nb_channels = nb_channels;
+    ap->out_bytes_per_sample = out_bytes_per_sample;
 
-    size_t sample_size = nb_channels * out_bytes_per_sample;
-    bool ok = sc_audio_regulator_init(&ap->audioreg, sample_size, ctx,
-                                      target_buffering_samples);
-    if (!ok) {
-        return false;
-    }
+    ap->target_buffering = ap->target_buffering_delay * ap->sample_rate
+                                                      / SC_TICK_FREQ;
 
-    uint64_t aout_samples = ap->output_buffer_duration * ctx->sample_rate
+    uint64_t aout_samples = ap->output_buffer_duration * ap->sample_rate
                                                        / SC_TICK_FREQ;
     assert(aout_samples <= 0xFFFF);
+    ap->output_buffer = (uint16_t) aout_samples;
 
     SDL_AudioSpec desired = {
         .freq = ctx->sample_rate,
@@ -74,10 +375,69 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
     ap->device = SDL_OpenAudioDevice(NULL, 0, &desired, &obtained, 0);
     if (!ap->device) {
         LOGE("Could not open audio device: %s", SDL_GetError());
-        sc_audio_regulator_destroy(&ap->audioreg);
         return false;
     }
 
+    SwrContext *swr_ctx = swr_alloc();
+    if (!swr_ctx) {
+        LOG_OOM();
+        goto error_close_audio_device;
+    }
+    ap->swr_ctx = swr_ctx;
+
+#ifdef SCRCPY_LAVU_HAS_CHLAYOUT
+    av_opt_set_chlayout(swr_ctx, "in_chlayout", &ctx->ch_layout, 0);
+    av_opt_set_chlayout(swr_ctx, "out_chlayout", &ctx->ch_layout, 0);
+#else
+    av_opt_set_channel_layout(swr_ctx, "in_channel_layout",
+                              ctx->channel_layout, 0);
+    av_opt_set_channel_layout(swr_ctx, "out_channel_layout",
+                              ctx->channel_layout, 0);
+#endif
+
+    av_opt_set_int(swr_ctx, "in_sample_rate", ctx->sample_rate, 0);
+    av_opt_set_int(swr_ctx, "out_sample_rate", ctx->sample_rate, 0);
+
+    av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", ctx->sample_fmt, 0);
+    av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", SC_AV_SAMPLE_FMT, 0);
+
+    int ret = swr_init(swr_ctx);
+    if (ret) {
+        LOGE("Failed to initialize the resampling context");
+        goto error_free_swr_ctx;
+    }
+
+    // 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.
+    uint32_t audiobuf_samples = ap->target_buffering + ap->sample_rate;
+
+    size_t sample_size = ap->nb_channels * ap->out_bytes_per_sample;
+    bool ok = sc_audiobuf_init(&ap->buf, sample_size, audiobuf_samples);
+    if (!ok) {
+        goto error_free_swr_ctx;
+    }
+
+    size_t initial_swr_buf_size = TO_BYTES(4096);
+    ap->swr_buf = malloc(initial_swr_buf_size);
+    if (!ap->swr_buf) {
+        LOG_OOM();
+        goto error_destroy_audiobuf;
+    }
+    ap->swr_buf_alloc_size = initial_swr_buf_size;
+
+    // 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, 128);
+    ap->samples_since_resync = 0;
+
+    ap->received = false;
+    atomic_init(&ap->played, false);
+    atomic_init(&ap->received, false);
+    atomic_init(&ap->underflow, 0);
+    ap->compensation = 0;
+
     // 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);
@@ -89,6 +449,15 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
     SDL_PauseAudioDevice(ap->device, 0);
 
     return true;
+
+error_destroy_audiobuf:
+    sc_audiobuf_destroy(&ap->buf);
+error_free_swr_ctx:
+    swr_free(&ap->swr_ctx);
+error_close_audio_device:
+    SDL_CloseAudioDevice(ap->device);
+
+    return false;
 }
 
 static void
@@ -99,7 +468,9 @@ sc_audio_player_frame_sink_close(struct sc_frame_sink *sink) {
     SDL_PauseAudioDevice(ap->device, 1);
     SDL_CloseAudioDevice(ap->device);
 
-    sc_audio_regulator_destroy(&ap->audioreg);
+    free(ap->swr_buf);
+    sc_audiobuf_destroy(&ap->buf);
+    swr_free(&ap->swr_ctx);
 }
 
 void

app/src/audio_player.h

@@ -5,27 +5,76 @@
 
 #include <stdatomic.h>
 #include <stdbool.h>
+#include <libavformat/avformat.h>
+#include <libswresample/swresample.h>
 #include <SDL2/SDL.h>
 
-#include "audio_regulator.h"
 #include "trait/frame_sink.h"
+#include "util/audiobuf.h"
+#include "util/average.h"
+#include "util/thread.h"
 #include "util/tick.h"
 
 struct sc_audio_player {
     struct sc_frame_sink frame_sink;
 
+    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
 
-    // SDL audio output buffer size
+    // SDL audio output buffer size.
     sc_tick output_buffer_duration;
+    uint16_t output_buffer;
 
-    SDL_AudioDeviceID device;
-    struct sc_audio_regulator audioreg;
+    // Audio buffer to communicate between the receiver and the SDL audio
+    // callback
+    struct sc_audiobuf buf;
+
+    // Resampler (only used from the receiver thread)
+    struct SwrContext *swr_ctx;
+
+    // The sample rate is the same for input and output
+    unsigned sample_rate;
+    // The number of channels is the same for input and output
+    unsigned nb_channels;
+    // The number of bytes per sample for a single channel
+    size_t out_bytes_per_sample;
+
+    // Target buffer for resampling (only used by the receiver thread)
+    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)
+    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;
+
+    // Number of silence samples inserted since the last received packet
+    atomic_uint_least32_t underflow;
+
+    // Current applied compensation value (only used by the receiver thread)
+    int compensation;
+
+    // Set to true the first time a sample is received
+    atomic_bool received;
+
+    // Set to true the first time the SDL callback is called
+    atomic_bool played;
+
+    const struct sc_audio_player_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+struct sc_audio_player_callbacks {
+    void (*on_ended)(struct sc_audio_player *ap, bool success, void *userdata);
 };
 
 void

app/src/audio_regulator.c

@@ -1,415 +0,0 @@
-#include "audio_regulator.h"
-
-#include <libavcodec/avcodec.h>
-#include <libavutil/opt.h>
-
-#include "util/log.h"
-
-//#define SC_AUDIO_REGULATOR_DEBUG // uncomment to debug
-
-/**
- * Real-time audio regulator with configurable latency
- *
- * As input, the regulator regularly receives AVFrames of decoded audio samples.
- * As output, the audio player regularly requests audio samples to be played.
- * In the middle, an audio buffer stores the samples produced but not consumed
- * yet.
- *
- * The goal of the regulator is to feed the audio player with a latency as low
- * as possible while avoiding buffer underrun (i.e. not being able to provide
- * samples when requested).
- *
- * To achieve this, it attempts to maintain the average buffering (the number
- * of samples present in the buffer) around a target value. If this target
- * buffering is too low, then buffer underrun will occur frequently. If it is
- * too high, then latency will become unacceptable. This target value is
- * configured using the scrcpy option --audio-buffer.
- *
- * The regulator cannot adjust the sample input rate (it receives samples
- * produced in real-time) or the sample output rate (it must provide samples as
- * requested by the audio player). Therefore, it may only apply compensation by
- * resampling (converting _m_ input samples to _n_ output samples).
- *
- * The compensation itself is applied by libswresample (FFmpeg). It is
- * configured using swr_set_compensation(). An important work for the regulator
- * is to estimate the compensation value regularly and apply it.
- *
- * The estimated buffering level is the result of averaging the "natural"
- * buffering (samples are produced and consumed by blocks, so it must be
- * smoothed), and making instant adjustments resulting of its own actions
- * (explicit compensation and silence insertion on underflow), which are not
- * smoothed.
- *
- * Buffer underflow events can occur when packets arrive too late. In that case,
- * the regulator inserts silence. Once the packets finally arrive (late), one
- * strategy could be to drop the samples that were replaced by silence, in
- * order to keep a minimal latency. However, dropping samples in case of buffer
- * underflow is inadvisable, as it would temporarily increase the underflow
- * even more and cause very noticeable audio glitches.
- *
- * Therefore, the regulator doesn't drop any sample on underflow. The
- * compensation mechanism will absorb the delay introduced by the inserted
- * silence.
- */
-
-#define TO_BYTES(SAMPLES) sc_audiobuf_to_bytes(&ar->buf, (SAMPLES))
-#define TO_SAMPLES(BYTES) sc_audiobuf_to_samples(&ar->buf, (BYTES))
-
-void
-sc_audio_regulator_pull(struct sc_audio_regulator *ar, uint8_t *out,
-                        uint32_t out_samples) {
-#ifdef SC_AUDIO_REGULATOR_DEBUG
-    LOGD("[Audio] Audio regulator pulls %" PRIu32 " samples", out_samples);
-#endif
-
-    // A lock is necessary in the rare case where the producer needs to drop
-    // samples already pushed (when the buffer is full)
-    sc_mutex_lock(&ar->mutex);
-
-    bool played = atomic_load_explicit(&ar->played, memory_order_relaxed);
-    if (!played) {
-        uint32_t buffered_samples = sc_audiobuf_can_read(&ar->buf);
-        // Wait until the buffer is filled up to at least target_buffering
-        // before playing
-        if (buffered_samples < ar->target_buffering) {
-            LOGV("[Audio] Inserting initial buffering silence: %" PRIu32
-                 " samples", out_samples);
-            // Delay playback starting to reach the target buffering. Fill the
-            // whole buffer with silence (len is small compared to the
-            // arbitrary margin value).
-            memset(out, 0, out_samples * ar->sample_size);
-            sc_mutex_unlock(&ar->mutex);
-            return;
-        }
-    }
-
-    uint32_t read = sc_audiobuf_read(&ar->buf, out, out_samples);
-
-    sc_mutex_unlock(&ar->mutex);
-
-    if (read < out_samples) {
-        uint32_t silence = out_samples - read;
-        // 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);
-        memset(out + TO_BYTES(read), 0, TO_BYTES(silence));
-
-        bool received = atomic_load_explicit(&ar->received,
-                                             memory_order_relaxed);
-        if (received) {
-            // Inserting additional samples immediately increases buffering
-            atomic_fetch_add_explicit(&ar->underflow, silence,
-                                      memory_order_relaxed);
-        }
-    }
-
-    atomic_store_explicit(&ar->played, true, memory_order_relaxed);
-}
-
-static uint8_t *
-sc_audio_regulator_get_swr_buf(struct sc_audio_regulator *ar,
-                               uint32_t min_samples) {
-    size_t min_buf_size = TO_BYTES(min_samples);
-    if (min_buf_size > ar->swr_buf_alloc_size) {
-        size_t new_size = min_buf_size + 4096;
-        uint8_t *buf = realloc(ar->swr_buf, new_size);
-        if (!buf) {
-            LOG_OOM();
-            // Could not realloc to the requested size
-            return NULL;
-        }
-        ar->swr_buf = buf;
-        ar->swr_buf_alloc_size = new_size;
-    }
-
-    return ar->swr_buf;
-}
-
-bool
-sc_audio_regulator_push(struct sc_audio_regulator *ar, const AVFrame *frame) {
-    SwrContext *swr_ctx = ar->swr_ctx;
-
-    int64_t swr_delay = swr_get_delay(swr_ctx, ar->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_regulator_get_swr_buf(ar, 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 = MIN(ret, dst_nb_samples);
-#ifdef SC_AUDIO_REGULATOR_DEBUG
-    LOGD("[Audio] %" PRIu32 " samples written to buffer", samples);
-#endif
-
-    uint32_t cap = sc_audiobuf_capacity(&ar->buf);
-    if (samples > cap) {
-        // Very very unlikely: a single resampled frame should never
-        // exceed the audio buffer size (or something is very wrong).
-        // Ignore the first bytes in swr_buf to avoid memory corruption anyway.
-        swr_buf += TO_BYTES(samples - cap);
-        samples = cap;
-    }
-
-    uint32_t skipped_samples = 0;
-
-    uint32_t written = sc_audiobuf_write(&ar->buf, swr_buf, samples);
-    if (written < samples) {
-        uint32_t remaining = samples - written;
-
-        // All samples that could be written without locking have been written,
-        // now we need to lock to drop/consume old samples
-        sc_mutex_lock(&ar->mutex);
-
-        // Retry with the lock
-        written += sc_audiobuf_write(&ar->buf,
-                                     swr_buf + TO_BYTES(written),
-                                     remaining);
-        if (written < samples) {
-            remaining = samples - written;
-            // Still insufficient, drop old samples to make space
-            skipped_samples = sc_audiobuf_read(&ar->buf, NULL, remaining);
-            assert(skipped_samples == remaining);
-        }
-
-        sc_mutex_unlock(&ar->mutex);
-
-        if (written < samples) {
-            // Now there is enough space
-            uint32_t w = sc_audiobuf_write(&ar->buf,
-                                           swr_buf + TO_BYTES(written),
-                                           remaining);
-            assert(w == remaining);
-            (void) w;
-        }
-    }
-
-    uint32_t underflow = 0;
-    uint32_t max_buffered_samples;
-    bool played = atomic_load_explicit(&ar->played, memory_order_relaxed);
-    if (played) {
-        underflow = atomic_exchange_explicit(&ar->underflow, 0,
-                                             memory_order_relaxed);
-
-        max_buffered_samples = ar->target_buffering * 11 / 10
-                             + 60 * ar->sample_rate / 1000 /* 60 ms */;
-    } else {
-        // Playback not started yet, do not accumulate more than
-        // max_initial_buffering samples, this would cause unnecessary delay
-        // (and glitches to compensate) on start.
-        max_buffered_samples = ar->target_buffering
-                             + 10 * ar->sample_rate / 1000 /* 10 ms */;
-    }
-
-    uint32_t can_read = sc_audiobuf_can_read(&ar->buf);
-    if (can_read > max_buffered_samples) {
-        uint32_t skip_samples = 0;
-
-        sc_mutex_lock(&ar->mutex);
-        can_read = sc_audiobuf_can_read(&ar->buf);
-        if (can_read > max_buffered_samples) {
-            skip_samples = can_read - max_buffered_samples;
-            uint32_t r = sc_audiobuf_read(&ar->buf, NULL, skip_samples);
-            assert(r == skip_samples);
-            (void) r;
-            skipped_samples += skip_samples;
-        }
-        sc_mutex_unlock(&ar->mutex);
-
-        if (skip_samples) {
-            if (played) {
-                LOGD("[Audio] Buffering threshold exceeded, skipping %" PRIu32
-                     " samples", skip_samples);
-#ifdef SC_AUDIO_REGULATOR_DEBUG
-            } else {
-                LOGD("[Audio] Playback not started, skipping %" PRIu32
-                     " samples", skip_samples);
-#endif
-            }
-        }
-    }
-
-    atomic_store_explicit(&ar->received, true, memory_order_relaxed);
-    if (!played) {
-        // Nothing more to do
-        return true;
-    }
-
-    // Number of samples added (or removed, if negative) for compensation
-    int32_t instant_compensation = (int32_t) written - frame->nb_samples;
-    // Inserting silence instantly increases buffering
-    int32_t inserted_silence = (int32_t) underflow;
-    // Dropping input samples instantly decreases buffering
-    int32_t dropped = (int32_t) skipped_samples;
-
-    // The compensation must apply instantly, it must not be smoothed
-    ar->avg_buffering.avg += instant_compensation + inserted_silence - dropped;
-    if (ar->avg_buffering.avg < 0) {
-        // Since dropping samples instantly reduces buffering, the difference
-        // is applied immediately to the average value, assuming that the delay
-        // between the producer and the consumer will be caught up.
-        //
-        // However, when this assumption is not valid, the average buffering
-        // may decrease indefinitely. Prevent it to become negative to limit
-        // the consequences.
-        ar->avg_buffering.avg = 0;
-    }
-
-    // However, the buffering level must be smoothed
-    sc_average_push(&ar->avg_buffering, can_read);
-
-#ifdef SC_AUDIO_REGULATOR_DEBUG
-    LOGD("[Audio] can_read=%" PRIu32 " avg_buffering=%f",
-         can_read, sc_average_get(&ar->avg_buffering));
-#endif
-
-    ar->samples_since_resync += written;
-    if (ar->samples_since_resync >= ar->sample_rate) {
-        // Recompute compensation every second
-        ar->samples_since_resync = 0;
-
-        float avg = sc_average_get(&ar->avg_buffering);
-        int diff = ar->target_buffering - avg;
-
-        // Enable compensation when the difference exceeds +/- 4ms.
-        // Disable compensation when the difference is lower than +/- 1ms.
-        int threshold = ar->compensation != 0
-                      ? ar->sample_rate     / 1000  /* 1ms */
-                      : ar->sample_rate * 4 / 1000; /* 4ms */
-
-        if (abs(diff) < threshold) {
-            // Do not compensate for small values, the error is just noise
-            diff = 0;
-        } else if (diff < 0 && can_read < ar->target_buffering) {
-            // Do not accelerate if the instant buffering level is below the
-            // target, this would increase underflow
-            diff = 0;
-        }
-        // Compensate the diff over 4 seconds (but will be recomputed after 1
-        // second)
-        int distance = 4 * ar->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", ar->target_buffering, avg, can_read, diff);
-
-        if (diff != ar->compensation) {
-            int ret = swr_set_compensation(swr_ctx, diff, distance);
-            if (ret < 0) {
-                LOGW("Resampling compensation failed: %d", ret);
-                // not fatal
-            } else {
-                ar->compensation = diff;
-            }
-        }
-    }
-
-    return true;
-}
-
-bool
-sc_audio_regulator_init(struct sc_audio_regulator *ar, size_t sample_size,
-                        const AVCodecContext *ctx, uint32_t target_buffering) {
-    SwrContext *swr_ctx = swr_alloc();
-    if (!swr_ctx) {
-        LOG_OOM();
-        return false;
-    }
-    ar->swr_ctx = swr_ctx;
-
-#ifdef SCRCPY_LAVU_HAS_CHLAYOUT
-    av_opt_set_chlayout(swr_ctx, "in_chlayout", &ctx->ch_layout, 0);
-    av_opt_set_chlayout(swr_ctx, "out_chlayout", &ctx->ch_layout, 0);
-#else
-    av_opt_set_channel_layout(swr_ctx, "in_channel_layout",
-                              ctx->channel_layout, 0);
-    av_opt_set_channel_layout(swr_ctx, "out_channel_layout",
-                              ctx->channel_layout, 0);
-#endif
-
-    av_opt_set_int(swr_ctx, "in_sample_rate", ctx->sample_rate, 0);
-    av_opt_set_int(swr_ctx, "out_sample_rate", ctx->sample_rate, 0);
-
-    av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", ctx->sample_fmt, 0);
-    av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", SC_AV_SAMPLE_FMT, 0);
-
-    int ret = swr_init(swr_ctx);
-    if (ret) {
-        LOGE("Failed to initialize the resampling context");
-        goto error_free_swr_ctx;
-    }
-
-    bool ok = sc_mutex_init(&ar->mutex);
-    if (!ok) {
-        goto error_free_swr_ctx;
-    }
-
-    ar->target_buffering = target_buffering;
-    ar->sample_size = sample_size;
-    ar->sample_rate = ctx->sample_rate;
-
-    // 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.
-    uint32_t audiobuf_samples = target_buffering + ar->sample_rate;
-
-    ok = sc_audiobuf_init(&ar->buf, sample_size, audiobuf_samples);
-    if (!ok) {
-        goto error_destroy_mutex;
-    }
-
-    size_t initial_swr_buf_size = TO_BYTES(4096);
-    ar->swr_buf = malloc(initial_swr_buf_size);
-    if (!ar->swr_buf) {
-        LOG_OOM();
-        goto error_destroy_audiobuf;
-    }
-    ar->swr_buf_alloc_size = initial_swr_buf_size;
-
-    // Samples are produced and consumed by blocks, so the buffering must be
-    // smoothed to get a relatively stable value.
-    sc_average_init(&ar->avg_buffering, 128);
-    ar->samples_since_resync = 0;
-
-    ar->received = false;
-    atomic_init(&ar->played, false);
-    atomic_init(&ar->received, false);
-    atomic_init(&ar->underflow, 0);
-    ar->compensation = 0;
-
-    return true;
-
-error_destroy_audiobuf:
-    sc_audiobuf_destroy(&ar->buf);
-error_destroy_mutex:
-    sc_mutex_destroy(&ar->mutex);
-error_free_swr_ctx:
-    swr_free(&ar->swr_ctx);
-
-    return false;
-}
-
-void
-sc_audio_regulator_destroy(struct sc_audio_regulator *ar) {
-    free(ar->swr_buf);
-    sc_audiobuf_destroy(&ar->buf);
-    sc_mutex_destroy(&ar->mutex);
-    swr_free(&ar->swr_ctx);
-}

app/src/audio_regulator.h

@@ -1,71 +0,0 @@
-#ifndef SC_AUDIO_REGULATOR_H
-#define SC_AUDIO_REGULATOR_H
-
-#include "common.h"
-
-#include <stdatomic.h>
-#include <stdbool.h>
-#include <libavcodec/avcodec.h>
-#include <libswresample/swresample.h>
-#include "util/audiobuf.h"
-#include "util/average.h"
-#include "util/thread.h"
-
-#define SC_AV_SAMPLE_FMT AV_SAMPLE_FMT_FLT
-
-struct sc_audio_regulator {
-    sc_mutex mutex;
-
-    // Target buffering between the producer and the consumer (in samples)
-    uint32_t target_buffering;
-
-    // Audio buffer to communicate between the receiver and the player
-    struct sc_audiobuf buf;
-
-    // Resampler (only used from the receiver thread)
-    struct SwrContext *swr_ctx;
-
-    // The sample rate is the same for input and output
-    uint32_t sample_rate;
-    // The number of bytes per sample (for all channels)
-    size_t sample_size;
-
-    // Target buffer for resampling (only used by the receiver thread)
-    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)
-    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;
-
-    // Number of silence samples inserted since the last received packet
-    atomic_uint_least32_t underflow;
-
-    // Current applied compensation value (only used by the receiver thread)
-    int compensation;
-
-    // Set to true the first time a sample is received
-    atomic_bool received;
-
-    // Set to true the first time samples are pulled by the player
-    atomic_bool played;
-};
-
-bool
-sc_audio_regulator_init(struct sc_audio_regulator *ar, size_t sample_size,
-                        const AVCodecContext *ctx, uint32_t target_buffering);
-
-void
-sc_audio_regulator_destroy(struct sc_audio_regulator *ar);
-
-bool
-sc_audio_regulator_push(struct sc_audio_regulator *ar, const AVFrame *frame);
-
-void
-sc_audio_regulator_pull(struct sc_audio_regulator *ar, uint8_t *out,
-                        uint32_t samples);
-
-#endif

app/src/cli.c

@@ -1072,11 +1072,7 @@ static const struct sc_shortcut shortcuts[] = {
     },
     {
         .shortcuts = { "Shift+click-and-move" },
-        .text = "Tilt vertically (slide with 2 fingers)",
-    },
-    {
-        .shortcuts = { "Ctrl+Shift+click-and-move" },
-        .text = "Tilt horizontally (slide with 2 fingers)",
+        .text = "Tilt (slide vertically with two fingers)",
     },
     {
         .shortcuts = { "Drag & drop APK file" },

app/src/events.h

@@ -5,7 +5,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL2/SDL_events.h>
+#include <SDL_events.h>
 
 enum {
     SC_EVENT_NEW_FRAME = SDL_USEREVENT,

app/src/input_manager.c

@@ -5,9 +5,53 @@
 
 #include "input_events.h"
 #include "screen.h"
-#include "shortcut_mod.h"
 #include "util/log.h"
 
+#define SC_SDL_SHORTCUT_MODS_MASK (KMOD_CTRL | KMOD_ALT | KMOD_GUI)
+
+static inline uint16_t
+to_sdl_mod(uint8_t shortcut_mod) {
+    uint16_t sdl_mod = 0;
+    if (shortcut_mod & SC_SHORTCUT_MOD_LCTRL) {
+        sdl_mod |= KMOD_LCTRL;
+    }
+    if (shortcut_mod & SC_SHORTCUT_MOD_RCTRL) {
+        sdl_mod |= KMOD_RCTRL;
+    }
+    if (shortcut_mod & SC_SHORTCUT_MOD_LALT) {
+        sdl_mod |= KMOD_LALT;
+    }
+    if (shortcut_mod & SC_SHORTCUT_MOD_RALT) {
+        sdl_mod |= KMOD_RALT;
+    }
+    if (shortcut_mod & SC_SHORTCUT_MOD_LSUPER) {
+        sdl_mod |= KMOD_LGUI;
+    }
+    if (shortcut_mod & SC_SHORTCUT_MOD_RSUPER) {
+        sdl_mod |= KMOD_RGUI;
+    }
+    return sdl_mod;
+}
+
+static bool
+is_shortcut_mod(struct sc_input_manager *im, uint16_t sdl_mod) {
+    // keep only the relevant modifier keys
+    sdl_mod &= SC_SDL_SHORTCUT_MODS_MASK;
+
+    // at least one shortcut mod pressed?
+    return sdl_mod & im->sdl_shortcut_mods;
+}
+
+static bool
+is_shortcut_key(struct sc_input_manager *im, SDL_Keycode keycode) {
+    return (im->sdl_shortcut_mods & KMOD_LCTRL && keycode == SDLK_LCTRL)
+        || (im->sdl_shortcut_mods & KMOD_RCTRL && keycode == SDLK_RCTRL)
+        || (im->sdl_shortcut_mods & KMOD_LALT  && keycode == SDLK_LALT)
+        || (im->sdl_shortcut_mods & KMOD_RALT  && keycode == SDLK_RALT)
+        || (im->sdl_shortcut_mods & KMOD_LGUI  && keycode == SDLK_LGUI)
+        || (im->sdl_shortcut_mods & KMOD_RGUI  && keycode == SDLK_RGUI);
+}
+
 void
 sc_input_manager_init(struct sc_input_manager *im,
                       const struct sc_input_manager_params *params) {
@@ -29,7 +73,7 @@ sc_input_manager_init(struct sc_input_manager *im,
     im->legacy_paste = params->legacy_paste;
     im->clipboard_autosync = params->clipboard_autosync;
 
-    im->sdl_shortcut_mods = sc_shortcut_mods_to_sdl(params->shortcut_mods);
+    im->sdl_shortcut_mods = to_sdl_mod(params->shortcut_mods);
 
     im->vfinger_down = false;
     im->vfinger_invert_x = false;
@@ -302,8 +346,7 @@ sc_input_manager_process_text_input(struct sc_input_manager *im,
         return;
     }
 
-    if (sc_shortcut_mods_is_shortcut_mod(im->sdl_shortcut_mods,
-                                         SDL_GetModState())) {
+    if (is_shortcut_mod(im, SDL_GetModState())) {
         // A shortcut must never generate text events
         return;
     }
@@ -370,9 +413,8 @@ sc_input_manager_process_key(struct sc_input_manager *im,
     // press/release is a modifier key.
     // The second condition is necessary to ignore the release of the modifier
     // key (because in this case mod is 0).
-    uint16_t mods = im->sdl_shortcut_mods;
-    bool is_shortcut = sc_shortcut_mods_is_shortcut_mod(mods, mod)
-                    || sc_shortcut_mods_is_shortcut_key(mods, sdl_keycode);
+    bool is_shortcut = is_shortcut_mod(im, mod)
+                    || is_shortcut_key(im, sdl_keycode);
 
     if (down && !repeat) {
         if (sdl_keycode == im->last_keycode && mod == im->last_mod) {
@@ -494,7 +536,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
                 return;
             case SDLK_f:
                 if (video && !shift && !repeat && down) {
-                    sc_screen_toggle_fullscreen(im->screen);
+                    sc_screen_switch_fullscreen(im->screen);
                 }
                 return;
             case SDLK_w:
@@ -794,7 +836,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
     }
 
     bool change_vfinger = event->button == SDL_BUTTON_LEFT &&
-            ((down && !im->vfinger_down && (ctrl_pressed || shift_pressed)) ||
+            ((down && !im->vfinger_down && (ctrl_pressed ^ shift_pressed)) ||
              (!down && im->vfinger_down));
     bool use_finger = im->vfinger_down || change_vfinger;
 
@@ -826,28 +868,16 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
     // In other words, the center of the rotation/scaling is the center of the
     // screen.
     //
-    // To simulate a vertical tilt gesture (a vertical slide with two fingers),
-    // Shift can be used instead of Ctrl. The "virtual finger" has a position
+    // To simulate a tilt gesture (a vertical slide with two fingers), Shift
+    // can be used instead of Ctrl. The "virtual finger" has a position
     // inverted with respect to the vertical axis of symmetry in the middle of
     // the screen.
-    //
-    // To simulate a horizontal tilt gesture (a horizontal slide with two
-    // fingers), Ctrl+Shift can be used. The "virtual finger" has a position
-    // inverted with respect to the horizontal axis of symmetry in the middle
-    // of the screen. It is expected to be less frequently used, that's why the
-    // one-mod shortcuts are assigned to rotation and vertical tilt.
     if (change_vfinger) {
         struct sc_point mouse =
             sc_screen_convert_window_to_frame_coords(im->screen, event->x,
                                                                  event->y);
         if (down) {
-            // Ctrl  Shift     invert_x  invert_y
-            // ----  ----- ==> --------  --------
-            //   0     0           0         0      -
-            //   0     1           1         0      vertical tilt
-            //   1     0           1         1      rotate
-            //   1     1           0         1      horizontal tilt
-            im->vfinger_invert_x = ctrl_pressed ^ shift_pressed;
+            im->vfinger_invert_x = ctrl_pressed || shift_pressed;
             im->vfinger_invert_y = ctrl_pressed;
         }
         struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size,

app/src/keyboard_sdk.c

@@ -45,10 +45,6 @@ convert_keycode(enum sc_keycode from, enum android_keycode *to, uint16_t mod,
         {SC_KEYCODE_RCTRL,     AKEYCODE_CTRL_RIGHT},
         {SC_KEYCODE_LSHIFT,    AKEYCODE_SHIFT_LEFT},
         {SC_KEYCODE_RSHIFT,    AKEYCODE_SHIFT_RIGHT},
-        {SC_KEYCODE_LALT,      AKEYCODE_ALT_LEFT},
-        {SC_KEYCODE_RALT,      AKEYCODE_ALT_RIGHT},
-        {SC_KEYCODE_LGUI,      AKEYCODE_META_LEFT},
-        {SC_KEYCODE_RGUI,      AKEYCODE_META_RIGHT},
     };
 
     // Numpad navigation keys.
@@ -170,7 +166,11 @@ convert_keycode(enum sc_keycode from, enum android_keycode *to, uint16_t mod,
         return false;
     }
 
-    // Handle letters and space
+    if (mod & (SC_MOD_LALT | SC_MOD_RALT | SC_MOD_LGUI | SC_MOD_RGUI)) {
+        return false;
+    }
+
+    // if ALT and META are not pressed, also handle letters and space
     entry = SC_INTMAP_FIND_ENTRY(alphaspace_keys, from);
     if (entry) {
         *to = entry->value;

app/src/mouse_capture.c

@@ -1,123 +0,0 @@
-#include "mouse_capture.h"
-
-#include "shortcut_mod.h"
-#include "util/log.h"
-
-void
-sc_mouse_capture_init(struct sc_mouse_capture *mc, SDL_Window *window,
-                      uint8_t shortcut_mods) {
-    mc->window = window;
-    mc->sdl_mouse_capture_keys = sc_shortcut_mods_to_sdl(shortcut_mods);
-    mc->mouse_capture_key_pressed = SDLK_UNKNOWN;
-}
-
-static inline bool
-sc_mouse_capture_is_capture_key(struct sc_mouse_capture *mc, SDL_Keycode key) {
-    return sc_shortcut_mods_is_shortcut_key(mc->sdl_mouse_capture_keys, key);
-}
-
-bool
-sc_mouse_capture_handle_event(struct sc_mouse_capture *mc,
-                              const SDL_Event *event) {
-    switch (event->type) {
-        case SDL_WINDOWEVENT:
-            if (event->window.event == SDL_WINDOWEVENT_FOCUS_LOST) {
-                sc_mouse_capture_set_active(mc, false);
-                return true;
-            }
-            break;
-        case SDL_KEYDOWN: {
-            SDL_Keycode key = event->key.keysym.sym;
-            if (sc_mouse_capture_is_capture_key(mc, key)) {
-                if (!mc->mouse_capture_key_pressed) {
-                    mc->mouse_capture_key_pressed = key;
-                } else {
-                    // Another mouse capture key has been pressed, cancel
-                    // mouse (un)capture
-                    mc->mouse_capture_key_pressed = 0;
-                }
-                // Mouse capture keys are never forwarded to the device
-                return true;
-            }
-            break;
-        }
-        case SDL_KEYUP: {
-            SDL_Keycode key = event->key.keysym.sym;
-            SDL_Keycode cap = mc->mouse_capture_key_pressed;
-            mc->mouse_capture_key_pressed = 0;
-            if (sc_mouse_capture_is_capture_key(mc, key)) {
-                if (key == cap) {
-                    // A mouse capture key has been pressed then released:
-                    // toggle the capture mouse mode
-                    sc_mouse_capture_toggle(mc);
-                }
-                // Mouse capture keys are never forwarded to the device
-                return true;
-            }
-            break;
-        }
-        case SDL_MOUSEWHEEL:
-        case SDL_MOUSEMOTION:
-        case SDL_MOUSEBUTTONDOWN:
-            if (!sc_mouse_capture_is_active(mc)) {
-                // The mouse will be captured on SDL_MOUSEBUTTONUP, so consume
-                // the event
-                return true;
-            }
-            break;
-        case SDL_MOUSEBUTTONUP:
-            if (!sc_mouse_capture_is_active(mc)) {
-                sc_mouse_capture_set_active(mc, true);
-                return true;
-            }
-            break;
-        case SDL_FINGERMOTION:
-        case SDL_FINGERDOWN:
-        case SDL_FINGERUP:
-            // Touch events are not compatible with relative mode
-            // (coordinates are not relative), so consume the event
-            return true;
-    }
-
-    return false;
-}
-
-void
-sc_mouse_capture_set_active(struct sc_mouse_capture *mc, bool capture) {
-#ifdef __APPLE__
-    // Workaround for SDL bug on macOS:
-    // <https://github.com/libsdl-org/SDL/issues/5340>
-    if (capture) {
-        int mouse_x, mouse_y;
-        SDL_GetGlobalMouseState(&mouse_x, &mouse_y);
-
-        int x, y, w, h;
-        SDL_GetWindowPosition(mc->window, &x, &y);
-        SDL_GetWindowSize(mc->window, &w, &h);
-
-        bool outside_window = mouse_x < x || mouse_x >= x + w
-                           || mouse_y < y || mouse_y >= y + h;
-        if (outside_window) {
-            SDL_WarpMouseInWindow(mc->window, w / 2, h / 2);
-        }
-    }
-#else
-    (void) mc;
-#endif
-    if (SDL_SetRelativeMouseMode(capture)) {
-        LOGE("Could not set relative mouse mode to %s: %s",
-             capture ? "true" : "false", SDL_GetError());
-    }
-}
-
-bool
-sc_mouse_capture_is_active(struct sc_mouse_capture *mc) {
-    (void) mc;
-    return SDL_GetRelativeMouseMode();
-}
-
-void
-sc_mouse_capture_toggle(struct sc_mouse_capture *mc) {
-    bool new_value = !sc_mouse_capture_is_active(mc);
-    sc_mouse_capture_set_active(mc, new_value);
-}

app/src/mouse_capture.h

@@ -1,38 +0,0 @@
-#ifndef SC_MOUSE_CAPTURE_H
-#define SC_MOUSE_CAPTURE_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include <SDL2/SDL.h>
-
-struct sc_mouse_capture {
-    SDL_Window *window;
-    uint16_t sdl_mouse_capture_keys;
-
-    // To enable/disable mouse capture, a mouse capture key (LALT, LGUI or
-    // RGUI) must be pressed. This variable tracks the pressed capture key.
-    SDL_Keycode mouse_capture_key_pressed;
-
-};
-
-void
-sc_mouse_capture_init(struct sc_mouse_capture *mc, SDL_Window *window,
-                      uint8_t shortcut_mods);
-
-void
-sc_mouse_capture_set_active(struct sc_mouse_capture *mc, bool capture);
-
-bool
-sc_mouse_capture_is_active(struct sc_mouse_capture *mc);
-
-void
-sc_mouse_capture_toggle(struct sc_mouse_capture *mc);
-
-// Return true if it consumed the event
-bool
-sc_mouse_capture_handle_event(struct sc_mouse_capture *mc,
-                              const SDL_Event *event);
-
-#endif

app/src/screen.c

@@ -162,6 +162,47 @@ sc_screen_is_relative_mode(struct sc_screen *screen) {
     return screen->im.mp && screen->im.mp->relative_mode;
 }
 
+static void
+sc_screen_set_mouse_capture(struct sc_screen *screen, bool capture) {
+#ifdef __APPLE__
+    // Workaround for SDL bug on macOS:
+    // <https://github.com/libsdl-org/SDL/issues/5340>
+    if (capture) {
+        int mouse_x, mouse_y;
+        SDL_GetGlobalMouseState(&mouse_x, &mouse_y);
+
+        int x, y, w, h;
+        SDL_GetWindowPosition(screen->window, &x, &y);
+        SDL_GetWindowSize(screen->window, &w, &h);
+
+        bool outside_window = mouse_x < x || mouse_x >= x + w
+                           || mouse_y < y || mouse_y >= y + h;
+        if (outside_window) {
+            SDL_WarpMouseInWindow(screen->window, w / 2, h / 2);
+        }
+    }
+#else
+    (void) screen;
+#endif
+    if (SDL_SetRelativeMouseMode(capture)) {
+        LOGE("Could not set relative mouse mode to %s: %s",
+             capture ? "true" : "false", SDL_GetError());
+    }
+}
+
+static inline bool
+sc_screen_get_mouse_capture(struct sc_screen *screen) {
+    (void) screen;
+    return SDL_GetRelativeMouseMode();
+}
+
+static inline void
+sc_screen_toggle_mouse_capture(struct sc_screen *screen) {
+    (void) screen;
+    bool new_value = !sc_screen_get_mouse_capture(screen);
+    sc_screen_set_mouse_capture(screen, new_value);
+}
+
 static void
 sc_screen_update_content_rect(struct sc_screen *screen) {
     assert(screen->video);
@@ -330,6 +371,7 @@ sc_screen_init(struct sc_screen *screen,
     screen->fullscreen = false;
     screen->maximized = false;
     screen->minimized = false;
+    screen->mouse_capture_key_pressed = 0;
     screen->paused = false;
     screen->resume_frame = NULL;
     screen->orientation = SC_ORIENTATION_0;
@@ -444,9 +486,6 @@ sc_screen_init(struct sc_screen *screen,
 
     sc_input_manager_init(&screen->im, &im_params);
 
-    // Initialize even if not used for simplicity
-    sc_mouse_capture_init(&screen->mc, screen->window, params->shortcut_mods);
-
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
     if (screen->video) {
         SDL_AddEventWatch(event_watcher, screen);
@@ -467,7 +506,7 @@ sc_screen_init(struct sc_screen *screen,
 
     if (!screen->video && sc_screen_is_relative_mode(screen)) {
         // Capture mouse immediately if video mirroring is disabled
-        sc_mouse_capture_set_active(&screen->mc, true);
+        sc_screen_set_mouse_capture(screen, true);
     }
 
     return true;
@@ -499,7 +538,7 @@ sc_screen_show_initial_window(struct sc_screen *screen) {
     SDL_SetWindowPosition(screen->window, x, y);
 
     if (screen->req.fullscreen) {
-        sc_screen_toggle_fullscreen(screen);
+        sc_screen_switch_fullscreen(screen);
     }
 
     if (screen->req.start_fps_counter) {
@@ -674,7 +713,7 @@ sc_screen_apply_frame(struct sc_screen *screen) {
 
         if (sc_screen_is_relative_mode(screen)) {
             // Capture mouse on start
-            sc_mouse_capture_set_active(&screen->mc, true);
+            sc_screen_set_mouse_capture(screen, true);
         }
     }
 
@@ -735,7 +774,7 @@ sc_screen_set_paused(struct sc_screen *screen, bool paused) {
 }
 
 void
-sc_screen_toggle_fullscreen(struct sc_screen *screen) {
+sc_screen_switch_fullscreen(struct sc_screen *screen) {
     assert(screen->video);
 
     uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
@@ -798,8 +837,15 @@ sc_screen_resize_to_pixel_perfect(struct sc_screen *screen) {
                                             content_size.height);
 }
 
+static inline bool
+sc_screen_is_mouse_capture_key(SDL_Keycode key) {
+    return key == SDLK_LALT || key == SDLK_LGUI || key == SDLK_RGUI;
+}
+
 bool
 sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
+    bool relative_mode = sc_screen_is_relative_mode(screen);
+
     switch (event->type) {
         case SC_EVENT_SCREEN_INIT_SIZE: {
             // The initial size is passed via screen->frame_size
@@ -857,14 +903,69 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
                     apply_pending_resize(screen);
                     sc_screen_render(screen, true);
                     break;
+                case SDL_WINDOWEVENT_FOCUS_LOST:
+                    if (relative_mode) {
+                        sc_screen_set_mouse_capture(screen, false);
+                    }
+                    break;
             }
             return true;
-    }
-
-    if (sc_screen_is_relative_mode(screen)
-            && sc_mouse_capture_handle_event(&screen->mc, event)) {
-        // The mouse capture handler consumed the event
-        return true;
+        case SDL_KEYDOWN:
+            if (relative_mode) {
+                SDL_Keycode key = event->key.keysym.sym;
+                if (sc_screen_is_mouse_capture_key(key)) {
+                    if (!screen->mouse_capture_key_pressed) {
+                        screen->mouse_capture_key_pressed = key;
+                    } else {
+                        // Another mouse capture key has been pressed, cancel
+                        // mouse (un)capture
+                        screen->mouse_capture_key_pressed = 0;
+                    }
+                    // Mouse capture keys are never forwarded to the device
+                    return true;
+                }
+            }
+            break;
+        case SDL_KEYUP:
+            if (relative_mode) {
+                SDL_Keycode key = event->key.keysym.sym;
+                SDL_Keycode cap = screen->mouse_capture_key_pressed;
+                screen->mouse_capture_key_pressed = 0;
+                if (sc_screen_is_mouse_capture_key(key)) {
+                    if (key == cap) {
+                        // A mouse capture key has been pressed then released:
+                        // toggle the capture mouse mode
+                        sc_screen_toggle_mouse_capture(screen);
+                    }
+                    // Mouse capture keys are never forwarded to the device
+                    return true;
+                }
+            }
+            break;
+        case SDL_MOUSEWHEEL:
+        case SDL_MOUSEMOTION:
+        case SDL_MOUSEBUTTONDOWN:
+            if (relative_mode && !sc_screen_get_mouse_capture(screen)) {
+                // Do not forward to input manager, the mouse will be captured
+                // on SDL_MOUSEBUTTONUP
+                return true;
+            }
+            break;
+        case SDL_FINGERMOTION:
+        case SDL_FINGERDOWN:
+        case SDL_FINGERUP:
+            if (relative_mode) {
+                // Touch events are not compatible with relative mode
+                // (coordinates are not relative)
+                return true;
+            }
+            break;
+        case SDL_MOUSEBUTTONUP:
+            if (relative_mode && !sc_screen_get_mouse_capture(screen)) {
+                sc_screen_set_mouse_capture(screen, true);
+                return true;
+            }
+            break;
     }
 
     sc_input_manager_handle_event(&screen->im, event);

app/src/screen.h

@@ -13,7 +13,6 @@
 #include "fps_counter.h"
 #include "frame_buffer.h"
 #include "input_manager.h"
-#include "mouse_capture.h"
 #include "opengl.h"
 #include "options.h"
 #include "trait/key_processor.h"
@@ -31,7 +30,6 @@ struct sc_screen {
 
     struct sc_display display;
     struct sc_input_manager im;
-    struct sc_mouse_capture mc; // only used in mouse relative mode
     struct sc_frame_buffer fb;
     struct sc_fps_counter fps_counter;
 
@@ -63,6 +61,10 @@ struct sc_screen {
     bool maximized;
     bool minimized;
 
+    // To enable/disable mouse capture, a mouse capture key (LALT, LGUI or
+    // RGUI) must be pressed. This variable tracks the pressed capture key.
+    SDL_Keycode mouse_capture_key_pressed;
+
     AVFrame *frame;
 
     bool paused;
@@ -124,9 +126,9 @@ sc_screen_destroy(struct sc_screen *screen);
 void
 sc_screen_hide_window(struct sc_screen *screen);
 
-// toggle the fullscreen mode
+// switch the fullscreen mode
 void
-sc_screen_toggle_fullscreen(struct sc_screen *screen);
+sc_screen_switch_fullscreen(struct sc_screen *screen);
 
 // resize window to optimal size (remove black borders)
 void

app/src/server.c

@@ -66,6 +66,56 @@ get_server_path(void) {
     return server_path;
 }
 
+static void
+sc_server_params_destroy(struct sc_server_params *params) {
+    // The server stores a copy of the params provided by the user
+    free((char *) params->req_serial);
+    free((char *) params->crop);
+    free((char *) params->video_codec_options);
+    free((char *) params->audio_codec_options);
+    free((char *) params->video_encoder);
+    free((char *) params->audio_encoder);
+    free((char *) params->tcpip_dst);
+    free((char *) params->camera_id);
+    free((char *) params->camera_ar);
+}
+
+static bool
+sc_server_params_copy(struct sc_server_params *dst,
+                      const struct sc_server_params *src) {
+    *dst = *src;
+
+    // The params reference user-allocated memory, so we must copy them to
+    // handle them from another thread
+
+#define COPY(FIELD) do { \
+    dst->FIELD = NULL; \
+    if (src->FIELD) { \
+        dst->FIELD = strdup(src->FIELD); \
+        if (!dst->FIELD) { \
+            goto error; \
+        } \
+    } \
+} while(0)
+
+    COPY(req_serial);
+    COPY(crop);
+    COPY(video_codec_options);
+    COPY(audio_codec_options);
+    COPY(video_encoder);
+    COPY(audio_encoder);
+    COPY(tcpip_dst);
+    COPY(camera_id);
+    COPY(camera_ar);
+#undef COPY
+
+    return true;
+
+error:
+    sc_server_params_destroy(dst);
+    return false;
+}
+
 static bool
 push_server(struct sc_intr *intr, const char *serial) {
     char *server_path = get_server_path();
@@ -449,18 +499,22 @@ connect_to_server(struct sc_server *server, unsigned attempts, sc_tick delay,
 bool
 sc_server_init(struct sc_server *server, const struct sc_server_params *params,
               const struct sc_server_callbacks *cbs, void *cbs_userdata) {
-    // The allocated data in params (const char *) must remain valid until the
-    // end of the program
-    server->params = *params;
-
-    bool ok = sc_mutex_init(&server->mutex);
+    bool ok = sc_server_params_copy(&server->params, params);
     if (!ok) {
+        LOG_OOM();
+        return false;
+    }
+
+    ok = sc_mutex_init(&server->mutex);
+    if (!ok) {
+        sc_server_params_destroy(&server->params);
         return false;
     }
 
     ok = sc_cond_init(&server->cond_stopped);
     if (!ok) {
         sc_mutex_destroy(&server->mutex);
+        sc_server_params_destroy(&server->params);
         return false;
     }
 
@@ -468,6 +522,7 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
     if (!ok) {
         sc_cond_destroy(&server->cond_stopped);
         sc_mutex_destroy(&server->mutex);
+        sc_server_params_destroy(&server->params);
         return false;
     }
 
@@ -1106,6 +1161,7 @@ sc_server_destroy(struct sc_server *server) {
 
     free(server->serial);
     free(server->device_socket_name);
+    sc_server_params_destroy(&server->params);
     sc_intr_destroy(&server->intr);
     sc_cond_destroy(&server->cond_stopped);
     sc_mutex_destroy(&server->mutex);

app/src/shortcut_mod.h

@@ -1,60 +0,0 @@
-#ifndef SC_SHORTCUT_MOD_H
-#define SC_SHORTCUT_MOD_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <SDL2/SDL_keycode.h>
-
-#include "options.h"
-
-#define SC_SDL_SHORTCUT_MODS_MASK (KMOD_CTRL | KMOD_ALT | KMOD_GUI)
-
-// input: OR of enum sc_shortcut_mod
-// output: OR of SDL_Keymod
-static inline uint16_t
-sc_shortcut_mods_to_sdl(uint8_t shortcut_mods) {
-    uint16_t sdl_mod = 0;
-    if (shortcut_mods & SC_SHORTCUT_MOD_LCTRL) {
-        sdl_mod |= KMOD_LCTRL;
-    }
-    if (shortcut_mods & SC_SHORTCUT_MOD_RCTRL) {
-        sdl_mod |= KMOD_RCTRL;
-    }
-    if (shortcut_mods & SC_SHORTCUT_MOD_LALT) {
-        sdl_mod |= KMOD_LALT;
-    }
-    if (shortcut_mods & SC_SHORTCUT_MOD_RALT) {
-        sdl_mod |= KMOD_RALT;
-    }
-    if (shortcut_mods & SC_SHORTCUT_MOD_LSUPER) {
-        sdl_mod |= KMOD_LGUI;
-    }
-    if (shortcut_mods & SC_SHORTCUT_MOD_RSUPER) {
-        sdl_mod |= KMOD_RGUI;
-    }
-    return sdl_mod;
-}
-
-static inline bool
-sc_shortcut_mods_is_shortcut_mod(uint16_t sdl_shortcut_mods, uint16_t sdl_mod) {
-    // sdl_shortcut_mods must be within the mask
-    assert(!(sdl_shortcut_mods & ~SC_SDL_SHORTCUT_MODS_MASK));
-
-    // at least one shortcut mod pressed?
-    return sdl_mod & sdl_shortcut_mods;
-}
-
-static inline bool
-sc_shortcut_mods_is_shortcut_key(uint16_t sdl_shortcut_mods,
-                                 SDL_Keycode keycode) {
-    return (sdl_shortcut_mods & KMOD_LCTRL && keycode == SDLK_LCTRL)
-        || (sdl_shortcut_mods & KMOD_RCTRL && keycode == SDLK_RCTRL)
-        || (sdl_shortcut_mods & KMOD_LALT  && keycode == SDLK_LALT)
-        || (sdl_shortcut_mods & KMOD_RALT  && keycode == SDLK_RALT)
-        || (sdl_shortcut_mods & KMOD_LGUI  && keycode == SDLK_LGUI)
-        || (sdl_shortcut_mods & KMOD_RGUI  && keycode == SDLK_RGUI);
-}
-
-#endif

app/src/usb/aoa_hid.h

@@ -1,8 +1,6 @@
 #ifndef SC_AOA_HID_H
 #define SC_AOA_HID_H
 
-#include "common.h"
-
 #include <stdint.h>
 #include <stdbool.h>
 

app/src/usb/scrcpy_otg.c

@@ -185,7 +185,6 @@ scrcpy_otg(struct scrcpy_options *options) {
         .window_width = options->window_width,
         .window_height = options->window_height,
         .window_borderless = options->window_borderless,
-        .shortcut_mods = options->shortcut_mods,
     };
 
     ok = sc_screen_otg_init(&s->screen_otg, &params);

app/src/usb/screen_otg.c

@@ -4,6 +4,47 @@
 #include "options.h"
 #include "util/log.h"
 
+static void
+sc_screen_otg_set_mouse_capture(struct sc_screen_otg *screen, bool capture) {
+#ifdef __APPLE__
+    // Workaround for SDL bug on macOS:
+    // <https://github.com/libsdl-org/SDL/issues/5340>
+    if (capture) {
+        int mouse_x, mouse_y;
+        SDL_GetGlobalMouseState(&mouse_x, &mouse_y);
+
+        int x, y, w, h;
+        SDL_GetWindowPosition(screen->window, &x, &y);
+        SDL_GetWindowSize(screen->window, &w, &h);
+
+        bool outside_window = mouse_x < x || mouse_x >= x + w
+                           || mouse_y < y || mouse_y >= y + h;
+        if (outside_window) {
+            SDL_WarpMouseInWindow(screen->window, w / 2, h / 2);
+        }
+    }
+#else
+    (void) screen;
+#endif
+    if (SDL_SetRelativeMouseMode(capture)) {
+        LOGE("Could not set relative mouse mode to %s: %s",
+             capture ? "true" : "false", SDL_GetError());
+    }
+}
+
+static inline bool
+sc_screen_otg_get_mouse_capture(struct sc_screen_otg *screen) {
+    (void) screen;
+    return SDL_GetRelativeMouseMode();
+}
+
+static inline void
+sc_screen_otg_toggle_mouse_capture(struct sc_screen_otg *screen) {
+    (void) screen;
+    bool new_value = !sc_screen_otg_get_mouse_capture(screen);
+    sc_screen_otg_set_mouse_capture(screen, new_value);
+}
+
 static void
 sc_screen_otg_render(struct sc_screen_otg *screen) {
     SDL_RenderClear(screen->renderer);
@@ -20,6 +61,8 @@ sc_screen_otg_init(struct sc_screen_otg *screen,
     screen->mouse = params->mouse;
     screen->gamepad = params->gamepad;
 
+    screen->mouse_capture_key_pressed = 0;
+
     const char *title = params->window_title;
     assert(title);
 
@@ -70,11 +113,9 @@ sc_screen_otg_init(struct sc_screen_otg *screen,
         LOGW("Could not load icon");
     }
 
-    sc_mouse_capture_init(&screen->mc, screen->window, params->shortcut_mods);
-
     if (screen->mouse) {
         // Capture mouse on start
-        sc_mouse_capture_set_active(&screen->mc, true);
+        sc_screen_otg_set_mouse_capture(screen, true);
     }
 
     return true;
@@ -96,6 +137,11 @@ sc_screen_otg_destroy(struct sc_screen_otg *screen) {
     SDL_DestroyWindow(screen->window);
 }
 
+static inline bool
+sc_screen_otg_is_mouse_capture_key(SDL_Keycode key) {
+    return key == SDLK_LALT || key == SDLK_LGUI || key == SDLK_RGUI;
+}
+
 static void
 sc_screen_otg_process_key(struct sc_screen_otg *screen,
                              const SDL_KeyboardEvent *event) {
@@ -252,46 +298,80 @@ sc_screen_otg_process_gamepad_button(struct sc_screen_otg *screen,
 
 void
 sc_screen_otg_handle_event(struct sc_screen_otg *screen, SDL_Event *event) {
-    if (sc_mouse_capture_handle_event(&screen->mc, event)) {
-        // The mouse capture handler consumed the event
-        return;
-    }
-
     switch (event->type) {
         case SDL_WINDOWEVENT:
             switch (event->window.event) {
                 case SDL_WINDOWEVENT_EXPOSED:
                     sc_screen_otg_render(screen);
                     break;
+                case SDL_WINDOWEVENT_FOCUS_LOST:
+                    if (screen->mouse) {
+                        sc_screen_otg_set_mouse_capture(screen, false);
+                    }
+                    break;
             }
             return;
         case SDL_KEYDOWN:
+            if (screen->mouse) {
+                SDL_Keycode key = event->key.keysym.sym;
+                if (sc_screen_otg_is_mouse_capture_key(key)) {
+                    if (!screen->mouse_capture_key_pressed) {
+                        screen->mouse_capture_key_pressed = key;
+                    } else {
+                        // Another mouse capture key has been pressed, cancel
+                        // mouse (un)capture
+                        screen->mouse_capture_key_pressed = 0;
+                    }
+                    // Mouse capture keys are never forwarded to the device
+                    return;
+                }
+            }
+
             if (screen->keyboard) {
                 sc_screen_otg_process_key(screen, &event->key);
             }
             break;
         case SDL_KEYUP:
+            if (screen->mouse) {
+                SDL_Keycode key = event->key.keysym.sym;
+                SDL_Keycode cap = screen->mouse_capture_key_pressed;
+                screen->mouse_capture_key_pressed = 0;
+                if (sc_screen_otg_is_mouse_capture_key(key)) {
+                    if (key == cap) {
+                        // A mouse capture key has been pressed then released:
+                        // toggle the capture mouse mode
+                        sc_screen_otg_toggle_mouse_capture(screen);
+                    }
+                    // Mouse capture keys are never forwarded to the device
+                    return;
+                }
+            }
+
             if (screen->keyboard) {
                 sc_screen_otg_process_key(screen, &event->key);
             }
             break;
         case SDL_MOUSEMOTION:
-            if (screen->mouse) {
+            if (screen->mouse && sc_screen_otg_get_mouse_capture(screen)) {
                 sc_screen_otg_process_mouse_motion(screen, &event->motion);
             }
             break;
         case SDL_MOUSEBUTTONDOWN:
-            if (screen->mouse) {
+            if (screen->mouse && sc_screen_otg_get_mouse_capture(screen)) {
                 sc_screen_otg_process_mouse_button(screen, &event->button);
             }
             break;
         case SDL_MOUSEBUTTONUP:
             if (screen->mouse) {
-                sc_screen_otg_process_mouse_button(screen, &event->button);
+                if (sc_screen_otg_get_mouse_capture(screen)) {
+                    sc_screen_otg_process_mouse_button(screen, &event->button);
+                } else {
+                    sc_screen_otg_set_mouse_capture(screen, true);
+                }
             }
             break;
         case SDL_MOUSEWHEEL:
-            if (screen->mouse) {
+            if (screen->mouse && sc_screen_otg_get_mouse_capture(screen)) {
                 sc_screen_otg_process_mouse_wheel(screen, &event->wheel);
             }
             break;

app/src/usb/screen_otg.h

@@ -8,7 +8,6 @@
 
 #include "keyboard_aoa.h"
 #include "mouse_aoa.h"
-#include "mouse_capture.h"
 #include "gamepad_aoa.h"
 
 struct sc_screen_otg {
@@ -20,7 +19,8 @@ struct sc_screen_otg {
     SDL_Renderer *renderer;
     SDL_Texture *texture;
 
-    struct sc_mouse_capture mc;
+    // See equivalent mechanism in screen.h
+    SDL_Keycode mouse_capture_key_pressed;
 };
 
 struct sc_screen_otg_params {
@@ -35,7 +35,6 @@ struct sc_screen_otg_params {
     uint16_t window_width;
     uint16_t window_height;
     bool window_borderless;
-    uint8_t shortcut_mods; // OR of enum sc_shortcut_mod values
 };
 
 bool

app/src/util/tick.h

@@ -10,14 +10,14 @@ typedef int64_t sc_tick;
 #define SC_TICK_FREQ 1000000 // microsecond
 
 // To be adapted if SC_TICK_FREQ changes
-#define SC_TICK_TO_NS(tick) ((sc_tick) (tick) * 1000)
-#define SC_TICK_TO_US(tick) ((sc_tick) tick)
-#define SC_TICK_TO_MS(tick) ((sc_tick) (tick) / 1000)
-#define SC_TICK_TO_SEC(tick) ((sc_tick) (tick) / 1000000)
-#define SC_TICK_FROM_NS(ns) ((sc_tick) (ns) / 1000)
-#define SC_TICK_FROM_US(us) ((sc_tick) us)
-#define SC_TICK_FROM_MS(ms) ((sc_tick) (ms) * 1000)
-#define SC_TICK_FROM_SEC(sec) ((sc_tick) (sec) * 1000000)
+#define SC_TICK_TO_NS(tick) ((tick) * 1000)
+#define SC_TICK_TO_US(tick) (tick)
+#define SC_TICK_TO_MS(tick) ((tick) / 1000)
+#define SC_TICK_TO_SEC(tick) ((tick) / 1000000)
+#define SC_TICK_FROM_NS(ns) ((ns) / 1000)
+#define SC_TICK_FROM_US(us) (us)
+#define SC_TICK_FROM_MS(ms) ((ms) * 1000)
+#define SC_TICK_FROM_SEC(sec) ((sec) * 1000000)
 
 sc_tick
 sc_tick_now(void);

app/src/util/timeout.c

@@ -62,7 +62,6 @@ void
 sc_timeout_stop(struct sc_timeout *timeout) {
     sc_mutex_lock(&timeout->mutex);
     timeout->stopped = true;
-    sc_cond_signal(&timeout->cond);
     sc_mutex_unlock(&timeout->mutex);
 }
 

build.gradle

@@ -7,7 +7,7 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:8.7.1'
+        classpath 'com.android.tools.build:gradle:8.3.0'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

doc/control.md

@@ -94,18 +94,14 @@ the content (if supported by the app) relative to the center of the screen.
 
 https://github.com/Genymobile/scrcpy/assets/543275/26c4a920-9805-43f1-8d4c-608752d04767
 
-To simulate a vertical tilt gesture: <kbd>Shift</kbd>+_click-and-move-up-or-down_.
+To simulate a tilt gesture: <kbd>Shift</kbd>+_click-and-move-up-or-down_.
 
 https://github.com/Genymobile/scrcpy/assets/543275/1e252341-4a90-4b29-9d11-9153b324669f
 
-Similarly, to simulate a horizontal tilt gesture:
-<kbd>Ctrl</kbd>+<kbd>Shift</kbd>+_click-and-move-left-or-right_.
-
 Technically, _scrcpy_ generates additional touch events from a "virtual finger"
 at a location inverted through the center of the screen. When pressing
 <kbd>Ctrl</kbd> the _x_ and _y_ coordinates are inverted. Using <kbd>Shift</kbd>
-only inverts _x_, whereas using <kbd>Ctrl</kbd>+<kbd>Shift</kbd> only inverts
-_y_.
+only inverts _x_.
 
 This only works for the default mouse mode (`--mouse=sdk`).
 

doc/shortcuts.md

@@ -53,8 +53,7 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
  | Open keyboard settings (HID keyboard only)  | <kbd>MOD</kbd>+<kbd>k</kbd>
  | Enable/disable FPS counter (on stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
  | Pinch-to-zoom/rotate                        | <kbd>Ctrl</kbd>+_click-and-move_
- | Tilt vertically (slide with 2 fingers)      | <kbd>Shift</kbd>+_click-and-move_
- | Tilt horizontally (slide with 2 fingers)    | <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+_click-and-move_
+ | Tilt (slide vertically with 2 fingers)      | <kbd>Shift</kbd>+_click-and-move_
  | Drag & drop APK file                        | Install APK from computer
  | Drag & drop non-APK file                    | [Push file to device](control.md#push-file-to-device)
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
-# https://gradle.org/release-checksums/
-distributionSha256Sum=d725d707bfabd4dfdc958c624003b3c80accc03f7037b5122c4b1d0ef15cecab
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

release.mk

@@ -9,12 +9,13 @@
 # the server to the device.
 
 .PHONY: default clean \
-	test test-client test-server \
+	test \
 	build-server \
-	prepare-deps-win32 prepare-deps-win64 \
+	prepare-deps \
 	build-win32 build-win64 \
+	dist-win32 dist-win64 \
 	zip-win32 zip-win64 \
-	package release
+	release
 
 GRADLE ?= ./gradlew
 
@@ -25,7 +26,7 @@ WIN64_BUILD_DIR := build-win64
 
 VERSION ?= $(shell git describe --tags --exclude='*install-release' --always)
 
-ZIP := zip
+DIST := dist
 WIN32_TARGET_DIR := scrcpy-win32-$(VERSION)
 WIN64_TARGET_DIR := scrcpy-win64-$(VERSION)
 WIN32_TARGET := $(WIN32_TARGET_DIR).zip
@@ -33,28 +34,33 @@ WIN64_TARGET := $(WIN64_TARGET_DIR).zip
 
 RELEASE_DIR := release-$(VERSION)
 
-release: clean test build-server build-win32 build-win64 package
+release: clean test build-server zip-win32 zip-win64
+	mkdir -p "$(RELEASE_DIR)"
+	cp "$(SERVER_BUILD_DIR)/server/scrcpy-server" \
+		"$(RELEASE_DIR)/scrcpy-server-$(VERSION)"
+	cp "$(DIST)/$(WIN32_TARGET)" "$(RELEASE_DIR)"
+	cp "$(DIST)/$(WIN64_TARGET)" "$(RELEASE_DIR)"
+	cd "$(RELEASE_DIR)" && \
+		sha256sum "scrcpy-server-$(VERSION)" \
+			"scrcpy-win32-$(VERSION).zip" \
+			"scrcpy-win64-$(VERSION).zip" > SHA256SUMS.txt
+	@echo "Release generated in $(RELEASE_DIR)/"
 
 clean:
 	$(GRADLE) clean
-	rm -rf "$(ZIP)" "$(TEST_BUILD_DIR)" "$(SERVER_BUILD_DIR)" \
+	rm -rf "$(DIST)" "$(TEST_BUILD_DIR)" "$(SERVER_BUILD_DIR)" \
 		"$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)"
 
-test-client:
+test:
 	[ -d "$(TEST_BUILD_DIR)" ] || ( mkdir "$(TEST_BUILD_DIR)" && \
 		meson setup "$(TEST_BUILD_DIR)" -Db_sanitize=address )
 	ninja -C "$(TEST_BUILD_DIR)"
-
-test-server:
 	$(GRADLE) -p server check
 
-test: test-client test-server
-
 build-server:
-	$(GRADLE) -p server assembleRelease
-	mkdir -p "$(SERVER_BUILD_DIR)/server"
-	cp server/build/outputs/apk/release/server-release-unsigned.apk \
-		"$(SERVER_BUILD_DIR)/server/scrcpy-server"
+	[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
+		meson setup "$(SERVER_BUILD_DIR)" --buildtype release -Dcompile_app=false )
+	ninja -C "$(SERVER_BUILD_DIR)"
 
 prepare-deps-win32:
 	@app/deps/adb.sh win32
@@ -80,15 +86,6 @@ build-win32: prepare-deps-win32
 		-Dcompile_server=false \
 		-Dportable=true
 	ninja -C "$(WIN32_BUILD_DIR)"
-	# Group intermediate outputs into a 'dist' directory
-	mkdir -p "$(WIN32_BUILD_DIR)/dist"
-	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(WIN32_BUILD_DIR)/dist/"
-	cp app/data/scrcpy-console.bat "$(WIN32_BUILD_DIR)/dist/"
-	cp app/data/scrcpy-noconsole.vbs "$(WIN32_BUILD_DIR)/dist/"
-	cp app/data/icon.png "$(WIN32_BUILD_DIR)/dist/"
-	cp app/data/open_a_terminal_here.bat "$(WIN32_BUILD_DIR)/dist/"
-	cp app/deps/work/install/win32/bin/*.dll "$(WIN32_BUILD_DIR)/dist/"
-	cp app/deps/work/install/win32/bin/adb.exe "$(WIN32_BUILD_DIR)/dist/"
 
 build-win64: prepare-deps-win64
 	rm -rf "$(WIN64_BUILD_DIR)"
@@ -102,40 +99,33 @@ build-win64: prepare-deps-win64
 		-Dcompile_server=false \
 		-Dportable=true
 	ninja -C "$(WIN64_BUILD_DIR)"
-	# Group intermediate outputs into a 'dist' directory
-	mkdir -p "$(WIN64_BUILD_DIR)/dist"
-	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(WIN64_BUILD_DIR)/dist/"
-	cp app/data/scrcpy-console.bat "$(WIN64_BUILD_DIR)/dist/"
-	cp app/data/scrcpy-noconsole.vbs "$(WIN64_BUILD_DIR)/dist/"
-	cp app/data/icon.png "$(WIN64_BUILD_DIR)/dist/"
-	cp app/data/open_a_terminal_here.bat "$(WIN64_BUILD_DIR)/dist/"
-	cp app/deps/work/install/win64/bin/*.dll "$(WIN64_BUILD_DIR)/dist/"
-	cp app/deps/work/install/win64/bin/adb.exe "$(WIN64_BUILD_DIR)/dist/"
 
-zip-win32:
-	mkdir -p "$(ZIP)/$(WIN32_TARGET_DIR)"
-	cp -r "$(WIN32_BUILD_DIR)/dist/." "$(ZIP)/$(WIN32_TARGET_DIR)/"
-	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(ZIP)/$(WIN32_TARGET_DIR)/"
-	cd "$(ZIP)"; \
+dist-win32: build-server build-win32
+	mkdir -p "$(DIST)/$(WIN32_TARGET_DIR)"
+	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/data/scrcpy-console.bat "$(DIST)/$(WIN32_TARGET_DIR)/"
+	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/deps/work/install/win32/bin/*.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/deps/work/install/win32/bin/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
+
+dist-win64: build-server build-win64
+	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
+	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/data/scrcpy-console.bat "$(DIST)/$(WIN64_TARGET_DIR)/"
+	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/deps/work/install/win64/bin/*.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/deps/work/install/win64/bin/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
+
+zip-win32: dist-win32
+	cd "$(DIST)"; \
 		zip -r "$(WIN32_TARGET)" "$(WIN32_TARGET_DIR)"
-	rm -rf "$(ZIP)/$(WIN32_TARGET_DIR)"
 
-zip-win64:
-	mkdir -p "$(ZIP)/$(WIN64_TARGET_DIR)"
-	cp -r "$(WIN64_BUILD_DIR)/dist/." "$(ZIP)/$(WIN64_TARGET_DIR)/"
-	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(ZIP)/$(WIN64_TARGET_DIR)/"
-	cd "$(ZIP)"; \
+zip-win64: dist-win64
+	cd "$(DIST)"; \
 		zip -r "$(WIN64_TARGET)" "$(WIN64_TARGET_DIR)"
-	rm -rf "$(ZIP)/$(WIN64_TARGET_DIR)"
-
-package: zip-win32 zip-win64
-	mkdir -p "$(RELEASE_DIR)"
-	cp "$(SERVER_BUILD_DIR)/server/scrcpy-server" \
-		"$(RELEASE_DIR)/scrcpy-server-$(VERSION)"
-	cp "$(ZIP)/$(WIN32_TARGET)" "$(RELEASE_DIR)"
-	cp "$(ZIP)/$(WIN64_TARGET)" "$(RELEASE_DIR)"
-	cd "$(RELEASE_DIR)" && \
-		sha256sum "scrcpy-server-$(VERSION)" \
-			"scrcpy-win32-$(VERSION).zip" \
-			"scrcpy-win64-$(VERSION).zip" > SHA256SUMS.txt
-	@echo "Release generated in $(RELEASE_DIR)/"

server/build.gradle

@@ -2,11 +2,11 @@ apply plugin: 'com.android.application'
 
 android {
     namespace 'com.genymobile.scrcpy'
-    compileSdk 35
+    compileSdk 34
     defaultConfig {
         applicationId "com.genymobile.scrcpy"
         minSdkVersion 21
-        targetSdkVersion 35
+        targetSdkVersion 34
         versionCode 20700
         versionName "2.7"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

server/build_without_gradle.sh

@@ -14,8 +14,8 @@ set -e
 SCRCPY_DEBUG=false
 SCRCPY_VERSION_NAME=2.7
 
-PLATFORM=${ANDROID_PLATFORM:-35}
-BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-35.0.0}
+PLATFORM=${ANDROID_PLATFORM:-34}
+BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-34.0.0}
 BUILD_TOOLS_DIR="$ANDROID_HOME/build-tools/$BUILD_TOOLS"
 
 BUILD_DIR="$(realpath ${BUILD_DIR:-build_manual})"
@@ -45,10 +45,10 @@ EOF
 
 echo "Generating java from aidl..."
 cd "$SERVER_DIR/src/main/aidl"
-"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" -I. android/view/IRotationWatcher.aidl
-"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" -I. \
+"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" android/view/IRotationWatcher.aidl
+"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" \
     android/content/IOnPrimaryClipChangedListener.aidl
-"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" -I. android/view/IDisplayFoldListener.aidl
+"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" android/view/IDisplayFoldListener.aidl
 
 SRC=( \
     com/genymobile/scrcpy/*.java \

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

@@ -1,32 +0,0 @@
-package com.genymobile.scrcpy;
-
-import android.os.Build;
-
-/**
- * Android version code constants, done right.
- * <p/>
- * <a href="https://apilevels.com/">API levels</a>
- */
-public final class AndroidVersions {
-
-    private AndroidVersions() {
-        // not instantiable
-    }
-
-    public static final int API_21_ANDROID_5_0 = Build.VERSION_CODES.LOLLIPOP;
-    public static final int API_22_ANDROID_5_1 = Build.VERSION_CODES.LOLLIPOP_MR1;
-    public static final int API_23_ANDROID_6_0 = Build.VERSION_CODES.M;
-    public static final int API_24_ANDROID_7_0 = Build.VERSION_CODES.N;
-    public static final int API_25_ANDROID_7_1 = Build.VERSION_CODES.N_MR1;
-    public static final int API_26_ANDROID_8_0 = Build.VERSION_CODES.O;
-    public static final int API_27_ANDROID_8_1 = Build.VERSION_CODES.O_MR1;
-    public static final int API_28_ANDROID_9 = Build.VERSION_CODES.P;
-    public static final int API_29_ANDROID_10 = Build.VERSION_CODES.Q;
-    public static final int API_30_ANDROID_11 = Build.VERSION_CODES.R;
-    public static final int API_31_ANDROID_12 = Build.VERSION_CODES.S;
-    public static final int API_32_ANDROID_12L = Build.VERSION_CODES.S_V2;
-    public static final int API_33_ANDROID_13 = Build.VERSION_CODES.TIRAMISU;
-    public static final int API_34_ANDROID_14 = Build.VERSION_CODES.UPSIDE_DOWN_CAKE;
-    public static final int API_35_ANDROID_15 = Build.VERSION_CODES.VANILLA_ICE_CREAM;
-
-}

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

@@ -4,6 +4,7 @@ import android.annotation.TargetApi;
 import android.content.AttributionSource;
 import android.content.Context;
 import android.content.ContextWrapper;
+import android.os.Build;
 import android.os.Process;
 
 public final class FakeContext extends ContextWrapper {
@@ -31,7 +32,7 @@ public final class FakeContext extends ContextWrapper {
         return PACKAGE_NAME;
     }
 
-    @TargetApi(AndroidVersions.API_31_ANDROID_12)
+    @TargetApi(Build.VERSION_CODES.S)
     @Override
     public AttributionSource getAttributionSource() {
         AttributionSource.Builder builder = new AttributionSource.Builder(Process.SHELL_UID);

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

@@ -475,9 +475,6 @@ public class Options {
         }
         int width = Integer.parseInt(tokens[0]);
         int height = Integer.parseInt(tokens[1]);
-        if (width <= 0 || height <= 0) {
-            throw new IllegalArgumentException("Invalid non-positive size dimension: \"" + size + "\"");
-        }
         return new Size(width, height);
     }
 

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

@@ -121,7 +121,7 @@ public final class Server {
     }
 
     private static void scrcpy(Options options) throws IOException, ConfigurationException {
-        if (Build.VERSION.SDK_INT < AndroidVersions.API_31_ANDROID_12 && options.getVideoSource() == VideoSource.CAMERA) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S && options.getVideoSource() == VideoSource.CAMERA) {
             Ln.e("Camera mirroring is not supported before Android 12");
             throw new ConfigurationException("Camera mirroring is not supported");
         }

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

@@ -52,7 +52,7 @@ public final class Workarounds {
     }
 
     public static void apply() {
-        if (Build.VERSION.SDK_INT >= AndroidVersions.API_31_ANDROID_12) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             // On some Samsung devices, DisplayManagerGlobal.getDisplayInfoLocked() calls ActivityThread.currentActivityThread().getConfiguration(),
             // which requires a non-null ConfigurationController.
             // ConfigurationController was introduced in Android 12, so do not attempt to set it on lower versions.
@@ -155,7 +155,7 @@ public final class Workarounds {
         }
     }
 
-    @TargetApi(AndroidVersions.API_30_ANDROID_11)
+    @TargetApi(Build.VERSION_CODES.R)
     @SuppressLint("WrongConstant,MissingPermission")
     public static AudioRecord createAudioRecord(int source, int sampleRate, int channelConfig, int channels, int channelMask, int encoding) throws
             AudioCaptureException {
@@ -226,7 +226,7 @@ public final class Workarounds {
             int[] session = new int[]{AudioManager.AUDIO_SESSION_ID_GENERATE};
 
             int initResult;
-            if (Build.VERSION.SDK_INT < AndroidVersions.API_31_ANDROID_12) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
                 // private native final int native_setup(Object audiorecord_this,
                 // Object /*AudioAttributes*/ attributes,
                 // int[] sampleRate, int channelMask, int channelIndexMask, int audioFormat,
@@ -252,7 +252,7 @@ public final class Workarounds {
                     Method getParcelMethod = attributionSourceState.getClass().getDeclaredMethod("getParcel");
                     Parcel attributionSourceParcel = (Parcel) getParcelMethod.invoke(attributionSourceState);
 
-                    if (Build.VERSION.SDK_INT < AndroidVersions.API_34_ANDROID_14) {
+                    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
                         // private native int native_setup(Object audiorecordThis,
                         // Object /*AudioAttributes*/ attributes,
                         // int[] sampleRate, int channelMask, int channelIndexMask, int audioFormat,

server/src/main/java/com/genymobile/scrcpy/audio/AudioDirectCapture.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.audio;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.FakeContext;
 import com.genymobile.scrcpy.Workarounds;
 import com.genymobile.scrcpy.util.Ln;
@@ -46,11 +45,11 @@ public class AudioDirectCapture implements AudioCapture {
         }
     }
 
-    @TargetApi(AndroidVersions.API_23_ANDROID_6_0)
+    @TargetApi(Build.VERSION_CODES.M)
     @SuppressLint({"WrongConstant", "MissingPermission"})
     private static AudioRecord createAudioRecord(int audioSource) {
         AudioRecord.Builder builder = new AudioRecord.Builder();
-        if (Build.VERSION.SDK_INT >= AndroidVersions.API_31_ANDROID_12) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             // On older APIs, Workarounds.fillAppInfo() must be called beforehand
             builder.setContext(FakeContext.get());
         }
@@ -118,7 +117,7 @@ public class AudioDirectCapture implements AudioCapture {
 
     @Override
     public void checkCompatibility() throws AudioCaptureException {
-        if (Build.VERSION.SDK_INT < AndroidVersions.API_30_ANDROID_11) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
             Ln.w("Audio disabled: it is not supported before Android 11");
             throw new AudioCaptureException();
         }
@@ -126,7 +125,7 @@ public class AudioDirectCapture implements AudioCapture {
 
     @Override
     public void start() throws AudioCaptureException {
-        if (Build.VERSION.SDK_INT == AndroidVersions.API_30_ANDROID_11) {
+        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
             startWorkaroundAndroid11();
             try {
                 tryStartRecording(5, 100);
@@ -147,7 +146,7 @@ public class AudioDirectCapture implements AudioCapture {
     }
 
     @Override
-    @TargetApi(AndroidVersions.API_24_ANDROID_7_0)
+    @TargetApi(Build.VERSION_CODES.N)
     public int read(ByteBuffer outDirectBuffer, MediaCodec.BufferInfo outBufferInfo) {
         return reader.read(outDirectBuffer, outBufferInfo);
     }

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

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.audio;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.AsyncProcessor;
 import com.genymobile.scrcpy.device.ConfigurationException;
 import com.genymobile.scrcpy.device.Streamer;
@@ -94,7 +93,7 @@ public final class AudioEncoder implements AsyncProcessor {
         return format;
     }
 
-    @TargetApi(AndroidVersions.API_24_ANDROID_7_0)
+    @TargetApi(Build.VERSION_CODES.N)
     private void inputThread(MediaCodec mediaCodec, AudioCapture capture) throws IOException, InterruptedException {
         final MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
 
@@ -176,9 +175,9 @@ public final class AudioEncoder implements AsyncProcessor {
         }
     }
 
-    @TargetApi(AndroidVersions.API_23_ANDROID_6_0)
+    @TargetApi(Build.VERSION_CODES.M)
     private void encode() throws IOException, ConfigurationException, AudioCaptureException {
-        if (Build.VERSION.SDK_INT < AndroidVersions.API_30_ANDROID_11) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
             Ln.w("Audio disabled: it is not supported before Android 11");
             streamer.writeDisableStream(false);
             return;
@@ -315,7 +314,7 @@ public final class AudioEncoder implements AsyncProcessor {
     }
 
     private final class EncoderCallback extends MediaCodec.Callback {
-        @TargetApi(AndroidVersions.API_24_ANDROID_7_0)
+        @TargetApi(Build.VERSION_CODES.N)
         @Override
         public void onInputBufferAvailable(MediaCodec codec, int index) {
             try {

server/src/main/java/com/genymobile/scrcpy/audio/AudioPlaybackCapture.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.audio;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.FakeContext;
 import com.genymobile.scrcpy.util.Ln;
 
@@ -109,7 +108,7 @@ public final class AudioPlaybackCapture implements AudioCapture {
 
     @Override
     public void checkCompatibility() throws AudioCaptureException {
-        if (Build.VERSION.SDK_INT < AndroidVersions.API_33_ANDROID_13) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
             Ln.w("Audio disabled: audio playback capture source not supported before Android 13");
             throw new AudioCaptureException();
         }
@@ -131,7 +130,7 @@ public final class AudioPlaybackCapture implements AudioCapture {
     }
 
     @Override
-    @TargetApi(AndroidVersions.API_24_ANDROID_7_0)
+    @TargetApi(Build.VERSION_CODES.N)
     public int read(ByteBuffer outDirectBuffer, MediaCodec.BufferInfo outBufferInfo) {
         return reader.read(outDirectBuffer, outBufferInfo);
     }

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

@@ -1,10 +1,9 @@
 package com.genymobile.scrcpy.audio;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.AsyncProcessor;
-import com.genymobile.scrcpy.device.Streamer;
 import com.genymobile.scrcpy.util.IO;
 import com.genymobile.scrcpy.util.Ln;
+import com.genymobile.scrcpy.device.Streamer;
 
 import android.media.MediaCodec;
 import android.os.Build;
@@ -25,7 +24,7 @@ public final class AudioRawRecorder implements AsyncProcessor {
     }
 
     private void record() throws IOException, AudioCaptureException {
-        if (Build.VERSION.SDK_INT < AndroidVersions.API_30_ANDROID_11) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
             Ln.w("Audio disabled: it is not supported before Android 11");
             streamer.writeDisableStream(false);
             return;

server/src/main/java/com/genymobile/scrcpy/audio/AudioRecordReader.java

@@ -1,12 +1,12 @@
 package com.genymobile.scrcpy.audio;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.util.Ln;
 
 import android.annotation.TargetApi;
 import android.media.AudioRecord;
 import android.media.AudioTimestamp;
 import android.media.MediaCodec;
+import android.os.Build;
 
 import java.nio.ByteBuffer;
 
@@ -26,7 +26,7 @@ public class AudioRecordReader {
         this.recorder = recorder;
     }
 
-    @TargetApi(AndroidVersions.API_24_ANDROID_7_0)
+    @TargetApi(Build.VERSION_CODES.N)
     public int read(ByteBuffer outDirectBuffer, MediaCodec.BufferInfo outBufferInfo) {
         int r = recorder.read(outDirectBuffer, AudioConfig.MAX_READ_SIZE);
         if (r <= 0) {

server/src/main/java/com/genymobile/scrcpy/control/ControlMessageReader.java

@@ -1,7 +1,7 @@
 package com.genymobile.scrcpy.control;
 
-import com.genymobile.scrcpy.device.Position;
 import com.genymobile.scrcpy.util.Binary;
+import com.genymobile.scrcpy.device.Position;
 
 import java.io.BufferedInputStream;
 import java.io.DataInputStream;

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

@@ -1,12 +1,11 @@
 package com.genymobile.scrcpy.control;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.AsyncProcessor;
 import com.genymobile.scrcpy.CleanUp;
 import com.genymobile.scrcpy.device.Device;
+import com.genymobile.scrcpy.util.Ln;
 import com.genymobile.scrcpy.device.Point;
 import com.genymobile.scrcpy.device.Position;
-import com.genymobile.scrcpy.util.Ln;
 import com.genymobile.scrcpy.wrappers.InputManager;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 
@@ -319,7 +318,7 @@ public class Controller implements AsyncProcessor {
          *
          * Otherwise, Chrome does not work properly: <https://github.com/Genymobile/scrcpy/issues/3635>
          */
-        if (Build.VERSION.SDK_INT >= AndroidVersions.API_23_ANDROID_6_0 && source == InputDevice.SOURCE_MOUSE) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && source == InputDevice.SOURCE_MOUSE) {
             if (action == MotionEvent.ACTION_DOWN) {
                 if (actionButton == buttons) {
                     // First button pressed: ACTION_DOWN
@@ -424,7 +423,7 @@ public class Controller implements AsyncProcessor {
 
     private void getClipboard(int copyKey) {
         // On Android >= 7, press the COPY or CUT key if requested
-        if (copyKey != ControlMessage.COPY_KEY_NONE && Build.VERSION.SDK_INT >= AndroidVersions.API_24_ANDROID_7_0 && device.supportsInputEvents()) {
+        if (copyKey != ControlMessage.COPY_KEY_NONE && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && device.supportsInputEvents()) {
             int key = copyKey == ControlMessage.COPY_KEY_COPY ? KeyEvent.KEYCODE_COPY : KeyEvent.KEYCODE_CUT;
             // Wait until the event is finished, to ensure that the clipboard text we read just after is the correct one
             device.pressReleaseKeycode(key, Device.INJECT_MODE_WAIT_FOR_FINISH);
@@ -449,7 +448,7 @@ public class Controller implements AsyncProcessor {
         }
 
         // On Android >= 7, also press the PASTE key if requested
-        if (paste && Build.VERSION.SDK_INT >= AndroidVersions.API_24_ANDROID_7_0 && device.supportsInputEvents()) {
+        if (paste && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && device.supportsInputEvents()) {
             device.pressReleaseKeycode(KeyEvent.KEYCODE_PASTE, Device.INJECT_MODE_ASYNC);
         }
 

server/src/main/java/com/genymobile/scrcpy/control/UhidManager.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.control;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.util.Ln;
 import com.genymobile.scrcpy.util.StringUtils;
 
@@ -39,7 +38,7 @@ public final class UhidManager {
 
     public UhidManager(DeviceMessageSender sender) {
         this.sender = sender;
-        if (Build.VERSION.SDK_INT >= AndroidVersions.API_23_ANDROID_6_0) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             HandlerThread thread = new HandlerThread("UHidManager");
             thread.start();
             queue = thread.getLooper().getQueue();
@@ -72,7 +71,7 @@ public final class UhidManager {
     }
 
     private void registerUhidListener(int id, FileDescriptor fd) {
-        if (Build.VERSION.SDK_INT >= AndroidVersions.API_23_ANDROID_6_0) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             queue.addOnFileDescriptorEventListener(fd, MessageQueue.OnFileDescriptorEventListener.EVENT_INPUT, (fd2, events) -> {
                 try {
                     buffer.clear();
@@ -98,7 +97,7 @@ public final class UhidManager {
     }
 
     private void unregisterUhidListener(FileDescriptor fd) {
-        if (Build.VERSION.SDK_INT >= AndroidVersions.API_23_ANDROID_6_0) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             queue.removeOnFileDescriptorEventListener(fd);
         }
     }

server/src/main/java/com/genymobile/scrcpy/device/Device.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.device;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.Options;
 import com.genymobile.scrcpy.util.Ln;
 import com.genymobile.scrcpy.util.LogUtils;
@@ -105,7 +104,7 @@ public final class Device {
             }
         }, displayId);
 
-        if (Build.VERSION.SDK_INT >= AndroidVersions.API_29_ANDROID_10) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             ServiceManager.getWindowManager().registerDisplayFoldListener(new IDisplayFoldListener.Stub() {
                 @Override
                 public void onDisplayFoldChanged(int displayId, boolean folded) {
@@ -162,8 +161,8 @@ public final class Device {
             Ln.w("Display doesn't have FLAG_SUPPORTS_PROTECTED_BUFFERS flag, mirroring can be restricted");
         }
 
-        // main display or any display on Android >= 10
-        supportsInputEvents = displayId == 0 || Build.VERSION.SDK_INT >= AndroidVersions.API_29_ANDROID_10;
+        // main display or any display on Android >= Q
+        supportsInputEvents = displayId == 0 || Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q;
         if (!supportsInputEvents) {
             Ln.w("Input events are not supported for secondary displays before Android 10");
         }
@@ -216,7 +215,7 @@ public final class Device {
     }
 
     public static boolean supportsInputEvents(int displayId) {
-        return displayId == 0 || Build.VERSION.SDK_INT >= AndroidVersions.API_29_ANDROID_10;
+        return displayId == 0 || Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q;
     }
 
     public boolean supportsInputEvents() {
@@ -324,10 +323,10 @@ public final class Device {
      * @param mode one of the {@code POWER_MODE_*} constants
      */
     public static boolean setScreenPowerMode(int mode) {
-        boolean applyToMultiPhysicalDisplays = Build.VERSION.SDK_INT >= AndroidVersions.API_29_ANDROID_10;
+        boolean applyToMultiPhysicalDisplays = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q;
 
         if (applyToMultiPhysicalDisplays
-                && Build.VERSION.SDK_INT >= AndroidVersions.API_34_ANDROID_14
+                && Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
                 && Build.BRAND.equalsIgnoreCase("honor")
                 && SurfaceControl.hasGetBuildInDisplayMethod()) {
             // Workaround for Honor devices with Android 14:
@@ -339,7 +338,7 @@ public final class Device {
         if (applyToMultiPhysicalDisplays) {
             // On Android 14, these internal methods have been moved to DisplayControl
             boolean useDisplayControl =
-                    Build.VERSION.SDK_INT >= AndroidVersions.API_34_ANDROID_14 && !SurfaceControl.hasGetPhysicalDisplayIdsMethod();
+                    Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE && !SurfaceControl.hasGetPhysicalDisplayIdsMethod();
 
             // Change the power mode for all physical displays
             long[] physicalDisplayIds = useDisplayControl ? DisplayControl.getPhysicalDisplayIds() : SurfaceControl.getPhysicalDisplayIds();

server/src/main/java/com/genymobile/scrcpy/util/IO.java

@@ -1,9 +1,7 @@
 package com.genymobile.scrcpy.util;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.BuildConfig;
 
-import android.os.Build;
 import android.system.ErrnoException;
 import android.system.Os;
 import android.system.OsConstants;
@@ -19,38 +17,23 @@ public final class IO {
         // not instantiable
     }
 
-    private static int write(FileDescriptor fd, ByteBuffer from) throws IOException {
-        while (true) {
-            try {
-                return Os.write(fd, from);
-            } catch (ErrnoException e) {
-                if (e.errno != OsConstants.EINTR) {
-                    throw new IOException(e);
-                }
-            }
-        }
-    }
-
     public static void writeFully(FileDescriptor fd, ByteBuffer from) throws IOException {
-        if (Build.VERSION.SDK_INT >= AndroidVersions.API_23_ANDROID_6_0) {
-            while (from.hasRemaining()) {
-                write(fd, from);
-            }
-        } else {
-            // ByteBuffer position is not updated as expected by Os.write() on old Android versions, so
-            // handle the position and the remaining bytes manually.
-            // See <https://github.com/Genymobile/scrcpy/issues/291>.
-            int position = from.position();
-            int remaining = from.remaining();
-            while (remaining > 0) {
-                int w = write(fd, from);
+        // ByteBuffer position is not updated as expected by Os.write() on old Android versions, so
+        // count the remaining bytes manually.
+        // See <https://github.com/Genymobile/scrcpy/issues/291>.
+        int remaining = from.remaining();
+        while (remaining > 0) {
+            try {
+                int w = Os.write(fd, from);
                 if (BuildConfig.DEBUG && w < 0) {
                     // w should not be negative, since an exception is thrown on error
                     throw new AssertionError("Os.write() returned a negative value (" + w + ")");
                 }
                 remaining -= w;
-                position += w;
-                from.position(position);
+            } catch (ErrnoException e) {
+                if (e.errno != OsConstants.EINTR) {
+                    throw new IOException(e);
+                }
             }
         }
     }

server/src/main/java/com/genymobile/scrcpy/util/LogUtils.java

@@ -31,7 +31,7 @@ public final class LogUtils {
         } else {
             for (CodecUtils.DeviceEncoder encoder : videoEncoders) {
                 builder.append("\n    --video-codec=").append(encoder.getCodec().getName());
-                builder.append(" --video-encoder=").append(encoder.getInfo().getName());
+                builder.append(" --video-encoder='").append(encoder.getInfo().getName()).append("'");
             }
         }
         return builder.toString();
@@ -45,7 +45,7 @@ public final class LogUtils {
         } else {
             for (CodecUtils.DeviceEncoder encoder : audioEncoders) {
                 builder.append("\n    --audio-codec=").append(encoder.getCodec().getName());
-                builder.append(" --audio-encoder=").append(encoder.getInfo().getName());
+                builder.append(" --audio-encoder='").append(encoder.getInfo().getName()).append("'");
             }
         }
         return builder.toString();

server/src/main/java/com/genymobile/scrcpy/util/Settings.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.util;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.wrappers.ContentProvider;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 
@@ -35,7 +34,7 @@ public final class Settings {
     }
 
     public static String getValue(String table, String key) throws SettingsException {
-        if (Build.VERSION.SDK_INT <= AndroidVersions.API_30_ANDROID_11) {
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
             // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
             try (ContentProvider provider = ServiceManager.getActivityManager().createSettingsProvider()) {
                 return provider.getValue(table, key);
@@ -48,7 +47,7 @@ public final class Settings {
     }
 
     public static void putValue(String table, String key, String value) throws SettingsException {
-        if (Build.VERSION.SDK_INT <= AndroidVersions.API_30_ANDROID_11) {
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
             // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
             try (ContentProvider provider = ServiceManager.getActivityManager().createSettingsProvider()) {
                 provider.putValue(table, key, value);
@@ -61,7 +60,7 @@ public final class Settings {
     }
 
     public static String getAndPutValue(String table, String key, String value) throws SettingsException {
-        if (Build.VERSION.SDK_INT <= AndroidVersions.API_30_ANDROID_11) {
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
             // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
             try (ContentProvider provider = ServiceManager.getActivityManager().createSettingsProvider()) {
                 String oldValue = provider.getValue(table, key);

server/src/main/java/com/genymobile/scrcpy/video/CameraCapture.java

@@ -1,9 +1,8 @@
 package com.genymobile.scrcpy.video;
 
-import com.genymobile.scrcpy.AndroidVersions;
-import com.genymobile.scrcpy.device.Size;
 import com.genymobile.scrcpy.util.HandlerExecutor;
 import com.genymobile.scrcpy.util.Ln;
+import com.genymobile.scrcpy.device.Size;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 
 import android.annotation.SuppressLint;
@@ -21,6 +20,7 @@ import android.hardware.camera2.params.OutputConfiguration;
 import android.hardware.camera2.params.SessionConfiguration;
 import android.hardware.camera2.params.StreamConfigurationMap;
 import android.media.MediaCodec;
+import android.os.Build;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.util.Range;
@@ -118,7 +118,7 @@ public class CameraCapture extends SurfaceCapture {
         return null;
     }
 
-    @TargetApi(AndroidVersions.API_24_ANDROID_7_0)
+    @TargetApi(Build.VERSION_CODES.N)
     private static Size selectSize(String cameraId, Size explicitSize, int maxSize, CameraAspectRatio aspectRatio, boolean highSpeed)
             throws CameraAccessException {
         if (explicitSize != null) {
@@ -242,7 +242,7 @@ public class CameraCapture extends SurfaceCapture {
     }
 
     @SuppressLint("MissingPermission")
-    @TargetApi(AndroidVersions.API_31_ANDROID_12)
+    @TargetApi(Build.VERSION_CODES.S)
     private CameraDevice openCamera(String id) throws CameraAccessException, InterruptedException {
         CompletableFuture<CameraDevice> future = new CompletableFuture<>();
         ServiceManager.getCameraManager().openCamera(id, new CameraDevice.StateCallback() {
@@ -289,7 +289,7 @@ public class CameraCapture extends SurfaceCapture {
         }
     }
 
-    @TargetApi(AndroidVersions.API_31_ANDROID_12)
+    @TargetApi(Build.VERSION_CODES.S)
     private CameraCaptureSession createCaptureSession(CameraDevice camera, Surface surface) throws CameraAccessException, InterruptedException {
         CompletableFuture<CameraCaptureSession> future = new CompletableFuture<>();
         OutputConfiguration outputConfig = new OutputConfiguration(surface);
@@ -328,7 +328,7 @@ public class CameraCapture extends SurfaceCapture {
         return requestBuilder.build();
     }
 
-    @TargetApi(AndroidVersions.API_31_ANDROID_12)
+    @TargetApi(Build.VERSION_CODES.S)
     private void setRepeatingRequest(CameraCaptureSession session, CaptureRequest request) throws CameraAccessException, InterruptedException {
         CameraCaptureSession.CaptureCallback callback = new CameraCaptureSession.CaptureCallback() {
             @Override

server/src/main/java/com/genymobile/scrcpy/video/ScreenCapture.java

@@ -1,9 +1,8 @@
 package com.genymobile.scrcpy.video;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.device.Device;
-import com.genymobile.scrcpy.device.Size;
 import com.genymobile.scrcpy.util.Ln;
+import com.genymobile.scrcpy.device.Size;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 import com.genymobile.scrcpy.wrappers.SurfaceControl;
 
@@ -104,8 +103,8 @@ public class ScreenCapture extends SurfaceCapture implements Device.RotationList
     private static IBinder createDisplay() throws Exception {
         // Since Android 12 (preview), secure displays could not be created with shell permissions anymore.
         // On Android 12 preview, SDK_INT is still R (not S), but CODENAME is "S".
-        boolean secure = Build.VERSION.SDK_INT < AndroidVersions.API_30_ANDROID_11 || (Build.VERSION.SDK_INT == AndroidVersions.API_30_ANDROID_11
-                && !"S".equals(Build.VERSION.CODENAME));
+        boolean secure = Build.VERSION.SDK_INT < Build.VERSION_CODES.R || (Build.VERSION.SDK_INT == Build.VERSION_CODES.R && !"S".equals(
+                Build.VERSION.CODENAME));
         return SurfaceControl.createDisplay("scrcpy", secure);
     }
 

server/src/main/java/com/genymobile/scrcpy/video/ScreenInfo.java

@@ -2,8 +2,8 @@ package com.genymobile.scrcpy.video;
 
 import com.genymobile.scrcpy.BuildConfig;
 import com.genymobile.scrcpy.device.Device;
-import com.genymobile.scrcpy.device.Size;
 import com.genymobile.scrcpy.util.Ln;
+import com.genymobile.scrcpy.device.Size;
 
 import android.graphics.Rect;
 

server/src/main/java/com/genymobile/scrcpy/video/SurfaceEncoder.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.video;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.AsyncProcessor;
 import com.genymobile.scrcpy.device.ConfigurationException;
 import com.genymobile.scrcpy.device.Size;
@@ -239,7 +238,7 @@ public class SurfaceEncoder implements AsyncProcessor {
         // must be present to configure the encoder, but does not impact the actual frame rate, which is variable
         format.setInteger(MediaFormat.KEY_FRAME_RATE, 60);
         format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
-        if (Build.VERSION.SDK_INT >= AndroidVersions.API_24_ANDROID_7_0) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
             format.setInteger(MediaFormat.KEY_COLOR_RANGE, MediaFormat.COLOR_RANGE_LIMITED);
         }
         format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, DEFAULT_I_FRAME_INTERVAL);

server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.wrappers;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.FakeContext;
 import com.genymobile.scrcpy.util.Ln;
 
@@ -8,6 +7,7 @@ import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.content.Intent;
 import android.os.Binder;
+import android.os.Build;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.os.IInterface;
@@ -63,7 +63,7 @@ public final class ActivityManager {
         return removeContentProviderExternalMethod;
     }
 
-    @TargetApi(AndroidVersions.API_29_ANDROID_10)
+    @TargetApi(Build.VERSION_CODES.Q)
     private ContentProvider getContentProviderExternal(String name, IBinder token) {
         try {
             Method method = getGetContentProviderExternalMethod();

server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.wrappers;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.FakeContext;
 import com.genymobile.scrcpy.util.Ln;
 
@@ -37,7 +36,7 @@ public final class ClipboardManager {
 
     private Method getGetPrimaryClipMethod() throws NoSuchMethodException {
         if (getPrimaryClipMethod == null) {
-            if (Build.VERSION.SDK_INT < AndroidVersions.API_29_ANDROID_10) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                 getPrimaryClipMethod = manager.getClass().getMethod("getPrimaryClip", String.class);
                 return getPrimaryClipMethod;
             }
@@ -100,7 +99,7 @@ public final class ClipboardManager {
 
     private Method getSetPrimaryClipMethod() throws NoSuchMethodException {
         if (setPrimaryClipMethod == null) {
-            if (Build.VERSION.SDK_INT < AndroidVersions.API_29_ANDROID_10) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                 setPrimaryClipMethod = manager.getClass().getMethod("setPrimaryClip", ClipData.class, String.class);
                 return setPrimaryClipMethod;
             }
@@ -138,7 +137,7 @@ public final class ClipboardManager {
     }
 
     private static ClipData getPrimaryClip(Method method, int methodVersion, IInterface manager) throws ReflectiveOperationException {
-        if (Build.VERSION.SDK_INT < AndroidVersions.API_29_ANDROID_10) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
             return (ClipData) method.invoke(manager, FakeContext.PACKAGE_NAME);
         }
 
@@ -162,7 +161,7 @@ public final class ClipboardManager {
     }
 
     private static void setPrimaryClip(Method method, int methodVersion, IInterface manager, ClipData clipData) throws ReflectiveOperationException {
-        if (Build.VERSION.SDK_INT < AndroidVersions.API_29_ANDROID_10) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
             method.invoke(manager, clipData, FakeContext.PACKAGE_NAME);
             return;
         }
@@ -211,7 +210,7 @@ public final class ClipboardManager {
 
     private static void addPrimaryClipChangedListener(Method method, int methodVersion, IInterface manager, IOnPrimaryClipChangedListener listener)
             throws ReflectiveOperationException {
-        if (Build.VERSION.SDK_INT < AndroidVersions.API_29_ANDROID_10) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
             method.invoke(manager, listener, FakeContext.PACKAGE_NAME);
             return;
         }
@@ -231,7 +230,7 @@ public final class ClipboardManager {
 
     private Method getAddPrimaryClipChangedListener() throws NoSuchMethodException {
         if (addPrimaryClipChangedListener == null) {
-            if (Build.VERSION.SDK_INT < AndroidVersions.API_29_ANDROID_10) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                 addPrimaryClipChangedListener = manager.getClass()
                         .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class);
             } else {

server/src/main/java/com/genymobile/scrcpy/wrappers/ContentProvider.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.wrappers;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.FakeContext;
 import com.genymobile.scrcpy.util.Ln;
 import com.genymobile.scrcpy.util.SettingsException;
@@ -52,7 +51,7 @@ public final class ContentProvider implements Closeable {
     @SuppressLint("PrivateApi")
     private Method getCallMethod() throws NoSuchMethodException {
         if (callMethod == null) {
-            if (Build.VERSION.SDK_INT >= AndroidVersions.API_31_ANDROID_12) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                 callMethod = provider.getClass().getMethod("call", AttributionSource.class, String.class, String.class, String.class, Bundle.class);
                 callMethodVersion = 0;
             } else {
@@ -80,7 +79,7 @@ public final class ContentProvider implements Closeable {
             Method method = getCallMethod();
             Object[] args;
 
-            if (Build.VERSION.SDK_INT >= AndroidVersions.API_31_ANDROID_12 && callMethodVersion == 0) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && callMethodVersion == 0) {
                 args = new Object[]{FakeContext.get().getAttributionSource(), "settings", callMethod, arg, extras};
             } else {
                 switch (callMethodVersion) {

server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayControl.java

@@ -1,16 +1,16 @@
 package com.genymobile.scrcpy.wrappers;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.util.Ln;
 
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
+import android.os.Build;
 import android.os.IBinder;
 
 import java.lang.reflect.Method;
 
 @SuppressLint({"PrivateApi", "SoonBlockedPrivateApi", "BlockedPrivateApi"})
-@TargetApi(AndroidVersions.API_34_ANDROID_14)
+@TargetApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
 public final class DisplayControl {
 
     private static final Class<?> CLASS;

server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayManager.java

@@ -1,9 +1,9 @@
 package com.genymobile.scrcpy.wrappers;
 
-import com.genymobile.scrcpy.device.DisplayInfo;
-import com.genymobile.scrcpy.device.Size;
 import com.genymobile.scrcpy.util.Command;
+import com.genymobile.scrcpy.device.DisplayInfo;
 import com.genymobile.scrcpy.util.Ln;
+import com.genymobile.scrcpy.device.Size;
 
 import android.annotation.SuppressLint;
 import android.hardware.display.VirtualDisplay;

server/src/main/java/com/genymobile/scrcpy/wrappers/PowerManager.java

@@ -2,6 +2,8 @@ package com.genymobile.scrcpy.wrappers;
 
 import com.genymobile.scrcpy.util.Ln;
 
+import android.annotation.SuppressLint;
+import android.os.Build;
 import android.os.IInterface;
 
 import java.lang.reflect.Method;
@@ -21,7 +23,9 @@ public final class PowerManager {
 
     private Method getIsScreenOnMethod() throws NoSuchMethodException {
         if (isScreenOnMethod == null) {
-            isScreenOnMethod = manager.getClass().getMethod("isInteractive");
+            @SuppressLint("ObsoleteSdkInt") // we may lower minSdkVersion in the future
+            String methodName = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH ? "isInteractive" : "isScreenOn";
+            isScreenOnMethod = manager.getClass().getMethod(methodName);
         }
         return isScreenOnMethod;
     }

server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.wrappers;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.util.Ln;
 
 import android.annotation.SuppressLint;
@@ -84,9 +83,9 @@ public final class SurfaceControl {
 
     private static Method getGetBuiltInDisplayMethod() throws NoSuchMethodException {
         if (getBuiltInDisplayMethod == null) {
-            // the method signature has changed in Android 10
+            // the method signature has changed in Android Q
             // <https://github.com/Genymobile/scrcpy/issues/586>
-            if (Build.VERSION.SDK_INT < AndroidVersions.API_29_ANDROID_10) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                 getBuiltInDisplayMethod = CLASS.getMethod("getBuiltInDisplay", int.class);
             } else {
                 getBuiltInDisplayMethod = CLASS.getMethod("getInternalDisplayToken");
@@ -107,7 +106,7 @@ public final class SurfaceControl {
     public static IBinder getBuiltInDisplay() {
         try {
             Method method = getGetBuiltInDisplayMethod();
-            if (Build.VERSION.SDK_INT < AndroidVersions.API_29_ANDROID_10) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                 // call getBuiltInDisplay(0)
                 return (IBinder) method.invoke(null, 0);
             }

server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java

@@ -1,6 +1,5 @@
 package com.genymobile.scrcpy.wrappers;
 
-import com.genymobile.scrcpy.AndroidVersions;
 import com.genymobile.scrcpy.util.Ln;
 
 import android.annotation.TargetApi;
@@ -201,7 +200,7 @@ public final class WindowManager {
         }
     }
 
-    @TargetApi(AndroidVersions.API_29_ANDROID_10)
+    @TargetApi(29)
     public void registerDisplayFoldListener(IDisplayFoldListener foldListener) {
         try {
             Class<?> cls = manager.getClass();