Reintroduce WinGet install note

Semantically reverts c27ab46efb. WinGet package has been fixed by: <https://github.com/microsoft/winget-pkgs/pull/196442> Refs #4027 <https://github.com/Genymobile/scrcpy/issues/4027> PR #5686 <https://github.com/Genymobile/scrcpy/pull/5686> Signed-off-by: Romain Vimont <rom@rom1v.com>
2026-02-24 07:14:29 +01:00 · 2024-12-19 09:38:26 +01:00
215 changed files with 3067 additions and 4404 deletions
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -72,33 +72,18 @@ jobs:
      - name: Checkout code
        uses: actions/checkout@v4

-        # Same as build-linux-x86_64
      - name: Install dependencies
        run: |
-          sudo apt update
-          sudo apt install -y meson ninja-build nasm ffmpeg libavcodec-dev \
-             libavdevice-dev libavformat-dev libavutil-dev libswresample-dev \
-             libusb-1.0-0 libusb-1.0-0-dev libv4l-dev \
-             libasound2-dev libpulse-dev \
-             libaudio-dev libfribidi-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
-             libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxtst-dev \
-             libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev libgles2-mesa-dev \
-             libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev libthai-dev \
-             libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev
-
-        # SDL3 is not available in Ubuntu yet
-      - name: Install SDL3
-        run: |
-          app/deps/sdl.sh linux native shared
+          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 \
+             libv4l-dev

      - name: Test
-        run: |
-          export PKG_CONFIG_PATH="$PWD"/app/deps/work/install/linux-native-shared/lib/pkgconfig
-          export LD_LIBRARY_PATH="$PWD"/app/deps/work/install/linux-native-shared/lib
-          release/test_client.sh
+        run: release/test_client.sh

  build-linux-x86_64:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
    steps:
      - name: Check architecture
        run: |
@@ -112,19 +97,12 @@ jobs:
      - name: Checkout code
        uses: actions/checkout@v4

-        # https://wiki.libsdl.org/SDL3/README-linux#build-dependencies
      - name: Install dependencies
        run: |
-          sudo apt update
-          sudo apt install -y meson ninja-build nasm ffmpeg libavcodec-dev \
-             libavdevice-dev libavformat-dev libavutil-dev libswresample-dev \
-             libusb-1.0-0 libusb-1.0-0-dev libv4l-dev \
-             libasound2-dev libpulse-dev \
-             libaudio-dev libfribidi-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
-             libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxtst-dev \
-             libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev libgles2-mesa-dev \
-             libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev libthai-dev \
-             libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev
+          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 \
+             libv4l-dev

      - name: Build
        run: release/build_linux.sh x86_64
@@ -151,10 +129,14 @@ jobs:

      - name: Install dependencies
        run: |
-          sudo apt update
-          sudo apt install -y meson ninja-build nasm \
+          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
        run: release/build_windows.sh 32

@@ -180,10 +162,14 @@ jobs:

      - name: Install dependencies
        run: |
-          sudo apt update
-          sudo apt install -y meson ninja-build nasm \
+          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
        run: release/build_windows.sh 64

@@ -218,16 +204,10 @@ jobs:

      - name: Install dependencies
        run: |
-            brew install meson nasm libiconv zlib automake autoconf libtool
+            brew install meson ninja nasm libiconv zlib automake autoconf \
+                libtool

      - name: Build
-        env:
-          # the default Xcode (and macOS SDK) version can be found at
-          # <https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md#xcode>
-          #
-          # then the minimal supported deployment target of that macOS SDK can be found at
-          # <https://developer.apple.com/support/xcode/#minimum-requirements>
-          MACOSX_DEPLOYMENT_TARGET: 10.13
        run: release/build_macos.sh aarch64

      # upload-artifact does not preserve permissions
@@ -245,7 +225,7 @@ jobs:
          path: release/work/build-macos-aarch64/dist-tar/

  build-macos-x86_64:
-    runs-on: macos-15-intel
+    runs-on: macos-13
    steps:
      - name: Check architecture
        run: |
@@ -260,17 +240,10 @@ jobs:
        uses: actions/checkout@v4

      - name: Install dependencies
-        run: brew install meson nasm libiconv zlib automake
+        run: brew install meson ninja nasm libiconv zlib automake
             # autoconf and libtool are already installed on macos-13

      - name: Build
-        env:
-          # the default Xcode (and macOS SDK) version can be found at
-          # <https://github.com/actions/runner-images/blob/main/images/macos/macos-13-Readme.md#xcode>
-          #
-          # then the minimal supported deployment target of that macOS SDK can be found at
-          # <https://developer.apple.com/support/xcode/#minimum-requirements>
-          MACOSX_DEPLOYMENT_TARGET: 10.13
        run: release/build_macos.sh x86_64

      # upload-artifact does not preserve permissions
--- a/FAQ.md
+++ b/FAQ.md
@@ -166,13 +166,14 @@ Rebooting the device is necessary once this option is set.

 ### Special characters do not work

-The default text injection method is limited to ASCII characters. A trick allows
-to also inject some [accented characters][accented-characters],
+The default text injection method is [limited to ASCII characters][text-input].
+A trick allows to also inject some [accented characters][accented-characters],
 but that's all. See [#37].

 To avoid the problem, [change the keyboard mode to simulate a physical
 keyboard][hid].

+[text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
 [accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
 [#37]: https://github.com/Genymobile/scrcpy/issues/37
 [hid]: doc/keyboard.md#physical-keyboard-simulation
--- a/2
+++ b/2
@@ -188,7 +188,7 @@
      identification within third-party archives.

   Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2025 Romain Vimont
+   Copyright (C) 2018-2024 Romain Vimont

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
--- a/README.md
+++ b/README.md
@@ -2,16 +2,16 @@
 source for the project. Do not download releases from random websites, even if
 their name contains `scrcpy`.**

-# scrcpy (v3.3.4)
+# scrcpy (v3.1)

 <img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />

 _pronounced "**scr**een **c**o**py**"_

-This application mirrors Android devices (video and audio) connected via USB or
-[TCP/IP](doc/connection.md#tcpip-wireless) and allows control using the
-computer's keyboard and mouse. It does not require _root_ access or an app
-installed on the device. It works on _Linux_, _Windows_, and _macOS_.
+This application mirrors Android devices (video and audio) connected via
+USB or [over TCP/IP](doc/connection.md#tcpip-wireless), and allows to control the
+device with the keyboard and the mouse of the computer. It does not require any
+_root_ access. It works on _Linux_, _Windows_ and _macOS_.

 ![screenshot](assets/screenshot-debian-600.jpg)

@@ -58,7 +58,7 @@ Make sure you [enabled USB debugging][enable-adb] on your device(s).
 On some devices (especially Xiaomi), you might get the following error:

 ```
-Injecting input events requires the caller (or the source of the instrumentation, if any) to have the INJECT_EVENTS permission.
+java.lang.SecurityException: Injecting input events requires the caller (or the source of the instrumentation, if any) to have the INJECT_EVENTS permission.
 ```

 In that case, you need to enable [an additional option][control] `USB debugging
@@ -129,7 +129,7 @@ Here are just some common examples.
    scrcpy --otg
    ```

- - Control the device using gamepads plugged into the computer:
+ - Control the device using gamepad controllers plugged into the computer:

    ```bash
    scrcpy --gamepad=uhid
@@ -207,10 +207,10 @@ work][donate]:

 [donate]: https://blog.rom1v.com/about/#support-my-open-source-work

-## License
+## Licence

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2025 Romain Vimont
+    Copyright (C) 2018-2024 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
--- a/app/data/bash-completion/scrcpy
+++ b/app/data/bash-completion/scrcpy
@@ -18,14 +18,11 @@ _scrcpy() {
        --camera-fps=
        --camera-high-speed
        --camera-size=
-        --camera-torch
-        --camera-zoom=
        --capture-orientation=
        --crop=
        -d --select-usb
        --disable-screensaver
        --display-id=
-        --display-ime-policy=
        --display-orientation=
        -e --select-tcpip
        -f --fullscreen
@@ -124,7 +121,7 @@ _scrcpy() {
            return
            ;;
        --audio-source)
-            COMPREPLY=($(compgen -W 'output playback mic mic-unprocessed mic-camcorder mic-voice-recognition mic-voice-communication voice-call voice-call-uplink voice-call-downlink voice-performance' -- "$cur"))
+            COMPREPLY=($(compgen -W 'output mic playback' -- "$cur"))
            return
            ;;
        --camera-facing)
@@ -151,10 +148,6 @@ _scrcpy() {
            COMPREPLY=($(compgen -W '0 90 180 270 flip0 flip90 flip180 flip270' -- "$cur"))
            return
            ;;
-        --display-ime-policy)
-            COMPREPLY=($(compgen -W 'local fallback hide' -- "$cur"))
-            return
-            ;;
        --record-orientation)
            COMPREPLY=($(compgen -W '0 90 180 270' -- "$cur"))
            return
@@ -199,8 +192,6 @@ _scrcpy() {
        |--camera-id \
        |--camera-fps \
        |--camera-size \
-        |--camera-torch \
-        |--camera-zoom \
        |--crop \
        |--display-id \
        |--max-fps \
@@ -209,7 +200,6 @@ _scrcpy() {
        |-p|--port \
        |--push-target \
        |--rotation \
-        |--screen-off-timeout \
        |--tunnel-host \
        |--tunnel-port \
        |--v4l2-buffer \
--- a/app/data/scrcpy-console.bat
+++ b/app/data/scrcpy-console.bat
@@ -0,0 +1,2 @@
+@echo off
+scrcpy.exe --pause-on-exit=if-error %*
--- a/app/data/zsh-completion/_scrcpy
+++ b/app/data/zsh-completion/_scrcpy
@@ -1,4 +1,4 @@
-#compdef scrcpy scrcpy.exe
+#compdef -N scrcpy -N scrcpy.exe
 #
 # name: scrcpy
 # auth: hltdev [hltdev8642@gmail.com]
@@ -11,12 +11,12 @@ arguments=(
    '--always-on-top[Make scrcpy window always on top \(above other windows\)]'
    '--angle=[Rotate the video content by a custom angle, in degrees]'
    '--audio-bit-rate=[Encode the audio at the given bit-rate]'
-    '--audio-buffer=[Configure the audio buffering delay \(in milliseconds\)]'
+    '--audio-buffer=[Configure the audio buffering delay (in milliseconds)]'
    '--audio-codec=[Select the audio codec]:codec:(opus aac flac raw)'
    '--audio-codec-options=[Set a list of comma-separated key\:type=value options for the device audio encoder]'
    '--audio-dup=[Duplicate audio]'
    '--audio-encoder=[Use a specific MediaCodec audio encoder]'
-    '--audio-source=[Select the audio source]:source:(output playback mic mic-unprocessed mic-camcorder mic-voice-recognition mic-voice-communication voice-call voice-call-uplink voice-call-downlink voice-performance)'
+    '--audio-source=[Select the audio source]:source:(output mic playback)'
    '--audio-output-buffer=[Configure the size of the SDL audio output buffer (in milliseconds)]'
    {-b,--video-bit-rate=}'[Encode the video at the given bit-rate]'
    '--camera-ar=[Select the camera size by its aspect ratio]'
@@ -25,22 +25,19 @@ arguments=(
    '--camera-facing=[Select the device camera by its facing direction]:facing:(front back external)'
    '--camera-fps=[Specify the camera capture frame rate]'
    '--camera-size=[Specify an explicit camera capture size]'
-    '--camera-torch[Turn on the camera torch when the camera starts]'
-    '--camera-zoom[Specify the camera zoom initial value]'
    '--capture-orientation=[Set the capture video orientation]:orientation:(0 90 180 270 flip0 flip90 flip180 flip270 @0 @90 @180 @270 @flip0 @flip90 @flip180 @flip270)'
    '--crop=[\[width\:height\:x\:y\] Crop the device screen on the server]'
    {-d,--select-usb}'[Use USB device]'
    '--disable-screensaver[Disable screensaver while scrcpy is running]'
    '--display-id=[Specify the display id to mirror]'
-    '--display-ime-policy[Set the policy for selecting where the IME should be displayed]'
    '--display-orientation=[Set the initial display orientation]:orientation values:(0 90 180 270 flip0 flip90 flip180 flip270)'
    {-e,--select-tcpip}'[Use TCP/IP device]'
    {-f,--fullscreen}'[Start in fullscreen]'
    '--force-adb-forward[Do not attempt to use \"adb reverse\" to connect to the device]'
-    '-G[Use UHID/AOA gamepad \(same as --gamepad=uhid or --gamepad=aoa, depending on OTG mode\)]'
+    '-G[Use UHID/AOA gamepad (same as --gamepad=uhid or --gamepad=aoa, depending on OTG mode)]'
    '--gamepad=[Set the gamepad input mode]:mode:(disabled uhid aoa)'
    {-h,--help}'[Print the help]'
-    '-K[Use UHID/AOA keyboard \(same as --keyboard=uhid or --keyboard=aoa, depending on OTG mode\)]'
+    '-K[Use UHID/AOA keyboard (same as --keyboard=uhid or --keyboard=aoa, depending on OTG mode)]'
    '--keyboard=[Set the keyboard input mode]:mode:(disabled sdk uhid aoa)'
    '--kill-adb-on-close[Kill adb when scrcpy terminates]'
    '--legacy-paste[Inject computer clipboard text as a sequence of key events on Ctrl+v]'
@@ -50,7 +47,7 @@ arguments=(
    '--list-displays[List displays available on the device]'
    '--list-encoders[List video and audio encoders available on the device]'
    {-m,--max-size=}'[Limit both the width and height of the video to value]'
-    '-M[Use UHID/AOA mouse \(same as --mouse=uhid or --mouse=aoa, depending on OTG mode\)]'
+    '-M[Use UHID/AOA mouse (same as --mouse=uhid or --mouse=aoa, depending on OTG mode)]'
    '--max-fps=[Limit the frame rate of screen capture]'
    '--mouse=[Set the mouse input mode]:mode:(disabled sdk uhid aoa)'
    '--mouse-bind=[Configure bindings of secondary clicks]'
--- a/app/deps/adb_linux.sh
+++ b/app/deps/adb_linux.sh
@@ -1,13 +1,13 @@
 #!/usr/bin/env bash
 set -ex
-. $(dirname ${BASH_SOURCE[0]})/_init "$@"
+DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DEPS_DIR"
+. common

-VERSION=36.0.0
-URL="https://dl.google.com/android/repository/platform-tools_r$VERSION-linux.zip"
-SHA256SUM=0ead642c943ffe79701fccca8f5f1c69c4ce4f43df2eefee553f6ccb27cbfbe8
-
-PROJECT_DIR="platform-tools-$VERSION-linux"
-FILENAME="$PROJECT_DIR.zip"
+VERSION=35.0.2
+FILENAME=platform-tools_r$VERSION-linux.zip
+PROJECT_DIR=platform-tools-$VERSION-linux
+SHA256SUM=acfdcccb123a8718c46c46c059b2f621140194e5ec1ac9d81715be3d6ab6cd0a

 cd "$SOURCES_DIR"

@@ -15,7 +15,7 @@ if [[ -d "$PROJECT_DIR" ]]
 then
    echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "$URL" "$FILENAME" "$SHA256SUM"
+    get_file "https://dl.google.com/android/repository/$FILENAME" "$FILENAME" "$SHA256SUM"
    mkdir -p "$PROJECT_DIR"
    cd "$PROJECT_DIR"
    ZIP_PREFIX=platform-tools
--- a/app/deps/adb_macos.sh
+++ b/app/deps/adb_macos.sh
@@ -1,13 +1,13 @@
 #!/usr/bin/env bash
 set -ex
-. $(dirname ${BASH_SOURCE[0]})/_init "$@"
+DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DEPS_DIR"
+. common

-VERSION=36.0.0
-URL="https://dl.google.com/android/repository/platform-tools_r$VERSION-darwin.zip"
-SHA256SUM=d3e9fa1df3345cf728586908426615a60863d2632f73f1ce14f0f1349ef000fd
-
-PROJECT_DIR="platform-tools-$VERSION-darwin"
-FILENAME="$PROJECT_DIR.zip"
+VERSION=35.0.2
+FILENAME=platform-tools_r$VERSION-darwin.zip
+PROJECT_DIR=platform-tools-$VERSION-darwin
+SHA256SUM=1820078db90bf21628d257ff052528af1c61bb48f754b3555648f5652fa35d78

 cd "$SOURCES_DIR"

@@ -15,7 +15,7 @@ if [[ -d "$PROJECT_DIR" ]]
 then
    echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "$URL" "$FILENAME" "$SHA256SUM"
+    get_file "https://dl.google.com/android/repository/$FILENAME" "$FILENAME" "$SHA256SUM"
    mkdir -p "$PROJECT_DIR"
    cd "$PROJECT_DIR"
    ZIP_PREFIX=platform-tools
--- a/app/deps/adb_windows.sh
+++ b/app/deps/adb_windows.sh
@@ -1,13 +1,13 @@
 #!/usr/bin/env bash
 set -ex
-. $(dirname ${BASH_SOURCE[0]})/_init "$@"
+DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DEPS_DIR"
+. common

-VERSION=36.0.0
-URL="https://dl.google.com/android/repository/platform-tools_r$VERSION-win.zip"
-SHA256SUM=12c2841f354e92a0eb2fd7bf6f0f9bf8538abce7bd6b060ac8349d6f6a61107c
-
-PROJECT_DIR="platform-tools-$VERSION-windows"
-FILENAME="$PROJECT_DIR.zip"
+VERSION=35.0.2
+FILENAME=platform-tools_r$VERSION-win.zip
+PROJECT_DIR=platform-tools-$VERSION-windows
+SHA256SUM=2975a3eac0b19182748d64195375ad056986561d994fffbdc64332a516300bb9

 cd "$SOURCES_DIR"

@@ -15,7 +15,7 @@ if [[ -d "$PROJECT_DIR" ]]
 then
    echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "$URL" "$FILENAME" "$SHA256SUM"
+    get_file "https://dl.google.com/android/repository/$FILENAME" "$FILENAME" "$SHA256SUM"
    mkdir -p "$PROJECT_DIR"
    cd "$PROJECT_DIR"
    ZIP_PREFIX=platform-tools
--- a/app/deps/common
+++ b/app/deps/common
@@ -1,9 +1,10 @@
+#!/usr/bin/env bash
 # This file is intended to be sourced by other scripts, not executed

 process_args() {
    if [[ $# != 3 ]]
    then
-        # <host>: linux, macos, win32 or win64
+        # <host>: win32 or win64
        # <build_type>: native or cross
        # <link_type>: static or shared
        echo "Syntax: $0 <host> <build_type> <link_type>" >&2
@@ -11,8 +12,8 @@ process_args() {
    fi

    HOST="$1"
-    BUILD_TYPE="$2"
-    LINK_TYPE="$3"
+    BUILD_TYPE="$2" # native or cross
+    LINK_TYPE="$3" # static or shared
    DIRNAME="$HOST-$BUILD_TYPE-$LINK_TYPE"

    if [[ "$BUILD_TYPE" != native && "$BUILD_TYPE" != cross ]]
--- a/app/deps/dav1d.sh
+++ b/app/deps/dav1d.sh
@@ -1,22 +1,22 @@
 #!/usr/bin/env bash
 set -ex
-. $(dirname ${BASH_SOURCE[0]})/_init
+DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DEPS_DIR"
+. common
 process_args "$@"

 VERSION=1.5.0
-URL="https://code.videolan.org/videolan/dav1d/-/archive/$VERSION/dav1d-$VERSION.tar.gz"
+FILENAME=dav1d-$VERSION.tar.gz
+PROJECT_DIR=dav1d-$VERSION
 SHA256SUM=78b15d9954b513ea92d27f39362535ded2243e1b0924fde39f37a31ebed5f76b

-PROJECT_DIR="dav1d-$VERSION"
-FILENAME="$PROJECT_DIR.tar.gz"
-
 cd "$SOURCES_DIR"

 if [[ -d "$PROJECT_DIR" ]]
 then
    echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "$URL" "$FILENAME" "$SHA256SUM"
+    get_file "https://code.videolan.org/videolan/dav1d/-/archive/$VERSION/$FILENAME" "$FILENAME" "$SHA256SUM"
    tar xf "$FILENAME"  # First level directory is "$PROJECT_DIR"
 fi

--- a/app/deps/ffmpeg.sh
+++ b/app/deps/ffmpeg.sh
@@ -1,14 +1,14 @@
 #!/usr/bin/env bash
 set -ex
-. $(dirname ${BASH_SOURCE[0]})/_init
+DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DEPS_DIR"
+. common
 process_args "$@"

-VERSION=7.1.1
-URL="https://ffmpeg.org/releases/ffmpeg-$VERSION.tar.xz"
-SHA256SUM=733984395e0dbbe5c046abda2dc49a5544e7e0e1e2366bba849222ae9e3a03b1
-
-PROJECT_DIR="ffmpeg-$VERSION"
-FILENAME="$PROJECT_DIR.tar.xz"
+VERSION=7.1
+FILENAME=ffmpeg-$VERSION.tar.xz
+PROJECT_DIR=ffmpeg-$VERSION
+SHA256SUM=40973D44970DBC83EF302B0609F2E74982BE2D85916DD2EE7472D30678A7ABE6

 cd "$SOURCES_DIR"

@@ -16,7 +16,7 @@ if [[ -d "$PROJECT_DIR" ]]
 then
    echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "$URL" "$FILENAME" "$SHA256SUM"
+    get_file "https://ffmpeg.org/releases/$FILENAME" "$FILENAME" "$SHA256SUM"
    tar xf "$FILENAME"  # First level directory is "$PROJECT_DIR"
 fi

--- a/app/deps/libusb.sh
+++ b/app/deps/libusb.sh
@@ -1,14 +1,14 @@
 #!/usr/bin/env bash
 set -ex
-. $(dirname ${BASH_SOURCE[0]})/_init
+DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DEPS_DIR"
+. common
 process_args "$@"

-VERSION=1.0.29
-URL="https://github.com/libusb/libusb/archive/refs/tags/v$VERSION.tar.gz"
-SHA256SUM=7c2dd39c0b2589236e48c93247c986ae272e27570942b4163cb00a060fcf1b74
-
-PROJECT_DIR="libusb-$VERSION"
-FILENAME="$PROJECT_DIR.tar.gz"
+VERSION=1.0.27
+FILENAME=libusb-$VERSION.tar.gz
+PROJECT_DIR=libusb-$VERSION
+SHA256SUM=e8f18a7a36ecbb11fb820bd71540350d8f61bcd9db0d2e8c18a6fb80b214a3de

 cd "$SOURCES_DIR"

@@ -16,7 +16,7 @@ if [[ -d "$PROJECT_DIR" ]]
 then
    echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "$URL" "$FILENAME" "$SHA256SUM"
+    get_file "https://github.com/libusb/libusb/archive/refs/tags/v$VERSION.tar.gz" "$FILENAME" "$SHA256SUM"
    tar xf "$FILENAME"  # First level directory is "$PROJECT_DIR"
 fi

--- a/app/deps/sdl.sh
+++ b/app/deps/sdl.sh
@@ -1,14 +1,14 @@
 #!/usr/bin/env bash
 set -ex
-. $(dirname ${BASH_SOURCE[0]})/_init
+DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DEPS_DIR"
+. common
 process_args "$@"

-VERSION=3.4.0
-URL="https://github.com/libsdl-org/SDL/archive/refs/tags/release-$VERSION.tar.gz"
-SHA256SUM=9614b9696abc4597ffce6b888829dc6537ae500423474c342ac4a67222c5654c
-
-PROJECT_DIR="sdl-$VERSION"
-FILENAME="$PROJECT_DIR.tar.gz"
+VERSION=2.30.10
+FILENAME=SDL-$VERSION.tar.gz
+PROJECT_DIR=SDL-release-$VERSION
+SHA256SUM=35a8b9c4f3635d85762b904ac60ca4e0806bff89faeb269caafbe80860d67168

 cd "$SOURCES_DIR"

@@ -16,9 +16,8 @@ if [[ -d "$PROJECT_DIR" ]]
 then
    echo "$PWD/$PROJECT_DIR" found
 else
-    get_file "$URL" "$FILENAME" "$SHA256SUM"
-    tar xf "$FILENAME"  # First level directory is "SDL-release-$VERSION"
-    mv "SDL-release-$VERSION" "$PROJECT_DIR"
+    get_file "https://github.com/libsdl-org/SDL/archive/refs/tags/release-$VERSION.tar.gz" "$FILENAME" "$SHA256SUM"
+    tar xf "$FILENAME"  # First level directory is "$PROJECT_DIR"
 fi

 mkdir -p "$BUILD_DIR/$PROJECT_DIR"
@@ -29,56 +28,52 @@ export CXXFLAGS="$CFLAGS"

 if [[ -d "$DIRNAME" ]]
 then
-    echo "'$PWD/$DIRNAME' already exists, not reconfigured"
+    echo "'$PWD/$HDIRNAME' already exists, not reconfigured"
    cd "$DIRNAME"
 else
    mkdir "$DIRNAME"
    cd "$DIRNAME"

    conf=(
-        -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR/$DIRNAME"
-        -DSDL_TESTS=OFF
+        --prefix="$INSTALL_DIR/$DIRNAME"
    )

    if [[ "$HOST" == linux ]]
    then
        conf+=(
-            -DSDL_WAYLAND=ON
-            -DSDL_X11=ON
+            --enable-video-wayland
+            --enable-video-x11
        )
    fi

    if [[ "$LINK_TYPE" == static ]]
    then
        conf+=(
-            -DBUILD_SHARED_LIBS=OFF
+            --enable-static
+            --disable-shared
        )
    else
        conf+=(
-            -DBUILD_SHARED_LIBS=ON
+            --disable-static
+            --enable-shared
        )
    fi

    if [[ "$BUILD_TYPE" == cross ]]
    then
-        if [[ "$HOST" = win32 ]]
-        then
-            TOOLCHAIN_FILENAME="cmake-toolchain-mingw64-i686.cmake"
-        elif [[ "$HOST" = win64 ]]
-        then
-            TOOLCHAIN_FILENAME="cmake-toolchain-mingw64-x86_64.cmake"
-        else
-            echo "Unsupported cross-build to host: $HOST" >&2
-            exit 1
-        fi
-
        conf+=(
-            -DCMAKE_TOOLCHAIN_FILE="$SOURCES_DIR/$PROJECT_DIR/build-scripts/$TOOLCHAIN_FILENAME"
+            --host="$HOST_TRIPLET"
        )
    fi

-    cmake "$SOURCES_DIR/$PROJECT_DIR" "${conf[@]}"
+    "$SOURCES_DIR/$PROJECT_DIR"/configure "${conf[@]}"
 fi

-cmake --build .
-cmake --install .
+make -j
+# There is no "make install-strip"
+make install
+# Strip manually
+if [[ "$LINK_TYPE" == shared && "$HOST" == win* ]]
+then
+    ${HOST_TRIPLET}-strip "$INSTALL_DIR/$DIRNAME/bin/SDL2.dll"
+fi
--- a/app/meson.build
+++ b/app/meson.build
@@ -15,6 +15,7 @@ src = [
    'src/delay_buffer.c',
    'src/demuxer.c',
    'src/device_msg.c',
+    'src/display.c',
    'src/events.c',
    'src/icon.c',
    'src/file_pusher.c',
@@ -32,7 +33,6 @@ src = [
    'src/scrcpy.c',
    'src/screen.c',
    'src/server.c',
-    'src/texture.c',
    'src/version.c',
    'src/hid/hid_gamepad.c',
    'src/hid/hid_keyboard.c',
@@ -57,7 +57,6 @@ src = [
    'src/util/process.c',
    'src/util/process_intr.c',
    'src/util/rand.c',
-    'src/util/sdl.c',
    'src/util/strbuf.c',
    'src/util/str.c',
    'src/util/term.c',
@@ -75,7 +74,6 @@ conf.set('_GNU_SOURCE', true)
 if host_machine.system() == 'windows'
    windows = import('windows')
    src += [
-        'src/util/command.c',
        'src/sys/win/file.c',
        'src/sys/win/process.c',
        windows.compile_resources('scrcpy-windows.rc'),
@@ -105,6 +103,7 @@ if usb_support
        'src/usb/keyboard_aoa.c',
        'src/usb/mouse_aoa.c',
        'src/usb/scrcpy_otg.c',
+        'src/usb/screen_otg.c',
        'src/usb/usb.c',
    ]
 endif
@@ -118,7 +117,7 @@ dependencies = [
    dependency('libavcodec', version: '>= 57.37', static: static),
    dependency('libavutil', static: static),
    dependency('libswresample', static: static),
-    dependency('sdl3', version: '>= 3.2.0', static: static),
+    dependency('sdl2', version: '>= 2.0.5', static: static),
 ]

 if v4l2_support
@@ -193,19 +192,19 @@ datadir = get_option('datadir') # by default 'share'
 install_man('scrcpy.1')
 install_data('data/icon.png',
             rename: 'scrcpy.png',
-             install_dir: datadir / 'icons/hicolor/256x256/apps')
+             install_dir: join_paths(datadir, 'icons/hicolor/256x256/apps'))
 install_data('data/zsh-completion/_scrcpy',
-             install_dir: datadir / 'zsh/site-functions')
+             install_dir: join_paths(datadir, 'zsh/site-functions'))
 install_data('data/bash-completion/scrcpy',
-             install_dir: datadir / 'bash-completion/completions')
+             install_dir: join_paths(datadir, 'bash-completion/completions'))

 # Desktop entry file for application launchers
 if host_machine.system() == 'linux'
    # Install a launcher (ex: /usr/local/share/applications/scrcpy.desktop)
    install_data('data/scrcpy.desktop',
-                 install_dir: datadir / 'applications')
+                 install_dir: join_paths(datadir, 'applications'))
    install_data('data/scrcpy-console.desktop',
-                 install_dir: datadir / 'applications')
+                 install_dir: join_paths(datadir, 'applications'))
 endif


@@ -239,12 +238,6 @@ if get_option('buildtype') == 'debug'
            'src/util/strbuf.c',
            'src/util/term.c',
        ]],
-        ['test_command_windows', [
-          'tests/test_command_windows.c',
-          'src/util/command.c',
-          'src/util/str.c',
-          'src/util/strbuf.c',
-        ]],
        ['test_control_msg_serialize', [
            'tests/test_control_msg_serialize.c',
            'src/control_msg.c',
@@ -282,13 +275,7 @@ if get_option('buildtype') == 'debug'
        exe = executable(t[0], sources,
                         include_directories: src_dir,
                         dependencies: dependencies,
-                         c_args: ['-DSC_TEST'])
+                         c_args: ['-DSDL_MAIN_HANDLED', '-DSC_TEST'])
        test(t[0], exe)
    endforeach
 endif
-
-if meson.version().version_compare('>= 0.58.0')
-       devenv = environment()
-       devenv.set('SCRCPY_ICON_PATH', meson.current_source_dir() / 'data/icon.png')
-       meson.add_devenv(devenv)
-endif
--- a/app/scrcpy-windows.rc
+++ b/app/scrcpy-windows.rc
@@ -13,7 +13,7 @@ BEGIN
      VALUE "LegalCopyright", "Romain Vimont, Genymobile"
      VALUE "OriginalFilename", "scrcpy.exe"
      VALUE "ProductName", "scrcpy"
-      VALUE "ProductVersion", "3.3.4"
+      VALUE "ProductVersion", "3.1"
    END
  END
  BLOCK "VarFileInfo"
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -67,19 +67,13 @@ The available encoders can be listed by \fB\-\-list\-encoders\fR.

 .TP
 .BI "\-\-audio\-source " source
-Select the audio source. Possible values are:
+Select the audio source (output, mic or playback).

- - "output": forwards the whole audio output, and disables playback on the device.
- - "playback": captures the audio playback (Android apps can opt-out, so the whole output is not necessarily captured).
- - "mic": captures the microphone.
- - "mic-unprocessed": captures the microphone unprocessed (raw) sound.
- - "mic-camcorder": captures the microphone tuned for video recording, with the same orientation as the camera if available.
- - "mic-voice-recognition": captures the microphone tuned for voice recognition.
- - "mic-voice-communication": captures the microphone tuned for voice communications (it will for instance take advantage of echo cancellation or automatic gain control if available).
- - "voice-call": captures voice call.
- - "voice-call-uplink": captures voice call uplink only.
- - "voice-call-downlink": captures voice call downlink only.
- - "voice-performance": captures audio meant to be processed for live performance (karaoke), includes both the microphone and the device playback.
+The "output" source forwards the whole audio output, and disables playback on the device.
+
+The "playback" source captures the audio playback (Android apps can opt-out, so the whole output is not necessarily captured).
+
+The "mic" source captures the microphone.

 Default is output.

@@ -131,14 +125,6 @@ The available camera ids can be listed by \fB\-\-list\-cameras\fR.
 .BI "\-\-camera\-size " width\fRx\fIheight
 Specify an explicit camera capture size.

-.TP
-.BI \-\-camera\-torch
-Turn on the camera torch when the camera starts.
-
-.TP
-.BI "\-\-camera-zoom " zoom
-Specify the camera zoom initial value.
-
 .TP
 .BI "\-\-capture\-orientation " value
 Possible values are 0, 90, 180, 270, flip0, flip90, flip180 and flip270, possibly prefixed by '@'.
@@ -175,19 +161,6 @@ The available display ids can be listed by \fB\-\-list\-displays\fR.

 Default is 0.

-.TP
-.BI "\-\-display\-ime\-policy " value
-Set the policy for selecting where the IME should be displayed.
-
-Possible values are "local", "fallback" and "hide":
-
- - "local" means that the IME should appear on the local display.
- - "fallback" means that the IME should appear on a fallback display (the default display).
- - "hide" means that the IME should be hidden.
-
-By default, the IME policy is left unchanged.
-
-
 .TP
 .BI "\-\-display\-orientation " value
 Set the initial display orientation.
@@ -416,7 +389,7 @@ Disable video playback on the computer.

 .TP
 .B \-\-no\-window
-Disable scrcpy window. Implies --no-video-playback.
+Disable scrcpy window. Implies --no-video-playback and --no-control.

 .TP
 .BI "\-\-orientation " value
@@ -518,10 +491,6 @@ The device serial number. Mandatory only if several devices are connected to adb
 .B \-S, \-\-turn\-screen\-off
 Turn the device screen off immediately.

-.TP
-.B "\-\-screen\-off\-timeout " seconds
-Set the screen off timeout while scrcpy is running (restore the initial value on exit).
-
 .TP
 .BI "\-\-shortcut\-mod " key\fR[+...]][,...]
 Specify the modifiers to use for scrcpy shortcuts. Possible keys are "lctrl", "rctrl", "lalt", "ralt", "lsuper" and "rsuper".
@@ -823,22 +792,6 @@ Install APK from computer
 .B Drag & drop non-APK file
 Push file to device (see \fB\-\-push\-target\fR)

-.TP
-.B MOD+t
-Turn on the camera torch (camera mode only)
-
-.TP
-.B MOD+Shift+t
-Turn off the camera torch (camera mode only)
-
-.TP
-.B MOD+Up
-Zoom camera in (camera mode only)
-
-.TP
-.B MOD+Down
-Zoom camera out (camera mode only)
-

 .SH Environment variables

@@ -876,7 +829,7 @@ Report bugs to <https://github.com/Genymobile/scrcpy/issues>.
 .SH COPYRIGHT
 Copyright \(co 2018 Genymobile <https://www.genymobile.com>

-Copyright \(co 2018\-2025 Romain Vimont <rom@rom1v.com>
+Copyright \(co 2018\-2024 Romain Vimont <rom@rom1v.com>

 Licensed under the Apache License, Version 2.0.

--- a/app/src/adb/adb.c
+++ b/app/src/adb/adb.c
@@ -4,10 +4,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>

-#include "adb/adb_device.h"
-#include "adb/adb_parser.h"
+#include "adb_device.h"
+#include "adb_parser.h"
 #include "util/env.h"
 #include "util/file.h"
 #include "util/log.h"
@@ -103,14 +102,14 @@ argv_to_string(const char *const *argv, char *buf, size_t bufsize) {

 static void
 show_adb_installation_msg(void) {
-#ifndef _WIN32
+#ifndef __WINDOWS__
    static const struct {
        const char *binary;
        const char *command;
    } pkg_managers[] = {
        {"apt", "apt install adb"},
        {"apt-get", "apt-get install adb"},
-        {"brew", "brew install --cask android-platform-tools"},
+        {"brew", "brew cask install android-platform-tools"},
        {"dnf", "dnf install android-tools"},
        {"emerge", "emerge dev-util/android-tools"},
        {"pacman", "pacman -S android-tools"},
@@ -331,24 +330,56 @@ sc_adb_reverse_remove(struct sc_intr *intr, const char *serial,
 bool
 sc_adb_push(struct sc_intr *intr, const char *serial, const char *local,
            const char *remote, unsigned flags) {
+#ifdef __WINDOWS__
+    // Windows will parse the string, so the paths must be quoted
+    // (see sys/win/command.c)
+    local = sc_str_quote(local);
+    if (!local) {
+        return SC_PROCESS_NONE;
+    }
+    remote = sc_str_quote(remote);
+    if (!remote) {
+        free((void *) local);
+        return SC_PROCESS_NONE;
+    }
+#endif
+
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "push", local, remote);

    sc_pid pid = sc_adb_execute(argv, flags);

+#ifdef __WINDOWS__
+    free((void *) remote);
+    free((void *) local);
+#endif
+
    return process_check_success_intr(intr, pid, "adb push", flags);
 }

 bool
 sc_adb_install(struct sc_intr *intr, const char *serial, const char *local,
               unsigned flags) {
+#ifdef __WINDOWS__
+    // Windows will parse the string, so the local name must be quoted
+    // (see sys/win/command.c)
+    local = sc_str_quote(local);
+    if (!local) {
+        return SC_PROCESS_NONE;
+    }
+#endif
+
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "install", "-r", local);

    sc_pid pid = sc_adb_execute(argv, flags);

+#ifdef __WINDOWS__
+    free((void *) local);
+#endif
+
    return process_check_success_intr(intr, pid, "adb install", flags);
 }

--- a/app/src/adb/adb.h
+++ b/app/src/adb/adb.h
@@ -6,7 +6,7 @@
 #include <stdbool.h>
 #include <inttypes.h>

-#include "adb/adb_device.h"
+#include "adb_device.h"
 #include "util/intr.h"

 #define SC_ADB_NO_STDOUT (1 << 0)
--- a/app/src/adb/adb_device.c
+++ b/app/src/adb/adb_device.c
@@ -39,11 +39,5 @@ sc_adb_device_get_type(const char *serial) {
        return SC_ADB_DEVICE_TYPE_TCPIP;
    }

-    // TCP/IP devices provided by mDNS contain "adb-tls-connect"
-    // <https://github.com/Genymobile/scrcpy/issues/6248>
-    if (strstr(serial, "adb-tls-connect")) {
-        return SC_ADB_DEVICE_TYPE_TCPIP;
-    }
-
    return SC_ADB_DEVICE_TYPE_USB;
 }
--- a/app/src/adb/adb_device.h
+++ b/app/src/adb/adb_device.h
@@ -4,6 +4,7 @@
 #include "common.h"

 #include <stdbool.h>
+#include <stddef.h>

 #include "util/vector.h"

--- a/app/src/adb/adb_parser.c
+++ b/app/src/adb/adb_parser.c
@@ -3,54 +3,10 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>

 #include "util/log.h"
 #include "util/str.h"

-static size_t
-rstrip_len(const char *s, size_t len) {
-    size_t i = len;
-
-    // Ignore trailing whitespaces
-    while (i > 0 && (s[i-1] == ' ' || s[i-1] == '\t')) {
-        --i;
-    }
-
-    return i;
-}
-
-static void
-locate_last_token(const char *s, size_t len, size_t *start, size_t *end) {
-    size_t i = rstrip_len(s, len);
-    *end = i; // excluded
-
-    // The token contains non-whitespace chars
-    while (i > 0 && (s[i-1] != ' ' && s[i-1] != '\t')) {
-        --i;
-    }
-
-    *start = i; // included
-}
-
-static bool
-is_device_state(const char *s) {
-    // <https://android.googlesource.com/platform/packages/modules/adb/+/1cf2f017d312f73b3dc53bda85ef2610e35a80e9/adb.cpp#144>
-    // "device", "unauthorized" and "offline" are the most common states, so
-    // check them first.
-    return !strcmp(s, "device")
-        || !strcmp(s, "unauthorized")
-        || !strcmp(s, "offline")
-        || !strcmp(s, "bootloader")
-        || !strcmp(s, "host")
-        || !strcmp(s, "recovery")
-        || !strcmp(s, "rescue")
-        || !strcmp(s, "sideload")
-        || !strcmp(s, "authorizing")
-        || !strcmp(s, "connecting")
-        || !strcmp(s, "detached");
-}
-
 static bool
 sc_adb_parse_device(char *line, struct sc_adb_device *device) {
    // One device line looks like:
@@ -68,54 +24,64 @@ sc_adb_parse_device(char *line, struct sc_adb_device *device) {
        return false;
    }

-    size_t len = strlen(line);
+    char *s = line; // cursor in the line

-    size_t start;
-    size_t end;
-
-    // The serial (the first token) may contain spaces, which are also token
-    // separators. To avoid ambiguity, parse the string backwards:
-    //  - first, parse all the trailing values until the device state,
-    //    identified using a list of well-known values;
-    //  - finally, treat the remaining leading token as the device serial.
-    //
-    // Refs:
-    //  - <https://github.com/Genymobile/scrcpy/issues/6248>
-    //  - <https://github.com/Genymobile/scrcpy/issues/3537>
-    const char *state;
-    const char *model = NULL;
-    for (;;) {
-        locate_last_token(line, len, &start, &end);
-        if (start == end) {
-            // No more tokens, unexpected
-            return false;
-        }
-
-        const char *token = &line[start];
-        line[end] = '\0';
-
-        if (!strncmp("model:", token, sizeof("model:") - 1)) {
-            model = &token[sizeof("model:") - 1];
-            // We only need the model
-        } else if (is_device_state(token)) {
-            state = token;
-            // The device state is the item immediately after the device serial
-            break;
-        }
-
-        // Remove the trailing parts already handled
-        len = start;
-    }
-
-    assert(state);
-
-    size_t serial_len = rstrip_len(line, start);
+    // After the serial:
+    //  - "adb devices" writes a single '\t'
+    //  - "adb devices -l" writes multiple spaces
+    // For flexibility, accept both.
+    size_t serial_len = strcspn(s, " \t");
    if (!serial_len) {
        // empty serial
        return false;
    }
-    char *serial = line;
-    line[serial_len] = '\0';
+    bool eol = s[serial_len] == '\0';
+    if (eol) {
+        // serial alone is unexpected
+        return false;
+    }
+    s[serial_len] = '\0';
+    char *serial = s;
+    s += serial_len + 1;
+    // After the serial, there might be several spaces
+    s += strspn(s, " \t"); // consume all separators
+
+    size_t state_len = strcspn(s, " ");
+    if (!state_len) {
+        // empty state
+        return false;
+    }
+    eol = s[state_len] == '\0';
+    s[state_len] = '\0';
+    char *state = s;
+
+    char *model = NULL;
+    if (!eol) {
+        s += state_len + 1;
+
+        // Iterate over all properties "key:value key:value ..."
+        for (;;) {
+            size_t token_len = strcspn(s, " ");
+            if (!token_len) {
+                break;
+            }
+            eol = s[token_len] == '\0';
+            s[token_len] = '\0';
+            char *token = s;
+
+            if (!strncmp("model:", token, sizeof("model:") - 1)) {
+                model = &token[sizeof("model:") - 1];
+                // We only need the model
+                break;
+            }
+
+            if (eol) {
+                break;
+            } else {
+                s+= token_len + 1;
+            }
+        }
+    }

    device->serial = strdup(serial);
    if (!device->serial) {
--- a/app/src/adb/adb_parser.h
+++ b/app/src/adb/adb_parser.h
@@ -3,9 +3,9 @@

 #include "common.h"

-#include <stdbool.h>
+#include <stddef.h>

-#include "adb/adb_device.h"
+#include "adb_device.h"

 /**
 * Parse the available devices from the output of `adb devices`
--- a/app/src/adb/adb_tunnel.c
+++ b/app/src/adb/adb_tunnel.c
@@ -1,11 +1,11 @@
 #include "adb_tunnel.h"

 #include <assert.h>
-#include <inttypes.h>

-#include "adb/adb.h"
+#include "adb.h"
 #include "util/log.h"
 #include "util/net_intr.h"
+#include "util/process_intr.h"

 static bool
 listen_on_port(struct sc_intr *intr, sc_socket socket, uint16_t port) {
--- a/app/src/audio_player.c
+++ b/app/src/audio_player.c
@@ -1,40 +1,23 @@
 #include "audio_player.h"

 #include "util/log.h"
-#include "SDL3/SDL_hints.h"

 /** Downcast frame_sink to sc_audio_player */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_audio_player, frame_sink)

-#define SC_SDL_SAMPLE_FMT SDL_AUDIO_F32LE
+#define SC_SDL_SAMPLE_FMT AUDIO_F32

 static void SDLCALL
-sc_audio_player_stream_callback(void *userdata, SDL_AudioStream *stream,
-                                int additional_amount, int total_amount) {
-    (void) total_amount;
-
+sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
    struct sc_audio_player *ap = userdata;

-    size_t len = additional_amount;
+    assert(len_int > 0);
+    size_t len = len_int;
+
    assert(len % ap->audioreg.sample_size == 0);
+    uint32_t out_samples = len / ap->audioreg.sample_size;

-    // The requested amount may exceed the internal aout_buffer size.
-    // In this (unlikely) case, send the data to the stream in multiple chunks.
-    while (len) {
-        size_t chunk_size = MIN(ap->aout_buffer_size, len);
-        uint32_t out_samples = chunk_size / ap->audioreg.sample_size;
-        sc_audio_regulator_pull(&ap->audioreg, ap->aout_buffer,
-                                out_samples);
-
-        assert(chunk_size <= len);
-        len -= chunk_size;
-        bool ok =
-            SDL_PutAudioStreamData(stream, ap->aout_buffer, chunk_size);
-        if (!ok) {
-            LOGW("Audio stream error: %s", SDL_GetError());
-            return;
-        }
-    }
+    sc_audio_regulator_pull(&ap->audioreg, stream, out_samples);
 }

 static bool
@@ -47,10 +30,7 @@ sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,

 static bool
 sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
-                                const AVCodecContext *ctx,
-                                const struct sc_stream_session *session) {
-    (void) session;
-
+                                const AVCodecContext *ctx) {
    struct sc_audio_player *ap = DOWNCAST(sink);

 #ifdef SCRCPY_LAVU_HAS_CHLAYOUT
@@ -81,54 +61,33 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
                                                       / SC_TICK_FREQ;
    assert(aout_samples <= 0xFFFF);

-    char str[5 + 1]; // max 65535
-    int r = snprintf(str, sizeof(str), "%" PRIu16, (uint16_t) aout_samples);
-    assert(r >= 0 && (size_t) r < sizeof(str));
-    (void) r;
-    if (!SDL_SetHint(SDL_HINT_AUDIO_DEVICE_SAMPLE_FRAMES, str)) {
-        LOGE("Could not set audio output buffer");
-        sc_audio_regulator_destroy(&ap->audioreg);
-        return false;
-    }
-
-    // Make the buffer at least 1024 samples long (the hint is not always
-    // honored)
-    uint64_t aout_buffer_samples = MAX(1024, aout_samples);
-    ap->aout_buffer_size = aout_buffer_samples * sample_size;
-    ap->aout_buffer = malloc(ap->aout_buffer_size);
-    if (!ap->aout_buffer) {
-        sc_audio_regulator_destroy(&ap->audioreg);
-        return false;
-    }
-
-    SDL_AudioSpec spec = {
+    SDL_AudioSpec desired = {
        .freq = ctx->sample_rate,
        .format = SC_SDL_SAMPLE_FMT,
        .channels = nb_channels,
+        .samples = aout_samples,
+        .callback = sc_audio_player_sdl_callback,
+        .userdata = ap,
    };
+    SDL_AudioSpec obtained;

-    ap->stream = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK,
-                                           &spec,
-                                           sc_audio_player_stream_callback, ap);
-    if (!ap->stream) {
+    ap->device = SDL_OpenAudioDevice(NULL, 0, &desired, &obtained, 0);
+    if (!ap->device) {
        LOGE("Could not open audio device: %s", SDL_GetError());
-        free(ap->aout_buffer);
        sc_audio_regulator_destroy(&ap->audioreg);
        return false;
    }

-    ap->device = SDL_GetAudioStreamDevice(ap->stream);
-    assert(ap->device);
-
-    ok = SDL_ResumeAudioDevice(ap->device);
+    // The thread calling open() is the thread calling push(), which fills the
+    // audio buffer consumed by the SDL audio thread.
+    ok = sc_thread_set_priority(SC_THREAD_PRIORITY_TIME_CRITICAL);
    if (!ok) {
-        LOGE("Could not resume audio device: %s", SDL_GetError());
-        SDL_DestroyAudioStream(ap->stream);
-        free(ap->aout_buffer);
-        sc_audio_regulator_destroy(&ap->audioreg);
-        return false;
+        ok = sc_thread_set_priority(SC_THREAD_PRIORITY_HIGH);
+        (void) ok; // We don't care if it worked, at least we tried
    }

+    SDL_PauseAudioDevice(ap->device, 0);
+
    return true;
 }

@@ -136,16 +95,11 @@ static void
 sc_audio_player_frame_sink_close(struct sc_frame_sink *sink) {
    struct sc_audio_player *ap = DOWNCAST(sink);

-    assert(ap->stream);
    assert(ap->device);
-    SDL_PauseAudioDevice(ap->device);
-
-    // ap->device is owned by ap->stream
-    SDL_DestroyAudioStream(ap->stream);
+    SDL_PauseAudioDevice(ap->device, 1);
+    SDL_CloseAudioDevice(ap->device);

    sc_audio_regulator_destroy(&ap->audioreg);
-
-    free(ap->aout_buffer);
 }

 void
--- a/app/src/audio_player.h
+++ b/app/src/audio_player.h
@@ -3,7 +3,9 @@

 #include "common.h"

-#include <SDL3/SDL_audio.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <SDL2/SDL.h>

 #include "audio_regulator.h"
 #include "trait/frame_sink.h"
@@ -22,11 +24,7 @@ struct sc_audio_player {
    // SDL audio output buffer size
    sc_tick output_buffer_duration;

-    uint8_t *aout_buffer;
-    size_t aout_buffer_size;
-
-    SDL_AudioStream *stream;
-    SDL_AudioDeviceID device; // owned by the audio stream
+    SDL_AudioDeviceID device;
    struct sc_audio_regulator audioreg;
 };

--- a/app/src/audio_regulator.c
+++ b/app/src/audio_regulator.c
@@ -1,9 +1,5 @@
 #include "audio_regulator.h"

-#include <assert.h>
-#include <inttypes.h>
-#include <stdlib.h>
-#include <string.h>
 #include <libavcodec/avcodec.h>
 #include <libavutil/opt.h>

@@ -76,10 +72,8 @@ sc_audio_regulator_pull(struct sc_audio_regulator *ar, uint8_t *out,
        // Wait until the buffer is filled up to at least target_buffering
        // before playing
        if (buffered_samples < ar->target_buffering) {
-#ifdef SC_AUDIO_REGULATOR_DEBUG
-            LOGD("[Audio] Inserting initial buffering silence: %" PRIu32
+            LOGV("[Audio] Inserting initial buffering silence: %" PRIu32
                 " samples", out_samples);
-#endif
            // Delay playback starting to reach the target buffering. Fill the
            // whole buffer with silence (len is small compared to the
            // arbitrary margin value).
@@ -100,10 +94,8 @@ sc_audio_regulator_pull(struct sc_audio_regulator *ar, uint8_t *out,
        // dropped to keep the latency minimal. However, this would cause very
        // audible glitches, so let the clock compensation restore the target
        // latency.
-#ifdef SC_AUDIO_REGULATOR_DEBUG
        LOGD("[Audio] Buffer underflow, inserting silence: %" PRIu32 " samples",
             silence);
-#endif
        memset(out + TO_BYTES(read), 0, TO_BYTES(silence));

        bool received = atomic_load_explicit(&ar->received,
@@ -141,36 +133,6 @@ bool
 sc_audio_regulator_push(struct sc_audio_regulator *ar, const AVFrame *frame) {
    SwrContext *swr_ctx = ar->swr_ctx;

-    uint32_t input_samples = frame->nb_samples;
-
-    assert(frame->pts >= 0);
-    int64_t pts = frame->pts;
-    if (ar->next_expected_pts && pts - ar->next_expected_pts > 100000) {
-        LOGV("[Audio] Discontinuity detected: %" PRIi64 "µs",
-             pts - ar->next_expected_pts);
-        // More than 100ms: consider it as a discontinuity
-        // (typically because silence packets were not captured)
-        uint32_t can_read = sc_audiobuf_can_read(&ar->buf);
-        if (input_samples + can_read < ar->target_buffering) {
-            // Adjust buffering to the target value directly
-            uint32_t silence = ar->target_buffering - can_read - input_samples;
-            sc_audiobuf_write_silence(&ar->buf, silence);
-        }
-
-        // Reset state
-        ar->avg_buffering.avg = ar->target_buffering;
-        int ret = swr_set_compensation(swr_ctx, 0, 0);
-        (void) ret;
-        assert(!ret); // disabling compensation should never fail
-        ar->compensation_active = false;
-        ar->samples_since_resync = 0;
-        atomic_store_explicit(&ar->underflow, 0, memory_order_relaxed);
-    }
-
-    int64_t packet_duration = input_samples * INT64_C(1000000)
-                            / ar->sample_rate;
-    ar->next_expected_pts = pts + packet_duration;
-
    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.
@@ -243,7 +205,6 @@ sc_audio_regulator_push(struct sc_audio_regulator *ar, const AVFrame *frame) {
    if (played) {
        underflow = atomic_exchange_explicit(&ar->underflow, 0,
                                             memory_order_relaxed);
-        ar->underflow_report += underflow;

        max_buffered_samples = ar->target_buffering * 11 / 10
                             + 60 * ar->sample_rate / 1000 /* 60 ms */;
@@ -290,7 +251,7 @@ sc_audio_regulator_push(struct sc_audio_regulator *ar, const AVFrame *frame) {
    }

    // Number of samples added (or removed, if negative) for compensation
-    int32_t instant_compensation = (int32_t) written - input_samples;
+    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
@@ -346,9 +307,7 @@ sc_audio_regulator_push(struct sc_audio_regulator *ar, const AVFrame *frame) {
        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 (underflow=%" PRIu32 ")",
-             ar->target_buffering, avg, can_read, diff, ar->underflow_report);
-        ar->underflow_report = 0;
+             " compensation=%d", ar->target_buffering, avg, can_read, diff);

        int ret = swr_set_compensation(swr_ctx, diff, distance);
        if (ret < 0) {
@@ -431,9 +390,7 @@ sc_audio_regulator_init(struct sc_audio_regulator *ar, size_t sample_size,
    atomic_init(&ar->played, false);
    atomic_init(&ar->received, false);
    atomic_init(&ar->underflow, 0);
-    ar->underflow_report = 0;
    ar->compensation_active = false;
-    ar->next_expected_pts = 0;

    return true;

--- a/app/src/audio_regulator.h
+++ b/app/src/audio_regulator.h
@@ -5,8 +5,6 @@

 #include <stdatomic.h>
 #include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
 #include <libavcodec/avcodec.h>
 #include <libswresample/swresample.h>
 #include "util/audiobuf.h"
@@ -46,9 +44,6 @@ struct sc_audio_regulator {
    // Number of silence samples inserted since the last received packet
    atomic_uint_least32_t underflow;

-    // Number of silence samples inserted since the last log
-    uint32_t underflow_report;
-
    // Non-zero compensation applied (only used by the receiver thread)
    bool compensation_active;

@@ -57,9 +52,6 @@ struct sc_audio_regulator {

    // Set to true the first time samples are pulled by the player
    atomic_bool played;
-
-    // PTS of the next expected packet (useful to detect discontinuities)
-    int64_t next_expected_pts;
 };

 bool
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -5,7 +5,6 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <unistd.h>

 #include "options.h"
@@ -14,7 +13,6 @@
 #include "util/str.h"
 #include "util/strbuf.h"
 #include "util/term.h"
-#include "util/tick.h"

 #define STR_IMPL_(x) #x
 #define STR(x) STR_IMPL_(x)
@@ -113,9 +111,6 @@ enum {
    OPT_ANGLE,
    OPT_NO_VD_SYSTEM_DECORATIONS,
    OPT_NO_VD_DESTROY_CONTENT,
-    OPT_DISPLAY_IME_POLICY,
-    OPT_CAMERA_TORCH,
-    OPT_CAMERA_ZOOM,
 };

 struct sc_option {
@@ -219,31 +214,13 @@ static const struct sc_option options[] = {
        .longopt_id = OPT_AUDIO_SOURCE,
        .longopt = "audio-source",
        .argdesc = "source",
-        .text = "Select the audio source. Possible values are:\n"
-                " - \"output\": forwards the whole audio output, and disables "
-                "playback on the device.\n"
-                " - \"playback\": captures the audio playback (Android apps "
-                "can opt-out, so the whole output is not necessarily "
+        .text = "Select the audio source (output, mic or playback).\n"
+                "The \"output\" source forwards the whole audio output, and "
+                "disables playback on the device.\n"
+                "The \"playback\" source captures the audio playback (Android "
+                "apps can opt-out, so the whole output is not necessarily "
                "captured).\n"
-                " - \"mic\": captures the microphone.\n"
-                " - \"mic-unprocessed\": captures the microphone unprocessed "
-                "(raw) sound.\n"
-                " - \"mic-camcorder\": captures the microphone tuned for video "
-                "recording, with the same orientation as the camera if "
-                "available.\n"
-                " - \"mic-voice-recognition\": captures the microphone tuned "
-                "for voice recognition.\n"
-                " - \"mic-voice-communication\": captures the microphone tuned "
-                "for voice communications (it will for instance take advantage "
-                "of echo cancellation or automatic gain control if "
-                "available).\n"
-                " - \"voice-call\": captures voice call.\n"
-                " - \"voice-call-uplink\": captures voice call uplink only.\n"
-                " - \"voice-call-downlink\": captures voice call downlink "
-                "only.\n"
-                " - \"voice-performance\": captures audio meant to be "
-                "processed for live performance (karaoke), includes both the "
-                "microphone and the device playback.\n"
+                "The \"mic\" source captures the microphone.\n"
                "Default is output.",
    },
    {
@@ -315,17 +292,6 @@ static const struct sc_option options[] = {
        .argdesc = "<width>x<height>",
        .text = "Specify an explicit camera capture size.",
    },
-    {
-        .longopt_id = OPT_CAMERA_TORCH,
-        .longopt = "camera-torch",
-        .text = "Turn on the camera torch when the camera starts.",
-    },
-    {
-        .longopt_id = OPT_CAMERA_ZOOM,
-        .longopt = "camera-zoom",
-        .argdesc = "zoom",
-        .text = "Specify the camera zoom initial value.",
-    },
    {
        .longopt_id = OPT_CAPTURE_ORIENTATION,
        .longopt = "capture-orientation",
@@ -398,19 +364,6 @@ static const struct sc_option options[] = {
                "    scrcpy --list-displays\n"
                "Default is 0.",
    },
-    {
-        .longopt_id = OPT_DISPLAY_IME_POLICY,
-        .longopt = "display-ime-policy",
-        .argdesc = "value",
-        .text = "Set the policy for selecting where the IME should be "
-                "displayed.\n"
-                "Possible values are \"local\", \"fallback\" and \"hide\".\n"
-                "\"local\" means that the IME should appear on the local "
-                "display.\n"
-                "\"fallback\" means that the IME should appear on a fallback "
-                "display (the default display).\n"
-                "\"hide\" means that the IME should be hidden.",
-    },
    {
        .longopt_id = OPT_DISPLAY_ORIENTATION,
        .longopt = "display-orientation",
@@ -734,7 +687,8 @@ static const struct sc_option options[] = {
    {
        .longopt_id = OPT_NO_WINDOW,
        .longopt = "no-window",
-        .text = "Disable scrcpy window. Implies --no-video-playback.",
+        .text = "Disable scrcpy window. Implies --no-video-playback and "
+                "--no-control.",
    },
    {
        .longopt_id = OPT_ORIENTATION,
@@ -1220,22 +1174,6 @@ static const struct sc_shortcut shortcuts[] = {
        .shortcuts = { "Drag & drop non-APK file" },
        .text = "Push file to device (see --push-target)",
    },
-    {
-        .shortcuts = { "MOD+t" },
-        .text = "Turn on the camera torch (camera mode only)",
-    },
-    {
-        .shortcuts = { "MOD+Shift+t" },
-        .text = "Turn off the camera torch (camera mode only)",
-    },
-    {
-        .shortcuts = { "MOD+Up" },
-        .text = "Zoom camera in (camera mode only)",
-    },
-    {
-        .shortcuts = { "MOD+Down" },
-        .text = "Zoom camera out (camera mode only)",
-    },
 };

 static const struct sc_envvar envvars[] = {
@@ -1675,25 +1613,6 @@ parse_audio_output_buffer(const char *s, sc_tick *tick) {
    return true;
 }

-static bool
-parse_display_ime_policy(const char *s, enum sc_display_ime_policy *policy) {
-    if (!strcmp(s, "local")) {
-        *policy = SC_DISPLAY_IME_POLICY_LOCAL;
-        return true;
-    }
-    if (!strcmp(s, "fallback")) {
-        *policy = SC_DISPLAY_IME_POLICY_FALLBACK;
-        return true;
-    }
-    if (!strcmp(s, "hide")) {
-        *policy = SC_DISPLAY_IME_POLICY_HIDE;
-        return true;
-    }
-    LOGE("Unsupported display IME policy: %s (expected local, fallback or "
-         "hide)", s);
-    return false;
-}
-
 static bool
 parse_orientation(const char *s, enum sc_orientation *orientation) {
    if (!strcmp(s, "0")) {
@@ -2083,50 +2002,8 @@ parse_audio_source(const char *optarg, enum sc_audio_source *source) {
        return true;
    }

-    if (!strcmp(optarg, "mic-unprocessed")) {
-        *source = SC_AUDIO_SOURCE_MIC_UNPROCESSED;
-        return true;
-    }
-
-    if (!strcmp(optarg, "mic-camcorder")) {
-        *source = SC_AUDIO_SOURCE_MIC_CAMCORDER;
-        return true;
-    }
-
-    if (!strcmp(optarg, "mic-voice-recognition")) {
-        *source = SC_AUDIO_SOURCE_MIC_VOICE_RECOGNITION;
-        return true;
-    }
-
-    if (!strcmp(optarg, "mic-voice-communication")) {
-        *source = SC_AUDIO_SOURCE_MIC_VOICE_COMMUNICATION;
-        return true;
-    }
-
-    if (!strcmp(optarg, "voice-call")) {
-        *source = SC_AUDIO_SOURCE_VOICE_CALL;
-        return true;
-    }
-
-    if (!strcmp(optarg, "voice-call-uplink")) {
-        *source = SC_AUDIO_SOURCE_VOICE_CALL_UPLINK;
-        return true;
-    }
-
-    if (!strcmp(optarg, "voice-call-downlink")) {
-        *source = SC_AUDIO_SOURCE_VOICE_CALL_DOWNLINK;
-        return true;
-    }
-
-    if (!strcmp(optarg, "voice-performance")) {
-        *source = SC_AUDIO_SOURCE_VOICE_PERFORMANCE;
-        return true;
-    }
-
-    LOGE("Unsupported audio source: %s (expected output, mic, playback, "
-         "mic-unprocessed, mic-camcorder, mic-voice-recognition, "
-         "mic-voice-communication, voice-call, voice-call-uplink, "
-         "voice-call-downlink, voice-performance)", optarg);
+    LOGE("Unsupported audio source: %s (expected output, mic or playback)",
+         optarg);
    return false;
 }

@@ -2809,12 +2686,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
            case OPT_CAMERA_HIGH_SPEED:
                opts->camera_high_speed = true;
                break;
-            case OPT_CAMERA_TORCH:
-                opts->camera_torch = true;
-                break;
-            case OPT_CAMERA_ZOOM:
-                opts->camera_zoom = optarg;
-                break;
            case OPT_NO_WINDOW:
                opts->window = false;
                break;
@@ -2850,12 +2721,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
            case OPT_NO_VD_SYSTEM_DECORATIONS:
                opts->vd_system_decorations = false;
                break;
-            case OPT_DISPLAY_IME_POLICY:
-                if (!parse_display_ime_policy(optarg,
-                                              &opts->display_ime_policy)) {
-                    return false;
-                }
-                break;
            default:
                // getopt prints the error message on stderr
                return false;
@@ -2894,10 +2759,9 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
 #endif

    if (!opts->window) {
-        // Without window, there cannot be any video playback
+        // Without window, there cannot be any video playback or control
        opts->video_playback = false;
-        // Controls are still possible, allowing for options like
-        // --turn-screen-off
+        opts->control = false;
    }

    if (!opts->video) {
@@ -2963,7 +2827,7 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
    }
 #endif

-    if (opts->control && opts->video_source == SC_VIDEO_SOURCE_DISPLAY) {
+    if (opts->control) {
        if (opts->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_AUTO) {
            opts->keyboard_input_mode = otg ? SC_KEYBOARD_INPUT_MODE_AOA
                                            : SC_KEYBOARD_INPUT_MODE_SDK;
@@ -3112,12 +2976,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
            return false;
        }

-        if (opts->display_ime_policy != SC_DISPLAY_IME_POLICY_UNDEFINED) {
-            LOGE("--display-ime-policy is only available with "
-                 "--video-source=display");
-            return false;
-        }
-
        if (opts->camera_id && opts->camera_facing != SC_CAMERA_FACING_ANY) {
            LOGE("Cannot specify both --camera-id and --camera-facing");
            return false;
@@ -3141,10 +2999,8 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
        }

        if (opts->control) {
-            // Disable all inputs for camera
-            opts->keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_DISABLED;
-            opts->mouse_input_mode = SC_MOUSE_INPUT_MODE_DISABLED;
-            opts->gamepad_input_mode = SC_GAMEPAD_INPUT_MODE_DISABLED;
+            LOGI("Camera video source: control disabled");
+            opts->control = false;
        }
    } else if (opts->camera_id
            || opts->camera_ar
@@ -3161,12 +3017,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
        return false;
    }

-    if (opts->display_ime_policy != SC_DISPLAY_IME_POLICY_UNDEFINED
-            && opts->display_id == 0 && !opts->new_display) {
-        LOGE("--display-ime-policy is only supported on a secondary display");
-        return false;
-    }
-
    if (opts->audio && opts->audio_source == SC_AUDIO_SOURCE_AUTO) {
        // Select the audio source according to the video source
        if (opts->video_source == SC_VIDEO_SOURCE_DISPLAY) {
@@ -3371,7 +3221,7 @@ sc_get_pause_on_exit(int argc, char *argv[]) {
            }
            if (arg[15] != '=') {
                // Invalid parameter, ignore
-                return SC_PAUSE_ON_EXIT_UNDEFINED;
+                return SC_PAUSE_ON_EXIT_FALSE;
            }
            const char *value = &arg[16];
            if (!strcmp(value, "true")) {
@@ -3380,44 +3230,14 @@ sc_get_pause_on_exit(int argc, char *argv[]) {
            if (!strcmp(value, "if-error")) {
                return SC_PAUSE_ON_EXIT_IF_ERROR;
            }
-            if (!strcmp(value, "false")) {
-                return SC_PAUSE_ON_EXIT_FALSE;
-            }
-            return SC_PAUSE_ON_EXIT_UNDEFINED;
+            // Set to false, including when the value is invalid
+            return SC_PAUSE_ON_EXIT_FALSE;
        }
    }

-    return SC_PAUSE_ON_EXIT_UNDEFINED;
+    return SC_PAUSE_ON_EXIT_FALSE;
 }

-#ifdef _WIN32
-/**
- * Attempt to detect whether the user launched scrcpy by double-clicking
- * scrcpy.exe in Windows Explorer.
- *
- * If so, the console should remain open on error.
- */
-static bool
-scrcpy_launched_by_double_click(void) {
-    // No console window
-    if (GetConsoleWindow() == NULL) {
-        return false;
-    }
-
-    // Must be interactive
-    if (!_isatty(_fileno(stdin)) || !_isatty(_fileno(stdout))) {
-        return false;
-    }
-
-    // Check how many processes share the console
-    DWORD dummy;
-    DWORD count = GetConsoleProcessList(&dummy, 1);
-
-    // Only this process attached, assume it was started by double-clicking
-    return count == 1;
-}
-#endif
-
 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
    struct sc_getopt_adapter adapter;
@@ -3431,22 +3251,11 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {

    sc_getopt_adapter_destroy(&adapter);

-    if (!ret && args->pause_on_exit == SC_PAUSE_ON_EXIT_UNDEFINED) {
+    if (!ret && args->pause_on_exit == SC_PAUSE_ON_EXIT_FALSE) {
        // Check if "--pause-on-exit" is present in the arguments list, because
        // it must be taken into account even if command line parsing failed
        args->pause_on_exit = sc_get_pause_on_exit(argc, argv);
    }

-    if (args->pause_on_exit == SC_PAUSE_ON_EXIT_UNDEFINED) {
-        args->pause_on_exit = SC_PAUSE_ON_EXIT_FALSE;
-#ifdef _WIN32
-        if (scrcpy_launched_by_double_click()) {
-            args->pause_on_exit = SC_PAUSE_ON_EXIT_IF_ERROR;
-        }
-#endif
-    }
-
-    assert(args->pause_on_exit != SC_PAUSE_ON_EXIT_UNDEFINED);
-
    return ret;
 }
--- a/app/src/cli.h
+++ b/app/src/cli.h
@@ -8,7 +8,6 @@
 #include "options.h"

 enum sc_pause_on_exit {
-    SC_PAUSE_ON_EXIT_UNDEFINED,
    SC_PAUSE_ON_EXIT_TRUE,
    SC_PAUSE_ON_EXIT_FALSE,
    SC_PAUSE_ON_EXIT_IF_ERROR,
--- a/app/src/compat.h
+++ b/app/src/compat.h
@@ -6,7 +6,7 @@
 #include <libavcodec/version.h>
 #include <libavformat/version.h>
 #include <libavutil/version.h>
-#include <SDL3/SDL_version.h>
+#include <SDL2/SDL_version.h>

 #ifndef _WIN32
 # define PRIu64_ PRIu64
@@ -61,6 +61,20 @@
 # define SCRCPY_LAVC_HAS_CODECPAR_CODEC_SIDEDATA
 #endif

+#if SDL_VERSION_ATLEAST(2, 0, 6)
+// <https://github.com/libsdl-org/SDL/commit/d7a318de563125e5bb465b1000d6bc9576fbc6fc>
+# define SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
+#endif
+
+#if SDL_VERSION_ATLEAST(2, 0, 8)
+// <https://hg.libsdl.org/SDL/rev/dfde5d3f9781>
+# define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
+#endif
+
+#if SDL_VERSION_ATLEAST(2, 0, 16)
+# define SCRCPY_SDL_HAS_THREAD_PRIORITY_TIME_CRITICAL
+#endif
+
 #ifndef HAVE_STRDUP
 char *strdup(const char *s);
 #endif
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@@ -127,14 +127,10 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
            return 32;
        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
            write_position(&buf[1], &msg->inject_scroll_event.position);
-            // Accept values in the range [-16, 16].
-            // Normalize to [-1, 1] in order to use sc_float_to_i16fp().
-            float hscroll_norm = msg->inject_scroll_event.hscroll / 16;
-            hscroll_norm = CLAMP(hscroll_norm, -1, 1);
-            float vscroll_norm = msg->inject_scroll_event.vscroll / 16;
-            vscroll_norm = CLAMP(vscroll_norm, -1, 1);
-            int16_t hscroll = sc_float_to_i16fp(hscroll_norm);
-            int16_t vscroll = sc_float_to_i16fp(vscroll_norm);
+            int16_t hscroll =
+                sc_float_to_i16fp(msg->inject_scroll_event.hscroll);
+            int16_t vscroll =
+                sc_float_to_i16fp(msg->inject_scroll_event.vscroll);
            sc_write16be(&buf[13], (uint16_t) hscroll);
            sc_write16be(&buf[15], (uint16_t) vscroll);
            sc_write32be(&buf[17], msg->inject_scroll_event.buttons);
@@ -182,17 +178,12 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
            size_t len = write_string_tiny(&buf[1], msg->start_app.name, 255);
            return 1 + len;
        }
-        case SC_CONTROL_MSG_TYPE_CAMERA_SET_TORCH:
-            buf[1] = msg->camera_set_torch.on ? 1 : 0;
-            return 2;
        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
        case SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
        case SC_CONTROL_MSG_TYPE_RESET_VIDEO:
-        case SC_CONTROL_MSG_TYPE_CAMERA_ZOOM_IN:
-        case SC_CONTROL_MSG_TYPE_CAMERA_ZOOM_OUT:
            // no additional data
            return 1;
        default:
@@ -323,16 +314,6 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
        case SC_CONTROL_MSG_TYPE_RESET_VIDEO:
            LOG_CMSG("reset video");
            break;
-        case SC_CONTROL_MSG_TYPE_CAMERA_SET_TORCH:
-            LOG_CMSG("camera set torch %s",
-                     msg->camera_set_torch.on ? "on" : "off");
-            break;
-        case SC_CONTROL_MSG_TYPE_CAMERA_ZOOM_IN:
-            LOG_CMSG("camera zoom in");
-            break;
-        case SC_CONTROL_MSG_TYPE_CAMERA_ZOOM_OUT:
-            LOG_CMSG("camera zoom out");
-            break;
        default:
            LOG_CMSG("unknown type: %u", (unsigned) msg->type);
            break;
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@@ -43,9 +43,6 @@ enum sc_control_msg_type {
    SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS,
    SC_CONTROL_MSG_TYPE_START_APP,
    SC_CONTROL_MSG_TYPE_RESET_VIDEO,
-    SC_CONTROL_MSG_TYPE_CAMERA_SET_TORCH,
-    SC_CONTROL_MSG_TYPE_CAMERA_ZOOM_IN,
-    SC_CONTROL_MSG_TYPE_CAMERA_ZOOM_OUT,
 };

 enum sc_copy_key {
@@ -114,9 +111,6 @@ struct sc_control_msg {
        struct {
            char *name;
        } start_app;
-        struct {
-            bool on;
-        } camera_set_torch;
    };
 };

--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@@ -1,39 +1,31 @@
 #include "decoder.h"

-#include <errno.h>
-#include <libavcodec/packet.h>
-#include <libavutil/avutil.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/channel_layout.h>

+#include "events.h"
+#include "trait/frame_sink.h"
 #include "util/log.h"

 /** Downcast packet_sink to decoder */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_decoder, packet_sink)

 static bool
-sc_decoder_open(struct sc_decoder *decoder, AVCodecContext *ctx,
-                const struct sc_stream_session *session) {
+sc_decoder_open(struct sc_decoder *decoder, AVCodecContext *ctx) {
    decoder->frame = av_frame_alloc();
    if (!decoder->frame) {
        LOG_OOM();
        return false;
    }

-    if (!sc_frame_source_sinks_open(&decoder->frame_source, ctx, session)) {
+    if (!sc_frame_source_sinks_open(&decoder->frame_source, ctx)) {
        av_frame_free(&decoder->frame);
        return false;
    }

    decoder->ctx = ctx;

-    // A video stream must have a session
-    assert(session || ctx->codec_type != AVMEDIA_TYPE_VIDEO);
-
-    if (session) {
-        decoder->session = *session;
-    }
-
-    memset(&decoder->frame_size, 0, sizeof(decoder->frame_size));
-
    return true;
 }

@@ -71,32 +63,6 @@ sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {
        }

        // a frame was received
-
-        if (decoder->ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
-            assert(decoder->frame->width >= 0);
-            assert(decoder->frame->height >= 0);
-            struct sc_size frame_size = {
-                .width = decoder->frame->width,
-                .height = decoder->frame->height,
-            };
-            if (decoder->frame_size.width != frame_size.width
-                    || decoder->frame_size.height != frame_size.height) {
-                // The frame size has changed, check if it matches the session
-                uint32_t sw = decoder->session.video.width;
-                uint32_t sh = decoder->session.video.height;
-                if (frame_size.width != sw || frame_size.height != sh) {
-                    LOGW("Unexpected video size: %" PRIu32 "x%" PRIu32
-                         " (expected %" PRIu32 "x%" PRIu32 ")",
-                         frame_size.width, frame_size.height, sw, sh);
-
-                    LOGW("The encoder did not respect the requested size, "
-                         "please retry with a lower resolution (-m/--max-size)");
-                }
-            }
-
-            decoder->frame_size = frame_size;
-        }
-
        bool ok = sc_frame_source_sinks_push(&decoder->frame_source,
                                             decoder->frame);
        av_frame_unref(decoder->frame);
@@ -110,17 +76,9 @@ sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {
 }

 static bool
-sc_decoder_push_session(struct sc_decoder *decoder,
-                        const struct sc_stream_session *session) {
-    decoder->session = *session;
-    return sc_frame_source_sinks_push_session(&decoder->frame_source, session);
-}
-
-static bool
-sc_decoder_packet_sink_open(struct sc_packet_sink *sink, AVCodecContext *ctx,
-                            const struct sc_stream_session *session) {
+sc_decoder_packet_sink_open(struct sc_packet_sink *sink, AVCodecContext *ctx) {
    struct sc_decoder *decoder = DOWNCAST(sink);
-    return sc_decoder_open(decoder, ctx, session);
+    return sc_decoder_open(decoder, ctx);
 }

 static void
@@ -136,14 +94,6 @@ sc_decoder_packet_sink_push(struct sc_packet_sink *sink,
    return sc_decoder_push(decoder, packet);
 }

-static bool
-sc_decoder_packet_sink_push_session(struct sc_packet_sink *sink,
-                                    const struct sc_stream_session *session) {
-
-    struct sc_decoder *decoder = DOWNCAST(sink);
-    return sc_decoder_push_session(decoder, session);
-}
-
 void
 sc_decoder_init(struct sc_decoder *decoder, const char *name) {
    decoder->name = name; // statically allocated
@@ -153,7 +103,6 @@ sc_decoder_init(struct sc_decoder *decoder, const char *name) {
        .open = sc_decoder_packet_sink_open,
        .close = sc_decoder_packet_sink_close,
        .push = sc_decoder_packet_sink_push,
-        .push_session = sc_decoder_packet_sink_push_session,
    };

    decoder->packet_sink.ops = &ops;
--- a/app/src/decoder.h
+++ b/app/src/decoder.h
@@ -3,12 +3,13 @@

 #include "common.h"

-#include <libavcodec/avcodec.h>
-
-#include "coords.h"
 #include "trait/frame_source.h"
 #include "trait/packet_sink.h"

+#include <stdbool.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+
 struct sc_decoder {
    struct sc_packet_sink packet_sink; // packet sink trait
    struct sc_frame_source frame_source; // frame source trait
@@ -17,9 +18,6 @@ struct sc_decoder {

    AVCodecContext *ctx;
    AVFrame *frame;
-
-    struct sc_stream_session session; // only initialized for video stream
-    struct sc_size frame_size;
 };

 // The name must be statically allocated (e.g. a string literal)
--- a/app/src/delay_buffer.c
+++ b/app/src/delay_buffer.c
@@ -2,7 +2,9 @@

 #include <assert.h>
 #include <stdlib.h>
-#include <libavcodec/avcodec.h>
+
+#include <libavutil/avutil.h>
+#include <libavformat/avformat.h>

 #include "util/log.h"

@@ -10,18 +12,16 @@
 #define DOWNCAST(SINK) container_of(SINK, struct sc_delay_buffer, frame_sink)

 static bool
-sc_delayed_packet_init_frame(struct sc_delayed_packet *dpacket,
-                             const AVFrame *frame) {
-    dpacket->type = SC_DELAYED_PACKET_TYPE_FRAME;
-    dpacket->frame = av_frame_alloc();
-    if (!dpacket->frame) {
+sc_delayed_frame_init(struct sc_delayed_frame *dframe, const AVFrame *frame) {
+    dframe->frame = av_frame_alloc();
+    if (!dframe->frame) {
        LOG_OOM();
        return false;
    }

-    if (av_frame_ref(dpacket->frame, frame)) {
+    if (av_frame_ref(dframe->frame, frame)) {
        LOG_OOM();
-        av_frame_free(&dpacket->frame);
+        av_frame_free(&dframe->frame);
        return false;
    }

@@ -29,18 +29,9 @@ sc_delayed_packet_init_frame(struct sc_delayed_packet *dpacket,
 }

 static void
-sc_delayed_packet_init_session(struct sc_delayed_packet *dpacket,
-                               const struct sc_stream_session *session) {
-    dpacket->type = SC_DELAYED_PACKET_TYPE_SESSION;
-    dpacket->session = *session;
-}
-
-static void
-sc_delayed_packet_destroy(struct sc_delayed_packet *dpacket) {
-    if (dpacket->type == SC_DELAYED_PACKET_TYPE_FRAME) {
-        av_frame_unref(dpacket->frame);
-        av_frame_free(&dpacket->frame);
-    }
+sc_delayed_frame_destroy(struct sc_delayed_frame *dframe) {
+    av_frame_unref(dframe->frame);
+    av_frame_free(&dframe->frame);
 }

 static int
@@ -61,52 +52,43 @@ run_buffering(void *data) {
            goto stopped;
        }

-        struct sc_delayed_packet dpacket = sc_vecdeque_pop(&db->queue);
+        struct sc_delayed_frame dframe = sc_vecdeque_pop(&db->queue);

-        bool ok;
-        if (dpacket.type == SC_DELAYED_PACKET_TYPE_FRAME) {
-            sc_tick max_deadline = sc_tick_now() + db->delay;
-            // PTS (written by the server) are expressed in microseconds
-            sc_tick pts = SC_TICK_FROM_US(dpacket.frame->pts);
+        sc_tick max_deadline = sc_tick_now() + db->delay;
+        // PTS (written by the server) are expressed in microseconds
+        sc_tick pts = SC_TICK_FROM_US(dframe.frame->pts);

-            bool timed_out = false;
-            while (!db->stopped && !timed_out) {
-                sc_tick deadline = sc_clock_to_system_time(&db->clock, pts)
-                                 + db->delay;
-                if (deadline > max_deadline) {
-                    deadline = max_deadline;
-                }
-
-                timed_out =
-                    !sc_cond_timedwait(&db->wait_cond, &db->mutex, deadline);
+        bool timed_out = false;
+        while (!db->stopped && !timed_out) {
+            sc_tick deadline = sc_clock_to_system_time(&db->clock, pts)
+                             + db->delay;
+            if (deadline > max_deadline) {
+                deadline = max_deadline;
            }

-            bool stopped = db->stopped;
-            sc_mutex_unlock(&db->mutex);
-
-            if (stopped) {
-                sc_delayed_packet_destroy(&dpacket);
-                goto stopped;
-            }
-
-#ifdef SC_BUFFERING_DEBUG
-            LOGD("Buffering: %" PRItick ";%" PRItick ";%" PRItick,
-                 pts, dframe.push_date, sc_tick_now());
-#endif
-
-            ok = sc_frame_source_sinks_push(&db->frame_source, dpacket.frame);
-        } else {
-            assert(dpacket.type == SC_DELAYED_PACKET_TYPE_SESSION);
-            sc_mutex_unlock(&db->mutex);
-            ok = sc_frame_source_sinks_push_session(&db->frame_source,
-                                                    &dpacket.session);
+            timed_out =
+                !sc_cond_timedwait(&db->wait_cond, &db->mutex, deadline);
        }

-        sc_delayed_packet_destroy(&dpacket);
+        bool stopped = db->stopped;
+        sc_mutex_unlock(&db->mutex);
+
+        if (stopped) {
+            sc_delayed_frame_destroy(&dframe);
+            goto stopped;
+        }
+
+#ifdef SC_BUFFERING_DEBUG
+        LOGD("Buffering: %" PRItick ";%" PRItick ";%" PRItick,
+             pts, dframe.push_date, sc_tick_now());
+#endif
+
+        bool ok = sc_frame_source_sinks_push(&db->frame_source, dframe.frame);
+        sc_delayed_frame_destroy(&dframe);
        if (!ok) {
-            LOGE("Delayed packet could not be pushed, stopping");
+            LOGE("Delayed frame could not be pushed, stopping");
            sc_mutex_lock(&db->mutex);
-            // Prevent to push any new packet
+            // Prevent to push any new frame
            db->stopped = true;
            sc_mutex_unlock(&db->mutex);
            goto stopped;
@@ -118,8 +100,8 @@ stopped:

    // Flush queue
    while (!sc_vecdeque_is_empty(&db->queue)) {
-        struct sc_delayed_packet *dpacket = sc_vecdeque_popref(&db->queue);
-        sc_delayed_packet_destroy(dpacket);
+        struct sc_delayed_frame *dframe = sc_vecdeque_popref(&db->queue);
+        sc_delayed_frame_destroy(dframe);
    }

    LOGD("Buffering thread ended");
@@ -129,11 +111,9 @@ stopped:

 static bool
 sc_delay_buffer_frame_sink_open(struct sc_frame_sink *sink,
-                                const AVCodecContext *ctx,
-                                const struct sc_stream_session *session) {
+                                const AVCodecContext *ctx) {
    struct sc_delay_buffer *db = DOWNCAST(sink);
    (void) ctx;
-    (void) session;

    bool ok = sc_mutex_init(&db->mutex);
    if (!ok) {
@@ -154,7 +134,7 @@ sc_delay_buffer_frame_sink_open(struct sc_frame_sink *sink,
    sc_vecdeque_init(&db->queue);
    db->stopped = false;

-    if (!sc_frame_source_sinks_open(&db->frame_source, ctx, session)) {
+    if (!sc_frame_source_sinks_open(&db->frame_source, ctx)) {
        goto error_destroy_wait_cond;
    }

@@ -218,56 +198,24 @@ sc_delay_buffer_frame_sink_push(struct sc_frame_sink *sink,
        return sc_frame_source_sinks_push(&db->frame_source, frame);
    }

-    struct sc_delayed_packet *dpacket = sc_vecdeque_push_hole(&db->queue);
-    if (!dpacket) {
+    struct sc_delayed_frame dframe;
+    bool ok = sc_delayed_frame_init(&dframe, frame);
+    if (!ok) {
        sc_mutex_unlock(&db->mutex);
-        LOG_OOM();
        return false;
    }

-    bool ok = sc_delayed_packet_init_frame(dpacket, frame);
+#ifdef SC_BUFFERING_DEBUG
+    dframe.push_date = sc_tick_now();
+#endif
+
+    ok = sc_vecdeque_push(&db->queue, dframe);
    if (!ok) {
        sc_mutex_unlock(&db->mutex);
        LOG_OOM();
        return false;
    }

-#ifdef SC_BUFFERING_DEBUG
-    dpacket->push_date = sc_tick_now();
-#endif
-
-    sc_cond_signal(&db->queue_cond);
-
-    sc_mutex_unlock(&db->mutex);
-
-    return true;
-}
-
-static bool
-sc_delay_buffer_frame_sink_push_session(struct sc_frame_sink *sink,
-                                      const struct sc_stream_session *session) {
-    struct sc_delay_buffer *db = DOWNCAST(sink);
-
-    sc_mutex_lock(&db->mutex);
-
-    if (db->stopped) {
-        sc_mutex_unlock(&db->mutex);
-        return false;
-    }
-
-    struct sc_delayed_packet *dpacket = sc_vecdeque_push_hole(&db->queue);
-    if (!dpacket) {
-        sc_mutex_unlock(&db->mutex);
-        LOG_OOM();
-        return false;
-    }
-
-    sc_delayed_packet_init_session(dpacket, session);
-
-#ifdef SC_BUFFERING_DEBUG
-    dpacket->push_date = sc_tick_now();
-#endif
-
    sc_cond_signal(&db->queue_cond);

    sc_mutex_unlock(&db->mutex);
@@ -289,7 +237,6 @@ sc_delay_buffer_init(struct sc_delay_buffer *db, sc_tick delay,
        .open = sc_delay_buffer_frame_sink_open,
        .close = sc_delay_buffer_frame_sink_close,
        .push = sc_delay_buffer_frame_sink_push,
-        .push_session = sc_delay_buffer_frame_sink_push_session,
    };

    db->frame_sink.ops = &ops;
--- a/app/src/delay_buffer.h
+++ b/app/src/delay_buffer.h
@@ -4,7 +4,6 @@
 #include "common.h"

 #include <stdbool.h>
-#include <libavutil/frame.h>

 #include "clock.h"
 #include "trait/frame_source.h"
@@ -18,23 +17,14 @@
 // forward declarations
 typedef struct AVFrame AVFrame;

-enum sc_delayed_packet_type {
-    SC_DELAYED_PACKET_TYPE_FRAME,
-    SC_DELAYED_PACKET_TYPE_SESSION,
-};
-
-struct sc_delayed_packet {
-    enum sc_delayed_packet_type type;
-    union {
-        AVFrame *frame;
-        struct sc_stream_session session;
-    };
+struct sc_delayed_frame {
+    AVFrame *frame;
 #ifdef SC_BUFFERING_DEBUG
    sc_tick push_date;
 #endif
 };

-struct sc_delayed_packet_queue SC_VECDEQUE(struct sc_delayed_packet);
+struct sc_delayed_frame_queue SC_VECDEQUE(struct sc_delayed_frame);

 struct sc_delay_buffer {
    struct sc_frame_source frame_source; // frame source trait
@@ -49,7 +39,7 @@ struct sc_delay_buffer {
    sc_cond wait_cond;

    struct sc_clock clock;
-    struct sc_delayed_packet_queue queue;
+    struct sc_delayed_frame_queue queue;
    bool stopped;
 };

--- a/app/src/demuxer.c
+++ b/app/src/demuxer.c
@@ -1,18 +1,21 @@
 #include "demuxer.h"

 #include <assert.h>
-#include <inttypes.h>
-#include <libavcodec/avcodec.h>
 #include <libavutil/channel_layout.h>
+#include <libavutil/time.h>
+#include <unistd.h>

+#include "decoder.h"
+#include "events.h"
 #include "packet_merger.h"
+#include "recorder.h"
 #include "util/binary.h"
 #include "util/log.h"

 #define SC_PACKET_HEADER_SIZE 12

-#define SC_PACKET_FLAG_CONFIG    (UINT64_C(1) << 62)
-#define SC_PACKET_FLAG_KEY_FRAME (UINT64_C(1) << 61)
+#define SC_PACKET_FLAG_CONFIG    (UINT64_C(1) << 63)
+#define SC_PACKET_FLAG_KEY_FRAME (UINT64_C(1) << 62)

 #define SC_PACKET_PTS_MASK (SC_PACKET_FLAG_KEY_FRAME - 1)

@@ -63,75 +66,48 @@ sc_demuxer_recv_codec_id(struct sc_demuxer *demuxer, uint32_t *codec_id) {
    return true;
 }

-static inline bool
-sc_demuxer_recv_header(struct sc_demuxer *demuxer,
-                       uint8_t buf[static SC_PACKET_HEADER_SIZE]) {
+static bool
+sc_demuxer_recv_video_size(struct sc_demuxer *demuxer, uint32_t *width,
+                           uint32_t *height) {
+    uint8_t data[8];
+    ssize_t r = net_recv_all(demuxer->socket, data, 8);
+    if (r < 8) {
+        return false;
+    }
+
+    *width = sc_read32be(data);
+    *height = sc_read32be(data + 4);
+    return true;
+}
+
+static bool
+sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
    // The video and audio streams contain a sequence of raw packets (as
    // provided by MediaCodec), each prefixed with a "meta" header.
    //
-    // The "meta" header length is 12 bytes.
-    //
-    //
-    // If the MSB is 1, then it is a session packet (for a video stream only),
-    // which only contains a 12-byte header:
-    //
-    //  byte 0   byte 1   byte 2   byte 3
-    // 10000000 00000000 00000000 00000000
-    // ^<-------------------------------->
-    // |               padding
-    //  `- session packet flag
-    //
-    //  byte 4   byte 5   byte 6   byte 7   byte 8   byte 9   byte 10  byte 11
-    // ........ ........ ........ ........ ........ ........ ........ ........
-    // <---------------------------------> <--------------------------------->
-    //             video width                         video height
-    //
-    //
-    // If the MSB is 0, then it is a media packet, comprised of a 12-byte header
-    // followed by <packet_size> bytes containing the packet/frame:
-    //
+    // The "meta" header length is 12 bytes:
    // [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
    //  <-------------> <-----> <-----------------------------...
    //        PTS        packet        raw packet
    //                    size
    //
+    // It is followed by <packet_size> bytes containing the packet/frame.
+    //
    // The most significant bits of the PTS are used for packet flags:
    //
-    //  byte 0   byte 1   byte 2   byte 3   byte 4   byte 5   byte 6   byte 7
-    // 0CK..... ........ ........ ........ ........ ........ ........ ........
-    // ^^^<------------------------------------------------------------------>
-    // |||                                PTS
-    // || `- key frame
-    // | `-- config packet
-    //  `--- media packet flag
-    //
-    //  byte 8   byte 9   byte 10  byte 11
-    // ........ ........ ........ ........ ........ ........ . . .
-    // <---------------------------------> <---------------- . . .
-    //            packet size                       raw packet
-    //
-    ssize_t r = net_recv_all(demuxer->socket, buf, SC_PACKET_HEADER_SIZE);
-    assert(r <= SC_PACKET_HEADER_SIZE);
-    return r == SC_PACKET_HEADER_SIZE;
-}
+    //  byte 7   byte 6   byte 5   byte 4   byte 3   byte 2   byte 1   byte 0
+    // CK...... ........ ........ ........ ........ ........ ........ ........
+    // ^^<------------------------------------------------------------------->
+    // ||                                PTS
+    // | `- key frame
+    //  `-- config packet

-static bool
-sc_demuxer_is_session(const uint8_t *header) {
-    return header[0] & 0x80;
-}
+    uint8_t header[SC_PACKET_HEADER_SIZE];
+    ssize_t r = net_recv_all(demuxer->socket, header, SC_PACKET_HEADER_SIZE);
+    if (r < SC_PACKET_HEADER_SIZE) {
+        return false;
+    }

-static void
-sc_demuxer_parse_session(const uint8_t *header,
-                         struct sc_stream_session *session) {
-    assert(sc_demuxer_is_session(header));
-    session->video.width = sc_read32be(&header[4]);
-    session->video.height = sc_read32be(&header[8]);
-}
-
-static bool
-sc_demuxer_recv_packet(struct sc_demuxer *demuxer, const uint8_t *header,
-                       AVPacket *packet) {
-    assert(!sc_demuxer_is_session(header));
    uint64_t pts_flags = sc_read64be(header);
    uint32_t len = sc_read32be(&header[8]);
    assert(len);
@@ -141,7 +117,7 @@ sc_demuxer_recv_packet(struct sc_demuxer *demuxer, const uint8_t *header,
        return false;
    }

-    ssize_t r = net_recv_all(demuxer->socket, packet->data, len);
+    r = net_recv_all(demuxer->socket, packet->data, len);
    if (r < 0 || ((uint32_t) r) < len) {
        av_packet_unref(packet);
        return false;
@@ -214,28 +190,17 @@ run_demuxer(void *data) {

    codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;

-    uint8_t header[SC_PACKET_HEADER_SIZE];
-    struct sc_stream_session session_data;
-
-    struct sc_stream_session *session = NULL;
    if (codec->type == AVMEDIA_TYPE_VIDEO) {
-        bool ok = sc_demuxer_recv_header(demuxer, header);
+        uint32_t width;
+        uint32_t height;
+        ok = sc_demuxer_recv_video_size(demuxer, &width, &height);
        if (!ok) {
            goto finally_free_context;
        }

-        if (!sc_demuxer_is_session(header)) {
-            LOGE("Unexpected packet (not a session header)");
-            goto finally_free_context;
-        }
-
-        session = &session_data;
-        sc_demuxer_parse_session(header, session);
-
-        codec_ctx->width = session_data.video.width;
-        codec_ctx->height = session_data.video.height;
+        codec_ctx->width = width;
+        codec_ctx->height = height;
        codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
-
    } else {
        // Hardcoded audio properties
 #ifdef SCRCPY_LAVU_HAS_CHLAYOUT
@@ -257,8 +222,7 @@ run_demuxer(void *data) {
        goto finally_free_context;
    }

-    if (!sc_packet_source_sinks_open(&demuxer->packet_source, codec_ctx,
-                                     session)) {
+    if (!sc_packet_source_sinks_open(&demuxer->packet_source, codec_ctx)) {
        goto finally_free_context;
    }

@@ -280,39 +244,27 @@ run_demuxer(void *data) {
    }

    for (;;) {
-        bool ok = sc_demuxer_recv_header(demuxer, header);
+        bool ok = sc_demuxer_recv_packet(demuxer, packet);
        if (!ok) {
            // end of stream
            status = SC_DEMUXER_STATUS_EOS;
            break;
        }

-        if (sc_demuxer_is_session(header)) {
-            sc_demuxer_parse_session(header, &session_data);
-            ok = sc_packet_source_sinks_push_session(&demuxer->packet_source,
-                                                     &session_data);
+        if (must_merge_config_packet) {
+            // Prepend any config packet to the next media packet
+            ok = sc_packet_merger_merge(&merger, packet);
            if (!ok) {
-                // The sink already logged its concrete error
+                av_packet_unref(packet);
                break;
            }
-        } else {
-            sc_demuxer_recv_packet(demuxer, header, packet);
+        }

-            if (must_merge_config_packet) {
-                // Prepend any config packet to the next media packet
-                ok = sc_packet_merger_merge(&merger, packet);
-                if (!ok) {
-                    av_packet_unref(packet);
-                    break;
-                }
-            }
-
-            ok = sc_packet_source_sinks_push(&demuxer->packet_source, packet);
-            av_packet_unref(packet);
-            if (!ok) {
-                // The sink already logged its concrete error
-                break;
-            }
+        ok = sc_packet_source_sinks_push(&demuxer->packet_source, packet);
+        av_packet_unref(packet);
+        if (!ok) {
+            // The sink already logged its concrete error
+            break;
        }
    }

--- a/app/src/demuxer.h
+++ b/app/src/demuxer.h
@@ -4,8 +4,12 @@
 #include "common.h"

 #include <stdbool.h>
+#include <stdint.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>

 #include "trait/packet_source.h"
+#include "trait/packet_sink.h"
 #include "util/net.h"
 #include "util/thread.h"

--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@@ -53,7 +53,7 @@ sc_device_msg_deserialize(const uint8_t *buf, size_t len,
            }
            uint16_t id = sc_read16be(&buf[1]);
            size_t size = sc_read16be(&buf[3]);
-            if (size > len - 5) {
+            if (size < len - 5) {
                return 0; // not available
            }
            uint8_t *data = malloc(size);
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@@ -3,9 +3,9 @@

 #include "common.h"

-#include <stddef.h>
+#include <stdbool.h>
 #include <stdint.h>
-#include <sys/types.h>
+#include <unistd.h>

 #define DEVICE_MSG_MAX_SIZE (1 << 18) // 256k
 // type: 1 byte; length: 4 bytes
--- a/app/src/display.c
+++ b/app/src/display.c
@@ -0,0 +1,342 @@
+#include "display.h"
+
+#include <assert.h>
+#include <libavutil/pixfmt.h>
+
+#include "util/log.h"
+
+static bool
+sc_display_init_novideo_icon(struct sc_display *display,
+                             SDL_Surface *icon_novideo) {
+    assert(icon_novideo);
+
+    if (SDL_RenderSetLogicalSize(display->renderer,
+                                 icon_novideo->w, icon_novideo->h)) {
+        LOGW("Could not set renderer logical size: %s", SDL_GetError());
+        // don't fail
+    }
+
+    display->texture = SDL_CreateTextureFromSurface(display->renderer,
+                                                    icon_novideo);
+    if (!display->texture) {
+        LOGE("Could not create texture: %s", SDL_GetError());
+        return false;
+    }
+
+    return true;
+}
+
+bool
+sc_display_init(struct sc_display *display, SDL_Window *window,
+                SDL_Surface *icon_novideo, bool mipmaps) {
+    display->renderer =
+        SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+    if (!display->renderer) {
+        LOGE("Could not create renderer: %s", SDL_GetError());
+        return false;
+    }
+
+    SDL_RendererInfo renderer_info;
+    int r = SDL_GetRendererInfo(display->renderer, &renderer_info);
+    const char *renderer_name = r ? NULL : renderer_info.name;
+    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
+
+    display->mipmaps = false;
+
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+    display->gl_context = NULL;
+#endif
+
+    // starts with "opengl"
+    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
+    if (use_opengl) {
+
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+        // Persuade macOS to give us something better than OpenGL 2.1.
+        // If we create a Core Profile context, we get the best OpenGL version.
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
+                            SDL_GL_CONTEXT_PROFILE_CORE);
+
+        LOGD("Creating OpenGL Core Profile context");
+        display->gl_context = SDL_GL_CreateContext(window);
+        if (!display->gl_context) {
+            LOGE("Could not create OpenGL context: %s", SDL_GetError());
+            SDL_DestroyRenderer(display->renderer);
+            return false;
+        }
+#endif
+
+        struct sc_opengl *gl = &display->gl;
+        sc_opengl_init(gl);
+
+        LOGI("OpenGL version: %s", gl->version);
+
+        if (mipmaps) {
+            bool supports_mipmaps =
+                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
+                                               2, 0  /* OpenGL ES 2.0+ */);
+            if (supports_mipmaps) {
+                LOGI("Trilinear filtering enabled");
+                display->mipmaps = true;
+            } else {
+                LOGW("Trilinear filtering disabled "
+                     "(OpenGL 3.0+ or ES 2.0+ required)");
+            }
+        } else {
+            LOGI("Trilinear filtering disabled");
+        }
+    } else if (mipmaps) {
+        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
+    }
+
+    display->texture = NULL;
+    display->pending.flags = 0;
+    display->pending.frame = NULL;
+    display->has_frame = false;
+
+    if (icon_novideo) {
+        // Without video, set a static scrcpy icon as window content
+        bool ok = sc_display_init_novideo_icon(display, icon_novideo);
+        if (!ok) {
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+            SDL_GL_DeleteContext(display->gl_context);
+#endif
+            SDL_DestroyRenderer(display->renderer);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void
+sc_display_destroy(struct sc_display *display) {
+    if (display->pending.frame) {
+        av_frame_free(&display->pending.frame);
+    }
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+    SDL_GL_DeleteContext(display->gl_context);
+#endif
+    if (display->texture) {
+        SDL_DestroyTexture(display->texture);
+    }
+    SDL_DestroyRenderer(display->renderer);
+}
+
+static SDL_Texture *
+sc_display_create_texture(struct sc_display *display,
+                          struct sc_size size) {
+    SDL_Renderer *renderer = display->renderer;
+    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
+                                             SDL_TEXTUREACCESS_STREAMING,
+                                             size.width, size.height);
+    if (!texture) {
+        LOGD("Could not create texture: %s", SDL_GetError());
+        return NULL;
+    }
+
+    if (display->mipmaps) {
+        struct sc_opengl *gl = &display->gl;
+
+        SDL_GL_BindTexture(texture, NULL, NULL);
+
+        // Enable trilinear filtering for downscaling
+        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                          GL_LINEAR_MIPMAP_LINEAR);
+        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
+
+        SDL_GL_UnbindTexture(texture);
+    }
+
+    return texture;
+}
+
+static inline void
+sc_display_set_pending_size(struct sc_display *display, struct sc_size size) {
+    assert(!display->texture);
+    display->pending.size = size;
+    display->pending.flags |= SC_DISPLAY_PENDING_FLAG_SIZE;
+}
+
+static bool
+sc_display_set_pending_frame(struct sc_display *display, const AVFrame *frame) {
+    if (!display->pending.frame) {
+        display->pending.frame = av_frame_alloc();
+        if (!display->pending.frame) {
+            LOG_OOM();
+            return false;
+        }
+    }
+
+    int r = av_frame_ref(display->pending.frame, frame);
+    if (r) {
+        LOGE("Could not ref frame: %d", r);
+        return false;
+    }
+
+    display->pending.flags |= SC_DISPLAY_PENDING_FLAG_FRAME;
+
+    return true;
+}
+
+static bool
+sc_display_apply_pending(struct sc_display *display) {
+    if (display->pending.flags & SC_DISPLAY_PENDING_FLAG_SIZE) {
+        assert(!display->texture);
+        display->texture =
+            sc_display_create_texture(display, display->pending.size);
+        if (!display->texture) {
+            return false;
+        }
+
+        display->pending.flags &= ~SC_DISPLAY_PENDING_FLAG_SIZE;
+    }
+
+    if (display->pending.flags & SC_DISPLAY_PENDING_FLAG_FRAME) {
+        assert(display->pending.frame);
+        bool ok = sc_display_update_texture(display, display->pending.frame);
+        if (!ok) {
+            return false;
+        }
+
+        av_frame_unref(display->pending.frame);
+        display->pending.flags &= ~SC_DISPLAY_PENDING_FLAG_FRAME;
+    }
+
+    return true;
+}
+
+static bool
+sc_display_set_texture_size_internal(struct sc_display *display,
+                                     struct sc_size size) {
+    assert(size.width && size.height);
+
+    if (display->texture) {
+        SDL_DestroyTexture(display->texture);
+    }
+
+    display->texture = sc_display_create_texture(display, size);
+    if (!display->texture) {
+        return false;
+    }
+
+    LOGI("Texture: %" PRIu16 "x%" PRIu16, size.width, size.height);
+    return true;
+}
+
+enum sc_display_result
+sc_display_set_texture_size(struct sc_display *display, struct sc_size size) {
+    bool ok = sc_display_set_texture_size_internal(display, size);
+    if (!ok) {
+        sc_display_set_pending_size(display, size);
+        return SC_DISPLAY_RESULT_PENDING;
+
+    }
+
+    return SC_DISPLAY_RESULT_OK;
+}
+
+static SDL_YUV_CONVERSION_MODE
+sc_display_to_sdl_color_range(enum AVColorRange color_range) {
+    return color_range == AVCOL_RANGE_JPEG ? SDL_YUV_CONVERSION_JPEG
+                                           : SDL_YUV_CONVERSION_AUTOMATIC;
+}
+
+static bool
+sc_display_update_texture_internal(struct sc_display *display,
+                                   const AVFrame *frame) {
+    if (!display->has_frame) {
+        // First frame
+        display->has_frame = true;
+
+        // Configure YUV color range conversion
+        SDL_YUV_CONVERSION_MODE sdl_color_range =
+            sc_display_to_sdl_color_range(frame->color_range);
+        SDL_SetYUVConversionMode(sdl_color_range);
+    }
+
+    int ret = SDL_UpdateYUVTexture(display->texture, NULL,
+                                   frame->data[0], frame->linesize[0],
+                                   frame->data[1], frame->linesize[1],
+                                   frame->data[2], frame->linesize[2]);
+    if (ret) {
+        LOGD("Could not update texture: %s", SDL_GetError());
+        return false;
+    }
+
+    if (display->mipmaps) {
+        SDL_GL_BindTexture(display->texture, NULL, NULL);
+        display->gl.GenerateMipmap(GL_TEXTURE_2D);
+        SDL_GL_UnbindTexture(display->texture);
+    }
+
+    return true;
+}
+
+enum sc_display_result
+sc_display_update_texture(struct sc_display *display, const AVFrame *frame) {
+    bool ok = sc_display_update_texture_internal(display, frame);
+    if (!ok) {
+        ok = sc_display_set_pending_frame(display, frame);
+        if (!ok) {
+            LOGE("Could not set pending frame");
+            return SC_DISPLAY_RESULT_ERROR;
+        }
+
+        return SC_DISPLAY_RESULT_PENDING;
+    }
+
+    return SC_DISPLAY_RESULT_OK;
+}
+
+enum sc_display_result
+sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
+                  enum sc_orientation orientation) {
+    SDL_RenderClear(display->renderer);
+
+    if (display->pending.flags) {
+        bool ok = sc_display_apply_pending(display);
+        if (!ok) {
+            return SC_DISPLAY_RESULT_PENDING;
+        }
+    }
+
+    SDL_Renderer *renderer = display->renderer;
+    SDL_Texture *texture = display->texture;
+
+    if (orientation == SC_ORIENTATION_0) {
+        int ret = SDL_RenderCopy(renderer, texture, NULL, geometry);
+        if (ret) {
+            LOGE("Could not render texture: %s", SDL_GetError());
+            return SC_DISPLAY_RESULT_ERROR;
+        }
+    } else {
+        unsigned cw_rotation = sc_orientation_get_rotation(orientation);
+        double angle = 90 * cw_rotation;
+
+        const SDL_Rect *dstrect = NULL;
+        SDL_Rect rect;
+        if (sc_orientation_is_swap(orientation)) {
+            rect.x = geometry->x + (geometry->w - geometry->h) / 2;
+            rect.y = geometry->y + (geometry->h - geometry->w) / 2;
+            rect.w = geometry->h;
+            rect.h = geometry->w;
+            dstrect = &rect;
+        } else {
+            dstrect = geometry;
+        }
+
+        SDL_RendererFlip flip = sc_orientation_is_mirror(orientation)
+                              ? SDL_FLIP_HORIZONTAL : 0;
+
+        int ret = SDL_RenderCopyEx(renderer, texture, NULL, dstrect, angle,
+                                   NULL, flip);
+        if (ret) {
+            LOGE("Could not render texture: %s", SDL_GetError());
+            return SC_DISPLAY_RESULT_ERROR;
+        }
+    }
+
+    SDL_RenderPresent(display->renderer);
+    return SC_DISPLAY_RESULT_OK;
+}
--- a/app/src/display.h
+++ b/app/src/display.h
@@ -0,0 +1,63 @@
+#ifndef SC_DISPLAY_H
+#define SC_DISPLAY_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <libavformat/avformat.h>
+#include <SDL2/SDL.h>
+
+#include "coords.h"
+#include "opengl.h"
+#include "options.h"
+
+#ifdef __APPLE__
+# define SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+#endif
+
+struct sc_display {
+    SDL_Renderer *renderer;
+    SDL_Texture *texture;
+
+    struct sc_opengl gl;
+#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
+    SDL_GLContext *gl_context;
+#endif
+
+    bool mipmaps;
+
+    struct {
+#define SC_DISPLAY_PENDING_FLAG_SIZE 1
+#define SC_DISPLAY_PENDING_FLAG_FRAME 2
+        int8_t flags;
+        struct sc_size size;
+        AVFrame *frame;
+    } pending;
+
+    bool has_frame;
+};
+
+enum sc_display_result {
+    SC_DISPLAY_RESULT_OK,
+    SC_DISPLAY_RESULT_PENDING,
+    SC_DISPLAY_RESULT_ERROR,
+};
+
+bool
+sc_display_init(struct sc_display *display, SDL_Window *window,
+                SDL_Surface *icon_novideo, bool mipmaps);
+
+void
+sc_display_destroy(struct sc_display *display);
+
+enum sc_display_result
+sc_display_set_texture_size(struct sc_display *display, struct sc_size size);
+
+enum sc_display_result
+sc_display_update_texture(struct sc_display *display, const AVFrame *frame);
+
+enum sc_display_result
+sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
+                  enum sc_orientation orientation);
+
+#endif
--- a/app/src/events.c
+++ b/app/src/events.c
@@ -1,7 +1,5 @@
 #include "events.h"

-#include <assert.h>
-
 #include "util/log.h"
 #include "util/thread.h"

@@ -9,8 +7,11 @@ bool
 sc_push_event_impl(uint32_t type, const char *name) {
    SDL_Event event;
    event.type = type;
-    bool ok = SDL_PushEvent(&event);
-    if (!ok) {
+    int ret = SDL_PushEvent(&event);
+    // ret < 0: error (queue full)
+    // ret == 0: event was filtered
+    // ret == 1: success
+    if (ret != 1) {
        LOGE("Could not post %s event: %s", name, SDL_GetError());
        return false;
    }
@@ -27,25 +28,34 @@ sc_post_to_main_thread(sc_runnable_fn run, void *userdata) {
            .data2 = userdata,
        },
    };
-    bool ok = SDL_PushEvent(&event);
-    if (!ok) {
-        LOGW("Could not post runnable to main thread: %s", SDL_GetError());
+    int ret = SDL_PushEvent(&event);
+    // ret < 0: error (queue full)
+    // ret == 0: event was filtered
+    // ret == 1: success
+    if (ret != 1) {
+        if (ret == 0) {
+            // if ret == 0, this is expected on exit, log in debug mode
+            LOGD("Could not post runnable to main thread (filtered)");
+        } else {
+            assert(ret < 0);
+            LOGW("Could not post runnable to main thread: %s", SDL_GetError());
+        }
        return false;
    }

    return true;
 }

-static bool SDLCALL
+static int SDLCALL
 task_event_filter(void *userdata, SDL_Event *event) {
    (void) userdata;

    if (event->type == SC_EVENT_RUN_ON_MAIN_THREAD) {
        // Reject this event type from now on
-        return false;
+        return 0;
    }

-    return true;
+    return 1;
 }

 void
--- a/app/src/events.h
+++ b/app/src/events.h
@@ -5,10 +5,10 @@

 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL3/SDL_events.h>
+#include <SDL2/SDL_events.h>

 enum {
-    SC_EVENT_NEW_FRAME = SDL_EVENT_USER,
+    SC_EVENT_NEW_FRAME = SDL_USEREVENT,
    SC_EVENT_RUN_ON_MAIN_THREAD,
    SC_EVENT_DEVICE_DISCONNECTED,
    SC_EVENT_SERVER_CONNECTION_FAILED,
@@ -16,6 +16,7 @@ enum {
    SC_EVENT_USB_DEVICE_DISCONNECTED,
    SC_EVENT_DEMUXER_ERROR,
    SC_EVENT_RECORDER_ERROR,
+    SC_EVENT_SCREEN_INIT_SIZE,
    SC_EVENT_TIME_LIMIT_REACHED,
    SC_EVENT_CONTROLLER_ERROR,
    SC_EVENT_AOA_OPEN_ERROR,
--- a/app/src/file_pusher.c
+++ b/app/src/file_pusher.c
@@ -1,11 +1,11 @@
 #include "file_pusher.h"

 #include <assert.h>
-#include <stdlib.h>
 #include <string.h>

 #include "adb/adb.h"
 #include "util/log.h"
+#include "util/process_intr.h"

 #define DEFAULT_PUSH_TARGET "/sdcard/Download/"

--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@@ -1,7 +1,6 @@
 #include "fps_counter.h"

 #include <assert.h>
-#include <stdint.h>

 #include "util/log.h"

--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@@ -5,9 +5,9 @@

 #include <stdatomic.h>
 #include <stdbool.h>
+#include <stdint.h>

 #include "util/thread.h"
-#include "util/tick.h"

 struct sc_fps_counter {
    sc_thread thread;
--- a/app/src/frame_buffer.c
+++ b/app/src/frame_buffer.c
@@ -1,6 +1,8 @@
 #include "frame_buffer.h"

 #include <assert.h>
+#include <libavutil/avutil.h>
+#include <libavformat/avformat.h>

 #include "util/log.h"

--- a/app/src/frame_buffer.h
+++ b/app/src/frame_buffer.h
@@ -4,7 +4,6 @@
 #include "common.h"

 #include <stdbool.h>
-#include <libavutil/frame.h>

 #include "util/thread.h"

--- a/app/src/hid/hid_event.h
+++ b/app/src/hid/hid_event.h
@@ -3,7 +3,6 @@

 #include "common.h"

-#include <stddef.h>
 #include <stdint.h>

 #define SC_HID_MAX_SIZE 15
--- a/app/src/hid/hid_gamepad.c
+++ b/app/src/hid/hid_gamepad.c
@@ -2,8 +2,6 @@

 #include <assert.h>
 #include <inttypes.h>
-#include <stddef.h>
-#include <sys/types.h>

 #include "util/binary.h"
 #include "util/log.h"
--- a/app/src/hid/hid_gamepad.h
+++ b/app/src/hid/hid_gamepad.h
@@ -4,7 +4,6 @@
 #include "common.h"

 #include <stdbool.h>
-#include <stdint.h>

 #include "hid/hid_event.h"
 #include "input_events.h"
--- a/app/src/hid/hid_keyboard.c
+++ b/app/src/hid/hid_keyboard.c
@@ -1,6 +1,5 @@
 #include "hid_keyboard.h"

-#include <assert.h>
 #include <string.h>

 #include "util/log.h"
--- a/app/src/hid/hid_keyboard.h
+++ b/app/src/hid/hid_keyboard.h
@@ -4,12 +4,11 @@
 #include "common.h"

 #include <stdbool.h>
-#include <stdint.h>

 #include "hid/hid_event.h"
 #include "input_events.h"

-// See "SDL3/SDL_scancode.h".
+// See "SDL2/SDL_scancode.h".
 // Maybe SDL_Keycode is used by most people, but SDL_Scancode is taken from USB
 // HID protocol.
 // 0x65 is Application, typically AT-101 Keyboard ends here.
--- a/app/src/hid/hid_mouse.c
+++ b/app/src/hid/hid_mouse.c
@@ -1,10 +1,8 @@
 #include "hid_mouse.h"

-#include <stdint.h>
-
 // 1 byte for buttons + padding, 1 byte for X position, 1 byte for Y position,
-// 1 byte for wheel motion, 1 byte for hozizontal scrolling
-#define SC_HID_MOUSE_INPUT_SIZE 5
+// 1 byte for wheel motion
+#define SC_HID_MOUSE_INPUT_SIZE 4

 /**
 * Mouse descriptor from the specification:
@@ -75,21 +73,6 @@ static const uint8_t SC_HID_MOUSE_REPORT_DESC[] = {
    // Input (Data, Variable, Relative): 3 position bytes (X, Y, Wheel)
    0x81, 0x06,

-    // Usage Page (Consumer Page)
-    0x05, 0x0C,
-    // Usage(AC Pan)
-    0x0A, 0x38, 0x02,
-    // Logical Minimum (-127)
-    0x15, 0x81,
-    // Logical Maximum (127)
-    0x25, 0x7F,
-    // Report Size (8)
-    0x75, 0x08,
-    // Report Count (1)
-    0x95, 0x01,
-    // Input (Data, Variable, Relative): 1 byte (AC Pan)
-    0x81, 0x06,
-
    // End Collection
    0xC0,

@@ -166,12 +149,6 @@ sc_hid_buttons_from_buttons_state(uint8_t buttons_state) {
    return c;
 }

-void
-sc_hid_mouse_init(struct sc_hid_mouse *hid) {
-    hid->residual_hscroll = 0;
-    hid->residual_vscroll = 0;
-}
-
 void
 sc_hid_mouse_generate_input_from_motion(struct sc_hid_input *hid_input,
                                    const struct sc_mouse_motion_event *event) {
@@ -181,8 +158,7 @@ sc_hid_mouse_generate_input_from_motion(struct sc_hid_input *hid_input,
    data[0] = sc_hid_buttons_from_buttons_state(event->buttons_state);
    data[1] = CLAMP(event->xrel, -127, 127);
    data[2] = CLAMP(event->yrel, -127, 127);
-    data[3] = 0; // no vertical scrolling
-    data[4] = 0; // no horizontal scrolling
+    data[3] = 0; // wheel coordinates only used for scrolling
 }

 void
@@ -194,42 +170,22 @@ sc_hid_mouse_generate_input_from_click(struct sc_hid_input *hid_input,
    data[0] = sc_hid_buttons_from_buttons_state(event->buttons_state);
    data[1] = 0; // no x motion
    data[2] = 0; // no y motion
-    data[3] = 0; // no vertical scrolling
-    data[4] = 0; // no horizontal scrolling
+    data[3] = 0; // wheel coordinates only used for scrolling
 }

-static int8_t
-consume_scroll_integer(float *scroll) {
-    float value = CLAMP(*scroll, -127, 127);
-    int8_t consume = value; // truncate towards 0
-    float residual = value - consume;
-    *scroll = residual;
-    return consume;
-}
-
-bool
-sc_hid_mouse_generate_input_from_scroll(struct sc_hid_mouse *hid,
-                                        struct sc_hid_input *hid_input,
+void
+sc_hid_mouse_generate_input_from_scroll(struct sc_hid_input *hid_input,
                                    const struct sc_mouse_scroll_event *event) {
    sc_hid_mouse_input_init(hid_input);

-    hid->residual_hscroll += event->hscroll;
-    hid->residual_vscroll += event->vscroll;
-    int8_t hscroll = consume_scroll_integer(&hid->residual_hscroll);
-    int8_t vscroll = consume_scroll_integer(&hid->residual_vscroll);
-
-    if (!hscroll && !vscroll) {
-        // Not enough scrolling to inject a scroll event
-        return false;
-    }
-
    uint8_t *data = hid_input->data;
    data[0] = 0; // buttons state irrelevant (and unknown)
    data[1] = 0; // no x motion
    data[2] = 0; // no y motion
-    data[3] = vscroll;
-    data[4] = hscroll;
-    return true;
+    // In practice, vscroll is always -1, 0 or 1, but in theory other values
+    // are possible
+    data[3] = CLAMP(event->vscroll, -127, 127);
+    // Horizontal scrolling ignored
 }

 void sc_hid_mouse_generate_open(struct sc_hid_open *hid_open) {
--- a/app/src/hid/hid_mouse.h
+++ b/app/src/hid/hid_mouse.h
@@ -3,18 +3,13 @@

 #include "common.h"

+#include <stdbool.h>
+
 #include "hid/hid_event.h"
 #include "input_events.h"

 #define SC_HID_ID_MOUSE 2

-struct sc_hid_mouse {
-    float residual_hscroll;
-    float residual_vscroll;
-};
-
-void sc_hid_mouse_init(struct sc_hid_mouse *hid);
-
 void
 sc_hid_mouse_generate_open(struct sc_hid_open *hid_open);

@@ -29,9 +24,8 @@ void
 sc_hid_mouse_generate_input_from_click(struct sc_hid_input *hid_input,
                                    const struct sc_mouse_click_event *event);

-bool
-sc_hid_mouse_generate_input_from_scroll(struct sc_hid_mouse *hid,
-                                        struct sc_hid_input *hid_input,
+void
+sc_hid_mouse_generate_input_from_scroll(struct sc_hid_input *hid_input,
                                    const struct sc_mouse_scroll_event *event);

 #endif
--- a/app/src/icon.c
+++ b/app/src/icon.c
@@ -2,22 +2,17 @@

 #include <assert.h>
 #include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
-#include <libavutil/avutil.h>
 #include <libavutil/pixdesc.h>
 #include <libavutil/pixfmt.h>
-#include <SDL3/SDL.h>

 #include "config.h"
+#include "compat.h"
 #include "util/env.h"
-#ifdef PORTABLE
-# include "util/file.h"
-#endif
+#include "util/file.h"
 #include "util/log.h"
+#include "util/str.h"

 #define SCRCPY_PORTABLE_ICON_FILENAME "icon.png"
 #define SCRCPY_DEFAULT_ICON_PATH \
@@ -156,7 +151,13 @@ free_ctx:
    return result;
 }

-static SDL_PixelFormat
+#if !SDL_VERSION_ATLEAST(2, 0, 10)
+// SDL_PixelFormatEnum has been introduced in SDL 2.0.10. Use int for older SDL
+// versions.
+typedef int SDL_PixelFormatEnum;
+#endif
+
+static SDL_PixelFormatEnum
 to_sdl_pixel_format(enum AVPixelFormat fmt) {
    switch (fmt) {
        case AV_PIX_FMT_RGB24: return SDL_PIXELFORMAT_RGB24;
@@ -166,11 +167,13 @@ to_sdl_pixel_format(enum AVPixelFormat fmt) {
        case AV_PIX_FMT_ABGR: return SDL_PIXELFORMAT_ABGR32;
        case AV_PIX_FMT_BGRA: return SDL_PIXELFORMAT_BGRA32;
        case AV_PIX_FMT_RGB565BE: return SDL_PIXELFORMAT_RGB565;
-        case AV_PIX_FMT_RGB555BE: return SDL_PIXELFORMAT_XRGB1555;
+        case AV_PIX_FMT_RGB555BE: return SDL_PIXELFORMAT_RGB555;
        case AV_PIX_FMT_BGR565BE: return SDL_PIXELFORMAT_BGR565;
-        case AV_PIX_FMT_BGR555BE: return SDL_PIXELFORMAT_XBGR1555;
-        case AV_PIX_FMT_RGB444BE: return SDL_PIXELFORMAT_XRGB4444;
-        case AV_PIX_FMT_BGR444BE: return SDL_PIXELFORMAT_XBGR4444;
+        case AV_PIX_FMT_BGR555BE: return SDL_PIXELFORMAT_BGR555;
+        case AV_PIX_FMT_RGB444BE: return SDL_PIXELFORMAT_RGB444;
+#if SDL_VERSION_ATLEAST(2, 0, 12)
+        case AV_PIX_FMT_BGR444BE: return SDL_PIXELFORMAT_BGR444;
+#endif
        case AV_PIX_FMT_PAL8: return SDL_PIXELFORMAT_INDEX8;
        default: return SDL_PIXELFORMAT_UNKNOWN;
    }
@@ -195,16 +198,20 @@ load_from_path(const char *path) {
        goto error;
    }

-    SDL_PixelFormat format = to_sdl_pixel_format(frame->format);
+    SDL_PixelFormatEnum format = to_sdl_pixel_format(frame->format);
    if (format == SDL_PIXELFORMAT_UNKNOWN) {
        LOGE("Unsupported icon pixel format: %s (%d)", desc->name,
                                                       frame->format);
        goto error;
    }

+    int bits_per_pixel = av_get_bits_per_pixel(desc);
    SDL_Surface *surface =
-        SDL_CreateSurfaceFrom(frame->width, frame->height, format,
-                              frame->data[0], frame->linesize[0]);
+        SDL_CreateRGBSurfaceWithFormatFrom(frame->data[0],
+                                           frame->width, frame->height,
+                                           bits_per_pixel,
+                                           frame->linesize[0],
+                                           format);

    if (!surface) {
        LOGE("Could not create icon surface");
@@ -236,35 +243,17 @@ load_from_path(const char *path) {
 #endif
        }

-        SDL_Palette *palette = SDL_CreateSurfacePalette(surface);
-        if (!palette) {
-            LOGE("Could not create palette");
-            SDL_DestroySurface(surface);
-            goto error;
-        }
-
-        bool ok = SDL_SetPaletteColors(palette, colors, 0, 256);
-        if (!ok) {
+        SDL_Palette *palette = surface->format->palette;
+        assert(palette);
+        int ret = SDL_SetPaletteColors(palette, colors, 0, 256);
+        if (ret) {
            LOGE("Could not set palette colors");
-            SDL_DestroySurface(surface);
+            SDL_FreeSurface(surface);
            goto error;
        }
    }

-    SDL_PropertiesID props = SDL_GetSurfaceProperties(surface);
-    if (!props) {
-        LOGE("Could not get surface properties: %s", SDL_GetError());
-        SDL_DestroySurface(surface);
-        goto error;
-    }
-
-    // frame owns the data
-    bool ok = SDL_SetPointerProperty(props, "sc_frame", frame);
-    if (!ok) {
-        LOGE("Could not set pointer property: %s", SDL_GetError());
-        SDL_DestroySurface(surface);
-        goto error;
-    }
+    surface->userdata = frame; // frame owns the data

    return surface;

@@ -287,10 +276,8 @@ scrcpy_icon_load(void) {

 void
 scrcpy_icon_destroy(SDL_Surface *icon) {
-    SDL_PropertiesID props = SDL_GetSurfaceProperties(icon);
-    assert(props);
-    AVFrame *frame = SDL_GetPointerProperty(props, "sc_frame", NULL);
+    AVFrame *frame = icon->userdata;
    assert(frame);
    av_frame_free(&frame);
-    SDL_DestroySurface(icon);
+    SDL_FreeSurface(icon);
 }
--- a/app/src/icon.h
+++ b/app/src/icon.h
@@ -3,7 +3,9 @@

 #include "common.h"

-#include <SDL3/SDL_surface.h>
+#include <stdbool.h>
+#include <SDL2/SDL.h>
+#include <libavformat/avformat.h>

 SDL_Surface *
 scrcpy_icon_load(void);
--- a/app/src/input_events.h
+++ b/app/src/input_events.h
@@ -6,16 +6,16 @@
 #include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL3/SDL_events.h>
+#include <SDL2/SDL_events.h>

 #include "coords.h"
+#include "options.h"

 /* The representation of input events in scrcpy is very close to the SDL API,
 * for simplicity.
 *
 * This scrcpy input events API is designed to be consumed by input event
- * processors (sc_key_processor, sc_mouse_processor and sc_gamepad_processor,
- * see app/src/trait/).
+ * processors (sc_key_processor and sc_mouse_processor, see app/src/trait/).
 *
 * One major semantic difference between SDL input events and scrcpy input
 * events is their frame of reference (for mouse and touch events): SDL events
@@ -44,17 +44,17 @@
 */

 enum sc_mod {
-    SC_MOD_LSHIFT = SDL_KMOD_LSHIFT,
-    SC_MOD_RSHIFT = SDL_KMOD_RSHIFT,
-    SC_MOD_LCTRL = SDL_KMOD_LCTRL,
-    SC_MOD_RCTRL = SDL_KMOD_RCTRL,
-    SC_MOD_LALT = SDL_KMOD_LALT,
-    SC_MOD_RALT = SDL_KMOD_RALT,
-    SC_MOD_LGUI = SDL_KMOD_LGUI,
-    SC_MOD_RGUI = SDL_KMOD_RGUI,
+    SC_MOD_LSHIFT = KMOD_LSHIFT,
+    SC_MOD_RSHIFT = KMOD_RSHIFT,
+    SC_MOD_LCTRL = KMOD_LCTRL,
+    SC_MOD_RCTRL = KMOD_RCTRL,
+    SC_MOD_LALT = KMOD_LALT,
+    SC_MOD_RALT = KMOD_RALT,
+    SC_MOD_LGUI = KMOD_LGUI,
+    SC_MOD_RGUI = KMOD_RGUI,

-    SC_MOD_NUM = SDL_KMOD_NUM,
-    SC_MOD_CAPS = SDL_KMOD_CAPS,
+    SC_MOD_NUM = KMOD_NUM,
+    SC_MOD_CAPS = KMOD_CAPS,
 };

 enum sc_action {
@@ -71,12 +71,12 @@ enum sc_keycode {
    SC_KEYCODE_TAB = SDLK_TAB,
    SC_KEYCODE_SPACE = SDLK_SPACE,
    SC_KEYCODE_EXCLAIM = SDLK_EXCLAIM,
-    SC_KEYCODE_QUOTEDBL = SDLK_DBLAPOSTROPHE,
+    SC_KEYCODE_QUOTEDBL = SDLK_QUOTEDBL,
    SC_KEYCODE_HASH = SDLK_HASH,
    SC_KEYCODE_PERCENT = SDLK_PERCENT,
    SC_KEYCODE_DOLLAR = SDLK_DOLLAR,
    SC_KEYCODE_AMPERSAND = SDLK_AMPERSAND,
-    SC_KEYCODE_QUOTE = SDLK_APOSTROPHE,
+    SC_KEYCODE_QUOTE = SDLK_QUOTE,
    SC_KEYCODE_LEFTPAREN = SDLK_LEFTPAREN,
    SC_KEYCODE_RIGHTPAREN = SDLK_RIGHTPAREN,
    SC_KEYCODE_ASTERISK = SDLK_ASTERISK,
@@ -108,33 +108,33 @@ enum sc_keycode {
    SC_KEYCODE_RIGHTBRACKET = SDLK_RIGHTBRACKET,
    SC_KEYCODE_CARET = SDLK_CARET,
    SC_KEYCODE_UNDERSCORE = SDLK_UNDERSCORE,
-    SC_KEYCODE_BACKQUOTE = SDLK_GRAVE,
-    SC_KEYCODE_a = SDLK_A,
-    SC_KEYCODE_b = SDLK_B,
-    SC_KEYCODE_c = SDLK_C,
-    SC_KEYCODE_d = SDLK_D,
-    SC_KEYCODE_e = SDLK_E,
-    SC_KEYCODE_f = SDLK_F,
-    SC_KEYCODE_g = SDLK_G,
-    SC_KEYCODE_h = SDLK_H,
-    SC_KEYCODE_i = SDLK_I,
-    SC_KEYCODE_j = SDLK_J,
-    SC_KEYCODE_k = SDLK_K,
-    SC_KEYCODE_l = SDLK_L,
-    SC_KEYCODE_m = SDLK_M,
-    SC_KEYCODE_n = SDLK_N,
-    SC_KEYCODE_o = SDLK_O,
-    SC_KEYCODE_p = SDLK_P,
-    SC_KEYCODE_q = SDLK_Q,
-    SC_KEYCODE_r = SDLK_R,
-    SC_KEYCODE_s = SDLK_S,
-    SC_KEYCODE_t = SDLK_T,
-    SC_KEYCODE_u = SDLK_U,
-    SC_KEYCODE_v = SDLK_V,
-    SC_KEYCODE_w = SDLK_W,
-    SC_KEYCODE_x = SDLK_X,
-    SC_KEYCODE_y = SDLK_Y,
-    SC_KEYCODE_z = SDLK_Z,
+    SC_KEYCODE_BACKQUOTE = SDLK_BACKQUOTE,
+    SC_KEYCODE_a = SDLK_a,
+    SC_KEYCODE_b = SDLK_b,
+    SC_KEYCODE_c = SDLK_c,
+    SC_KEYCODE_d = SDLK_d,
+    SC_KEYCODE_e = SDLK_e,
+    SC_KEYCODE_f = SDLK_f,
+    SC_KEYCODE_g = SDLK_g,
+    SC_KEYCODE_h = SDLK_h,
+    SC_KEYCODE_i = SDLK_i,
+    SC_KEYCODE_j = SDLK_j,
+    SC_KEYCODE_k = SDLK_k,
+    SC_KEYCODE_l = SDLK_l,
+    SC_KEYCODE_m = SDLK_m,
+    SC_KEYCODE_n = SDLK_n,
+    SC_KEYCODE_o = SDLK_o,
+    SC_KEYCODE_p = SDLK_p,
+    SC_KEYCODE_q = SDLK_q,
+    SC_KEYCODE_r = SDLK_r,
+    SC_KEYCODE_s = SDLK_s,
+    SC_KEYCODE_t = SDLK_t,
+    SC_KEYCODE_u = SDLK_u,
+    SC_KEYCODE_v = SDLK_v,
+    SC_KEYCODE_w = SDLK_w,
+    SC_KEYCODE_x = SDLK_x,
+    SC_KEYCODE_y = SDLK_y,
+    SC_KEYCODE_z = SDLK_z,

    SC_KEYCODE_CAPSLOCK = SDLK_CAPSLOCK,

@@ -316,40 +316,43 @@ enum sc_scancode {
 // to avoid unnecessary conversions (and confusion).
 enum sc_mouse_button {
    SC_MOUSE_BUTTON_UNKNOWN = 0,
-    SC_MOUSE_BUTTON_LEFT = SDL_BUTTON_MASK(SDL_BUTTON_LEFT),
-    SC_MOUSE_BUTTON_RIGHT = SDL_BUTTON_MASK(SDL_BUTTON_RIGHT),
-    SC_MOUSE_BUTTON_MIDDLE = SDL_BUTTON_MASK(SDL_BUTTON_MIDDLE),
-    SC_MOUSE_BUTTON_X1 = SDL_BUTTON_MASK(SDL_BUTTON_X1),
-    SC_MOUSE_BUTTON_X2 = SDL_BUTTON_MASK(SDL_BUTTON_X2),
+    SC_MOUSE_BUTTON_LEFT = SDL_BUTTON(SDL_BUTTON_LEFT),
+    SC_MOUSE_BUTTON_RIGHT = SDL_BUTTON(SDL_BUTTON_RIGHT),
+    SC_MOUSE_BUTTON_MIDDLE = SDL_BUTTON(SDL_BUTTON_MIDDLE),
+    SC_MOUSE_BUTTON_X1 = SDL_BUTTON(SDL_BUTTON_X1),
+    SC_MOUSE_BUTTON_X2 = SDL_BUTTON(SDL_BUTTON_X2),
 };

+// Use the naming from SDL3 for gamepad axis and buttons:
+// <https://wiki.libsdl.org/SDL3/README/migration>
+
 enum sc_gamepad_axis {
    SC_GAMEPAD_AXIS_UNKNOWN = -1,
-    SC_GAMEPAD_AXIS_LEFTX = SDL_GAMEPAD_AXIS_LEFTX,
-    SC_GAMEPAD_AXIS_LEFTY = SDL_GAMEPAD_AXIS_LEFTY,
-    SC_GAMEPAD_AXIS_RIGHTX = SDL_GAMEPAD_AXIS_RIGHTX,
-    SC_GAMEPAD_AXIS_RIGHTY = SDL_GAMEPAD_AXIS_RIGHTY,
-    SC_GAMEPAD_AXIS_LEFT_TRIGGER = SDL_GAMEPAD_AXIS_LEFT_TRIGGER,
-    SC_GAMEPAD_AXIS_RIGHT_TRIGGER = SDL_GAMEPAD_AXIS_RIGHT_TRIGGER,
+    SC_GAMEPAD_AXIS_LEFTX = SDL_CONTROLLER_AXIS_LEFTX,
+    SC_GAMEPAD_AXIS_LEFTY = SDL_CONTROLLER_AXIS_LEFTY,
+    SC_GAMEPAD_AXIS_RIGHTX = SDL_CONTROLLER_AXIS_RIGHTX,
+    SC_GAMEPAD_AXIS_RIGHTY = SDL_CONTROLLER_AXIS_RIGHTY,
+    SC_GAMEPAD_AXIS_LEFT_TRIGGER = SDL_CONTROLLER_AXIS_TRIGGERLEFT,
+    SC_GAMEPAD_AXIS_RIGHT_TRIGGER = SDL_CONTROLLER_AXIS_TRIGGERRIGHT,
 };

 enum sc_gamepad_button {
    SC_GAMEPAD_BUTTON_UNKNOWN = -1,
-    SC_GAMEPAD_BUTTON_SOUTH = SDL_GAMEPAD_BUTTON_SOUTH,
-    SC_GAMEPAD_BUTTON_EAST = SDL_GAMEPAD_BUTTON_EAST,
-    SC_GAMEPAD_BUTTON_WEST = SDL_GAMEPAD_BUTTON_WEST,
-    SC_GAMEPAD_BUTTON_NORTH = SDL_GAMEPAD_BUTTON_NORTH,
-    SC_GAMEPAD_BUTTON_BACK = SDL_GAMEPAD_BUTTON_BACK,
-    SC_GAMEPAD_BUTTON_GUIDE = SDL_GAMEPAD_BUTTON_GUIDE,
-    SC_GAMEPAD_BUTTON_START = SDL_GAMEPAD_BUTTON_START,
-    SC_GAMEPAD_BUTTON_LEFT_STICK = SDL_GAMEPAD_BUTTON_LEFT_STICK,
-    SC_GAMEPAD_BUTTON_RIGHT_STICK = SDL_GAMEPAD_BUTTON_RIGHT_STICK,
-    SC_GAMEPAD_BUTTON_LEFT_SHOULDER = SDL_GAMEPAD_BUTTON_LEFT_SHOULDER,
-    SC_GAMEPAD_BUTTON_RIGHT_SHOULDER = SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER,
-    SC_GAMEPAD_BUTTON_DPAD_UP = SDL_GAMEPAD_BUTTON_DPAD_UP,
-    SC_GAMEPAD_BUTTON_DPAD_DOWN = SDL_GAMEPAD_BUTTON_DPAD_DOWN,
-    SC_GAMEPAD_BUTTON_DPAD_LEFT = SDL_GAMEPAD_BUTTON_DPAD_LEFT,
-    SC_GAMEPAD_BUTTON_DPAD_RIGHT = SDL_GAMEPAD_BUTTON_DPAD_RIGHT,
+    SC_GAMEPAD_BUTTON_SOUTH = SDL_CONTROLLER_BUTTON_A,
+    SC_GAMEPAD_BUTTON_EAST = SDL_CONTROLLER_BUTTON_B,
+    SC_GAMEPAD_BUTTON_WEST = SDL_CONTROLLER_BUTTON_X,
+    SC_GAMEPAD_BUTTON_NORTH = SDL_CONTROLLER_BUTTON_Y,
+    SC_GAMEPAD_BUTTON_BACK = SDL_CONTROLLER_BUTTON_BACK,
+    SC_GAMEPAD_BUTTON_GUIDE = SDL_CONTROLLER_BUTTON_GUIDE,
+    SC_GAMEPAD_BUTTON_START = SDL_CONTROLLER_BUTTON_START,
+    SC_GAMEPAD_BUTTON_LEFT_STICK = SDL_CONTROLLER_BUTTON_LEFTSTICK,
+    SC_GAMEPAD_BUTTON_RIGHT_STICK = SDL_CONTROLLER_BUTTON_RIGHTSTICK,
+    SC_GAMEPAD_BUTTON_LEFT_SHOULDER = SDL_CONTROLLER_BUTTON_LEFTSHOULDER,
+    SC_GAMEPAD_BUTTON_RIGHT_SHOULDER = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER,
+    SC_GAMEPAD_BUTTON_DPAD_UP = SDL_CONTROLLER_BUTTON_DPAD_UP,
+    SC_GAMEPAD_BUTTON_DPAD_DOWN = SDL_CONTROLLER_BUTTON_DPAD_DOWN,
+    SC_GAMEPAD_BUTTON_DPAD_LEFT = SDL_CONTROLLER_BUTTON_DPAD_LEFT,
+    SC_GAMEPAD_BUTTON_DPAD_RIGHT = SDL_CONTROLLER_BUTTON_DPAD_RIGHT,
 };

 static_assert(sizeof(enum sc_mod) >= sizeof(SDL_Keymod),
@@ -409,9 +412,10 @@ struct sc_touch_event {
    float pressure;
 };

-// As documented in <https://wiki.libsdl.org/SDL3/SDL_JoystickID>:
-// The value 0 is an invalid ID.
-#define SC_GAMEPAD_ID_INVALID 0
+// As documented in <https://wiki.libsdl.org/SDL2/SDL_JoystickID>:
+// The ID value starts at 0 and increments from there. The value -1 is an
+// invalid ID.
+#define SC_GAMEPAD_ID_INVALID UINT32_C(-1)

 struct sc_gamepad_device_event {
    uint32_t gamepad_id;
@@ -446,8 +450,8 @@ sc_scancode_from_sdl(SDL_Scancode scancode) {

 static inline enum sc_action
 sc_action_from_sdl_keyboard_type(uint32_t type) {
-    assert(type == SDL_EVENT_KEY_DOWN || type == SDL_EVENT_KEY_UP);
-    if (type == SDL_EVENT_KEY_DOWN) {
+    assert(type == SDL_KEYDOWN || type == SDL_KEYUP);
+    if (type == SDL_KEYDOWN) {
        return SC_ACTION_DOWN;
    }
    return SC_ACTION_UP;
@@ -455,8 +459,8 @@ sc_action_from_sdl_keyboard_type(uint32_t type) {

 static inline enum sc_action
 sc_action_from_sdl_mousebutton_type(uint32_t type) {
-    assert(type == SDL_EVENT_MOUSE_BUTTON_DOWN || type == SDL_EVENT_MOUSE_BUTTON_UP);
-    if (type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
+    assert(type == SDL_MOUSEBUTTONDOWN || type == SDL_MOUSEBUTTONUP);
+    if (type == SDL_MOUSEBUTTONDOWN) {
        return SC_ACTION_DOWN;
    }
    return SC_ACTION_UP;
@@ -464,12 +468,12 @@ sc_action_from_sdl_mousebutton_type(uint32_t type) {

 static inline enum sc_touch_action
 sc_touch_action_from_sdl(uint32_t type) {
-    assert(type == SDL_EVENT_FINGER_MOTION || type == SDL_EVENT_FINGER_DOWN ||
-           type == SDL_EVENT_FINGER_UP);
-    if (type == SDL_EVENT_FINGER_MOTION) {
+    assert(type == SDL_FINGERMOTION || type == SDL_FINGERDOWN ||
+           type == SDL_FINGERUP);
+    if (type == SDL_FINGERMOTION) {
        return SC_TOUCH_ACTION_MOVE;
    }
-    if (type == SDL_EVENT_FINGER_DOWN) {
+    if (type == SDL_FINGERDOWN) {
        return SC_TOUCH_ACTION_DOWN;
    }
    return SC_TOUCH_ACTION_UP;
@@ -479,7 +483,7 @@ static inline enum sc_mouse_button
 sc_mouse_button_from_sdl(uint8_t button) {
    if (button >= SDL_BUTTON_LEFT && button <= SDL_BUTTON_X2) {
        // SC_MOUSE_BUTTON_* constants are initialized from SDL_BUTTON(index)
-        return SDL_BUTTON_MASK(button);
+        return SDL_BUTTON(button);
    }

    return SC_MOUSE_BUTTON_UNKNOWN;
@@ -495,9 +499,9 @@ sc_mouse_buttons_state_from_sdl(uint32_t buttons_state) {

 static inline enum sc_gamepad_axis
 sc_gamepad_axis_from_sdl(uint8_t axis) {
-    if (axis <= SDL_GAMEPAD_AXIS_RIGHT_TRIGGER) {
+    if (axis <= SDL_CONTROLLER_AXIS_TRIGGERRIGHT) {
        // SC_GAMEPAD_AXIS_* constants are initialized from
-        // SDL_GAMEPAD_AXIS_*
+        // SDL_CONTROLLER_AXIS_*
        return axis;
    }
    return SC_GAMEPAD_AXIS_UNKNOWN;
@@ -505,18 +509,18 @@ sc_gamepad_axis_from_sdl(uint8_t axis) {

 static inline enum sc_gamepad_button
 sc_gamepad_button_from_sdl(uint8_t button) {
-    if (button <= SDL_GAMEPAD_BUTTON_DPAD_RIGHT) {
+    if (button <= SDL_CONTROLLER_BUTTON_DPAD_RIGHT) {
        // SC_GAMEPAD_BUTTON_* constants are initialized from
-        // SDL_GAMEPAD_BUTTON_*
+        // SDL_CONTROLLER_BUTTON_*
        return button;
    }
    return SC_GAMEPAD_BUTTON_UNKNOWN;
 }

 static inline enum sc_action
-sc_action_from_sdl_gamepad_button_type(uint32_t type) {
-    assert(type == SDL_EVENT_GAMEPAD_BUTTON_DOWN || type == SDL_EVENT_GAMEPAD_BUTTON_UP);
-    if (type == SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
+sc_action_from_sdl_controllerbutton_type(uint32_t type) {
+    assert(type == SDL_CONTROLLERBUTTONDOWN || type == SDL_CONTROLLERBUTTONUP);
+    if (type == SDL_CONTROLLERBUTTONDOWN) {
        return SC_ACTION_DOWN;
    }
    return SC_ACTION_UP;
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@@ -1,21 +1,18 @@
 #include "input_manager.h"

 #include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <SDL3/SDL.h>
+#include <SDL2/SDL_keycode.h>

-#include "android/input.h"
-#include "android/keycodes.h"
 #include "input_events.h"
 #include "screen.h"
 #include "shortcut_mod.h"
 #include "util/log.h"
-#include "util/sdl.h"

 void
 sc_input_manager_init(struct sc_input_manager *im,
                      const struct sc_input_manager_params *params) {
+    // A key/mouse processor may not be present if there is no controller
+    assert((!params->kp && !params->mp && !params->gp) || params->controller);
    // A processor must have ops initialized
    assert(!params->kp || params->kp->ops);
    assert(!params->mp || params->mp->ops);
@@ -27,7 +24,6 @@ sc_input_manager_init(struct sc_input_manager *im,
    im->kp = params->kp;
    im->mp = params->mp;
    im->gp = params->gp;
-    im->camera = params->camera;

    im->mouse_bindings = params->mouse_bindings;
    im->legacy_paste = params->legacy_paste;
@@ -51,7 +47,7 @@ sc_input_manager_init(struct sc_input_manager *im,
 static void
 send_keycode(struct sc_input_manager *im, enum android_keycode keycode,
             enum sc_action action, const char *name) {
-    assert(im->controller && im->kp && !im->camera);
+    assert(im->controller && im->kp);

    // send DOWN event
    struct sc_control_msg msg;
@@ -108,7 +104,7 @@ action_menu(struct sc_input_manager *im, enum sc_action action) {
 static void
 press_back_or_turn_screen_on(struct sc_input_manager *im,
                             enum sc_action action) {
-    assert(im->controller && im->kp && !im->camera);
+    assert(im->controller && im->kp);

    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
@@ -123,7 +119,7 @@ press_back_or_turn_screen_on(struct sc_input_manager *im,

 static void
 expand_notification_panel(struct sc_input_manager *im) {
-    assert(im->controller && !im->camera);
+    assert(im->controller);

    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
@@ -135,7 +131,7 @@ expand_notification_panel(struct sc_input_manager *im) {

 static void
 expand_settings_panel(struct sc_input_manager *im) {
-    assert(im->controller && !im->camera);
+    assert(im->controller);

    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL;
@@ -147,7 +143,7 @@ expand_settings_panel(struct sc_input_manager *im) {

 static void
 collapse_panels(struct sc_input_manager *im) {
-    assert(im->controller && !im->camera);
+    assert(im->controller);

    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS;
@@ -159,7 +155,7 @@ collapse_panels(struct sc_input_manager *im) {

 static bool
 get_device_clipboard(struct sc_input_manager *im, enum sc_copy_key copy_key) {
-    assert(im->controller && im->kp && !im->camera);
+    assert(im->controller && im->kp);

    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD;
@@ -176,7 +172,7 @@ get_device_clipboard(struct sc_input_manager *im, enum sc_copy_key copy_key) {
 static bool
 set_device_clipboard(struct sc_input_manager *im, bool paste,
                     uint64_t sequence) {
-    assert(im->controller && im->kp && !im->camera);
+    assert(im->controller && im->kp);

    char *text = SDL_GetClipboardText();
    if (!text) {
@@ -208,7 +204,7 @@ set_device_clipboard(struct sc_input_manager *im, bool paste,

 static void
 set_display_power(struct sc_input_manager *im, bool on) {
-    assert(im->controller && !im->camera);
+    assert(im->controller);

    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_SET_DISPLAY_POWER;
@@ -235,7 +231,7 @@ switch_fps_counter_state(struct sc_input_manager *im) {

 static void
 clipboard_paste(struct sc_input_manager *im) {
-    assert(im->controller && im->kp && !im->camera);
+    assert(im->controller && im->kp);

    char *text = SDL_GetClipboardText();
    if (!text) {
@@ -266,7 +262,7 @@ clipboard_paste(struct sc_input_manager *im) {

 static void
 rotate_device(struct sc_input_manager *im) {
-    assert(im->controller && !im->camera);
+    assert(im->controller);

    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE;
@@ -278,7 +274,7 @@ rotate_device(struct sc_input_manager *im) {

 static void
 open_hard_keyboard_settings(struct sc_input_manager *im) {
-    assert(im->controller && !im->camera);
+    assert(im->controller);

    struct sc_control_msg msg;
    msg.type = SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS;
@@ -300,43 +296,6 @@ reset_video(struct sc_input_manager *im) {
    }
 }

-static void
-camera_set_torch(struct sc_input_manager *im, bool on) {
-    assert(im->controller && im->camera);
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_CAMERA_SET_TORCH;
-    msg.camera_set_torch.on = on;
-
-    if (!sc_controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request setting camera torch");
-    }
-}
-
-static void
-camera_zoom_in(struct sc_input_manager *im) {
-    assert(im->controller && im->camera);
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_CAMERA_ZOOM_IN;
-
-    if (!sc_controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request camera zoom in");
-    }
-}
-
-static void
-camera_zoom_out(struct sc_input_manager *im) {
-    assert(im->controller && im->camera);
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_CAMERA_ZOOM_OUT;
-
-    if (!sc_controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request camera zoom out");
-    }
-}
-
 static void
 apply_orientation_transform(struct sc_input_manager *im,
                            enum sc_orientation transform) {
@@ -349,10 +308,6 @@ apply_orientation_transform(struct sc_input_manager *im,
 static void
 sc_input_manager_process_text_input(struct sc_input_manager *im,
                                    const SDL_TextInputEvent *event) {
-    if (im->camera || !im->kp || im->screen->paused) {
-        return;
-    }
-
    if (!im->kp->ops->process_text) {
        // The key processor does not support text input
        return;
@@ -410,19 +365,16 @@ inverse_point(struct sc_point point, struct sc_size size,
 static void
 sc_input_manager_process_key(struct sc_input_manager *im,
                             const SDL_KeyboardEvent *event) {
-    // some key events do not interact with the device, so process the event
-    // even if control is disabled
-
    // controller is NULL if --no-control is requested
    bool control = im->controller;
    bool paused = im->screen->paused;
    bool video = im->screen->video;

-    SDL_Keycode sdl_keycode = event->key;
-    uint16_t mod = event->mod;
-    bool down = event->type == SDL_EVENT_KEY_DOWN;
-    bool ctrl = event->mod & SDL_KMOD_CTRL;
-    bool shift = event->mod & SDL_KMOD_SHIFT;
+    SDL_Keycode sdl_keycode = event->keysym.sym;
+    uint16_t mod = event->keysym.mod;
+    bool down = event->type == SDL_KEYDOWN;
+    bool ctrl = event->keysym.mod & KMOD_CTRL;
+    bool shift = event->keysym.mod & KMOD_SHIFT;
    bool repeat = event->repeat;

    // Either the modifier includes a shortcut modifier, or the key
@@ -446,196 +398,156 @@ sc_input_manager_process_key(struct sc_input_manager *im,
    if (is_shortcut) {
        enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
        switch (sdl_keycode) {
-            case SDLK_Z:
+            case SDLK_h:
+                if (im->kp && !shift && !repeat && !paused) {
+                    action_home(im, action);
+                }
+                return;
+            case SDLK_b: // fall-through
+            case SDLK_BACKSPACE:
+                if (im->kp && !shift && !repeat && !paused) {
+                    action_back(im, action);
+                }
+                return;
+            case SDLK_s:
+                if (im->kp && !shift && !repeat && !paused) {
+                    action_app_switch(im, action);
+                }
+                return;
+            case SDLK_m:
+                if (im->kp && !shift && !repeat && !paused) {
+                    action_menu(im, action);
+                }
+                return;
+            case SDLK_p:
+                if (im->kp && !shift && !repeat && !paused) {
+                    action_power(im, action);
+                }
+                return;
+            case SDLK_o:
+                if (control && !repeat && down && !paused) {
+                    bool on = shift;
+                    set_display_power(im, on);
+                }
+                return;
+            case SDLK_z:
                if (video && down && !repeat) {
                    sc_screen_set_paused(im->screen, !shift);
                }
                return;
            case SDLK_DOWN:
-                // Only capture if shift is set
                if (shift) {
                    if (video && !repeat && down) {
                        apply_orientation_transform(im,
                                                    SC_ORIENTATION_FLIP_180);
                    }
-                    return;
+                } else if (im->kp && !paused) {
+                    // forward repeated events
+                    action_volume_down(im, action);
                }
-                break;
+                return;
            case SDLK_UP:
-                // Only capture if shift is set
                if (shift) {
                    if (video && !repeat && down) {
-                        apply_orientation_transform(im, SC_ORIENTATION_FLIP_180);
+                        apply_orientation_transform(im,
+                                                    SC_ORIENTATION_FLIP_180);
                    }
-                    return;
+                } else if (im->kp && !paused) {
+                    // forward repeated events
+                    action_volume_up(im, action);
                }
-                break;
+                return;
            case SDLK_LEFT:
                if (video && !repeat && down) {
                    if (shift) {
-                        apply_orientation_transform(im, SC_ORIENTATION_FLIP_0);
+                        apply_orientation_transform(im,
+                                                    SC_ORIENTATION_FLIP_0);
                    } else {
-                        apply_orientation_transform(im, SC_ORIENTATION_270);
+                        apply_orientation_transform(im,
+                                                    SC_ORIENTATION_270);
                    }
                }
                return;
            case SDLK_RIGHT:
                if (video && !repeat && down) {
                    if (shift) {
-                        apply_orientation_transform(im, SC_ORIENTATION_FLIP_0);
+                        apply_orientation_transform(im,
+                                                    SC_ORIENTATION_FLIP_0);
                    } else {
-                        apply_orientation_transform(im, SC_ORIENTATION_90);
+                        apply_orientation_transform(im,
+                                                    SC_ORIENTATION_90);
                    }
                }
                return;
-            case SDLK_F:
+            case SDLK_c:
+                if (im->kp && !shift && !repeat && down && !paused) {
+                    get_device_clipboard(im, SC_COPY_KEY_COPY);
+                }
+                return;
+            case SDLK_x:
+                if (im->kp && !shift && !repeat && down && !paused) {
+                    get_device_clipboard(im, SC_COPY_KEY_CUT);
+                }
+                return;
+            case SDLK_v:
+                if (im->kp && !repeat && down && !paused) {
+                    if (shift || im->legacy_paste) {
+                        // inject the text as input events
+                        clipboard_paste(im);
+                    } else {
+                        // store the text in the device clipboard and paste,
+                        // without requesting an acknowledgment
+                        set_device_clipboard(im, true, SC_SEQUENCE_INVALID);
+                    }
+                }
+                return;
+            case SDLK_f:
                if (video && !shift && !repeat && down) {
                    sc_screen_toggle_fullscreen(im->screen);
                }
                return;
-            case SDLK_W:
+            case SDLK_w:
                if (video && !shift && !repeat && down) {
                    sc_screen_resize_to_fit(im->screen);
                }
                return;
-            case SDLK_G:
+            case SDLK_g:
                if (video && !shift && !repeat && down) {
                    sc_screen_resize_to_pixel_perfect(im->screen);
                }
                return;
-            case SDLK_I:
+            case SDLK_i:
                if (video && !shift && !repeat && down) {
                    switch_fps_counter_state(im);
                }
                return;
-        }
-
-        // Flatten conditions to avoid additional indentation levels
-        if (control) {
-            // Controls for all sources
-            switch (sdl_keycode) {
-                case SDLK_R:
-                    if (!repeat && shift && down && !paused) {
+            case SDLK_n:
+                if (control && !repeat && down && !paused) {
+                    if (shift) {
+                        collapse_panels(im);
+                    } else if (im->key_repeat == 0) {
+                        expand_notification_panel(im);
+                    } else {
+                        expand_settings_panel(im);
+                    }
+                }
+                return;
+            case SDLK_r:
+                if (control && !repeat && down && !paused) {
+                    if (shift) {
                        reset_video(im);
-                    }
-                    return;
-            }
-        }
-
-        if (control && !im->camera) {
-            switch (sdl_keycode) {
-                case SDLK_H:
-                    if (im->kp && !shift && !repeat && !paused) {
-                        action_home(im, action);
-                    }
-                    return;
-                case SDLK_B: // fall-through
-                case SDLK_BACKSPACE:
-                    if (im->kp && !shift && !repeat && !paused) {
-                        action_back(im, action);
-                    }
-                    return;
-                case SDLK_S:
-                    if (im->kp && !shift && !repeat && !paused) {
-                        action_app_switch(im, action);
-                    }
-                    return;
-                case SDLK_M:
-                    if (im->kp && !shift && !repeat && !paused) {
-                        action_menu(im, action);
-                    }
-                    return;
-                case SDLK_P:
-                    if (im->kp && !shift && !repeat && !paused) {
-                        action_power(im, action);
-                    }
-                    return;
-                case SDLK_O:
-                    if (control && !repeat && down && !paused) {
-                        bool on = shift;
-                        set_display_power(im, on);
-                    }
-                    return;
-                case SDLK_DOWN:
-                    if (im->kp && !shift && !paused) {
-                        // forward repeated events
-                        action_volume_down(im, action);
-                    }
-                    return;
-                case SDLK_UP:
-                    if (im->kp && !shift && !paused) {
-                        // forward repeated events
-                        action_volume_up(im, action);
-                    }
-                    return;
-                case SDLK_C:
-                    if (im->kp && !shift && !repeat && down && !paused) {
-                        get_device_clipboard(im, SC_COPY_KEY_COPY);
-                    }
-                    return;
-                case SDLK_X:
-                    if (im->kp && !shift && !repeat && down && !paused) {
-                        get_device_clipboard(im, SC_COPY_KEY_CUT);
-                    }
-                    return;
-                case SDLK_V:
-                    if (im->kp && !repeat && down && !paused) {
-                        if (shift || im->legacy_paste) {
-                            // inject the text as input events
-                            clipboard_paste(im);
-                        } else {
-                            // store the text in the device clipboard and paste,
-                            // without requesting an acknowledgment
-                            set_device_clipboard(im, true, SC_SEQUENCE_INVALID);
-                        }
-                    }
-                    return;
-                case SDLK_N:
-                    if (!repeat && down && !paused) {
-                        if (shift) {
-                            collapse_panels(im);
-                        } else if (im->key_repeat == 0) {
-                            expand_notification_panel(im);
-                        } else {
-                            expand_settings_panel(im);
-                        }
-                    }
-                    return;
-                case SDLK_R:
-                    if (!repeat && !shift && down && !paused) {
+                    } else {
                        rotate_device(im);
                    }
-                    return;
-                case SDLK_K:
-                    if (!shift && !repeat && down && !paused
-                            && im->kp && im->kp->hid) {
-                        // Only if the current keyboard is hid
-                        open_hard_keyboard_settings(im);
-                    }
-                    return;
-            }
-        }
-
-        if (control && im->camera) {
-            switch (sdl_keycode) {
-                case SDLK_T:
-                    if (!repeat && down) {
-                        camera_set_torch(im, !shift);
-                    }
-                    return;
-                case SDLK_DOWN:
-                    if (!shift && down && !paused) {
-                        // forward repeated events
-                        camera_zoom_out(im);
-                    }
-                    return;
-                case SDLK_UP:
-                    if (!shift && down && !paused) {
-                        // forward repeated events
-                        camera_zoom_in(im);
-                    }
-                    return;
-            }
+                }
+                return;
+            case SDLK_k:
+                if (control && !shift && !repeat && down && !paused
+                        && im->kp && im->kp->hid) {
+                    // Only if the current keyboard is hid
+                    open_hard_keyboard_settings(im);
+                }
+                return;
        }

        return;
@@ -645,10 +557,8 @@ sc_input_manager_process_key(struct sc_input_manager *im,
        return;
    }

-    assert(!im->camera);
-
    uint64_t ack_to_wait = SC_SEQUENCE_INVALID;
-    bool is_ctrl_v = ctrl && !shift && sdl_keycode == SDLK_V && down && !repeat;
+    bool is_ctrl_v = ctrl && !shift && sdl_keycode == SDLK_v && down && !repeat;
    if (im->clipboard_autosync && is_ctrl_v) {
        if (im->legacy_paste) {
            // inject the text as input events
@@ -681,7 +591,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
        return;
    }

-    enum sc_scancode scancode = sc_scancode_from_sdl(event->scancode);
+    enum sc_scancode scancode = sc_scancode_from_sdl(event->keysym.scancode);
    if (scancode == SC_SCANCODE_UNKNOWN) {
        return;
    }
@@ -691,7 +601,7 @@ sc_input_manager_process_key(struct sc_input_manager *im,
        .keycode = keycode,
        .scancode = scancode,
        .repeat = event->repeat,
-        .mods_state = sc_mods_state_from_sdl(event->mod),
+        .mods_state = sc_mods_state_from_sdl(event->keysym.mod),
    };

    assert(im->kp->ops->process_key);
@@ -718,10 +628,6 @@ sc_input_manager_get_position(struct sc_input_manager *im, int32_t x,
 static void
 sc_input_manager_process_mouse_motion(struct sc_input_manager *im,
                                      const SDL_MouseMotionEvent *event) {
-    if (im->camera || !im->mp || im->screen->paused) {
-        return;
-    }
-
    if (event->which == SDL_TOUCH_MOUSEID) {
        // simulated from touch events, so it's a duplicate
        return;
@@ -757,21 +663,18 @@ sc_input_manager_process_mouse_motion(struct sc_input_manager *im,
 static void
 sc_input_manager_process_touch(struct sc_input_manager *im,
                               const SDL_TouchFingerEvent *event) {
-    if (im->camera || !im->mp || im->screen->paused) {
-        return;
-    }
-
    if (!im->mp->ops->process_touch) {
        // The mouse processor does not support touch events
        return;
    }

-    struct sc_size drawable_size =
-        sc_sdl_get_window_size_in_pixels(im->screen->window);
+    int dw;
+    int dh;
+    SDL_GL_GetDrawableSize(im->screen->window, &dw, &dh);

    // SDL touch event coordinates are normalized in the range [0; 1]
-    int32_t x = event->x * (int32_t) drawable_size.width;
-    int32_t y = event->y * (int32_t) drawable_size.height;
+    int32_t x = event->x * dw;
+    int32_t y = event->y * dh;

    struct sc_touch_event evt = {
        .position = {
@@ -780,7 +683,7 @@ sc_input_manager_process_touch(struct sc_input_manager *im,
                sc_screen_convert_drawable_to_frame_coords(im->screen, x, y),
        },
        .action = sc_touch_action_from_sdl(event->type),
-        .pointer_id = event->fingerID,
+        .pointer_id = event->fingerId,
        .pressure = event->pressure,
    };

@@ -809,13 +712,6 @@ sc_input_manager_get_binding(const struct sc_mouse_binding_set *bindings,
 static void
 sc_input_manager_process_mouse_button(struct sc_input_manager *im,
                                      const SDL_MouseButtonEvent *event) {
-    // some mouse events do not interact with the device, so process the event
-    // even if control is disabled
-
-    if (im->camera) {
-        return;
-    }
-
    if (event->which == SDL_TOUCH_MOUSEID) {
        // simulated from touch events, so it's a duplicate
        return;
@@ -823,7 +719,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,

    bool control = im->controller;
    bool paused = im->screen->paused;
-    bool down = event->type == SDL_EVENT_MOUSE_BUTTON_DOWN;
+    bool down = event->type == SDL_MOUSEBUTTONDOWN;

    enum sc_mouse_button button = sc_mouse_button_from_sdl(event->button);
    if (button == SC_MOUSE_BUTTON_UNKNOWN) {
@@ -836,8 +732,8 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
    }

    SDL_Keymod keymod = SDL_GetModState();
-    bool ctrl_pressed = keymod & SDL_KMOD_CTRL;
-    bool shift_pressed = keymod & SDL_KMOD_SHIFT;
+    bool ctrl_pressed = keymod & KMOD_CTRL;
+    bool shift_pressed = keymod & KMOD_SHIFT;

    if (control && !paused) {
        enum sc_action action = down ? SC_ACTION_DOWN : SC_ACTION_UP;
@@ -890,7 +786,7 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
        int32_t x = event->x;
        int32_t y = event->y;
        sc_screen_hidpi_scale_coords(im->screen, &x, &y);
-        SDL_FRect *r = &im->screen->rect;
+        SDL_Rect *r = &im->screen->rect;
        bool outside = x < r->x || x >= r->x + r->w
                    || y < r->y || y >= r->y + r->h;
        if (outside) {
@@ -983,25 +879,26 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
 static void
 sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,
                                     const SDL_MouseWheelEvent *event) {
-    if (im->camera || !im->kp || im->screen->paused) {
-        return;
-    }
-
    if (!im->mp->ops->process_mouse_scroll) {
        // The mouse processor does not support scroll events
        return;
    }

    // mouse_x and mouse_y are expressed in pixels relative to the window
-    float mouse_x;
-    float mouse_y;
+    int mouse_x;
+    int mouse_y;
    uint32_t buttons = SDL_GetMouseState(&mouse_x, &mouse_y);
    (void) buttons; // Actual buttons are tracked manually to ignore shortcuts

    struct sc_mouse_scroll_event evt = {
        .position = sc_input_manager_get_position(im, mouse_x, mouse_y),
-        .hscroll = event->x,
-        .vscroll = event->y,
+#if SDL_VERSION_ATLEAST(2, 0, 18)
+        .hscroll = CLAMP(event->preciseX, -1.0f, 1.0f),
+        .vscroll = CLAMP(event->preciseY, -1.0f, 1.0f),
+#else
+        .hscroll = CLAMP(event->x, -1, 1),
+        .vscroll = CLAMP(event->y, -1, 1),
+#endif
        .buttons_state = im->mouse_buttons_state,
    };

@@ -1010,37 +907,31 @@ sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,

 static void
 sc_input_manager_process_gamepad_device(struct sc_input_manager *im,
-                                       const SDL_GamepadDeviceEvent *event) {
-    // Handle device added or removed even if paused
-
-    if (im->camera || !im->gp) {
-        return;
-    }
-
-    if (event->type == SDL_EVENT_GAMEPAD_ADDED) {
-        SDL_Gamepad *sdl_gamepad = SDL_OpenGamepad(event->which);
-        if (!sdl_gamepad) {
-            LOGW("Could not open gamepad");
+                                       const SDL_ControllerDeviceEvent *event) {
+    if (event->type == SDL_CONTROLLERDEVICEADDED) {
+        SDL_GameController *gc = SDL_GameControllerOpen(event->which);
+        if (!gc) {
+            LOGW("Could not open game controller");
            return;
        }

-        SDL_Joystick *joystick = SDL_GetGamepadJoystick(sdl_gamepad);
+        SDL_Joystick *joystick = SDL_GameControllerGetJoystick(gc);
        if (!joystick) {
-            LOGW("Could not get gamepad joystick");
-            SDL_CloseGamepad(sdl_gamepad);
+            LOGW("Could not get controller joystick");
+            SDL_GameControllerClose(gc);
            return;
        }

        struct sc_gamepad_device_event evt = {
-            .gamepad_id = SDL_GetJoystickID(joystick),
+            .gamepad_id = SDL_JoystickInstanceID(joystick),
        };
        im->gp->ops->process_gamepad_added(im->gp, &evt);
-    } else if (event->type == SDL_EVENT_GAMEPAD_REMOVED) {
+    } else if (event->type == SDL_CONTROLLERDEVICEREMOVED) {
        SDL_JoystickID id = event->which;

-        SDL_Gamepad *sdl_gamepad = SDL_GetGamepadFromID(id);
-        if (sdl_gamepad) {
-            SDL_CloseGamepad(sdl_gamepad);
+        SDL_GameController *gc = SDL_GameControllerFromInstanceID(id);
+        if (gc) {
+            SDL_GameControllerClose(gc);
        } else {
            LOGW("Unknown gamepad device removed");
        }
@@ -1057,11 +948,7 @@ sc_input_manager_process_gamepad_device(struct sc_input_manager *im,

 static void
 sc_input_manager_process_gamepad_axis(struct sc_input_manager *im,
-                                      const SDL_GamepadAxisEvent *event) {
-    if (im->camera || !im->gp || im->screen->paused) {
-        return;
-    }
-
+                                      const SDL_ControllerAxisEvent *event) {
    enum sc_gamepad_axis axis = sc_gamepad_axis_from_sdl(event->axis);
    if (axis == SC_GAMEPAD_AXIS_UNKNOWN) {
        return;
@@ -1077,11 +964,7 @@ sc_input_manager_process_gamepad_axis(struct sc_input_manager *im,

 static void
 sc_input_manager_process_gamepad_button(struct sc_input_manager *im,
-                                       const SDL_GamepadButtonEvent *event) {
-    if (im->camera || !im->gp || im->screen->paused) {
-        return;
-    }
-
+                                       const SDL_ControllerButtonEvent *event) {
    enum sc_gamepad_button button = sc_gamepad_button_from_sdl(event->button);
    if (button == SC_GAMEPAD_BUTTON_UNKNOWN) {
        return;
@@ -1089,7 +972,7 @@ sc_input_manager_process_gamepad_button(struct sc_input_manager *im,

    struct sc_gamepad_button_event evt = {
        .gamepad_id = event->which,
-        .action = sc_action_from_sdl_gamepad_button_type(event->type),
+        .action = sc_action_from_sdl_controllerbutton_type(event->type),
        .button = button,
    };
    im->gp->ops->process_gamepad_button(im->gp, &evt);
@@ -1104,12 +987,8 @@ is_apk(const char *file) {
 static void
 sc_input_manager_process_file(struct sc_input_manager *im,
                              const SDL_DropEvent *event) {
-    if (im->camera || !im->controller) {
-        return;
-    }
-
-    assert(event->type == SDL_EVENT_DROP_FILE);
-    char *file = strdup(event->data);
+    char *file = strdup(event->file);
+    SDL_free(event->file);
    if (!file) {
        LOG_OOM();
        return;
@@ -1130,42 +1009,73 @@ sc_input_manager_process_file(struct sc_input_manager *im,
 void
 sc_input_manager_handle_event(struct sc_input_manager *im,
                              const SDL_Event *event) {
+    bool control = im->controller;
+    bool paused = im->screen->paused;
    switch (event->type) {
-        case SDL_EVENT_TEXT_INPUT:
+        case SDL_TEXTINPUT:
+            if (!im->kp || paused) {
+                break;
+            }
            sc_input_manager_process_text_input(im, &event->text);
            break;
-        case SDL_EVENT_KEY_DOWN:
-        case SDL_EVENT_KEY_UP:
+        case SDL_KEYDOWN:
+        case SDL_KEYUP:
+            // some key events do not interact with the device, so process the
+            // event even if control is disabled
            sc_input_manager_process_key(im, &event->key);
            break;
-        case SDL_EVENT_MOUSE_MOTION:
+        case SDL_MOUSEMOTION:
+            if (!im->mp || paused) {
+                break;
+            }
            sc_input_manager_process_mouse_motion(im, &event->motion);
            break;
-        case SDL_EVENT_MOUSE_WHEEL:
+        case SDL_MOUSEWHEEL:
+            if (!im->mp || paused) {
+                break;
+            }
            sc_input_manager_process_mouse_wheel(im, &event->wheel);
            break;
-        case SDL_EVENT_MOUSE_BUTTON_DOWN:
-        case SDL_EVENT_MOUSE_BUTTON_UP:
+        case SDL_MOUSEBUTTONDOWN:
+        case SDL_MOUSEBUTTONUP:
+            // some mouse events do not interact with the device, so process
+            // the event even if control is disabled
            sc_input_manager_process_mouse_button(im, &event->button);
            break;
-        case SDL_EVENT_FINGER_MOTION:
-        case SDL_EVENT_FINGER_DOWN:
-        case SDL_EVENT_FINGER_UP:
+        case SDL_FINGERMOTION:
+        case SDL_FINGERDOWN:
+        case SDL_FINGERUP:
+            if (!im->mp || paused) {
+                break;
+            }
            sc_input_manager_process_touch(im, &event->tfinger);
            break;
-        case SDL_EVENT_GAMEPAD_ADDED:
-        case SDL_EVENT_GAMEPAD_REMOVED:
-            sc_input_manager_process_gamepad_device(im, &event->gdevice);
+        case SDL_CONTROLLERDEVICEADDED:
+        case SDL_CONTROLLERDEVICEREMOVED:
+            // Handle device added or removed even if paused
+            if (!im->gp) {
+                break;
+            }
+            sc_input_manager_process_gamepad_device(im, &event->cdevice);
            break;
-        case SDL_EVENT_GAMEPAD_AXIS_MOTION:
-            sc_input_manager_process_gamepad_axis(im, &event->gaxis);
+        case SDL_CONTROLLERAXISMOTION:
+            if (!im->gp || paused) {
+                break;
+            }
+            sc_input_manager_process_gamepad_axis(im, &event->caxis);
            break;
-        case SDL_EVENT_GAMEPAD_BUTTON_DOWN:
-        case SDL_EVENT_GAMEPAD_BUTTON_UP:
-            sc_input_manager_process_gamepad_button(im, &event->gbutton);
+        case SDL_CONTROLLERBUTTONDOWN:
+        case SDL_CONTROLLERBUTTONUP:
+            if (!im->gp || paused) {
+                break;
+            }
+            sc_input_manager_process_gamepad_button(im, &event->cbutton);
            break;
-        case SDL_EVENT_DROP_FILE:
+        case SDL_DROPFILE: {
+            if (!control) {
+                break;
+            }
            sc_input_manager_process_file(im, &event->drop);
-            break;
+        }
    }
 }
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@@ -4,12 +4,12 @@
 #include "common.h"

 #include <stdbool.h>
-#include <stdint.h>
-#include <SDL3/SDL_events.h>
-#include <SDL3/SDL_keycode.h>
+
+#include <SDL2/SDL.h>

 #include "controller.h"
 #include "file_pusher.h"
+#include "fps_counter.h"
 #include "options.h"
 #include "trait/gamepad_processor.h"
 #include "trait/key_processor.h"
@@ -24,8 +24,6 @@ struct sc_input_manager {
    struct sc_mouse_processor *mp;
    struct sc_gamepad_processor *gp;

-    bool camera;
-
    struct sc_mouse_bindings mouse_bindings;
    bool legacy_paste;
    bool clipboard_autosync;
@@ -55,7 +53,6 @@ struct sc_input_manager_params {
    struct sc_key_processor *kp;
    struct sc_mouse_processor *mp;
    struct sc_gamepad_processor *gp;
-    bool camera;

    struct sc_mouse_bindings mouse_bindings;
    bool legacy_paste;
--- a/app/src/keyboard_sdk.c
+++ b/app/src/keyboard_sdk.c
@@ -1,13 +1,8 @@
 #include "keyboard_sdk.h"

 #include <assert.h>
-#include <ctype.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>

 #include "android/input.h"
-#include "android/keycodes.h"
 #include "control_msg.h"
 #include "controller.h"
 #include "input_events.h"
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -1,18 +1,19 @@
 #include "common.h"

+#include <assert.h>
 #include <stdbool.h>
-#include <stdio.h>
+#include <unistd.h>
+#include <libavformat/avformat.h>
 #ifdef HAVE_V4L2
 # include <libavdevice/avdevice.h>
 #endif
-#include <SDL3/SDL.h>
+#define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
+#include <SDL2/SDL.h>

 #include "cli.h"
 #include "options.h"
 #include "scrcpy.h"
-#ifdef HAVE_USB
-# include "usb/scrcpy_otg.h"
-#endif
+#include "usb/scrcpy_otg.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/thread.h"
@@ -39,7 +40,7 @@ main_scrcpy(int argc, char *argv[]) {
        .opts = scrcpy_options_default,
        .help = false,
        .version = false,
-        .pause_on_exit = SC_PAUSE_ON_EXIT_UNDEFINED,
+        .pause_on_exit = SC_PAUSE_ON_EXIT_FALSE,
    };

 #ifndef NDEBUG
--- a/app/src/mouse_capture.c
+++ b/app/src/mouse_capture.c
@@ -20,11 +20,14 @@ bool
 sc_mouse_capture_handle_event(struct sc_mouse_capture *mc,
                              const SDL_Event *event) {
    switch (event->type) {
-        case SDL_EVENT_WINDOW_FOCUS_LOST:
-            sc_mouse_capture_set_active(mc, false);
-            return true;
-        case SDL_EVENT_KEY_DOWN: {
-            SDL_Keycode key = event->key.key;
+        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;
@@ -38,8 +41,8 @@ sc_mouse_capture_handle_event(struct sc_mouse_capture *mc,
            }
            break;
        }
-        case SDL_EVENT_KEY_UP: {
-            SDL_Keycode key = event->key.key;
+        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)) {
@@ -53,24 +56,24 @@ sc_mouse_capture_handle_event(struct sc_mouse_capture *mc,
            }
            break;
        }
-        case SDL_EVENT_MOUSE_WHEEL:
-        case SDL_EVENT_MOUSE_MOTION:
-        case SDL_EVENT_MOUSE_BUTTON_DOWN:
+        case SDL_MOUSEWHEEL:
+        case SDL_MOUSEMOTION:
+        case SDL_MOUSEBUTTONDOWN:
            if (!sc_mouse_capture_is_active(mc)) {
-                // The mouse will be captured on SDL_EVENT_MOUSE_BUTTON_UP, so
-                // consume the event
+                // The mouse will be captured on SDL_MOUSEBUTTONUP, so consume
+                // the event
                return true;
            }
            break;
-        case SDL_EVENT_MOUSE_BUTTON_UP:
+        case SDL_MOUSEBUTTONUP:
            if (!sc_mouse_capture_is_active(mc)) {
                sc_mouse_capture_set_active(mc, true);
                return true;
            }
            break;
-        case SDL_EVENT_FINGER_MOTION:
-        case SDL_EVENT_FINGER_DOWN:
-        case SDL_EVENT_FINGER_UP:
+        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;
@@ -81,8 +84,27 @@ sc_mouse_capture_handle_event(struct sc_mouse_capture *mc,

 void
 sc_mouse_capture_set_active(struct sc_mouse_capture *mc, bool capture) {
-    bool ok = SDL_SetWindowRelativeMouseMode(mc->window, capture);
-    if (!ok) {
+#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());
    }
@@ -90,7 +112,8 @@ sc_mouse_capture_set_active(struct sc_mouse_capture *mc, bool capture) {

 bool
 sc_mouse_capture_is_active(struct sc_mouse_capture *mc) {
-    return SDL_GetWindowRelativeMouseMode(mc->window);
+    (void) mc;
+    return SDL_GetRelativeMouseMode();
 }

 void
--- a/app/src/mouse_capture.h
+++ b/app/src/mouse_capture.h
@@ -5,7 +5,7 @@

 #include <stdbool.h>

-#include <SDL3/SDL.h>
+#include <SDL2/SDL.h>

 struct sc_mouse_capture {
    SDL_Window *window;
--- a/app/src/mouse_sdk.c
+++ b/app/src/mouse_sdk.c
@@ -1,12 +1,12 @@
 #include "mouse_sdk.h"

 #include <assert.h>
-#include <stdint.h>

 #include "android/input.h"
 #include "control_msg.h"
 #include "controller.h"
 #include "input_events.h"
+#include "util/intmap.h"
 #include "util/log.h"

 /** Downcast mouse processor to sc_mouse_sdk */
--- a/app/src/mouse_sdk.h
+++ b/app/src/mouse_sdk.h
@@ -6,6 +6,7 @@
 #include <stdbool.h>

 #include "controller.h"
+#include "screen.h"
 #include "trait/mouse_processor.h"

 struct sc_mouse_sdk {
--- a/app/src/opengl.c
+++ b/app/src/opengl.c
@@ -2,30 +2,21 @@

 #include <assert.h>
 #include <stdio.h>
-#include <string.h>
-#include <SDL3/SDL.h>
+#include "SDL2/SDL.h"

 void
 sc_opengl_init(struct sc_opengl *gl) {
-    gl->GetString = (const GLubyte *(*)(GLenum))
-                    SDL_GL_GetProcAddress("glGetString");
+    gl->GetString = SDL_GL_GetProcAddress("glGetString");
    assert(gl->GetString);

-    gl->BindTexture = (void (*)(GLenum, GLuint))
-                      SDL_GL_GetProcAddress("glBindTexture");
-    assert(gl->BindTexture);
-
-    gl->TexParameterf = (void (*)(GLenum, GLenum, GLfloat))
-                        SDL_GL_GetProcAddress("glTexParameterf");
+    gl->TexParameterf = SDL_GL_GetProcAddress("glTexParameterf");
    assert(gl->TexParameterf);

-    gl->TexParameteri = (void (*)(GLenum, GLenum, GLint))
-                        SDL_GL_GetProcAddress("glTexParameteri");
+    gl->TexParameteri = SDL_GL_GetProcAddress("glTexParameteri");
    assert(gl->TexParameteri);

    // optional
-    gl->GenerateMipmap = (void (*)(GLenum))
-                         SDL_GL_GetProcAddress("glGenerateMipmap");
+    gl->GenerateMipmap = SDL_GL_GetProcAddress("glGenerateMipmap");

    const char *version = (const char *) gl->GetString(GL_VERSION);
    assert(version);
--- a/app/src/opengl.h
+++ b/app/src/opengl.h
@@ -4,7 +4,7 @@
 #include "common.h"

 #include <stdbool.h>
-#include <SDL3/SDL_opengl.h>
+#include <SDL2/SDL_opengl.h>

 struct sc_opengl {
    const char *version;
@@ -15,9 +15,6 @@ struct sc_opengl {
    const GLubyte *
    (*GetString)(GLenum name);

-    void
-    (*BindTexture)(GLenum target, GLuint texture);
-
    void
    (*TexParameterf)(GLenum target, GLenum pname, GLfloat param);

--- a/app/src/options.c
+++ b/app/src/options.c
@@ -1,7 +1,5 @@
 #include "options.h"

-#include <stddef.h>
-
 const struct scrcpy_options scrcpy_options_default = {
    .serial = NULL,
    .crop = NULL,
@@ -16,7 +14,6 @@ const struct scrcpy_options scrcpy_options_default = {
    .camera_id = NULL,
    .camera_size = NULL,
    .camera_ar = NULL,
-    .camera_zoom = NULL,
    .camera_fps = 0,
    .log_level = SC_LOG_LEVEL_INFO,
    .video_codec = SC_CODEC_H264,
@@ -57,7 +54,6 @@ const struct scrcpy_options scrcpy_options_default = {
    .capture_orientation_lock = SC_ORIENTATION_UNLOCKED,
    .display_orientation = SC_ORIENTATION_0,
    .record_orientation = SC_ORIENTATION_0,
-    .display_ime_policy = SC_DISPLAY_IME_POLICY_UNDEFINED,
    .window_x = SC_WINDOW_POSITION_UNDEFINED,
    .window_y = SC_WINDOW_POSITION_UNDEFINED,
    .window_width = 0,
@@ -114,7 +110,6 @@ const struct scrcpy_options scrcpy_options_default = {
    .angle = NULL,
    .vd_destroy_content = true,
    .vd_system_decorations = true,
-    .camera_torch = false,
 };

 enum sc_orientation
--- a/app/src/options.h
+++ b/app/src/options.h
@@ -5,6 +5,7 @@

 #include <assert.h>
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>

 #include "util/tick.h"
@@ -59,14 +60,6 @@ enum sc_audio_source {
    SC_AUDIO_SOURCE_OUTPUT,
    SC_AUDIO_SOURCE_MIC,
    SC_AUDIO_SOURCE_PLAYBACK,
-    SC_AUDIO_SOURCE_MIC_UNPROCESSED,
-    SC_AUDIO_SOURCE_MIC_CAMCORDER,
-    SC_AUDIO_SOURCE_MIC_VOICE_RECOGNITION,
-    SC_AUDIO_SOURCE_MIC_VOICE_COMMUNICATION,
-    SC_AUDIO_SOURCE_VOICE_CALL,
-    SC_AUDIO_SOURCE_VOICE_CALL_UPLINK,
-    SC_AUDIO_SOURCE_VOICE_CALL_DOWNLINK,
-    SC_AUDIO_SOURCE_VOICE_PERFORMANCE,
 };

 enum sc_camera_facing {
@@ -97,13 +90,6 @@ enum sc_orientation_lock {
    SC_ORIENTATION_LOCKED_INITIAL, // lock to initial device orientation
 };

-enum sc_display_ime_policy {
-    SC_DISPLAY_IME_POLICY_UNDEFINED,
-    SC_DISPLAY_IME_POLICY_LOCAL,
-    SC_DISPLAY_IME_POLICY_FALLBACK,
-    SC_DISPLAY_IME_POLICY_HIDE,
-};
-
 static inline bool
 sc_orientation_is_mirror(enum sc_orientation orientation) {
    assert(!(orientation & ~7));
@@ -241,7 +227,6 @@ struct scrcpy_options {
    const char *camera_id;
    const char *camera_size;
    const char *camera_ar;
-    const char *camera_zoom;
    uint16_t camera_fps;
    enum sc_log_level log_level;
    enum sc_codec video_codec;
@@ -267,7 +252,6 @@ struct scrcpy_options {
    enum sc_orientation_lock capture_orientation_lock;
    enum sc_orientation display_orientation;
    enum sc_orientation record_orientation;
-    enum sc_display_ime_policy display_ime_policy;
    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    uint16_t window_width;
@@ -328,7 +312,6 @@ struct scrcpy_options {
    const char *start_app;
    bool vd_destroy_content;
    bool vd_system_decorations;
-    bool camera_torch;
 };

 extern const struct scrcpy_options scrcpy_options_default;
--- a/app/src/packet_merger.c
+++ b/app/src/packet_merger.c
@@ -1,9 +1,5 @@
 #include "packet_merger.h"

-#include <stdlib.h>
-#include <string.h>
-#include <libavutil/avutil.h>
-
 #include "util/log.h"

 void
--- a/app/src/packet_merger.h
+++ b/app/src/packet_merger.h
@@ -5,7 +5,7 @@

 #include <stdbool.h>
 #include <stdint.h>
-#include <libavcodec/packet.h>
+#include <libavcodec/avcodec.h>

 /**
 * Config packets (containing the SPS/PPS) are sent in-band. A new config
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@@ -2,8 +2,8 @@

 #include <assert.h>
 #include <inttypes.h>
-#include <stdlib.h>
-#include <SDL3/SDL_clipboard.h>
+#include <stdint.h>
+#include <SDL2/SDL_clipboard.h>

 #include "device_msg.h"
 #include "events.h"
@@ -54,12 +54,8 @@ task_set_clipboard(void *userdata) {
    if (same) {
        LOGD("Computer clipboard unchanged");
    } else {
-        bool ok = SDL_SetClipboardText(text);
-        if (ok) {
-            LOGI("Device clipboard copied");
-        } else {
-            LOGE("Could not set clipboard: %s", SDL_GetError());
-        }
+        LOGI("Device clipboard copied");
+        SDL_SetClipboardText(text);
    }

    free(text);
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@@ -1,9 +1,6 @@
 #include "recorder.h"

 #include <assert.h>
-#include <inttypes.h>
-#include <stdlib.h>
-#include <string.h>
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
@@ -444,7 +441,7 @@ sc_recorder_process_packets(struct sc_recorder *recorder) {
    int ret = av_write_trailer(recorder->ctx);
    if (ret < 0) {
        LOGE("Failed to write trailer to %s", recorder->filename);
-        error = true;
+        error = false;
    }

 end:
@@ -541,10 +538,7 @@ sc_recorder_set_orientation(AVStream *stream, enum sc_orientation orientation) {

 static bool
 sc_recorder_video_packet_sink_open(struct sc_packet_sink *sink,
-                                   AVCodecContext *ctx,
-                                   const struct sc_stream_session *session) {
-    (void) session;
-
+                                   AVCodecContext *ctx) {
    struct sc_recorder *recorder = DOWNCAST_VIDEO(sink);
    // only written from this thread, no need to lock
    assert(!recorder->video_init);
@@ -638,10 +632,7 @@ sc_recorder_video_packet_sink_push(struct sc_packet_sink *sink,

 static bool
 sc_recorder_audio_packet_sink_open(struct sc_packet_sink *sink,
-                                   AVCodecContext *ctx,
-                                   const struct sc_stream_session *session) {
-    (void) session;
-
+                                   AVCodecContext *ctx) {
    struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
    assert(recorder->audio);
    // only written from this thread, no need to lock
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@@ -4,10 +4,9 @@
 #include "common.h"

 #include <stdbool.h>
-#include <stdint.h>
-#include <libavcodec/packet.h>
 #include <libavformat/avformat.h>

+#include "coords.h"
 #include "options.h"
 #include "trait/packet_sink.h"
 #include "util/thread.h"
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -1,12 +1,11 @@
 #include "scrcpy.h"

-#include <assert.h>
-#include <inttypes.h>
-#include <stdbool.h>
 #include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
-#include <SDL3/SDL.h>
+#include <unistd.h>
+#include <libavformat/avformat.h>
+#include <sys/time.h>
+#include <SDL2/SDL.h>

 #ifdef _WIN32
 // not needed here, but winsock2.h must never be included AFTER windows.h
@@ -38,9 +37,9 @@
 #endif
 #include "util/acksync.h"
 #include "util/log.h"
+#include "util/net.h"
 #include "util/rand.h"
 #include "util/timeout.h"
-#include "util/tick.h"
 #ifdef HAVE_V4L2
 # include "v4l2_sink.h"
 #endif
@@ -93,8 +92,8 @@ struct scrcpy {

 #ifdef _WIN32
 static BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
-    if (ctrl_type == CTRL_C_EVENT || ctrl_type == CTRL_BREAK_EVENT) {
-        sc_push_event(SDL_EVENT_QUIT);
+    if (ctrl_type == CTRL_C_EVENT) {
+        sc_push_event(SDL_QUIT);
        return TRUE;
    }
    return FALSE;
@@ -107,9 +106,9 @@ sdl_set_hints(const char *render_driver) {
        LOGW("Could not set render driver");
    }

-    // App name used in various contexts (such as PulseAudio)
-    if (!SDL_SetHint(SDL_HINT_APP_NAME, "scrcpy")) {
-        LOGW("Could not set app name");
+    // Linear filtering
+    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
+        LOGW("Could not enable linear filtering");
    }

    // Handle a click to gain focus as any other click
@@ -117,17 +116,21 @@ sdl_set_hints(const char *render_driver) {
        LOGW("Could not enable mouse focus clickthrough");
    }

+#ifdef SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
    // Disable synthetic mouse events from touch events
    // Touch events with id SDL_TOUCH_MOUSEID are ignored anyway, but it is
    // better not to generate them in the first place.
    if (!SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0")) {
        LOGW("Could not disable synthetic mouse events");
    }
+#endif

+#ifdef SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
    // Disable compositor bypassing on X11
    if (!SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0")) {
        LOGW("Could not disable X11 compositor bypass");
    }
+#endif

    // Do not minimize on focus loss
    if (!SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0")) {
@@ -154,20 +157,14 @@ sdl_configure(bool video_playback, bool disable_screensaver) {
    }

    if (disable_screensaver) {
-        bool ok = SDL_DisableScreenSaver();
-        if (!ok) {
-            LOGW("Could not disable screen saver");
-        }
+        SDL_DisableScreenSaver();
    } else {
-        bool ok = SDL_EnableScreenSaver();
-        if (!ok) {
-            LOGW("Could not enable screen saver");
-        }
+        SDL_EnableScreenSaver();
    }
 }

 static enum scrcpy_exit_code
-event_loop(struct scrcpy *s, bool has_screen) {
+event_loop(struct scrcpy *s) {
    SDL_Event event;
    while (SDL_WaitEvent(&event)) {
        switch (event.type) {
@@ -189,7 +186,7 @@ event_loop(struct scrcpy *s, bool has_screen) {
            case SC_EVENT_TIME_LIMIT_REACHED:
                LOGI("Time limit reached");
                return SCRCPY_EXIT_SUCCESS;
-            case SDL_EVENT_QUIT:
+            case SDL_QUIT:
                LOGD("User requested to quit");
                return SCRCPY_EXIT_SUCCESS;
            case SC_EVENT_RUN_ON_MAIN_THREAD: {
@@ -199,8 +196,8 @@ event_loop(struct scrcpy *s, bool has_screen) {
                break;
            }
            default:
-                if (has_screen) {
-                    sc_screen_handle_event(&s->screen, &event);
+                if (!sc_screen_handle_event(&s->screen, &event)) {
+                    return SCRCPY_EXIT_FAILURE;
                }
                break;
        }
@@ -229,7 +226,7 @@ await_for_server(bool *connected) {
    SDL_Event event;
    while (SDL_WaitEvent(&event)) {
        switch (event.type) {
-            case SDL_EVENT_QUIT:
+            case SDL_QUIT:
                if (connected) {
                    *connected = false;
                }
@@ -355,21 +352,14 @@ scrcpy_generate_scid(void) {

 static void
 init_sdl_gamepads(void) {
-    // Trigger a SDL_EVENT_GAMEPAD_ADDED event for all gamepads already
+    // Trigger a SDL_CONTROLLERDEVICEADDED event for all gamepads already
    // connected
-    int count;
-    SDL_JoystickID *joysticks = SDL_GetJoysticks(&count);
-    if (!joysticks) {
-        LOGE("Could not list joysticks: %s", SDL_GetError());
-        return;
-    }
-
-    for (int i = 0; i < count; ++i) {
-        SDL_JoystickID joystick = joysticks[i];
-        if (SDL_IsGamepad(joystick)) {
+    int num_joysticks = SDL_NumJoysticks();
+    for (int i = 0; i < num_joysticks; ++i) {
+        if (SDL_IsGameController(i)) {
            SDL_Event event;
-            event.gdevice.type = SDL_EVENT_GAMEPAD_ADDED;
-            event.gdevice.which = i;
+            event.cdevice.type = SDL_CONTROLLERDEVICEADDED;
+            event.cdevice.which = i;
            SDL_PushEvent(&event);
        }
    }
@@ -385,7 +375,7 @@ scrcpy(struct scrcpy_options *options) {
    struct scrcpy *s = &scrcpy;

    // Minimal SDL initialization
-    if (!SDL_Init(SDL_INIT_EVENTS)) {
+    if (SDL_Init(SDL_INIT_EVENTS)) {
        LOGE("Could not initialize SDL: %s", SDL_GetError());
        return SCRCPY_EXIT_FAILURE;
    }
@@ -445,7 +435,6 @@ scrcpy(struct scrcpy_options *options) {
        .control = options->control,
        .display_id = options->display_id,
        .new_display = options->new_display,
-        .display_ime_policy = options->display_ime_policy,
        .video = options->video,
        .audio = options->audio,
        .audio_dup = options->audio_dup,
@@ -469,8 +458,6 @@ scrcpy(struct scrcpy_options *options) {
        .power_on = options->power_on,
        .kill_adb_on_close = options->kill_adb_on_close,
        .camera_high_speed = options->camera_high_speed,
-        .camera_torch = options->camera_torch,
-        .camera_zoom = options->camera_zoom,
        .vd_destroy_content = options->vd_destroy_content,
        .vd_system_decorations = options->vd_system_decorations,
        .list = options->list,
@@ -513,7 +500,7 @@ scrcpy(struct scrcpy_options *options) {
        // --no-video-playback is passed so that clipboard synchronization
        // still works.
        // <https://github.com/Genymobile/scrcpy/issues/4418>
-        if (!SDL_Init(SDL_INIT_VIDEO)) {
+        if (SDL_Init(SDL_INIT_VIDEO)) {
            // If it fails, it is an error only if video playback is enabled
            if (options->video_playback) {
                LOGE("Could not initialize SDL video: %s", SDL_GetError());
@@ -525,14 +512,14 @@ scrcpy(struct scrcpy_options *options) {
    }

    if (options->audio_playback) {
-        if (!SDL_Init(SDL_INIT_AUDIO)) {
+        if (SDL_Init(SDL_INIT_AUDIO)) {
            LOGE("Could not initialize SDL audio: %s", SDL_GetError());
            goto end;
        }
    }

    if (options->gamepad_input_mode != SC_GAMEPAD_INPUT_MODE_DISABLED) {
-        if (!SDL_Init(SDL_INIT_GAMEPAD)) {
+        if (SDL_Init(SDL_INIT_GAMECONTROLLER)) {
            LOGE("Could not initialize SDL gamepad: %s", SDL_GetError());
            goto end;
        }
@@ -564,7 +551,7 @@ scrcpy(struct scrcpy_options *options) {

    struct sc_file_pusher *fp = NULL;

-    if (options->window && options->control) {
+    if (options->video_playback && options->control) {
        if (!sc_file_pusher_init(&s->file_pusher, serial,
                                 options->push_target)) {
            goto end;
@@ -804,7 +791,6 @@ aoa_complete:

        struct sc_screen_params screen_params = {
            .video = options->video_playback,
-            .camera = options->video_source == SC_VIDEO_SOURCE_CAMERA,
            .controller = controller,
            .fp = fp,
            .kp = kp,
@@ -945,11 +931,11 @@ aoa_complete:
        }
    }

-    ret = event_loop(s, options->window);
+    ret = event_loop(s);
    terminate_event_loop();
    LOGD("quit...");

-    if (options->window) {
+    if (options->video_playback) {
        // Close the window immediately on closing, because screen_destroy()
        // may only be called once the video demuxer thread is joined (it may
        // take time)
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@@ -3,6 +3,7 @@

 #include "common.h"

+#include <stdbool.h>
 #include "options.h"

 enum scrcpy_exit_code {
--- a/app/src/screen.c
+++ b/app/src/screen.c
@@ -2,13 +2,12 @@

 #include <assert.h>
 #include <string.h>
-#include <SDL3/SDL.h>
+#include <SDL2/SDL.h>

 #include "events.h"
 #include "icon.h"
 #include "options.h"
 #include "util/log.h"
-#include "util/sdl.h"

 #define DISPLAY_MARGINS 96

@@ -27,25 +26,45 @@ get_oriented_size(struct sc_size size, enum sc_orientation orientation) {
    return oriented_size;
 }

-static inline bool
-is_windowed(struct sc_screen *screen) {
-    return !(SDL_GetWindowFlags(screen->window) & (SDL_WINDOW_FULLSCREEN
-                                                 | SDL_WINDOW_MINIMIZED
-                                                 | SDL_WINDOW_MAXIMIZED));
+// get the window size in a struct sc_size
+static struct sc_size
+get_window_size(const struct sc_screen *screen) {
+    int width;
+    int height;
+    SDL_GetWindowSize(screen->window, &width, &height);
+
+    struct sc_size size;
+    size.width = width;
+    size.height = height;
+    return size;
+}
+
+static struct sc_point
+get_window_position(const struct sc_screen *screen) {
+    int x;
+    int y;
+    SDL_GetWindowPosition(screen->window, &x, &y);
+
+    struct sc_point point;
+    point.x = x;
+    point.y = y;
+    return point;
+}
+
+// set the window size to be applied when fullscreen is disabled
+static void
+set_window_size(struct sc_screen *screen, struct sc_size new_size) {
+    assert(!screen->fullscreen);
+    assert(!screen->maximized);
+    assert(!screen->minimized);
+    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
 }

 // get the preferred display bounds (i.e. the screen bounds with some margins)
 static bool
 get_preferred_display_bounds(struct sc_size *bounds) {
    SDL_Rect rect;
-    SDL_DisplayID display = SDL_GetPrimaryDisplay();
-    if (!display) {
-        LOGW("Could not get primary display: %s", SDL_GetError());
-        return false;
-    }
-
-    bool ok = SDL_GetDisplayUsableBounds(display, &rect);
-    if (!ok) {
+    if (SDL_GetDisplayUsableBounds(0, &rect)) {
        LOGW("Could not get display usable bounds: %s", SDL_GetError());
        return false;
    }
@@ -144,113 +163,69 @@ sc_screen_is_relative_mode(struct sc_screen *screen) {
 }

 static void
-compute_content_rect(struct sc_size render_size, struct sc_size content_size,
-                     bool can_upscale, SDL_FRect *rect) {
-    if (is_optimal_size(render_size, content_size)) {
+sc_screen_update_content_rect(struct sc_screen *screen) {
+    assert(screen->video);
+
+    int dw;
+    int dh;
+    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
+
+    struct sc_size content_size = screen->content_size;
+    // The drawable size is the window size * the HiDPI scale
+    struct sc_size drawable_size = {dw, dh};
+
+    SDL_Rect *rect = &screen->rect;
+
+    if (is_optimal_size(drawable_size, content_size)) {
        rect->x = 0;
        rect->y = 0;
-        rect->w = render_size.width;
-        rect->h = render_size.height;
+        rect->w = drawable_size.width;
+        rect->h = drawable_size.height;
        return;
    }

-    if (!can_upscale && content_size.width <= render_size.width
-                     && content_size.height <= render_size.height) {
-        // Center without upscaling
-        rect->x = (render_size.width - content_size.width) / 2.f;
-        rect->y = (render_size.height - content_size.height) / 2.f;
-        rect->w = content_size.width;
-        rect->h = content_size.height;
-        return;
-    }
-
-    bool keep_width = content_size.width * render_size.height
-                    > content_size.height * render_size.width;
+    bool keep_width = content_size.width * drawable_size.height
+                    > content_size.height * drawable_size.width;
    if (keep_width) {
        rect->x = 0;
-        rect->w = render_size.width;
-        rect->h = (float) render_size.width * content_size.height
-                                            / content_size.width;
-        rect->y = (render_size.height - rect->h) / 2.f;
+        rect->w = drawable_size.width;
+        rect->h = drawable_size.width * content_size.height
+                                      / content_size.width;
+        rect->y = (drawable_size.height - rect->h) / 2;
    } else {
        rect->y = 0;
-        rect->h = render_size.height;
-        rect->w = (float) render_size.height * content_size.width
-                                             / content_size.height;
-        rect->x = (render_size.width - rect->w) / 2.f;
+        rect->h = drawable_size.height;
+        rect->w = drawable_size.height * content_size.width
+                                       / content_size.height;
+        rect->x = (drawable_size.width - rect->w) / 2;
    }
 }

-static void
-sc_screen_update_content_rect(struct sc_screen *screen) {
-    // Only upscale video frames, not icon
-    bool can_upscale = screen->video;
-
-    struct sc_size render_size =
-        sc_sdl_get_render_output_size(screen->renderer);
-    compute_content_rect(render_size, screen->content_size, can_upscale,
-                         &screen->rect);
-}
-
 // render the texture to the renderer
 //
 // Set the update_content_rect flag if the window or content size may have
 // changed, so that the content rectangle is recomputed
 static void
 sc_screen_render(struct sc_screen *screen, bool update_content_rect) {
-    assert(!screen->video || screen->has_video_window);
+    assert(screen->video);

    if (update_content_rect) {
        sc_screen_update_content_rect(screen);
    }

-    SDL_Renderer *renderer = screen->renderer;
-    sc_sdl_render_clear(renderer);
-
-    bool ok = false;
-    SDL_Texture *texture = screen->tex.texture;
-    if (!texture) {
-        LOGW("No texture to render");
-        goto end;
-    }
-
-    SDL_FRect *geometry = &screen->rect;
-    enum sc_orientation orientation = screen->orientation;
-
-    if (orientation == SC_ORIENTATION_0) {
-        ok = SDL_RenderTexture(renderer, texture, NULL, geometry);
-    } else {
-        unsigned cw_rotation = sc_orientation_get_rotation(orientation);
-        double angle = 90 * cw_rotation;
-
-        const SDL_FRect *dstrect = NULL;
-        SDL_FRect rect;
-        if (sc_orientation_is_swap(orientation)) {
-            rect.x = geometry->x + (geometry->w - geometry->h) / 2.f;
-            rect.y = geometry->y + (geometry->h - geometry->w) / 2.f;
-            rect.w = geometry->h;
-            rect.h = geometry->w;
-            dstrect = &rect;
-        } else {
-            dstrect = geometry;
-        }
-
-        SDL_FlipMode flip = sc_orientation_is_mirror(orientation)
-                              ? SDL_FLIP_HORIZONTAL : 0;
-
-        ok = SDL_RenderTextureRotated(renderer, texture, NULL, dstrect, angle,
-                                      NULL, flip);
-    }
-
-    if (!ok) {
-        LOGE("Could not render texture: %s", SDL_GetError());
-    }
-
-end:
-    sc_sdl_render_present(renderer);
+    enum sc_display_result res =
+        sc_display_render(&screen->display, &screen->rect, screen->orientation);
+    (void) res; // any error already logged
 }

-#if defined(__APPLE__) || defined(_WIN32)
+static void
+sc_screen_render_novideo(struct sc_screen *screen) {
+    enum sc_display_result res =
+        sc_display_render(&screen->display, NULL, SC_ORIENTATION_0);
+    (void) res; // any error already logged
+}
+
+#if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif

@@ -260,31 +235,28 @@ end:
 //
 // <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
 // <https://stackoverflow.com/a/40693139/1987178>
-static bool
+static int
 event_watcher(void *data, SDL_Event *event) {
    struct sc_screen *screen = data;
    assert(screen->video);

-    if (event->type == SDL_EVENT_WINDOW_RESIZED) {
+    if (event->type == SDL_WINDOWEVENT
+            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
        // In practice, it seems to always be called from the same thread in
        // that specific case. Anyway, it's just a workaround.
        sc_screen_render(screen, true);
    }
-
-    return true;
+    return 0;
 }
 #endif

 static bool
 sc_screen_frame_sink_open(struct sc_frame_sink *sink,
-                          const AVCodecContext *ctx,
-                          const struct sc_stream_session *session) {
+                          const AVCodecContext *ctx) {
    assert(ctx->pix_fmt == AV_PIX_FMT_YUV420P);
    (void) ctx;
-    (void) session;

    struct sc_screen *screen = DOWNCAST(sink);
-    (void) screen;

    if (ctx->width <= 0 || ctx->width > 0xFFFF
            || ctx->height <= 0 || ctx->height > 0xFFFF) {
@@ -292,6 +264,19 @@ sc_screen_frame_sink_open(struct sc_frame_sink *sink,
        return false;
    }

+    assert(ctx->width > 0 && ctx->width <= 0xFFFF);
+    assert(ctx->height > 0 && ctx->height <= 0xFFFF);
+    // screen->frame_size is never used before the event is pushed, and the
+    // event acts as a memory barrier so it is safe without mutex
+    screen->frame_size.width = ctx->width;
+    screen->frame_size.height = ctx->height;
+
+    // Post the event on the UI thread (the texture must be created from there)
+    bool ok = sc_push_event(SC_EVENT_SCREEN_INIT_SIZE);
+    if (!ok) {
+        return false;
+    }
+
 #ifndef NDEBUG
    screen->open = true;
 #endif
@@ -342,13 +327,14 @@ sc_screen_init(struct sc_screen *screen,
               const struct sc_screen_params *params) {
    screen->resize_pending = false;
    screen->has_frame = false;
-    screen->has_video_window = false;
+    screen->fullscreen = false;
+    screen->maximized = false;
+    screen->minimized = false;
    screen->paused = false;
    screen->resume_frame = NULL;
    screen->orientation = SC_ORIENTATION_0;

    screen->video = params->video;
-    screen->camera = params->camera;

    screen->req.x = params->window_x;
    screen->req.y = params->window_y;
@@ -374,8 +360,7 @@ sc_screen_init(struct sc_screen *screen,
        }
    }

-    // Always create the window hidden to prevent blinking during initialization
-    uint32_t window_flags = SDL_WINDOW_HIGH_PIXEL_DENSITY | SDL_WINDOW_HIDDEN;
+    uint32_t window_flags = SDL_WINDOW_ALLOW_HIGHDPI;
    if (params->always_on_top) {
        window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
    }
@@ -384,7 +369,8 @@ sc_screen_init(struct sc_screen *screen,
    }
    if (params->video) {
        // The window will be shown on first frame
-        window_flags |= SDL_WINDOW_RESIZABLE;
+        window_flags |= SDL_WINDOW_HIDDEN
+                      | SDL_WINDOW_RESIZABLE;
    }

    const char *title = params->window_title;
@@ -408,86 +394,39 @@ sc_screen_init(struct sc_screen *screen,
    }

    // The window will be positioned and sized on first video frame
-    screen->window =
-        sc_sdl_create_window(title, x, y, width, height, window_flags);
+    screen->window = SDL_CreateWindow(title, x, y, width, height, window_flags);
    if (!screen->window) {
        LOGE("Could not create window: %s", SDL_GetError());
        goto error_destroy_fps_counter;
    }

-    screen->renderer = SDL_CreateRenderer(screen->window, NULL);
-    if (!screen->renderer) {
-        LOGE("Could not create renderer: %s", SDL_GetError());
-        goto error_destroy_window;
-    }
-
-#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
-    screen->gl_context = NULL;
-
-    // starts with "opengl"
-    const char *renderer_name = SDL_GetRendererName(screen->renderer);
-    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (use_opengl) {
-        // Persuade macOS to give us something better than OpenGL 2.1.
-        // If we create a Core Profile context, we get the best OpenGL version.
-        bool ok = SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
-                                      SDL_GL_CONTEXT_PROFILE_CORE);
-        if (!ok) {
-            LOGW("Could not set a GL Core Profile Context");
-        }
-
-        LOGD("Creating OpenGL Core Profile context");
-        screen->gl_context = SDL_GL_CreateContext(screen->window);
-        if (!screen->gl_context) {
-            LOGE("Could not create OpenGL context: %s", SDL_GetError());
-            goto error_destroy_renderer;
-        }
-    }
-#endif
-
-    bool mipmaps = params->video;
-    ok = sc_texture_init(&screen->tex, screen->renderer, mipmaps);
-    if (!ok) {
-        goto error_destroy_renderer;
-    }
-
-    ok = SDL_StartTextInput(screen->window);
-    if (!ok) {
-        LOGE("Could not enable text input: %s", SDL_GetError());
-        goto error_destroy_texture;
-    }
-
    SDL_Surface *icon = scrcpy_icon_load();
    if (icon) {
-        if (!SDL_SetWindowIcon(screen->window, icon)) {
-            LOGW("Could not set window icon: %s", SDL_GetError());
-        }
-
-        if (!params->video) {
-            screen->content_size.width = icon->w;
-            screen->content_size.height = icon->h;
-            ok = sc_texture_set_from_surface(&screen->tex, icon);
-            if (!ok) {
-                LOGE("Could not set icon: %s", SDL_GetError());
-            }
-        }
-
-        scrcpy_icon_destroy(icon);
+        SDL_SetWindowIcon(screen->window, icon);
+    } else if (params->video) {
+        // just a warning
+        LOGW("Could not load icon");
    } else {
-        // not fatal
+        // without video, the icon is used as window content, it must be present
        LOGE("Could not load icon");
+        goto error_destroy_fps_counter;
+    }

-        if (!params->video) {
-            // Make sure the content size is initialized
-            screen->content_size.width = 256;
-            screen->content_size.height = 256;
-        }
+    SDL_Surface *icon_novideo = params->video ? NULL : icon;
+    bool mipmaps = params->video && params->mipmaps;
+    ok = sc_display_init(&screen->display, screen->window, icon_novideo,
+                         mipmaps);
+    if (icon) {
+        scrcpy_icon_destroy(icon);
+    }
+    if (!ok) {
+        goto error_destroy_window;
    }

    screen->frame = av_frame_alloc();
    if (!screen->frame) {
        LOG_OOM();
-        goto error_destroy_texture;
+        goto error_destroy_display;
    }

    struct sc_input_manager_params im_params = {
@@ -497,7 +436,6 @@ sc_screen_init(struct sc_screen *screen,
        .kp = params->kp,
        .mp = params->mp,
        .gp = params->gp,
-        .camera = params->camera,
        .mouse_bindings = params->mouse_bindings,
        .legacy_paste = params->legacy_paste,
        .clipboard_autosync = params->clipboard_autosync,
@@ -511,11 +449,7 @@ sc_screen_init(struct sc_screen *screen,

 #ifdef CONTINUOUS_RESIZING_WORKAROUND
    if (screen->video) {
-        ok = SDL_AddEventWatch(event_watcher, screen);
-        if (!ok) {
-            LOGW("Could not add event watcher for continuous resizing: %s",
-                 SDL_GetError());
-        }
+        SDL_AddEventWatch(event_watcher, screen);
    }
 #endif

@@ -531,27 +465,15 @@ sc_screen_init(struct sc_screen *screen,
    screen->open = false;
 #endif

-    if (!screen->video) {
-        // Show the window immediately
-        sc_sdl_show_window(screen->window);
-
-        if (sc_screen_is_relative_mode(screen)) {
-            // Capture mouse immediately if video mirroring is disabled
-            sc_mouse_capture_set_active(&screen->mc, true);
-        }
+    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);
    }

    return true;

-error_destroy_texture:
-    sc_texture_destroy(&screen->tex);
-error_destroy_renderer:
-#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
-    if (screen->gl_context) {
-        SDL_GL_DestroyContext(screen->gl_context);
-    }
-#endif
-    SDL_DestroyRenderer(screen->renderer);
+error_destroy_display:
+    sc_display_destroy(&screen->display);
 error_destroy_window:
    SDL_DestroyWindow(screen->window);
 error_destroy_fps_counter:
@@ -568,18 +490,13 @@ sc_screen_show_initial_window(struct sc_screen *screen) {
          ? screen->req.x : (int) SDL_WINDOWPOS_CENTERED;
    int y = screen->req.y != SC_WINDOW_POSITION_UNDEFINED
          ? screen->req.y : (int) SDL_WINDOWPOS_CENTERED;
-    struct sc_point position = {
-        .x = x,
-        .y = y,
-    };

    struct sc_size window_size =
        get_initial_optimal_size(screen->content_size, screen->req.width,
                                                       screen->req.height);

-    assert(is_windowed(screen));
-    sc_sdl_set_window_size(screen->window, window_size);
-    sc_sdl_set_window_position(screen->window, position);
+    set_window_size(screen, window_size);
+    SDL_SetWindowPosition(screen->window, x, y);

    if (screen->req.fullscreen) {
        sc_screen_toggle_fullscreen(screen);
@@ -589,13 +506,13 @@ sc_screen_show_initial_window(struct sc_screen *screen) {
        sc_fps_counter_start(&screen->fps_counter);
    }

-    sc_sdl_show_window(screen->window);
+    SDL_ShowWindow(screen->window);
    sc_screen_update_content_rect(screen);
 }

 void
 sc_screen_hide_window(struct sc_screen *screen) {
-    sc_sdl_hide_window(screen->window);
+    SDL_HideWindow(screen->window);
 }

 void
@@ -613,12 +530,8 @@ sc_screen_destroy(struct sc_screen *screen) {
 #ifndef NDEBUG
    assert(!screen->open);
 #endif
-    sc_texture_destroy(&screen->tex);
+    sc_display_destroy(&screen->display);
    av_frame_free(&screen->frame);
-#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
-    SDL_GL_DestroyContext(screen->gl_context);
-#endif
-    SDL_DestroyRenderer(screen->renderer);
    SDL_DestroyWindow(screen->window);
    sc_fps_counter_destroy(&screen->fps_counter);
    sc_frame_buffer_destroy(&screen->fb);
@@ -629,7 +542,7 @@ resize_for_content(struct sc_screen *screen, struct sc_size old_content_size,
                   struct sc_size new_content_size) {
    assert(screen->video);

-    struct sc_size window_size = sc_sdl_get_window_size(screen->window);
+    struct sc_size window_size = get_window_size(screen);
    struct sc_size target_size = {
        .width = (uint32_t) window_size.width * new_content_size.width
                / old_content_size.width,
@@ -637,15 +550,14 @@ resize_for_content(struct sc_screen *screen, struct sc_size old_content_size,
                / old_content_size.height,
    };
    target_size = get_optimal_size(target_size, new_content_size, true);
-    assert(is_windowed(screen));
-    sc_sdl_set_window_size(screen->window, target_size);
+    set_window_size(screen, target_size);
 }

 static void
 set_content_size(struct sc_screen *screen, struct sc_size new_content_size) {
    assert(screen->video);

-    if (is_windowed(screen)) {
+    if (!screen->fullscreen && !screen->maximized && !screen->minimized) {
        resize_for_content(screen, screen->content_size, new_content_size);
    } else if (!screen->resize_pending) {
        // Store the windowed size to be able to compute the optimal size once
@@ -661,7 +573,9 @@ static void
 apply_pending_resize(struct sc_screen *screen) {
    assert(screen->video);

-    assert(is_windowed(screen));
+    assert(!screen->fullscreen);
+    assert(!screen->maximized);
+    assert(!screen->minimized);
    if (screen->resize_pending) {
        resize_for_content(screen, screen->windowed_content_size,
                                   screen->content_size);
@@ -689,6 +603,44 @@ sc_screen_set_orientation(struct sc_screen *screen,
    sc_screen_render(screen, true);
 }

+static bool
+sc_screen_init_size(struct sc_screen *screen) {
+    // Before first frame
+    assert(!screen->has_frame);
+
+    // The requested size is passed via screen->frame_size
+
+    struct sc_size content_size =
+        get_oriented_size(screen->frame_size, screen->orientation);
+    screen->content_size = content_size;
+
+    enum sc_display_result res =
+        sc_display_set_texture_size(&screen->display, screen->frame_size);
+    return res != SC_DISPLAY_RESULT_ERROR;
+}
+
+// recreate the texture and resize the window if the frame size has changed
+static enum sc_display_result
+prepare_for_frame(struct sc_screen *screen, struct sc_size new_frame_size) {
+    assert(screen->video);
+
+    if (screen->frame_size.width == new_frame_size.width
+            && screen->frame_size.height == new_frame_size.height) {
+        return SC_DISPLAY_RESULT_OK;
+    }
+
+    // frame dimension changed
+    screen->frame_size = new_frame_size;
+
+    struct sc_size new_content_size =
+        get_oriented_size(new_frame_size, screen->orientation);
+    set_content_size(screen, new_content_size);
+
+    sc_screen_update_content_rect(screen);
+
+    return sc_display_set_texture_size(&screen->display, screen->frame_size);
+}
+
 static bool
 sc_screen_apply_frame(struct sc_screen *screen) {
    assert(screen->video);
@@ -697,34 +649,26 @@ sc_screen_apply_frame(struct sc_screen *screen) {

    AVFrame *frame = screen->frame;
    struct sc_size new_frame_size = {frame->width, frame->height};
-
-    if (!screen->has_frame
-            || screen->frame_size.width != new_frame_size.width
-            || screen->frame_size.height != new_frame_size.height) {
-
-        // frame dimension changed
-        screen->frame_size = new_frame_size;
-
-        struct sc_size new_content_size =
-            get_oriented_size(new_frame_size, screen->orientation);
-        if (screen->has_frame) {
-            set_content_size(screen, new_content_size);
-            sc_screen_update_content_rect(screen);
-        } else {
-            // This is the first frame
-            screen->has_frame = true;
-            screen->content_size = new_content_size;
-        }
-    }
-
-    bool ok = sc_texture_set_from_frame(&screen->tex, frame);
-    if (!ok) {
+    enum sc_display_result res = prepare_for_frame(screen, new_frame_size);
+    if (res == SC_DISPLAY_RESULT_ERROR) {
        return false;
    }
+    if (res == SC_DISPLAY_RESULT_PENDING) {
+        // Not an error, but do not continue
+        return true;
+    }

-    assert(screen->has_frame);
-    if (!screen->has_video_window) {
-        screen->has_video_window = true;
+    res = sc_display_update_texture(&screen->display, frame);
+    if (res == SC_DISPLAY_RESULT_ERROR) {
+        return false;
+    }
+    if (res == SC_DISPLAY_RESULT_PENDING) {
+        // Not an error, but do not continue
+        return true;
+    }
+
+    if (!screen->has_frame) {
+        screen->has_frame = true;
        // this is the very first frame, show the window
        sc_screen_show_initial_window(screen);

@@ -776,10 +720,7 @@ sc_screen_set_paused(struct sc_screen *screen, bool paused) {
        av_frame_free(&screen->frame);
        screen->frame = screen->resume_frame;
        screen->resume_frame = NULL;
-        bool ok = sc_screen_apply_frame(screen);
-        if (!ok) {
-            LOGE("Resume frame update failed");
-        }
+        sc_screen_apply_frame(screen);
    }

    if (!paused) {
@@ -797,28 +738,31 @@ void
 sc_screen_toggle_fullscreen(struct sc_screen *screen) {
    assert(screen->video);

-    bool req_fullscreen =
-        !(SDL_GetWindowFlags(screen->window) & SDL_WINDOW_FULLSCREEN);
-
-    bool ok = SDL_SetWindowFullscreen(screen->window, req_fullscreen);
-    if (!ok) {
+    uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
+    if (SDL_SetWindowFullscreen(screen->window, new_mode)) {
        LOGW("Could not switch fullscreen mode: %s", SDL_GetError());
        return;
    }

-    LOGD("Requested %s mode", req_fullscreen ? "fullscreen" : "windowed");
+    screen->fullscreen = !screen->fullscreen;
+    if (!screen->fullscreen && !screen->maximized && !screen->minimized) {
+        apply_pending_resize(screen);
+    }
+
+    LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
+    sc_screen_render(screen, true);
 }

 void
 sc_screen_resize_to_fit(struct sc_screen *screen) {
    assert(screen->video);

-    if (!is_windowed(screen)) {
+    if (screen->fullscreen || screen->maximized || screen->minimized) {
        return;
    }

-    struct sc_point point = sc_sdl_get_window_position(screen->window);
-    struct sc_size window_size = sc_sdl_get_window_size(screen->window);
+    struct sc_point point = get_window_position(screen);
+    struct sc_size window_size = get_window_size(screen);

    struct sc_size optimal_size =
        get_optimal_size(window_size, screen->content_size, false);
@@ -826,14 +770,11 @@ sc_screen_resize_to_fit(struct sc_screen *screen) {
    // Center the window related to the device screen
    assert(optimal_size.width <= window_size.width);
    assert(optimal_size.height <= window_size.height);
+    uint32_t new_x = point.x + (window_size.width - optimal_size.width) / 2;
+    uint32_t new_y = point.y + (window_size.height - optimal_size.height) / 2;

-    struct sc_point new_position = {
-        .x = point.x + (window_size.width - optimal_size.width) / 2,
-        .y = point.y + (window_size.height - optimal_size.height) / 2,
-    };
-
-    sc_sdl_set_window_size(screen->window, optimal_size);
-    sc_sdl_set_window_position(screen->window, new_position);
+    SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
+    SDL_SetWindowPosition(screen->window, new_x, new_y);
    LOGD("Resized to optimal size: %ux%u", optimal_size.width,
                                           optimal_size.height);
 }
@@ -842,65 +783,92 @@ void
 sc_screen_resize_to_pixel_perfect(struct sc_screen *screen) {
    assert(screen->video);

-    if (!is_windowed(screen)) {
+    if (screen->fullscreen || screen->minimized) {
        return;
    }

+    if (screen->maximized) {
+        SDL_RestoreWindow(screen->window);
+        screen->maximized = false;
+    }
+
    struct sc_size content_size = screen->content_size;
-    sc_sdl_set_window_size(screen->window, content_size);
+    SDL_SetWindowSize(screen->window, content_size.width, content_size.height);
    LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
                                            content_size.height);
 }

-void
+bool
 sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
-    // !video implies !has_video_window
-    assert(screen->video || !screen->has_video_window);
    switch (event->type) {
+        case SC_EVENT_SCREEN_INIT_SIZE: {
+            // The initial size is passed via screen->frame_size
+            bool ok = sc_screen_init_size(screen);
+            if (!ok) {
+                LOGE("Could not initialize screen size");
+                return false;
+            }
+            return true;
+        }
        case SC_EVENT_NEW_FRAME: {
            bool ok = sc_screen_update_frame(screen);
            if (!ok) {
                LOGE("Frame update failed\n");
+                return false;
            }
-            return;
+            return true;
        }
-        case SDL_EVENT_WINDOW_EXPOSED:
-            if (!screen->video || screen->has_video_window) {
-                sc_screen_render(screen, true);
+        case SDL_WINDOWEVENT:
+            if (!screen->video
+                    && event->window.event == SDL_WINDOWEVENT_EXPOSED) {
+                sc_screen_render_novideo(screen);
            }
-            return;
-        case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
-            if (screen->has_video_window) {
-                sc_screen_render(screen, true);
+
+            // !video implies !has_frame
+            assert(screen->video || !screen->has_frame);
+            if (!screen->has_frame) {
+                // Do nothing
+                return true;
            }
-            return;
-        case SDL_EVENT_WINDOW_RESTORED:
-            if (screen->has_video_window && is_windowed(screen)) {
-                apply_pending_resize(screen);
-                sc_screen_render(screen, true);
+            switch (event->window.event) {
+                case SDL_WINDOWEVENT_EXPOSED:
+                    sc_screen_render(screen, true);
+                    break;
+                case SDL_WINDOWEVENT_SIZE_CHANGED:
+                    sc_screen_render(screen, true);
+                    break;
+                case SDL_WINDOWEVENT_MAXIMIZED:
+                    screen->maximized = true;
+                    break;
+                case SDL_WINDOWEVENT_MINIMIZED:
+                    screen->minimized = true;
+                    break;
+                case SDL_WINDOWEVENT_RESTORED:
+                    if (screen->fullscreen) {
+                        // On Windows, in maximized+fullscreen, disabling
+                        // fullscreen mode unexpectedly triggers the "restored"
+                        // then "maximized" events, leaving the window in a
+                        // weird state (maximized according to the events, but
+                        // not maximized visually).
+                        break;
+                    }
+                    screen->maximized = false;
+                    screen->minimized = false;
+                    apply_pending_resize(screen);
+                    sc_screen_render(screen, true);
+                    break;
            }
-            return;
-        case SDL_EVENT_WINDOW_ENTER_FULLSCREEN:
-            LOGD("Switched to fullscreen mode");
-            assert(screen->has_video_window);
-            return;
-        case SDL_EVENT_WINDOW_LEAVE_FULLSCREEN:
-            LOGD("Switched to windowed mode");
-            assert(screen->has_video_window);
-            if (is_windowed(screen)) {
-                apply_pending_resize(screen);
-                sc_screen_render(screen, true);
-            }
-            return;
+            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;
+        return true;
    }

    sc_input_manager_handle_event(&screen->im, event);
+    return true;
 }

 struct sc_point
@@ -969,15 +937,9 @@ sc_screen_convert_window_to_frame_coords(struct sc_screen *screen,
 void
 sc_screen_hidpi_scale_coords(struct sc_screen *screen, int32_t *x, int32_t *y) {
    // take the HiDPI scaling (dw/ww and dh/wh) into account
-
-    struct sc_size window_size = sc_sdl_get_window_size(screen->window);
-    int64_t ww = window_size.width;
-    int64_t wh = window_size.height;
-
-    struct sc_size drawable_size =
-        sc_sdl_get_window_size_in_pixels(screen->window);
-    int64_t dw = drawable_size.width;
-    int64_t dh = drawable_size.height;
+    int ww, wh, dw, dh;
+    SDL_GetWindowSize(screen->window, &ww, &wh);
+    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);

    // scale for HiDPI (64 bits for intermediate multiplications)
    *x = (int64_t) *x * dw / ww;
--- a/app/src/screen.h
+++ b/app/src/screen.h
@@ -1,31 +1,25 @@
-#ifndef SC_SCREEN_H
-#define SC_SCREEN_H
+#ifndef SCREEN_H
+#define SCREEN_H

 #include "common.h"

 #include <stdbool.h>
-#include <stdint.h>
-#include <SDL3/SDL.h>
-#include <libavcodec/avcodec.h>
-#include <libavutil/frame.h>
-#include <libavutil/pixfmt.h>
+#include <SDL2/SDL.h>
+#include <libavformat/avformat.h>

 #include "controller.h"
 #include "coords.h"
+#include "display.h"
 #include "fps_counter.h"
 #include "frame_buffer.h"
 #include "input_manager.h"
 #include "mouse_capture.h"
+#include "opengl.h"
 #include "options.h"
-#include "texture.h"
 #include "trait/key_processor.h"
 #include "trait/frame_sink.h"
 #include "trait/mouse_processor.h"

-#ifdef __APPLE__
-# define SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
-#endif
-
 struct sc_screen {
    struct sc_frame_sink frame_sink; // frame sink trait

@@ -34,9 +28,8 @@ struct sc_screen {
 #endif

    bool video;
-    bool camera;

-    struct sc_texture tex;
+    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;
@@ -53,11 +46,6 @@ struct sc_screen {
    } req;

    SDL_Window *window;
-    SDL_Renderer *renderer;
-#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
-    SDL_GLContext gl_context;
-#endif
-
    struct sc_size frame_size;
    struct sc_size content_size; // rotated frame_size

@@ -69,9 +57,11 @@ struct sc_screen {
    // client orientation
    enum sc_orientation orientation;
    // rectangle of the content (excluding black borders)
-    struct SDL_FRect rect;
+    struct SDL_Rect rect;
    bool has_frame;
-    bool has_video_window;
+    bool fullscreen;
+    bool maximized;
+    bool minimized;

    AVFrame *frame;

@@ -81,7 +71,6 @@ struct sc_screen {

 struct sc_screen_params {
    bool video;
-    bool camera;

    struct sc_controller *controller;
    struct sc_file_pusher *fp;
@@ -157,7 +146,8 @@ void
 sc_screen_set_paused(struct sc_screen *screen, bool paused);

 // react to SDL events
-void
+// If this function returns false, scrcpy must exit with an error.
+bool
 sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event);

 // convert point from window coordinates to frame coordinates
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -1,18 +1,19 @@
 #include "server.h"

 #include <assert.h>
+#include <errno.h>
 #include <inttypes.h>
 #include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
+#include <SDL2/SDL_timer.h>
+#include <SDL2/SDL_platform.h>

 #include "adb/adb.h"
+#include "util/binary.h"
 #include "util/env.h"
 #include "util/file.h"
 #include "util/log.h"
 #include "util/net_intr.h"
-#include "util/process.h"
+#include "util/process_intr.h"
 #include "util/str.h"

 #define SC_SERVER_FILENAME "scrcpy-server"
@@ -149,43 +150,12 @@ sc_server_get_audio_source_name(enum sc_audio_source audio_source) {
            return "mic";
        case SC_AUDIO_SOURCE_PLAYBACK:
            return "playback";
-        case SC_AUDIO_SOURCE_MIC_UNPROCESSED:
-            return "mic-unprocessed";
-        case SC_AUDIO_SOURCE_MIC_CAMCORDER:
-            return "mic-camcorder";
-        case SC_AUDIO_SOURCE_MIC_VOICE_RECOGNITION:
-            return "mic-voice-recognition";
-        case SC_AUDIO_SOURCE_MIC_VOICE_COMMUNICATION:
-            return "mic-voice-communication";
-        case SC_AUDIO_SOURCE_VOICE_CALL:
-            return "voice-call";
-        case SC_AUDIO_SOURCE_VOICE_CALL_UPLINK:
-            return "voice-call-uplink";
-        case SC_AUDIO_SOURCE_VOICE_CALL_DOWNLINK:
-            return "voice-call-downlink";
-        case SC_AUDIO_SOURCE_VOICE_PERFORMANCE:
-            return "voice-performance";
        default:
            assert(!"unexpected audio source");
            return NULL;
    }
 }

-static const char *
-sc_server_get_display_ime_policy_name(enum sc_display_ime_policy policy) {
-    switch (policy) {
-        case SC_DISPLAY_IME_POLICY_LOCAL:
-            return "local";
-        case SC_DISPLAY_IME_POLICY_FALLBACK:
-            return "fallback";
-        case SC_DISPLAY_IME_POLICY_HIDE:
-            return "hide";
-        default:
-            assert(!"unexpected display IME policy");
-            return NULL;
-    }
-}
-
 static bool
 validate_string(const char *s) {
    // The parameters values are passed as command line arguments to adb, so
@@ -357,13 +327,6 @@ execute_server(struct sc_server *server,
    if (params->camera_high_speed) {
        ADD_PARAM("camera_high_speed=true");
    }
-    if (params->camera_torch) {
-        ADD_PARAM("camera_torch=true");
-    }
-    if (params->camera_zoom) {
-        VALIDATE_STRING(params->camera_zoom);
-        ADD_PARAM("camera_zoom=%s", params->camera_zoom);
-    }
    if (params->show_touches) {
        ADD_PARAM("show_touches=true");
    }
@@ -414,10 +377,6 @@ execute_server(struct sc_server *server,
        VALIDATE_STRING(params->new_display);
        ADD_PARAM("new_display=%s", params->new_display);
    }
-    if (params->display_ime_policy != SC_DISPLAY_IME_POLICY_UNDEFINED) {
-        ADD_PARAM("display_ime_policy=%s",
-            sc_server_get_display_ime_policy_name(params->display_ime_policy));
-    }
    if (!params->vd_destroy_content) {
        ADD_PARAM("vd_destroy_content=false");
    }
--- a/app/src/server.h
+++ b/app/src/server.h
@@ -1,17 +1,19 @@
-#ifndef SC_SERVER_H
-#define SC_SERVER_H
+#ifndef SERVER_H
+#define SERVER_H

 #include "common.h"

+#include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>

 #include "adb/adb_tunnel.h"
+#include "coords.h"
 #include "options.h"
 #include "util/intr.h"
+#include "util/log.h"
 #include "util/net.h"
 #include "util/thread.h"
-#include "util/tick.h"

 #define SC_DEVICE_NAME_FIELD_LENGTH 64
 struct sc_server_info {
@@ -35,7 +37,6 @@ struct sc_server_params {
    const char *camera_id;
    const char *camera_size;
    const char *camera_ar;
-    const char *camera_zoom;
    uint16_t camera_fps;
    struct sc_port_range port_range;
    uint32_t tunnel_host;
@@ -51,7 +52,6 @@ struct sc_server_params {
    bool control;
    uint32_t display_id;
    const char *new_display;
-    enum sc_display_ime_policy display_ime_policy;
    bool video;
    bool audio;
    bool audio_dup;
@@ -69,7 +69,6 @@ struct sc_server_params {
    bool power_on;
    bool kill_adb_on_close;
    bool camera_high_speed;
-    bool camera_torch;
    bool vd_destroy_content;
    bool vd_system_decorations;
    uint8_t list;
--- a/app/src/shortcut_mod.h
+++ b/app/src/shortcut_mod.h
@@ -3,14 +3,13 @@

 #include "common.h"

-#include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL3/SDL_keycode.h>
+#include <SDL2/SDL_keycode.h>

 #include "options.h"

-#define SC_SDL_SHORTCUT_MODS_MASK (SDL_KMOD_CTRL | SDL_KMOD_ALT | SDL_KMOD_GUI)
+#define SC_SDL_SHORTCUT_MODS_MASK (KMOD_CTRL | KMOD_ALT | KMOD_GUI)

 // input: OR of enum sc_shortcut_mod
 // output: OR of SDL_Keymod
@@ -18,22 +17,22 @@ 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 |= SDL_KMOD_LCTRL;
+        sdl_mod |= KMOD_LCTRL;
    }
    if (shortcut_mods & SC_SHORTCUT_MOD_RCTRL) {
-        sdl_mod |= SDL_KMOD_RCTRL;
+        sdl_mod |= KMOD_RCTRL;
    }
    if (shortcut_mods & SC_SHORTCUT_MOD_LALT) {
-        sdl_mod |= SDL_KMOD_LALT;
+        sdl_mod |= KMOD_LALT;
    }
    if (shortcut_mods & SC_SHORTCUT_MOD_RALT) {
-        sdl_mod |= SDL_KMOD_RALT;
+        sdl_mod |= KMOD_RALT;
    }
    if (shortcut_mods & SC_SHORTCUT_MOD_LSUPER) {
-        sdl_mod |= SDL_KMOD_LGUI;
+        sdl_mod |= KMOD_LGUI;
    }
    if (shortcut_mods & SC_SHORTCUT_MOD_RSUPER) {
-        sdl_mod |= SDL_KMOD_RGUI;
+        sdl_mod |= KMOD_RGUI;
    }
    return sdl_mod;
 }
@@ -50,12 +49,12 @@ sc_shortcut_mods_is_shortcut_mod(uint16_t sdl_shortcut_mods, uint16_t sdl_mod) {
 static inline bool
 sc_shortcut_mods_is_shortcut_key(uint16_t sdl_shortcut_mods,
                                 SDL_Keycode keycode) {
-    return (sdl_shortcut_mods & SDL_KMOD_LCTRL && keycode == SDLK_LCTRL)
-        || (sdl_shortcut_mods & SDL_KMOD_RCTRL && keycode == SDLK_RCTRL)
-        || (sdl_shortcut_mods & SDL_KMOD_LALT  && keycode == SDLK_LALT)
-        || (sdl_shortcut_mods & SDL_KMOD_RALT  && keycode == SDLK_RALT)
-        || (sdl_shortcut_mods & SDL_KMOD_LGUI  && keycode == SDLK_LGUI)
-        || (sdl_shortcut_mods & SDL_KMOD_RGUI  && keycode == SDLK_RGUI);
+    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
--- a/app/src/sys/unix/file.c
+++ b/app/src/sys/unix/file.c
@@ -1,11 +1,10 @@
 #include "util/file.h"

 #include <limits.h>
-#include <stdio.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
-#include <sys/types.h>
 #include <unistd.h>
 #ifdef __APPLE__
 # include <mach-o/dyld.h> // for _NSGetExecutablePath()
--- a/app/src/sys/unix/process.c
+++ b/app/src/sys/unix/process.c
@@ -4,8 +4,6 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
--- a/app/src/sys/win/process.c
+++ b/app/src/sys/win/process.c
@@ -3,14 +3,26 @@
 #include <processthreadsapi.h>

 #include <assert.h>
-#include <stdlib.h>

-#include "util/command.h"
 #include "util/log.h"
 #include "util/str.h"

 #define CMD_MAX_LEN 8192

+static bool
+build_cmd(char *cmd, size_t len, const char *const argv[]) {
+    // Windows command-line parsing is WTF:
+    // <http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS>
+    // only make it work for this very specific program
+    // (don't handle escaping nor quotes)
+    size_t ret = sc_str_join(cmd, argv, ' ', len);
+    if (ret >= len) {
+        LOGE("Command too long (%" SC_PRIsizet " chars)", len - 1);
+        return false;
+    }
+    return true;
+}
+
 enum sc_process_result
 sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned flags,
                     HANDLE *pin, HANDLE *pout, HANDLE *perr) {
@@ -125,9 +137,8 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned flags,
        si.lpAttributeList = lpAttributeList;
    }

-    assert(argv && *argv);
-    char *cmd = sc_command_serialize_windows(argv);
-    if (!cmd) {
+    char *cmd = malloc(CMD_MAX_LEN);
+    if (!cmd || !build_cmd(cmd, CMD_MAX_LEN, argv)) {
        LOG_OOM();
        goto error_free_attribute_list;
    }
--- a/app/src/texture.c
+++ b/app/src/texture.c
@@ -1,227 +0,0 @@
-#include "texture.h"
-
-#include <assert.h>
-#include <inttypes.h>
-#include <string.h>
-#include <libavutil/pixfmt.h>
-
-#include "util/log.h"
-
-bool
-sc_texture_init(struct sc_texture *tex, SDL_Renderer *renderer, bool mipmaps) {
-    const char *renderer_name = SDL_GetRendererName(renderer);
-    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
-
-    tex->mipmaps = false;
-
-    // starts with "opengl"
-    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (use_opengl) {
-        struct sc_opengl *gl = &tex->gl;
-        sc_opengl_init(gl);
-
-        LOGI("OpenGL version: %s", gl->version);
-
-        if (mipmaps) {
-            bool supports_mipmaps =
-                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
-                                               2, 0  /* OpenGL ES 2.0+ */);
-            if (supports_mipmaps) {
-                LOGI("Trilinear filtering enabled");
-                tex->mipmaps = true;
-            } else {
-                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required)");
-            }
-        } else {
-            LOGI("Trilinear filtering disabled");
-        }
-    } else if (mipmaps) {
-        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
-    }
-
-    tex->renderer = renderer;
-    tex->texture = NULL;
-    return true;
-}
-
-void
-sc_texture_destroy(struct sc_texture *tex) {
-    if (tex->texture) {
-        SDL_DestroyTexture(tex->texture);
-    }
-}
-
-static enum SDL_Colorspace
-sc_texture_to_sdl_color_space(enum AVColorSpace color_space,
-                              enum AVColorRange color_range) {
-    bool full_range = color_range == AVCOL_RANGE_JPEG;
-
-    switch (color_space) {
-        case AVCOL_SPC_BT709:
-        case AVCOL_SPC_RGB:
-            return full_range ? SDL_COLORSPACE_BT709_FULL
-                              : SDL_COLORSPACE_BT709_LIMITED;
-        case AVCOL_SPC_BT470BG:
-        case AVCOL_SPC_SMPTE170M:
-            return full_range ? SDL_COLORSPACE_BT601_FULL
-                              : SDL_COLORSPACE_BT601_LIMITED;
-        case AVCOL_SPC_BT2020_NCL:
-        case AVCOL_SPC_BT2020_CL:
-            return full_range ? SDL_COLORSPACE_BT2020_FULL
-                              : SDL_COLORSPACE_BT2020_LIMITED;
-        default:
-            return SDL_COLORSPACE_JPEG;
-    }
-}
-
-static SDL_Texture *
-sc_texture_create_frame_texture(struct sc_texture *tex,
-                                struct sc_size size,
-                                enum AVColorSpace color_space,
-                                enum AVColorRange color_range) {
-    SDL_PropertiesID props = SDL_CreateProperties();
-    if (!props) {
-        return NULL;
-    }
-
-    enum SDL_Colorspace sdl_color_space =
-        sc_texture_to_sdl_color_space(color_space, color_range);
-
-    bool ok =
-        SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER,
-                              SDL_PIXELFORMAT_YV12);
-    ok &= SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER,
-                                SDL_TEXTUREACCESS_STREAMING);
-    ok &= SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER,
-                                size.width);
-    ok &= SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER,
-                                size.height);
-    ok &= SDL_SetNumberProperty(props,
-                                SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER,
-                                sdl_color_space);
-
-    if (!ok) {
-        LOGE("Could not set texture properties");
-        SDL_DestroyProperties(props);
-        return NULL;
-    }
-
-    SDL_Renderer *renderer = tex->renderer;
-    SDL_Texture *texture = SDL_CreateTextureWithProperties(renderer, props);
-    SDL_DestroyProperties(props);
-    if (!texture) {
-        LOGD("Could not create texture: %s", SDL_GetError());
-        return NULL;
-    }
-
-    if (tex->mipmaps) {
-        struct sc_opengl *gl = &tex->gl;
-
-        SDL_PropertiesID props = SDL_GetTextureProperties(texture);
-        if (!props) {
-            LOGE("Could not get texture properties: %s", SDL_GetError());
-            SDL_DestroyTexture(texture);
-            return NULL;
-        }
-
-        const char *renderer_name = SDL_GetRendererName(tex->renderer);
-        const char *key = !renderer_name || !strcmp(renderer_name, "opengl")
-                        ? SDL_PROP_TEXTURE_OPENGL_TEXTURE_NUMBER
-                        : SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_NUMBER;
-
-        int64_t texture_id = SDL_GetNumberProperty(props, key, 0);
-        SDL_DestroyProperties(props);
-        if (!texture_id) {
-            LOGE("Could not get texture id: %s", SDL_GetError());
-            SDL_DestroyTexture(texture);
-            return NULL;
-        }
-
-        assert(!(texture_id & ~0xFFFFFFFF)); // fits in uint32_t
-        tex->texture_id = texture_id;
-        gl->BindTexture(GL_TEXTURE_2D, tex->texture_id);
-
-        // Enable trilinear filtering for downscaling
-        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
-
-        gl->BindTexture(GL_TEXTURE_2D, 0);
-    }
-
-    return texture;
-}
-
-bool
-sc_texture_set_from_frame(struct sc_texture *tex, const AVFrame *frame) {
-
-    struct sc_size size = {frame->width, frame->height};
-    assert(size.width && size.height);
-
-    if (!tex->texture
-            || tex->texture_type != SC_TEXTURE_TYPE_FRAME
-            || tex->texture_size.width != size.width
-            || tex->texture_size.height != size.height) {
-        // Incompatible texture, recreate it
-        enum AVColorSpace color_space = frame->colorspace;
-        enum AVColorRange color_range = frame->color_range;
-
-        if (tex->texture) {
-            SDL_DestroyTexture(tex->texture);
-        }
-
-        tex->texture = sc_texture_create_frame_texture(tex, size, color_space,
-                                                       color_range);
-        if (!tex->texture) {
-            return false;
-        }
-
-        tex->texture_size = size;
-        tex->texture_type = SC_TEXTURE_TYPE_FRAME;
-
-        LOGI("Texture: %" PRIu16 "x%" PRIu16, size.width, size.height);
-    }
-
-    assert(tex->texture);
-    assert(tex->texture_type == SC_TEXTURE_TYPE_FRAME);
-
-    bool ok = SDL_UpdateYUVTexture(tex->texture, NULL,
-                                   frame->data[0], frame->linesize[0],
-                                   frame->data[1], frame->linesize[1],
-                                   frame->data[2], frame->linesize[2]);
-    if (!ok) {
-        LOGD("Could not update texture: %s", SDL_GetError());
-        return false;
-    }
-
-    if (tex->mipmaps) {
-        assert(tex->texture_id);
-        struct sc_opengl *gl = &tex->gl;
-
-        gl->BindTexture(GL_TEXTURE_2D, tex->texture_id);
-        gl->GenerateMipmap(GL_TEXTURE_2D);
-        gl->BindTexture(GL_TEXTURE_2D, 0);
-    }
-
-    return true;
-}
-
-bool
-sc_texture_set_from_surface(struct sc_texture *tex, SDL_Surface *surface) {
-    if (tex->texture) {
-        SDL_DestroyTexture(tex->texture);
-    }
-
-    tex->texture = SDL_CreateTextureFromSurface(tex->renderer, surface);
-    if (!tex->texture) {
-        LOGE("Could not create texture: %s", SDL_GetError());
-        return false;
-    }
-
-    tex->texture_size.width = surface->w;
-    tex->texture_size.height = surface->h;
-    tex->texture_type = SC_TEXTURE_TYPE_ICON;
-
-    return true;
-}
--- a/app/src/texture.h
+++ b/app/src/texture.h
@@ -1,44 +0,0 @@
-#ifndef SC_DISPLAY_H
-#define SC_DISPLAY_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <libavutil/frame.h>
-#include <SDL3/SDL.h>
-
-#include "coords.h"
-#include "opengl.h"
-
-enum sc_texture_type {
-    SC_TEXTURE_TYPE_FRAME,
-    SC_TEXTURE_TYPE_ICON,
-};
-
-struct sc_texture {
-    SDL_Renderer *renderer; // owned by the caller
-    SDL_Texture *texture;
-    // Only valid if texture != NULL
-    struct sc_size texture_size;
-    enum sc_texture_type texture_type;
-
-    struct sc_opengl gl;
-
-    bool mipmaps;
-    uint32_t texture_id; // only set if mipmaps is enabled
-};
-
-bool
-sc_texture_init(struct sc_texture *tex, SDL_Renderer *renderer, bool mipmaps);
-
-void
-sc_texture_destroy(struct sc_texture *tex);
-
-bool
-sc_texture_set_from_frame(struct sc_texture *tex, const AVFrame *frame);
-
-bool
-sc_texture_set_from_surface(struct sc_texture *tex, SDL_Surface *surface);
-
-#endif
--- a/app/src/trait/frame_sink.h
+++ b/app/src/trait/frame_sink.h
@@ -3,11 +3,10 @@

 #include "common.h"

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

-#include "trait/packet_sink.h"
-
 /**
 * Frame sink trait.
 *
@@ -19,16 +18,9 @@ struct sc_frame_sink {

 struct sc_frame_sink_ops {
    /* The codec context is valid until the sink is closed */
-    bool (*open)(struct sc_frame_sink *sink, const AVCodecContext *ctx,
-                 const struct sc_stream_session *session);
+    bool (*open)(struct sc_frame_sink *sink, const AVCodecContext *ctx);
    void (*close)(struct sc_frame_sink *sink);
    bool (*push)(struct sc_frame_sink *sink, const AVFrame *frame);
-
-    /**
-     * Optional callback to be notified of a new stream session.
-     */
-    bool (*push_session)(struct sc_frame_sink *sink,
-                         const struct sc_stream_session *session);
 };

 #endif
--- a/app/src/trait/frame_source.c
+++ b/app/src/trait/frame_source.c
@@ -1,7 +1,5 @@
 #include "frame_source.h"

-#include <assert.h>
-
 void
 sc_frame_source_init(struct sc_frame_source *source) {
    source->sink_count = 0;
@@ -27,12 +25,11 @@ sc_frame_source_sinks_close_firsts(struct sc_frame_source *source,

 bool
 sc_frame_source_sinks_open(struct sc_frame_source *source,
-                           const AVCodecContext *ctx,
-                           const struct sc_stream_session *session) {
+                           const AVCodecContext *ctx) {
    assert(source->sink_count);
    for (unsigned i = 0; i < source->sink_count; ++i) {
        struct sc_frame_sink *sink = source->sinks[i];
-        if (!sink->ops->open(sink, ctx, session)) {
+        if (!sink->ops->open(sink, ctx)) {
            sc_frame_source_sinks_close_firsts(source, i);
            return false;
        }
@@ -60,18 +57,3 @@ sc_frame_source_sinks_push(struct sc_frame_source *source,

    return true;
 }
-
-bool
-sc_frame_source_sinks_push_session(struct sc_frame_source *source,
-                                   const struct sc_stream_session *session) {
-    assert(source->sink_count);
-    for (unsigned i = 0; i < source->sink_count; ++i) {
-        struct sc_frame_sink *sink = source->sinks[i];
-        if (sink->ops->push_session &&
-                !sink->ops->push_session(sink, session)) {
-            return false;
-        }
-    }
-
-    return true;
-}
--- a/app/src/trait/frame_source.h
+++ b/app/src/trait/frame_source.h
@@ -3,9 +3,7 @@

 #include "common.h"

-#include <stdbool.h>
-
-#include "trait/frame_sink.h"
+#include "frame_sink.h"

 #define SC_FRAME_SOURCE_MAX_SINKS 2

@@ -28,8 +26,7 @@ sc_frame_source_add_sink(struct sc_frame_source *source,

 bool
 sc_frame_source_sinks_open(struct sc_frame_source *source,
-                           const AVCodecContext *ctx,
-                           const struct sc_stream_session *session);
+                           const AVCodecContext *ctx);

 void
 sc_frame_source_sinks_close(struct sc_frame_source *source);
@@ -38,8 +35,4 @@ bool
 sc_frame_source_sinks_push(struct sc_frame_source *source,
                           const AVFrame *frame);

-bool
-sc_frame_source_sinks_push_session(struct sc_frame_source *source,
-                                   const struct sc_stream_session *session);
-
 #endif
--- a/app/src/trait/gamepad_processor.h
+++ b/app/src/trait/gamepad_processor.h
@@ -3,6 +3,9 @@

 #include "common.h"

+#include <assert.h>
+#include <stdbool.h>
+
 #include "input_events.h"

 /**
--- a/app/src/trait/key_processor.h
+++ b/app/src/trait/key_processor.h
@@ -3,6 +3,7 @@

 #include "common.h"

+#include <assert.h>
 #include <stdbool.h>

 #include "input_events.h"
--- a/app/src/trait/mouse_processor.h
+++ b/app/src/trait/mouse_processor.h
@@ -3,6 +3,7 @@

 #include "common.h"

+#include <assert.h>
 #include <stdbool.h>

 #include "input_events.h"
--- a/app/src/trait/packet_sink.h
+++ b/app/src/trait/packet_sink.h
@@ -3,6 +3,7 @@

 #include "common.h"

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

@@ -15,28 +16,12 @@ struct sc_packet_sink {
    const struct sc_packet_sink_ops *ops;
 };

-struct sc_stream_session_video {
-    uint32_t width;
-    uint32_t height;
-};
-
-struct sc_stream_session {
-    struct sc_stream_session_video video;
-};
-
 struct sc_packet_sink_ops {
    /* The codec context is valid until the sink is closed */
-    bool (*open)(struct sc_packet_sink *sink, AVCodecContext *ctx,
-                 const struct sc_stream_session *session);
+    bool (*open)(struct sc_packet_sink *sink, AVCodecContext *ctx);
    void (*close)(struct sc_packet_sink *sink);
    bool (*push)(struct sc_packet_sink *sink, const AVPacket *packet);

-    /**
-     * Optional callback to be notified of a new stream session.
-     */
-    bool (*push_session)(struct sc_packet_sink *sink,
-                         const struct sc_stream_session *session);
-
    /*/
     * Called when the input stream has been disabled at runtime.
     *
--- a/app/src/trait/packet_source.c
+++ b/app/src/trait/packet_source.c
@@ -1,7 +1,5 @@
 #include "packet_source.h"

-#include <assert.h>
-
 void
 sc_packet_source_init(struct sc_packet_source *source) {
    source->sink_count = 0;
@@ -27,12 +25,11 @@ sc_packet_source_sinks_close_firsts(struct sc_packet_source *source,

 bool
 sc_packet_source_sinks_open(struct sc_packet_source *source,
-                            AVCodecContext *ctx,
-                            const struct sc_stream_session *session) {
+                            AVCodecContext *ctx) {
    assert(source->sink_count);
    for (unsigned i = 0; i < source->sink_count; ++i) {
        struct sc_packet_sink *sink = source->sinks[i];
-        if (!sink->ops->open(sink, ctx, session)) {
+        if (!sink->ops->open(sink, ctx)) {
            sc_packet_source_sinks_close_firsts(source, i);
            return false;
        }
@@ -61,21 +58,6 @@ sc_packet_source_sinks_push(struct sc_packet_source *source,
    return true;
 }

-bool
-sc_packet_source_sinks_push_session(struct sc_packet_source *source,
-                                    const struct sc_stream_session *session) {
-    assert(source->sink_count);
-    for (unsigned i = 0; i < source->sink_count; ++i) {
-        struct sc_packet_sink *sink = source->sinks[i];
-        if (sink->ops->push_session
-                && !sink->ops->push_session(sink, session)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
 void
 sc_packet_source_sinks_disable(struct sc_packet_source *source) {
    assert(source->sink_count);
--- a/app/src/trait/packet_source.h
+++ b/app/src/trait/packet_source.h
@@ -3,9 +3,7 @@

 #include "common.h"

-#include <stdbool.h>
-
-#include "trait/packet_sink.h"
+#include "packet_sink.h"

 #define SC_PACKET_SOURCE_MAX_SINKS 2

@@ -28,8 +26,7 @@ sc_packet_source_add_sink(struct sc_packet_source *source,

 bool
 sc_packet_source_sinks_open(struct sc_packet_source *source,
-                            AVCodecContext *ctx,
-                            const struct sc_stream_session *session);
+                            AVCodecContext *ctx);

 void
 sc_packet_source_sinks_close(struct sc_packet_source *source);
@@ -38,10 +35,6 @@ bool
 sc_packet_source_sinks_push(struct sc_packet_source *source,
                            const AVPacket *packet);

-bool
-sc_packet_source_sinks_push_session(struct sc_packet_source *source,
-                                    const struct sc_stream_session *session);
-
 void
 sc_packet_source_sinks_disable(struct sc_packet_source *source);

--- a/app/src/uhid/gamepad_uhid.c
+++ b/app/src/uhid/gamepad_uhid.c
@@ -1,10 +1,5 @@
 #include "gamepad_uhid.h"

-#include <assert.h>
-#include <inttypes.h>
-#include <string.h>
-#include <SDL3/SDL_gamepad.h>
-
 #include "hid/hid_gamepad.h"
 #include "input_events.h"
 #include "util/log.h"
@@ -74,9 +69,10 @@ sc_gamepad_processor_process_gamepad_added(struct sc_gamepad_processor *gp,
        return;
    }

-    SDL_Gamepad *sdl_gamepad = SDL_GetGamepadFromID(event->gamepad_id);
-    assert(sdl_gamepad);
-    const char *name = SDL_GetGamepadName(sdl_gamepad);
+    SDL_GameController* game_controller =
+        SDL_GameControllerFromInstanceID(event->gamepad_id);
+    assert(game_controller);
+    const char *name = SDL_GameControllerName(game_controller);
    LOGI("Gamepad added: [%" PRIu32 "] %s", event->gamepad_id, name);

    sc_gamepad_uhid_send_open(gamepad, &hid_open);
--- a/Show More
+++ b/Show More