Retry on recoverable MediaCodec errors

Refs <https://developer.android.com/reference/android/media/MediaCodec#error-handling>
Fixes #3693 <https://github.com/Genymobile/scrcpy/issues/3693>

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-github: [rom1v]
-liberapay: rom1v
-custom: ["https://paypal.me/rom2v"]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,25 +7,17 @@ assignees: ''
 
 ---
 
-_Please read the [prerequisites] to run scrcpy._
+ - [ ] I have read the [FAQ](https://github.com/Genymobile/scrcpy/blob/master/FAQ.md).
+ - [ ] I have searched in existing [issues](https://github.com/Genymobile/scrcpy/issues).
 
-[prerequisites]: https://github.com/Genymobile/scrcpy#prerequisites
-
-_Also read the [FAQ] and check if your [issue][issues] already exists._
-
-[FAQ]: https://github.com/Genymobile/scrcpy/blob/master/FAQ.md
-[issues]: https://github.com/Genymobile/scrcpy/issues
-
-## Environment
-
- - **OS:** [e.g. Debian, Windows, macOS...]
- - **Scrcpy version:** [e.g. 2.5]
- - **Installation method:** [e.g. manual build, apt, snap, brew, Windows release...]
- - **Device model:**
- - **Android version:** [e.g. 14]
-
-## Describe the bug
+**Environment**
+ - OS: [e.g. Debian, Windows, macOS...]
+ - scrcpy version: [e.g. 1.12.1]
+ - installation method: [e.g. manual build, apt, snap, brew, Windows release...]
+ - device model:
+ - Android version: [e.g. 10]
 
+**Describe the bug**
 A clear and concise description of what the bug is.
 
 On errors, please provide the output of the console (and `adb logcat` if relevant).

.github/ISSUE_TEMPLATE/question.md

@@ -1,8 +0,0 @@
----
-name: Question
-about: Ask a question about scrcpy
-title: ''
-labels: ''
-assignees: ''
-
----

.github/workflows/release.yml

@@ -1,502 +0,0 @@
-name: Build
-
-on:
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'Version name (default is ref name)'
-
-env:
-  # $VERSION is used by release scripts
-  VERSION: ${{ github.event.inputs.name || github.ref_name }}
-
-jobs:
-  test-scrcpy-server:
-    runs-on: ubuntu-latest
-    env:
-      GRADLE: gradle  # use native gradle instead of ./gradlew in scripts
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup JDK
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'zulu'
-          java-version: '17'
-
-      - name: Test scrcpy-server
-        run: release/test_server.sh
-
-  build-scrcpy-server:
-    runs-on: ubuntu-latest
-    env:
-      GRADLE: gradle  # use native gradle instead of ./gradlew in scripts
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup JDK
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'zulu'
-          java-version: '17'
-
-      - name: Build
-        run: release/build_server.sh
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: scrcpy-server
-          path: release/work/build-server/server/scrcpy-server
-
-  test-build-scrcpy-server-without-gradle:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup JDK
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'zulu'
-          java-version: '17'
-
-      - name: Build without gradle
-        run: server/build_without_gradle.sh
-
-  test-client:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          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: release/test_client.sh
-
-  build-linux-x86_64:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check architecture
-        run: |
-            arch=$(uname -m)
-            if [[ "$arch" != x86_64 ]]
-            then
-                echo "Unexpected architecture: $arch" >&2
-                exit 1
-            fi
-
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          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
-
-      # upload-artifact does not preserve permissions
-      - name: Tar
-        run: |
-            cd release/work/build-linux-x86_64
-            mkdir dist-tar
-            cd dist-tar
-            tar -C .. -cvf dist.tar.gz dist/
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: build-linux-x86_64-intermediate
-          path: release/work/build-linux-x86_64/dist-tar/
-
-  build-win32:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          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
-
-      # upload-artifact does not preserve permissions
-      - name: Tar
-        run: |
-            cd release/work/build-win32
-            mkdir dist-tar
-            cd dist-tar
-            tar -C .. -cvf dist.tar.gz dist/
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: build-win32-intermediate
-          path: release/work/build-win32/dist-tar/
-
-  build-win64:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          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
-
-      # upload-artifact does not preserve permissions
-      - name: Tar
-        run: |
-            cd release/work/build-win64
-            mkdir dist-tar
-            cd dist-tar
-            tar -C .. -cvf dist.tar.gz dist/
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: build-win64-intermediate
-          path: release/work/build-win64/dist-tar/
-
-  build-macos-aarch64:
-    runs-on: macos-latest
-    steps:
-      - name: Check architecture
-        run: |
-            arch=$(uname -m)
-            if [[ "$arch" != arm64 ]]
-            then
-                echo "Unexpected architecture: $arch" >&2
-                exit 1
-            fi
-
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-            brew install meson ninja nasm libiconv zlib automake autoconf \
-                libtool
-
-      - name: Build
-        run: release/build_macos.sh aarch64
-
-      # upload-artifact does not preserve permissions
-      - name: Tar
-        run: |
-            cd release/work/build-macos-aarch64
-            mkdir dist-tar
-            cd dist-tar
-            tar -C .. -cvf dist.tar.gz dist/
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: build-macos-aarch64-intermediate
-          path: release/work/build-macos-aarch64/dist-tar/
-
-  build-macos-x86_64:
-    runs-on: macos-13
-    steps:
-      - name: Check architecture
-        run: |
-            arch=$(uname -m)
-            if [[ "$arch" != x86_64 ]]
-            then
-                echo "Unexpected architecture: $arch" >&2
-                exit 1
-            fi
-
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: brew install meson ninja nasm libiconv zlib automake
-             # autoconf and libtool are already installed on macos-13
-
-      - name: Build
-        run: release/build_macos.sh x86_64
-
-      # upload-artifact does not preserve permissions
-      - name: Tar
-        run: |
-            cd release/work/build-macos-x86_64
-            mkdir dist-tar
-            cd dist-tar
-            tar -C .. -cvf dist.tar.gz dist/
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: build-macos-x86_64-intermediate
-          path: release/work/build-macos-x86_64/dist-tar/
-
-  package-linux-x86_64:
-    needs:
-      - build-scrcpy-server
-      - build-linux-x86_64
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Download scrcpy-server
-        uses: actions/download-artifact@v4
-        with:
-          name: scrcpy-server
-          path: release/work/build-server/server/
-
-      - name: Download build-linux-x86_64
-        uses: actions/download-artifact@v4
-        with:
-          name: build-linux-x86_64-intermediate
-          path: release/work/build-linux-x86_64/dist-tar/
-
-      # upload-artifact does not preserve permissions
-      - name: Detar
-        run: |
-            cd release/work/build-linux-x86_64
-            tar xf dist-tar/dist.tar.gz
-
-      - name: Package
-        run: release/package_client.sh linux-x86_64 tar.gz
-
-      - name: Upload release
-        uses: actions/upload-artifact@v4
-        with:
-          name: release-linux-x86_64
-          path: release/output/
-
-  package-win32:
-    needs:
-      - build-scrcpy-server
-      - build-win32
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Download scrcpy-server
-        uses: actions/download-artifact@v4
-        with:
-          name: scrcpy-server
-          path: release/work/build-server/server/
-
-      - name: Download build-win32
-        uses: actions/download-artifact@v4
-        with:
-          name: build-win32-intermediate
-          path: release/work/build-win32/dist-tar/
-
-      # upload-artifact does not preserve permissions
-      - name: Detar
-        run: |
-            cd release/work/build-win32
-            tar xf dist-tar/dist.tar.gz
-
-      - name: Package
-        run: release/package_client.sh win32 zip
-
-      - name: Upload release
-        uses: actions/upload-artifact@v4
-        with:
-          name: release-win32
-          path: release/output/
-
-  package-win64:
-    needs:
-      - build-scrcpy-server
-      - build-win64
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Download scrcpy-server
-        uses: actions/download-artifact@v4
-        with:
-          name: scrcpy-server
-          path: release/work/build-server/server/
-
-      - name: Download build-win64
-        uses: actions/download-artifact@v4
-        with:
-          name: build-win64-intermediate
-          path: release/work/build-win64/dist-tar/
-
-      # upload-artifact does not preserve permissions
-      - name: Detar
-        run: |
-            cd release/work/build-win64
-            tar xf dist-tar/dist.tar.gz
-
-      - name: Package
-        run: release/package_client.sh win64 zip
-
-      - name: Upload release
-        uses: actions/upload-artifact@v4
-        with:
-          name: release-win64
-          path: release/output
-
-  package-macos-aarch64:
-    needs:
-      - build-scrcpy-server
-      - build-macos-aarch64
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Download scrcpy-server
-        uses: actions/download-artifact@v4
-        with:
-          name: scrcpy-server
-          path: release/work/build-server/server/
-
-      - name: Download build-macos-aarch64
-        uses: actions/download-artifact@v4
-        with:
-          name: build-macos-aarch64-intermediate
-          path: release/work/build-macos-aarch64/dist-tar/
-
-      # upload-artifact does not preserve permissions
-      - name: Detar
-        run: |
-            cd release/work/build-macos-aarch64
-            tar xf dist-tar/dist.tar.gz
-
-      - name: Package
-        run: release/package_client.sh macos-aarch64 tar.gz
-
-      - name: Upload release
-        uses: actions/upload-artifact@v4
-        with:
-          name: release-macos-aarch64
-          path: release/output/
-
-  package-macos-x86_64:
-    needs:
-      - build-scrcpy-server
-      - build-macos-x86_64
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Download scrcpy-server
-        uses: actions/download-artifact@v4
-        with:
-          name: scrcpy-server
-          path: release/work/build-server/server/
-
-      - name: Download build-macos
-        uses: actions/download-artifact@v4
-        with:
-          name: build-macos-x86_64-intermediate
-          path: release/work/build-macos-x86_64/dist-tar/
-
-      # upload-artifact does not preserve permissions
-      - name: Detar
-        run: |
-            cd release/work/build-macos-x86_64
-            tar xf dist-tar/dist.tar.gz
-
-      - name: Package
-        run: release/package_client.sh macos-x86_64 tar.gz
-
-      - name: Upload release
-        uses: actions/upload-artifact@v4
-        with:
-          name: release-macos-x86_64
-          path: release/output/
-
-  release:
-    needs:
-      - build-scrcpy-server
-      - package-linux-x86_64
-      - package-win32
-      - package-win64
-      - package-macos-aarch64
-      - package-macos-x86_64
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Download scrcpy-server
-        uses: actions/download-artifact@v4
-        with:
-          name: scrcpy-server
-          path: release/work/build-server/server/
-
-      - name: Download release-linux-x86_64
-        uses: actions/download-artifact@v4
-        with:
-          name: release-linux-x86_64
-          path: release/output/
-
-      - name: Download release-win32
-        uses: actions/download-artifact@v4
-        with:
-          name: release-win32
-          path: release/output/
-
-      - name: Download release-win64
-        uses: actions/download-artifact@v4
-        with:
-          name: release-win64
-          path: release/output/
-
-      - name: Download release-macos-aarch64
-        uses: actions/download-artifact@v4
-        with:
-          name: release-macos-aarch64
-          path: release/output/
-
-      - name: Download release-macos-x86_64
-        uses: actions/download-artifact@v4
-        with:
-          name: release-macos-x86_64
-          path: release/output/
-
-      - name: Package server
-        run: release/package_server.sh
-
-      - name: Generate checksums
-        run: release/generate_checksums.sh
-
-      - name: Upload release artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: scrcpy-release-${{ env.VERSION }}
-          path: release/output

.gitignore

@@ -7,4 +7,3 @@ build/
 .gradle/
 /x/
 local.properties
-/scrcpy-server

BUILD.md

@@ -2,16 +2,57 @@
 
 Here are the instructions to build _scrcpy_ (client and server).
 
-If you just want to build and install the latest release, follow the simplified
-process described in [doc/linux.md](linux.md).
+
+## Simple
+
+If you just want to install the latest release from `master`, follow this
+simplified process.
+
+First, you need to install the required packages:
+
+```bash
+# for Debian/Ubuntu
+sudo apt install ffmpeg libsdl2-2.0-0 adb wget \
+                 gcc git pkg-config meson ninja-build libsdl2-dev \
+                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
+                 libusb-1.0-0 libusb-1.0-0-dev
+```
+
+Then clone the repo and execute the installation script
+([source](install_release.sh)):
+
+```bash
+git clone https://github.com/Genymobile/scrcpy
+cd scrcpy
+./install_release.sh
+```
+
+When a new release is out, update the repo and reinstall:
+
+```bash
+git pull
+./install_release.sh
+```
+
+To uninstall:
+
+```bash
+sudo ninja -Cbuild-auto uninstall
+```
+
 
 ## Branches
 
-There are two main branches:
- - `master`: contains the latest release. It is the home page of the project on
-   GitHub.
- - `dev`: the current development branch. Every commit present in `dev` will be
-   in the next release.
+### `master`
+
+The `master` branch concerns the latest release, and is the home page of the
+project on GitHub.
+
+
+### `dev`
+
+`dev` is the current development branch. Every commit present in `dev` will be
+in the next release.
 
 If you want to contribute code, please base your commits on the latest `dev`
 branch.
@@ -28,8 +69,6 @@ the following files to a directory accessible from your `PATH`:
  - `AdbWinApi.dll`
  - `AdbWinUsbApi.dll`
 
-It is also available in scrcpy releases.
-
 The client requires [FFmpeg] and [LibSDL2]. Just follow the instructions.
 
 [adb]: https://developer.android.com/studio/command-line/adb.html
@@ -55,10 +94,10 @@ sudo apt install ffmpeg libsdl2-2.0-0 adb libusb-1.0-0
 # client build dependencies
 sudo apt install gcc git pkg-config meson ninja-build libsdl2-dev \
                  libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
-                 libswresample-dev libusb-1.0-0-dev
+                 libusb-1.0-0-dev
 
 # server build dependencies
-sudo apt install openjdk-17-jdk
+sudo apt install openjdk-11-jdk
 ```
 
 On old versions (like Ubuntu 16.04), `meson` is too old. In that case, install
@@ -77,7 +116,7 @@ pip3 install meson
 sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
 
 # client build dependencies
-sudo dnf install SDL2-devel ffms2-devel libusb1-devel libavdevice-free-devel meson gcc make
+sudo dnf install SDL2-devel ffms2-devel libusb-devel meson gcc make
 
 # server build dependencies
 sudo dnf install java-devel
@@ -94,13 +133,13 @@ This is the preferred method (and the way the release is built).
 From _Debian_, install _mingw_:
 
 ```bash
-sudo apt install mingw-w64 mingw-w64-tools libz-mingw-w64-dev
+sudo apt install mingw-w64 mingw-w64-tools
 ```
 
 You also need the JDK to build the server:
 
 ```bash
-sudo apt install openjdk-17-jdk
+sudo apt install openjdk-11-jdk
 ```
 
 Then generate the releases:
@@ -168,13 +207,13 @@ brew install sdl2 ffmpeg libusb
 brew install pkg-config meson
 ```
 
-Additionally, if you want to build the server, install Java 17 from Caskroom, and
+Additionally, if you want to build the server, install Java 8 from Caskroom, and
 make it available from the `PATH`:
 
 ```bash
 brew tap homebrew/cask-versions
-brew install adoptopenjdk/openjdk/adoptopenjdk17
-export JAVA_HOME="$(/usr/libexec/java_home --version 1.17)"
+brew install adoptopenjdk/openjdk/adoptopenjdk11
+export JAVA_HOME="$(/usr/libexec/java_home --version 1.11)"
 export PATH="$JAVA_HOME/bin:$PATH"
 ```
 
@@ -233,10 +272,10 @@ install` must be run as root)._
 
 #### Option 2: Use prebuilt server
 
- - [`scrcpy-server-v3.0.2`][direct-scrcpy-server]  
-   <sub>SHA-256: `e19fe024bfa3367809494407ad6ca809a6f6e77dac95e99f85ba75144e0ba35d`</sub>
+ - [`scrcpy-server-v1.25`][direct-scrcpy-server]  
+   <sub>SHA-256: `ce0306c7bbd06ae72f6d06f7ec0ee33774995a65de71e0a83813ecb67aec9bdb`</sub>
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v3.0.2/scrcpy-server-v3.0.2
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.25/scrcpy-server-v1.25
 
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
@@ -275,8 +314,7 @@ This installs several files:
  - `/usr/local/share/zsh/site-functions/_scrcpy` (zsh completion)
  - `/usr/local/share/bash-completion/completions/scrcpy` (bash completion)
 
-You can then run `scrcpy`.
-
+You can then [run](README.md#run) `scrcpy`.
 
 ### Uninstall
 

DEVELOP.md

@@ -0,0 +1,309 @@
+# scrcpy for developers
+
+## Overview
+
+This application is composed of two parts:
+ - the server (`scrcpy-server`), to be executed on the device,
+ - the client (the `scrcpy` binary), executed on the host computer.
+
+The client is responsible to push the server to the device and start its
+execution.
+
+Once the client and the server are connected to each other, the server initially
+sends device information (name and initial screen dimensions), then starts to
+send a raw H.264 video stream of the device screen. The client decodes the video
+frames, and display them as soon as possible, without buffering, to minimize
+latency. The client is not aware of the device rotation (which is handled by the
+server), it just knows the dimensions of the video frames.
+
+The client captures relevant keyboard and mouse events, that it transmits to the
+server, which injects them to the device.
+
+
+
+## Server
+
+
+### Privileges
+
+Capturing the screen requires some privileges, which are granted to `shell`.
+
+The server is a Java application (with a [`public static void main(String...
+args)`][main] method), compiled against the Android framework, and executed as
+`shell` on the Android device.
+
+[main]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/Server.java#L123
+
+To run such a Java application, the classes must be [_dexed_][dex] (typically,
+to `classes.dex`). If `my.package.MainClass` is the main class, compiled to
+`classes.dex`, pushed to the device in `/data/local/tmp`, then it can be run
+with:
+
+    adb shell CLASSPATH=/data/local/tmp/classes.dex \
+        app_process / my.package.MainClass
+
+_The path `/data/local/tmp` is a good candidate to push the server, since it's
+readable and writable by `shell`, but not world-writable, so a malicious
+application may not replace the server just before the client executes it._
+
+Instead of a raw _dex_ file, `app_process` accepts a _jar_ containing
+`classes.dex` (e.g. an [APK]). For simplicity, and to benefit from the gradle
+build system, the server is built to an (unsigned) APK (renamed to
+`scrcpy-server`).
+
+[dex]: https://en.wikipedia.org/wiki/Dalvik_(software)
+[apk]: https://en.wikipedia.org/wiki/Android_application_package
+
+
+### Hidden methods
+
+Although compiled against the Android framework, [hidden] methods and classes are
+not directly accessible (and they may differ from one Android version to
+another).
+
+They can be called using reflection though. The communication with hidden
+components is provided by [_wrappers_ classes][wrappers] and [aidl].
+
+[hidden]: https://stackoverflow.com/a/31908373/1987178
+[wrappers]: https://github.com/Genymobile/scrcpy/tree/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/wrappers
+[aidl]: https://github.com/Genymobile/scrcpy/tree/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/aidl/android/view
+
+
+### Threading
+
+The server uses 3 threads:
+
+ - the **main** thread, encoding and streaming the video to the client;
+ - the **controller** thread, listening for _control messages_ (typically,
+   keyboard and mouse events) from the client;
+ - the **receiver** thread (managed by the controller), sending _device messages_
+   to the clients (currently, it is only used to send the device clipboard
+   content).
+
+Since the video encoding is typically hardware, there would be no benefit in
+encoding and streaming in two different threads.
+
+
+### Screen video encoding
+
+The encoding is managed by [`ScreenEncoder`].
+
+The video is encoded using the [`MediaCodec`] API. The codec takes its input
+from a [surface] associated to the display, and writes the resulting H.264
+stream to the provided output stream (the socket connected to the client).
+
+[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+[`MediaCodec`]: https://developer.android.com/reference/android/media/MediaCodec.html
+[surface]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L68-L69
+
+On device [rotation], the codec, surface and display are reinitialized, and a
+new video stream is produced.
+
+New frames are produced only when changes occur on the surface. This is good
+because it avoids to send unnecessary frames, but there are drawbacks:
+
+ - it does not send any frame on start if the device screen does not change,
+ - after fast motion changes, the last frame may have poor quality.
+
+Both problems are [solved][repeat] by the flag
+[`KEY_REPEAT_PREVIOUS_FRAME_AFTER`][repeat-flag].
+
+[rotation]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L90
+[repeat]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L147-L148
+[repeat-flag]: https://developer.android.com/reference/android/media/MediaFormat.html#KEY_REPEAT_PREVIOUS_FRAME_AFTER
+
+
+### Input events injection
+
+_Control messages_ are received from the client by the [`Controller`] (run in a
+separate thread). There are several types of input events:
+ - keycode (cf [`KeyEvent`]),
+ - text (special characters may not be handled by keycodes directly),
+ - mouse motion/click,
+ - mouse scroll,
+ - other commands (e.g. to switch the screen on or to copy the clipboard).
+
+Some of them need to inject input events to the system. To do so, they use the
+_hidden_ method [`InputManager.injectInputEvent`] (exposed by our
+[`InputManager` wrapper][inject-wrapper]).
+
+[`Controller`]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/Controller.java#L81
+[`KeyEvent`]: https://developer.android.com/reference/android/view/KeyEvent.html
+[`MotionEvent`]: https://developer.android.com/reference/android/view/MotionEvent.html
+[`InputManager.injectInputEvent`]: https://android.googlesource.com/platform/frameworks/base/+/oreo-release/core/java/android/hardware/input/InputManager.java#857
+[inject-wrapper]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27
+
+
+
+## Client
+
+The client relies on [SDL], which provides cross-platform API for UI, input
+events, threading, etc.
+
+The video stream is decoded by [libav] (FFmpeg).
+
+[SDL]: https://www.libsdl.org
+[libav]: https://www.libav.org/
+
+### Initialization
+
+On startup, in addition to _libav_ and _SDL_ initialization, the client must
+push and start the server on the device, and open two sockets (one for the video
+stream, one for control) so that they may communicate.
+
+Note that the client-server roles are expressed at the application level:
+
+ - the server _serves_ video stream and handle requests from the client,
+ - the client _controls_ the device through the server.
+
+However, the roles are reversed at the network level:
+
+ - the client opens a server socket and listen on a port before starting the
+   server,
+ - the server connects to the client.
+
+This role inversion guarantees that the connection will not fail due to race
+conditions, and avoids polling.
+
+_(Note that over TCP/IP, the roles are not reversed, due to a bug in `adb
+reverse`. See commit [1038bad] and [issue #5].)_
+
+Once the server is connected, it sends the device information (name and initial
+screen dimensions). Thus, the client may init the window and renderer, before
+the first frame is available.
+
+To minimize startup time, SDL initialization is performed while listening for
+the connection from the server (see commit [90a46b4]).
+
+[1038bad]: https://github.com/Genymobile/scrcpy/commit/1038bad3850f18717a048a4d5c0f8110e54ee172
+[issue #5]: https://github.com/Genymobile/scrcpy/issues/5
+[90a46b4]: https://github.com/Genymobile/scrcpy/commit/90a46b4c45637d083e877020d85ade52a9a5fa8e
+
+
+### Threading
+
+The client uses 4 threads:
+
+ - the **main** thread, executing the SDL event loop,
+ - the **stream** thread, receiving the video and used for decoding and
+   recording,
+ - the **controller** thread, sending _control messages_ to the server,
+ - the **receiver** thread (managed by the controller), receiving _device
+   messages_ from the server.
+
+In addition, another thread can be started if necessary to handle APK
+installation or file push requests (via drag&drop on the main window) or to
+print the framerate regularly in the console.
+
+
+
+### Stream
+
+The video [stream] is received from the socket (connected to the server on the
+device) in a separate thread.
+
+If a [decoder] is present (i.e. `--no-display` is not set), then it uses _libav_
+to decode the H.264 stream from the socket, and notifies the main thread when a
+new frame is available.
+
+There are two [frames][video_buffer] simultaneously in memory:
+ - the **decoding** frame, written by the decoder from the decoder thread,
+ - the **rendering** frame, rendered in a texture from the main thread.
+
+When a new decoded frame is available, the decoder _swaps_ the decoding and
+rendering frame (with proper synchronization). Thus, it immediately starts
+to decode a new frame while the main thread renders the last one.
+
+If a [recorder] is present (i.e. `--record` is enabled), then it muxes the raw
+H.264 packet to the output video file.
+
+[stream]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/stream.h
+[decoder]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/decoder.h
+[video_buffer]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/video_buffer.h
+[recorder]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/recorder.h
+
+```
+                                   +----------+      +----------+
+                              ---> | decoder  | ---> |  screen  |
+             +---------+     /     +----------+      +----------+
+ socket ---> | stream  | ----
+             +---------+     \     +----------+
+                              ---> | recorder |
+                                   +----------+
+```
+
+### Controller
+
+The [controller] is responsible to send _control messages_ to the device. It
+runs in a separate thread, to avoid I/O on the main thread.
+
+On SDL event, received on the main thread, the [input manager][inputmanager]
+creates appropriate [_control messages_][controlmsg]. It is responsible to
+convert SDL events to Android events (using [convert]). It pushes the _control
+messages_ to a queue hold by the controller. On its own thread, the controller
+takes messages from the queue, that it serializes and sends to the client.
+
+[controller]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/controller.h
+[controlmsg]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/control_msg.h
+[inputmanager]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/input_manager.h
+[convert]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/convert.h
+
+
+### UI and event loop
+
+Initialization, input events and rendering are all [managed][scrcpy] in the main
+thread.
+
+Events are handled in the [event loop], which either updates the [screen] or
+delegates to the [input manager][inputmanager].
+
+[scrcpy]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/scrcpy.c
+[event loop]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/scrcpy.c#L201
+[screen]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/screen.h
+
+
+## Hack
+
+For more details, go read the code!
+
+If you find a bug, or have an awesome idea to implement, please discuss and
+contribute ;-)
+
+
+### Debug the server
+
+The server is pushed to the device by the client on startup.
+
+To debug it, enable the server debugger during configuration:
+
+```bash
+meson setup x -Dserver_debugger=true
+# or, if x is already configured
+meson configure x -Dserver_debugger=true
+```
+
+If your device runs Android 8 or below, set the `server_debugger_method` to
+`old` in addition:
+
+```bash
+meson setup x -Dserver_debugger=true -Dserver_debugger_method=old
+# or, if x is already configured
+meson configure x -Dserver_debugger=true -Dserver_debugger_method=old
+```
+
+Then recompile.
+
+When you start scrcpy, it will start a debugger on port 5005 on the device.
+Redirect that port to the computer:
+
+```bash
+adb forward tcp:5005 tcp:5005
+```
+
+In Android Studio, _Run_ > _Debug_ > _Edit configurations..._ On the left, click on
+`+`, _Remote_, and fill the form:
+
+ - Host: `localhost`
+ - Port: `5005`
+
+Then click on _Debug_.

FAQ.md

@@ -7,7 +7,7 @@ Here are the common reported problems and their status.
 If you encounter any error, the first step is to upgrade to the latest version.
 
 
-## `adb` and USB issues
+## `adb` issues
 
 `scrcpy` execute `adb` commands to initialize the connection with the device. If
 `adb` fails, then scrcpy will not work.
@@ -133,21 +133,6 @@ Try with another USB cable or plug it into another USB port. See [#281] and
 [#283]: https://github.com/Genymobile/scrcpy/issues/283
 
 
-## OTG issues on Windows
-
-On Windows, if `scrcpy --otg` (or `--keyboard=aoa`/`--mouse=aoa`) results in:
-
->     ERROR: Could not find any USB device
-
-(or if only unrelated USB devices are detected), there might be drivers issues.
-
-Please read [#3654], in particular [this comment][#3654-comment1] and [the next
-one][#3654-comment2].
-
-[#3654]: https://github.com/Genymobile/scrcpy/issues/3654
-[#3654-comment1]: https://github.com/Genymobile/scrcpy/issues/3654#issuecomment-1369278232
-[#3654-comment2]: https://github.com/Genymobile/scrcpy/issues/3654#issuecomment-1369295011
-
 
 ## Control issues
 
@@ -159,8 +144,6 @@ In developer options, enable:
 > **USB debugging (Security settings)**  
 > _Allow granting permissions and simulating input via USB debugging_
 
-Rebooting the device is necessary once this option is set.
-
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 
 
@@ -170,17 +153,43 @@ 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].
+Since scrcpy v1.20 on Linux, it is possible to simulate a [physical
+keyboard][hid] (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
+[hid]: README.md#physical-keyboard-simulation-hid
 
 
 ## Client issues
 
+### The quality is low
+
+If the definition of your client window is smaller than that of your device
+screen, then you might get poor quality, especially visible on text (see [#40]).
+
+[#40]: https://github.com/Genymobile/scrcpy/issues/40
+
+This problem should be fixed in scrcpy v1.22: **update to the latest version**.
+
+On older versions, you must configure the [scaling behavior]:
+
+> `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
+> Override high DPI scaling behavior > Scaling performed by: _Application_.
+
+[scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
+
+Also, to improve downscaling quality, trilinear filtering is enabled
+automatically if the renderer is OpenGL and if it supports mipmapping.
+
+On Windows, you might want to force OpenGL to enable mipmapping:
+
+```
+scrcpy --render-driver=opengl
+```
+
+
 ### Issue with Wayland
 
 By default, SDL uses x11 on Linux. The [video driver] can be changed via the
@@ -215,15 +224,102 @@ As a workaround, [disable "Block compositing"][kwin].
 
 ### Exception
 
-If you get any exception related to `MediaCodec`:
+There may be many reasons. One common cause is that the hardware encoder of your
+device is not able to encode at the given definition:
+
+> ```
+> ERROR: Exception on thread Thread[main,5,main]
+> android.media.MediaCodec$CodecException: Error 0xfffffc0e
+> ...
+> Exit due to uncaughtException in main thread:
+> ERROR: Could not open video stream
+> INFO: Initial texture: 1080x2336
+> ```
+
+or
+
+> ```
+> ERROR: Exception on thread Thread[main,5,main]
+> java.lang.IllegalStateException
+>         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
+> ```
+
+Just try with a lower definition:
 
 ```
-ERROR: Exception on thread Thread[main,5,main]
-java.lang.IllegalStateException
-        at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
+scrcpy -m 1920
+scrcpy -m 1024
+scrcpy -m 800
 ```
 
-then try with another [encoder](doc/video.md#encoder).
+Since scrcpy v1.22, scrcpy automatically tries again with a lower definition
+before failing. This behavior can be disabled with `--no-downsize-on-error`.
+
+You could also try another [encoder](README.md#encoder).
+
+
+If you encounter this exception on Android 12, then just upgrade to scrcpy >=
+1.18 (see [#2129]):
+
+```
+> ERROR: Exception on thread Thread[main,5,main]
+java.lang.AssertionError: java.lang.reflect.InvocationTargetException
+    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:75)
+    ...
+Caused by: java.lang.reflect.InvocationTargetException
+    at java.lang.reflect.Method.invoke(Native Method)
+    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:73)
+    ... 7 more
+Caused by: java.lang.IllegalArgumentException: displayToken must not be null
+    at android.view.SurfaceControl$Transaction.setDisplaySurface(SurfaceControl.java:3067)
+    at android.view.SurfaceControl.setDisplaySurface(SurfaceControl.java:2147)
+    ... 9 more
+```
+
+[#2129]: https://github.com/Genymobile/scrcpy/issues/2129
+
+
+## Command line on Windows
+
+Since v1.22, a "shortcut" has been added to directly open a terminal in the
+scrcpy directory. Double-click on `open_a_terminal_here.bat`, then type your
+command. For example:
+
+```
+scrcpy --record file.mkv
+```
+
+You could also open a terminal and go to the scrcpy folder manually:
+
+ 1. Press <kbd>Windows</kbd>+<kbd>r</kbd>, this opens a dialog box.
+ 2. Type `cmd` and press <kbd>Enter</kbd>, this opens a terminal.
+ 3. Go to your _scrcpy_ directory, by typing (adapt the path):
+
+    ```bat
+    cd C:\Users\user\Downloads\scrcpy-win64-xxx
+    ```
+
+    and press <kbd>Enter</kbd>
+ 4. Type your command. For example:
+
+    ```bat
+    scrcpy --record file.mkv
+    ```
+
+If you plan to always use the same arguments, create a file `myscrcpy.bat`
+(enable [show file extensions] to avoid confusion) in the `scrcpy` directory,
+containing your command. For example:
+
+```bat
+scrcpy --prefer-text --turn-screen-off --stay-awake
+```
+
+Then just double-click on that file.
+
+You could also edit (a copy of) `scrcpy-console.bat` or `scrcpy-noconsole.vbs`
+to add some arguments.
+
+[show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/
 
 
 ## Translations
@@ -232,4 +328,4 @@ Translations of this FAQ in other languages are available in the [wiki].
 
 [wiki]: https://github.com/Genymobile/scrcpy/wiki
 
-Only this FAQ file is guaranteed to be up-to-date.
+Only this README file is guaranteed to be up-to-date.

LICENSE

@@ -188,7 +188,7 @@
       identification within third-party archives.
 
    Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2024 Romain Vimont
+   Copyright (C) 2018-2022 Romain Vimont
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

app/data/bash-completion/scrcpy

@@ -2,101 +2,57 @@ _scrcpy() {
     local cur prev words cword
     local opts="
         --always-on-top
-        --angle
-        --audio-bit-rate=
-        --audio-buffer=
-        --audio-codec=
-        --audio-codec-options=
-        --audio-dup
-        --audio-encoder=
-        --audio-source=
-        --audio-output-buffer=
-        -b --video-bit-rate=
-        --camera-ar=
-        --camera-id=
-        --camera-facing=
-        --camera-fps=
-        --camera-high-speed
-        --camera-size=
-        --capture-orientation=
+        -b --bit-rate=
+        --codec-options=
         --crop=
         -d --select-usb
         --disable-screensaver
-        --display-id=
-        --display-orientation=
+        --display=
+        --display-buffer=
         -e --select-tcpip
-        -f --fullscreen
+        --encoder=
         --force-adb-forward
-        -G
-        --gamepad=
+        --forward-all-clicks
+        -f --fullscreen
+        -K --hid-keyboard
         -h --help
-        -K
-        --keyboard=
-        --kill-adb-on-close
         --legacy-paste
-        --list-apps
-        --list-camera-sizes
-        --list-cameras
-        --list-displays
-        --list-encoders
-        -m --max-size=
-        -M
+        --lock-video-orientation
+        --lock-video-orientation=
         --max-fps=
-        --mouse=
-        --mouse-bind=
-        -n --no-control
-        -N --no-playback
-        --new-display
-        --new-display=
-        --no-audio
-        --no-audio-playback
+        -M --hid-mouse
+        -m --max-size=
         --no-cleanup
-        --no-clipboard-autosync
+        --no-clipboard-on-error
         --no-downsize-on-error
+        -n --no-control
+        -N --no-display
         --no-key-repeat
         --no-mipmaps
-        --no-mouse-hover
         --no-power-on
-        --no-vd-destroy-content
-        --no-vd-system-decorations
-        --no-video
-        --no-video-playback
-        --orientation=
         --otg
         -p --port=
-        --pause-on-exit
-        --pause-on-exit=
         --power-off-on-close
         --prefer-text
         --print-fps
         --push-target=
-        -r --record=
         --raw-key-events
+        -r --record=
         --record-format=
-        --record-orientation=
         --render-driver=
-        --require-audio
         --rotation=
         -s --serial=
-        -S --turn-screen-off
-        --screen-off-timeout=
         --shortcut-mod=
-        --start-app=
+        -S --turn-screen-off
         -t --show-touches
         --tcpip
         --tcpip=
-        --time-limit=
         --tunnel-host=
         --tunnel-port=
         --v4l2-buffer=
         --v4l2-sink=
-        -v --version
         -V --verbosity=
-        --video-buffer=
-        --video-codec=
-        --video-codec-options=
-        --video-encoder=
-        --video-source=
+        -v --version
         -w --stay-awake
         --window-borderless
         --window-title=
@@ -108,52 +64,8 @@ _scrcpy() {
     _init_completion -s || return
 
     case "$prev" in
-        --video-codec)
-            COMPREPLY=($(compgen -W 'h264 h265 av1' -- "$cur"))
-            return
-            ;;
-        --audio-codec)
-            COMPREPLY=($(compgen -W 'opus aac flac raw' -- "$cur"))
-            return
-            ;;
-        --video-source)
-            COMPREPLY=($(compgen -W 'display camera' -- "$cur"))
-            return
-            ;;
-        --audio-source)
-            COMPREPLY=($(compgen -W 'output mic playback' -- "$cur"))
-            return
-            ;;
-        --camera-facing)
-            COMPREPLY=($(compgen -W 'front back external' -- "$cur"))
-            return
-            ;;
-        --keyboard)
-            COMPREPLY=($(compgen -W 'disabled sdk uhid aoa' -- "$cur"))
-            return
-            ;;
-        --mouse)
-            COMPREPLY=($(compgen -W 'disabled sdk uhid aoa' -- "$cur"))
-            return
-            ;;
-        --gamepad)
-            COMPREPLY=($(compgen -W 'disabled uhid aoa' -- "$cur"))
-            return
-            ;;
-        --capture-orientation)
-            COMPREPLY=($(compgen -W '0 90 180 270 flip0 flip90 flip180 flip270 @0 @90 @180 @270 @flip0 @flip90 @flip180 @flip270' -- "$cur"))
-            return
-            ;;
-        --orientation|--display-orientation)
-            COMPREPLY=($(compgen -W '0 90 180 270 flip0 flip90 flip180 flip270' -- "$cur"))
-            return
-            ;;
-        --record-orientation)
-            COMPREPLY=($(compgen -W '0 90 180 270' -- "$cur"))
-            return
-            ;;
-        --pause-on-exit)
-            COMPREPLY=($(compgen -W 'true false if-error' -- "$cur"))
+        --lock-video-orientation)
+            COMPREPLY=($(compgen -W 'unlocked initial 0 1 2 3' -- "$cur"))
             return
             ;;
         -r|--record)
@@ -161,13 +73,17 @@ _scrcpy() {
             return
             ;;
         --record-format)
-            COMPREPLY=($(compgen -W 'mp4 mkv m4a mka opus aac flac wav' -- "$cur"))
+            COMPREPLY=($(compgen -W 'mkv mp4' -- "$cur"))
             return
             ;;
         --render-driver)
             COMPREPLY=($(compgen -W 'direct3d opengl opengles2 opengles metal software' -- "$cur"))
             return
             ;;
+        --rotation)
+            COMPREPLY=($(compgen -W '0 1 2 3' -- "$cur"))
+            return
+            ;;
         --shortcut-mod)
             # Only auto-complete a single key
             COMPREPLY=($(compgen -W 'lctrl rctrl lalt ralt lsuper rsuper' -- "$cur"))
@@ -182,31 +98,20 @@ _scrcpy() {
             COMPREPLY=($(compgen -W "$("${ADB:-adb}" devices | awk '$2 == "device" {print $1}')" -- ${cur}))
             return
             ;;
-        --audio-bit-rate \
-        |--audio-buffer \
-        |-b|--video-bit-rate \
-        |--audio-codec-options \
-        |--audio-encoder \
-        |--audio-output-buffer \
-        |--camera-ar \
-        |--camera-id \
-        |--camera-fps \
-        |--camera-size \
+        -b|--bitrate \
+        |--codec-options \
         |--crop \
-        |--display-id \
+        |--display \
+        |--display-buffer \
+        |--encoder \
         |--max-fps \
         |-m|--max-size \
-        |--new-display \
         |-p|--port \
         |--push-target \
-        |--rotation \
         |--tunnel-host \
         |--tunnel-port \
         |--v4l2-buffer \
         |--v4l2-sink \
-        |--video-buffer \
-        |--video-codec-options \
-        |--video-encoder \
         |--tcpip \
         |--window-*)
             # Option accepting an argument, but nothing to auto-complete

app/data/scrcpy-console.bat

@@ -1,2 +1,4 @@
 @echo off
-scrcpy.exe --pause-on-exit=if-error %*
+scrcpy.exe %*
+:: if the exit code is >= 1, then pause
+if errorlevel 1 pause

app/data/scrcpy-console.desktop

@@ -5,7 +5,7 @@ Comment=Display and control your Android device
 # For some users, the PATH or ADB environment variables are set from the shell
 # startup file, like .bashrc or .zshrc… Run an interactive shell to get
 # environment correctly initialized.
-Exec=/bin/sh -c "\\$SHELL -i -c 'scrcpy --pause-on-exit=if-error'"
+Exec=/bin/bash --norc --noprofile -i -c '"$SHELL" -i -c scrcpy || read -p "Press any key to quit..."'
 Icon=scrcpy
 Terminal=true
 Type=Application

app/data/scrcpy.desktop

@@ -5,7 +5,7 @@ Comment=Display and control your Android device
 # For some users, the PATH or ADB environment variables are set from the shell
 # startup file, like .bashrc or .zshrc… Run an interactive shell to get
 # environment correctly initialized.
-Exec=/bin/sh -c "\\$SHELL -i -c scrcpy"
+Exec=/bin/sh -c '"$SHELL" -i -c scrcpy'
 Icon=scrcpy
 Terminal=false
 Type=Application

app/data/zsh-completion/_scrcpy

@@ -9,97 +9,55 @@ local arguments
 
 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-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 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]'
-    '--camera-high-speed=[Enable high-speed camera capture mode]'
-    '--camera-id=[Specify the camera id to mirror]'
-    '--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]'
-    '--capture-orientation=[Set the capture video orientation]:orientation:(0 90 180 270 flip0 flip90 flip180 flip270 @0 @90 @180 @270 @flip0 @flip90 @flip180 @flip270)'
+    {-b,--bit-rate=}'[Encode the video at the given bit-rate]'
+    '--codec-options=[Set a list of comma-separated key\:type=value options for the device encoder]'
     '--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-orientation=[Set the initial display orientation]:orientation values:(0 90 180 270 flip0 flip90 flip180 flip270)'
+    '--display=[Specify the display id to mirror]'
+    '--display-buffer=[Add a buffering delay \(in milliseconds\) before displaying]'
     {-e,--select-tcpip}'[Use TCP/IP device]'
-    {-f,--fullscreen}'[Start in fullscreen]'
+    '--encoder=[Use a specific MediaCodec encoder \(must be a H.264 encoder\)]'
     '--force-adb-forward[Do not attempt to use \"adb reverse\" to connect to the device]'
-    '-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)'
+    '--forward-all-clicks[Forward clicks to device]'
+    {-f,--fullscreen}'[Start in fullscreen]'
+    {-K,--hid-keyboard}'[Simulate a physical keyboard by using HID over AOAv2]'
     {-h,--help}'[Print the help]'
-    '-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]'
-    '--list-apps[List Android apps installed on the device]'
-    '--list-camera-sizes[List the valid camera capture sizes]'
-    '--list-cameras[List cameras available on the device]'
-    '--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)]'
+    '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 1 2 3)'
     '--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]'
-    {-n,--no-control}'[Disable device control \(mirror the device in read only\)]'
-    {-N,--no-playback}'[Disable video and audio playback]'
-    '--new-display=[Create a new display]'
-    '--no-audio[Disable audio forwarding]'
-    '--no-audio-playback[Disable audio playback]'
+    {-M,--hid-mouse}'[Simulate a physical mouse by using HID over AOAv2]'
+    {-m,--max-size=}'[Limit both the width and height of the video to value]'
     '--no-cleanup[Disable device cleanup actions on exit]'
     '--no-clipboard-autosync[Disable automatic clipboard synchronization]'
     '--no-downsize-on-error[Disable lowering definition on MediaCodec error]'
+    {-n,--no-control}'[Disable device control \(mirror the device in read only\)]'
+    {-N,--no-display}'[Do not display device \(during screen recording or when V4L2 sink is enabled\)]'
     '--no-key-repeat[Do not forward repeated key events when a key is held down]'
     '--no-mipmaps[Disable the generation of mipmaps]'
-    '--no-mouse-hover[Do not forward mouse hover events]'
     '--no-power-on[Do not power on the device on start]'
-    '--no-vd-destroy-content[Disable virtual display "destroy content on removal" flag]'
-    '--no-vd-system-decorations[Disable virtual display system decorations flag]'
-    '--no-video[Disable video forwarding]'
-    '--no-video-playback[Disable video playback]'
-    '--orientation=[Set the video orientation]:orientation values:(0 90 180 270 flip0 flip90 flip180 flip270)'
     '--otg[Run in OTG mode \(simulating physical keyboard and mouse\)]'
     {-p,--port=}'[\[port\[\:port\]\] Set the TCP port \(range\) used by the client to listen]'
-    '--pause-on-exit=[Make scrcpy pause before exiting]:mode:(true false if-error)'
     '--power-off-on-close[Turn the device screen off when closing scrcpy]'
     '--prefer-text[Inject alpha characters and space as text events instead of key events]'
     '--print-fps[Start FPS counter, to print frame logs to the console]'
     '--push-target=[Set the target directory for pushing files to the device by drag and drop]'
-    {-r,--record=}'[Record screen to file]:record file:_files'
     '--raw-key-events[Inject key events for all input keys, and ignore text events]'
-    '--record-format=[Force recording format]:format:(mp4 mkv m4a mka opus aac flac wav)'
-    '--record-orientation=[Set the record orientation]:orientation values:(0 90 180 270)'
+    {-r,--record=}'[Record screen to file]:record file:_files'
+    '--record-format=[Force recording format]:format:(mp4 mkv)'
     '--render-driver=[Request SDL to use the given render driver]:driver name:(direct3d opengl opengles2 opengles metal software)'
-    '--require-audio=[Make scrcpy fail if audio is enabled but does not work]'
+    '--rotation=[Set the initial display rotation]:rotation values:(0 1 2 3)'
     {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]:serial:($("${ADB-adb}" devices | awk '\''$2 == "device" {print $1}'\''))'
-    {-S,--turn-screen-off}'[Turn the device screen off immediately]'
-    '--screen-off-timeout=[Set the screen off timeout in seconds]'
     '--shortcut-mod=[\[key1,key2+key3,...\] Specify the modifiers to use for scrcpy shortcuts]:shortcut mod:(lctrl rctrl lalt ralt lsuper rsuper)'
-    '--start-app=[Start an Android app]'
+    {-S,--turn-screen-off}'[Turn the device screen off immediately]'
     {-t,--show-touches}'[Show physical touches]'
     '--tcpip[\(optional \[ip\:port\]\) Configure and connect the device over TCP/IP]'
-    '--time-limit=[Set the maximum mirroring time, in seconds]'
     '--tunnel-host=[Set the IP address of the adb tunnel to reach the scrcpy server]'
     '--tunnel-port=[Set the TCP port of the adb tunnel to reach the scrcpy server]'
     '--v4l2-buffer=[Add a buffering delay \(in milliseconds\) before pushing frames]'
     '--v4l2-sink=[\[\/dev\/videoN\] Output to v4l2loopback device]'
-    {-v,--version}'[Print the version of scrcpy]'
     {-V,--verbosity=}'[Set the log level]:verbosity:(verbose debug info warn error)'
-    '--video-buffer=[Add a buffering delay \(in milliseconds\) before displaying video frames]'
-    '--video-codec=[Select the video codec]:codec:(h264 h265 av1)'
-    '--video-codec-options=[Set a list of comma-separated key\:type=value options for the device video encoder]'
-    '--video-encoder=[Use a specific MediaCodec video encoder]'
-    '--video-source=[Select the video source]:source:(display camera)'
+    {-v,--version}'[Print the version of scrcpy]'
     {-w,--stay-awake}'[Keep the device on while scrcpy is running, when the device is plugged in]'
     '--window-borderless[Disable window decorations \(display borderless window\)]'
     '--window-title=[Set a custom window title]'

app/deps/.gitignore

@@ -1 +0,0 @@
-/work

app/deps/README

@@ -1,27 +0,0 @@
-This directory (app/deps/) contains:
-
-*.sh          : shell scripts to download and build dependencies
-
-patches/      : patches to fix dependencies (used by scripts)
-
-work/sources/ : downloaded tarballs and extracted folders
-                    ffmpeg-6.1.1.tar.xz
-                    ffmpeg-6.1.1/
-                    libusb-1.0.27.tar.gz
-                    libusb-1.0.27/
-                    ...
-work/build/   : build dirs for each dependency/version/architecture
-                    ffmpeg-6.1.1/win32/
-                    ffmpeg-6.1.1/win64/
-                    libusb-1.0.27/win32/
-                    libusb-1.0.27/win64/
-                    ...
-work/install/ : install dirs for each architexture
-                    win32/bin/
-                    win32/include/
-                    win32/lib/
-                    win32/share/
-                    win64/bin/
-                    win64/include/
-                    win64/lib/
-                    win64/share/

app/deps/adb_linux.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
-
-VERSION=35.0.2
-FILENAME=platform-tools_r$VERSION-linux.zip
-PROJECT_DIR=platform-tools-$VERSION-linux
-SHA256SUM=acfdcccb123a8718c46c46c059b2f621140194e5ec1ac9d81715be3d6ab6cd0a
-
-cd "$SOURCES_DIR"
-
-if [[ -d "$PROJECT_DIR" ]]
-then
-    echo "$PWD/$PROJECT_DIR" found
-else
-    get_file "https://dl.google.com/android/repository/$FILENAME" "$FILENAME" "$SHA256SUM"
-    mkdir -p "$PROJECT_DIR"
-    cd "$PROJECT_DIR"
-    ZIP_PREFIX=platform-tools
-    unzip "../$FILENAME" "$ZIP_PREFIX"/adb
-    mv "$ZIP_PREFIX"/* .
-    rmdir "$ZIP_PREFIX"
-fi
-
-mkdir -p "$INSTALL_DIR/adb-linux"
-cd "$INSTALL_DIR/adb-linux"
-cp -r "$SOURCES_DIR/$PROJECT_DIR"/. "$INSTALL_DIR/adb-linux/"

app/deps/adb_macos.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
-
-VERSION=35.0.2
-FILENAME=platform-tools_r$VERSION-darwin.zip
-PROJECT_DIR=platform-tools-$VERSION-darwin
-SHA256SUM=1820078db90bf21628d257ff052528af1c61bb48f754b3555648f5652fa35d78
-
-cd "$SOURCES_DIR"
-
-if [[ -d "$PROJECT_DIR" ]]
-then
-    echo "$PWD/$PROJECT_DIR" found
-else
-    get_file "https://dl.google.com/android/repository/$FILENAME" "$FILENAME" "$SHA256SUM"
-    mkdir -p "$PROJECT_DIR"
-    cd "$PROJECT_DIR"
-    ZIP_PREFIX=platform-tools
-    unzip "../$FILENAME" "$ZIP_PREFIX"/adb
-    mv "$ZIP_PREFIX"/* .
-    rmdir "$ZIP_PREFIX"
-fi
-
-mkdir -p "$INSTALL_DIR/adb-macos"
-cd "$INSTALL_DIR/adb-macos"
-cp -r "$SOURCES_DIR/$PROJECT_DIR"/. "$INSTALL_DIR/adb-macos/"

app/deps/adb_windows.sh

@@ -1,32 +0,0 @@
-#!/usr/bin/env bash
-set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
-
-VERSION=35.0.2
-FILENAME=platform-tools_r$VERSION-win.zip
-PROJECT_DIR=platform-tools-$VERSION-windows
-SHA256SUM=2975a3eac0b19182748d64195375ad056986561d994fffbdc64332a516300bb9
-
-cd "$SOURCES_DIR"
-
-if [[ -d "$PROJECT_DIR" ]]
-then
-    echo "$PWD/$PROJECT_DIR" found
-else
-    get_file "https://dl.google.com/android/repository/$FILENAME" "$FILENAME" "$SHA256SUM"
-    mkdir -p "$PROJECT_DIR"
-    cd "$PROJECT_DIR"
-    ZIP_PREFIX=platform-tools
-    unzip "../$FILENAME" \
-        "$ZIP_PREFIX"/AdbWinApi.dll \
-        "$ZIP_PREFIX"/AdbWinUsbApi.dll \
-        "$ZIP_PREFIX"/adb.exe
-    mv "$ZIP_PREFIX"/* .
-    rmdir "$ZIP_PREFIX"
-fi
-
-mkdir -p "$INSTALL_DIR/adb-windows"
-cd "$INSTALL_DIR/adb-windows"
-cp -r "$SOURCES_DIR/$PROJECT_DIR"/. "$INSTALL_DIR/adb-windows/"

app/deps/common

@@ -1,77 +0,0 @@
-#!/usr/bin/env bash
-# This file is intended to be sourced by other scripts, not executed
-
-process_args() {
-    if [[ $# != 3 ]]
-    then
-        # <host>: win32 or win64
-        # <build_type>: native or cross
-        # <link_type>: static or shared
-        echo "Syntax: $0 <host> <build_type> <link_type>" >&2
-        exit 1
-    fi
-
-    HOST="$1"
-    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 ]]
-    then
-        echo "Unsupported build type (expected native or cross): $BUILD_TYPE" >&2
-        exit 1
-    fi
-
-    if [[ "$LINK_TYPE" != static && "$LINK_TYPE" != shared ]]
-    then
-        echo "Unsupported link type (expected static or shared): $LINK_TYPE" >&2
-        exit 1
-    fi
-
-    if [[ "$BUILD_TYPE" == cross ]]
-    then
-        if [[ "$HOST" = win32 ]]
-        then
-            HOST_TRIPLET=i686-w64-mingw32
-        elif [[ "$HOST" = win64 ]]
-        then
-            HOST_TRIPLET=x86_64-w64-mingw32
-        else
-            echo "Unsupported cross-build to host: $HOST" >&2
-            exit 1
-        fi
-    fi
-}
-
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-
-PATCHES_DIR="$PWD/patches"
-
-WORK_DIR="$PWD/work"
-SOURCES_DIR="$WORK_DIR/sources"
-BUILD_DIR="$WORK_DIR/build"
-INSTALL_DIR="$WORK_DIR/install"
-
-mkdir -p "$INSTALL_DIR" "$SOURCES_DIR" "$WORK_DIR"
-
-checksum() {
-    local file="$1"
-    local sum="$2"
-    echo "$file: verifying checksum..."
-    echo "$sum  $file" | shasum -a256 -c
-}
-
-get_file() {
-    local url="$1"
-    local file="$2"
-    local sum="$3"
-    if [[ -f "$file" ]]
-    then
-        echo "$file: found"
-    else
-        echo "$file: not found, downloading..."
-        wget "$url" -O "$file"
-    fi
-    checksum "$file" "$sum"
-}

app/deps/ffmpeg.sh

@@ -1,144 +0,0 @@
-#!/usr/bin/env bash
-set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
-process_args "$@"
-
-VERSION=7.1
-FILENAME=ffmpeg-$VERSION.tar.xz
-PROJECT_DIR=ffmpeg-$VERSION
-SHA256SUM=40973D44970DBC83EF302B0609F2E74982BE2D85916DD2EE7472D30678A7ABE6
-
-cd "$SOURCES_DIR"
-
-if [[ -d "$PROJECT_DIR" ]]
-then
-    echo "$PWD/$PROJECT_DIR" found
-else
-    get_file "https://ffmpeg.org/releases/$FILENAME" "$FILENAME" "$SHA256SUM"
-    tar xf "$FILENAME"  # First level directory is "$PROJECT_DIR"
-fi
-
-mkdir -p "$BUILD_DIR/$PROJECT_DIR"
-cd "$BUILD_DIR/$PROJECT_DIR"
-
-if [[ -d "$DIRNAME" ]]
-then
-    echo "'$PWD/$DIRNAME' already exists, not reconfigured"
-    cd "$DIRNAME"
-else
-    mkdir "$DIRNAME"
-    cd "$DIRNAME"
-
-    if [[ "$HOST" == win* ]]
-    then
-        # -static-libgcc to avoid missing libgcc_s_dw2-1.dll
-        # -static to avoid dynamic dependency to zlib
-        export CFLAGS='-static-libgcc -static'
-        export CXXFLAGS="$CFLAGS"
-        export LDFLAGS='-static-libgcc -static'
-    elif [[ "$HOST" == "macos" ]]
-    then
-        export LDFLAGS="$LDFLAGS -L/opt/homebrew/opt/zlib/lib"
-        export CPPFLAGS="$CPPFLAGS -I/opt/homebrew/opt/zlib/include"
-
-        export LDFLAGS="$LDFLAGS-L/opt/homebrew/opt/libiconv/lib"
-        export CPPFLAGS="$CPPFLAGS -I/opt/homebrew/opt/libiconv/include"
-        export PKG_CONFIG_PATH="/opt/homebrew/opt/zlib/lib/pkgconfig"
-    fi
-
-    conf=(
-        --prefix="$INSTALL_DIR/$DIRNAME"
-        --extra-cflags="-O2 -fPIC"
-        --disable-programs
-        --disable-doc
-        --disable-swscale
-        --disable-postproc
-        --disable-avfilter
-        --disable-network
-        --disable-everything
-        --disable-vulkan
-        --disable-vaapi
-        --disable-vdpau
-        --enable-swresample
-        --enable-decoder=h264
-        --enable-decoder=hevc
-        --enable-decoder=av1
-        --enable-decoder=pcm_s16le
-        --enable-decoder=opus
-        --enable-decoder=aac
-        --enable-decoder=flac
-        --enable-decoder=png
-        --enable-protocol=file
-        --enable-demuxer=image2
-        --enable-parser=png
-        --enable-zlib
-        --enable-muxer=matroska
-        --enable-muxer=mp4
-        --enable-muxer=opus
-        --enable-muxer=flac
-        --enable-muxer=wav
-    )
-
-    if [[ "$HOST" == linux ]]
-    then
-        conf+=(
-            --enable-libv4l2
-            --enable-outdev=v4l2
-            --enable-encoder=rawvideo
-        )
-    else
-        # libavdevice is only used for V4L2 on Linux
-        conf+=(
-            --disable-avdevice
-        )
-    fi
-
-    if [[ "$LINK_TYPE" == static ]]
-    then
-        conf+=(
-            --enable-static
-            --disable-shared
-        )
-    else
-        conf+=(
-            --disable-static
-            --enable-shared
-        )
-    fi
-
-    if [[ "$BUILD_TYPE" == cross ]]
-    then
-        conf+=(
-            --enable-cross-compile
-            --cross-prefix="${HOST_TRIPLET}-"
-            --cc="${HOST_TRIPLET}-gcc"
-        )
-
-        case "$HOST" in
-            win32)
-                conf+=(
-                    --target-os=mingw32
-                    --arch=x86
-                )
-                ;;
-
-            win64)
-                conf+=(
-                    --target-os=mingw32
-                    --arch=x86_64
-                )
-                ;;
-
-            *)
-                echo "Unsupported host: $HOST" >&2
-                exit 1
-        esac
-    fi
-
-    "$SOURCES_DIR/$PROJECT_DIR"/configure "${conf[@]}"
-fi
-
-make -j
-make install

app/deps/libusb.sh

@@ -1,66 +0,0 @@
-#!/usr/bin/env bash
-set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
-process_args "$@"
-
-VERSION=1.0.27
-FILENAME=libusb-$VERSION.tar.gz
-PROJECT_DIR=libusb-$VERSION
-SHA256SUM=e8f18a7a36ecbb11fb820bd71540350d8f61bcd9db0d2e8c18a6fb80b214a3de
-
-cd "$SOURCES_DIR"
-
-if [[ -d "$PROJECT_DIR" ]]
-then
-    echo "$PWD/$PROJECT_DIR" found
-else
-    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
-
-mkdir -p "$BUILD_DIR/$PROJECT_DIR"
-cd "$BUILD_DIR/$PROJECT_DIR"
-
-export CFLAGS='-O2'
-export CXXFLAGS="$CFLAGS"
-
-if [[ -d "$DIRNAME" ]]
-then
-    echo "'$PWD/$DIRNAME' already exists, not reconfigured"
-    cd "$DIRNAME"
-else
-    mkdir "$DIRNAME"
-    cd "$DIRNAME"
-
-    conf=(
-        --prefix="$INSTALL_DIR/$DIRNAME"
-    )
-
-    if [[ "$LINK_TYPE" == static ]]
-    then
-        conf+=(
-            --enable-static
-            --disable-shared
-        )
-    else
-        conf+=(
-            --disable-static
-            --enable-shared
-        )
-    fi
-
-    if [[ "$BUILD_TYPE" == cross ]]
-    then
-        conf+=(
-            --host="$HOST_TRIPLET"
-        )
-    fi
-
-    "$SOURCES_DIR/$PROJECT_DIR"/bootstrap.sh
-    "$SOURCES_DIR/$PROJECT_DIR"/configure "${conf[@]}"
-fi
-
-make -j
-make install-strip

app/deps/sdl.sh

@@ -1,79 +0,0 @@
-#!/usr/bin/env bash
-set -ex
-DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
-cd "$DEPS_DIR"
-. common
-process_args "$@"
-
-VERSION=2.30.9
-FILENAME=SDL-$VERSION.tar.gz
-PROJECT_DIR=SDL-release-$VERSION
-SHA256SUM=682a055004081e37d81a7d4ce546c3ee3ef2e0e6a675ed2651e430ccd14eb407
-
-cd "$SOURCES_DIR"
-
-if [[ -d "$PROJECT_DIR" ]]
-then
-    echo "$PWD/$PROJECT_DIR" found
-else
-    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"
-cd "$BUILD_DIR/$PROJECT_DIR"
-
-export CFLAGS='-O2'
-export CXXFLAGS="$CFLAGS"
-
-if [[ -d "$DIRNAME" ]]
-then
-    echo "'$PWD/$HDIRNAME' already exists, not reconfigured"
-    cd "$DIRNAME"
-else
-    mkdir "$DIRNAME"
-    cd "$DIRNAME"
-
-    conf=(
-        --prefix="$INSTALL_DIR/$DIRNAME"
-    )
-
-    if [[ "$HOST" == linux ]]
-    then
-        conf+=(
-            --enable-video-wayland
-            --enable-video-x11
-        )
-    fi
-
-    if [[ "$LINK_TYPE" == static ]]
-    then
-        conf+=(
-            --enable-static
-            --disable-shared
-        )
-    else
-        conf+=(
-            --disable-static
-            --enable-shared
-        )
-    fi
-
-    if [[ "$BUILD_TYPE" == cross ]]
-    then
-        conf+=(
-            --host="$HOST_TRIPLET"
-        )
-    fi
-
-    "$SOURCES_DIR/$PROJECT_DIR"/configure "${conf[@]}"
-fi
-
-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

app/meson.build

@@ -4,54 +4,35 @@ src = [
     'src/adb/adb_device.c',
     'src/adb/adb_parser.c',
     'src/adb/adb_tunnel.c',
-    'src/audio_player.c',
-    'src/audio_regulator.c',
     'src/cli.c',
     'src/clock.c',
     'src/compat.c',
     'src/control_msg.c',
     'src/controller.c',
     'src/decoder.c',
-    'src/delay_buffer.c',
     'src/demuxer.c',
     'src/device_msg.c',
-    'src/display.c',
-    'src/events.c',
     'src/icon.c',
     'src/file_pusher.c',
     'src/fps_counter.c',
     'src/frame_buffer.c',
     'src/input_manager.c',
-    'src/keyboard_sdk.c',
-    'src/mouse_capture.c',
-    'src/mouse_sdk.c',
+    'src/keyboard_inject.c',
+    'src/mouse_inject.c',
     'src/opengl.c',
     'src/options.c',
-    'src/packet_merger.c',
     'src/receiver.c',
     'src/recorder.c',
     'src/scrcpy.c',
     'src/screen.c',
     'src/server.c',
     'src/version.c',
-    'src/hid/hid_gamepad.c',
-    'src/hid/hid_keyboard.c',
-    'src/hid/hid_mouse.c',
-    'src/trait/frame_source.c',
-    'src/trait/packet_source.c',
-    'src/uhid/gamepad_uhid.c',
-    'src/uhid/keyboard_uhid.c',
-    'src/uhid/mouse_uhid.c',
-    'src/uhid/uhid_output.c',
+    'src/video_buffer.c',
     'src/util/acksync.c',
-    'src/util/audiobuf.c',
-    'src/util/average.c',
-    'src/util/env.c',
     'src/util/file.c',
     'src/util/intmap.c',
     'src/util/intr.c',
     'src/util/log.c',
-    'src/util/memory.c',
     'src/util/net.c',
     'src/util/net_intr.c',
     'src/util/process.c',
@@ -62,7 +43,6 @@ src = [
     'src/util/term.c',
     'src/util/thread.c',
     'src/util/tick.c',
-    'src/util/timeout.c',
 ]
 
 conf = configuration_data()
@@ -99,9 +79,8 @@ usb_support = get_option('usb')
 if usb_support
     src += [
         'src/usb/aoa_hid.c',
-        'src/usb/gamepad_aoa.c',
-        'src/usb/keyboard_aoa.c',
-        'src/usb/mouse_aoa.c',
+        'src/usb/hid_keyboard.c',
+        'src/usb/hid_mouse.c',
         'src/usb/scrcpy_otg.c',
         'src/usb/screen_otg.c',
         'src/usb/usb.c',
@@ -110,26 +89,81 @@ endif
 
 cc = meson.get_compiler('c')
 
-static = get_option('static')
+crossbuild_windows = meson.is_cross_build() and host_machine.system() == 'windows'
 
-dependencies = [
-    dependency('libavformat', version: '>= 57.33', static: static),
-    dependency('libavcodec', version: '>= 57.37', static: static),
-    dependency('libavutil', static: static),
-    dependency('libswresample', static: static),
-    dependency('sdl2', version: '>= 2.0.5', static: static),
-]
+if not crossbuild_windows
 
-if v4l2_support
-    dependencies += dependency('libavdevice', static: static)
-endif
+    # native build
+    dependencies = [
+        dependency('libavformat', version: '>= 57.33'),
+        dependency('libavcodec', version: '>= 57.37'),
+        dependency('libavutil'),
+        dependency('sdl2', version: '>= 2.0.5'),
+    ]
+
+    if v4l2_support
+        dependencies += dependency('libavdevice')
+    endif
+
+    if usb_support
+        dependencies += dependency('libusb-1.0')
+    endif
+
+else
+    # cross-compile mingw32 build (from Linux to Windows)
+    prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
+    sdl2_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_sdl2 + '/bin'
+    sdl2_lib_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_sdl2 + '/lib'
+    sdl2_include_dir = 'prebuilt-deps/data/' + prebuilt_sdl2 + '/include'
+
+    sdl2 = declare_dependency(
+        dependencies: [
+            cc.find_library('SDL2', dirs: sdl2_bin_dir),
+            cc.find_library('SDL2main', dirs: sdl2_lib_dir),
+        ],
+        include_directories: include_directories(sdl2_include_dir)
+    )
+
+    prebuilt_ffmpeg = meson.get_cross_property('prebuilt_ffmpeg')
+    ffmpeg_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_ffmpeg + '/bin'
+    ffmpeg_include_dir = 'prebuilt-deps/data/' + prebuilt_ffmpeg + '/include'
+
+    # ffmpeg versions are different for win32 and win64 builds
+    ffmpeg_avcodec = meson.get_cross_property('ffmpeg_avcodec')
+    ffmpeg_avformat = meson.get_cross_property('ffmpeg_avformat')
+    ffmpeg_avutil = meson.get_cross_property('ffmpeg_avutil')
+
+    ffmpeg = declare_dependency(
+        dependencies: [
+            cc.find_library(ffmpeg_avcodec, dirs: ffmpeg_bin_dir),
+            cc.find_library(ffmpeg_avformat, dirs: ffmpeg_bin_dir),
+            cc.find_library(ffmpeg_avutil, dirs: ffmpeg_bin_dir),
+        ],
+        include_directories: include_directories(ffmpeg_include_dir)
+    )
+
+    prebuilt_libusb = meson.get_cross_property('prebuilt_libusb')
+    prebuilt_libusb_root = meson.get_cross_property('prebuilt_libusb_root')
+    libusb_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_libusb
+    libusb_include_dir = 'prebuilt-deps/data/' + prebuilt_libusb_root + '/include'
+
+    libusb = declare_dependency(
+        dependencies: [
+            cc.find_library('msys-usb-1.0', dirs: libusb_bin_dir),
+        ],
+        include_directories: include_directories(libusb_include_dir)
+    )
+
+    dependencies = [
+        ffmpeg,
+        sdl2,
+        libusb,
+        cc.find_library('mingw32')
+    ]
 
-if usb_support
-    dependencies += dependency('libusb-1.0', static: static)
 endif
 
 if host_machine.system() == 'windows'
-    dependencies += cc.find_library('mingw32')
     dependencies += cc.find_library('ws2_32')
 endif
 
@@ -139,7 +173,6 @@ check_functions = [
     'vasprintf',
     'nrand48',
     'jrand48',
-    'reallocarray',
 ]
 
 foreach f : check_functions
@@ -167,9 +200,16 @@ conf.set('PORTABLE', get_option('portable'))
 conf.set('DEFAULT_LOCAL_PORT_RANGE_FIRST', '27183')
 conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')
 
+# the default video bitrate, in bits/second
+# overridden by option --bit-rate
+conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
+
 # run a server debugger and wait for a client to be attached
 conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
 
+# select the debugger method ('old' for Android < 9, 'new' for Android >= 9)
+conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == 'new')
+
 # enable V4L2 support (linux only)
 conf.set('HAVE_V4L2', v4l2_support)
 
@@ -223,10 +263,8 @@ if get_option('buildtype') == 'debug'
         ['test_binary', [
             'tests/test_binary.c',
         ]],
-        ['test_audiobuf', [
-            'tests/test_audiobuf.c',
-            'src/util/audiobuf.c',
-            'src/util/memory.c',
+        ['test_cbuf', [
+            'tests/test_cbuf.c',
         ]],
         ['test_cli', [
             'tests/test_cli.c',
@@ -238,6 +276,10 @@ if get_option('buildtype') == 'debug'
             'src/util/strbuf.c',
             'src/util/term.c',
         ]],
+        ['test_clock', [
+            'tests/test_clock.c',
+            'src/clock.c',
+        ]],
         ['test_control_msg_serialize', [
             'tests/test_control_msg_serialize.c',
             'src/control_msg.c',
@@ -248,9 +290,8 @@ if get_option('buildtype') == 'debug'
             'tests/test_device_msg_deserialize.c',
             'src/device_msg.c',
         ]],
-        ['test_orientation', [
-            'tests/test_orientation.c',
-            'src/options.c',
+        ['test_queue', [
+            'tests/test_queue.c',
         ]],
         ['test_strbuf', [
             'tests/test_strbuf.c',
@@ -261,18 +302,13 @@ if get_option('buildtype') == 'debug'
             'src/util/str.c',
             'src/util/strbuf.c',
         ]],
-        ['test_vecdeque', [
-            'tests/test_vecdeque.c',
-            'src/util/memory.c',
-        ]],
         ['test_vector', [
             'tests/test_vector.c',
         ]],
     ]
 
     foreach t : tests
-        sources = t[1] + ['src/compat.c']
-        exe = executable(t[0], sources,
+        exe = executable(t[0], t[1],
                          include_directories: src_dir,
                          dependencies: dependencies,
                          c_args: ['-DSDL_MAIN_HANDLED', '-DSC_TEST'])

app/prebuilt-deps/.gitignore

@@ -0,0 +1 @@
+/data

app/prebuilt-deps/common

@@ -0,0 +1,22 @@
+PREBUILT_DATA_DIR=data
+
+checksum() {
+    local file="$1"
+    local sum="$2"
+    echo "$file: verifying checksum..."
+    echo "$sum  $file" | sha256sum -c
+}
+
+get_file() {
+    local url="$1"
+    local file="$2"
+    local sum="$3"
+    if [[ -f "$file" ]]
+    then
+        echo "$file: found"
+    else
+        echo "$file: not found, downloading..."
+        wget "$url" -O "$file"
+    fi
+    checksum "$file" "$sum"
+}

app/prebuilt-deps/prepare-adb.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -e
+DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DIR"
+. common
+mkdir -p "$PREBUILT_DATA_DIR"
+cd "$PREBUILT_DATA_DIR"
+
+DEP_DIR=platform-tools-33.0.3
+
+FILENAME=platform-tools_r33.0.3-windows.zip
+SHA256SUM=1e59afd40a74c5c0eab0a9fad3f0faf8a674267106e0b19921be9f67081808c2
+
+if [[ -d "$DEP_DIR" ]]
+then
+    echo "$DEP_DIR" found
+    exit 0
+fi
+
+get_file "https://dl.google.com/android/repository/$FILENAME" \
+    "$FILENAME" "$SHA256SUM"
+
+mkdir "$DEP_DIR"
+cd "$DEP_DIR"
+
+ZIP_PREFIX=platform-tools
+unzip "../$FILENAME" \
+    "$ZIP_PREFIX"/AdbWinApi.dll \
+    "$ZIP_PREFIX"/AdbWinUsbApi.dll \
+    "$ZIP_PREFIX"/adb.exe
+mv "$ZIP_PREFIX"/* .
+rmdir "$ZIP_PREFIX"

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

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

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

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

app/prebuilt-deps/prepare-libusb.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -e
+DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DIR"
+. common
+mkdir -p "$PREBUILT_DATA_DIR"
+cd "$PREBUILT_DATA_DIR"
+
+DEP_DIR=libusb-1.0.26
+
+FILENAME=libusb-1.0.26-binaries.7z
+SHA256SUM=9c242696342dbde9cdc47239391f71833939bf9f7aa2bbb28cdaabe890465ec5
+
+if [[ -d "$DEP_DIR" ]]
+then
+    echo "$DEP_DIR" found
+    exit 0
+fi
+
+get_file "https://github.com/libusb/libusb/releases/download/v1.0.26/$FILENAME" "$FILENAME" "$SHA256SUM"
+
+mkdir "$DEP_DIR"
+cd "$DEP_DIR"
+
+# include/ is the same in all folders of the archive
+7z x "../$FILENAME" \
+    libusb-1.0.26-binaries/libusb-MinGW-Win32/bin/msys-usb-1.0.dll \
+    libusb-1.0.26-binaries/libusb-MinGW-x64/bin/msys-usb-1.0.dll \
+    libusb-1.0.26-binaries/libusb-MinGW-x64/include/
+
+mv libusb-1.0.26-binaries/libusb-MinGW-Win32/bin MinGW-Win32
+mv libusb-1.0.26-binaries/libusb-MinGW-x64/bin MinGW-x64
+mv libusb-1.0.26-binaries/libusb-MinGW-x64/include .
+rm -rf libusb-1.0.26-binaries

app/prebuilt-deps/prepare-sdl.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -e
+DIR=$(dirname ${BASH_SOURCE[0]})
+cd "$DIR"
+. common
+mkdir -p "$PREBUILT_DATA_DIR"
+cd "$PREBUILT_DATA_DIR"
+
+DEP_DIR=SDL2-2.26.1
+
+FILENAME=SDL2-devel-2.26.1-mingw.tar.gz
+SHA256SUM=aa43e1531a89551f9f9e14b27953a81d4ac946a9e574b5813cd0f2b36e83cc1c
+
+if [[ -d "$DEP_DIR" ]]
+then
+    echo "$DEP_DIR" found
+    exit 0
+fi
+
+get_file "https://libsdl.org/release/$FILENAME" "$FILENAME" "$SHA256SUM"
+
+mkdir "$DEP_DIR"
+cd "$DEP_DIR"
+
+TAR_PREFIX="$DEP_DIR" # root directory inside the tar has the same name
+tar xf "../$FILENAME" --strip-components=1 \
+    "$TAR_PREFIX"/i686-w64-mingw32/bin/SDL2.dll \
+    "$TAR_PREFIX"/i686-w64-mingw32/include/ \
+    "$TAR_PREFIX"/i686-w64-mingw32/lib/ \
+    "$TAR_PREFIX"/x86_64-w64-mingw32/bin/SDL2.dll \
+    "$TAR_PREFIX"/x86_64-w64-mingw32/include/ \
+    "$TAR_PREFIX"/x86_64-w64-mingw32/lib/ \

app/scrcpy-windows.rc

@@ -13,7 +13,7 @@ BEGIN
       VALUE "LegalCopyright", "Romain Vimont, Genymobile"
       VALUE "OriginalFilename", "scrcpy.exe"
       VALUE "ProductName", "scrcpy"
-      VALUE "ProductVersion", "3.0.2"
+      VALUE "ProductVersion", "1.25"
     END
   END
   BLOCK "VarFileInfo"

app/scrcpy.1

@@ -20,128 +20,28 @@ provides display and control of Android devices connected on USB (or over TCP/IP
 Make scrcpy window always on top (above other windows).
 
 .TP
-.BI "\-\-angle " degrees
-Rotate the video content by a custom angle, in degrees (clockwise).
+.BI "\-b, \-\-bit\-rate " value
+Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
+
+Default is 8000000.
 
 .TP
-.BI "\-\-audio\-bit\-rate " value
-Encode the audio at the given bit rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
-
-Default is 128K (128000).
-
-.TP
-.BI "\-\-audio\-buffer " ms
-Configure the audio buffering delay (in milliseconds).
-
-Lower values decrease the latency, but increase the likelihood of buffer underrun (causing audio glitches).
-
-Default is 50.
-
-.TP
-.BI "\-\-audio\-codec " name
-Select an audio codec (opus, aac, flac or raw).
-
-Default is opus.
-
-.TP
-.BI "\-\-audio\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
-Set a list of comma-separated key:type=value options for the device audio encoder.
+.BI "\-\-codec\-options " key[:type]=value[,...]
+Set a list of comma-separated key:type=value options for the device encoder.
 
 The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
 
-The list of possible codec options is available in the Android documentation:
-
-<https://d.android.com/reference/android/media/MediaFormat>
-
-.TP
-.B \-\-audio\-dup
-Duplicate audio (capture and keep playing on the device).
-
-This feature is only available with --audio-source=playback.
-
-.TP
-.BI "\-\-audio\-encoder " name
-Use a specific MediaCodec audio encoder (depending on the codec provided by \fB\-\-audio\-codec\fR).
-
-The available encoders can be listed by \fB\-\-list\-encoders\fR.
-
-.TP
-.BI "\-\-audio\-source " source
-Select the audio source (output, mic or 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.
-
-.TP
-.BI "\-\-audio\-output\-buffer " ms
-Configure the size of the SDL audio output buffer (in milliseconds).
-
-If you get "robotic" audio playback, you should test with a higher value (10). Do not change this setting otherwise.
-
-Default is 5.
-
-.TP
-.BI "\-b, \-\-video\-bit\-rate " value
-Encode the video at the given bit rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
-
-Default is 8M (8000000).
-
-.TP
-.BI "\-\-camera\-ar " ar
-Select the camera size by its aspect ratio (+/- 10%).
-
-Possible values are "sensor" (use the camera sensor aspect ratio), "\fInum\fR:\fIden\fR" (e.g. "4:3") and "\fIvalue\fR" (e.g. "1.6").
-
-.TP
-.BI "\-\-camera\-facing " facing
-Select the device camera by its facing direction.
-
-Possible values are "front", "back" and "external".
-
-.TP
-.BI "\-\-camera\-fps " fps
-Specify the camera capture frame rate.
-
-If not specified, Android's default frame rate (30 fps) is used.
-
-.TP
-.B \-\-camera\-high\-speed
-Enable high-speed camera capture mode.
-
-This mode is restricted to specific resolutions and frame rates, listed by \fB\-\-list\-camera\-sizes\fR.
-
-.TP
-.BI "\-\-camera\-id " id
-Specify the device camera id to mirror.
-
-The available camera ids can be listed by \fB\-\-list\-cameras\fR.
-
-.TP
-.BI "\-\-camera\-size " width\fRx\fIheight
-Specify an explicit camera capture size.
-
-.TP
-.BI "\-\-capture\-orientation " value
-Possible values are 0, 90, 180, 270, flip0, flip90, flip180 and flip270, possibly prefixed by '@'.
-
-The number represents the clockwise rotation in degrees; the "flip" keyword applies a horizontal flip before the rotation.
-
-If a leading '@' is passed (@90) for display capture, then the rotation is locked, and is relative to the natural device orientation.
-
-If '@' is passed alone, then the rotation is locked to the initial device orientation.
-
-Default is 0.
+The list of possible codec options is available in the Android documentation
+.UR https://d.android.com/reference/android/media/MediaFormat
+.UE .
 
 .TP
 .BI "\-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
 Crop the device screen on the server.
 
-The values are expressed in the device natural orientation (typically, portrait for a phone, landscape for a tablet).
+The values are expressed in the device natural orientation (typically, portrait for a phone, landscape for a tablet). Any
+.B \-\-max\-size
+value is computed on the cropped size.
 
 .TP
 .B \-d, \-\-select\-usb
@@ -150,24 +50,23 @@ Use USB device (if there is exactly one, like adb -d).
 Also see \fB\-e\fR (\fB\-\-select\-tcpip\fR).
 
 .TP
-.BI "\-\-disable\-screensaver"
+.BI "\-\-disable-screensaver"
 Disable screensaver while scrcpy is running.
 
 .TP
-.BI "\-\-display\-id " id
-Specify the device display id to mirror.
+.BI "\-\-display " id
+Specify the display id to mirror.
 
-The available display ids can be listed by \fB\-\-list\-displays\fR.
+The list of possible display ids can be listed by "adb shell dumpsys display"
+(search "mDisplayId=" in the output).
 
 Default is 0.
 
 .TP
-.BI "\-\-display\-orientation " value
-Set the initial display orientation.
+.BI "\-\-display\-buffer ms
+Add a buffering delay (in milliseconds) before displaying. This increases latency to compensate for jitter.
 
-Possible values are 0, 90, 180, 270, flip0, flip90, flip180 and flip270. The number represents the clockwise rotation in degrees; the "flip" keyword applies a horizontal flip before the rotation.
-
-Default is 0.
+Default is 0 (no buffering).
 
 .TP
 .B \-e, \-\-select\-tcpip
@@ -176,58 +75,40 @@ Use TCP/IP device (if there is exactly one, like adb -e).
 Also see \fB\-d\fR (\fB\-\-select\-usb\fR).
 
 .TP
-.B \-f, \-\-fullscreen
-Start in fullscreen.
+.BI "\-\-encoder " name
+Use a specific MediaCodec encoder (must be a H.264 encoder).
 
 .TP
 .B \-\-force\-adb\-forward
 Do not attempt to use "adb reverse" to connect to the device.
 
 .TP
-.B \-G
-Same as \fB\-\-gamepad=uhid\fR, or \fB\-\-keyboard=aoa\fR if \fB\-\-otg\fR is set.
+.B \-\-forward\-all\-clicks
+By default, right-click triggers BACK (or POWER on) and middle-click triggers HOME. This option disables these shortcuts and forward the clicks to the device instead.
 
 .TP
-.BI "\-\-gamepad " mode
-Select how to send gamepad inputs to the device.
+.B \-f, \-\-fullscreen
+Start in fullscreen.
 
-Possible values are "disabled", "uhid" and "aoa":
-
- - "disabled" does not send gamepad inputs to the device.
- - "uhid" simulates physical HID gamepads using the Linux HID kernel module on the device.
- - "aoa" simulates physical HID gamepads using the AOAv2 protocol. It may only work over USB.
-
-Also see \fB\-\-keyboard\f and R\fB\-\-mouse\fR.
 .TP
 .B \-h, \-\-help
 Print this help.
 
 .TP
-.B \-K
-Same as \fB\-\-keyboard=uhid\fR, or \fB\-\-keyboard=aoa\fR if \fB\-\-otg\fR is set.
+.B \-K, \-\-hid\-keyboard
+Simulate a physical keyboard by using HID over AOAv2.
 
-.TP
-.BI "\-\-keyboard " mode
-Select how to send keyboard inputs to the device.
+This provides a better experience for IME users, and allows to generate non-ASCII characters, contrary to the default injection method.
 
-Possible values are "disabled", "sdk", "uhid" and "aoa":
+It may only work over USB.
 
- - "disabled" does not send keyboard inputs to the device.
- - "sdk" uses the Android system API to deliver keyboard events to applications.
- - "uhid" simulates a physical HID keyboard using the Linux HID kernel module on the device.
- - "aoa" simulates a physical HID keyboard using the AOAv2 protocol. It may only work over USB.
-
-For "uhid" and "aoa", the keyboard layout must be configured (once and for all) on the device, via Settings -> System -> Languages and input -> Physical keyboard. This settings page can be started directly using the shortcut MOD+k (except in OTG mode), or by executing:
+The keyboard layout must be configured (once and for all) on the device, via Settings -> System -> Languages and input -> Physical keyboard. This settings page can be started directly:
 
     adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
 
-This option is only available when the HID keyboard is enabled (or a physical keyboard is connected).
+However, the option is only available when the HID keyboard is enabled (or a physical keyboard is connected).
 
-Also see \fB\-\-mouse\fR and \fB\-\-gamepad\fR.
-
-.TP
-.B \-\-kill\-adb\-on\-close
-Kill adb when scrcpy terminates.
+Also see \fB\-\-hid\-mouse\fR.
 
 .TP
 .B \-\-legacy\-paste
@@ -236,24 +117,16 @@ Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+S
 This is a workaround for some devices not behaving as expected when setting the device clipboard programmatically.
 
 .TP
-.B \-\-list\-apps
-List Android apps installed on the device.
+.BI "\-\-lock\-video\-orientation[=value]
+Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees rotation counterclockwise.
+
+Default is "unlocked".
+
+Passing the option without argument is equivalent to passing "initial".
 
 .TP
-.B \-\-list\-camera\-sizes
-List the valid camera capture sizes.
-
-.TP
-.B \-\-list\-cameras
-List cameras available on the device.
-
-.TP
-.B \-\-list\-encoders
-List video and audio encoders available on the device.
-
-.TP
-.B \-\-list\-displays
-List displays available on the device.
+.BI "\-\-max\-fps " value
+Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
 
 .TP
 .BI "\-m, \-\-max\-size " value
@@ -262,78 +135,16 @@ Limit both the width and height of the video to \fIvalue\fR. The other dimension
 Default is 0 (unlimited).
 
 .TP
-.B \-M
-Same as \fB\-\-mouse=uhid\fR, or \fB\-\-mouse=aoa\fR if \fB\-\-otg\fR is set.
+.B \-M, \-\-hid\-mouse
+Simulate a physical mouse by using HID over AOAv2.
 
-.TP
-.BI "\-\-max\-fps " value
-Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
-
-.TP
-.BI "\-\-mouse " mode
-Select how to send mouse inputs to the device.
-
-Possible values are "disabled", "sdk", "uhid" and "aoa":
-
- - "disabled" does not send mouse inputs to the device.
- - "sdk" uses the Android system API to deliver mouse events to applications.
- - "uhid" simulates a physical HID mouse using the Linux HID kernel module on the device.
- - "aoa" simulates a physical mouse using the AOAv2 protocol. It may only work over USB.
-
-In "uhid" and "aoa" modes, the computer mouse is captured to control the device directly (relative mouse mode).
+In this mode, the computer mouse is captured to control the device directly (relative mouse mode).
 
 LAlt, LSuper or RSuper toggle the capture mode, to give control of the mouse back to the computer.
 
-Also see \fB\-\-keyboard\fR and \fB\-\-gamepad\fR.
+It may only work over USB.
 
-.TP
-.BI "\-\-mouse\-bind " xxxx[:xxxx]
-Configure bindings of secondary clicks.
-
-The argument must be one or two sequences (separated by ':') of exactly 4 characters, one for each secondary click (in order: right click, middle click, 4th click, 5th click).
-
-The first sequence defines the primary bindings, used when a mouse button is pressed alone. The second sequence defines the secondary bindings, used when a mouse button is pressed while the Shift key is held.
-
-If the second sequence of bindings is omitted, then it is the same as the first one.
-
-Each character must be one of the following:
-
- - '+': forward the click to the device
- - '-': ignore the click
- - 'b': trigger shortcut BACK (or turn screen on if off)
- - 'h': trigger shortcut HOME
- - 's': trigger shortcut APP_SWITCH
- - 'n': trigger shortcut "expand notification panel"
-
-Default is 'bhsn:++++' for SDK mouse, and '++++:bhsn' for AOA and UHID.
-
-
-.TP
-.B \-n, \-\-no\-control
-Disable device control (mirror the device in read\-only).
-
-.TP
-.B \-N, \-\-no\-playback
-Disable video and audio playback on the computer (equivalent to \fB\-\-no\-video\-playback \-\-no\-audio\-playback\fR).
-
-.TP
-\fB\-\-new\-display\fR[=[\fIwidth\fRx\fIheight\fR][/\fIdpi\fR]]
-Create a new display with the specified resolution and density. If not provided, they default to the main display dimensions and DPI.
-
-Examples:
-
-    \-\-new\-display=1920x1080
-    \-\-new\-display=1920x1080/420
-    \-\-new\-display         # main display size and density
-    \-\-new\-display=/240    # main display size and 240 dpi
-
-.TP
-.B \-\-no\-audio
-Disable audio forwarding.
-
-.TP
-.B \-\-no\-audio\-playback
-Disable audio playback on the computer.
+Also see \fB\-\-hid\-keyboard\fR.
 
 .TP
 .B \-\-no\-cleanup
@@ -353,6 +164,14 @@ By default, on MediaCodec error, scrcpy automatically tries again with a lower d
 
 This option disables this behavior.
 
+.TP
+.B \-n, \-\-no\-control
+Disable device control (mirror the device in read\-only).
+
+.TP
+.B \-N, \-\-no\-display
+Do not display device (only when screen recording is enabled).
+
 .TP
 .B \-\-no\-key\-repeat
 Do not forward repeated key events when a key is held down.
@@ -361,40 +180,10 @@ Do not forward repeated key events when a key is held down.
 .B \-\-no\-mipmaps
 If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then mipmaps are automatically generated to improve downscaling quality. This option disables the generation of mipmaps.
 
-.TP
-.B \-\-no\-mouse\-hover
-Do not forward mouse hover (mouse motion without any clicks) events.
-
 .TP
 .B \-\-no\-power\-on
 Do not power on the device on start.
 
-.TP
-.B \-\-no\-vd\-destroy\-content
-Disable virtual display "destroy content on removal" flag.
-
-With this option, when the virtual display is closed, the running apps are moved to the main display rather than being destroyed.
-
-.TP
-.B \-\-no\-vd\-system\-decorations
-Disable virtual display system decorations flag.
-
-.TP
-.B \-\-no\-video
-Disable video forwarding.
-
-.TP
-.B \-\-no\-video\-playback
-Disable video playback on the computer.
-
-.TP
-.B \-\-no\-window
-Disable scrcpy window. Implies --no-video-playback and --no-control.
-
-.TP
-.BI "\-\-orientation " value
-Same as --display-orientation=value --record-orientation=value.
-
 .TP
 .B \-\-otg
 Run in OTG mode: simulate physical keyboard and mouse, as if the computer keyboard and mouse were plugged directly to the device via an OTG cable.
@@ -407,24 +196,14 @@ If any of \fB\-\-hid\-keyboard\fR or \fB\-\-hid\-mouse\fR is set, only enable ke
 
 It may only work over USB.
 
-See \fB\-\-keyboard\fR, \fB\-\-mouse\fR and \fB\-\-gamepad\fR.
+See \fB\-\-hid\-keyboard\fR and \fB\-\-hid\-mouse\fR.
 
 .TP
-.BI "\-p, \-\-port " port\fR[:\fIport\fR]
+.BI "\-p, \-\-port " port[:port]
 Set the TCP port (range) used by the client to listen.
 
 Default is 27183:27199.
 
-.TP
-\fB\-\-pause\-on\-exit\fR[=\fImode\fR]
-Configure pause on exit. Possible values are "true" (always pause on exit), "false" (never pause on exit) and "if-error" (pause only if an error occurred).
-
-This is useful to prevent the terminal window from automatically closing, so that error messages can be read.
-
-Default is "false".
-
-Passing the option without argument is equivalent to passing "true".
-
 .TP
 .B \-\-power\-off\-on\-close
 Turn the device screen off when closing scrcpy.
@@ -446,6 +225,10 @@ Set the target directory for pushing files to the device by drag & drop. It is p
 
 Default is "/sdcard/Download/".
 
+.TP
+.B \-\-raw\-key\-events
+Inject key events for all input keys, and ignore text events.
+
 .TP
 .BI "\-r, \-\-record " file
 Record screen to
@@ -453,23 +236,11 @@ Record screen to
 
 The format is determined by the
 .B \-\-record\-format
-option if set, or by the file extension.
-
-.TP
-.B \-\-raw\-key\-events
-Inject key events for all input keys, and ignore text events.
+option if set, or by the file extension (.mp4 or .mkv).
 
 .TP
 .BI "\-\-record\-format " format
-Force recording format (mp4, mkv, m4a, mka, opus, aac, flac or wav).
-
-.TP
-.BI "\-\-record\-orientation " value
-Set the record orientation.
-
-Possible values are 0, 90, 180 and 270. The number represents the clockwise rotation in degrees.
-
-Default is 0.
+Force recording format (either mp4 or mkv).
 
 .TP
 .BI "\-\-render\-driver " name
@@ -477,45 +248,38 @@ Request SDL to use the given render driver (this is just a hint).
 
 Supported names are currently "direct3d", "opengl", "opengles2", "opengles", "metal" and "software".
 
-<https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER>
+.UR https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER
+.UE
 
 .TP
-.B \-\-require\-audio
-By default, scrcpy mirrors only the video if audio capture fails on the device. This option makes scrcpy fail if audio is enabled but does not work.
+.BI "\-\-rotation " value
+Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each increment adds a 90 degrees rotation counterclockwise.
 
 .TP
 .BI "\-s, \-\-serial " number
 The device serial number. Mandatory only if several devices are connected to adb.
 
 .TP
-.B \-S, \-\-turn\-screen\-off
-Turn the device screen off immediately.
-
-.TP
-.BI "\-\-shortcut\-mod " key\fR[+...]][,...]
+.BI "\-\-shortcut\-mod " key[+...]][,...]
 Specify the modifiers to use for scrcpy shortcuts. Possible keys are "lctrl", "rctrl", "lalt", "ralt", "lsuper" and "rsuper".
 
-Several shortcut modifiers can be specified, separated by ','.
+A shortcut can consist in several keys, separated by '+'. Several shortcuts can be specified, separated by ','.
 
-For example, to use either LCtrl or LSuper for scrcpy shortcuts, pass "lctrl,lsuper".
+For example, to use either LCtrl+LAlt or LSuper for scrcpy shortcuts, pass "lctrl+lalt,lsuper".
 
 Default is "lalt,lsuper" (left-Alt or left-Super).
 
 .TP
-.BI "\-\-start\-app " name
-Start an Android app, by its exact package name.
+.BI "\-\-tcpip[=ip[:port]]
+Configure and reconnect the device over TCP/IP.
 
-Add a '?' prefix to select an app whose name starts with the given name, case-insensitive (retrieving app names on the device may take some time):
+If a destination address is provided, then scrcpy connects to this address before starting. The device must listen on the given TCP port (default is 5555).
 
-    scrcpy --start-app=?firefox
+If no destination address is provided, then scrcpy attempts to find the IP address and adb port of the current device (typically connected over USB), enables TCP/IP mode if necessary, then connects to this address before starting.
 
-Add a '+' prefix to force-stop before starting the app:
-
-    scrcpy --new-display --start-app=+org.mozilla.firefox
-
-Both prefixes can be used, in that order:
-
-    scrcpy --start-app=+?firefox
+.TP
+.B \-S, \-\-turn\-screen\-off
+Turn the device screen off immediately.
 
 .TP
 .B \-t, \-\-show\-touches
@@ -523,35 +287,31 @@ Enable "show touches" on start, restore the initial value on exit.
 
 It only shows physical touches (not clicks from scrcpy).
 
-.TP
-.BI "\-\-tcpip\fR[=[+]\fIip\fR[:\fIport\fR]]
-Configure and connect the device over TCP/IP.
-
-If a destination address is provided, then scrcpy connects to this address before starting. The device must listen on the given TCP port (default is 5555).
-
-If no destination address is provided, then scrcpy attempts to find the IP address and adb port of the current device (typically connected over USB), enables TCP/IP mode if necessary, then connects to this address before starting.
-
-Prefix the address with a '+' to force a reconnection.
-
-.TP
-.BI "\-\-time\-limit " seconds
-Set the maximum mirroring time, in seconds.
-
 .TP
 .BI "\-\-tunnel\-host " ip
-Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables \fB\-\-force\-adb\-forward\fR.
+Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
 
 Default is localhost.
 
 .TP
 .BI "\-\-tunnel\-port " port
-Set the TCP port of the adb tunnel to reach the scrcpy server. This option automatically enables \fB\-\-force\-adb\-forward\fR.
+Set the TCP port of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
 
 Default is 0 (not forced): the local port used for establishing the tunnel will be used.
 
 .TP
-.B \-v, \-\-version
-Print the version of scrcpy.
+.BI "\-\-v4l2-sink " /dev/videoN
+Output to v4l2loopback device.
+
+It requires to lock the video orientation (see \fB\-\-lock\-video\-orientation\fR).
+
+.TP
+.BI "\-\-v4l2-buffer " ms
+Add a buffering delay (in milliseconds) before pushing frames. This increases latency to compensate for jitter.
+
+This option is similar to \fB\-\-display\-buffer\fR, but specific to V4L2 sink.
+
+Default is 0 (no buffering).
 
 .TP
 .BI "\-V, \-\-verbosity " value
@@ -560,54 +320,8 @@ Set the log level ("verbose", "debug", "info", "warn" or "error").
 Default is "info" for release builds, "debug" for debug builds.
 
 .TP
-.BI "\-\-v4l2-sink " /dev/videoN
-Output to v4l2loopback device.
-
-.TP
-.BI "\-\-v4l2-buffer " ms
-Add a buffering delay (in milliseconds) before pushing frames. This increases latency to compensate for jitter.
-
-This option is similar to \fB\-\-video\-buffer\fR, but specific to V4L2 sink.
-
-Default is 0 (no buffering).
-
-.TP
-.BI "\-\-video\-buffer " ms
-Add a buffering delay (in milliseconds) before displaying video frames.
-
-This increases latency to compensate for jitter.
-
-Default is 0 (no buffering).
-
-.TP
-.BI "\-\-video\-codec " name
-Select a video codec (h264, h265 or av1).
-
-Default is h264.
-
-.TP
-.BI "\-\-video\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
-Set a list of comma-separated key:type=value options for the device video encoder.
-
-The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
-
-The list of possible codec options is available in the Android documentation:
-
-<https://d.android.com/reference/android/media/MediaFormat>
-
-.TP
-.BI "\-\-video\-encoder " name
-Use a specific MediaCodec video encoder (depending on the codec provided by \fB\-\-video\-codec\fR).
-
-The available encoders can be listed by \fB\-\-list\-encoders\fR.
-
-.TP
-.BI "\-\-video\-source " source
-Select the video source (display or camera).
-
-Camera mirroring requires Android 12+.
-
-Default is display.
+.B \-v, \-\-version
+Print the version of scrcpy.
 
 .TP
 .B \-w, \-\-stay-awake
@@ -668,26 +382,6 @@ Rotate display left
 .B MOD+Right
 Rotate display right
 
-.TP
-.B MOD+Shift+Left, MOD+Shift+Right
-Flip display horizontally
-
-.TP
-.B MOD+Shift+Up, MOD+Shift+Down
-Flip display vertically
-
-.TP
-.B MOD+z
-Pause or re-pause display
-
-.TP
-.B MOD+Shift+z
-Unpause display
-
-.TP
-.B MOD+Shift+r
-Reset video capture/encoding
-
 .TP
 .B MOD+g
 Resize window to 1:1 (pixel\-perfect)
@@ -764,25 +458,13 @@ Copy computer clipboard to device, then paste (inject PASTE keycode, Android >=
 .B MOD+Shift+v
 Inject computer clipboard text as a sequence of key events
 
-.TP
-.B MOD+k
-Open keyboard settings on the device (for HID keyboard only)
-
 .TP
 .B MOD+i
 Enable/disable FPS counter (print frames/second in logs)
 
 .TP
 .B Ctrl+click-and-move
-Pinch-to-zoom and rotate from the center of the screen
-
-.TP
-.B Shift+click-and-move
-Tilt vertically (slide with 2 fingers)
-
-.TP
-.B Ctrl+Shift+click-and-move
-Tilt horizontally (slide with 2 fingers)
+Pinch-to-zoom from the center of the screen
 
 .TP
 .B Drag & drop APK file
@@ -801,7 +483,7 @@ Path to adb.
 
 .TP
 .B ANDROID_SERIAL
-Device serial to use if no selector (\fB-s\fR, \fB-d\fR, \fB-e\fR or \fB\-\-tcpip=\fIaddr\fR) is specified.
+Device serial to use if no selector (-s, -d, -e or --tcpip=<addr>) is specified.
 
 .TP
 .B SCRCPY_ICON_PATH
@@ -824,14 +506,23 @@ for the Debian Project (and may be used by others).
 
 
 .SH "REPORTING BUGS"
-Report bugs to <https://github.com/Genymobile/scrcpy/issues>.
+Report bugs to
+.UR https://github.com/Genymobile/scrcpy/issues
+.UE .
 
 .SH COPYRIGHT
-Copyright \(co 2018 Genymobile <https://www.genymobile.com>
+Copyright \(co 2018 Genymobile
+.UR https://www.genymobile.com
+Genymobile
+.UE
 
-Copyright \(co 2018\-2024 Romain Vimont <rom@rom1v.com>
+Copyright \(co 2018\-2022
+.MT rom@rom1v.com
+Romain Vimont
+.ME
 
 Licensed under the Apache License, Version 2.0.
 
 .SH WWW
-<https://github.com/Genymobile/scrcpy>
+.UR https://github.com/Genymobile/scrcpy
+.UE

app/src/adb/adb.c

@@ -7,7 +7,6 @@
 
 #include "adb_device.h"
 #include "adb_parser.h"
-#include "util/env.h"
 #include "util/file.h"
 #include "util/log.h"
 #include "util/process_intr.h"
@@ -25,45 +24,15 @@
  */
 #define SC_ADB_COMMAND(...) { sc_adb_get_executable(), __VA_ARGS__, NULL }
 
-static char *adb_executable;
-
-bool
-sc_adb_init(void) {
-    adb_executable = sc_get_env("ADB");
-    if (adb_executable) {
-        LOGD("Using adb: %s", adb_executable);
-        return true;
-    }
-
-#if !defined(PORTABLE) || defined(_WIN32)
-    adb_executable = strdup("adb");
-    if (!adb_executable) {
-        LOG_OOM();
-        return false;
-    }
-#else
-    // For portable builds, use the absolute path to the adb executable
-    // in the same directory as scrcpy (except on Windows, where "adb"
-    // is sufficient)
-    adb_executable = sc_file_get_local_path("adb");
-    if (!adb_executable) {
-        // Error already logged
-        return false;
-    }
-
-    LOGD("Using adb (portable): %s", adb_executable);
-#endif
-
-    return true;
-}
-
-void
-sc_adb_destroy(void) {
-    free(adb_executable);
-}
+static const char *adb_executable;
 
 const char *
 sc_adb_get_executable(void) {
+    if (!adb_executable) {
+        adb_executable = getenv("ADB");
+        if (!adb_executable)
+            adb_executable = "adb";
+    }
     return adb_executable;
 }
 
@@ -101,7 +70,7 @@ argv_to_string(const char *const *argv, char *buf, size_t bufsize) {
 }
 
 static void
-show_adb_installation_msg(void) {
+show_adb_installation_msg() {
 #ifndef __WINDOWS__
     static const struct {
         const char *binary;
@@ -249,16 +218,8 @@ sc_adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
                const char *device_socket_name, unsigned flags) {
     char local[4 + 5 + 1]; // tcp:PORT
     char remote[108 + 14 + 1]; // localabstract:NAME
-
-    int r = snprintf(local, sizeof(local), "tcp:%" PRIu16, local_port);
-    assert(r >= 0 && (size_t) r < sizeof(local));
-
-    r = snprintf(remote, sizeof(remote), "localabstract:%s",
-                 device_socket_name);
-    if (r < 0 || (size_t) r >= sizeof(remote)) {
-        LOGE("Could not write socket name");
-        return false;
-    }
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
 
     assert(serial);
     const char *const argv[] =
@@ -272,9 +233,7 @@ bool
 sc_adb_forward_remove(struct sc_intr *intr, const char *serial,
                       uint16_t local_port, unsigned flags) {
     char local[4 + 5 + 1]; // tcp:PORT
-    int r = snprintf(local, sizeof(local), "tcp:%" PRIu16, local_port);
-    assert(r >= 0 && (size_t) r < sizeof(local));
-    (void) r;
+    sprintf(local, "tcp:%" PRIu16, local_port);
 
     assert(serial);
     const char *const argv[] =
@@ -290,16 +249,8 @@ sc_adb_reverse(struct sc_intr *intr, const char *serial,
                unsigned flags) {
     char local[4 + 5 + 1]; // tcp:PORT
     char remote[108 + 14 + 1]; // localabstract:NAME
-    int r = snprintf(local, sizeof(local), "tcp:%" PRIu16, local_port);
-    assert(r >= 0 && (size_t) r < sizeof(local));
-
-    r = snprintf(remote, sizeof(remote), "localabstract:%s",
-                 device_socket_name);
-    if (r < 0 || (size_t) r >= sizeof(remote)) {
-        LOGE("Could not write socket name");
-        return false;
-    }
-
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
     assert(serial);
     const char *const argv[] =
         SC_ADB_COMMAND("-s", serial, "reverse", remote, local);
@@ -312,12 +263,7 @@ bool
 sc_adb_reverse_remove(struct sc_intr *intr, const char *serial,
                       const char *device_socket_name, unsigned flags) {
     char remote[108 + 14 + 1]; // localabstract:NAME
-    int r = snprintf(remote, sizeof(remote), "localabstract:%s",
-                     device_socket_name);
-    if (r < 0 || (size_t) r >= sizeof(remote)) {
-        LOGE("Device socket name too long");
-        return false;
-    }
+    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
 
     assert(serial);
     const char *const argv[] =
@@ -387,9 +333,7 @@ bool
 sc_adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
              unsigned flags) {
     char port_string[5 + 1];
-    int r = snprintf(port_string, sizeof(port_string), "%" PRIu16, port);
-    assert(r >= 0 && (size_t) r < sizeof(port_string));
-    (void) r;
+    sprintf(port_string, "%" PRIu16, port);
 
     assert(serial);
     const char *const argv[] =
@@ -412,7 +356,7 @@ sc_adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
 
     // "adb connect" always returns successfully (with exit code 0), even in
     // case of failure. As a workaround, check if its output starts with
-    // "connected" or "already connected".
+    // "connected".
     char buf[128];
     ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf) - 1);
     sc_pipe_close(pout);
@@ -429,8 +373,7 @@ sc_adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
     assert((size_t) r < sizeof(buf));
     buf[r] = '\0';
 
-    ok = !strncmp("connected", buf, sizeof("connected") - 1)
-        || !strncmp("already connected", buf, sizeof("already connected") - 1);
+    ok = !strncmp("connected", buf, sizeof("connected") - 1);
     if (!ok && !(flags & SC_ADB_NO_STDERR)) {
         // "adb connect" also prints errors to stdout. Since we capture it,
         // re-print the error to stderr.
@@ -490,7 +433,6 @@ sc_adb_list_devices(struct sc_intr *intr, unsigned flags,
         // in the buffer in a single pass
         LOGW("Result of \"adb devices -l\" does not fit in 64Kb. "
              "Please report an issue.");
-        free(buf);
         return false;
     }
 
@@ -686,8 +628,8 @@ sc_adb_select_device(struct sc_intr *intr,
         return false;
     }
 
-    LOGI("ADB device found:");
-    sc_adb_devices_log(SC_LOG_LEVEL_INFO, vec.data, vec.size);
+    LOGD("ADB device found:");
+    sc_adb_devices_log(SC_LOG_LEVEL_DEBUG, vec.data, vec.size);
 
     // Move devics into out_device (do not destroy device)
     sc_adb_device_move(out_device, device);
@@ -771,21 +713,3 @@ sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
 
     return sc_adb_parse_device_ip(buf);
 }
-
-uint16_t
-sc_adb_get_device_sdk_version(struct sc_intr *intr, const char *serial) {
-    char *sdk_version =
-        sc_adb_getprop(intr, serial, "ro.build.version.sdk", SC_ADB_SILENT);
-    if (!sdk_version) {
-        return 0;
-    }
-
-    long value;
-    bool ok = sc_str_parse_integer(sdk_version, &value);
-    free(sdk_version);
-    if (!ok || value < 0 || value > 0xFFFF) {
-        return 0;
-    }
-
-    return value;
-}

app/src/adb/adb.h

@@ -15,12 +15,6 @@
 
 #define SC_ADB_SILENT (SC_ADB_NO_STDOUT | SC_ADB_NO_STDERR | SC_ADB_NO_LOGERR)
 
-bool
-sc_adb_init(void);
-
-void
-sc_adb_destroy(void);
-
 const char *
 sc_adb_get_executable(void);
 
@@ -120,10 +114,4 @@ sc_adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
 char *
 sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags);
 
-/**
- * Return the device SDK version.
- */
-uint16_t
-sc_adb_get_device_sdk_version(struct sc_intr *intr, const char *serial);
-
 #endif

app/src/adb/adb_parser.c

@@ -7,7 +7,7 @@
 #include "util/log.h"
 #include "util/str.h"
 
-static bool
+bool
 sc_adb_parse_device(char *line, struct sc_adb_device *device) {
     // One device line looks like:
     // "0123456789abcdef	device usb:2-1 product:MyProduct model:MyModel "
@@ -204,7 +204,6 @@ sc_adb_parse_device_ip(char *str) {
     while (str[idx_line] != '\0') {
         char *line = &str[idx_line];
         size_t len = strcspn(line, "\n");
-        bool is_last_line = line[len] == '\0';
 
         // The same, but without any trailing '\r'
         size_t line_len = sc_str_remove_trailing_cr(line, len);
@@ -216,12 +215,12 @@ sc_adb_parse_device_ip(char *str) {
             return ip;
         }
 
-        if (is_last_line) {
-            break;
-        }
+        idx_line += len;
 
-        // The next line starts after the '\n'
-        idx_line += len + 1;
+        if (str[idx_line] != '\0') {
+            // The next line starts after the '\n'
+            ++idx_line;
+        }
     }
 
     return NULL;

app/src/android/keycodes.h

@@ -633,7 +633,7 @@ enum android_keycode {
      * Toggles between BS and CS digital satellite services. */
     AKEYCODE_TV_SATELLITE_SERVICE = 240,
     /** Toggle Network key.
-     * Toggles selecting broadcast services. */
+     * Toggles selecting broacast services. */
     AKEYCODE_TV_NETWORK      = 241,
     /** Antenna/Cable key.
      * Toggles broadcast input source between antenna and cable. */

app/src/audio_player.c

@@ -1,118 +0,0 @@
-#include "audio_player.h"
-
-#include "util/log.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 AUDIO_F32
-
-static void SDLCALL
-sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
-    struct sc_audio_player *ap = userdata;
-
-    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;
-
-    sc_audio_regulator_pull(&ap->audioreg, stream, out_samples);
-}
-
-static bool
-sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
-                                const AVFrame *frame) {
-    struct sc_audio_player *ap = DOWNCAST(sink);
-
-    return sc_audio_regulator_push(&ap->audioreg, frame);
-}
-
-static bool
-sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
-                                const AVCodecContext *ctx) {
-    struct sc_audio_player *ap = DOWNCAST(sink);
-
-#ifdef SCRCPY_LAVU_HAS_CHLAYOUT
-    assert(ctx->ch_layout.nb_channels > 0 && ctx->ch_layout.nb_channels < 256);
-    uint8_t nb_channels = ctx->ch_layout.nb_channels;
-#else
-    int tmp = av_get_channel_layout_nb_channels(ctx->channel_layout);
-    assert(tmp > 0 && tmp < 256);
-    uint8_t nb_channels = tmp;
-#endif
-
-    assert(ctx->sample_rate > 0);
-    assert(!av_sample_fmt_is_planar(SC_AV_SAMPLE_FMT));
-    int out_bytes_per_sample = av_get_bytes_per_sample(SC_AV_SAMPLE_FMT);
-    assert(out_bytes_per_sample > 0);
-
-    uint32_t target_buffering_samples =
-        ap->target_buffering_delay * ctx->sample_rate / SC_TICK_FREQ;
-
-    size_t sample_size = nb_channels * out_bytes_per_sample;
-    bool ok = sc_audio_regulator_init(&ap->audioreg, sample_size, ctx,
-                                      target_buffering_samples);
-    if (!ok) {
-        return false;
-    }
-
-    uint64_t aout_samples = ap->output_buffer_duration * ctx->sample_rate
-                                                       / SC_TICK_FREQ;
-    assert(aout_samples <= 0xFFFF);
-
-    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->device = SDL_OpenAudioDevice(NULL, 0, &desired, &obtained, 0);
-    if (!ap->device) {
-        LOGE("Could not open audio device: %s", SDL_GetError());
-        sc_audio_regulator_destroy(&ap->audioreg);
-        return false;
-    }
-
-    // The thread calling open() is the thread calling push(), which fills the
-    // audio buffer consumed by the SDL audio thread.
-    ok = sc_thread_set_priority(SC_THREAD_PRIORITY_TIME_CRITICAL);
-    if (!ok) {
-        ok = sc_thread_set_priority(SC_THREAD_PRIORITY_HIGH);
-        (void) ok; // We don't care if it worked, at least we tried
-    }
-
-    SDL_PauseAudioDevice(ap->device, 0);
-
-    return true;
-}
-
-static void
-sc_audio_player_frame_sink_close(struct sc_frame_sink *sink) {
-    struct sc_audio_player *ap = DOWNCAST(sink);
-
-    assert(ap->device);
-    SDL_PauseAudioDevice(ap->device, 1);
-    SDL_CloseAudioDevice(ap->device);
-
-    sc_audio_regulator_destroy(&ap->audioreg);
-}
-
-void
-sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering,
-                     sc_tick output_buffer_duration) {
-    ap->target_buffering_delay = target_buffering;
-    ap->output_buffer_duration = output_buffer_duration;
-
-    static const struct sc_frame_sink_ops ops = {
-        .open = sc_audio_player_frame_sink_open,
-        .close = sc_audio_player_frame_sink_close,
-        .push = sc_audio_player_frame_sink_push,
-    };
-
-    ap->frame_sink.ops = &ops;
-}

app/src/audio_player.h

@@ -1,35 +0,0 @@
-#ifndef SC_AUDIO_PLAYER_H
-#define SC_AUDIO_PLAYER_H
-
-#include "common.h"
-
-#include <stdatomic.h>
-#include <stdbool.h>
-#include <SDL2/SDL.h>
-
-#include "audio_regulator.h"
-#include "trait/frame_sink.h"
-#include "util/tick.h"
-
-struct sc_audio_player {
-    struct sc_frame_sink frame_sink;
-
-    // The target buffering between the producer and the consumer. This value
-    // is directly use for compensation.
-    // Since audio capture and/or encoding on the device typically produce
-    // blocks of 960 samples (20ms) or 1024 samples (~21.3ms), this target
-    // value should be higher.
-    sc_tick target_buffering_delay;
-
-    // SDL audio output buffer size
-    sc_tick output_buffer_duration;
-
-    SDL_AudioDeviceID device;
-    struct sc_audio_regulator audioreg;
-};
-
-void
-sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering,
-                     sc_tick audio_output_buffer);
-
-#endif

app/src/audio_regulator.c

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

app/src/audio_regulator.h

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

app/src/cli.h

@@ -7,17 +7,10 @@
 
 #include "options.h"
 
-enum sc_pause_on_exit {
-    SC_PAUSE_ON_EXIT_TRUE,
-    SC_PAUSE_ON_EXIT_FALSE,
-    SC_PAUSE_ON_EXIT_IF_ERROR,
-};
-
 struct scrcpy_cli_args {
     struct scrcpy_options opts;
     bool help;
     bool version;
-    enum sc_pause_on_exit pause_on_exit;
 };
 
 void
@@ -28,7 +21,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]);
 
 #ifdef SC_TEST
 bool
-sc_parse_shortcut_mods(const char *s, uint8_t *shortcut_mods);
+sc_parse_shortcut_mods(const char *s, struct sc_shortcut_mods *mods);
 #endif
 
 #endif

app/src/clock.c

@@ -1,38 +1,111 @@
 #include "clock.h"
 
-#include <assert.h>
-
 #include "util/log.h"
 
-//#define SC_CLOCK_DEBUG // uncomment to debug
-
-#define SC_CLOCK_RANGE 32
+#define SC_CLOCK_NDEBUG // comment to debug
 
 void
 sc_clock_init(struct sc_clock *clock) {
-    clock->range = 0;
-    clock->offset = 0;
+    clock->count = 0;
+    clock->head = 0;
+    clock->left_sum.system = 0;
+    clock->left_sum.stream = 0;
+    clock->right_sum.system = 0;
+    clock->right_sum.stream = 0;
+}
+
+// Estimate the affine function f(stream) = slope * stream + offset
+static void
+sc_clock_estimate(struct sc_clock *clock,
+                  double *out_slope, sc_tick *out_offset) {
+    assert(clock->count > 1); // two points are necessary
+
+    struct sc_clock_point left_avg = {
+        .system = clock->left_sum.system / (clock->count / 2),
+        .stream = clock->left_sum.stream / (clock->count / 2),
+    };
+    struct sc_clock_point right_avg = {
+        .system = clock->right_sum.system / ((clock->count + 1) / 2),
+        .stream = clock->right_sum.stream / ((clock->count + 1) / 2),
+    };
+
+    double slope = (double) (right_avg.system - left_avg.system)
+                 / (right_avg.stream - left_avg.stream);
+
+    if (clock->count < SC_CLOCK_RANGE) {
+        /* The first frames are typically received and decoded with more delay
+         * than the others, causing a wrong slope estimation on start. To
+         * compensate, assume an initial slope of 1, then progressively use the
+         * estimated slope. */
+        slope = (clock->count * slope + (SC_CLOCK_RANGE - clock->count))
+              / SC_CLOCK_RANGE;
+    }
+
+    struct sc_clock_point global_avg = {
+        .system = (clock->left_sum.system + clock->right_sum.system)
+                 / clock->count,
+        .stream = (clock->left_sum.stream + clock->right_sum.stream)
+                 / clock->count,
+    };
+
+    sc_tick offset = global_avg.system - (sc_tick) (global_avg.stream * slope);
+
+    *out_slope = slope;
+    *out_offset = offset;
 }
 
 void
 sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
-    if (clock->range < SC_CLOCK_RANGE) {
-        ++clock->range;
+    struct sc_clock_point *point = &clock->points[clock->head];
+
+    if (clock->count == SC_CLOCK_RANGE || clock->count & 1) {
+        // One point passes from the right sum to the left sum
+
+        unsigned mid;
+        if (clock->count == SC_CLOCK_RANGE) {
+            mid = (clock->head + SC_CLOCK_RANGE / 2) % SC_CLOCK_RANGE;
+        } else {
+            // Only for the first frames
+            mid = clock->count / 2;
+        }
+
+        struct sc_clock_point *mid_point = &clock->points[mid];
+        clock->left_sum.system += mid_point->system;
+        clock->left_sum.stream += mid_point->stream;
+        clock->right_sum.system -= mid_point->system;
+        clock->right_sum.stream -= mid_point->stream;
     }
 
-    sc_tick offset = system - stream;
-    unsigned clock_weight = clock->range - 1;
-    unsigned value_weight = SC_CLOCK_RANGE - clock->range + 1;
-    clock->offset = (clock->offset * clock_weight + offset * value_weight)
-                  / SC_CLOCK_RANGE;
+    if (clock->count == SC_CLOCK_RANGE) {
+        // The current point overwrites the previous value in the circular
+        // array, update the left sum accordingly
+        clock->left_sum.system -= point->system;
+        clock->left_sum.stream -= point->stream;
+    } else {
+        ++clock->count;
+    }
 
-#ifdef SC_CLOCK_DEBUG
-    LOGD("Clock estimation: pts + %" PRItick, clock->offset);
+    point->system = system;
+    point->stream = stream;
+
+    clock->right_sum.system += system;
+    clock->right_sum.stream += stream;
+
+    clock->head = (clock->head + 1) % SC_CLOCK_RANGE;
+
+    if (clock->count > 1) {
+        // Update estimation
+        sc_clock_estimate(clock, &clock->slope, &clock->offset);
+
+#ifndef SC_CLOCK_NDEBUG
+        LOGD("Clock estimation: %f * pts + %" PRItick,
+             clock->slope, clock->offset);
 #endif
+    }
 }
 
 sc_tick
 sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream) {
-    assert(clock->range); // sc_clock_update() must have been called
-    return stream + clock->offset;
+    assert(clock->count > 1); // sc_clock_update() must have been called
+    return (sc_tick) (stream * clock->slope) + clock->offset;
 }

app/src/clock.h

@@ -3,8 +3,13 @@
 
 #include "common.h"
 
+#include <assert.h>
+
 #include "util/tick.h"
 
+#define SC_CLOCK_RANGE 32
+static_assert(!(SC_CLOCK_RANGE & 1), "SC_CLOCK_RANGE must be even");
+
 struct sc_clock_point {
     sc_tick system;
     sc_tick stream;
@@ -16,18 +21,40 @@ struct sc_clock_point {
  *
  *     f(stream) = slope * stream + offset
  *
- * Theoretically, the slope encodes the drift between the device clock and the
- * computer clock. It is expected to be very close to 1.
+ * To that end, it stores the SC_CLOCK_RANGE last clock points (the timestamps
+ * of a frame expressed both in stream time and system time) in a circular
+ * array.
  *
- * Since the clock is used to estimate very close points in the future (which
- * are reestimated on every clock update, see delay_buffer), the error caused
- * by clock drift is totally negligible, so it is better to assume that the
- * slope is 1 than to estimate it (the estimation error would be larger).
+ * To estimate the slope, it splits the last SC_CLOCK_RANGE points into two
+ * sets of SC_CLOCK_RANGE/2 points, and computes their centroid ("average
+ * point"). The slope of the estimated affine function is that of the line
+ * passing through these two points.
  *
- * Therefore, only the offset is estimated.
+ * To estimate the offset, it computes the centroid of all the SC_CLOCK_RANGE
+ * points. The resulting affine function passes by this centroid.
+ *
+ * With a circular array, the rolling sums (and average) are quick to compute.
+ * In practice, the estimation is stable and the evolution is smooth.
  */
 struct sc_clock {
-    unsigned range;
+    // Circular array
+    struct sc_clock_point points[SC_CLOCK_RANGE];
+
+    // Number of points in the array (count <= SC_CLOCK_RANGE)
+    unsigned count;
+
+    // Index of the next point to write
+    unsigned head;
+
+    // Sum of the first count/2 points
+    struct sc_clock_point left_sum;
+
+    // Sum of the last (count+1)/2 points
+    struct sc_clock_point right_sum;
+
+    // Estimated slope and offset
+    // (computed on sc_clock_update(), used by sc_clock_to_system_time())
+    double slope;
     sc_tick offset;
 };
 

app/src/common.h

@@ -5,8 +5,8 @@
 #include "compat.h"
 
 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
-#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
-#define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
+#define MIN(X,Y) (X) < (Y) ? (X) : (Y)
+#define MAX(X,Y) (X) > (Y) ? (X) : (Y)
 #define CLAMP(V,X,Y) MIN( MAX((V),(X)), (Y) )
 
 #define container_of(ptr, type, member) \

app/src/compat.c

@@ -3,9 +3,6 @@
 #include "config.h"
 
 #include <assert.h>
-#ifndef HAVE_REALLOCARRAY
-# include <errno.h>
-#endif
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
@@ -96,15 +93,5 @@ long jrand48(unsigned short xsubi[3]) {
     return v.i;
 }
 #endif
-#endif
 
-#ifndef HAVE_REALLOCARRAY
-void *reallocarray(void *ptr, size_t nmemb, size_t size) {
-    size_t bytes;
-    if (__builtin_mul_overflow(nmemb, size, &bytes)) {
-      errno = ENOMEM;
-      return NULL;
-    }
-    return realloc(ptr, bytes);
-}
 #endif

app/src/compat.h

@@ -3,12 +3,10 @@
 
 #include "config.h"
 
-#include <libavcodec/version.h>
 #include <libavformat/version.h>
-#include <libavutil/version.h>
 #include <SDL2/SDL_version.h>
 
-#ifndef _WIN32
+#ifndef __WIN32
 # define PRIu64_ PRIu64
 # define SC_PRIsizet "zu"
 #else
@@ -27,12 +25,6 @@
 # define SCRCPY_LAVF_REQUIRES_REGISTER_ALL
 #endif
 
-// Not documented in ffmpeg/doc/APIchanges, but AV_CODEC_ID_AV1 has been added
-// by FFmpeg commit d42809f9835a4e9e5c7c63210abb09ad0ef19cfb (included in tag
-// n3.3).
-#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 89, 100)
-# define SCRCPY_LAVC_HAS_AV1
-#endif
 
 // In ffmpeg/doc/APIchanges:
 // 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
@@ -45,22 +37,6 @@
 # define SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
 #endif
 
-// Not documented in ffmpeg/doc/APIchanges, but the channel_layout API
-// has been replaced by chlayout in FFmpeg commit
-// f423497b455da06c1337846902c770028760e094.
-#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(57, 23, 100)
-# define SCRCPY_LAVU_HAS_CHLAYOUT
-#endif
-
-// In ffmpeg/doc/APIchanges:
-// 2023-10-06 - 5432d2aacad - lavc 60.15.100 - avformat.h
-//   Deprecate AVFormatContext.{nb_,}side_data, av_stream_add_side_data(),
-//   av_stream_new_side_data(), and av_stream_get_side_data(). Side data fields
-//   from AVFormatContext.codecpar should be used from now on.
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(60, 15, 100)
-# 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
@@ -71,10 +47,6 @@
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
 #endif
 
-#if SDL_VERSION_ATLEAST(2, 0, 16)
-# define SCRCPY_SDL_HAS_THREAD_PRIORITY_TIME_CRITICAL
-#endif
-
 #ifndef HAVE_STRDUP
 char *strdup(const char *s);
 #endif
@@ -95,8 +67,4 @@ long nrand48(unsigned short xsubi[3]);
 long jrand48(unsigned short xsubi[3]);
 #endif
 
-#ifndef HAVE_REALLOCARRAY
-void *reallocarray(void *ptr, size_t nmemb, size_t size);
-#endif
-
 #endif

app/src/control_msg.c

@@ -22,6 +22,9 @@
 #define MOTIONEVENT_ACTION_LABEL(value) \
     ENUM_TO_LABEL(android_motionevent_action_labels, value)
 
+#define SCREEN_POWER_MODE_LABEL(value) \
+    ENUM_TO_LABEL(screen_power_mode_labels, value)
+
 static const char *const android_keyevent_action_labels[] = {
     "down",
     "up",
@@ -44,6 +47,14 @@ static const char *const android_motionevent_action_labels[] = {
     "btn-release",
 };
 
+static const char *const screen_power_mode_labels[] = {
+    "off",
+    "doze",
+    "normal",
+    "doze-suspend",
+    "suspend",
+};
+
 static const char *const copy_key_labels[] = {
     "none",
     "copy",
@@ -53,11 +64,13 @@ static const char *const copy_key_labels[] = {
 static inline const char *
 get_well_known_pointer_id_name(uint64_t pointer_id) {
     switch (pointer_id) {
-        case SC_POINTER_ID_MOUSE:
+        case POINTER_ID_MOUSE:
             return "mouse";
-        case SC_POINTER_ID_GENERIC_FINGER:
+        case POINTER_ID_GENERIC_FINGER:
             return "finger";
-        case SC_POINTER_ID_VIRTUAL_FINGER:
+        case POINTER_ID_VIRTUAL_MOUSE:
+            return "vmouse";
+        case POINTER_ID_VIRTUAL_FINGER:
             return "vfinger";
         default:
             return NULL;
@@ -72,36 +85,17 @@ write_position(uint8_t *buf, const struct sc_position *position) {
     sc_write16be(&buf[10], position->screen_size.height);
 }
 
-// Write truncated string, and return the size
+// write length (4 bytes) + string (non null-terminated)
 static size_t
-write_string_payload(uint8_t *payload, const char *utf8, size_t max_len) {
-    if (!utf8) {
-        return 0;
-    }
+write_string(const char *utf8, size_t max_len, unsigned char *buf) {
     size_t len = sc_str_utf8_truncation_index(utf8, max_len);
-    memcpy(payload, utf8, len);
-    return len;
-}
-
-// Write length (4 bytes) + string (non null-terminated)
-static size_t
-write_string(uint8_t *buf, const char *utf8, size_t max_len) {
-    size_t len = write_string_payload(buf + 4, utf8, max_len);
     sc_write32be(buf, len);
+    memcpy(&buf[4], utf8, len);
     return 4 + len;
 }
 
-// Write length (1 byte) + string (non null-terminated)
-static size_t
-write_string_tiny(uint8_t *buf, const char *utf8, size_t max_len) {
-    assert(max_len <= 0xFF);
-    size_t len = write_string_payload(buf + 1, utf8, max_len);
-    buf[0] = len;
-    return 1 + len;
-}
-
 size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
+sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
     buf[0] = msg->type;
     switch (msg->type) {
         case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
@@ -111,8 +105,9 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
             sc_write32be(&buf[10], msg->inject_keycode.metastate);
             return 14;
         case SC_CONTROL_MSG_TYPE_INJECT_TEXT: {
-            size_t len = write_string(&buf[1], msg->inject_text.text,
-                                      SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+            size_t len =
+                write_string(msg->inject_text.text,
+                             SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
             return 1 + len;
         }
         case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
@@ -122,9 +117,8 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
             uint16_t pressure =
                 sc_float_to_u16fp(msg->inject_touch_event.pressure);
             sc_write16be(&buf[22], pressure);
-            sc_write32be(&buf[24], msg->inject_touch_event.action_button);
-            sc_write32be(&buf[28], msg->inject_touch_event.buttons);
-            return 32;
+            sc_write32be(&buf[24], msg->inject_touch_event.buttons);
+            return 28;
         case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
             write_position(&buf[1], &msg->inject_scroll_event.position);
             int16_t hscroll =
@@ -144,44 +138,17 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
         case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
             sc_write64be(&buf[1], msg->set_clipboard.sequence);
             buf[9] = !!msg->set_clipboard.paste;
-            size_t len = write_string(&buf[10], msg->set_clipboard.text,
-                                      SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH);
+            size_t len = write_string(msg->set_clipboard.text,
+                                      SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
+                                      &buf[10]);
             return 10 + len;
-        case SC_CONTROL_MSG_TYPE_SET_DISPLAY_POWER:
-            buf[1] = msg->set_display_power.on;
+        case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
+            buf[1] = msg->set_screen_power_mode.mode;
             return 2;
-        case SC_CONTROL_MSG_TYPE_UHID_CREATE:
-            sc_write16be(&buf[1], msg->uhid_create.id);
-
-            size_t index = 3;
-            index += write_string_tiny(&buf[index], msg->uhid_create.name, 127);
-
-            sc_write16be(&buf[index], msg->uhid_create.report_desc_size);
-            index += 2;
-
-            memcpy(&buf[index], msg->uhid_create.report_desc,
-                                msg->uhid_create.report_desc_size);
-            index += msg->uhid_create.report_desc_size;
-
-            return index;
-        case SC_CONTROL_MSG_TYPE_UHID_INPUT:
-            sc_write16be(&buf[1], msg->uhid_input.id);
-            sc_write16be(&buf[3], msg->uhid_input.size);
-            memcpy(&buf[5], msg->uhid_input.data, msg->uhid_input.size);
-            return 5 + msg->uhid_input.size;
-        case SC_CONTROL_MSG_TYPE_UHID_DESTROY:
-            sc_write16be(&buf[1], msg->uhid_destroy.id);
-            return 3;
-        case SC_CONTROL_MSG_TYPE_START_APP: {
-            size_t len = write_string_tiny(&buf[1], msg->start_app.name, 255);
-            return 1 + len;
-        }
         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:
             // no additional data
             return 1;
         default:
@@ -212,25 +179,22 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
             if (pointer_name) {
                 // string pointer id
                 LOG_CMSG("touch [id=%s] %-4s position=%" PRIi32 ",%" PRIi32
-                             " pressure=%f action_button=%06lx buttons=%06lx",
+                             " pressure=%f buttons=%06lx",
                          pointer_name,
                          MOTIONEVENT_ACTION_LABEL(action),
                          msg->inject_touch_event.position.point.x,
                          msg->inject_touch_event.position.point.y,
                          msg->inject_touch_event.pressure,
-                         (long) msg->inject_touch_event.action_button,
                          (long) msg->inject_touch_event.buttons);
             } else {
                 // numeric pointer id
                 LOG_CMSG("touch [id=%" PRIu64_ "] %-4s position=%" PRIi32 ",%"
-                             PRIi32 " pressure=%f action_button=%06lx"
-                             " buttons=%06lx",
+                             PRIi32 " pressure=%f buttons=%06lx",
                          id,
                          MOTIONEVENT_ACTION_LABEL(action),
                          msg->inject_touch_event.position.point.x,
                          msg->inject_touch_event.position.point.y,
                          msg->inject_touch_event.pressure,
-                         (long) msg->inject_touch_event.action_button,
                          (long) msg->inject_touch_event.buttons);
             }
             break;
@@ -258,9 +222,9 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
                      msg->set_clipboard.paste ? "paste" : "nopaste",
                      msg->set_clipboard.text);
             break;
-        case SC_CONTROL_MSG_TYPE_SET_DISPLAY_POWER:
-            LOG_CMSG("display power %s",
-                     msg->set_display_power.on ? "on" : "off");
+        case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
+            LOG_CMSG("power mode %s",
+                     SCREEN_POWER_MODE_LABEL(msg->set_screen_power_mode.mode));
             break;
         case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
             LOG_CMSG("expand notification panel");
@@ -274,56 +238,12 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
         case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
             LOG_CMSG("rotate device");
             break;
-        case SC_CONTROL_MSG_TYPE_UHID_CREATE: {
-            // Quote only if name is not null
-            const char *name = msg->uhid_create.name;
-            const char *quote = name ? "\"" : "";
-            LOG_CMSG("UHID create [%" PRIu16 "] name=%s%s%s "
-                     "report_desc_size=%" PRIu16, msg->uhid_create.id,
-                     quote, name, quote, msg->uhid_create.report_desc_size);
-            break;
-        }
-        case SC_CONTROL_MSG_TYPE_UHID_INPUT: {
-            char *hex = sc_str_to_hex_string(msg->uhid_input.data,
-                                             msg->uhid_input.size);
-            if (hex) {
-                LOG_CMSG("UHID input [%" PRIu16 "] %s",
-                         msg->uhid_input.id, hex);
-                free(hex);
-            } else {
-                LOG_CMSG("UHID input [%" PRIu16 "] size=%" PRIu16,
-                         msg->uhid_input.id, msg->uhid_input.size);
-            }
-            break;
-        }
-        case SC_CONTROL_MSG_TYPE_UHID_DESTROY:
-            LOG_CMSG("UHID destroy [%" PRIu16 "]", msg->uhid_destroy.id);
-            break;
-        case SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
-            LOG_CMSG("open hard keyboard settings");
-            break;
-        case SC_CONTROL_MSG_TYPE_START_APP:
-            LOG_CMSG("start app \"%s\"", msg->start_app.name);
-            break;
-        case SC_CONTROL_MSG_TYPE_RESET_VIDEO:
-            LOG_CMSG("reset video");
-            break;
         default:
             LOG_CMSG("unknown type: %u", (unsigned) msg->type);
             break;
     }
 }
 
-bool
-sc_control_msg_is_droppable(const struct sc_control_msg *msg) {
-    // Cannot drop UHID_CREATE messages, because it would cause all further
-    // UHID_INPUT messages for this device to be invalid.
-    // Cannot drop UHID_DESTROY messages either, because a further UHID_CREATE
-    // with the same id may fail.
-    return msg->type != SC_CONTROL_MSG_TYPE_UHID_CREATE
-        && msg->type != SC_CONTROL_MSG_TYPE_UHID_DESTROY;
-}
-
 void
 sc_control_msg_destroy(struct sc_control_msg *msg) {
     switch (msg->type) {
@@ -333,9 +253,6 @@ sc_control_msg_destroy(struct sc_control_msg *msg) {
         case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
             free(msg->set_clipboard.text);
             break;
-        case SC_CONTROL_MSG_TYPE_START_APP:
-            free(msg->start_app.name);
-            break;
         default:
             // do nothing
             break;

app/src/control_msg.h

@@ -10,7 +10,6 @@
 #include "android/input.h"
 #include "android/keycodes.h"
 #include "coords.h"
-#include "hid/hid_event.h"
 
 #define SC_CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
 
@@ -18,11 +17,12 @@
 // type: 1 byte; sequence: 8 bytes; paste flag: 1 byte; length: 4 bytes
 #define SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (SC_CONTROL_MSG_MAX_SIZE - 14)
 
-#define SC_POINTER_ID_MOUSE UINT64_C(-1)
-#define SC_POINTER_ID_GENERIC_FINGER UINT64_C(-2)
+#define POINTER_ID_MOUSE UINT64_C(-1)
+#define POINTER_ID_GENERIC_FINGER UINT64_C(-2)
 
 // Used for injecting an additional virtual pointer for pinch-to-zoom
-#define SC_POINTER_ID_VIRTUAL_FINGER UINT64_C(-3)
+#define POINTER_ID_VIRTUAL_MOUSE UINT64_C(-3)
+#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-4)
 
 enum sc_control_msg_type {
     SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
@@ -35,14 +35,14 @@ enum sc_control_msg_type {
     SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
     SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
     SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
-    SC_CONTROL_MSG_TYPE_SET_DISPLAY_POWER,
+    SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
     SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
-    SC_CONTROL_MSG_TYPE_UHID_CREATE,
-    SC_CONTROL_MSG_TYPE_UHID_INPUT,
-    SC_CONTROL_MSG_TYPE_UHID_DESTROY,
-    SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS,
-    SC_CONTROL_MSG_TYPE_START_APP,
-    SC_CONTROL_MSG_TYPE_RESET_VIDEO,
+};
+
+enum sc_screen_power_mode {
+    // see <https://android.googlesource.com/platform/frameworks/base.git/+/pie-release-2/core/java/android/view/SurfaceControl.java#305>
+    SC_SCREEN_POWER_MODE_OFF = 0,
+    SC_SCREEN_POWER_MODE_NORMAL = 2,
 };
 
 enum sc_copy_key {
@@ -65,7 +65,6 @@ struct sc_control_msg {
         } inject_text;
         struct {
             enum android_motionevent_action action;
-            enum android_motionevent_buttons action_button;
             enum android_motionevent_buttons buttons;
             uint64_t pointer_id;
             struct sc_position position;
@@ -90,41 +89,19 @@ struct sc_control_msg {
             bool paste;
         } set_clipboard;
         struct {
-            bool on;
-        } set_display_power;
-        struct {
-            uint16_t id;
-            const char *name; // pointer to static data
-            uint16_t report_desc_size;
-            const uint8_t *report_desc; // pointer to static data
-        } uhid_create;
-        struct {
-            uint16_t id;
-            uint16_t size;
-            uint8_t data[SC_HID_MAX_SIZE];
-        } uhid_input;
-        struct {
-            uint16_t id;
-        } uhid_destroy;
-        struct {
-            char *name;
-        } start_app;
+            enum sc_screen_power_mode mode;
+        } set_screen_power_mode;
     };
 };
 
 // buf size must be at least CONTROL_MSG_MAX_SIZE
 // return the number of bytes written
 size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf);
+sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf);
 
 void
 sc_control_msg_log(const struct sc_control_msg *msg);
 
-// Even when the buffer is "full", some messages must absolutely not be dropped
-// to avoid inconsistencies.
-bool
-sc_control_msg_is_droppable(const struct sc_control_msg *msg);
-
 void
 sc_control_msg_destroy(struct sc_control_msg *msg);
 

app/src/controller.c

@@ -4,89 +4,46 @@
 
 #include "util/log.h"
 
-// Drop droppable events above this limit
-#define SC_CONTROL_MSG_QUEUE_LIMIT 60
-
-static void
-sc_controller_receiver_on_ended(struct sc_receiver *receiver, bool error,
-                                void *userdata) {
-    (void) receiver;
-
-    struct sc_controller *controller = userdata;
-    // Forward the event to the controller listener
-    controller->cbs->on_ended(controller, error, controller->cbs_userdata);
-}
-
 bool
 sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
-                   const struct sc_controller_callbacks *cbs,
-                   void *cbs_userdata) {
-    sc_vecdeque_init(&controller->queue);
+                   struct sc_acksync *acksync) {
+    cbuf_init(&controller->queue);
 
-    // Add 4 to support 4 non-droppable events without re-allocation
-    bool ok = sc_vecdeque_reserve(&controller->queue,
-                                  SC_CONTROL_MSG_QUEUE_LIMIT + 4);
+    bool ok = receiver_init(&controller->receiver, control_socket, acksync);
     if (!ok) {
         return false;
     }
 
-    static const struct sc_receiver_callbacks receiver_cbs = {
-        .on_ended = sc_controller_receiver_on_ended,
-    };
-
-    ok = sc_receiver_init(&controller->receiver, control_socket, &receiver_cbs,
-                          controller);
-    if (!ok) {
-        sc_vecdeque_destroy(&controller->queue);
-        return false;
-    }
-
     ok = sc_mutex_init(&controller->mutex);
     if (!ok) {
-        sc_receiver_destroy(&controller->receiver);
-        sc_vecdeque_destroy(&controller->queue);
+        receiver_destroy(&controller->receiver);
         return false;
     }
 
     ok = sc_cond_init(&controller->msg_cond);
     if (!ok) {
-        sc_receiver_destroy(&controller->receiver);
+        receiver_destroy(&controller->receiver);
         sc_mutex_destroy(&controller->mutex);
-        sc_vecdeque_destroy(&controller->queue);
         return false;
     }
 
     controller->control_socket = control_socket;
     controller->stopped = false;
 
-    assert(cbs && cbs->on_ended);
-    controller->cbs = cbs;
-    controller->cbs_userdata = cbs_userdata;
-
     return true;
 }
 
-void
-sc_controller_configure(struct sc_controller *controller,
-                        struct sc_acksync *acksync,
-                        struct sc_uhid_devices *uhid_devices) {
-    controller->receiver.acksync = acksync;
-    controller->receiver.uhid_devices = uhid_devices;
-}
-
 void
 sc_controller_destroy(struct sc_controller *controller) {
     sc_cond_destroy(&controller->msg_cond);
     sc_mutex_destroy(&controller->mutex);
 
-    while (!sc_vecdeque_is_empty(&controller->queue)) {
-        struct sc_control_msg *msg = sc_vecdeque_popref(&controller->queue);
-        assert(msg);
-        sc_control_msg_destroy(msg);
+    struct sc_control_msg msg;
+    while (cbuf_take(&controller->queue, &msg)) {
+        sc_control_msg_destroy(&msg);
     }
-    sc_vecdeque_destroy(&controller->queue);
 
-    sc_receiver_destroy(&controller->receiver);
+    receiver_destroy(&controller->receiver);
 }
 
 bool
@@ -96,90 +53,56 @@ sc_controller_push_msg(struct sc_controller *controller,
         sc_control_msg_log(msg);
     }
 
-    bool pushed = false;
-
     sc_mutex_lock(&controller->mutex);
-    size_t size = sc_vecdeque_size(&controller->queue);
-    if (size < SC_CONTROL_MSG_QUEUE_LIMIT) {
-        bool was_empty = sc_vecdeque_is_empty(&controller->queue);
-        sc_vecdeque_push_noresize(&controller->queue, *msg);
-        pushed = true;
-        if (was_empty) {
-            sc_cond_signal(&controller->msg_cond);
-        }
-    } else if (!sc_control_msg_is_droppable(msg)) {
-        bool ok = sc_vecdeque_push(&controller->queue, *msg);
-        if (ok) {
-            pushed = true;
-        } else {
-            // A non-droppable event must be dropped anyway
-            LOG_OOM();
-        }
+    bool was_empty = cbuf_is_empty(&controller->queue);
+    bool res = cbuf_push(&controller->queue, *msg);
+    if (was_empty) {
+        sc_cond_signal(&controller->msg_cond);
     }
-    // Otherwise, the msg is discarded
-
     sc_mutex_unlock(&controller->mutex);
-
-    return pushed;
+    return res;
 }
 
 static bool
 process_msg(struct sc_controller *controller,
-            const struct sc_control_msg *msg, bool *eos) {
-    static uint8_t serialized_msg[SC_CONTROL_MSG_MAX_SIZE];
+            const struct sc_control_msg *msg) {
+    static unsigned char serialized_msg[SC_CONTROL_MSG_MAX_SIZE];
     size_t length = sc_control_msg_serialize(msg, serialized_msg);
     if (!length) {
-        *eos = false;
         return false;
     }
-
     ssize_t w =
         net_send_all(controller->control_socket, serialized_msg, length);
-    if ((size_t) w != length) {
-        *eos = true;
-        return false;
-    }
-
-    return true;
+    return (size_t) w == length;
 }
 
 static int
 run_controller(void *data) {
     struct sc_controller *controller = data;
 
-    bool error = false;
-
     for (;;) {
         sc_mutex_lock(&controller->mutex);
-        while (!controller->stopped
-                && sc_vecdeque_is_empty(&controller->queue)) {
+        while (!controller->stopped && cbuf_is_empty(&controller->queue)) {
             sc_cond_wait(&controller->msg_cond, &controller->mutex);
         }
         if (controller->stopped) {
             // stop immediately, do not process further msgs
             sc_mutex_unlock(&controller->mutex);
-            LOGD("Controller stopped");
             break;
         }
-
-        assert(!sc_vecdeque_is_empty(&controller->queue));
-        struct sc_control_msg msg = sc_vecdeque_pop(&controller->queue);
+        struct sc_control_msg msg;
+        bool non_empty = cbuf_take(&controller->queue, &msg);
+        assert(non_empty);
+        (void) non_empty;
         sc_mutex_unlock(&controller->mutex);
 
-        bool eos;
-        bool ok = process_msg(controller, &msg, &eos);
+        bool ok = process_msg(controller, &msg);
         sc_control_msg_destroy(&msg);
         if (!ok) {
-            if (eos) {
-                LOGD("Controller stopped (socket closed)");
-            } // else error already logged
-            error = !eos;
+            LOGD("Could not write msg to socket");
             break;
         }
     }
-
-    controller->cbs->on_ended(controller, error, controller->cbs_userdata);
-
     return 0;
 }
 
@@ -194,7 +117,7 @@ sc_controller_start(struct sc_controller *controller) {
         return false;
     }
 
-    if (!sc_receiver_start(&controller->receiver)) {
+    if (!receiver_start(&controller->receiver)) {
         sc_controller_stop(controller);
         sc_thread_join(&controller->thread, NULL);
         return false;
@@ -214,5 +137,5 @@ sc_controller_stop(struct sc_controller *controller) {
 void
 sc_controller_join(struct sc_controller *controller) {
     sc_thread_join(&controller->thread, NULL);
-    sc_receiver_join(&controller->receiver);
+    receiver_join(&controller->receiver);
 }

app/src/controller.h

@@ -8,11 +8,11 @@
 #include "control_msg.h"
 #include "receiver.h"
 #include "util/acksync.h"
+#include "util/cbuf.h"
 #include "util/net.h"
 #include "util/thread.h"
-#include "util/vecdeque.h"
 
-struct sc_control_msg_queue SC_VECDEQUE(struct sc_control_msg);
+struct sc_control_msg_queue CBUF(struct sc_control_msg, 64);
 
 struct sc_controller {
     sc_socket control_socket;
@@ -21,26 +21,12 @@ struct sc_controller {
     sc_cond msg_cond;
     bool stopped;
     struct sc_control_msg_queue queue;
-    struct sc_receiver receiver;
-
-    const struct sc_controller_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct sc_controller_callbacks {
-    void (*on_ended)(struct sc_controller *controller, bool error,
-                     void *userdata);
+    struct receiver receiver;
 };
 
 bool
 sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
-                   const struct sc_controller_callbacks *cbs,
-                   void *cbs_userdata);
-
-void
-sc_controller_configure(struct sc_controller *controller,
-                        struct sc_acksync *acksync,
-                        struct sc_uhid_devices *uhid_devices);
+                   struct sc_acksync *acksync);
 
 void
 sc_controller_destroy(struct sc_controller *controller);

app/src/decoder.c

@@ -2,37 +2,96 @@
 
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
-#include <libavutil/channel_layout.h>
 
 #include "events.h"
+#include "video_buffer.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 void
+sc_decoder_close_first_sinks(struct sc_decoder *decoder, unsigned count) {
+    while (count) {
+        struct sc_frame_sink *sink = decoder->sinks[--count];
+        sink->ops->close(sink);
+    }
+}
+
+static inline void
+sc_decoder_close_sinks(struct sc_decoder *decoder) {
+    sc_decoder_close_first_sinks(decoder, decoder->sink_count);
+}
+
 static bool
-sc_decoder_open(struct sc_decoder *decoder, AVCodecContext *ctx) {
-    decoder->frame = av_frame_alloc();
-    if (!decoder->frame) {
+sc_decoder_open_sinks(struct sc_decoder *decoder) {
+    for (unsigned i = 0; i < decoder->sink_count; ++i) {
+        struct sc_frame_sink *sink = decoder->sinks[i];
+        if (!sink->ops->open(sink)) {
+            LOGE("Could not open frame sink %d", i);
+            sc_decoder_close_first_sinks(decoder, i);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool
+sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
+    decoder->codec_ctx = avcodec_alloc_context3(codec);
+    if (!decoder->codec_ctx) {
         LOG_OOM();
         return false;
     }
 
-    if (!sc_frame_source_sinks_open(&decoder->frame_source, ctx)) {
-        av_frame_free(&decoder->frame);
+    decoder->codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;
+
+    if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
+        LOGE("Could not open codec");
+        avcodec_free_context(&decoder->codec_ctx);
         return false;
     }
 
-    decoder->ctx = ctx;
+    decoder->frame = av_frame_alloc();
+    if (!decoder->frame) {
+        LOG_OOM();
+        avcodec_close(decoder->codec_ctx);
+        avcodec_free_context(&decoder->codec_ctx);
+        return false;
+    }
+
+    if (!sc_decoder_open_sinks(decoder)) {
+        LOGE("Could not open decoder sinks");
+        av_frame_free(&decoder->frame);
+        avcodec_close(decoder->codec_ctx);
+        avcodec_free_context(&decoder->codec_ctx);
+        return false;
+    }
 
     return true;
 }
 
 static void
 sc_decoder_close(struct sc_decoder *decoder) {
-    sc_frame_source_sinks_close(&decoder->frame_source);
+    sc_decoder_close_sinks(decoder);
     av_frame_free(&decoder->frame);
+    avcodec_close(decoder->codec_ctx);
+    avcodec_free_context(&decoder->codec_ctx);
+}
+
+static bool
+push_frame_to_sinks(struct sc_decoder *decoder, const AVFrame *frame) {
+    for (unsigned i = 0; i < decoder->sink_count; ++i) {
+        struct sc_frame_sink *sink = decoder->sinks[i];
+        if (!sink->ops->push(sink, frame)) {
+            LOGE("Could not send frame to sink %d", i);
+            return false;
+        }
+    }
+
+    return true;
 }
 
 static bool
@@ -43,42 +102,31 @@ sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {
         return true;
     }
 
-    int ret = avcodec_send_packet(decoder->ctx, packet);
+    int ret = avcodec_send_packet(decoder->codec_ctx, packet);
     if (ret < 0 && ret != AVERROR(EAGAIN)) {
-        LOGE("Decoder '%s': could not send video packet: %d",
-             decoder->name, ret);
+        LOGE("Could not send video packet: %d", ret);
         return false;
     }
-
-    for (;;) {
-        ret = avcodec_receive_frame(decoder->ctx, decoder->frame);
-        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
-            break;
-        }
-
-        if (ret) {
-            LOGE("Decoder '%s', could not receive video frame: %d",
-                 decoder->name, ret);
-            return false;
-        }
-
+    ret = avcodec_receive_frame(decoder->codec_ctx, decoder->frame);
+    if (!ret) {
         // a frame was received
-        bool ok = sc_frame_source_sinks_push(&decoder->frame_source,
-                                             decoder->frame);
-        av_frame_unref(decoder->frame);
-        if (!ok) {
-            // Error already logged
-            return false;
-        }
-    }
+        bool ok = push_frame_to_sinks(decoder, decoder->frame);
+        // A frame lost should not make the whole pipeline fail. The error, if
+        // any, is already logged.
+        (void) ok;
 
+        av_frame_unref(decoder->frame);
+    } else if (ret != AVERROR(EAGAIN)) {
+        LOGE("Could not receive video frame: %d", ret);
+        return false;
+    }
     return true;
 }
 
 static bool
-sc_decoder_packet_sink_open(struct sc_packet_sink *sink, AVCodecContext *ctx) {
+sc_decoder_packet_sink_open(struct sc_packet_sink *sink, const AVCodec *codec) {
     struct sc_decoder *decoder = DOWNCAST(sink);
-    return sc_decoder_open(decoder, ctx);
+    return sc_decoder_open(decoder, codec);
 }
 
 static void
@@ -95,9 +143,8 @@ sc_decoder_packet_sink_push(struct sc_packet_sink *sink,
 }
 
 void
-sc_decoder_init(struct sc_decoder *decoder, const char *name) {
-    decoder->name = name; // statically allocated
-    sc_frame_source_init(&decoder->frame_source);
+sc_decoder_init(struct sc_decoder *decoder) {
+    decoder->sink_count = 0;
 
     static const struct sc_packet_sink_ops ops = {
         .open = sc_decoder_packet_sink_open,
@@ -107,3 +154,11 @@ sc_decoder_init(struct sc_decoder *decoder, const char *name) {
 
     decoder->packet_sink.ops = &ops;
 }
+
+void
+sc_decoder_add_sink(struct sc_decoder *decoder, struct sc_frame_sink *sink) {
+    assert(decoder->sink_count < SC_DECODER_MAX_SINKS);
+    assert(sink);
+    assert(sink->ops);
+    decoder->sinks[decoder->sink_count++] = sink;
+}

app/src/decoder.h

@@ -3,25 +3,28 @@
 
 #include "common.h"
 
-#include "trait/frame_source.h"
 #include "trait/packet_sink.h"
 
 #include <stdbool.h>
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 
+#define SC_DECODER_MAX_SINKS 2
+
 struct sc_decoder {
     struct sc_packet_sink packet_sink; // packet sink trait
-    struct sc_frame_source frame_source; // frame source trait
 
-    const char *name; // must be statically allocated (e.g. a string literal)
+    struct sc_frame_sink *sinks[SC_DECODER_MAX_SINKS];
+    unsigned sink_count;
 
-    AVCodecContext *ctx;
+    AVCodecContext *codec_ctx;
     AVFrame *frame;
 };
 
-// The name must be statically allocated (e.g. a string literal)
 void
-sc_decoder_init(struct sc_decoder *decoder, const char *name);
+sc_decoder_init(struct sc_decoder *decoder);
+
+void
+sc_decoder_add_sink(struct sc_decoder *decoder, struct sc_frame_sink *sink);
 
 #endif

app/src/delay_buffer.c

@@ -1,243 +0,0 @@
-#include "delay_buffer.h"
-
-#include <assert.h>
-#include <stdlib.h>
-
-#include <libavutil/avutil.h>
-#include <libavformat/avformat.h>
-
-#include "util/log.h"
-
-/** Downcast frame_sink to sc_delay_buffer */
-#define DOWNCAST(SINK) container_of(SINK, struct sc_delay_buffer, frame_sink)
-
-static bool
-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(dframe->frame, frame)) {
-        LOG_OOM();
-        av_frame_free(&dframe->frame);
-        return false;
-    }
-
-    return true;
-}
-
-static void
-sc_delayed_frame_destroy(struct sc_delayed_frame *dframe) {
-    av_frame_unref(dframe->frame);
-    av_frame_free(&dframe->frame);
-}
-
-static int
-run_buffering(void *data) {
-    struct sc_delay_buffer *db = data;
-
-    assert(db->delay > 0);
-
-    for (;;) {
-        sc_mutex_lock(&db->mutex);
-
-        while (!db->stopped && sc_vecdeque_is_empty(&db->queue)) {
-            sc_cond_wait(&db->queue_cond, &db->mutex);
-        }
-
-        if (db->stopped) {
-            sc_mutex_unlock(&db->mutex);
-            goto stopped;
-        }
-
-        struct sc_delayed_frame dframe = sc_vecdeque_pop(&db->queue);
-
-        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 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 frame could not be pushed, stopping");
-            sc_mutex_lock(&db->mutex);
-            // Prevent to push any new frame
-            db->stopped = true;
-            sc_mutex_unlock(&db->mutex);
-            goto stopped;
-        }
-    }
-
-stopped:
-    assert(db->stopped);
-
-    // Flush queue
-    while (!sc_vecdeque_is_empty(&db->queue)) {
-        struct sc_delayed_frame *dframe = sc_vecdeque_popref(&db->queue);
-        sc_delayed_frame_destroy(dframe);
-    }
-
-    LOGD("Buffering thread ended");
-
-    return 0;
-}
-
-static bool
-sc_delay_buffer_frame_sink_open(struct sc_frame_sink *sink,
-                                const AVCodecContext *ctx) {
-    struct sc_delay_buffer *db = DOWNCAST(sink);
-    (void) ctx;
-
-    bool ok = sc_mutex_init(&db->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&db->queue_cond);
-    if (!ok) {
-        goto error_destroy_mutex;
-    }
-
-    ok = sc_cond_init(&db->wait_cond);
-    if (!ok) {
-        goto error_destroy_queue_cond;
-    }
-
-    sc_clock_init(&db->clock);
-    sc_vecdeque_init(&db->queue);
-    db->stopped = false;
-
-    if (!sc_frame_source_sinks_open(&db->frame_source, ctx)) {
-        goto error_destroy_wait_cond;
-    }
-
-    ok = sc_thread_create(&db->thread, run_buffering, "scrcpy-dbuf", db);
-    if (!ok) {
-        LOGE("Could not start buffering thread");
-        goto error_close_sinks;
-    }
-
-    return true;
-
-error_close_sinks:
-    sc_frame_source_sinks_close(&db->frame_source);
-error_destroy_wait_cond:
-    sc_cond_destroy(&db->wait_cond);
-error_destroy_queue_cond:
-    sc_cond_destroy(&db->queue_cond);
-error_destroy_mutex:
-    sc_mutex_destroy(&db->mutex);
-
-    return false;
-}
-
-static void
-sc_delay_buffer_frame_sink_close(struct sc_frame_sink *sink) {
-    struct sc_delay_buffer *db = DOWNCAST(sink);
-
-    sc_mutex_lock(&db->mutex);
-    db->stopped = true;
-    sc_cond_signal(&db->queue_cond);
-    sc_cond_signal(&db->wait_cond);
-    sc_mutex_unlock(&db->mutex);
-
-    sc_thread_join(&db->thread, NULL);
-
-    sc_frame_source_sinks_close(&db->frame_source);
-
-    sc_cond_destroy(&db->wait_cond);
-    sc_cond_destroy(&db->queue_cond);
-    sc_mutex_destroy(&db->mutex);
-}
-
-static bool
-sc_delay_buffer_frame_sink_push(struct sc_frame_sink *sink,
-                                const AVFrame *frame) {
-    struct sc_delay_buffer *db = DOWNCAST(sink);
-
-    sc_mutex_lock(&db->mutex);
-
-    if (db->stopped) {
-        sc_mutex_unlock(&db->mutex);
-        return false;
-    }
-
-    sc_tick pts = SC_TICK_FROM_US(frame->pts);
-    sc_clock_update(&db->clock, sc_tick_now(), pts);
-    sc_cond_signal(&db->wait_cond);
-
-    if (db->first_frame_asap && db->clock.range == 1) {
-        sc_mutex_unlock(&db->mutex);
-        return sc_frame_source_sinks_push(&db->frame_source, frame);
-    }
-
-    struct sc_delayed_frame dframe;
-    bool ok = sc_delayed_frame_init(&dframe, frame);
-    if (!ok) {
-        sc_mutex_unlock(&db->mutex);
-        return false;
-    }
-
-#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;
-    }
-
-    sc_cond_signal(&db->queue_cond);
-
-    sc_mutex_unlock(&db->mutex);
-
-    return true;
-}
-
-void
-sc_delay_buffer_init(struct sc_delay_buffer *db, sc_tick delay,
-                     bool first_frame_asap) {
-    assert(delay > 0);
-
-    db->delay = delay;
-    db->first_frame_asap = first_frame_asap;
-
-    sc_frame_source_init(&db->frame_source);
-
-    static const struct sc_frame_sink_ops ops = {
-        .open = sc_delay_buffer_frame_sink_open,
-        .close = sc_delay_buffer_frame_sink_close,
-        .push = sc_delay_buffer_frame_sink_push,
-    };
-
-    db->frame_sink.ops = &ops;
-}

app/src/delay_buffer.h

@@ -1,62 +0,0 @@
-#ifndef SC_DELAY_BUFFER_H
-#define SC_DELAY_BUFFER_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "clock.h"
-#include "trait/frame_source.h"
-#include "trait/frame_sink.h"
-#include "util/thread.h"
-#include "util/tick.h"
-#include "util/vecdeque.h"
-
-//#define SC_BUFFERING_DEBUG // uncomment to debug
-
-// forward declarations
-typedef struct AVFrame AVFrame;
-
-struct sc_delayed_frame {
-    AVFrame *frame;
-#ifdef SC_BUFFERING_DEBUG
-    sc_tick push_date;
-#endif
-};
-
-struct sc_delayed_frame_queue SC_VECDEQUE(struct sc_delayed_frame);
-
-struct sc_delay_buffer {
-    struct sc_frame_source frame_source; // frame source trait
-    struct sc_frame_sink frame_sink; // frame sink trait
-
-    sc_tick delay;
-    bool first_frame_asap;
-
-    sc_thread thread;
-    sc_mutex mutex;
-    sc_cond queue_cond;
-    sc_cond wait_cond;
-
-    struct sc_clock clock;
-    struct sc_delayed_frame_queue queue;
-    bool stopped;
-};
-
-struct sc_delay_buffer_callbacks {
-    bool (*on_new_frame)(struct sc_delay_buffer *db, const AVFrame *frame,
-                         void *userdata);
-};
-
-/**
- * Initialize a delay buffer.
- *
- * \param delay a (strictly) positive delay
- * \param first_frame_asap if true, do not delay the first frame (useful for
-                           a video stream).
- */
-void
-sc_delay_buffer_init(struct sc_delay_buffer *db, sc_tick delay,
-                     bool first_frame_asap);
-
-#endif

app/src/demuxer.c

@@ -1,13 +1,11 @@
 #include "demuxer.h"
 
 #include <assert.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"
@@ -19,71 +17,11 @@
 
 #define SC_PACKET_PTS_MASK (SC_PACKET_FLAG_KEY_FRAME - 1)
 
-static enum AVCodecID
-sc_demuxer_to_avcodec_id(uint32_t codec_id) {
-#define SC_CODEC_ID_H264 UINT32_C(0x68323634) // "h264" in ASCII
-#define SC_CODEC_ID_H265 UINT32_C(0x68323635) // "h265" in ASCII
-#define SC_CODEC_ID_AV1 UINT32_C(0x00617631) // "av1" in ASCII
-#define SC_CODEC_ID_OPUS UINT32_C(0x6f707573) // "opus" in ASCII
-#define SC_CODEC_ID_AAC UINT32_C(0x00616163) // "aac" in ASCII
-#define SC_CODEC_ID_FLAC UINT32_C(0x666c6163) // "flac" in ASCII
-#define SC_CODEC_ID_RAW UINT32_C(0x00726177) // "raw" in ASCII
-    switch (codec_id) {
-        case SC_CODEC_ID_H264:
-            return AV_CODEC_ID_H264;
-        case SC_CODEC_ID_H265:
-            return AV_CODEC_ID_HEVC;
-        case SC_CODEC_ID_AV1:
-#ifdef SCRCPY_LAVC_HAS_AV1
-            return AV_CODEC_ID_AV1;
-#else
-            LOGE("AV1 not supported by this FFmpeg version");
-            return AV_CODEC_ID_NONE;
-#endif
-        case SC_CODEC_ID_OPUS:
-            return AV_CODEC_ID_OPUS;
-        case SC_CODEC_ID_AAC:
-            return AV_CODEC_ID_AAC;
-        case SC_CODEC_ID_FLAC:
-            return AV_CODEC_ID_FLAC;
-        case SC_CODEC_ID_RAW:
-            return AV_CODEC_ID_PCM_S16LE;
-        default:
-            LOGE("Unknown codec id 0x%08" PRIx32, codec_id);
-            return AV_CODEC_ID_NONE;
-    }
-}
-
-static bool
-sc_demuxer_recv_codec_id(struct sc_demuxer *demuxer, uint32_t *codec_id) {
-    uint8_t data[4];
-    ssize_t r = net_recv_all(demuxer->socket, data, 4);
-    if (r < 4) {
-        return false;
-    }
-
-    *codec_id = sc_read32be(data);
-    return true;
-}
-
-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 video stream contains raw packets, without time information. When we
+    // record, we retrieve the timestamps separately, from a "meta" header
+    // added by the server before each raw packet.
     //
     // The "meta" header length is 12 bytes:
     // [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
@@ -137,177 +75,198 @@ sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
     return true;
 }
 
+static bool
+push_packet_to_sinks(struct sc_demuxer *demuxer, const AVPacket *packet) {
+    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
+        struct sc_packet_sink *sink = demuxer->sinks[i];
+        if (!sink->ops->push(sink, packet)) {
+            LOGE("Could not send config packet to sink %d", i);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool
+sc_demuxer_push_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
+    bool is_config = packet->pts == AV_NOPTS_VALUE;
+
+    // A config packet must not be decoded immediately (it contains no
+    // frame); instead, it must be concatenated with the future data packet.
+    if (demuxer->pending || is_config) {
+        if (demuxer->pending) {
+            size_t offset = demuxer->pending->size;
+            if (av_grow_packet(demuxer->pending, packet->size)) {
+                LOG_OOM();
+                return false;
+            }
+
+            memcpy(demuxer->pending->data + offset, packet->data, packet->size);
+        } else {
+            demuxer->pending = av_packet_alloc();
+            if (!demuxer->pending) {
+                LOG_OOM();
+                return false;
+            }
+            if (av_packet_ref(demuxer->pending, packet)) {
+                LOG_OOM();
+                av_packet_free(&demuxer->pending);
+                return false;
+            }
+        }
+
+        if (!is_config) {
+            // prepare the concat packet to send to the decoder
+            demuxer->pending->pts = packet->pts;
+            demuxer->pending->dts = packet->dts;
+            demuxer->pending->flags = packet->flags;
+            packet = demuxer->pending;
+        }
+    }
+
+    bool ok = push_packet_to_sinks(demuxer, packet);
+
+    if (!is_config && demuxer->pending) {
+        // the pending packet must be discarded (consumed or error)
+        av_packet_free(&demuxer->pending);
+    }
+
+    if (!ok) {
+        LOGE("Could not process packet");
+        return false;
+    }
+
+    return true;
+}
+
+static void
+sc_demuxer_close_first_sinks(struct sc_demuxer *demuxer, unsigned count) {
+    while (count) {
+        struct sc_packet_sink *sink = demuxer->sinks[--count];
+        sink->ops->close(sink);
+    }
+}
+
+static inline void
+sc_demuxer_close_sinks(struct sc_demuxer *demuxer) {
+    sc_demuxer_close_first_sinks(demuxer, demuxer->sink_count);
+}
+
+static bool
+sc_demuxer_open_sinks(struct sc_demuxer *demuxer, const AVCodec *codec) {
+    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
+        struct sc_packet_sink *sink = demuxer->sinks[i];
+        if (!sink->ops->open(sink, codec)) {
+            LOGE("Could not open packet sink %d", i);
+            sc_demuxer_close_first_sinks(demuxer, i);
+            return false;
+        }
+    }
+
+    return true;
+}
+
 static int
 run_demuxer(void *data) {
     struct sc_demuxer *demuxer = data;
 
-    // Flag to report end-of-stream (i.e. device disconnected)
-    enum sc_demuxer_status status = SC_DEMUXER_STATUS_ERROR;
-
-    uint32_t raw_codec_id;
-    bool ok = sc_demuxer_recv_codec_id(demuxer, &raw_codec_id);
-    if (!ok) {
-        LOGE("Demuxer '%s': stream disabled due to connection error",
-             demuxer->name);
-        goto end;
-    }
-
-    if (raw_codec_id == 0) {
-        LOGW("Demuxer '%s': stream explicitly disabled by the device",
-             demuxer->name);
-        sc_packet_source_sinks_disable(&demuxer->packet_source);
-        status = SC_DEMUXER_STATUS_DISABLED;
-        goto end;
-    }
-
-    if (raw_codec_id == 1) {
-        LOGE("Demuxer '%s': stream configuration error on the device",
-             demuxer->name);
-        goto end;
-    }
-
-    enum AVCodecID codec_id = sc_demuxer_to_avcodec_id(raw_codec_id);
-    if (codec_id == AV_CODEC_ID_NONE) {
-        LOGE("Demuxer '%s': stream disabled due to unsupported codec",
-             demuxer->name);
-        sc_packet_source_sinks_disable(&demuxer->packet_source);
-        goto end;
-    }
-
-    const AVCodec *codec = avcodec_find_decoder(codec_id);
+    const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
     if (!codec) {
-        LOGE("Demuxer '%s': stream disabled due to missing decoder",
-             demuxer->name);
-        sc_packet_source_sinks_disable(&demuxer->packet_source);
+        LOGE("H.264 decoder not found");
         goto end;
     }
 
-    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
-    if (!codec_ctx) {
+    demuxer->codec_ctx = avcodec_alloc_context3(codec);
+    if (!demuxer->codec_ctx) {
         LOG_OOM();
         goto end;
     }
 
-    codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;
-
-    if (codec->type == AVMEDIA_TYPE_VIDEO) {
-        uint32_t width;
-        uint32_t height;
-        ok = sc_demuxer_recv_video_size(demuxer, &width, &height);
-        if (!ok) {
-            goto finally_free_context;
-        }
-
-        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
-        codec_ctx->ch_layout = (AVChannelLayout) AV_CHANNEL_LAYOUT_STEREO;
-#else
-        codec_ctx->channel_layout = AV_CH_LAYOUT_STEREO;
-        codec_ctx->channels = 2;
-#endif
-        codec_ctx->sample_rate = 48000;
-
-        if (raw_codec_id == SC_CODEC_ID_FLAC) {
-            // The sample_fmt is not set by the FLAC decoder
-            codec_ctx->sample_fmt = AV_SAMPLE_FMT_S16;
-        }
+    if (!sc_demuxer_open_sinks(demuxer, codec)) {
+        LOGE("Could not open demuxer sinks");
+        goto finally_free_codec_ctx;
     }
 
-    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
-        LOGE("Demuxer '%s': could not open codec", demuxer->name);
-        goto finally_free_context;
+    demuxer->parser = av_parser_init(AV_CODEC_ID_H264);
+    if (!demuxer->parser) {
+        LOGE("Could not initialize parser");
+        goto finally_close_sinks;
     }
 
-    if (!sc_packet_source_sinks_open(&demuxer->packet_source, codec_ctx)) {
-        goto finally_free_context;
-    }
-
-    // Config packets must be merged with the next non-config packet only for
-    // H.26x
-    bool must_merge_config_packet = raw_codec_id == SC_CODEC_ID_H264
-                                 || raw_codec_id == SC_CODEC_ID_H265;
-
-    struct sc_packet_merger merger;
-
-    if (must_merge_config_packet) {
-        sc_packet_merger_init(&merger);
-    }
+    // We must only pass complete frames to av_parser_parse2()!
+    // It's more complicated, but this allows to reduce the latency by 1 frame!
+    demuxer->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
 
     AVPacket *packet = av_packet_alloc();
     if (!packet) {
         LOG_OOM();
-        goto finally_close_sinks;
+        goto finally_close_parser;
     }
 
     for (;;) {
         bool ok = sc_demuxer_recv_packet(demuxer, packet);
         if (!ok) {
             // end of stream
-            status = SC_DEMUXER_STATUS_EOS;
             break;
         }
 
-        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);
+        ok = sc_demuxer_push_packet(demuxer, packet);
         av_packet_unref(packet);
         if (!ok) {
-            // The sink already logged its concrete error
+            // cannot process packet (error already logged)
             break;
         }
     }
 
-    LOGD("Demuxer '%s': end of frames", demuxer->name);
+    LOGD("End of frames");
 
-    if (must_merge_config_packet) {
-        sc_packet_merger_destroy(&merger);
+    if (demuxer->pending) {
+        av_packet_free(&demuxer->pending);
     }
 
     av_packet_free(&packet);
+finally_close_parser:
+    av_parser_close(demuxer->parser);
 finally_close_sinks:
-    sc_packet_source_sinks_close(&demuxer->packet_source);
-finally_free_context:
-    avcodec_free_context(&codec_ctx);
+    sc_demuxer_close_sinks(demuxer);
+finally_free_codec_ctx:
+    avcodec_free_context(&demuxer->codec_ctx);
 end:
-    demuxer->cbs->on_ended(demuxer, status, demuxer->cbs_userdata);
+    demuxer->cbs->on_eos(demuxer, demuxer->cbs_userdata);
 
     return 0;
 }
 
 void
-sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
+sc_demuxer_init(struct sc_demuxer *demuxer, sc_socket socket,
                 const struct sc_demuxer_callbacks *cbs, void *cbs_userdata) {
-    assert(socket != SC_SOCKET_NONE);
-
-    demuxer->name = name; // statically allocated
     demuxer->socket = socket;
-    sc_packet_source_init(&demuxer->packet_source);
+    demuxer->pending = NULL;
+    demuxer->sink_count = 0;
 
-    assert(cbs && cbs->on_ended);
+    assert(cbs && cbs->on_eos);
 
     demuxer->cbs = cbs;
     demuxer->cbs_userdata = cbs_userdata;
 }
 
+void
+sc_demuxer_add_sink(struct sc_demuxer *demuxer, struct sc_packet_sink *sink) {
+    assert(demuxer->sink_count < SC_DEMUXER_MAX_SINKS);
+    assert(sink);
+    assert(sink->ops);
+    demuxer->sinks[demuxer->sink_count++] = sink;
+}
+
 bool
 sc_demuxer_start(struct sc_demuxer *demuxer) {
-    LOGD("Demuxer '%s': starting thread", demuxer->name);
+    LOGD("Starting demuxer thread");
 
     bool ok = sc_thread_create(&demuxer->thread, run_demuxer, "scrcpy-demuxer",
                                demuxer);
     if (!ok) {
-        LOGE("Demuxer '%s': could not start thread", demuxer->name);
+        LOGE("Could not start demuxer thread");
         return false;
     }
     return true;

app/src/demuxer.h

@@ -8,39 +8,40 @@
 #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"
 
+#define SC_DEMUXER_MAX_SINKS 2
+
 struct sc_demuxer {
-    struct sc_packet_source packet_source; // packet source trait
-
-    const char *name; // must be statically allocated (e.g. a string literal)
-
     sc_socket socket;
     sc_thread thread;
 
+    struct sc_packet_sink *sinks[SC_DEMUXER_MAX_SINKS];
+    unsigned sink_count;
+
+    AVCodecContext *codec_ctx;
+    AVCodecParserContext *parser;
+    // successive packets may need to be concatenated, until a non-config
+    // packet is available
+    AVPacket *pending;
+
     const struct sc_demuxer_callbacks *cbs;
     void *cbs_userdata;
 };
 
-enum sc_demuxer_status {
-    SC_DEMUXER_STATUS_EOS,
-    SC_DEMUXER_STATUS_DISABLED,
-    SC_DEMUXER_STATUS_ERROR,
-};
-
 struct sc_demuxer_callbacks {
-    void (*on_ended)(struct sc_demuxer *demuxer, enum sc_demuxer_status,
-                     void *userdata);
+    void (*on_eos)(struct sc_demuxer *demuxer, void *userdata);
 };
 
-// The name must be statically allocated (e.g. a string literal)
 void
-sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
+sc_demuxer_init(struct sc_demuxer *demuxer, sc_socket socket,
                 const struct sc_demuxer_callbacks *cbs, void *cbs_userdata);
 
+void
+sc_demuxer_add_sink(struct sc_demuxer *demuxer, struct sc_packet_sink *sink);
+
 bool
 sc_demuxer_start(struct sc_demuxer *demuxer);
 

app/src/device_msg.c

@@ -8,22 +8,19 @@
 #include "util/log.h"
 
 ssize_t
-sc_device_msg_deserialize(const uint8_t *buf, size_t len,
-                          struct sc_device_msg *msg) {
-    if (!len) {
-        return 0; // no message
+device_msg_deserialize(const unsigned char *buf, size_t len,
+                       struct device_msg *msg) {
+    if (len < 5) {
+        // at least type + empty string length
+        return 0; // not available
     }
 
     msg->type = buf[0];
     switch (msg->type) {
         case DEVICE_MSG_TYPE_CLIPBOARD: {
-            if (len < 5) {
-                // at least type + empty string length
-                return 0; // no complete message
-            }
             size_t clipboard_len = sc_read32be(&buf[1]);
             if (clipboard_len > len - 5) {
-                return 0; // no complete message
+                return 0; // not available
             }
             char *text = malloc(clipboard_len + 1);
             if (!text) {
@@ -39,38 +36,10 @@ sc_device_msg_deserialize(const uint8_t *buf, size_t len,
             return 5 + clipboard_len;
         }
         case DEVICE_MSG_TYPE_ACK_CLIPBOARD: {
-            if (len < 9) {
-                return 0; // no complete message
-            }
             uint64_t sequence = sc_read64be(&buf[1]);
             msg->ack_clipboard.sequence = sequence;
             return 9;
         }
-        case DEVICE_MSG_TYPE_UHID_OUTPUT: {
-            if (len < 5) {
-                // at least id + size
-                return 0; // not available
-            }
-            uint16_t id = sc_read16be(&buf[1]);
-            size_t size = sc_read16be(&buf[3]);
-            if (size < len - 5) {
-                return 0; // not available
-            }
-            uint8_t *data = malloc(size);
-            if (!data) {
-                LOG_OOM();
-                return -1;
-            }
-            if (size) {
-                memcpy(data, &buf[5], size);
-            }
-
-            msg->uhid_output.id = id;
-            msg->uhid_output.size = size;
-            msg->uhid_output.data = data;
-
-            return 5 + size;
-        }
         default:
             LOGW("Unknown device message type: %d", (int) msg->type);
             return -1; // error, we cannot recover
@@ -78,16 +47,8 @@ sc_device_msg_deserialize(const uint8_t *buf, size_t len,
 }
 
 void
-sc_device_msg_destroy(struct sc_device_msg *msg) {
-    switch (msg->type) {
-        case DEVICE_MSG_TYPE_CLIPBOARD:
-            free(msg->clipboard.text);
-            break;
-        case DEVICE_MSG_TYPE_UHID_OUTPUT:
-            free(msg->uhid_output.data);
-            break;
-        default:
-            // nothing to do
-            break;
+device_msg_destroy(struct device_msg *msg) {
+    if (msg->type == DEVICE_MSG_TYPE_CLIPBOARD) {
+        free(msg->clipboard.text);
     }
 }

app/src/device_msg.h

@@ -11,14 +11,13 @@
 // type: 1 byte; length: 4 bytes
 #define DEVICE_MSG_TEXT_MAX_LENGTH (DEVICE_MSG_MAX_SIZE - 5)
 
-enum sc_device_msg_type {
+enum device_msg_type {
     DEVICE_MSG_TYPE_CLIPBOARD,
     DEVICE_MSG_TYPE_ACK_CLIPBOARD,
-    DEVICE_MSG_TYPE_UHID_OUTPUT,
 };
 
-struct sc_device_msg {
-    enum sc_device_msg_type type;
+struct device_msg {
+    enum device_msg_type type;
     union {
         struct {
             char *text; // owned, to be freed by free()
@@ -26,20 +25,15 @@ struct sc_device_msg {
         struct {
             uint64_t sequence;
         } ack_clipboard;
-        struct {
-            uint16_t id;
-            uint16_t size;
-            uint8_t *data; // owned, to be freed by free()
-        } uhid_output;
     };
 };
 
 // return the number of bytes consumed (0 for no msg available, -1 on error)
 ssize_t
-sc_device_msg_deserialize(const uint8_t *buf, size_t len,
-                          struct sc_device_msg *msg);
+device_msg_deserialize(const unsigned char *buf, size_t len,
+                       struct device_msg *msg);
 
 void
-sc_device_msg_destroy(struct sc_device_msg *msg);
+device_msg_destroy(struct device_msg *msg);
 
 #endif

app/src/display.c

@@ -1,342 +0,0 @@
-#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;
-}

app/src/display.h

@@ -1,63 +0,0 @@
-#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

app/src/events.c

@@ -1,66 +0,0 @@
-#include "events.h"
-
-#include "util/log.h"
-#include "util/thread.h"
-
-bool
-sc_push_event_impl(uint32_t type, const char *name) {
-    SDL_Event event;
-    event.type = type;
-    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;
-    }
-
-    return true;
-}
-
-bool
-sc_post_to_main_thread(sc_runnable_fn run, void *userdata) {
-    SDL_Event event = {
-        .user = {
-            .type = SC_EVENT_RUN_ON_MAIN_THREAD,
-            .data1 = run,
-            .data2 = userdata,
-        },
-    };
-    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 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 0;
-    }
-
-    return 1;
-}
-
-void
-sc_reject_new_runnables(void) {
-    assert(sc_thread_get_id() == SC_MAIN_THREAD_ID);
-
-    SDL_SetEventFilter(task_event_filter, NULL);
-}

app/src/events.h

@@ -1,38 +1,5 @@
-#ifndef SC_EVENTS_H
-#define SC_EVENTS_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <SDL2/SDL_events.h>
-
-enum {
-    SC_EVENT_NEW_FRAME = SDL_USEREVENT,
-    SC_EVENT_RUN_ON_MAIN_THREAD,
-    SC_EVENT_DEVICE_DISCONNECTED,
-    SC_EVENT_SERVER_CONNECTION_FAILED,
-    SC_EVENT_SERVER_CONNECTED,
-    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,
-};
-
-bool
-sc_push_event_impl(uint32_t type, const char *name);
-
-#define sc_push_event(TYPE) sc_push_event_impl(TYPE, # TYPE)
-
-typedef void (*sc_runnable_fn)(void *userdata);
-
-bool
-sc_post_to_main_thread(sc_runnable_fn run, void *userdata);
-
-void
-sc_reject_new_runnables(void);
-
-#endif
+#define EVENT_NEW_FRAME                 SDL_USEREVENT
+#define EVENT_STREAM_STOPPED           (SDL_USEREVENT + 1)
+#define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
+#define EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
+#define EVENT_USB_DEVICE_DISCONNECTED  (SDL_USEREVENT + 4)

app/src/file_pusher.c

@@ -19,7 +19,7 @@ sc_file_pusher_init(struct sc_file_pusher *fp, const char *serial,
                     const char *push_target) {
     assert(serial);
 
-    sc_vecdeque_init(&fp->queue);
+    cbuf_init(&fp->queue);
 
     bool ok = sc_mutex_init(&fp->mutex);
     if (!ok) {
@@ -65,10 +65,9 @@ sc_file_pusher_destroy(struct sc_file_pusher *fp) {
     sc_intr_destroy(&fp->intr);
     free(fp->serial);
 
-    while (!sc_vecdeque_is_empty(&fp->queue)) {
-        struct sc_file_pusher_request *req = sc_vecdeque_popref(&fp->queue);
-        assert(req);
-        sc_file_pusher_request_destroy(req);
+    struct sc_file_pusher_request req;
+    while (cbuf_take(&fp->queue, &req)) {
+        sc_file_pusher_request_destroy(&req);
     }
 }
 
@@ -92,20 +91,13 @@ sc_file_pusher_request(struct sc_file_pusher *fp,
     };
 
     sc_mutex_lock(&fp->mutex);
-    bool was_empty = sc_vecdeque_is_empty(&fp->queue);
-    bool res = sc_vecdeque_push(&fp->queue, req);
-    if (!res) {
-        LOG_OOM();
-        sc_mutex_unlock(&fp->mutex);
-        return false;
-    }
-
+    bool was_empty = cbuf_is_empty(&fp->queue);
+    bool res = cbuf_push(&fp->queue, req);
     if (was_empty) {
         sc_cond_signal(&fp->event_cond);
     }
     sc_mutex_unlock(&fp->mutex);
-
-    return true;
+    return res;
 }
 
 static int
@@ -121,7 +113,7 @@ run_file_pusher(void *data) {
 
     for (;;) {
         sc_mutex_lock(&fp->mutex);
-        while (!fp->stopped && sc_vecdeque_is_empty(&fp->queue)) {
+        while (!fp->stopped && cbuf_is_empty(&fp->queue)) {
             sc_cond_wait(&fp->event_cond, &fp->mutex);
         }
         if (fp->stopped) {
@@ -129,9 +121,10 @@ run_file_pusher(void *data) {
             sc_mutex_unlock(&fp->mutex);
             break;
         }
-
-        assert(!sc_vecdeque_is_empty(&fp->queue));
-        struct sc_file_pusher_request req = sc_vecdeque_pop(&fp->queue);
+        struct sc_file_pusher_request req;
+        bool non_empty = cbuf_take(&fp->queue, &req);
+        assert(non_empty);
+        (void) non_empty;
         sc_mutex_unlock(&fp->mutex);
 
         if (req.action == SC_FILE_PUSHER_ACTION_INSTALL_APK) {
@@ -172,18 +165,14 @@ sc_file_pusher_start(struct sc_file_pusher *fp) {
 
 void
 sc_file_pusher_stop(struct sc_file_pusher *fp) {
-    if (fp->initialized) {
-        sc_mutex_lock(&fp->mutex);
-        fp->stopped = true;
-        sc_cond_signal(&fp->event_cond);
-        sc_intr_interrupt(&fp->intr);
-        sc_mutex_unlock(&fp->mutex);
-    }
+    sc_mutex_lock(&fp->mutex);
+    fp->stopped = true;
+    sc_cond_signal(&fp->event_cond);
+    sc_intr_interrupt(&fp->intr);
+    sc_mutex_unlock(&fp->mutex);
 }
 
 void
 sc_file_pusher_join(struct sc_file_pusher *fp) {
-    if (fp->initialized) {
-        sc_thread_join(&fp->thread, NULL);
-    }
+    sc_thread_join(&fp->thread, NULL);
 }

app/src/file_pusher.h

@@ -5,9 +5,9 @@
 
 #include <stdbool.h>
 
-#include "util/intr.h"
+#include "util/cbuf.h"
 #include "util/thread.h"
-#include "util/vecdeque.h"
+#include "util/intr.h"
 
 enum sc_file_pusher_action {
     SC_FILE_PUSHER_ACTION_INSTALL_APK,
@@ -19,7 +19,7 @@ struct sc_file_pusher_request {
     char *file;
 };
 
-struct sc_file_pusher_request_queue SC_VECDEQUE(struct sc_file_pusher_request);
+struct sc_file_pusher_request_queue CBUF(struct sc_file_pusher_request, 16);
 
 struct sc_file_pusher {
     char *serial;

app/src/fps_counter.c

@@ -96,7 +96,6 @@ run_fps_counter(void *data) {
 bool
 sc_fps_counter_start(struct sc_fps_counter *counter) {
     sc_mutex_lock(&counter->mutex);
-    counter->interrupted = false;
     counter->next_timestamp = sc_tick_now() + SC_FPS_COUNTER_INTERVAL;
     counter->nr_rendered = 0;
     counter->nr_skipped = 0;

app/src/hid/hid_event.h

@@ -1,27 +0,0 @@
-#ifndef SC_HID_EVENT_H
-#define SC_HID_EVENT_H
-
-#include "common.h"
-
-#include <stdint.h>
-
-#define SC_HID_MAX_SIZE 15
-
-struct sc_hid_input {
-    uint16_t hid_id;
-    uint8_t data[SC_HID_MAX_SIZE];
-    uint8_t size;
-};
-
-struct sc_hid_open {
-    uint16_t hid_id;
-    const char *name; // pointer to static memory
-    const uint8_t *report_desc; // pointer to static memory
-    size_t report_desc_size;
-};
-
-struct sc_hid_close {
-    uint16_t hid_id;
-};
-
-#endif

app/src/hid/hid_gamepad.c

@@ -1,457 +0,0 @@
-#include "hid_gamepad.h"
-
-#include <assert.h>
-#include <inttypes.h>
-
-#include "util/binary.h"
-#include "util/log.h"
-
-// 2x2 bytes for left stick (X, Y)
-// 2x2 bytes for right stick (Z, Rz)
-// 2x2 bytes for L2/R2 triggers
-// 2 bytes for buttons + padding,
-// 1 byte for hat switch (dpad) + padding
-#define SC_HID_GAMEPAD_EVENT_SIZE 15
-
-// The ->buttons field stores the state for all buttons, but only some of them
-// (the 16 LSB) must be transmitted "as is". The DPAD (hat switch) buttons are
-// stored locally in the MSB of this field, but not transmitted as is: they are
-// transformed to generate another specific byte.
-#define SC_HID_BUTTONS_MASK 0xFFFF
-
-// outside SC_HID_BUTTONS_MASK
-#define SC_GAMEPAD_BUTTONS_BIT_DPAD_UP    UINT32_C(0x10000)
-#define SC_GAMEPAD_BUTTONS_BIT_DPAD_DOWN  UINT32_C(0x20000)
-#define SC_GAMEPAD_BUTTONS_BIT_DPAD_LEFT  UINT32_C(0x40000)
-#define SC_GAMEPAD_BUTTONS_BIT_DPAD_RIGHT UINT32_C(0x80000)
-
-/**
- * Gamepad descriptor manually crafted to transmit the input reports.
- *
- * The HID specification is available here:
- * <https://www.usb.org/document-library/device-class-definition-hid-111>
- *
- * The HID Usage Tables is also useful:
- * <https://www.usb.org/document-library/hid-usage-tables-15>
- */
-static const uint8_t SC_HID_GAMEPAD_REPORT_DESC[] = {
-    // Usage Page (Generic Desktop)
-    0x05, 0x01,
-    // Usage (Gamepad)
-    0x09, 0x05,
-
-    // Collection (Application)
-    0xA1, 0x01,
-
-    // Collection (Physical)
-    0xA1, 0x00,
-
-    // Usage Page (Generic Desktop)
-    0x05, 0x01,
-    // Usage (X)   Left stick x
-    0x09, 0x30,
-    // Usage (Y)   Left stick y
-    0x09, 0x31,
-    // Usage (Z)   Right stick x
-    0x09, 0x32,
-    // Usage (Rz)  Right stick y
-    0x09, 0x35,
-    // Logical Minimum (0)
-    0x15, 0x00,
-    // Logical Maximum (65535)
-    // Cannot use 26 FF FF because 0xFFFF is interpreted as signed 16-bit
-    0x27, 0xFF, 0xFF, 0x00, 0x00, // little-endian
-    // Report Size (16)
-    0x75, 0x10,
-    // Report Count (4)
-    0x95, 0x04,
-    // Input (Data, Variable, Absolute): 4 bytes (X, Y, Z, Rz)
-    0x81, 0x02,
-
-    // Usage Page (Simulation Controls)
-    0x05, 0x02,
-    // Usage (Brake)
-    0x09, 0xC5,
-    // Usage (Accelerator)
-    0x09, 0xC4,
-    // Logical Minimum (0)
-    0x15, 0x00,
-    // Logical Maximum (32767)
-    0x26, 0xFF, 0x7F,
-    // Report Size (16)
-    0x75, 0x10,
-    // Report Count (2)
-    0x95, 0x02,
-    // Input (Data, Variable, Absolute): 2 bytes (L2, R2)
-    0x81, 0x02,
-
-    // Usage Page (Buttons)
-    0x05, 0x09,
-    // Usage Minimum (1)
-    0x19, 0x01,
-    // Usage Maximum (16)
-    0x29, 0x10,
-    // Logical Minimum (0)
-    0x15, 0x00,
-    // Logical Maximum (1)
-    0x25, 0x01,
-    // Report Count (16)
-    0x95, 0x10,
-    // Report Size (1)
-    0x75, 0x01,
-    // Input (Data, Variable, Absolute): 16 buttons bits
-    0x81, 0x02,
-
-    // Usage Page (Generic Desktop)
-    0x05, 0x01,
-    // Usage (Hat switch)
-    0x09, 0x39,
-    // Logical Minimum (1)
-    0x15, 0x01,
-    // Logical Maximum (8)
-    0x25, 0x08,
-    // Report Size (4)
-    0x75, 0x04,
-    // Report Count (1)
-    0x95, 0x01,
-    // Input (Data, Variable, Null State): 4-bit value
-    0x81, 0x42,
-
-    // End Collection
-    0xC0,
-
-    // End Collection
-    0xC0,
-};
-
-/**
- * A gamepad HID input report is 15 bytes long:
- *  - bytes 0-3:   left stick state
- *  - bytes 4-7:   right stick state
- *  - bytes 8-11:  L2/R2 triggers state
- *  - bytes 12-13: buttons state
- *  - bytes 14:    hat switch position (dpad)
- *
- *                  +---------------+
- *         byte 0:  |. . . . . . . .|
- *                  |               | left stick x (0-65535, little-endian)
- *         byte 1:  |. . . . . . . .|
- *                  +---------------+
- *         byte 2:  |. . . . . . . .|
- *                  |               | left stick y (0-65535, little-endian)
- *         byte 3:  |. . . . . . . .|
- *                  +---------------+
- *         byte 4:  |. . . . . . . .|
- *                  |               | right stick x (0-65535, little-endian)
- *         byte 5:  |. . . . . . . .|
- *                  +---------------+
- *         byte 6:  |. . . . . . . .|
- *                  |               | right stick y (0-65535, little-endian)
- *         byte 7:  |. . . . . . . .|
- *                  +---------------+
- *         byte 8:  |. . . . . . . .|
- *                  |               | L2 trigger (0-32767, little-endian)
- *         byte 9:  |0 . . . . . . .|
- *                  +---------------+
- *        byte 10:  |. . . . . . . .|
- *                  |               | R2 trigger (0-32767, little-endian)
- *        byte 11:  |0 . . . . . . .|
- *                  +---------------+
- *
- *                   ,--------------- SC_GAMEPAD_BUTTON_RIGHT_SHOULDER
- *                   | ,------------- SC_GAMEPAD_BUTTON_LEFT_SHOULDER
- *                   | |
- *                   | |   ,--------- SC_GAMEPAD_BUTTON_NORTH
- *                   | |   | ,------- SC_GAMEPAD_BUTTON_WEST
- *                   | |   | |
- *                   | |   | |   ,--- SC_GAMEPAD_BUTTON_EAST
- *                   | |   | |   | ,- SC_GAMEPAD_BUTTON_SOUTH
- *                   v v   v v   v v
- *                  +---------------+
- *        byte 12:  |. . 0 . . 0 . .|
- *                  |               | Buttons (16-bit little-endian)
- *        byte 13:  |0 . . . . . 0 0|
- *                  +---------------+
- *                     ^ ^ ^ ^ ^
- *                     | | | | |
- *                     | | | | |
- *                     | | | | `----- SC_GAMEPAD_BUTTON_BACK
- *                     | | | `------- SC_GAMEPAD_BUTTON_START
- *                     | | `--------- SC_GAMEPAD_BUTTON_GUIDE
- *                     | `----------- SC_GAMEPAD_BUTTON_LEFT_STICK
- *                     `------------- SC_GAMEPAD_BUTTON_RIGHT_STICK
- *
- *                  +---------------+
- *        byte 14:  |0 0 0 . . . . .| hat switch (dpad) position (0-8)
- *                  +---------------+
- *                     9 possible positions and their values:
- *                             8 1 2
- *                             7 0 3
- *                             6 5 4
- *                     (8 is top-left, 1 is top, 2 is top-right, etc.)
- */
-
-static void
-sc_hid_gamepad_slot_init(struct sc_hid_gamepad_slot *slot,
-                         uint32_t gamepad_id) {
-    assert(gamepad_id != SC_GAMEPAD_ID_INVALID);
-    slot->gamepad_id = gamepad_id;
-    slot->buttons = 0;
-    slot->axis_left_x = 0;
-    slot->axis_left_y = 0;
-    slot->axis_right_x = 0;
-    slot->axis_right_y = 0;
-    slot->axis_left_trigger = 0;
-    slot->axis_right_trigger = 0;
-}
-
-static ssize_t
-sc_hid_gamepad_slot_find(struct sc_hid_gamepad *hid, uint32_t gamepad_id) {
-    for (size_t i = 0; i < SC_MAX_GAMEPADS; ++i) {
-        if (gamepad_id == hid->slots[i].gamepad_id) {
-            // found
-            return i;
-        }
-    }
-
-    return -1;
-}
-
-void
-sc_hid_gamepad_init(struct sc_hid_gamepad *hid) {
-    for (size_t i = 0; i < SC_MAX_GAMEPADS; ++i) {
-        hid->slots[i].gamepad_id = SC_GAMEPAD_ID_INVALID;
-    }
-}
-
-static inline uint16_t
-sc_hid_gamepad_slot_get_id(size_t slot_idx) {
-    assert(slot_idx < SC_MAX_GAMEPADS);
-    return SC_HID_ID_GAMEPAD_FIRST + slot_idx;
-}
-
-bool
-sc_hid_gamepad_generate_open(struct sc_hid_gamepad *hid,
-                             struct sc_hid_open *hid_open,
-                             uint32_t gamepad_id) {
-    assert(gamepad_id != SC_GAMEPAD_ID_INVALID);
-    ssize_t slot_idx = sc_hid_gamepad_slot_find(hid, SC_GAMEPAD_ID_INVALID);
-    if (slot_idx == -1) {
-        LOGW("No gamepad slot available for new gamepad %" PRIu32, gamepad_id);
-        return false;
-    }
-
-    sc_hid_gamepad_slot_init(&hid->slots[slot_idx], gamepad_id);
-
-    SDL_GameController* game_controller =
-        SDL_GameControllerFromInstanceID(gamepad_id);
-    assert(game_controller);
-    const char *name = SDL_GameControllerName(game_controller);
-
-    uint16_t hid_id = sc_hid_gamepad_slot_get_id(slot_idx);
-    hid_open->hid_id = hid_id;
-    hid_open->name = name;
-    hid_open->report_desc = SC_HID_GAMEPAD_REPORT_DESC;
-    hid_open->report_desc_size = sizeof(SC_HID_GAMEPAD_REPORT_DESC);
-
-    return true;
-}
-
-bool
-sc_hid_gamepad_generate_close(struct sc_hid_gamepad *hid,
-                              struct sc_hid_close *hid_close,
-                              uint32_t gamepad_id) {
-    assert(gamepad_id != SC_GAMEPAD_ID_INVALID);
-    ssize_t slot_idx = sc_hid_gamepad_slot_find(hid, gamepad_id);
-    if (slot_idx == -1) {
-        LOGW("Unknown gamepad removed %" PRIu32, gamepad_id);
-        return false;
-    }
-
-    hid->slots[slot_idx].gamepad_id = SC_GAMEPAD_ID_INVALID;
-
-    uint16_t hid_id = sc_hid_gamepad_slot_get_id(slot_idx);
-    hid_close->hid_id = hid_id;
-
-    return true;
-}
-
-static uint8_t
-sc_hid_gamepad_get_dpad_value(uint32_t buttons) {
-    // Value depending on direction:
-    //     8 1 2
-    //     7 0 3
-    //     6 5 4
-    if (buttons & SC_GAMEPAD_BUTTONS_BIT_DPAD_UP) {
-        if (buttons & SC_GAMEPAD_BUTTONS_BIT_DPAD_LEFT) {
-            return 8;
-        }
-        if (buttons & SC_GAMEPAD_BUTTONS_BIT_DPAD_RIGHT) {
-            return 2;
-        }
-        return 1;
-    }
-    if (buttons & SC_GAMEPAD_BUTTONS_BIT_DPAD_DOWN) {
-        if (buttons & SC_GAMEPAD_BUTTONS_BIT_DPAD_LEFT) {
-            return 6;
-        }
-        if (buttons & SC_GAMEPAD_BUTTONS_BIT_DPAD_RIGHT) {
-            return 4;
-        }
-        return 5;
-    }
-    if (buttons & SC_GAMEPAD_BUTTONS_BIT_DPAD_LEFT) {
-        return 7;
-    }
-    if (buttons & SC_GAMEPAD_BUTTONS_BIT_DPAD_RIGHT) {
-        return 3;
-    }
-
-    return 0;
-}
-
-static void
-sc_hid_gamepad_event_from_slot(uint16_t hid_id,
-                               const struct sc_hid_gamepad_slot *slot,
-                               struct sc_hid_input *hid_input) {
-    hid_input->hid_id = hid_id;
-    hid_input->size = SC_HID_GAMEPAD_EVENT_SIZE;
-
-    uint8_t *data = hid_input->data;
-    // Values must be written in little-endian
-    sc_write16le(data, slot->axis_left_x);
-    sc_write16le(data + 2, slot->axis_left_y);
-    sc_write16le(data + 4, slot->axis_right_x);
-    sc_write16le(data + 6, slot->axis_right_y);
-    sc_write16le(data + 8, slot->axis_left_trigger);
-    sc_write16le(data + 10, slot->axis_right_trigger);
-    sc_write16le(data + 12, slot->buttons & SC_HID_BUTTONS_MASK);
-    data[14] = sc_hid_gamepad_get_dpad_value(slot->buttons);
-}
-
-static uint32_t
-sc_hid_gamepad_get_button_id(enum sc_gamepad_button button) {
-    switch (button) {
-        case SC_GAMEPAD_BUTTON_SOUTH:
-            return 0x0001;
-        case SC_GAMEPAD_BUTTON_EAST:
-            return 0x0002;
-        case SC_GAMEPAD_BUTTON_WEST:
-            return 0x0008;
-        case SC_GAMEPAD_BUTTON_NORTH:
-            return 0x0010;
-        case SC_GAMEPAD_BUTTON_BACK:
-            return 0x0400;
-        case SC_GAMEPAD_BUTTON_GUIDE:
-            return 0x1000;
-        case SC_GAMEPAD_BUTTON_START:
-            return 0x0800;
-        case SC_GAMEPAD_BUTTON_LEFT_STICK:
-            return 0x2000;
-        case SC_GAMEPAD_BUTTON_RIGHT_STICK:
-            return 0x4000;
-        case SC_GAMEPAD_BUTTON_LEFT_SHOULDER:
-            return 0x0040;
-        case SC_GAMEPAD_BUTTON_RIGHT_SHOULDER:
-            return 0x0080;
-        case SC_GAMEPAD_BUTTON_DPAD_UP:
-            return SC_GAMEPAD_BUTTONS_BIT_DPAD_UP;
-        case SC_GAMEPAD_BUTTON_DPAD_DOWN:
-            return SC_GAMEPAD_BUTTONS_BIT_DPAD_DOWN;
-        case SC_GAMEPAD_BUTTON_DPAD_LEFT:
-            return SC_GAMEPAD_BUTTONS_BIT_DPAD_LEFT;
-        case SC_GAMEPAD_BUTTON_DPAD_RIGHT:
-            return SC_GAMEPAD_BUTTONS_BIT_DPAD_RIGHT;
-        default:
-            // unknown button, ignore
-            return 0;
-    }
-}
-
-bool
-sc_hid_gamepad_generate_input_from_button(struct sc_hid_gamepad *hid,
-                                          struct sc_hid_input *hid_input,
-                                const struct sc_gamepad_button_event *event) {
-    if ((event->button < 0) || (event->button > 15)) {
-        return false;
-    }
-
-    uint32_t gamepad_id = event->gamepad_id;
-
-    ssize_t slot_idx = sc_hid_gamepad_slot_find(hid, gamepad_id);
-    if (slot_idx == -1) {
-        LOGW("Axis event for unknown gamepad %" PRIu32, gamepad_id);
-        return false;
-    }
-
-    assert(slot_idx < SC_MAX_GAMEPADS);
-
-    struct sc_hid_gamepad_slot *slot = &hid->slots[slot_idx];
-
-    uint32_t button = sc_hid_gamepad_get_button_id(event->button);
-    if (!button) {
-        // unknown button, ignore
-        return false;
-    }
-
-    if (event->action == SC_ACTION_DOWN) {
-        slot->buttons |= button;
-    } else {
-        assert(event->action == SC_ACTION_UP);
-        slot->buttons &= ~button;
-    }
-
-    uint16_t hid_id = sc_hid_gamepad_slot_get_id(slot_idx);
-    sc_hid_gamepad_event_from_slot(hid_id, slot, hid_input);
-
-    return true;
-}
-
-bool
-sc_hid_gamepad_generate_input_from_axis(struct sc_hid_gamepad *hid,
-                                        struct sc_hid_input *hid_input,
-                                const struct sc_gamepad_axis_event *event) {
-    uint32_t gamepad_id = event->gamepad_id;
-
-    ssize_t slot_idx = sc_hid_gamepad_slot_find(hid, gamepad_id);
-    if (slot_idx == -1) {
-        LOGW("Button event for unknown gamepad %" PRIu32, gamepad_id);
-        return false;
-    }
-
-    assert(slot_idx < SC_MAX_GAMEPADS);
-
-    struct sc_hid_gamepad_slot *slot = &hid->slots[slot_idx];
-
-// [-32768 to 32767] -> [0 to 65535]
-#define AXIS_RESCALE(V) (uint16_t) (((int32_t) V) + 0x8000)
-    switch (event->axis) {
-        case SC_GAMEPAD_AXIS_LEFTX:
-            slot->axis_left_x = AXIS_RESCALE(event->value);
-            break;
-        case SC_GAMEPAD_AXIS_LEFTY:
-            slot->axis_left_y = AXIS_RESCALE(event->value);
-            break;
-        case SC_GAMEPAD_AXIS_RIGHTX:
-            slot->axis_right_x = AXIS_RESCALE(event->value);
-            break;
-        case SC_GAMEPAD_AXIS_RIGHTY:
-            slot->axis_right_y = AXIS_RESCALE(event->value);
-            break;
-        case SC_GAMEPAD_AXIS_LEFT_TRIGGER:
-            // Trigger is always positive between 0 and 32767
-            slot->axis_left_trigger = MAX(0, event->value);
-            break;
-        case SC_GAMEPAD_AXIS_RIGHT_TRIGGER:
-            // Trigger is always positive between 0 and 32767
-            slot->axis_right_trigger = MAX(0, event->value);
-            break;
-        default:
-            return false;
-    }
-
-    uint16_t hid_id = sc_hid_gamepad_slot_get_id(slot_idx);
-    sc_hid_gamepad_event_from_slot(hid_id, slot, hid_input);
-
-    return true;
-}

app/src/hid/hid_gamepad.h

@@ -1,53 +0,0 @@
-#ifndef SC_HID_GAMEPAD_H
-#define SC_HID_GAMEPAD_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "hid/hid_event.h"
-#include "input_events.h"
-
-#define SC_MAX_GAMEPADS 8
-#define SC_HID_ID_GAMEPAD_FIRST 3
-#define SC_HID_ID_GAMEPAD_LAST (SC_HID_ID_GAMEPAD_FIRST + SC_MAX_GAMEPADS - 1)
-
-struct sc_hid_gamepad_slot {
-    uint32_t gamepad_id;
-    uint32_t buttons;
-    uint16_t axis_left_x;
-    uint16_t axis_left_y;
-    uint16_t axis_right_x;
-    uint16_t axis_right_y;
-    uint16_t axis_left_trigger;
-    uint16_t axis_right_trigger;
-};
-
-struct sc_hid_gamepad {
-    struct sc_hid_gamepad_slot slots[SC_MAX_GAMEPADS];
-};
-
-void
-sc_hid_gamepad_init(struct sc_hid_gamepad *hid);
-
-bool
-sc_hid_gamepad_generate_open(struct sc_hid_gamepad *hid,
-                             struct sc_hid_open *hid_open,
-                             uint32_t gamepad_id);
-
-bool
-sc_hid_gamepad_generate_close(struct sc_hid_gamepad *hid,
-                              struct sc_hid_close *hid_close,
-                              uint32_t gamepad_id);
-
-bool
-sc_hid_gamepad_generate_input_from_button(struct sc_hid_gamepad *hid,
-                                          struct sc_hid_input *hid_input,
-                                const struct sc_gamepad_button_event *event);
-
-bool
-sc_hid_gamepad_generate_input_from_axis(struct sc_hid_gamepad *hid,
-                                        struct sc_hid_input *hid_input,
-                                const struct sc_gamepad_axis_event *event);
-
-#endif

app/src/hid/hid_mouse.c

@@ -1,200 +0,0 @@
-#include "hid_mouse.h"
-
-// 1 byte for buttons + padding, 1 byte for X position, 1 byte for Y position,
-// 1 byte for wheel motion
-#define SC_HID_MOUSE_INPUT_SIZE 4
-
-/**
- * Mouse descriptor from the specification:
- * <https://www.usb.org/document-library/device-class-definition-hid-111>
- *
- * Appendix E (p71): §E.10 Report Descriptor (Mouse)
- *
- * The usage tags (like Wheel) are listed in "HID Usage Tables":
- * <https://www.usb.org/document-library/hid-usage-tables-15>
- * §4 Generic Desktop Page (0x01) (p32)
- */
-static const uint8_t SC_HID_MOUSE_REPORT_DESC[] = {
-    // Usage Page (Generic Desktop)
-    0x05, 0x01,
-    // Usage (Mouse)
-    0x09, 0x02,
-
-    // Collection (Application)
-    0xA1, 0x01,
-
-    // Usage (Pointer)
-    0x09, 0x01,
-
-    // Collection (Physical)
-    0xA1, 0x00,
-
-    // Usage Page (Buttons)
-    0x05, 0x09,
-
-    // Usage Minimum (1)
-    0x19, 0x01,
-    // Usage Maximum (5)
-    0x29, 0x05,
-    // Logical Minimum (0)
-    0x15, 0x00,
-    // Logical Maximum (1)
-    0x25, 0x01,
-    // Report Count (5)
-    0x95, 0x05,
-    // Report Size (1)
-    0x75, 0x01,
-    // Input (Data, Variable, Absolute): 5 buttons bits
-    0x81, 0x02,
-
-    // Report Count (1)
-    0x95, 0x01,
-    // Report Size (3)
-    0x75, 0x03,
-    // Input (Constant): 3 bits padding
-    0x81, 0x01,
-
-    // Usage Page (Generic Desktop)
-    0x05, 0x01,
-    // Usage (X)
-    0x09, 0x30,
-    // Usage (Y)
-    0x09, 0x31,
-    // Usage (Wheel)
-    0x09, 0x38,
-    // Logical Minimum (-127)
-    0x15, 0x81,
-    // Logical Maximum (127)
-    0x25, 0x7F,
-    // Report Size (8)
-    0x75, 0x08,
-    // Report Count (3)
-    0x95, 0x03,
-    // Input (Data, Variable, Relative): 3 position bytes (X, Y, Wheel)
-    0x81, 0x06,
-
-    // End Collection
-    0xC0,
-
-    // End Collection
-    0xC0,
-};
-
-/**
- * A mouse HID input report is 4 bytes long:
- *
- *  - byte 0: buttons state
- *  - byte 1: relative x motion (signed byte from -127 to 127)
- *  - byte 2: relative y motion (signed byte from -127 to 127)
- *  - byte 3: wheel motion (-1, 0 or 1)
- *
- *                   7 6 5 4 3 2 1 0
- *                  +---------------+
- *         byte 0:  |0 0 0 . . . . .| buttons state
- *                  +---------------+
- *                         ^ ^ ^ ^ ^
- *                         | | | | `- left button
- *                         | | | `--- right button
- *                         | | `----- middle button
- *                         | `------- button 4
- *                         `--------- button 5
- *
- *                  +---------------+
- *         byte 1:  |. . . . . . . .| relative x motion
- *                  +---------------+
- *         byte 2:  |. . . . . . . .| relative y motion
- *                  +---------------+
- *         byte 3:  |. . . . . . . .| wheel motion
- *                  +---------------+
- *
- * As an example, here is the report for a motion of (x=5, y=-4) with left
- * button pressed:
- *
- *                  +---------------+
- *                  |0 0 0 0 0 0 0 1| left button pressed
- *                  +---------------+
- *                  |0 0 0 0 0 1 0 1| horizontal motion (x = 5)
- *                  +---------------+
- *                  |1 1 1 1 1 1 0 0| relative y motion (y = -4)
- *                  +---------------+
- *                  |0 0 0 0 0 0 0 0| wheel motion
- *                  +---------------+
- */
-
-static void
-sc_hid_mouse_input_init(struct sc_hid_input *hid_input) {
-    hid_input->hid_id = SC_HID_ID_MOUSE;
-    hid_input->size = SC_HID_MOUSE_INPUT_SIZE;
-    // Leave ->data uninitialized, it will be fully initialized by callers
-}
-
-static uint8_t
-sc_hid_buttons_from_buttons_state(uint8_t buttons_state) {
-    uint8_t c = 0;
-    if (buttons_state & SC_MOUSE_BUTTON_LEFT) {
-        c |= 1 << 0;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_RIGHT) {
-        c |= 1 << 1;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_MIDDLE) {
-        c |= 1 << 2;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_X1) {
-        c |= 1 << 3;
-    }
-    if (buttons_state & SC_MOUSE_BUTTON_X2) {
-        c |= 1 << 4;
-    }
-    return c;
-}
-
-void
-sc_hid_mouse_generate_input_from_motion(struct sc_hid_input *hid_input,
-                                    const struct sc_mouse_motion_event *event) {
-    sc_hid_mouse_input_init(hid_input);
-
-    uint8_t *data = hid_input->data;
-    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; // wheel coordinates only used for scrolling
-}
-
-void
-sc_hid_mouse_generate_input_from_click(struct sc_hid_input *hid_input,
-                                     const struct sc_mouse_click_event *event) {
-    sc_hid_mouse_input_init(hid_input);
-
-    uint8_t *data = hid_input->data;
-    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; // wheel coordinates only used for scrolling
-}
-
-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);
-
-    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
-    // 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) {
-    hid_open->hid_id = SC_HID_ID_MOUSE;
-    hid_open->name = NULL; // No name specified after "scrcpy"
-    hid_open->report_desc = SC_HID_MOUSE_REPORT_DESC;
-    hid_open->report_desc_size = sizeof(SC_HID_MOUSE_REPORT_DESC);
-}
-
-void sc_hid_mouse_generate_close(struct sc_hid_close *hid_close) {
-    hid_close->hid_id = SC_HID_ID_MOUSE;
-}

app/src/hid/hid_mouse.h

@@ -1,31 +0,0 @@
-#ifndef SC_HID_MOUSE_H
-#define SC_HID_MOUSE_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "hid/hid_event.h"
-#include "input_events.h"
-
-#define SC_HID_ID_MOUSE 2
-
-void
-sc_hid_mouse_generate_open(struct sc_hid_open *hid_open);
-
-void
-sc_hid_mouse_generate_close(struct sc_hid_close *hid_close);
-
-void
-sc_hid_mouse_generate_input_from_motion(struct sc_hid_input *hid_input,
-                                    const struct sc_mouse_motion_event *event);
-
-void
-sc_hid_mouse_generate_input_from_click(struct sc_hid_input *hid_input,
-                                    const struct sc_mouse_click_event *event);
-
-void
-sc_hid_mouse_generate_input_from_scroll(struct sc_hid_input *hid_input,
-                                    const struct sc_mouse_scroll_event *event);
-
-#endif

app/src/icon.c

@@ -9,7 +9,6 @@
 
 #include "config.h"
 #include "compat.h"
-#include "util/env.h"
 #include "util/file.h"
 #include "util/log.h"
 #include "util/str.h"
@@ -20,22 +19,35 @@
 
 static char *
 get_icon_path(void) {
-    char *icon_path = sc_get_env("SCRCPY_ICON_PATH");
-    if (icon_path) {
+#ifdef __WINDOWS__
+    const wchar_t *icon_path_env = _wgetenv(L"SCRCPY_ICON_PATH");
+#else
+    const char *icon_path_env = getenv("SCRCPY_ICON_PATH");
+#endif
+    if (icon_path_env) {
         // if the envvar is set, use it
+#ifdef __WINDOWS__
+        char *icon_path = sc_str_from_wchars(icon_path_env);
+#else
+        char *icon_path = strdup(icon_path_env);
+#endif
+        if (!icon_path) {
+            LOG_OOM();
+            return NULL;
+        }
         LOGD("Using SCRCPY_ICON_PATH: %s", icon_path);
         return icon_path;
     }
 
 #ifndef PORTABLE
     LOGD("Using icon: " SCRCPY_DEFAULT_ICON_PATH);
-    icon_path = strdup(SCRCPY_DEFAULT_ICON_PATH);
+    char *icon_path = strdup(SCRCPY_DEFAULT_ICON_PATH);
     if (!icon_path) {
         LOG_OOM();
         return NULL;
     }
 #else
-    icon_path = sc_file_get_local_path(SCRCPY_PORTABLE_ICON_FILENAME);
+    char *icon_path = sc_file_get_local_path(SCRCPY_PORTABLE_ICON_FILENAME);
     if (!icon_path) {
         LOGE("Could not get icon path");
         return NULL;
@@ -57,7 +69,7 @@ decode_image(const char *path) {
     }
 
     if (avformat_open_input(&ctx, path, NULL, NULL) < 0) {
-        LOGE("Could not open icon image: %s", path);
+        LOGE("Could not open image codec: %s", path);
         goto free_ctx;
     }
 
@@ -66,19 +78,7 @@ decode_image(const char *path) {
         goto close_input;
     }
 
-
-// In ffmpeg/doc/APIchanges:
-// 2021-04-27 - 46dac8cf3d - lavf 59.0.100 - avformat.h
-//   av_find_best_stream now uses a const AVCodec ** parameter
-//   for the returned decoder.
-#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(59, 0, 100)
-    const AVCodec *codec;
-#else
-    AVCodec *codec;
-#endif
-
-    int stream =
-        av_find_best_stream(ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &codec, 0);
+    int stream = av_find_best_stream(ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
     if (stream < 0 ) {
         LOGE("Could not find best image stream");
         goto close_input;
@@ -86,6 +86,12 @@ decode_image(const char *path) {
 
     AVCodecParameters *params = ctx->streams[stream]->codecpar;
 
+    const AVCodec *codec = avcodec_find_decoder(params->codec_id);
+    if (!codec) {
+        LOGE("Could not find image decoder");
+        goto close_input;
+    }
+
     AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
     if (!codec_ctx) {
         LOG_OOM();
@@ -105,21 +111,21 @@ decode_image(const char *path) {
     AVFrame *frame = av_frame_alloc();
     if (!frame) {
         LOG_OOM();
-        goto free_codec_ctx;
+        goto close_codec;
     }
 
     AVPacket *packet = av_packet_alloc();
     if (!packet) {
         LOG_OOM();
         av_frame_free(&frame);
-        goto free_codec_ctx;
+        goto close_codec;
     }
 
     if (av_read_frame(ctx, packet) < 0) {
         LOGE("Could not read frame");
         av_packet_free(&packet);
         av_frame_free(&frame);
-        goto free_codec_ctx;
+        goto close_codec;
     }
 
     int ret;
@@ -127,20 +133,22 @@ decode_image(const char *path) {
         LOGE("Could not send icon packet: %d", ret);
         av_packet_free(&packet);
         av_frame_free(&frame);
-        goto free_codec_ctx;
+        goto close_codec;
     }
 
     if ((ret = avcodec_receive_frame(codec_ctx, frame)) != 0) {
         LOGE("Could not receive icon frame: %d", ret);
         av_packet_free(&packet);
         av_frame_free(&frame);
-        goto free_codec_ctx;
+        goto close_codec;
     }
 
     av_packet_free(&packet);
 
     result = frame;
 
+close_codec:
+    avcodec_close(codec_ctx);
 free_codec_ctx:
     avcodec_free_context(&codec_ctx);
 close_input:
@@ -263,7 +271,7 @@ error:
 }
 
 SDL_Surface *
-scrcpy_icon_load(void) {
+scrcpy_icon_load() {
     char *icon_path = get_icon_path();
     if (!icon_path) {
         return NULL;

app/src/input_events.h

@@ -9,7 +9,6 @@
 #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.
@@ -323,38 +322,6 @@ enum sc_mouse_button {
     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_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_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),
               "SDL_Keymod must be convertible to sc_mod");
 
@@ -412,33 +379,6 @@ struct sc_touch_event {
     float pressure;
 };
 
-enum sc_gamepad_device_event_type {
-    SC_GAMEPAD_DEVICE_ADDED,
-    SC_GAMEPAD_DEVICE_REMOVED,
-};
-
-// 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 {
-    enum sc_gamepad_device_event_type type;
-    uint32_t gamepad_id;
-};
-
-struct sc_gamepad_button_event {
-    uint32_t gamepad_id;
-    enum sc_action action;
-    enum sc_gamepad_button button;
-};
-
-struct sc_gamepad_axis_event {
-    uint32_t gamepad_id;
-    enum sc_gamepad_axis axis;
-    int16_t value;
-};
-
 static inline uint16_t
 sc_mods_state_from_sdl(uint16_t mods_state) {
     return mods_state;
@@ -496,50 +436,19 @@ sc_mouse_button_from_sdl(uint8_t button) {
 }
 
 static inline uint8_t
-sc_mouse_buttons_state_from_sdl(uint32_t buttons_state) {
+sc_mouse_buttons_state_from_sdl(uint32_t buttons_state,
+                                bool forward_all_clicks) {
     assert(buttons_state < 0x100); // fits in uint8_t
 
-    // SC_MOUSE_BUTTON_* constants are initialized from SDL_BUTTON(index)
-    return buttons_state;
-}
-
-static inline enum sc_gamepad_device_event_type
-sc_gamepad_device_event_type_from_sdl_type(uint32_t type) {
-    assert(type == SDL_CONTROLLERDEVICEADDED
-        || type == SDL_CONTROLLERDEVICEREMOVED);
-    if (type == SDL_CONTROLLERDEVICEADDED) {
-        return SC_GAMEPAD_DEVICE_ADDED;
+    uint8_t mask = SC_MOUSE_BUTTON_LEFT;
+    if (forward_all_clicks) {
+        mask |= SC_MOUSE_BUTTON_RIGHT
+              | SC_MOUSE_BUTTON_MIDDLE
+              | SC_MOUSE_BUTTON_X1
+              | SC_MOUSE_BUTTON_X2;
     }
-    return SC_GAMEPAD_DEVICE_REMOVED;
-}
 
-static inline enum sc_gamepad_axis
-sc_gamepad_axis_from_sdl(uint8_t axis) {
-    if (axis <= SDL_CONTROLLER_AXIS_TRIGGERRIGHT) {
-        // SC_GAMEPAD_AXIS_* constants are initialized from
-        // SDL_CONTROLLER_AXIS_*
-        return axis;
-    }
-    return SC_GAMEPAD_AXIS_UNKNOWN;
-}
-
-static inline enum sc_gamepad_button
-sc_gamepad_button_from_sdl(uint8_t button) {
-    if (button <= SDL_CONTROLLER_BUTTON_DPAD_RIGHT) {
-        // SC_GAMEPAD_BUTTON_* constants are initialized from
-        // SDL_CONTROLLER_BUTTON_*
-        return button;
-    }
-    return SC_GAMEPAD_BUTTON_UNKNOWN;
-}
-
-static inline enum sc_action
-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;
+    return buttons_state & mask;
 }
 
 #endif

app/src/input_manager.h

@@ -11,7 +11,6 @@
 #include "file_pusher.h"
 #include "fps_counter.h"
 #include "options.h"
-#include "trait/gamepad_processor.h"
 #include "trait/key_processor.h"
 #include "trait/mouse_processor.h"
 
@@ -22,19 +21,17 @@ struct sc_input_manager {
 
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
-    struct sc_gamepad_processor *gp;
 
-    struct sc_mouse_bindings mouse_bindings;
+    bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
 
-    uint16_t sdl_shortcut_mods;
+    struct {
+        unsigned data[SC_MAX_SHORTCUT_MODS];
+        unsigned count;
+    } sdl_shortcut_mods;
 
     bool vfinger_down;
-    bool vfinger_invert_x;
-    bool vfinger_invert_y;
-
-    uint8_t mouse_buttons_state; // OR of enum sc_mouse_button values
 
     // Tracks the number of identical consecutive shortcut key down events.
     // Not to be confused with event->repeat, which counts the number of
@@ -52,12 +49,11 @@ struct sc_input_manager_params {
     struct sc_screen *screen;
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
-    struct sc_gamepad_processor *gp;
 
-    struct sc_mouse_bindings mouse_bindings;
+    bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
-    uint8_t shortcut_mods; // OR of enum sc_shortcut_mod values
+    const struct sc_shortcut_mods *shortcut_mods;
 };
 
 void
@@ -65,7 +61,6 @@ sc_input_manager_init(struct sc_input_manager *im,
                       const struct sc_input_manager_params *params);
 
 void
-sc_input_manager_handle_event(struct sc_input_manager *im,
-                              const SDL_Event *event);
+sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event);
 
 #endif

app/src/keyboard_inject.c

@@ -1,4 +1,4 @@
-#include "keyboard_sdk.h"
+#include "keyboard_inject.h"
 
 #include <assert.h>
 
@@ -9,8 +9,8 @@
 #include "util/intmap.h"
 #include "util/log.h"
 
-/** Downcast key processor to sc_keyboard_sdk */
-#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_sdk, key_processor)
+/** Downcast key processor to sc_keyboard_inject */
+#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_inject, key_processor)
 
 static enum android_keyevent_action
 convert_keycode_action(enum sc_action action) {
@@ -45,10 +45,6 @@ convert_keycode(enum sc_keycode from, enum android_keycode *to, uint16_t mod,
         {SC_KEYCODE_RCTRL,     AKEYCODE_CTRL_RIGHT},
         {SC_KEYCODE_LSHIFT,    AKEYCODE_SHIFT_LEFT},
         {SC_KEYCODE_RSHIFT,    AKEYCODE_SHIFT_RIGHT},
-        {SC_KEYCODE_LALT,      AKEYCODE_ALT_LEFT},
-        {SC_KEYCODE_RALT,      AKEYCODE_ALT_RIGHT},
-        {SC_KEYCODE_LGUI,      AKEYCODE_META_LEFT},
-        {SC_KEYCODE_RGUI,      AKEYCODE_META_RIGHT},
     };
 
     // Numpad navigation keys.
@@ -170,7 +166,11 @@ convert_keycode(enum sc_keycode from, enum android_keycode *to, uint16_t mod,
         return false;
     }
 
-    // Handle letters and space
+    if (mod & (SC_MOD_LALT | SC_MOD_RALT | SC_MOD_LGUI | SC_MOD_RGUI)) {
+        return false;
+    }
+
+    // if ALT and META are not pressed, also handle letters and space
     entry = SC_INTMAP_FIND_ENTRY(alphaspace_keys, from);
     if (entry) {
         *to = entry->value;
@@ -271,20 +271,20 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
     // is set before injecting Ctrl+v.
     (void) ack_to_wait;
 
-    struct sc_keyboard_sdk *kb = DOWNCAST(kp);
+    struct sc_keyboard_inject *ki = DOWNCAST(kp);
 
     if (event->repeat) {
-        if (!kb->forward_key_repeat) {
+        if (!ki->forward_key_repeat) {
             return;
         }
-        ++kb->repeat;
+        ++ki->repeat;
     } else {
-        kb->repeat = 0;
+        ki->repeat = 0;
     }
 
     struct sc_control_msg msg;
-    if (convert_input_key(event, &msg, kb->key_inject_mode, kb->repeat)) {
-        if (!sc_controller_push_msg(kb->controller, &msg)) {
+    if (convert_input_key(event, &msg, ki->key_inject_mode, ki->repeat)) {
+        if (!sc_controller_push_msg(ki->controller, &msg)) {
             LOGW("Could not request 'inject keycode'");
         }
     }
@@ -293,14 +293,14 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
 static void
 sc_key_processor_process_text(struct sc_key_processor *kp,
                               const struct sc_text_event *event) {
-    struct sc_keyboard_sdk *kb = DOWNCAST(kp);
+    struct sc_keyboard_inject *ki = DOWNCAST(kp);
 
-    if (kb->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
+    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
         // Never inject text events
         return;
     }
 
-    if (kb->key_inject_mode == SC_KEY_INJECT_MODE_MIXED) {
+    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_MIXED) {
         char c = event->text[0];
         if (isalpha(c) || c == ' ') {
             assert(event->text[1] == '\0');
@@ -316,22 +316,22 @@ sc_key_processor_process_text(struct sc_key_processor *kp,
         LOGW("Could not strdup input text");
         return;
     }
-    if (!sc_controller_push_msg(kb->controller, &msg)) {
+    if (!sc_controller_push_msg(ki->controller, &msg)) {
         free(msg.inject_text.text);
         LOGW("Could not request 'inject text'");
     }
 }
 
 void
-sc_keyboard_sdk_init(struct sc_keyboard_sdk *kb,
-                     struct sc_controller *controller,
-                     enum sc_key_inject_mode key_inject_mode,
-                     bool forward_key_repeat) {
-    kb->controller = controller;
-    kb->key_inject_mode = key_inject_mode;
-    kb->forward_key_repeat = forward_key_repeat;
+sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
+                        struct sc_controller *controller,
+                        enum sc_key_inject_mode key_inject_mode,
+                        bool forward_key_repeat) {
+    ki->controller = controller;
+    ki->key_inject_mode = key_inject_mode;
+    ki->forward_key_repeat = forward_key_repeat;
 
-    kb->repeat = 0;
+    ki->repeat = 0;
 
     static const struct sc_key_processor_ops ops = {
         .process_key = sc_key_processor_process_key,
@@ -339,7 +339,6 @@ sc_keyboard_sdk_init(struct sc_keyboard_sdk *kb,
     };
 
     // Key injection and clipboard synchronization are serialized
-    kb->key_processor.async_paste = false;
-    kb->key_processor.hid = false;
-    kb->key_processor.ops = &ops;
+    ki->key_processor.async_paste = false;
+    ki->key_processor.ops = &ops;
 }

app/src/keyboard_inject.h

@@ -1,5 +1,5 @@
-#ifndef SC_KEYBOARD_SDK_H
-#define SC_KEYBOARD_SDK_H
+#ifndef SC_KEYBOARD_INJECT_H
+#define SC_KEYBOARD_INJECT_H
 
 #include "common.h"
 
@@ -9,7 +9,7 @@
 #include "options.h"
 #include "trait/key_processor.h"
 
-struct sc_keyboard_sdk {
+struct sc_keyboard_inject {
     struct sc_key_processor key_processor; // key processor trait
 
     struct sc_controller *controller;
@@ -23,9 +23,9 @@ struct sc_keyboard_sdk {
 };
 
 void
-sc_keyboard_sdk_init(struct sc_keyboard_sdk *kb,
-                     struct sc_controller *controller,
-                     enum sc_key_inject_mode key_inject_mode,
-                     bool forward_key_repeat);
+sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
+                        struct sc_controller *controller,
+                        enum sc_key_inject_mode key_inject_mode,
+                        bool forward_key_repeat);
 
 #endif

app/src/main.c

@@ -4,6 +4,10 @@
 #include <stdbool.h>
 #include <unistd.h>
 #include <libavformat/avformat.h>
+#ifdef _WIN32
+#include <windows.h>
+#include "util/str.h"
+#endif
 #ifdef HAVE_V4L2
 # include <libavdevice/avdevice.h>
 #endif
@@ -15,16 +19,9 @@
 #include "scrcpy.h"
 #include "usb/scrcpy_otg.h"
 #include "util/log.h"
-#include "util/net.h"
-#include "util/thread.h"
 #include "version.h"
 
-#ifdef _WIN32
-#include <windows.h>
-#include "util/str.h"
-#endif
-
-static int
+int
 main_scrcpy(int argc, char *argv[]) {
 #ifdef _WIN32
     // disable buffering, we want logs immediately
@@ -40,37 +37,28 @@ main_scrcpy(int argc, char *argv[]) {
         .opts = scrcpy_options_default,
         .help = false,
         .version = false,
-        .pause_on_exit = SC_PAUSE_ON_EXIT_FALSE,
     };
 
 #ifndef NDEBUG
     args.opts.log_level = SC_LOG_LEVEL_DEBUG;
 #endif
 
-    enum scrcpy_exit_code ret;
-
     if (!scrcpy_parse_args(&args, argc, argv)) {
-        ret = SCRCPY_EXIT_FAILURE;
-        goto end;
+        return SCRCPY_EXIT_FAILURE;
     }
 
     sc_set_log_level(args.opts.log_level);
 
     if (args.help) {
         scrcpy_print_usage(argv[0]);
-        ret = SCRCPY_EXIT_SUCCESS;
-        goto end;
+        return SCRCPY_EXIT_SUCCESS;
     }
 
     if (args.version) {
         scrcpy_print_version();
-        ret = SCRCPY_EXIT_SUCCESS;
-        goto end;
+        return SCRCPY_EXIT_SUCCESS;
     }
 
-    // The current thread is the main thread
-    SC_MAIN_THREAD_ID = sc_thread_get_id();
-
 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
     av_register_all();
 #endif
@@ -81,26 +69,18 @@ main_scrcpy(int argc, char *argv[]) {
     }
 #endif
 
-    if (!net_init()) {
-        ret = SCRCPY_EXIT_FAILURE;
-        goto end;
+    if (avformat_network_init()) {
+        return SCRCPY_EXIT_FAILURE;
     }
 
-    sc_log_configure();
-
 #ifdef HAVE_USB
-    ret = args.opts.otg ? scrcpy_otg(&args.opts) : scrcpy(&args.opts);
+    enum scrcpy_exit_code ret = args.opts.otg ? scrcpy_otg(&args.opts)
+                                              : scrcpy(&args.opts);
 #else
-    ret = scrcpy(&args.opts);
+    enum scrcpy_exit_code ret = scrcpy(&args.opts);
 #endif
 
-end:
-    if (args.pause_on_exit == SC_PAUSE_ON_EXIT_TRUE ||
-            (args.pause_on_exit == SC_PAUSE_ON_EXIT_IF_ERROR &&
-                ret != SCRCPY_EXIT_SUCCESS)) {
-        printf("Press Enter to continue...\n");
-        getchar();
-    }
+    avformat_network_deinit(); // ignore failure
 
     return ret;
 }

app/src/mouse_capture.c

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

app/src/mouse_capture.h

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

app/src/mouse_inject.c

@@ -1,4 +1,4 @@
-#include "mouse_sdk.h"
+#include "mouse_inject.h"
 
 #include <assert.h>
 
@@ -9,8 +9,8 @@
 #include "util/intmap.h"
 #include "util/log.h"
 
-/** Downcast mouse processor to sc_mouse_sdk */
-#define DOWNCAST(MP) container_of(MP, struct sc_mouse_sdk, mouse_processor)
+/** Downcast mouse processor to sc_mouse_inject */
+#define DOWNCAST(MP) container_of(MP, struct sc_mouse_inject, mouse_processor)
 
 static enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state) {
@@ -58,18 +58,17 @@ convert_touch_action(enum sc_touch_action action) {
 static void
 sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
                                     const struct sc_mouse_motion_event *event) {
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
-
-    if (!m->mouse_hover && !event->buttons_state) {
+    if (!event->buttons_state) {
         // Do not send motion events when no click is pressed
         return;
     }
 
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
+
     struct sc_control_msg msg = {
         .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
-            .action = event->buttons_state ? AMOTION_EVENT_ACTION_MOVE
-                                           : AMOTION_EVENT_ACTION_HOVER_MOVE,
+            .action = AMOTION_EVENT_ACTION_MOVE,
             .pointer_id = event->pointer_id,
             .position = event->position,
             .pressure = 1.f,
@@ -77,7 +76,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject mouse motion event'");
     }
 }
@@ -85,7 +84,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
 static void
 sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
                                     const struct sc_mouse_click_event *event) {
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
         .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
@@ -94,12 +93,11 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
             .pointer_id = event->pointer_id,
             .position = event->position,
             .pressure = event->action == SC_ACTION_DOWN ? 1.f : 0.f,
-            .action_button = convert_mouse_buttons(event->button),
             .buttons = convert_mouse_buttons(event->buttons_state),
         },
     };
 
-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject mouse click event'");
     }
 }
@@ -107,7 +105,7 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
 static void
 sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
                                    const struct sc_mouse_scroll_event *event) {
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
         .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
@@ -119,7 +117,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject mouse scroll event'");
     }
 }
@@ -127,7 +125,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
 static void
 sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
                                  const struct sc_touch_event *event) {
-    struct sc_mouse_sdk *m = DOWNCAST(mp);
+    struct sc_mouse_inject *mi = DOWNCAST(mp);
 
     struct sc_control_msg msg = {
         .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
@@ -140,16 +138,15 @@ sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
         },
     };
 
-    if (!sc_controller_push_msg(m->controller, &msg)) {
+    if (!sc_controller_push_msg(mi->controller, &msg)) {
         LOGW("Could not request 'inject touch event'");
     }
 }
 
 void
-sc_mouse_sdk_init(struct sc_mouse_sdk *m, struct sc_controller *controller,
-                  bool mouse_hover) {
-    m->controller = controller;
-    m->mouse_hover = mouse_hover;
+sc_mouse_inject_init(struct sc_mouse_inject *mi,
+                     struct sc_controller *controller) {
+    mi->controller = controller;
 
     static const struct sc_mouse_processor_ops ops = {
         .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
@@ -158,7 +155,7 @@ sc_mouse_sdk_init(struct sc_mouse_sdk *m, struct sc_controller *controller,
         .process_touch = sc_mouse_processor_process_touch,
     };
 
-    m->mouse_processor.ops = &ops;
+    mi->mouse_processor.ops = &ops;
 
-    m->mouse_processor.relative_mode = false;
+    mi->mouse_processor.relative_mode = false;
 }

app/src/mouse_inject.h

@@ -1,5 +1,5 @@
-#ifndef SC_MOUSE_SDK_H
-#define SC_MOUSE_SDK_H
+#ifndef SC_MOUSE_INJECT_H
+#define SC_MOUSE_INJECT_H
 
 #include "common.h"
 
@@ -9,15 +9,14 @@
 #include "screen.h"
 #include "trait/mouse_processor.h"
 
-struct sc_mouse_sdk {
+struct sc_mouse_inject {
     struct sc_mouse_processor mouse_processor; // mouse processor trait
 
     struct sc_controller *controller;
-    bool mouse_hover;
 };
 
 void
-sc_mouse_sdk_init(struct sc_mouse_sdk *m, struct sc_controller *controller,
-                  bool mouse_hover);
+sc_mouse_inject_init(struct sc_mouse_inject *mi,
+                     struct sc_controller *controller);
 
 #endif

app/src/options.c

@@ -7,67 +7,36 @@ const struct scrcpy_options scrcpy_options_default = {
     .window_title = NULL,
     .push_target = NULL,
     .render_driver = NULL,
-    .video_codec_options = NULL,
-    .audio_codec_options = NULL,
-    .video_encoder = NULL,
-    .audio_encoder = NULL,
-    .camera_id = NULL,
-    .camera_size = NULL,
-    .camera_ar = NULL,
-    .camera_fps = 0,
+    .codec_options = NULL,
+    .encoder_name = NULL,
+#ifdef HAVE_V4L2
+    .v4l2_device = NULL,
+#endif
     .log_level = SC_LOG_LEVEL_INFO,
-    .video_codec = SC_CODEC_H264,
-    .audio_codec = SC_CODEC_OPUS,
-    .video_source = SC_VIDEO_SOURCE_DISPLAY,
-    .audio_source = SC_AUDIO_SOURCE_AUTO,
     .record_format = SC_RECORD_FORMAT_AUTO,
-    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_AUTO,
-    .mouse_input_mode = SC_MOUSE_INPUT_MODE_AUTO,
-    .gamepad_input_mode = SC_GAMEPAD_INPUT_MODE_DISABLED,
-    .mouse_bindings = {
-        .pri = {
-            .right_click = SC_MOUSE_BINDING_AUTO,
-            .middle_click = SC_MOUSE_BINDING_AUTO,
-            .click4 = SC_MOUSE_BINDING_AUTO,
-            .click5 = SC_MOUSE_BINDING_AUTO,
-        },
-        .sec = {
-            .right_click = SC_MOUSE_BINDING_AUTO,
-            .middle_click = SC_MOUSE_BINDING_AUTO,
-            .click4 = SC_MOUSE_BINDING_AUTO,
-            .click5 = SC_MOUSE_BINDING_AUTO,
-        },
-    },
-    .camera_facing = SC_CAMERA_FACING_ANY,
+    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
     .port_range = {
         .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
         .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
     },
     .tunnel_host = 0,
     .tunnel_port = 0,
-    .shortcut_mods = SC_SHORTCUT_MOD_LALT | SC_SHORTCUT_MOD_LSUPER,
+    .shortcut_mods = {
+        .data = {SC_SHORTCUT_MOD_LALT, SC_SHORTCUT_MOD_LSUPER},
+        .count = 2,
+    },
     .max_size = 0,
-    .video_bit_rate = 0,
-    .audio_bit_rate = 0,
-    .max_fps = NULL,
-    .capture_orientation = SC_ORIENTATION_0,
-    .capture_orientation_lock = SC_ORIENTATION_UNLOCKED,
-    .display_orientation = SC_ORIENTATION_0,
-    .record_orientation = SC_ORIENTATION_0,
+    .bit_rate = DEFAULT_BIT_RATE,
+    .max_fps = 0,
+    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
+    .rotation = 0,
     .window_x = SC_WINDOW_POSITION_UNDEFINED,
     .window_y = SC_WINDOW_POSITION_UNDEFINED,
     .window_width = 0,
     .window_height = 0,
     .display_id = 0,
-    .video_buffer = 0,
-    .audio_buffer = -1, // depends on the audio format,
-    .audio_output_buffer = SC_TICK_FROM_MS(5),
-    .time_limit = 0,
-    .screen_off_timeout = -1,
-#ifdef HAVE_V4L2
-    .v4l2_device = NULL,
+    .display_buffer = 0,
     .v4l2_buffer = 0,
-#endif
 #ifdef HAVE_USB
     .otg = false,
 #endif
@@ -75,8 +44,7 @@ const struct scrcpy_options scrcpy_options_default = {
     .fullscreen = false,
     .always_on_top = false,
     .control = true,
-    .video_playback = true,
-    .audio_playback = true,
+    .display = true,
     .turn_screen_off = false,
     .key_inject_mode = SC_KEY_INJECT_MODE_MIXED,
     .window_borderless = false,
@@ -85,6 +53,7 @@ const struct scrcpy_options scrcpy_options_default = {
     .force_adb_forward = false,
     .disable_screensaver = false,
     .forward_key_repeat = true,
+    .forward_all_clicks = false,
     .legacy_paste = false,
     .power_off_on_close = false,
     .clipboard_autosync = true,
@@ -96,54 +65,4 @@ const struct scrcpy_options scrcpy_options_default = {
     .cleanup = true,
     .start_fps_counter = false,
     .power_on = true,
-    .video = true,
-    .audio = true,
-    .require_audio = false,
-    .kill_adb_on_close = false,
-    .camera_high_speed = false,
-    .list = 0,
-    .window = true,
-    .mouse_hover = true,
-    .audio_dup = false,
-    .new_display = NULL,
-    .start_app = NULL,
-    .angle = NULL,
-    .vd_destroy_content = true,
-    .vd_system_decorations = true,
 };
-
-enum sc_orientation
-sc_orientation_apply(enum sc_orientation src, enum sc_orientation transform) {
-    assert(!(src & ~7));
-    assert(!(transform & ~7));
-
-    unsigned transform_hflip = transform & 4;
-    unsigned transform_rotation = transform & 3;
-    unsigned src_hflip = src & 4;
-    unsigned src_rotation = src & 3;
-    unsigned src_swap = src & 1;
-    if (src_swap && transform_hflip) {
-        // If the src is rotated by 90 or 270 degrees, applying a flipped
-        // transformation requires an additional 180 degrees rotation to
-        // compensate for the inversion of the order of multiplication:
-        //
-        //     hflip1 × rotate1 × hflip2 × rotate2
-        //     `--------------'   `--------------'
-        //           src             transform
-        //
-        // In the final result, we want all the hflips then all the rotations,
-        // so we must move hflip2 to the left:
-        //
-        //     hflip1 × hflip2 × rotate1' × rotate2
-        //
-        // with rotate1' = | rotate1           if src is 0° or 180°
-        //                 | rotate1 + 180°    if src is 90° or 270°
-
-        src_rotation += 2;
-    }
-
-    unsigned result_hflip = src_hflip ^ transform_hflip;
-    unsigned result_rotation = (transform_rotation + src_rotation) % 4;
-    enum sc_orientation result = result_hflip | result_rotation;
-    return result;
-}

app/src/options.h

@@ -3,7 +3,6 @@
 
 #include "common.h"
 
-#include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -22,165 +21,26 @@ enum sc_record_format {
     SC_RECORD_FORMAT_AUTO,
     SC_RECORD_FORMAT_MP4,
     SC_RECORD_FORMAT_MKV,
-    SC_RECORD_FORMAT_M4A,
-    SC_RECORD_FORMAT_MKA,
-    SC_RECORD_FORMAT_OPUS,
-    SC_RECORD_FORMAT_AAC,
-    SC_RECORD_FORMAT_FLAC,
-    SC_RECORD_FORMAT_WAV,
 };
 
-static inline bool
-sc_record_format_is_audio_only(enum sc_record_format fmt) {
-    return fmt == SC_RECORD_FORMAT_M4A
-        || fmt == SC_RECORD_FORMAT_MKA
-        || fmt == SC_RECORD_FORMAT_OPUS
-        || fmt == SC_RECORD_FORMAT_AAC
-        || fmt == SC_RECORD_FORMAT_FLAC
-        || fmt == SC_RECORD_FORMAT_WAV;
-}
-
-enum sc_codec {
-    SC_CODEC_H264,
-    SC_CODEC_H265,
-    SC_CODEC_AV1,
-    SC_CODEC_OPUS,
-    SC_CODEC_AAC,
-    SC_CODEC_FLAC,
-    SC_CODEC_RAW,
+enum sc_lock_video_orientation {
+    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
+    // lock the current orientation when scrcpy starts
+    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
+    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
+    SC_LOCK_VIDEO_ORIENTATION_1,
+    SC_LOCK_VIDEO_ORIENTATION_2,
+    SC_LOCK_VIDEO_ORIENTATION_3,
 };
 
-enum sc_video_source {
-    SC_VIDEO_SOURCE_DISPLAY,
-    SC_VIDEO_SOURCE_CAMERA,
-};
-
-enum sc_audio_source {
-    SC_AUDIO_SOURCE_AUTO, // OUTPUT for video DISPLAY, MIC for video CAMERA
-    SC_AUDIO_SOURCE_OUTPUT,
-    SC_AUDIO_SOURCE_MIC,
-    SC_AUDIO_SOURCE_PLAYBACK,
-};
-
-enum sc_camera_facing {
-    SC_CAMERA_FACING_ANY,
-    SC_CAMERA_FACING_FRONT,
-    SC_CAMERA_FACING_BACK,
-    SC_CAMERA_FACING_EXTERNAL,
-};
-
-                              // ,----- hflip (applied before the rotation)
-                              // | ,--- 180°
-                              // | | ,- 90° clockwise
-                              // | | |
-enum sc_orientation {         // v v v
-    SC_ORIENTATION_0,         // 0 0 0
-    SC_ORIENTATION_90,        // 0 0 1
-    SC_ORIENTATION_180,       // 0 1 0
-    SC_ORIENTATION_270,       // 0 1 1
-    SC_ORIENTATION_FLIP_0,    // 1 0 0
-    SC_ORIENTATION_FLIP_90,   // 1 0 1
-    SC_ORIENTATION_FLIP_180,  // 1 1 0
-    SC_ORIENTATION_FLIP_270,  // 1 1 1
-};
-
-enum sc_orientation_lock {
-    SC_ORIENTATION_UNLOCKED,
-    SC_ORIENTATION_LOCKED_VALUE,   // lock to specified orientation
-    SC_ORIENTATION_LOCKED_INITIAL, // lock to initial device orientation
-};
-
-static inline bool
-sc_orientation_is_mirror(enum sc_orientation orientation) {
-    assert(!(orientation & ~7));
-    return orientation & 4;
-}
-
-// Does the orientation swap width and height?
-static inline bool
-sc_orientation_is_swap(enum sc_orientation orientation) {
-    assert(!(orientation & ~7));
-    return orientation & 1;
-}
-
-static inline enum sc_orientation
-sc_orientation_get_rotation(enum sc_orientation orientation) {
-    assert(!(orientation & ~7));
-    return orientation & 3;
-}
-
-enum sc_orientation
-sc_orientation_apply(enum sc_orientation src, enum sc_orientation transform);
-
-static inline const char *
-sc_orientation_get_name(enum sc_orientation orientation) {
-    switch (orientation) {
-        case SC_ORIENTATION_0:
-            return "0";
-        case SC_ORIENTATION_90:
-            return "90";
-        case SC_ORIENTATION_180:
-            return "180";
-        case SC_ORIENTATION_270:
-            return "270";
-        case SC_ORIENTATION_FLIP_0:
-            return "flip0";
-        case SC_ORIENTATION_FLIP_90:
-            return "flip90";
-        case SC_ORIENTATION_FLIP_180:
-            return "flip180";
-        case SC_ORIENTATION_FLIP_270:
-            return "flip270";
-        default:
-            return "(unknown)";
-    }
-}
-
 enum sc_keyboard_input_mode {
-    SC_KEYBOARD_INPUT_MODE_AUTO,
-    SC_KEYBOARD_INPUT_MODE_UHID_OR_AOA, // normal vs otg mode
-    SC_KEYBOARD_INPUT_MODE_DISABLED,
-    SC_KEYBOARD_INPUT_MODE_SDK,
-    SC_KEYBOARD_INPUT_MODE_UHID,
-    SC_KEYBOARD_INPUT_MODE_AOA,
+    SC_KEYBOARD_INPUT_MODE_INJECT,
+    SC_KEYBOARD_INPUT_MODE_HID,
 };
 
 enum sc_mouse_input_mode {
-    SC_MOUSE_INPUT_MODE_AUTO,
-    SC_MOUSE_INPUT_MODE_UHID_OR_AOA, // normal vs otg mode
-    SC_MOUSE_INPUT_MODE_DISABLED,
-    SC_MOUSE_INPUT_MODE_SDK,
-    SC_MOUSE_INPUT_MODE_UHID,
-    SC_MOUSE_INPUT_MODE_AOA,
-};
-
-enum sc_gamepad_input_mode {
-    SC_GAMEPAD_INPUT_MODE_DISABLED,
-    SC_GAMEPAD_INPUT_MODE_UHID_OR_AOA, // normal vs otg mode
-    SC_GAMEPAD_INPUT_MODE_UHID,
-    SC_GAMEPAD_INPUT_MODE_AOA,
-};
-
-enum sc_mouse_binding {
-    SC_MOUSE_BINDING_AUTO,
-    SC_MOUSE_BINDING_DISABLED,
-    SC_MOUSE_BINDING_CLICK,
-    SC_MOUSE_BINDING_BACK,
-    SC_MOUSE_BINDING_HOME,
-    SC_MOUSE_BINDING_APP_SWITCH,
-    SC_MOUSE_BINDING_EXPAND_NOTIFICATION_PANEL,
-};
-
-struct sc_mouse_binding_set {
-    enum sc_mouse_binding right_click;
-    enum sc_mouse_binding middle_click;
-    enum sc_mouse_binding click4;
-    enum sc_mouse_binding click5;
-};
-
-struct sc_mouse_bindings {
-    struct sc_mouse_binding_set pri;
-    struct sc_mouse_binding_set sec; // When Shift is pressed
+    SC_MOUSE_INPUT_MODE_INJECT,
+    SC_MOUSE_INPUT_MODE_HID,
 };
 
 enum sc_key_inject_mode {
@@ -197,6 +57,8 @@ enum sc_key_inject_mode {
     SC_KEY_INJECT_MODE_RAW,
 };
 
+#define SC_MAX_SHORTCUT_MODS 8
+
 enum sc_shortcut_mod {
     SC_SHORTCUT_MOD_LCTRL = 1 << 0,
     SC_SHORTCUT_MOD_RCTRL = 1 << 1,
@@ -206,6 +68,11 @@ enum sc_shortcut_mod {
     SC_SHORTCUT_MOD_RSUPER = 1 << 5,
 };
 
+struct sc_shortcut_mods {
+    unsigned data[SC_MAX_SHORTCUT_MODS];
+    unsigned count;
+};
+
 struct sc_port_range {
     uint16_t first;
     uint16_t last;
@@ -220,52 +87,31 @@ struct scrcpy_options {
     const char *window_title;
     const char *push_target;
     const char *render_driver;
-    const char *video_codec_options;
-    const char *audio_codec_options;
-    const char *video_encoder;
-    const char *audio_encoder;
-    const char *camera_id;
-    const char *camera_size;
-    const char *camera_ar;
-    uint16_t camera_fps;
+    const char *codec_options;
+    const char *encoder_name;
+#ifdef HAVE_V4L2
+    const char *v4l2_device;
+#endif
     enum sc_log_level log_level;
-    enum sc_codec video_codec;
-    enum sc_codec audio_codec;
-    enum sc_video_source video_source;
-    enum sc_audio_source audio_source;
     enum sc_record_format record_format;
     enum sc_keyboard_input_mode keyboard_input_mode;
     enum sc_mouse_input_mode mouse_input_mode;
-    enum sc_gamepad_input_mode gamepad_input_mode;
-    struct sc_mouse_bindings mouse_bindings;
-    enum sc_camera_facing camera_facing;
     struct sc_port_range port_range;
     uint32_t tunnel_host;
     uint16_t tunnel_port;
-    uint8_t shortcut_mods; // OR of enum sc_shortcut_mod values
+    struct sc_shortcut_mods shortcut_mods;
     uint16_t max_size;
-    uint32_t video_bit_rate;
-    uint32_t audio_bit_rate;
-    const char *max_fps; // float to be parsed by the server
-    const char *angle; // float to be parsed by the server
-    enum sc_orientation capture_orientation;
-    enum sc_orientation_lock capture_orientation_lock;
-    enum sc_orientation display_orientation;
-    enum sc_orientation record_orientation;
+    uint32_t bit_rate;
+    uint16_t max_fps;
+    enum sc_lock_video_orientation lock_video_orientation;
+    uint8_t rotation;
     int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
     int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
     uint16_t window_width;
     uint16_t window_height;
     uint32_t display_id;
-    sc_tick video_buffer;
-    sc_tick audio_buffer;
-    sc_tick audio_output_buffer;
-    sc_tick time_limit;
-    sc_tick screen_off_timeout;
-#ifdef HAVE_V4L2
-    const char *v4l2_device;
+    sc_tick display_buffer;
     sc_tick v4l2_buffer;
-#endif
 #ifdef HAVE_USB
     bool otg;
 #endif
@@ -273,8 +119,7 @@ struct scrcpy_options {
     bool fullscreen;
     bool always_on_top;
     bool control;
-    bool video_playback;
-    bool audio_playback;
+    bool display;
     bool turn_screen_off;
     enum sc_key_inject_mode key_inject_mode;
     bool window_borderless;
@@ -283,6 +128,7 @@ struct scrcpy_options {
     bool force_adb_forward;
     bool disable_screensaver;
     bool forward_key_repeat;
+    bool forward_all_clicks;
     bool legacy_paste;
     bool power_off_on_close;
     bool clipboard_autosync;
@@ -294,24 +140,6 @@ struct scrcpy_options {
     bool cleanup;
     bool start_fps_counter;
     bool power_on;
-    bool video;
-    bool audio;
-    bool require_audio;
-    bool kill_adb_on_close;
-    bool camera_high_speed;
-#define SC_OPTION_LIST_ENCODERS 0x1
-#define SC_OPTION_LIST_DISPLAYS 0x2
-#define SC_OPTION_LIST_CAMERAS 0x4
-#define SC_OPTION_LIST_CAMERA_SIZES 0x8
-#define SC_OPTION_LIST_APPS 0x10
-    uint8_t list;
-    bool window;
-    bool mouse_hover;
-    bool audio_dup;
-    const char *new_display; // [<width>x<height>][/<dpi>] parsed by the server
-    const char *start_app;
-    bool vd_destroy_content;
-    bool vd_system_decorations;
 };
 
 extern const struct scrcpy_options scrcpy_options_default;

app/src/packet_merger.c

@@ -1,48 +0,0 @@
-#include "packet_merger.h"
-
-#include "util/log.h"
-
-void
-sc_packet_merger_init(struct sc_packet_merger *merger) {
-    merger->config = NULL;
-}
-
-void
-sc_packet_merger_destroy(struct sc_packet_merger *merger) {
-    free(merger->config);
-}
-
-bool
-sc_packet_merger_merge(struct sc_packet_merger *merger, AVPacket *packet) {
-    bool is_config = packet->pts == AV_NOPTS_VALUE;
-
-    if (is_config) {
-        free(merger->config);
-
-        merger->config = malloc(packet->size);
-        if (!merger->config) {
-            LOG_OOM();
-            return false;
-        }
-
-        memcpy(merger->config, packet->data, packet->size);
-        merger->config_size = packet->size;
-    } else if (merger->config) {
-        size_t config_size = merger->config_size;
-        size_t media_size = packet->size;
-
-        if (av_grow_packet(packet, config_size)) {
-            LOG_OOM();
-            return false;
-        }
-
-        memmove(packet->data + config_size, packet->data, media_size);
-        memcpy(packet->data, merger->config, config_size);
-
-        free(merger->config);
-        merger->config = NULL;
-        // merger->size is meaningless when merger->config is NULL
-    }
-
-    return true;
-}

app/src/packet_merger.h

@@ -1,43 +0,0 @@
-#ifndef SC_PACKET_MERGER_H
-#define SC_PACKET_MERGER_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <libavcodec/avcodec.h>
-
-/**
- * Config packets (containing the SPS/PPS) are sent in-band. A new config
- * packet is sent whenever a new encoding session is started (on start and on
- * device orientation change).
- *
- * Every time a config packet is received, it must be sent alone (for recorder
- * extradata), then concatenated to the next media packet (for correct decoding
- * and recording).
- *
- * This helper reads every input packet and modifies each media packet which
- * immediately follows a config packet to prepend the config packet payload.
- */
-
-struct sc_packet_merger {
-    uint8_t *config;
-    size_t config_size;
-};
-
-void
-sc_packet_merger_init(struct sc_packet_merger *merger);
-
-void
-sc_packet_merger_destroy(struct sc_packet_merger *merger);
-
-/**
- * If the packet is a config packet, then keep its data for later.
- * Otherwise (if the packet is a media packet), then if a config packet is
- * pending, prepend the config packet to this packet (so the packet is
- * modified!).
- */
-bool
-sc_packet_merger_merge(struct sc_packet_merger *merger, AVPacket *packet);
-
-#endif

app/src/receiver.c

@@ -1,165 +1,61 @@
 #include "receiver.h"
 
 #include <assert.h>
-#include <inttypes.h>
-#include <stdint.h>
 #include <SDL2/SDL_clipboard.h>
 
 #include "device_msg.h"
-#include "events.h"
 #include "util/log.h"
-#include "util/str.h"
-#include "util/thread.h"
-
-struct sc_uhid_output_task_data {
-    struct sc_uhid_devices *uhid_devices;
-    uint16_t id;
-    uint16_t size;
-    uint8_t *data;
-};
 
 bool
-sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
-                 const struct sc_receiver_callbacks *cbs, void *cbs_userdata) {
+receiver_init(struct receiver *receiver, sc_socket control_socket,
+              struct sc_acksync *acksync) {
     bool ok = sc_mutex_init(&receiver->mutex);
     if (!ok) {
         return false;
     }
 
     receiver->control_socket = control_socket;
-    receiver->acksync = NULL;
-    receiver->uhid_devices = NULL;
-
-    assert(cbs && cbs->on_ended);
-    receiver->cbs = cbs;
-    receiver->cbs_userdata = cbs_userdata;
+    receiver->acksync = acksync;
 
     return true;
 }
 
 void
-sc_receiver_destroy(struct sc_receiver *receiver) {
+receiver_destroy(struct receiver *receiver) {
     sc_mutex_destroy(&receiver->mutex);
 }
 
 static void
-task_set_clipboard(void *userdata) {
-    assert(sc_thread_get_id() == SC_MAIN_THREAD_ID);
-
-    char *text = userdata;
-
-    char *current = SDL_GetClipboardText();
-    bool same = current && !strcmp(current, text);
-    SDL_free(current);
-    if (same) {
-        LOGD("Computer clipboard unchanged");
-    } else {
-        LOGI("Device clipboard copied");
-        SDL_SetClipboardText(text);
-    }
-
-    free(text);
-}
-
-static void
-task_uhid_output(void *userdata) {
-    assert(sc_thread_get_id() == SC_MAIN_THREAD_ID);
-
-    struct sc_uhid_output_task_data *data = userdata;
-
-    sc_uhid_devices_process_hid_output(data->uhid_devices, data->id, data->data,
-                                       data->size);
-
-    free(data->data);
-    free(data);
-}
-
-static void
-process_msg(struct sc_receiver *receiver, struct sc_device_msg *msg) {
+process_msg(struct receiver *receiver, struct device_msg *msg) {
     switch (msg->type) {
         case DEVICE_MSG_TYPE_CLIPBOARD: {
-            // Take ownership of the text (do not destroy the msg)
-            char *text = msg->clipboard.text;
-
-            bool ok = sc_post_to_main_thread(task_set_clipboard, text);
-            if (!ok) {
-                LOGW("Could not post clipboard to main thread");
-                free(text);
+            char *current = SDL_GetClipboardText();
+            bool same = current && !strcmp(current, msg->clipboard.text);
+            SDL_free(current);
+            if (same) {
+                LOGD("Computer clipboard unchanged");
                 return;
             }
 
+            LOGI("Device clipboard copied");
+            SDL_SetClipboardText(msg->clipboard.text);
             break;
         }
         case DEVICE_MSG_TYPE_ACK_CLIPBOARD:
+            assert(receiver->acksync);
             LOGD("Ack device clipboard sequence=%" PRIu64_,
                  msg->ack_clipboard.sequence);
-
-            // This is a programming error to receive this message if there is
-            // no ACK synchronization mechanism
-            assert(receiver->acksync);
-
-            // Also check at runtime (do not trust the server)
-            if (!receiver->acksync) {
-                LOGE("Received unexpected ack");
-                return;
-            }
-
             sc_acksync_ack(receiver->acksync, msg->ack_clipboard.sequence);
-            // No allocation to free in the msg
-            break;
-        case DEVICE_MSG_TYPE_UHID_OUTPUT:
-            if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
-                char *hex = sc_str_to_hex_string(msg->uhid_output.data,
-                                                 msg->uhid_output.size);
-                if (hex) {
-                    LOGV("UHID output [%" PRIu16 "] %s",
-                         msg->uhid_output.id, hex);
-                    free(hex);
-                } else {
-                    LOGV("UHID output [%" PRIu16 "] size=%" PRIu16,
-                         msg->uhid_output.id, msg->uhid_output.size);
-                }
-            }
-
-            if (!receiver->uhid_devices) {
-                LOGE("Received unexpected HID output message");
-                sc_device_msg_destroy(msg);
-                return;
-            }
-
-            struct sc_uhid_output_task_data *data = malloc(sizeof(*data));
-            if (!data) {
-                LOG_OOM();
-                return;
-            }
-
-            // It is guaranteed that these pointers will still be valid when
-            // the main thread will process them (the main thread will stop
-            // processing SC_EVENT_RUN_ON_MAIN_THREAD on exit, when everything
-            // gets deinitialized)
-            data->uhid_devices = receiver->uhid_devices;
-            data->id = msg->uhid_output.id;
-            data->data = msg->uhid_output.data; // take ownership
-            data->size = msg->uhid_output.size;
-
-            bool ok = sc_post_to_main_thread(task_uhid_output, data);
-            if (!ok) {
-                LOGW("Could not post UHID output to main thread");
-                free(data->data);
-                free(data);
-                return;
-            }
-
             break;
     }
 }
 
 static ssize_t
-process_msgs(struct sc_receiver *receiver, const uint8_t *buf, size_t len) {
+process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
     size_t head = 0;
     for (;;) {
-        struct sc_device_msg msg;
-        ssize_t r = sc_device_msg_deserialize(&buf[head], len - head, &msg);
+        struct device_msg msg;
+        ssize_t r = device_msg_deserialize(&buf[head], len - head, &msg);
         if (r == -1) {
             return -1;
         }
@@ -168,7 +64,7 @@ process_msgs(struct sc_receiver *receiver, const uint8_t *buf, size_t len) {
         }
 
         process_msg(receiver, &msg);
-        // the device msg must be destroyed by process_msg()
+        device_msg_destroy(&msg);
 
         head += r;
         assert(head <= len);
@@ -180,20 +76,17 @@ process_msgs(struct sc_receiver *receiver, const uint8_t *buf, size_t len) {
 
 static int
 run_receiver(void *data) {
-    struct sc_receiver *receiver = data;
+    struct receiver *receiver = data;
 
-    static uint8_t buf[DEVICE_MSG_MAX_SIZE];
+    static unsigned char buf[DEVICE_MSG_MAX_SIZE];
     size_t head = 0;
 
-    bool error = false;
-
     for (;;) {
         assert(head < DEVICE_MSG_MAX_SIZE);
         ssize_t r = net_recv(receiver->control_socket, buf + head,
                              DEVICE_MSG_MAX_SIZE - head);
         if (r <= 0) {
             LOGD("Receiver stopped");
-            // device disconnected: keep error=false
             break;
         }
 
@@ -201,7 +94,6 @@ run_receiver(void *data) {
         ssize_t consumed = process_msgs(receiver, buf, head);
         if (consumed == -1) {
             // an error occurred
-            error = true;
             break;
         }
 
@@ -212,13 +104,11 @@ run_receiver(void *data) {
         }
     }
 
-    receiver->cbs->on_ended(receiver, error, receiver->cbs_userdata);
-
     return 0;
 }
 
 bool
-sc_receiver_start(struct sc_receiver *receiver) {
+receiver_start(struct receiver *receiver) {
     LOGD("Starting receiver thread");
 
     bool ok = sc_thread_create(&receiver->thread, run_receiver,
@@ -232,6 +122,6 @@ sc_receiver_start(struct sc_receiver *receiver) {
 }
 
 void
-sc_receiver_join(struct sc_receiver *receiver) {
+receiver_join(struct receiver *receiver) {
     sc_thread_join(&receiver->thread, NULL);
 }

app/src/receiver.h

@@ -5,42 +5,33 @@
 
 #include <stdbool.h>
 
-#include "uhid/uhid_output.h"
 #include "util/acksync.h"
 #include "util/net.h"
 #include "util/thread.h"
 
 // receive events from the device
 // managed by the controller
-struct sc_receiver {
+struct receiver {
     sc_socket control_socket;
     sc_thread thread;
     sc_mutex mutex;
 
     struct sc_acksync *acksync;
-    struct sc_uhid_devices *uhid_devices;
-
-    const struct sc_receiver_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct sc_receiver_callbacks {
-    void (*on_ended)(struct sc_receiver *receiver, bool error, void *userdata);
 };
 
 bool
-sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
-                 const struct sc_receiver_callbacks *cbs, void *cbs_userdata);
+receiver_init(struct receiver *receiver, sc_socket control_socket,
+              struct sc_acksync *acksync);
 
 void
-sc_receiver_destroy(struct sc_receiver *receiver);
+receiver_destroy(struct receiver *receiver);
 
 bool
-sc_receiver_start(struct sc_receiver *receiver);
+receiver_start(struct receiver *receiver);
 
-// no sc_receiver_stop(), it will automatically stop on control_socket shutdown
+// no receiver_stop(), it will automatically stop on control_socket shutdown
 
 void
-sc_receiver_join(struct sc_receiver *receiver);
+receiver_join(struct receiver *receiver);
 
 #endif

app/src/recorder.h

@@ -9,77 +9,43 @@
 #include "coords.h"
 #include "options.h"
 #include "trait/packet_sink.h"
+#include "util/queue.h"
 #include "util/thread.h"
-#include "util/vecdeque.h"
 
-struct sc_recorder_queue SC_VECDEQUE(AVPacket *);
-
-struct sc_recorder_stream {
-    int index;
-    int64_t last_pts;
+struct sc_record_packet {
+    AVPacket *packet;
+    struct sc_record_packet *next;
 };
 
+struct sc_recorder_queue SC_QUEUE(struct sc_record_packet);
+
 struct sc_recorder {
-    struct sc_packet_sink video_packet_sink;
-    struct sc_packet_sink audio_packet_sink;
-
-    /* The audio flag is unprotected:
-     *  - it is initialized from sc_recorder_init() from the main thread;
-     *  - it may be reset once from the recorder thread if the audio is
-     *    disabled dynamically.
-     *
-     * Therefore, once the recorder thread is started, only the recorder thread
-     * may access it without data races.
-     */
-    bool audio;
-    bool video;
-
-    enum sc_orientation orientation;
+    struct sc_packet_sink packet_sink; // packet sink trait
 
     char *filename;
     enum sc_record_format format;
     AVFormatContext *ctx;
+    struct sc_size declared_frame_size;
+    bool header_written;
 
     sc_thread thread;
     sc_mutex mutex;
-    sc_cond cond;
-    // set on sc_recorder_stop(), packet_sink close or recording failure
-    bool stopped;
-    struct sc_recorder_queue video_queue;
-    struct sc_recorder_queue audio_queue;
+    sc_cond queue_cond;
+    bool stopped; // set on recorder_close()
+    bool failed; // set on packet write failure
+    struct sc_recorder_queue queue;
 
-    // wake up the recorder thread once the video or audio codec is known
-    bool video_init;
-    bool audio_init;
-
-    bool audio_expects_config_packet;
-
-    struct sc_recorder_stream video_stream;
-    struct sc_recorder_stream audio_stream;
-
-    const struct sc_recorder_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct sc_recorder_callbacks {
-    void (*on_ended)(struct sc_recorder *recorder, bool success,
-                     void *userdata);
+    // we can write a packet only once we received the next one so that we can
+    // set its duration (next_pts - current_pts)
+    // "previous" is only accessed from the recorder thread, so it does not
+    // need to be protected by the mutex
+    struct sc_record_packet *previous;
 };
 
 bool
 sc_recorder_init(struct sc_recorder *recorder, const char *filename,
-                 enum sc_record_format format, bool video, bool audio,
-                 enum sc_orientation orientation,
-                 const struct sc_recorder_callbacks *cbs, void *cbs_userdata);
-
-bool
-sc_recorder_start(struct sc_recorder *recorder);
-
-void
-sc_recorder_stop(struct sc_recorder *recorder);
-
-void
-sc_recorder_join(struct sc_recorder *recorder);
+                 enum sc_record_format format,
+                 struct sc_size declared_frame_size);
 
 void
 sc_recorder_destroy(struct sc_recorder *recorder);

app/src/screen.h

@@ -9,16 +9,13 @@
 
 #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 "trait/key_processor.h"
 #include "trait/frame_sink.h"
 #include "trait/mouse_processor.h"
+#include "video_buffer.h"
 
 struct sc_screen {
     struct sc_frame_sink frame_sink; // frame sink trait
@@ -27,12 +24,8 @@ struct sc_screen {
     bool open; // track the open/close state to assert correct behavior
 #endif
 
-    bool video;
-
-    struct sc_display display;
     struct sc_input_manager im;
-    struct sc_mouse_capture mc; // only used in mouse relative mode
-    struct sc_frame_buffer fb;
+    struct sc_video_buffer vb;
     struct sc_fps_counter fps_counter;
 
     // The initial requested window properties
@@ -46,6 +39,9 @@ struct sc_screen {
     } req;
 
     SDL_Window *window;
+    SDL_Renderer *renderer;
+    SDL_Texture *texture;
+    struct sc_opengl gl;
     struct sc_size frame_size;
     struct sc_size content_size; // rotated frame_size
 
@@ -54,36 +50,37 @@ struct sc_screen {
     // fullscreen (meaningful only when resize_pending is true)
     struct sc_size windowed_content_size;
 
-    // client orientation
-    enum sc_orientation orientation;
+    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
+    unsigned rotation;
     // rectangle of the content (excluding black borders)
     struct SDL_Rect rect;
     bool has_frame;
     bool fullscreen;
     bool maximized;
-    bool minimized;
+    bool mipmaps;
+
+    bool event_failed; // in case SDL_PushEvent() returned an error
+
+    // To enable/disable mouse capture, a mouse capture key (LALT, LGUI or
+    // RGUI) must be pressed. This variable tracks the pressed capture key.
+    SDL_Keycode mouse_capture_key_pressed;
 
     AVFrame *frame;
-
-    bool paused;
-    AVFrame *resume_frame;
 };
 
 struct sc_screen_params {
-    bool video;
-
     struct sc_controller *controller;
     struct sc_file_pusher *fp;
     struct sc_key_processor *kp;
     struct sc_mouse_processor *mp;
-    struct sc_gamepad_processor *gp;
 
-    struct sc_mouse_bindings mouse_bindings;
+    bool forward_all_clicks;
     bool legacy_paste;
     bool clipboard_autosync;
-    uint8_t shortcut_mods; // OR of enum sc_shortcut_mod values
+    const struct sc_shortcut_mods *shortcut_mods;
 
     const char *window_title;
+    struct sc_size frame_size;
     bool always_on_top;
 
     int16_t window_x; // accepts SC_WINDOW_POSITION_UNDEFINED
@@ -93,11 +90,13 @@ struct sc_screen_params {
 
     bool window_borderless;
 
-    enum sc_orientation orientation;
+    uint8_t rotation;
     bool mipmaps;
 
     bool fullscreen;
     bool start_fps_counter;
+
+    sc_tick buffering_time;
 };
 
 // initialize screen, create window, renderer and texture (window is hidden)
@@ -124,9 +123,9 @@ sc_screen_destroy(struct sc_screen *screen);
 void
 sc_screen_hide_window(struct sc_screen *screen);
 
-// toggle the fullscreen mode
+// switch the fullscreen mode
 void
-sc_screen_toggle_fullscreen(struct sc_screen *screen);
+sc_screen_switch_fullscreen(struct sc_screen *screen);
 
 // resize window to optimal size (remove black borders)
 void
@@ -136,19 +135,13 @@ sc_screen_resize_to_fit(struct sc_screen *screen);
 void
 sc_screen_resize_to_pixel_perfect(struct sc_screen *screen);
 
-// set the display orientation
+// set the display rotation (0, 1, 2 or 3, x90 degrees counterclockwise)
 void
-sc_screen_set_orientation(struct sc_screen *screen,
-                          enum sc_orientation orientation);
-
-// set the display pause state
-void
-sc_screen_set_paused(struct sc_screen *screen, bool paused);
+sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation);
 
 // react to SDL events
-// If this function returns false, scrcpy must exit with an error.
-bool
-sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event);
+void
+sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event);
 
 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels

app/src/server.c

@@ -8,8 +8,6 @@
 #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"
@@ -26,22 +24,35 @@
 
 static char *
 get_server_path(void) {
-    char *server_path = sc_get_env("SCRCPY_SERVER_PATH");
-    if (server_path) {
+#ifdef __WINDOWS__
+    const wchar_t *server_path_env = _wgetenv(L"SCRCPY_SERVER_PATH");
+#else
+    const char *server_path_env = getenv("SCRCPY_SERVER_PATH");
+#endif
+    if (server_path_env) {
         // if the envvar is set, use it
+#ifdef __WINDOWS__
+        char *server_path = sc_str_from_wchars(server_path_env);
+#else
+        char *server_path = strdup(server_path_env);
+#endif
+        if (!server_path) {
+            LOG_OOM();
+            return NULL;
+        }
         LOGD("Using SCRCPY_SERVER_PATH: %s", server_path);
         return server_path;
     }
 
 #ifndef PORTABLE
     LOGD("Using server: " SC_SERVER_PATH_DEFAULT);
-    server_path = strdup(SC_SERVER_PATH_DEFAULT);
+    char *server_path = strdup(SC_SERVER_PATH_DEFAULT);
     if (!server_path) {
         LOG_OOM();
         return NULL;
     }
 #else
-    server_path = sc_file_get_local_path(SC_SERVER_FILENAME);
+    char *server_path = sc_file_get_local_path(SC_SERVER_FILENAME);
     if (!server_path) {
         LOGE("Could not get local file path, "
              "using " SC_SERVER_FILENAME " from current directory");
@@ -54,6 +65,47 @@ get_server_path(void) {
     return server_path;
 }
 
+static void
+sc_server_params_destroy(struct sc_server_params *params) {
+    // The server stores a copy of the params provided by the user
+    free((char *) params->req_serial);
+    free((char *) params->crop);
+    free((char *) params->codec_options);
+    free((char *) params->encoder_name);
+    free((char *) params->tcpip_dst);
+}
+
+static bool
+sc_server_params_copy(struct sc_server_params *dst,
+                      const struct sc_server_params *src) {
+    *dst = *src;
+
+    // The params reference user-allocated memory, so we must copy them to
+    // handle them from another thread
+
+#define COPY(FIELD) \
+    dst->FIELD = NULL; \
+    if (src->FIELD) { \
+        dst->FIELD = strdup(src->FIELD); \
+        if (!dst->FIELD) { \
+            goto error; \
+        } \
+    }
+
+    COPY(req_serial);
+    COPY(crop);
+    COPY(codec_options);
+    COPY(encoder_name);
+    COPY(tcpip_dst);
+#undef COPY
+
+    return true;
+
+error:
+    sc_server_params_destroy(dst);
+    return false;
+}
+
 static bool
 push_server(struct sc_intr *intr, const char *serial) {
     char *server_path = get_server_path();
@@ -85,7 +137,7 @@ log_level_to_server_string(enum sc_log_level level) {
             return "error";
         default:
             assert(!"unexpected log level");
-            return NULL;
+            return "(unknown)";
     }
 }
 
@@ -103,74 +155,6 @@ sc_server_sleep(struct sc_server *server, sc_tick deadline) {
     return !stopped;
 }
 
-static const char *
-sc_server_get_codec_name(enum sc_codec codec) {
-    switch (codec) {
-        case SC_CODEC_H264:
-            return "h264";
-        case SC_CODEC_H265:
-            return "h265";
-        case SC_CODEC_AV1:
-            return "av1";
-        case SC_CODEC_OPUS:
-            return "opus";
-        case SC_CODEC_AAC:
-            return "aac";
-        case SC_CODEC_FLAC:
-            return "flac";
-        case SC_CODEC_RAW:
-            return "raw";
-        default:
-            assert(!"unexpected codec");
-            return NULL;
-    }
-}
-
-static const char *
-sc_server_get_camera_facing_name(enum sc_camera_facing camera_facing) {
-    switch (camera_facing) {
-        case SC_CAMERA_FACING_FRONT:
-            return "front";
-        case SC_CAMERA_FACING_BACK:
-            return "back";
-        case SC_CAMERA_FACING_EXTERNAL:
-            return "external";
-        default:
-            assert(!"unexpected camera facing");
-            return NULL;
-    }
-}
-
-static const char *
-sc_server_get_audio_source_name(enum sc_audio_source audio_source) {
-    switch (audio_source) {
-        case SC_AUDIO_SOURCE_OUTPUT:
-            return "output";
-        case SC_AUDIO_SOURCE_MIC:
-            return "mic";
-        case SC_AUDIO_SOURCE_PLAYBACK:
-            return "playback";
-        default:
-            assert(!"unexpected audio source");
-            return NULL;
-    }
-}
-
-static bool
-validate_string(const char *s) {
-    // The parameters values are passed as command line arguments to adb, so
-    // they must either be properly escaped, or they must not contain any
-    // special shell characters.
-    // Since they are not properly escaped on Windows anyway (see
-    // sys/win/process.c), just forbid special shell characters.
-    if (strpbrk(s, " ;'\"*$?&`#\\|<>[]{}()!~\r\n")) {
-        LOGE("Invalid server param: [%s]", s);
-        return false;
-    }
-
-    return true;
-}
-
 static sc_pid
 execute_server(struct sc_server *server,
                const struct sc_server_params *params) {
@@ -189,113 +173,49 @@ execute_server(struct sc_server *server,
     cmd[count++] = "app_process";
 
 #ifdef SERVER_DEBUGGER
-    uint16_t sdk_version = sc_adb_get_device_sdk_version(&server->intr, serial);
-    if (!sdk_version) {
-        LOGE("Could not determine SDK version");
-        return 0;
-    }
-
 # define SERVER_DEBUGGER_PORT "5005"
-    const char *dbg;
-    if (sdk_version < 28) {
-        // Android < 9
-        dbg = "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
-              SERVER_DEBUGGER_PORT;
-    } else if (sdk_version < 30) {
-        // Android >= 9 && Android < 11
-        dbg = "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,"
-              "suspend=y,server=y,address=" SERVER_DEBUGGER_PORT;
-    } else {
-        // Android >= 11
-        // Contrary to the other methods, this does not suspend on start.
-        // <https://github.com/Genymobile/scrcpy/pull/5466>
-        dbg = "-XjdwpProvider:adbconnection";
-    }
-    cmd[count++] = dbg;
+    cmd[count++] =
+# ifdef SERVER_DEBUGGER_METHOD_NEW
+        /* Android 9 and above */
+        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,"
+        "server=y,address="
+# else
+        /* Android 8 and below */
+        "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
+# endif
+            SERVER_DEBUGGER_PORT;
 #endif
-
     cmd[count++] = "/"; // unused
     cmd[count++] = "com.genymobile.scrcpy.Server";
     cmd[count++] = SCRCPY_VERSION;
 
     unsigned dyn_idx = count; // from there, the strings are allocated
-#define ADD_PARAM(fmt, ...) do { \
-        char *p; \
+#define ADD_PARAM(fmt, ...) { \
+        char *p = (char *) &cmd[count]; \
         if (asprintf(&p, fmt, ## __VA_ARGS__) == -1) { \
             goto end; \
         } \
         cmd[count++] = p; \
-    } while(0)
-#define VALIDATE_STRING(s) do { \
-        if (!validate_string(s)) { \
-            goto end; \
-        } \
-    } while(0)
+    }
 
-    ADD_PARAM("scid=%08x", params->scid);
+    ADD_PARAM("uid=%08x", params->uid);
     ADD_PARAM("log_level=%s", log_level_to_server_string(params->log_level));
+    ADD_PARAM("bit_rate=%" PRIu32, params->bit_rate);
 
-    if (!params->video) {
-        ADD_PARAM("video=false");
-    }
-    if (params->video_bit_rate) {
-        ADD_PARAM("video_bit_rate=%" PRIu32, params->video_bit_rate);
-    }
-    if (!params->audio) {
-        ADD_PARAM("audio=false");
-    }
-    if (params->audio_bit_rate) {
-        ADD_PARAM("audio_bit_rate=%" PRIu32, params->audio_bit_rate);
-    }
-    if (params->video_codec != SC_CODEC_H264) {
-        ADD_PARAM("video_codec=%s",
-                  sc_server_get_codec_name(params->video_codec));
-    }
-    if (params->audio_codec != SC_CODEC_OPUS) {
-        ADD_PARAM("audio_codec=%s",
-            sc_server_get_codec_name(params->audio_codec));
-    }
-    if (params->video_source != SC_VIDEO_SOURCE_DISPLAY) {
-        assert(params->video_source == SC_VIDEO_SOURCE_CAMERA);
-        ADD_PARAM("video_source=camera");
-    }
-    // If audio is enabled, an "auto" audio source must have been resolved
-    assert(params->audio_source != SC_AUDIO_SOURCE_AUTO || !params->audio);
-    if (params->audio_source != SC_AUDIO_SOURCE_OUTPUT && params->audio) {
-        ADD_PARAM("audio_source=%s",
-                  sc_server_get_audio_source_name(params->audio_source));
-    }
-    if (params->audio_dup) {
-        ADD_PARAM("audio_dup=true");
-    }
     if (params->max_size) {
         ADD_PARAM("max_size=%" PRIu16, params->max_size);
     }
     if (params->max_fps) {
-        VALIDATE_STRING(params->max_fps);
-        ADD_PARAM("max_fps=%s", params->max_fps);
+        ADD_PARAM("max_fps=%" PRIu16, params->max_fps);
     }
-    if (params->angle) {
-        VALIDATE_STRING(params->angle);
-        ADD_PARAM("angle=%s", params->angle);
-    }
-    if (params->capture_orientation_lock != SC_ORIENTATION_UNLOCKED
-            || params->capture_orientation != SC_ORIENTATION_0) {
-        if (params->capture_orientation_lock == SC_ORIENTATION_LOCKED_INITIAL) {
-            ADD_PARAM("capture_orientation=@");
-        } else {
-            const char *orient =
-                sc_orientation_get_name(params->capture_orientation);
-            bool locked =
-                params->capture_orientation_lock != SC_ORIENTATION_UNLOCKED;
-            ADD_PARAM("capture_orientation=%s%s", locked ? "@" : "", orient);
-        }
+    if (params->lock_video_orientation != SC_LOCK_VIDEO_ORIENTATION_UNLOCKED) {
+        ADD_PARAM("lock_video_orientation=%" PRIi8,
+                  params->lock_video_orientation);
     }
     if (server->tunnel.forward) {
         ADD_PARAM("tunnel_forward=true");
     }
     if (params->crop) {
-        VALIDATE_STRING(params->crop);
         ADD_PARAM("crop=%s", params->crop);
     }
     if (!params->control) {
@@ -305,54 +225,17 @@ execute_server(struct sc_server *server,
     if (params->display_id) {
         ADD_PARAM("display_id=%" PRIu32, params->display_id);
     }
-    if (params->camera_id) {
-        VALIDATE_STRING(params->camera_id);
-        ADD_PARAM("camera_id=%s", params->camera_id);
-    }
-    if (params->camera_size) {
-        VALIDATE_STRING(params->camera_size);
-        ADD_PARAM("camera_size=%s", params->camera_size);
-    }
-    if (params->camera_facing != SC_CAMERA_FACING_ANY) {
-        ADD_PARAM("camera_facing=%s",
-            sc_server_get_camera_facing_name(params->camera_facing));
-    }
-    if (params->camera_ar) {
-        VALIDATE_STRING(params->camera_ar);
-        ADD_PARAM("camera_ar=%s", params->camera_ar);
-    }
-    if (params->camera_fps) {
-        ADD_PARAM("camera_fps=%" PRIu16, params->camera_fps);
-    }
-    if (params->camera_high_speed) {
-        ADD_PARAM("camera_high_speed=true");
-    }
     if (params->show_touches) {
         ADD_PARAM("show_touches=true");
     }
     if (params->stay_awake) {
         ADD_PARAM("stay_awake=true");
     }
-    if (params->screen_off_timeout != -1) {
-        assert(params->screen_off_timeout >= 0);
-        uint64_t ms = SC_TICK_TO_MS(params->screen_off_timeout);
-        ADD_PARAM("screen_off_timeout=%" PRIu64, ms);
+    if (params->codec_options) {
+        ADD_PARAM("codec_options=%s", params->codec_options);
     }
-    if (params->video_codec_options) {
-        VALIDATE_STRING(params->video_codec_options);
-        ADD_PARAM("video_codec_options=%s", params->video_codec_options);
-    }
-    if (params->audio_codec_options) {
-        VALIDATE_STRING(params->audio_codec_options);
-        ADD_PARAM("audio_codec_options=%s", params->audio_codec_options);
-    }
-    if (params->video_encoder) {
-        VALIDATE_STRING(params->video_encoder);
-        ADD_PARAM("video_encoder=%s", params->video_encoder);
-    }
-    if (params->audio_encoder) {
-        VALIDATE_STRING(params->audio_encoder);
-        ADD_PARAM("audio_encoder=%s", params->audio_encoder);
+    if (params->encoder_name) {
+        ADD_PARAM("encoder_name=%s", params->encoder_name);
     }
     if (params->power_off_on_close) {
         ADD_PARAM("power_off_on_close=true");
@@ -373,45 +256,16 @@ execute_server(struct sc_server *server,
         // By default, power_on is true
         ADD_PARAM("power_on=false");
     }
-    if (params->new_display) {
-        VALIDATE_STRING(params->new_display);
-        ADD_PARAM("new_display=%s", params->new_display);
-    }
-    if (!params->vd_destroy_content) {
-        ADD_PARAM("vd_destroy_content=false");
-    }
-    if (!params->vd_system_decorations) {
-        ADD_PARAM("vd_system_decorations=false");
-    }
-    if (params->list & SC_OPTION_LIST_ENCODERS) {
-        ADD_PARAM("list_encoders=true");
-    }
-    if (params->list & SC_OPTION_LIST_DISPLAYS) {
-        ADD_PARAM("list_displays=true");
-    }
-    if (params->list & SC_OPTION_LIST_CAMERAS) {
-        ADD_PARAM("list_cameras=true");
-    }
-    if (params->list & SC_OPTION_LIST_CAMERA_SIZES) {
-        ADD_PARAM("list_camera_sizes=true");
-    }
-    if (params->list & SC_OPTION_LIST_APPS) {
-        ADD_PARAM("list_apps=true");
-    }
 
 #undef ADD_PARAM
 
     cmd[count++] = NULL;
 
 #ifdef SERVER_DEBUGGER
-    LOGI("Server debugger listening%s...",
-         sdk_version < 30 ? " on port " SERVER_DEBUGGER_PORT : "");
-    // For Android < 11, from the computer:
-    //     - run `adb forward tcp:5005 tcp:5005`
-    // For Android >= 11:
-    //     - execute `adb jdwp` to get the jdwp port
-    //     - run `adb forward tcp:5005 jdwp:XXXX` (replace XXXX)
-    //
+    LOGI("Server debugger waiting for a client on device port "
+         SERVER_DEBUGGER_PORT "...");
+    // From the computer, run
+    //     adb forward tcp:5005 tcp:5005
     // Then, from Android Studio: Run > Debug > Edit configurations...
     // On the left, click on '+', "Remote", with:
     //     Host: localhost
@@ -484,25 +338,22 @@ connect_to_server(struct sc_server *server, unsigned attempts, sc_tick delay,
 bool
 sc_server_init(struct sc_server *server, const struct sc_server_params *params,
               const struct sc_server_callbacks *cbs, void *cbs_userdata) {
-    // The allocated data in params (const char *) must remain valid until the
-    // end of the program
-    server->params = *params;
-
-    bool ok = sc_adb_init();
+    bool ok = sc_server_params_copy(&server->params, params);
     if (!ok) {
+        LOG_OOM();
         return false;
     }
 
     ok = sc_mutex_init(&server->mutex);
     if (!ok) {
-        sc_adb_destroy();
+        sc_server_params_destroy(&server->params);
         return false;
     }
 
     ok = sc_cond_init(&server->cond_stopped);
     if (!ok) {
         sc_mutex_destroy(&server->mutex);
-        sc_adb_destroy();
+        sc_server_params_destroy(&server->params);
         return false;
     }
 
@@ -510,7 +361,7 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
     if (!ok) {
         sc_cond_destroy(&server->cond_stopped);
         sc_mutex_destroy(&server->mutex);
-        sc_adb_destroy();
+        sc_server_params_destroy(&server->params);
         return false;
     }
 
@@ -519,7 +370,6 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
     server->stopped = false;
 
     server->video_socket = SC_SOCKET_NONE;
-    server->audio_socket = SC_SOCKET_NONE;
     server->control_socket = SC_SOCKET_NONE;
 
     sc_adb_tunnel_init(&server->tunnel);
@@ -538,9 +388,9 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
 static bool
 device_read_info(struct sc_intr *intr, sc_socket device_socket,
                  struct sc_server_info *info) {
-    uint8_t buf[SC_DEVICE_NAME_FIELD_LENGTH];
+    unsigned char buf[SC_DEVICE_NAME_FIELD_LENGTH + 4];
     ssize_t r = net_recv_all_intr(intr, device_socket, buf, sizeof(buf));
-    if (r < SC_DEVICE_NAME_FIELD_LENGTH) {
+    if (r < SC_DEVICE_NAME_FIELD_LENGTH + 4) {
         LOGE("Could not retrieve device information");
         return false;
     }
@@ -548,6 +398,10 @@ device_read_info(struct sc_intr *intr, sc_socket device_socket,
     buf[SC_DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
     memcpy(info->device_name, (char *) buf, sizeof(info->device_name));
 
+    info->frame_size.width = (buf[SC_DEVICE_NAME_FIELD_LENGTH] << 8)
+                           | buf[SC_DEVICE_NAME_FIELD_LENGTH + 1];
+    info->frame_size.height = (buf[SC_DEVICE_NAME_FIELD_LENGTH + 2] << 8)
+                            | buf[SC_DEVICE_NAME_FIELD_LENGTH + 3];
     return true;
 }
 
@@ -560,28 +414,14 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
     const char *serial = server->serial;
     assert(serial);
 
-    bool video = server->params.video;
-    bool audio = server->params.audio;
     bool control = server->params.control;
 
     sc_socket video_socket = SC_SOCKET_NONE;
-    sc_socket audio_socket = SC_SOCKET_NONE;
     sc_socket control_socket = SC_SOCKET_NONE;
     if (!tunnel->forward) {
-        if (video) {
-            video_socket =
-                net_accept_intr(&server->intr, tunnel->server_socket);
-            if (video_socket == SC_SOCKET_NONE) {
-                goto fail;
-            }
-        }
-
-        if (audio) {
-            audio_socket =
-                net_accept_intr(&server->intr, tunnel->server_socket);
-            if (audio_socket == SC_SOCKET_NONE) {
-                goto fail;
-            }
+        video_socket = net_accept_intr(&server->intr, tunnel->server_socket);
+        if (video_socket == SC_SOCKET_NONE) {
+            goto fail;
         }
 
         if (control) {
@@ -604,77 +444,41 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
 
         unsigned attempts = 100;
         sc_tick delay = SC_TICK_FROM_MS(100);
-        sc_socket first_socket = connect_to_server(server, attempts, delay,
-                                                   tunnel_host, tunnel_port);
-        if (first_socket == SC_SOCKET_NONE) {
+        video_socket = connect_to_server(server, attempts, delay, tunnel_host,
+                                         tunnel_port);
+        if (video_socket == SC_SOCKET_NONE) {
             goto fail;
         }
 
-        if (video) {
-            video_socket = first_socket;
-        }
-
-        if (audio) {
-            if (!video) {
-                audio_socket = first_socket;
-            } else {
-                audio_socket = net_socket();
-                if (audio_socket == SC_SOCKET_NONE) {
-                    goto fail;
-                }
-                bool ok = net_connect_intr(&server->intr, audio_socket,
-                                           tunnel_host, tunnel_port);
-                if (!ok) {
-                    goto fail;
-                }
-            }
-        }
-
         if (control) {
-            if (!video && !audio) {
-                control_socket = first_socket;
-            } else {
-                control_socket = net_socket();
-                if (control_socket == SC_SOCKET_NONE) {
-                    goto fail;
-                }
-                bool ok = net_connect_intr(&server->intr, control_socket,
-                                           tunnel_host, tunnel_port);
-                if (!ok) {
-                    goto fail;
-                }
+            // we know that the device is listening, we don't need several
+            // attempts
+            control_socket = net_socket();
+            if (control_socket == SC_SOCKET_NONE) {
+                goto fail;
+            }
+            bool ok = net_connect_intr(&server->intr, control_socket,
+                                       tunnel_host, tunnel_port);
+            if (!ok) {
+                goto fail;
             }
         }
     }
 
-    if (control_socket != SC_SOCKET_NONE) {
-        // Disable Nagle's algorithm for the control socket
-        // (it only impacts the sending side, so it is useless to set it
-        // for the other sockets)
-        bool ok = net_set_tcp_nodelay(control_socket, true);
-        (void) ok; // error already logged
-    }
-
     // we don't need the adb tunnel anymore
     sc_adb_tunnel_close(tunnel, &server->intr, serial,
                         server->device_socket_name);
 
-    sc_socket first_socket = video ? video_socket
-                           : audio ? audio_socket
-                                   : control_socket;
-
     // The sockets will be closed on stop if device_read_info() fails
-    bool ok = device_read_info(&server->intr, first_socket, info);
+    bool ok = device_read_info(&server->intr, video_socket, info);
     if (!ok) {
         goto fail;
     }
 
-    assert(!video || video_socket != SC_SOCKET_NONE);
-    assert(!audio || audio_socket != SC_SOCKET_NONE);
+    assert(video_socket != SC_SOCKET_NONE);
     assert(!control || control_socket != SC_SOCKET_NONE);
 
     server->video_socket = video_socket;
-    server->audio_socket = audio_socket;
     server->control_socket = control_socket;
 
     return true;
@@ -686,12 +490,6 @@ fail:
         }
     }
 
-    if (audio_socket != SC_SOCKET_NONE) {
-        if (!net_close(audio_socket)) {
-            LOGW("Could not close audio socket");
-        }
-    }
-
     if (control_socket != SC_SOCKET_NONE) {
         if (!net_close(control_socket)) {
             LOGW("Could not close control socket");
@@ -832,14 +630,11 @@ sc_server_switch_to_tcpip(struct sc_server *server, const char *serial) {
 }
 
 static bool
-sc_server_connect_to_tcpip(struct sc_server *server, const char *ip_port,
-                           bool disconnect) {
+sc_server_connect_to_tcpip(struct sc_server *server, const char *ip_port) {
     struct sc_intr *intr = &server->intr;
 
-    if (disconnect) {
-        // Error expected if not connected, do not report any error
-        sc_adb_disconnect(intr, ip_port, SC_ADB_SILENT);
-    }
+    // Error expected if not connected, do not report any error
+    sc_adb_disconnect(intr, ip_port, SC_ADB_SILENT);
 
     LOGI("Connecting to %s...", ip_port);
 
@@ -855,7 +650,7 @@ sc_server_connect_to_tcpip(struct sc_server *server, const char *ip_port,
 
 static bool
 sc_server_configure_tcpip_known_address(struct sc_server *server,
-                                        const char *addr, bool disconnect) {
+                                        const char *addr) {
     // Append ":5555" if no port is present
     bool contains_port = strchr(addr, ':');
     char *ip_port = contains_port ? strdup(addr)
@@ -866,7 +661,7 @@ sc_server_configure_tcpip_known_address(struct sc_server *server,
     }
 
     server->serial = ip_port;
-    return sc_server_connect_to_tcpip(server, ip_port, disconnect);
+    return sc_server_connect_to_tcpip(server, ip_port);
 }
 
 static bool
@@ -877,11 +672,6 @@ sc_server_configure_tcpip_unknown_address(struct sc_server *server,
     if (is_already_tcpip) {
         // Nothing to do
         LOGI("Device already connected via TCP/IP: %s", serial);
-        server->serial = strdup(serial);
-        if (!server->serial) {
-            LOG_OOM();
-            return false;
-        }
         return true;
     }
 
@@ -891,16 +681,7 @@ sc_server_configure_tcpip_unknown_address(struct sc_server *server,
     }
 
     server->serial = ip_port;
-    return sc_server_connect_to_tcpip(server, ip_port, false);
-}
-
-static void
-sc_server_kill_adb_if_requested(struct sc_server *server) {
-    if (server->params.kill_adb_on_close) {
-        LOGI("Killing adb server...");
-        unsigned flags = SC_ADB_NO_STDOUT | SC_ADB_NO_STDERR | SC_ADB_NO_LOGERR;
-        sc_adb_kill_server(&server->intr, flags);
-    }
+    return sc_server_connect_to_tcpip(server, ip_port);
 }
 
 static int
@@ -914,7 +695,7 @@ run_server(void *data) {
     // is parsed, so it is not output)
     bool ok = sc_adb_start_server(&server->intr, 0);
     if (!ok) {
-        LOGE("Could not start adb server");
+        LOGE("Could not start adb daemon");
         goto error_connection_failed;
     }
 
@@ -978,13 +759,7 @@ run_server(void *data) {
             sc_adb_device_destroy(&device);
         }
     } else {
-        // If the user passed a '+' (--tcpip=+ip), then disconnect first
-        const char *tcpip_dst = params->tcpip_dst;
-        bool plus = tcpip_dst[0] == '+';
-        if (plus) {
-            ++tcpip_dst;
-        }
-        ok = sc_server_configure_tcpip_known_address(server, tcpip_dst, plus);
+        ok = sc_server_configure_tcpip_known_address(server, params->tcpip_dst);
         if (!ok) {
             goto error_connection_failed;
         }
@@ -994,27 +769,8 @@ run_server(void *data) {
     assert(serial);
     LOGD("Device serial: %s", serial);
 
-    ok = push_server(&server->intr, serial);
-    if (!ok) {
-        goto error_connection_failed;
-    }
-
-    // If --list-* is passed, then the server just prints the requested data
-    // then exits.
-    if (params->list) {
-        sc_pid pid = execute_server(server, params);
-        if (pid == SC_PROCESS_NONE) {
-            goto error_connection_failed;
-        }
-        sc_process_wait(pid, NULL); // ignore exit code
-        sc_process_close(pid);
-        // Wake up await_for_server()
-        server->cbs->on_connected(server, server->cbs_userdata);
-        return 0;
-    }
-
     int r = asprintf(&server->device_socket_name, SC_SOCKET_NAME_PREFIX "%08x",
-                     params->scid);
+                     params->uid);
     if (r == -1) {
         LOG_OOM();
         goto error_connection_failed;
@@ -1022,6 +778,11 @@ run_server(void *data) {
     assert(r == sizeof(SC_SOCKET_NAME_PREFIX) - 1 + 8);
     assert(server->device_socket_name);
 
+    ok = push_server(&server->intr, serial);
+    if (!ok) {
+        goto error_connection_failed;
+    }
+
     ok = sc_adb_tunnel_open(&server->tunnel, &server->intr, serial,
                             server->device_socket_name, params->port_range,
                             params->force_adb_forward);
@@ -1071,16 +832,8 @@ run_server(void *data) {
     sc_mutex_unlock(&server->mutex);
 
     // Interrupt sockets to wake up socket blocking calls on the server
-
-    if (server->video_socket != SC_SOCKET_NONE) {
-        // There is no video_socket if --no-video is set
-        net_interrupt(server->video_socket);
-    }
-
-    if (server->audio_socket != SC_SOCKET_NONE) {
-        // There is no audio_socket if --no-audio is set
-        net_interrupt(server->audio_socket);
-    }
+    assert(server->video_socket != SC_SOCKET_NONE);
+    net_interrupt(server->video_socket);
 
     if (server->control_socket != SC_SOCKET_NONE) {
         // There is no control_socket if --no-control is set
@@ -1108,12 +861,9 @@ run_server(void *data) {
 
     sc_process_close(pid);
 
-    sc_server_kill_adb_if_requested(server);
-
     return 0;
 
 error_connection_failed:
-    sc_server_kill_adb_if_requested(server);
     server->cbs->on_connection_failed(server, server->cbs_userdata);
     return -1;
 }
@@ -1137,10 +887,7 @@ sc_server_stop(struct sc_server *server) {
     sc_cond_signal(&server->cond_stopped);
     sc_intr_interrupt(&server->intr);
     sc_mutex_unlock(&server->mutex);
-}
 
-void
-sc_server_join(struct sc_server *server) {
     sc_thread_join(&server->thread, NULL);
 }
 
@@ -1149,18 +896,14 @@ sc_server_destroy(struct sc_server *server) {
     if (server->video_socket != SC_SOCKET_NONE) {
         net_close(server->video_socket);
     }
-    if (server->audio_socket != SC_SOCKET_NONE) {
-        net_close(server->audio_socket);
-    }
     if (server->control_socket != SC_SOCKET_NONE) {
         net_close(server->control_socket);
     }
 
     free(server->serial);
     free(server->device_socket_name);
+    sc_server_params_destroy(&server->params);
     sc_intr_destroy(&server->intr);
     sc_cond_destroy(&server->cond_stopped);
     sc_mutex_destroy(&server->mutex);
-
-    sc_adb_destroy();
 }

app/src/server.h

@@ -18,43 +18,25 @@
 #define SC_DEVICE_NAME_FIELD_LENGTH 64
 struct sc_server_info {
     char device_name[SC_DEVICE_NAME_FIELD_LENGTH];
+    struct sc_size frame_size;
 };
 
 struct sc_server_params {
-    uint32_t scid;
+    uint32_t uid;
     const char *req_serial;
     enum sc_log_level log_level;
-    enum sc_codec video_codec;
-    enum sc_codec audio_codec;
-    enum sc_video_source video_source;
-    enum sc_audio_source audio_source;
-    enum sc_camera_facing camera_facing;
     const char *crop;
-    const char *video_codec_options;
-    const char *audio_codec_options;
-    const char *video_encoder;
-    const char *audio_encoder;
-    const char *camera_id;
-    const char *camera_size;
-    const char *camera_ar;
-    uint16_t camera_fps;
+    const char *codec_options;
+    const char *encoder_name;
     struct sc_port_range port_range;
     uint32_t tunnel_host;
     uint16_t tunnel_port;
     uint16_t max_size;
-    uint32_t video_bit_rate;
-    uint32_t audio_bit_rate;
-    const char *max_fps; // float to be parsed by the server
-    const char *angle; // float to be parsed by the server
-    sc_tick screen_off_timeout;
-    enum sc_orientation capture_orientation;
-    enum sc_orientation_lock capture_orientation_lock;
+    uint32_t bit_rate;
+    uint16_t max_fps;
+    int8_t lock_video_orientation;
     bool control;
     uint32_t display_id;
-    const char *new_display;
-    bool video;
-    bool audio;
-    bool audio_dup;
     bool show_touches;
     bool stay_awake;
     bool force_adb_forward;
@@ -67,11 +49,6 @@ struct sc_server_params {
     bool select_tcpip;
     bool cleanup;
     bool power_on;
-    bool kill_adb_on_close;
-    bool camera_high_speed;
-    bool vd_destroy_content;
-    bool vd_system_decorations;
-    uint8_t list;
 };
 
 struct sc_server {
@@ -91,7 +68,6 @@ struct sc_server {
     struct sc_adb_tunnel tunnel;
 
     sc_socket video_socket;
-    sc_socket audio_socket;
     sc_socket control_socket;
 
     const struct sc_server_callbacks *cbs;
@@ -131,10 +107,6 @@ sc_server_start(struct sc_server *server);
 void
 sc_server_stop(struct sc_server *server);
 
-// join the server thread
-void
-sc_server_join(struct sc_server *server);
-
 // close and release sockets
 void
 sc_server_destroy(struct sc_server *server);

app/src/shortcut_mod.h

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

app/src/sys/unix/file.c

@@ -6,9 +6,6 @@
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>
-#ifdef __APPLE__
-# include <mach-o/dyld.h> // for _NSGetExecutablePath()
-#endif
 
 #include "util/log.h"
 
@@ -63,22 +60,11 @@ sc_file_get_executable_path(void) {
     }
     buf[len] = '\0';
     return strdup(buf);
-#elif defined(__APPLE__)
-    char buf[PATH_MAX];
-    uint32_t bufsize = PATH_MAX;
-    if (_NSGetExecutablePath(buf, &bufsize) != 0) {
-        LOGE("Executable path buffer too small; need %u bytes", bufsize);
-        return NULL;
-    }
-    return realpath(buf, NULL);
 #else
-    // "_" is often used to store the full path of the command being executed
-    char *path = getenv("_");
-    if (!path) {
-        LOGE("Could not determine executable path");
-        return NULL;
-    }
-    return strdup(path);
+    // in practice, we only need this feature for portable builds, only used on
+    // Windows, so we don't care implementing it for every platform
+    // (it's useful to have a working version on Linux for debugging though)
+    return NULL;
 #endif
 }
 

app/src/sys/win/process.c

@@ -176,8 +176,6 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned flags,
         free(lpAttributeList);
     }
 
-    CloseHandle(pi.hThread);
-
     // These handles are used by the child process, close them for this process
     if (pin) {
         CloseHandle(stdin_read_handle);