Use the physical size for the renderer

Position and scale the frames manually instead of relying on the renderer "logical size". This will allow to draw elements having a size independant of the device frame.
Handle window resizing in screen
2019-10-20 21:09:30 +02:00 · 2019-10-20 16:21:10 +02:00 · 2019-10-20 16:21:10 +02:00 · 2019-10-20 16:09:00 +02:00 · 2019-10-20 16:09:00 +02:00
407 changed files with 8621 additions and 44690 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -1,3 +0,0 @@
 github: [rom1v]
 liberapay: rom1v
 custom: ["https://paypal.me/rom2v"]
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -1,37 +0,0 @@
 ---
 name: Bug report
 about: Create a report to help us improve
 title: ''
 labels: ''
 assignees: ''
 ---
 _Please read the [prerequisites] to run scrcpy._
 [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
 A clear and concise description of what the bug is.
 On errors, please provide the output of the console (and `adb logcat` if relevant).
 ```
 Please paste terminal output in a code block.
 ```
 Please do not post screenshots of your terminal, just post the content as text instead.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@ -1,22 +0,0 @@
 ---
 name: Feature request
 about: Suggest an idea for this project
 title: ''
 labels: ''
 assignees: ''
 ---
 - [ ] I have checked that a similar [feature request](https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3A%22feature+request%22) does not already exist.
 **Is your feature request related to a problem? Please describe.**
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 **Describe the solution you'd like**
 A clear and concise description of what you want to happen.
 **Describe alternatives you've considered**
 A clear and concise description of any alternative solutions or features you've considered.
 **Additional context**
 Add any other context or screenshots about the feature request here.
--- a/.github/ISSUE_TEMPLATE/question.md
+++ b/.github/ISSUE_TEMPLATE/question.md
@ -1,8 +0,0 @@
 ---
 name: Question
 about: Ask a question about scrcpy
 title: ''
 labels: ''
 assignees: ''
 ---
--- a/.github/workflows/release.yml
+++ b/.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
--- a/.gitignore
+++ b/.gitignore
@ -1,10 +1,4 @@
 build/
 /dist/
 /build-*/
 /build_*/
 /release-*/
 .idea/
 .gradle/
 /x/
 local.properties
 /scrcpy-server
--- a/doc/build.md
+++ b/doc/build.md
@ -2,19 +2,11 @@
 Here are the instructions to build _scrcpy_ (client and server).
-If you just want to build and install the latest release, follow the simplified
+You may want to build only the client: the server binary, which will be pushed
-process described in [doc/linux.md](linux.md).
+to the Android device, does not depend on your system and architecture. In that
 case, use the [prebuilt server] (so you will not need Java or the Android SDK).
-## Branches
+[prebuilt server]: #prebuilt-server
 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.
 If you want to contribute code, please base your commits on the latest `dev`
 branch.
 ## Requirements
@ -28,8 +20,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
@ -50,15 +40,15 @@ Install the required packages from your package manager.
 ```bash
 # runtime dependencies
-sudo apt install ffmpeg libsdl2-2.0-0 adb libusb-1.0-0
+sudo apt install ffmpeg libsdl2-2.0-0
 # client build dependencies
-sudo apt install gcc git pkg-config meson ninja-build libsdl2-dev \
+sudo apt install gcc git pkg-config meson ninja-build \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
+                 libavcodec-dev libavformat-dev libavutil-dev \
-                 libswresample-dev libusb-1.0-0-dev
+                 libsdl2-dev
 # server build dependencies
-sudo apt install openjdk-17-jdk
+sudo apt install openjdk-8-jdk
 ```
 On old versions (like Ubuntu 16.04), `meson` is too old. In that case, install
@ -77,7 +67,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 meson gcc make
 # server build dependencies
 sudo dnf install java-devel
@ -94,19 +84,19 @@ 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-8-jdk
 ```
 Then generate the releases:
 ```bash
-./release.sh
+make -f Makefile.CrossWindows
 ```
 It will generate win32 and win64 releases into `dist/`.
@ -122,8 +112,7 @@ install the required packages:
 ```bash
 # runtime dependencies
 pacman -S mingw-w64-x86_64-SDL2 \
-          mingw-w64-x86_64-ffmpeg \
+          mingw-w64-x86_64-ffmpeg
          mingw-w64-x86_64-libusb
 # client build dependencies
 pacman -S mingw-w64-x86_64-make \
@ -137,8 +126,7 @@ For a 32 bits version, replace `x86_64` by `i686`:
 ```bash
 # runtime dependencies
 pacman -S mingw-w64-i686-SDL2 \
-          mingw-w64-i686-ffmpeg \
+          mingw-w64-i686-ffmpeg
          mingw-w64-i686-libusb
 # client build dependencies
 pacman -S mingw-w64-i686-make \
@ -162,19 +150,19 @@ Install the packages with [Homebrew]:
 ```bash
 # runtime dependencies
-brew install sdl2 ffmpeg libusb
+brew install sdl2 ffmpeg
 # client build dependencies
 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`:
+make it avaliable from the `PATH`:
 ```bash
-brew tap homebrew/cask-versions
+brew tap caskroom/versions
-brew install adoptopenjdk/openjdk/adoptopenjdk17
+brew cask install java8
-export JAVA_HOME="$(/usr/libexec/java_home --version 1.17)"
+export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
 export PATH="$JAVA_HOME/bin:$PATH"
 ```
@ -185,44 +173,30 @@ See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).
 ## Common steps
-**As a non-root user**, clone the project:
+If you want to build the server, install the [Android SDK] (_Android Studio_),
 and set `ANDROID_HOME` to its directory. For example:
 [Android SDK]: https://developer.android.com/studio/index.html
 ```bash
 export ANDROID_HOME=~/android/sdk
 ```
 If you don't want to build the server, use the [prebuilt server].
 Clone the project:
 ```bash
 git clone https://github.com/Genymobile/scrcpy
 cd scrcpy
 ```
 ### Build
 You may want to build only the client: the server binary, which will be pushed
 to the Android device, does not depend on your system and architecture. In that
 case, use the [prebuilt server] (so you will not need Java or the Android SDK).
 [prebuilt server]: #option-2-use-prebuilt-server
 #### Option 1: Build everything from sources
 Install the [Android SDK] (_Android Studio_), and set `ANDROID_SDK_ROOT` to its
 directory. For example:
 [Android SDK]: https://developer.android.com/studio/index.html
 ```bash
 # Linux
 export ANDROID_SDK_ROOT=~/Android/Sdk
 # Mac
 export ANDROID_SDK_ROOT=~/Library/Android/sdk
 # Windows
 set ANDROID_SDK_ROOT=%LOCALAPPDATA%\Android\sdk
 ```
 Then, build:
 ```bash
-meson setup x --buildtype=release --strip -Db_lto=true
+meson x --buildtype release --strip -Db_lto=true
-ninja -Cx  # DO NOT RUN AS ROOT
+cd x
 ninja
 ```
 _Note: `ninja` [must][ninja-user] be run as a non-root user (only `ninja
@ -231,27 +205,9 @@ install` must be run as root)._
 [ninja-user]: https://github.com/Genymobile/scrcpy/commit/4c49b27e9f6be02b8e63b508b60535426bd0291a
-#### Option 2: Use prebuilt server
+### Run
- - [`scrcpy-server-v3.1`][direct-scrcpy-server]  
+To run without installing:
   <sub>SHA-256: `958f0944a62f23b1f33a16e9eb14844c1a04b882ca175a738c16d23cb22b86c0`</sub>
 [direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v3.1/scrcpy-server-v3.1
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
 ```bash
 meson setup x --buildtype=release --strip -Db_lto=true \
    -Dprebuilt_server=/path/to/scrcpy-server
 ninja -Cx  # DO NOT RUN AS ROOT
 ```
 The server only works with a matching client version (this server works with the
 `master` branch).
 ### Run without installing:
 ```bash
 ./run x [options]
@ -263,23 +219,33 @@ The server only works with a matching client version (this server works with the
 After a successful build, you can install _scrcpy_ on the system:
 ```bash
-sudo ninja -Cx install    # without sudo on Windows
+sudo ninja install    # without sudo on Windows
 ```
-This installs several files:
+This installs two files:
- - `/usr/local/bin/scrcpy` (main app)
+ - `/usr/local/bin/scrcpy`
- - `/usr/local/share/scrcpy/scrcpy-server` (server to push to the device)
+ - `/usr/local/share/scrcpy/scrcpy-server.jar`
 - `/usr/local/share/man/man1/scrcpy.1` (manpage)
 - `/usr/local/share/icons/hicolor/256x256/apps/icon.png` (app icon)
 - `/usr/local/share/zsh/site-functions/_scrcpy` (zsh completion)
 - `/usr/local/share/bash-completion/completions/scrcpy` (bash completion)
-You can then run `scrcpy`.
+Just remove them to "uninstall" the application.
 You can then [run](README.md#run) _scrcpy_.
-### Uninstall
+## Prebuilt server
 - [`scrcpy-server-v1.10.jar`][direct-scrcpy-server]  
   _(SHA-256: cbeb1a4e046f1392c1dc73c3ccffd7f86dec4636b505556ea20929687a119390)_
 [direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.10/scrcpy-server-v1.10.jar
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
 ```bash
-sudo ninja -Cx uninstall  # without sudo on Windows
+meson x --buildtype release --strip -Db_lto=true \
    -Dprebuilt_server=/path/to/scrcpy-server.jar
 cd x
 ninja
 sudo ninja install
 ```
--- a/DEVELOP.md
+++ b/DEVELOP.md
@ -0,0 +1,270 @@
 # scrcpy for developers
 ## Overview
 This application is composed of two parts:
 - the server (`scrcpy-server.jar`), 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.jar`).
 [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 messges_
   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 client.
 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 immediatly 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 its 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 ;-)
--- a/FAQ.md
+++ b/FAQ.md
@ -1,157 +1,21 @@
 # Frequently Asked Questions
 [Read in another language](#translations)
 Here are the common reported problems and their status.
 If you encounter any error, the first step is to upgrade to the latest version.
 ### On Windows, my device is not detected
-## `adb` and USB issues
+The most common is your device not being detected by `adb`, or is unauthorized.
 Check everything is ok by calling:
-`scrcpy` execute `adb` commands to initialize the connection with the device. If
+    adb devices
 `adb` fails, then scrcpy will not work.
-This is typically not a bug in _scrcpy_, but a problem in your environment.
+Windows may need some [drivers] to detect your device.
 ### `adb` not found
 You need `adb` accessible from your `PATH`.
 On Windows, the current directory is in your `PATH`, and `adb.exe` is included
 in the release, so it should work out-of-the-box.
 ### Device not detected
 >     ERROR: Could not find any ADB device
 Check that you correctly enabled [adb debugging][enable-adb].
 Your device must be detected by `adb`:
 ```
 adb devices
 ```
 If your device is not detected, you may need some [drivers] (on Windows). There is a separate [USB driver for Google devices][google-usb-driver].
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
 [google-usb-driver]: https://developer.android.com/studio/run/win-usb
-### Device unauthorized
+### I can only mirror, I cannot interact with the device
 >     ERROR: Device is unauthorized:
 >     ERROR:     -->   (usb)  0123456789abcdef          unauthorized
 >     ERROR: A popup should open on the device to request authorization.
 When connecting, a popup should open on the device. You must authorize USB
 debugging.
 If it does not open, check [stackoverflow][device-unauthorized].
 [device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
 ### Several devices connected
 If several devices are connected, you will encounter this error:
 >     ERROR: Multiple (2) ADB devices:
 >     ERROR:     -->   (usb)  0123456789abcdef                device  Nexus_5
 >     ERROR:     --> (tcpip)  192.168.1.5:5555                device  GM1913
 >     ERROR: Select a device via -s (--serial), -d (--select-usb) or -e (--select-tcpip)
 In that case, you can either provide the identifier of the device you want to
 mirror:
 ```bash
 scrcpy -s 0123456789abcdef
 ```
 Or request the single USB (or TCP/IP) device:
 ```bash
 scrcpy -d  # USB device
 scrcpy -e  # TCP/IP device
 ```
 Note that if your device is connected over TCP/IP, you might get this message:
 >     adb: error: more than one device/emulator
 >     ERROR: "adb reverse" returned with value 1
 >     WARN: 'adb reverse' failed, fallback to 'adb forward'
 This is expected (due to a bug on old Android versions, see [#5]), but in that
 case, scrcpy fallbacks to a different method, which should work.
 [#5]: https://github.com/Genymobile/scrcpy/issues/5
 ### Conflicts between adb versions
 >     adb server version (41) doesn't match this client (39); killing...
 This error occurs when you use several `adb` versions simultaneously. You must
 find the program using a different `adb` version, and use the same `adb` version
 everywhere.
 You could overwrite the `adb` binary in the other program, or ask _scrcpy_ to
 use a specific `adb` binary, by setting the `ADB` environment variable:
 ```bash
 # in bash
 export ADB=/path/to/your/adb
 scrcpy
 ```
 ```cmd
 :: in cmd
 set ADB=C:\path\to\your\adb.exe
 scrcpy
 ```
 ```powershell
 # in PowerShell
 $env:ADB = 'C:\path\to\your\adb.exe'
 scrcpy
 ```
 ### Device disconnected
 If _scrcpy_ stops itself with the warning "Device disconnected", then the
 `adb` connection has been closed.
 Try with another USB cable or plug it into another USB port. See [#281] and
 [#283].
 [#281]: https://github.com/Genymobile/scrcpy/issues/281
 [#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
 ### Mouse and keyboard do not work
 On some devices, you may need to enable an option to allow [simulating input].
 In developer options, enable:
@ -159,47 +23,33 @@ 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
-### Special characters do not work
+### Mouse clicks at wrong location
-The default text injection method is [limited to ASCII characters][text-input].
+On MacOS, with HiDPI support and multiple screens, input location are wrongly
-A trick allows to also inject some [accented characters][accented-characters],
+scaled. See [issue 15].
 but that's all. See [#37].
-To avoid the problem, [change the keyboard mode to simulate a physical
+[issue 15]: https://github.com/Genymobile/scrcpy/issues/15
 keyboard][hid].
-[text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
+A workaround is to build with HiDPI support disabled:
 [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
 ## Client issues
 ### Issue with Wayland
 By default, SDL uses x11 on Linux. The [video driver] can be changed via the
 `SDL_VIDEODRIVER` environment variable:
 [video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
 ```bash
-export SDL_VIDEODRIVER=wayland
+meson x --buildtype release -Dhidpi_support=false
 scrcpy
 ```
-On some distributions (at least Fedora), the package `libdecor` must be
+However, the video will be displayed at lower resolution.
 installed manually.
 See issues [#2554] and [#2559].
-[#2554]: https://github.com/Genymobile/scrcpy/issues/2554
+### The quality is low on HiDPI display
-[#2559]: https://github.com/Genymobile/scrcpy/issues/2559
+
 On Windows, you may need to 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
 ### KWin compositor crashes
@ -211,25 +61,24 @@ As a workaround, [disable "Block compositing"][kwin].
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
-## Crashes
+### I get an error "Could not open video stream"
-### Exception
+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:
 If you get any exception related to `MediaCodec`:
 ```
 ERROR: Exception on thread Thread[main,5,main]
-java.lang.IllegalStateException
+android.media.MediaCodec$CodecException: Error 0xfffffc0e
-        at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
+...
 Exit due to uncaughtException in main thread:
 ERROR: Could not open video stream
 INFO: Initial texture: 1080x2336
 ```
-then try with another [encoder](doc/video.md#encoder).
+Just try with a lower definition:
-
+```
-## Translations
+scrcpy -m 1920
-
+scrcpy -m 1024
-Translations of this FAQ in other languages are available in the [wiki].
+scrcpy -m 800
-
+```
 [wiki]: https://github.com/Genymobile/scrcpy/wiki
 Only this FAQ file is guaranteed to be up-to-date.
--- a/2
+++ b/2
@ -188,7 +188,7 @@
      identification within third-party archives.
   Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2025 Romain Vimont
+   Copyright (C) 2018-2019 Romain Vimont
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
--- a/Makefile.CrossWindows
+++ b/Makefile.CrossWindows
@ -0,0 +1,138 @@
 # This makefile provides recipes to build a "portable" version of scrcpy for
 # Windows.
 #
 # Here, "portable" means that the client and server binaries are expected to be
 # anywhere, but in the same directory, instead of well-defined separate
 # locations (e.g. /usr/bin/scrcpy and /usr/share/scrcpy/scrcpy-server.jar).
 #
 # In particular, this implies to change the location from where the client push
 # the server to the device.
 .PHONY: default clean \
 	build-server \
 	prepare-deps-win32 prepare-deps-win64 \
 	build-win32 build-win32-noconsole \
 	build-win64 build-win64-noconsole \
 	dist-win32 dist-win64 \
 	zip-win32 zip-win64 \
 	sums release
 GRADLE ?= ./gradlew
 SERVER_BUILD_DIR := build-server
 WIN32_BUILD_DIR := build-win32
 WIN32_NOCONSOLE_BUILD_DIR := build-win32-noconsole
 WIN64_BUILD_DIR := build-win64
 WIN64_NOCONSOLE_BUILD_DIR := build-win64-noconsole
 DIST := dist
 WIN32_TARGET_DIR := scrcpy-win32
 WIN64_TARGET_DIR := scrcpy-win64
 VERSION := $(shell git describe --tags --always)
 WIN32_TARGET := $(WIN32_TARGET_DIR)-$(VERSION).zip
 WIN64_TARGET := $(WIN64_TARGET_DIR)-$(VERSION).zip
 release: clean zip-win32 zip-win64 sums
 	@echo "Windows archives generated in $(DIST)/"
 clean:
 	$(GRADLE) clean
 	rm -rf "$(SERVER_BUILD_DIR)" "$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)" \
 		   "$(WIN32_NOCONSOLE_BUILD_DIR)" "$(WIN64_NOCONSOLE_BUILD_DIR)" "$(DIST)"
 build-server:
 	[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
 		meson "$(SERVER_BUILD_DIR)" \
 			--buildtype release -Dcompile_app=false )
 		ninja -C "$(SERVER_BUILD_DIR)"
 prepare-deps-win32:
 	-$(MAKE) -C prebuilt-deps prepare-win32
 build-win32: prepare-deps-win32
 	[ -d "$(WIN32_BUILD_DIR)" ] || ( mkdir "$(WIN32_BUILD_DIR)" && \
 		meson "$(WIN32_BUILD_DIR)" \
 			--cross-file cross_win32.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
 			-Dcompile_server=false \
 			-Dportable=true )
 	ninja -C "$(WIN32_BUILD_DIR)"
 build-win32-noconsole: prepare-deps-win32
 	[ -d "$(WIN32_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN32_NOCONSOLE_BUILD_DIR)" && \
 		meson "$(WIN32_NOCONSOLE_BUILD_DIR)" \
 			--cross-file cross_win32.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
 			-Dcompile_server=false \
 			-Dwindows_noconsole=true \
 			-Dportable=true )
 	ninja -C "$(WIN32_NOCONSOLE_BUILD_DIR)"
 prepare-deps-win64:
 	-$(MAKE) -C prebuilt-deps prepare-win64
 build-win64: prepare-deps-win64
 	[ -d "$(WIN64_BUILD_DIR)" ] || ( mkdir "$(WIN64_BUILD_DIR)" && \
 		meson "$(WIN64_BUILD_DIR)" \
 			--cross-file cross_win64.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
 			-Dcompile_server=false \
 			-Dportable=true )
 	ninja -C "$(WIN64_BUILD_DIR)"
 build-win64-noconsole: prepare-deps-win64
 	[ -d "$(WIN64_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN64_NOCONSOLE_BUILD_DIR)" && \
 		meson "$(WIN64_NOCONSOLE_BUILD_DIR)" \
 			--cross-file cross_win64.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcrossbuild_windows=true \
 			-Dcompile_server=false \
 			-Dwindows_noconsole=true \
 			-Dportable=true )
 	ninja -C "$(WIN64_NOCONSOLE_BUILD_DIR)"
 dist-win32: build-server build-win32 build-win32-noconsole
 	mkdir -p "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/scrcpy-noconsole.exe"
 	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.1.4-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/SDL2-2.0.10/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 dist-win64: build-server build-win64 build-win64-noconsole
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/scrcpy-noconsole.exe"
 	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.1.4-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/SDL2-2.0.10/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 zip-win32: dist-win32
 	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
 		zip -r "../$(WIN32_TARGET)" .
 zip-win64: dist-win64
 	cd "$(DIST)/$(WIN64_TARGET_DIR)"; \
 		zip -r "../$(WIN64_TARGET)" .
 sums:
 	cd "$(DIST)"; \
 		sha256sum *.zip > SHA256SUMS.txt
--- a/README.md
+++ b/README.md
@ -1,216 +1,402 @@
-**This GitHub repo (<https://github.com/Genymobile/scrcpy>) is the only official
+# scrcpy (v1.10)
 source for the project. Do not download releases from random websites, even if
 their name contains `scrcpy`.**
-# scrcpy (v3.1)
+This application provides display and control of Android devices connected on
-
+USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
-<img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
+It works on _GNU/Linux_, _Windows_ and _macOS_.
 _pronounced "**scr**een **c**o**py**"_
 This application mirrors Android devices (video and audio) connected via
 USB or [over TCP/IP](doc/connection.md#tcpip-wireless), and allows to control the
 device with the keyboard and the mouse of the computer. It does not require any
 _root_ access. It works on _Linux_, _Windows_ and _macOS_.
 ![screenshot](assets/screenshot-debian-600.jpg)
 It focuses on:
- - **lightness**: native, displays only the device screen
+ - **lightness** (native, displays only the device screen)
- - **performance**: 30~120fps, depending on the device
+ - **performance** (30~60fps)
- - **quality**: 1920×1080 or above
+ - **quality** (1920×1080 or above)
- - **low latency**: [35~70ms][lowlatency]
+ - **low latency** ([35~70ms][lowlatency])
- - **low startup time**: ~1 second to display the first image
+ - **low startup time** (~1 second to display the first image)
- - **non-intrusiveness**: nothing is left installed on the Android device
+ - **non-intrusiveness** (nothing is left installed on the device)
 - **user benefits**: no account, no ads, no internet required
 - **freedom**: free and open source software
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 Its features include:
 - [audio forwarding](doc/audio.md) (Android 11+)
 - [recording](doc/recording.md)
 - [virtual display](doc/virtual_display.md)
 - mirroring with [Android device screen off](doc/device.md#turn-screen-off)
 - [copy-paste](doc/control.md#copy-paste) in both directions
 - [configurable quality](doc/video.md)
 - [camera mirroring](doc/camera.md) (Android 12+)
 - [mirroring as a webcam (V4L2)](doc/v4l2.md) (Linux-only)
 - physical [keyboard][hid-keyboard] and [mouse][hid-mouse] simulation (HID)
 - [gamepad](doc/gamepad.md) support
 - [OTG mode](doc/otg.md)
 - and more…
-[hid-keyboard]: doc/keyboard.md#physical-keyboard-simulation
+## Requirements
 [hid-mouse]: doc/mouse.md#physical-mouse-simulation
 ## Prerequisites
 The Android device requires at least API 21 (Android 5.0).
-[Audio forwarding](doc/audio.md) is supported for API >= 30 (Android 11+).
+Make sure you [enabled adb debugging][enable-adb] on your device(s).
-Make sure you [enabled USB debugging][enable-adb] on your device(s).
+[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-[enable-adb]: https://developer.android.com/studio/debug/dev-options#enable
+On some devices, you also need to enable [an additional option][control] to
-
+control it using keyboard and mouse.
 On some devices (especially Xiaomi), you might get the following error:
 ```
 java.lang.SecurityException: Injecting input events requires the caller (or the source of the instrumentation, if any) to have the INJECT_EVENTS permission.
 ```
 In that case, you need to enable [an additional option][control] `USB debugging
 (Security Settings)` (this is an item different from `USB debugging`) to control
 it using a keyboard and mouse. Rebooting the device is necessary once this
 option is set.
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 Note that USB debugging is not required to run scrcpy in [OTG mode](doc/otg.md).
 ## Get the app
- - [Linux](doc/linux.md)
+
- - [Windows](doc/windows.md) (read [how to run](doc/windows.md#run))
+### Linux
- - [macOS](doc/macos.md)
+
 On Linux, you typically need to [build the app manually][BUILD]. Don't worry,
 it's not that hard.
 A [Snap] package is available: [`scrcpy`][snap-link].
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
 For Arch Linux, an [AUR] package is available: [`scrcpy`][aur-link].
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 [aur-link]: https://aur.archlinux.org/packages/scrcpy/
 For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-## Must-know tips
+### Windows
- - [Reducing resolution](doc/video.md#size) may greatly improve performance
+For Windows, for simplicity, prebuilt archives with all the dependencies
-   (`scrcpy -m1024`)
+(including `adb`) are available:
- - [_Right-click_](doc/mouse.md#mouse-bindings) triggers `BACK`
+
- - [_Middle-click_](doc/mouse.md#mouse-bindings) triggers `HOME`
+ - [`scrcpy-win32-v1.10.zip`][direct-win32]  
- - <kbd>Alt</kbd>+<kbd>f</kbd> toggles [fullscreen](doc/window.md#fullscreen)
+   _(SHA-256: f98b400b3764404b33b212e9762dd6f1593ddb766c1480fc2609c94768e4a8e1)_
- - There are many other [shortcuts](doc/shortcuts.md)
+ - [`scrcpy-win64-v1.10.zip`][direct-win64]  
   _(SHA-256: 95de34575d873c7e95dfcfb5e74d0f6af4f70b2a5bc6fde0f48d1a05480e3a44)_
 [direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.10/scrcpy-win32-v1.10.zip
 [direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.10/scrcpy-win64-v1.10.zip
 You can also [build the app manually][BUILD].
-## Usage examples
+### macOS
-There are a lot of options, [documented](#user-documentation) in separate pages.
+The application is available in [Homebrew]. Just install it:
 Here are just some common examples.
- - Capture the screen in H.265 (better quality), limit the size to 1920, limit
+[Homebrew]: https://brew.sh/
   the frame rate to 60fps, disable audio, and control the device by simulating
   a physical keyboard:
-    ```bash
+```bash
-    scrcpy --video-codec=h265 --max-size=1920 --max-fps=60 --no-audio --keyboard=uhid
+brew install scrcpy
-    scrcpy --video-codec=h265 -m1920 --max-fps=60 --no-audio -K  # short version
+```
    ```
- - Start VLC in a new virtual display (separate from the device display):
+You need `adb`, accessible from your `PATH`. If you don't have it yet:
-    ```bash
+```bash
-    scrcpy --new-display=1920x1080 --start-app=org.videolan.vlc
+brew cask install android-platform-tools
-    ```
+```
- - Record the device camera in H.265 at 1920x1080 (and microphone) to an MP4
+You can also [build the app manually][BUILD].
   file:
    ```bash
    scrcpy --video-source=camera --video-codec=h265 --camera-size=1920x1080 --record=file.mp4
    ```
 - Capture the device front camera and expose it as a webcam on the computer (on
   Linux):
    ```bash
    scrcpy --video-source=camera --camera-size=1920x1080 --camera-facing=front --v4l2-sink=/dev/video2 --no-playback
    ```
 - Control the device without mirroring by simulating a physical keyboard and
   mouse (USB debugging not required):
    ```bash
    scrcpy --otg
    ```
 - Control the device using gamepad controllers plugged into the computer:
    ```bash
    scrcpy --gamepad=uhid
    scrcpy -G  # short version
    ```
 ## User documentation
 The application provides a lot of features and configuration options. They are
 documented in the following pages:
 - [Connection](doc/connection.md)
 - [Video](doc/video.md)
 - [Audio](doc/audio.md)
 - [Control](doc/control.md)
 - [Keyboard](doc/keyboard.md)
 - [Mouse](doc/mouse.md)
 - [Gamepad](doc/gamepad.md)
 - [Device](doc/device.md)
 - [Window](doc/window.md)
 - [Recording](doc/recording.md)
 - [Virtual display](doc/virtual_display.md)
 - [Tunnels](doc/tunnels.md)
 - [OTG](doc/otg.md)
 - [Camera](doc/camera.md)
 - [Video4Linux](doc/v4l2.md)
 - [Shortcuts](doc/shortcuts.md)
-## Resources
+## Run
- - [FAQ](FAQ.md)
+Plug an Android device, and execute:
 - [Translations][wiki] (not necessarily up to date)
 - [Build instructions](doc/build.md)
 - [Developers](doc/develop.md)
-[wiki]: https://github.com/Genymobile/scrcpy/wiki
+```bash
 scrcpy
 ```
 It accepts command-line arguments, listed by:
 ```bash
 scrcpy --help
 ```
 ## Features
-## Articles
+### Reduce size
- [Introducing scrcpy][article-intro]
+Sometimes, it is useful to mirror an Android device at a lower definition to
- [Scrcpy now works wirelessly][article-tcpip]
+increase performance.
 - [Scrcpy 2.0, with audio][article-scrcpy2]
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
+To limit both the width and height to some value (e.g. 1024):
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
 [article-scrcpy2]: https://blog.rom1v.com/2023/03/scrcpy-2-0-with-audio/
-## Contact
+```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # short version
 ```
-You can open an [issue] for bug reports, feature requests or general questions.
+The other dimension is computed to that the device aspect ratio is preserved.
-
+That way, a device in 1920×1080 will be mirrored at 1024×576.
 For bug reports, please read the [FAQ](FAQ.md) first, you might find a solution
 to your problem immediately.
 [issue]: https://github.com/Genymobile/scrcpy/issues
 You can also use:
 - Reddit: [`r/scrcpy`](https://www.reddit.com/r/scrcpy)
 - BlueSky: [`@scrcpy.bsky.social`](https://bsky.app/profile/scrcpy.bsky.social)
 - Twitter: [`@scrcpy_app`](https://twitter.com/scrcpy_app)
-## Donate
+### Change bit-rate
-I'm [@rom1v](https://github.com/rom1v), the author and maintainer of _scrcpy_.
+The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):
-If you appreciate this application, you can [support my open source
+```bash
-work][donate]:
+scrcpy --bit-rate 2M
- - [GitHub Sponsors](https://github.com/sponsors/rom1v)
+scrcpy -b 2M  # short version
- - [Liberapay](https://liberapay.com/rom1v/)
+```
- - [PayPal](https://paypal.me/rom2v)
+
 ### Crop
 The device screen may be cropped to mirror only part of the screen.
 This is useful for example to mirror only one eye of the Oculus Go:
 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
 scrcpy -c 1224:1440:0:0       # short version
 ```
 If `--max-size` is also specified, resizing is applied after cropping.
 ### Wireless
 _Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
 device over TCP/IP:
 1. Connect the device to the same Wi-Fi as your computer.
 2. Get your device IP address (in Settings → About phone → Status).
 3. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
 4. Unplug your device.
 5. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`)_.
 6. Run `scrcpy` as usual.
 It may be useful to decrease the bit-rate and the definition:
 ```bash
 scrcpy --bit-rate 2M --max-size 800
 scrcpy -b2M -m800  # short version
 ```
 [connect]: https://developer.android.com/studio/command-line/adb.html#wireless
 ### Record screen
 It is possible to record the screen while mirroring:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 To disable mirroring while recording:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrupt recording with Ctrl+C
 # Ctrl+C does not terminate properly on Windows, so disconnect the device
 ```
 "Skipped frames" are recorded, even if they are not displayed in real time (for
 performance reasons). Frames are _timestamped_ on the device, so [packet delay
 variation] does not impact the recorded file.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
 ### Multi-devices
 If several devices are listed in `adb devices`, you must specify the _serial_:
 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # short version
 ```
 You can start several instances of _scrcpy_ for several devices.
 ### Fullscreen
 The app may be started directly in fullscreen:
 ```bash
 scrcpy --fullscreen
 scrcpy -f  # short version
 ```
 Fullscreen can then be toggled dynamically with `Ctrl`+`f`.
 ### Always on top
 The window of app can always be above others by:
 ```bash
 scrcpy --always-on-top
 scrcpy -T  # short version
 ```
 ### Show touches
 For presentations, it may be useful to show physical touches (on the physical
 device).
 Android provides this feature in _Developers options_.
 _Scrcpy_ provides an option to enable this feature on start and disable on exit:
 ```bash
 scrcpy --show-touches
 scrcpy -t
 ```
 Note that it only shows _physical_ touches (with the finger on the device).
 ### Install APK
 To install an APK, drag & drop an APK file (ending with `.apk`) to the _scrcpy_
 window.
 There is no visual feedback, a log is printed to the console.
 ### Push file to device
 To push a file to `/sdcard/` on the device, drag & drop a (non-APK) file to the
 _scrcpy_ window.
 There is no visual feedback, a log is printed to the console.
 The target directory can be changed on start:
 ```bash
 scrcpy --push-target /sdcard/foo/bar/
 ```
 ### Read-only
 To disable controls (everything which can interact with the device: input keys,
 mouse events, drag&drop files):
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
 ### Turn screen off
 It is possible to turn the device screen off while mirroring on start with a
 command-line option:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
 Or by pressing `Ctrl`+`o` at any time.
 To turn it back on, press `POWER` (or `Ctrl`+`p`).
 ### Render expired frames
 By default, to minimize latency, _scrcpy_ always renders the last decoded frame
 available, and drops any previous one.
 To force the rendering of all frames (at a cost of a possible increased
 latency), use:
 ```bash
 scrcpy --render-expired-frames
 ```
 ### Custom window title
 By default, the window title is the device model. It can be changed:
 ```bash
 scrcpy --window-title 'My device'
 ```
 ### Forward audio
 Audio is not forwarded by _scrcpy_. Use [USBaudio] (Linux-only).
 Also see [issue #14].
 [USBaudio]: https://github.com/rom1v/usbaudio
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## Shortcuts
 | Action                                 |   Shortcut                    |   Shortcut (macOS)
 | -------------------------------------- |:----------------------------- |:-----------------------------
 | Switch fullscreen mode                 | `Ctrl`+`f`                    | `Cmd`+`f`
 | Resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`                    | `Cmd`+`g`
 | Resize window to remove black borders  | `Ctrl`+`x` \| _Double-click¹_ | `Cmd`+`x`  \| _Double-click¹_
 | Click on `HOME`                        | `Ctrl`+`h` \| _Middle-click_  | `Ctrl`+`h` \| _Middle-click_
 | Click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  | `Cmd`+`b`  \| _Right-click²_
 | Click on `APP_SWITCH`                  | `Ctrl`+`s`                    | `Cmd`+`s`
 | Click on `MENU`                        | `Ctrl`+`m`                    | `Ctrl`+`m`
 | Click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_             | `Cmd`+`↑` _(up)_
 | Click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_           | `Cmd`+`↓` _(down)_
 | Click on `POWER`                       | `Ctrl`+`p`                    | `Cmd`+`p`
 | Power on                               | _Right-click²_                | _Right-click²_
 | Turn device screen off (keep mirroring)| `Ctrl`+`o`                    | `Cmd`+`o`
 | Expand notification panel              | `Ctrl`+`n`                    | `Cmd`+`n`
 | Collapse notification panel            | `Ctrl`+`Shift`+`n`            | `Cmd`+`Shift`+`n`
 | Copy device clipboard to computer      | `Ctrl`+`c`                    | `Cmd`+`c`
 | Paste computer clipboard to device     | `Ctrl`+`v`                    | `Cmd`+`v`
 | Copy computer clipboard to device      | `Ctrl`+`Shift`+`v`            | `Cmd`+`Shift`+`v`
 | Enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    | `Cmd`+`i`
 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._
 ## Custom paths
 To use a specific _adb_ binary, configure its path in the environment variable
 `ADB`:
    ADB=/path/to/adb scrcpy
 To override the path of the `scrcpy-server.jar` file, configure its path in
 `SCRCPY_SERVER_PATH`.
 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## Why _scrcpy_?
 A colleague challenged me to find a name as unpronounceable as [gnirehtet].
 [`strcpy`] copies a **str**ing; `scrcpy` copies a **scr**een.
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## How to build?
 See [BUILD].
 [BUILD]: BUILD.md
 ## Common issues
 See the [FAQ](FAQ.md).
 ## Developers
 Read the [developers page].
 [developers page]: DEVELOP.md
 [donate]: https://blog.rom1v.com/about/#support-my-open-source-work
 ## Licence
    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2025 Romain Vimont
+    Copyright (C) 2018-2019 Romain Vimont
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@ -223,3 +409,11 @@ work][donate]:
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 ## Articles
 - [Introducing scrcpy][article-intro]
 - [Scrcpy now works wirelessly][article-tcpip]
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/app/data/bash-completion/scrcpy
+++ b/app/data/bash-completion/scrcpy
@ -1,221 +0,0 @@
 _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=
        --crop=
        -d --select-usb
        --disable-screensaver
        --display-id=
        --display-orientation=
        -e --select-tcpip
        -f --fullscreen
        --force-adb-forward
        -G
        --gamepad=
        -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
        --max-fps=
        --mouse=
        --mouse-bind=
        -n --no-control
        -N --no-playback
        --new-display
        --new-display=
        --no-audio
        --no-audio-playback
        --no-cleanup
        --no-clipboard-autosync
        --no-downsize-on-error
        --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
        --record-format=
        --record-orientation=
        --render-driver=
        --require-audio
        --rotation=
        -s --serial=
        -S --turn-screen-off
        --screen-off-timeout=
        --shortcut-mod=
        --start-app=
        -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=
        -w --stay-awake
        --window-borderless
        --window-title=
        --window-x=
        --window-y=
        --window-width=
        --window-height="
    _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"))
            return
            ;;
        -r|--record)
            COMPREPLY=($(compgen -f -- "$cur"))
            return
            ;;
        --record-format)
            COMPREPLY=($(compgen -W 'mp4 mkv m4a mka opus aac flac wav' -- "$cur"))
            return
            ;;
        --render-driver)
            COMPREPLY=($(compgen -W 'direct3d opengl opengles2 opengles metal software' -- "$cur"))
            return
            ;;
        --shortcut-mod)
            # Only auto-complete a single key
            COMPREPLY=($(compgen -W 'lctrl rctrl lalt ralt lsuper rsuper' -- "$cur"))
            return
            ;;
        -V|--verbosity)
            COMPREPLY=($(compgen -W 'verbose debug info warn error' -- "$cur"))
            return
            ;;
        -s|--serial)
            # Use 'adb devices' to list serial numbers
            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 \
        |--crop \
        |--display-id \
        |--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
            return
            ;;
    esac
    COMPREPLY=($(compgen -W "$opts" -- "$cur"))
    [[ $COMPREPLY == *= ]] && compopt -o nospace
 }
 complete -F _scrcpy scrcpy
--- a/app/data/icon.ico
+++ b/app/data/icon.ico
--- a/app/data/icon.png
+++ b/app/data/icon.png
--- a/app/data/icon.svg
+++ b/app/data/icon.svg
@ -1,16 +0,0 @@
 <svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" version="1.1">
 <path style="opacity:0.2" d="m 16.846877,12 c -1.116351,0 -2.227419,0.912229 -2.015075,2 l 3.122973,16 -5.596557,11.109375 C 11.959876,41.871734 11.885244,42.336988 12.177176,43 c 0.278672,0.632897 0.998812,1 1.747448,1 H 24 34.075375 c 0.748637,0 1.468777,-0.367103 1.747448,-1 0.291932,-0.663012 0.217302,-1.128266 -0.181041,-1.890625 L 30.045225,30 33.168198,14 c 0.212344,-1.087771 -0.898724,-2 -2.015075,-2 H 24 Z"/>
 <path style="fill:#cccccc" d="m 16.846877,11 c -1.116351,0 -2.227419,0.912229 -2.015075,2 l 3.122973,16 -5.596557,11.109375 C 11.959876,40.871734 11.885244,41.336988 12.177176,42 c 0.278672,0.632897 0.998812,1 1.747448,1 H 24 34.075375 c 0.748637,0 1.468777,-0.367103 1.747448,-1 0.291932,-0.663012 0.217302,-1.128266 -0.181041,-1.890625 L 30.045225,29 33.168198,13 c 0.212344,-1.087771 -0.898724,-2 -2.015075,-2 H 24 Z"/>
 <rect style="opacity:0.2" width="40" height="32" x="4" y="6" rx="2" ry="2"/>
 <path style="fill:#e4e4e4" d="m 4,33 v 2 c 0,1.108 0.892,2 2,2 h 36 c 1.108,0 2,-0.892 2,-2 v -2 z"/>
 <path style="opacity:0.1" d="m 11.494141,15 a 1.5,1.5 0 0 0 -0.832032,0.255859 1.5,1.5 0 0 0 -0.40625,2.082032 l 3.13086,4.654297 C 10.404945,24.606192 8.4012371,28.299159 8.0019531,32.460938 7.9284599,34.000879 9.5546875,34 9.5546875,34 H 38.40625 c 0,0 1.672856,-3.38e-4 1.591797,-1.617188 -0.416529,-4.131451 -2.415618,-7.796833 -5.380859,-10.394531 l 3.126953,-4.65039 a 1.5,1.5 0 0 0 -0.40625,-2.082032 1.5,1.5 0 0 0 -1.125,-0.228515 1.5,1.5 0 0 0 -0.957032,0.634765 l -3.072265,4.566407 C 29.78649,18.814887 26.990024,18 24.001953,18 c -2.989385,0 -5.786177,0.815488 -8.183594,2.230469 l -3.074218,-4.56836 A 1.5,1.5 0 0 0 11.787109,15.027344 1.5,1.5 0 0 0 11.494141,15 Z"/>
 <path style="fill:#077063" d="M 6,5 C 4.892,5 4,5.892 4,7 V 33 H 44 V 7 C 44,5.892 43.108,5 42,5 Z"/>
 <path style="opacity:0.1;fill:#ffffff" d="M 6,5 C 4.892,5 4,5.892 4,7 V 8 C 4,6.892 4.892,6 6,6 h 36 c 1.108,0 2,0.892 2,2 V 7 C 44,5.892 43.108,5 42,5 Z"/>
 <path style="fill:none;stroke:#30dd81;stroke-width:3;stroke-linecap:round" d="M 15.1998,21.000026 11.5,15.5"/>
 <path style="fill:none;stroke:#30dd81;stroke-width:3;stroke-linecap:round" d="M 32.799764,21.000026 36.5,15.5"/>
 <path style="fill:#30dd81" d="m 24.002386,17.000034 c -8.355868,0 -15.2214979,6.346843 -15.9999669,14.460906 C 7.9289259,33.000882 9.5544999,33 9.5544999,33 H 38.406003 c 0,0 1.672201,-3.35e-4 1.591142,-1.617185 C 39.182807,23.305596 32.331836,17.000034 24.002386,17.000034 Z"/>
 <path style="opacity:0.2" d="m 16,25 a 1.9999959,1.9999959 0 0 0 -2,2 1.9999959,1.9999959 0 0 0 2,2 1.9999959,1.9999959 0 0 0 2,-2 1.9999959,1.9999959 0 0 0 -2,-2 z m 16,0 a 1.9999959,1.9999959 0 0 0 -2,2 1.9999959,1.9999959 0 0 0 2,2 1.9999959,1.9999959 0 0 0 2,-2 1.9999959,1.9999959 0 0 0 -2,-2 z"/>
 <path style="fill:#ffffff" d="M 15.999996,24.000008 A 1.9999959,1.9999959 0 0 1 17.999992,26.000004 1.9999959,1.9999959 0 0 1 15.999996,28 1.9999959,1.9999959 0 0 1 14,26.000004 1.9999959,1.9999959 0 0 1 15.999996,24.000008 Z"/>
 <path style="fill:#ffffff" d="M 31.999996,24.000008 A 1.9999959,1.9999959 0 0 1 33.999991,26.000004 1.9999959,1.9999959 0 0 1 31.999996,28 1.9999959,1.9999959 0 0 1 30,26.000004 1.9999959,1.9999959 0 0 1 31.999996,24.000008 Z"/>
 <path style="fill:#ffffff;opacity:0.2" d="M 11.494141 14 A 1.5 1.5 0 0 0 10.662109 14.255859 A 1.5 1.5 0 0 0 10.115234 16.001953 A 1.5 1.5 0 0 1 10.662109 15.255859 A 1.5 1.5 0 0 1 11.494141 15 A 1.5 1.5 0 0 1 11.787109 15.027344 A 1.5 1.5 0 0 1 12.744141 15.662109 L 15.818359 20.230469 C 18.215776 18.815488 21.012568 18 24.001953 18 C 26.990024 18 29.78649 18.814887 32.183594 20.228516 L 35.255859 15.662109 A 1.5 1.5 0 0 1 36.212891 15.027344 A 1.5 1.5 0 0 1 37.337891 15.255859 A 1.5 1.5 0 0 1 37.910156 16.001953 A 1.5 1.5 0 0 0 37.337891 14.255859 A 1.5 1.5 0 0 0 36.212891 14.027344 A 1.5 1.5 0 0 0 35.255859 14.662109 L 32.183594 19.228516 C 29.78649 17.814887 26.990024 17 24.001953 17 C 21.012568 17 18.215776 17.815488 15.818359 19.230469 L 12.744141 14.662109 A 1.5 1.5 0 0 0 11.787109 14.027344 A 1.5 1.5 0 0 0 11.494141 14 z M 35.033203 21.369141 L 34.617188 21.988281 C 37.477056 24.493668 39.433905 27.993356 39.943359 31.945312 C 39.986866 31.783283 40.008864 31.598575 39.998047 31.382812 C 39.601372 27.448291 37.768055 23.938648 35.033203 21.369141 z M 12.970703 21.373047 C 10.220358 23.959215 8.3822757 27.496796 8.0019531 31.460938 C 7.9920657 31.668114 8.0150508 31.844846 8.0585938 32 C 8.5570234 28.027243 10.515755 24.509049 13.386719 21.992188 L 12.970703 21.373047 z"/>
 </svg>
--- a/app/data/open_a_terminal_here.bat
+++ b/app/data/open_a_terminal_here.bat
@ -1 +0,0 @@
@cmd
--- a/app/data/scrcpy-console.bat
+++ b/app/data/scrcpy-console.bat
@ -1,2 +0,0 @@
@echo off
 scrcpy.exe --pause-on-exit=if-error %*
--- a/app/data/scrcpy-console.desktop
+++ b/app/data/scrcpy-console.desktop
@ -1,13 +0,0 @@
 [Desktop Entry]
 Name=scrcpy (console)
 GenericName=Android Remote Control
 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'"
 Icon=scrcpy
 Terminal=true
 Type=Application
 Categories=Utility;RemoteAccess;
 StartupNotify=false
--- a/app/data/scrcpy-noconsole.vbs
+++ b/app/data/scrcpy-noconsole.vbs
@ -1,7 +0,0 @@
 strCommand = "cmd /c scrcpy.exe"
 For Each Arg In WScript.Arguments
    strCommand = strCommand & " """ & replace(Arg, """", """""""""") & """"
 Next
 CreateObject("Wscript.Shell").Run strCommand, 0, false
--- a/app/data/scrcpy.desktop
+++ b/app/data/scrcpy.desktop
@ -1,13 +0,0 @@
 [Desktop Entry]
 Name=scrcpy
 GenericName=Android Remote Control
 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"
 Icon=scrcpy
 Terminal=false
 Type=Application
 Categories=Utility;RemoteAccess;
 StartupNotify=false
--- a/app/data/zsh-completion/_scrcpy
+++ b/app/data/zsh-completion/_scrcpy
@ -1,112 +0,0 @@
 #compdef -N scrcpy -N scrcpy.exe
 #
 # name: scrcpy
 # auth: hltdev [hltdev8642@gmail.com]
 # desc: completion file for scrcpy (all OSes)
 #
 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)'
    '--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)'
    {-e,--select-tcpip}'[Use TCP/IP device]'
    {-f,--fullscreen}'[Start in fullscreen]'
    '--force-adb-forward[Do not attempt to use \"adb reverse\" to connect to the device]'
    '-G[Use UHID/AOA gamepad (same as --gamepad=uhid or --gamepad=aoa, depending on OTG mode)]'
    '--gamepad=[Set the gamepad input mode]:mode:(disabled uhid aoa)'
    {-h,--help}'[Print the help]'
    '-K[Use UHID/AOA keyboard (same as --keyboard=uhid or --keyboard=aoa, depending on OTG mode)]'
    '--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)]'
    '--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]'
    '--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]'
    '--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)'
    '--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]'
    {-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]'
    {-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)'
    {-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]'
    '--window-x=[Set the initial window horizontal position]'
    '--window-y=[Set the initial window vertical position]'
    '--window-width=[Set the initial window width]'
    '--window-height=[Set the initial window height]'
 )
 _arguments -s $arguments
--- a/app/deps/.gitignore
+++ b/app/deps/.gitignore
@ -1 +0,0 @@
 /work
--- a/app/deps/README
+++ b/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/
--- a/app/deps/adb_linux.sh
+++ b/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/"
--- a/app/deps/adb_macos.sh
+++ b/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/"
--- a/app/deps/adb_windows.sh
+++ b/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/"
--- a/app/deps/common
+++ b/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"
 }
--- a/app/deps/dav1d.sh
+++ b/app/deps/dav1d.sh
@ -1,68 +0,0 @@
 #!/usr/bin/env bash
 set -ex
 DEPS_DIR=$(dirname ${BASH_SOURCE[0]})
 cd "$DEPS_DIR"
 . common
 process_args "$@"
 VERSION=1.5.0
 FILENAME=dav1d-$VERSION.tar.gz
 PROJECT_DIR=dav1d-$VERSION
 SHA256SUM=78b15d9954b513ea92d27f39362535ded2243e1b0924fde39f37a31ebed5f76b
 cd "$SOURCES_DIR"
 if [[ -d "$PROJECT_DIR" ]]
 then
    echo "$PWD/$PROJECT_DIR" found
 else
    get_file "https://code.videolan.org/videolan/dav1d/-/archive/$VERSION/$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"
    conf=(
        --prefix="$INSTALL_DIR/$DIRNAME"
        --libdir=lib
        -Denable_tests=false
        -Denable_tools=false
        # Always build dav1d statically
        --default-library=static
    )
    if [[ "$BUILD_TYPE" == cross ]]
    then
        case "$HOST" in
            win32)
                conf+=(
                    --cross-file="$SOURCES_DIR/$PROJECT_DIR/package/crossfiles/i686-w64-mingw32.meson"
                )
                ;;
            win64)
                conf+=(
                    --cross-file="$SOURCES_DIR/$PROJECT_DIR/package/crossfiles/x86_64-w64-mingw32.meson"
                )
                ;;
            *)
                echo "Unsupported host: $HOST" >&2
                exit 1
        esac
    fi
    meson setup . "$SOURCES_DIR/$PROJECT_DIR" "${conf[@]}"
 fi
 ninja
 ninja install
--- a/app/deps/ffmpeg.sh
+++ b/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 PKG_CONFIG_PATH="/opt/homebrew/opt/zlib/lib/pkgconfig"
    fi
    export PKG_CONFIG_PATH="$INSTALL_DIR/$DIRNAME/lib/pkgconfig:$PKG_CONFIG_PATH"
    conf=(
        --prefix="$INSTALL_DIR/$DIRNAME"
        --pkg-config-flags="--static"
        --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-libdav1d
        --enable-decoder=h264
        --enable-decoder=hevc
        --enable-decoder=av1
        --enable-decoder=libdav1d
        --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
--- a/app/deps/libusb.sh
+++ b/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
--- a/app/deps/sdl.sh
+++ b/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.10
 FILENAME=SDL-$VERSION.tar.gz
 PROJECT_DIR=SDL-release-$VERSION
 SHA256SUM=35a8b9c4f3635d85762b904ac60ca4e0806bff89faeb269caafbe80860d67168
 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
--- a/app/meson.build
+++ b/app/meson.build
@ -1,156 +1,91 @@
 src = [
    'src/main.c',
-    'src/adb/adb.c',
+    'src/command.c',
    '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/device.c',
    'src/demuxer.c',
    'src/device_msg.c',
-    'src/display.c',
+    'src/event_converter.c',
-    'src/events.c',
+    'src/file_handler.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/net.c',
    'src/mouse_capture.c',
    'src/mouse_sdk.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/str_util.c',
-    'src/hid/hid_gamepad.c',
+    'src/tiny_xpm.c',
-    'src/hid/hid_keyboard.c',
+    'src/stream.c',
-    'src/hid/hid_mouse.c',
+    'src/video_buffer.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/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',
    'src/util/process_intr.c',
    'src/util/rand.c',
    'src/util/strbuf.c',
    'src/util/str.c',
    'src/util/term.c',
    'src/util/thread.c',
    'src/util/tick.c',
    'src/util/timeout.c',
 ]
-conf = configuration_data()
+if not get_option('crossbuild_windows')
-conf.set('_POSIX_C_SOURCE', '200809L')
+    # native build
-conf.set('_XOPEN_SOURCE', '700')
+    dependencies = [
-conf.set('_GNU_SOURCE', true)
+        dependency('libavformat'),
-
+        dependency('libavcodec'),
-if host_machine.system() == 'windows'
+        dependency('libavutil'),
-    windows = import('windows')
+        dependency('sdl2'),
    src += [
        'src/sys/win/file.c',
        'src/sys/win/process.c',
        windows.compile_resources('scrcpy-windows.rc'),
    ]
-    conf.set('_WIN32_WINNT', '0x0600')
+
    conf.set('WINVER', '0x0600')
 else
    src += [
        'src/sys/unix/file.c',
        'src/sys/unix/process.c',
    ]
    if host_machine.system() == 'darwin'
        conf.set('_DARWIN_C_SOURCE', true)
    endif
 endif
-v4l2_support = get_option('v4l2') and host_machine.system() == 'linux'
+    # cross-compile mingw32 build (from Linux to Windows)
-if v4l2_support
+    cc = meson.get_compiler('c')
    src += [ 'src/v4l2_sink.c' ]
 endif
-usb_support = get_option('usb')
+    prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
-if usb_support
+    sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
-    src += [
+    sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/lib'
-        'src/usb/aoa_hid.c',
+    sdl2_include_dir = '../prebuilt-deps/' + prebuilt_sdl2 + '/include'
-        'src/usb/gamepad_aoa.c',
+
-        'src/usb/keyboard_aoa.c',
+    sdl2 = declare_dependency(
-        'src/usb/mouse_aoa.c',
+        dependencies: [
-        'src/usb/scrcpy_otg.c',
+            cc.find_library('SDL2', dirs: sdl2_bin_dir),
-        'src/usb/screen_otg.c',
+            cc.find_library('SDL2main', dirs: sdl2_lib_dir),
-        'src/usb/usb.c',
+        ],
        include_directories: include_directories(sdl2_include_dir)
    )
    prebuilt_ffmpeg_shared = meson.get_cross_property('prebuilt_ffmpeg_shared')
    prebuilt_ffmpeg_dev = meson.get_cross_property('prebuilt_ffmpeg_dev')
    ffmpeg_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_ffmpeg_shared + '/bin'
    ffmpeg_include_dir = '../prebuilt-deps/' + prebuilt_ffmpeg_dev + '/include'
    ffmpeg = declare_dependency(
        dependencies: [
            cc.find_library('avcodec-58', dirs: ffmpeg_bin_dir),
            cc.find_library('avformat-58', dirs: ffmpeg_bin_dir),
            cc.find_library('avutil-56', dirs: ffmpeg_bin_dir),
        ],
        include_directories: include_directories(ffmpeg_include_dir)
    )
    dependencies = [
        ffmpeg,
        sdl2,
        cc.find_library('mingw32')
    ]
 endif
 cc = meson.get_compiler('c')
 static = get_option('static')
 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 v4l2_support
    dependencies += dependency('libavdevice', static: static)
 endif
 if usb_support
    dependencies += dependency('libusb-1.0', static: static)
 endif
 if host_machine.system() == 'windows'
-    dependencies += cc.find_library('mingw32')
+    src += [ 'src/sys/win/command.c' ]
    src += [ 'src/sys/win/net.c' ]
    dependencies += cc.find_library('ws2_32')
 else
    src += [ 'src/sys/unix/command.c' ]
    src += [ 'src/sys/unix/net.c' ]
 endif
-check_functions = [
+conf = configuration_data()
    'strdup',
    'asprintf',
    'vasprintf',
    'nrand48',
    'jrand48',
    'reallocarray',
 ]
-foreach f : check_functions
+# expose the build type
-  if cc.has_function(f)
+conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')
    define = 'HAVE_' + f.underscorify().to_upper()
    conf.set(define, true)
  endif
 endforeach
 conf.set('HAVE_SOCK_CLOEXEC', host_machine.system() != 'windows' and
                              cc.has_header_symbol('sys/socket.h', 'SOCK_CLOEXEC'))
 # the version, updated on release
 conf.set_quoted('SCRCPY_VERSION', meson.project_version())
@ -158,124 +93,75 @@ conf.set_quoted('SCRCPY_VERSION', meson.project_version())
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))
-# build a "portable" version (with scrcpy-server accessible from the same
+# build a "portable" version (with scrcpy-server.jar accessible from the same
 # directory as the executable)
 conf.set('PORTABLE', get_option('portable'))
-# the default client TCP port range for the "adb reverse" tunnel
+# the default client TCP port for the "adb reverse" tunnel
 # overridden by option --port
-conf.set('DEFAULT_LOCAL_PORT_RANGE_FIRST', '27183')
+conf.set('DEFAULT_LOCAL_PORT', '27183')
 conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')
-# run a server debugger and wait for a client to be attached
+# the default max video size for both dimensions, in pixels
-conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
+# overridden by option --max-size
 conf.set('DEFAULT_MAX_SIZE', '0')  # 0: unlimited
-# enable V4L2 support (linux only)
+# the default video bitrate, in bits/second
-conf.set('HAVE_V4L2', v4l2_support)
+# overridden by option --bit-rate
 conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
-# enable HID over AOA support (linux only)
+# enable High DPI support
-conf.set('HAVE_USB', usb_support)
+conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
 # disable console on Windows
 conf.set('WINDOWS_NOCONSOLE', get_option('windows_noconsole'))
 configure_file(configuration: conf, output: 'config.h')
 src_dir = include_directories('src')
 if get_option('windows_noconsole')
    c_args = [ '-mwindows' ]
    link_args = [ '-mwindows' ]
 else
    c_args = []
    link_args = []
 endif
 executable('scrcpy', src,
           dependencies: dependencies,
           include_directories: src_dir,
           install: true,
-           c_args: [])
+           c_args: c_args,
-
+           link_args: link_args)
 # <https://mesonbuild.com/Builtin-options.html#directories>
 datadir = get_option('datadir') # by default 'share'
 install_man('scrcpy.1')
 install_data('data/icon.png',
             rename: 'scrcpy.png',
             install_dir: join_paths(datadir, 'icons/hicolor/256x256/apps'))
 install_data('data/zsh-completion/_scrcpy',
             install_dir: join_paths(datadir, 'zsh/site-functions'))
 install_data('data/bash-completion/scrcpy',
             install_dir: join_paths(datadir, 'bash-completion/completions'))
 # Desktop entry file for application launchers
 if host_machine.system() == 'linux'
    # Install a launcher (ex: /usr/local/share/applications/scrcpy.desktop)
    install_data('data/scrcpy.desktop',
                 install_dir: join_paths(datadir, 'applications'))
    install_data('data/scrcpy-console.desktop',
                 install_dir: join_paths(datadir, 'applications'))
 endif
 ### TESTS
-# do not build tests in release (assertions would not be executed at all)
+tests = [
-if get_option('buildtype') == 'debug'
+    ['test_cbuf', [
-    tests = [
+        'tests/test_cbuf.c',
        ['test_adb_parser', [
            'tests/test_adb_parser.c',
            'src/adb/adb_device.c',
            'src/adb/adb_parser.c',
            'src/util/str.c',
            'src/util/strbuf.c',
    ]],
-        ['test_binary', [
+    ['test_control_event_serialize', [
            'tests/test_binary.c',
        ]],
        ['test_audiobuf', [
            'tests/test_audiobuf.c',
            'src/util/audiobuf.c',
            'src/util/memory.c',
        ]],
        ['test_cli', [
            'tests/test_cli.c',
            'src/cli.c',
            'src/options.c',
            'src/util/log.c',
            'src/util/net.c',
            'src/util/str.c',
            'src/util/strbuf.c',
            'src/util/term.c',
        ]],
        ['test_control_msg_serialize', [
        'tests/test_control_msg_serialize.c',
        'src/control_msg.c',
-            'src/util/str.c',
+        'src/str_util.c'
            'src/util/strbuf.c',
    ]],
-        ['test_device_msg_deserialize', [
+    ['test_device_event_deserialize', [
        'tests/test_device_msg_deserialize.c',
-            'src/device_msg.c',
+        'src/device_msg.c'
    ]],
-        ['test_orientation', [
+    ['test_queue', [
-            'tests/test_orientation.c',
+        'tests/test_queue.c',
            'src/options.c',
    ]],
-        ['test_strbuf', [
+    ['test_strutil', [
-            'tests/test_strbuf.c',
+        'tests/test_strutil.c',
-            'src/util/strbuf.c',
+        'src/str_util.c'
    ]],
-        ['test_str', [
+]
            'tests/test_str.c',
            '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
+foreach t : tests
-        sources = t[1] + ['src/compat.c']
+    exe = executable(t[0], t[1],
        exe = executable(t[0], sources,
                     include_directories: src_dir,
-                         dependencies: dependencies,
+                     dependencies: dependencies)
                         c_args: ['-DSDL_MAIN_HANDLED', '-DSC_TEST'])
    test(t[0], exe)
-    endforeach
+endforeach
 endif
--- a/app/scrcpy-windows.manifest
+++ b/app/scrcpy-windows.manifest
@ -1,9 +0,0 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
  <asmv3:application>
    <asmv3:windowsSettings>
      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
    </asmv3:windowsSettings>
  </asmv3:application>
 </assembly>
--- a/app/scrcpy-windows.rc
+++ b/app/scrcpy-windows.rc
@ -1,23 +0,0 @@
 #include <winuser.h>
 0 ICON "data/icon.ico"
 1 RT_MANIFEST "scrcpy-windows.manifest"
 2 VERSIONINFO
 BEGIN
  BLOCK "StringFileInfo"
  BEGIN
    BLOCK "040904E4"
    BEGIN
      VALUE "FileDescription", "Display and control your Android device"
      VALUE "InternalName", "scrcpy"
      VALUE "LegalCopyright", "Romain Vimont, Genymobile"
      VALUE "OriginalFilename", "scrcpy.exe"
      VALUE "ProductName", "scrcpy"
      VALUE "ProductVersion", "3.1"
    END
  END
  BLOCK "VarFileInfo"
  BEGIN
    VALUE "Translation", 0x409, 1252
  END
 END
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -1,837 +0,0 @@
 .TH "scrcpy" "1"
 .SH NAME
 scrcpy \- Display and control your Android device
 .SH SYNOPSIS
 .B scrcpy
 .RI [ options ]
 .SH DESCRIPTION
 .B scrcpy
 provides display and control of Android devices connected on USB (or over TCP/IP). It does not require any root access.
 .SH OPTIONS
 .TP
 .B \-\-always\-on\-top
 Make scrcpy window always on top (above other windows).
 .TP
 .BI "\-\-angle " degrees
 Rotate the video content by a custom angle, in degrees (clockwise).
 .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.
 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.
 .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).
 .TP
 .B \-d, \-\-select\-usb
 Use USB device (if there is exactly one, like adb -d).
 Also see \fB\-e\fR (\fB\-\-select\-tcpip\fR).
 .TP
 .BI "\-\-disable\-screensaver"
 Disable screensaver while scrcpy is running.
 .TP
 .BI "\-\-display\-id " id
 Specify the device display id to mirror.
 The available display ids can be listed by \fB\-\-list\-displays\fR.
 Default is 0.
 .TP
 .BI "\-\-display\-orientation " value
 Set the initial display orientation.
 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.
 .TP
 .B \-e, \-\-select\-tcpip
 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.
 .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.
 .TP
 .BI "\-\-gamepad " mode
 Select how to send gamepad inputs to the device.
 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.
 .TP
 .BI "\-\-keyboard " mode
 Select how to send keyboard inputs to the device.
 Possible values are "disabled", "sdk", "uhid" and "aoa":
 - "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:
    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).
 Also see \fB\-\-mouse\fR and \fB\-\-gamepad\fR.
 .TP
 .B \-\-kill\-adb\-on\-close
 Kill adb when scrcpy terminates.
 .TP
 .B \-\-legacy\-paste
 Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+Shift+v).
 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.
 .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.
 .TP
 .BI "\-m, \-\-max\-size " value
 Limit both the width and height of the video to \fIvalue\fR. The other dimension is computed so that the device aspect\-ratio is preserved.
 Default is 0 (unlimited).
 .TP
 .B \-M
 Same as \fB\-\-mouse=uhid\fR, or \fB\-\-mouse=aoa\fR if \fB\-\-otg\fR is set.
 .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).
 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.
 .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.
 .TP
 .B \-\-no\-cleanup
 By default, scrcpy removes the server binary from the device and restores the device state (show touches, stay awake and power mode) on exit.
 This option disables this cleanup.
 .TP
 .B \-\-no\-clipboard\-autosync
 By default, scrcpy automatically synchronizes the computer clipboard to the device clipboard before injecting Ctrl+v, and the device clipboard to the computer clipboard whenever it changes.
 This option disables this automatic synchronization.
 .TP
 .B \-\-no\-downsize\-on\-error
 By default, on MediaCodec error, scrcpy automatically tries again with a lower definition.
 This option disables this behavior.
 .TP
 .B \-\-no\-key\-repeat
 Do not forward repeated key events when a key is held down.
 .TP
 .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.
 In this mode, adb (USB debugging) is not necessary, and mirroring is disabled.
 LAlt, LSuper or RSuper toggle the mouse capture mode, to give control of the mouse back to the computer.
 If any of \fB\-\-hid\-keyboard\fR or \fB\-\-hid\-mouse\fR is set, only enable keyboard or mouse respectively, otherwise enable both.
 It may only work over USB.
 See \fB\-\-keyboard\fR, \fB\-\-mouse\fR and \fB\-\-gamepad\fR.
 .TP
 .BI "\-p, \-\-port " port\fR[:\fIport\fR]
 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.
 .TP
 .B \-\-prefer\-text
 Inject alpha characters and space as text events instead of key events.
 This avoids issues when combining multiple keys to enter special characters,
 but breaks the expected behavior of alpha keys in games (typically WASD).
 .TP
 .B "\-\-print\-fps
 Start FPS counter, to print framerate logs to the console. It can be started or stopped at any time with MOD+i.
 .TP
 .BI "\-\-push\-target " path
 Set the target directory for pushing files to the device by drag & drop. It is passed as\-is to "adb push".
 Default is "/sdcard/Download/".
 .TP
 .BI "\-r, \-\-record " file
 Record screen to
 .IR file .
 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.
 .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.
 .TP
 .BI "\-\-render\-driver " name
 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>
 .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.
 .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[+...]][,...]
 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 ','.
 For example, to use either LCtrl or LSuper for scrcpy shortcuts, pass "lctrl,lsuper".
 Default is "lalt,lsuper" (left-Alt or left-Super).
 .TP
 .BI "\-\-start\-app " name
 Start an Android app, by its exact package name.
 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):
    scrcpy --start-app=?firefox
 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 \-t, \-\-show\-touches
 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.
 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.
 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.
 .TP
 .BI "\-V, \-\-verbosity " value
 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.
 .TP
 .B \-w, \-\-stay-awake
 Keep the device on while scrcpy is running, when the device is plugged in.
 .TP
 .B \-\-window\-borderless
 Disable window decorations (display borderless window).
 .TP
 .BI "\-\-window\-title " text
 Set a custom window title.
 .TP
 .BI "\-\-window\-x " value
 Set the initial window horizontal position.
 Default is "auto".
 .TP
 .BI "\-\-window\-y " value
 Set the initial window vertical position.
 Default is "auto".
 .TP
 .BI "\-\-window\-width " value
 Set the initial window width.
 Default is 0 (automatic).
 .TP
 .BI "\-\-window\-height " value
 Set the initial window height.
 Default is 0 (automatic).
 .SH EXIT STATUS
 .B scrcpy
 will exit with code 0 on normal program termination. If an initial
 connection cannot be established, the exit code 1 will be returned. If the
 device disconnects while a session is active, exit code 2 will be returned.
 .SH SHORTCUTS
 In the following list, MOD is the shortcut modifier. By default, it's (left)
 Alt or (left) Super, but it can be configured by \fB\-\-shortcut\-mod\fR (see above).
 .TP
 .B MOD+f
 Switch fullscreen mode
 .TP
 .B MOD+Left
 Rotate display left
 .TP
 .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)
 .TP
 .B MOD+w, Double\-click on black borders
 Resize window to remove black borders
 .TP
 .B MOD+h, Home, Middle\-click
 Click on HOME
 .TP
 .B MOD+b, MOD+Backspace, Right\-click (when screen is on)
 Click on BACK
 .TP
 .B MOD+s
 Click on APP_SWITCH
 .TP
 .B MOD+m
 Click on MENU
 .TP
 .B MOD+Up
 Click on VOLUME_UP
 .TP
 .B MOD+Down
 Click on VOLUME_DOWN
 .TP
 .B MOD+p
 Click on POWER (turn screen on/off)
 .TP
 .B Right\-click (when screen is off)
 Turn screen on
 .TP
 .B MOD+o
 Turn device screen off (keep mirroring)
 .TP
 .B MOD+Shift+o
 Turn device screen on
 .TP
 .B MOD+r
 Rotate device screen
 .TP
 .B MOD+n
 Expand notification panel
 .TP
 .B MOD+Shift+n
 Collapse notification panel
 .TP
 .B Mod+c
 Copy to clipboard (inject COPY keycode, Android >= 7 only)
 .TP
 .B Mod+x
 Cut to clipboard (inject CUT keycode, Android >= 7 only)
 .TP
 .B MOD+v
 Copy computer clipboard to device, then paste (inject PASTE keycode, Android >= 7 only)
 .TP
 .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)
 .TP
 .B Drag & drop APK file
 Install APK from computer
 .TP
 .B Drag & drop non-APK file
 Push file to device (see \fB\-\-push\-target\fR)
 .SH Environment variables
 .TP
 .B ADB
 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.
 .TP
 .B SCRCPY_ICON_PATH
 Path to the program icon.
 .TP
 .B SCRCPY_SERVER_PATH
 Path to the server binary.
 .SH AUTHORS
 .B scrcpy
 is written by Romain Vimont.
 This manual page was written by
 .MT mmyangfl@gmail.com
 Yangfl
 .ME
 for the Debian Project (and may be used by others).
 .SH "REPORTING BUGS"
 Report bugs to <https://github.com/Genymobile/scrcpy/issues>.
 .SH COPYRIGHT
 Copyright \(co 2018 Genymobile <https://www.genymobile.com>
 Copyright \(co 2018\-2025 Romain Vimont <rom@rom1v.com>
 Licensed under the Apache License, Version 2.0.
 .SH WWW
 <https://github.com/Genymobile/scrcpy>
--- a/app/src/adb/adb.c
+++ b/app/src/adb/adb.c
@ -1,791 +0,0 @@
 #include "adb.h"
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #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"
 #include "util/str.h"
 /* Convenience macro to expand:
 *
 *     const char *const argv[] =
 *         SC_ADB_COMMAND("shell", "echo", "hello");
 *
 * to:
 *
 *     const char *const argv[] =
 *         { sc_adb_get_executable(), "shell", "echo", "hello", NULL };
 */
 #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);
 }
 const char *
 sc_adb_get_executable(void) {
    return adb_executable;
 }
 // serialize argv to string "[arg1], [arg2], [arg3]"
 static size_t
 argv_to_string(const char *const *argv, char *buf, size_t bufsize) {
    size_t idx = 0;
    bool first = true;
    while (*argv) {
        const char *arg = *argv;
        size_t len = strlen(arg);
        // count space for "[], ...\0"
        if (idx + len + 8 >= bufsize) {
            // not enough space, truncate
            assert(idx < bufsize - 4);
            memcpy(&buf[idx], "...", 3);
            idx += 3;
            break;
        }
        if (first) {
            first = false;
        } else {
            buf[idx++] = ',';
            buf[idx++] = ' ';
        }
        buf[idx++] = '[';
        memcpy(&buf[idx], arg, len);
        idx += len;
        buf[idx++] = ']';
        argv++;
    }
    assert(idx < bufsize);
    buf[idx] = '\0';
    return idx;
 }
 static void
 show_adb_installation_msg(void) {
 #ifndef __WINDOWS__
    static const struct {
        const char *binary;
        const char *command;
    } pkg_managers[] = {
        {"apt", "apt install adb"},
        {"apt-get", "apt-get install adb"},
        {"brew", "brew cask install android-platform-tools"},
        {"dnf", "dnf install android-tools"},
        {"emerge", "emerge dev-util/android-tools"},
        {"pacman", "pacman -S android-tools"},
    };
    for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
        if (sc_file_executable_exists(pkg_managers[i].binary)) {
            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
            return;
        }
    }
 #endif
 }
 static void
 show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
 #define MAX_COMMAND_STRING_LEN 1024
    char *buf = malloc(MAX_COMMAND_STRING_LEN);
    if (!buf) {
        LOG_OOM();
        LOGE("Failed to execute");
        return;
    }
    switch (err) {
        case SC_PROCESS_ERROR_GENERIC:
            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
            LOGE("Failed to execute: %s", buf);
            break;
        case SC_PROCESS_ERROR_MISSING_BINARY:
            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
            LOGE("Command not found: %s", buf);
            LOGE("(make 'adb' accessible from your PATH or define its full"
                 "path in the ADB environment variable)");
            show_adb_installation_msg();
            break;
        case SC_PROCESS_SUCCESS:
            // do nothing
            break;
    }
    free(buf);
 }
 static bool
 process_check_success_internal(sc_pid pid, const char *name, bool close,
                               unsigned flags) {
    bool log_errors = !(flags & SC_ADB_NO_LOGERR);
    if (pid == SC_PROCESS_NONE) {
        if (log_errors) {
            LOGE("Could not execute \"%s\"", name);
        }
        return false;
    }
    sc_exit_code exit_code = sc_process_wait(pid, close);
    if (exit_code) {
        if (log_errors) {
            if (exit_code != SC_EXIT_CODE_NONE) {
                LOGE("\"%s\" returned with value %" SC_PRIexitcode, name,
                     exit_code);
            } else {
                LOGE("\"%s\" exited unexpectedly", name);
            }
        }
        return false;
    }
    return true;
 }
 static bool
 process_check_success_intr(struct sc_intr *intr, sc_pid pid, const char *name,
                           unsigned flags) {
    if (intr && !sc_intr_set_process(intr, pid)) {
        // Already interrupted
        return false;
    }
    // Always pass close=false, interrupting would be racy otherwise
    bool ret = process_check_success_internal(pid, name, false, flags);
    if (intr) {
        sc_intr_set_process(intr, SC_PROCESS_NONE);
    }
    // Close separately
    sc_process_close(pid);
    return ret;
 }
 static sc_pid
 sc_adb_execute_p(const char *const argv[], unsigned flags, sc_pipe *pout) {
    unsigned process_flags = 0;
    if (flags & SC_ADB_NO_STDOUT) {
        process_flags |= SC_PROCESS_NO_STDOUT;
    }
    if (flags & SC_ADB_NO_STDERR) {
        process_flags |= SC_PROCESS_NO_STDERR;
    }
    sc_pid pid;
    enum sc_process_result r =
        sc_process_execute_p(argv, &pid, process_flags, NULL, pout, NULL);
    if (r != SC_PROCESS_SUCCESS) {
        // If the execution itself failed (not the command exit code), log the
        // error in all cases
        show_adb_err_msg(r, argv);
        pid = SC_PROCESS_NONE;
    }
    return pid;
 }
 sc_pid
 sc_adb_execute(const char *const argv[], unsigned flags) {
    return sc_adb_execute_p(argv, flags, NULL);
 }
 bool
 sc_adb_start_server(struct sc_intr *intr, unsigned flags) {
    const char *const argv[] = SC_ADB_COMMAND("start-server");
    sc_pid pid = sc_adb_execute(argv, flags);
    return process_check_success_intr(intr, pid, "adb start-server", flags);
 }
 bool
 sc_adb_kill_server(struct sc_intr *intr, unsigned flags) {
    const char *const argv[] = SC_ADB_COMMAND("kill-server");
    sc_pid pid = sc_adb_execute(argv, flags);
    return process_check_success_intr(intr, pid, "adb kill-server", flags);
 }
 bool
 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;
    }
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "forward", local, remote);
    sc_pid pid = sc_adb_execute(argv, flags);
    return process_check_success_intr(intr, pid, "adb forward", flags);
 }
 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;
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "forward", "--remove", local);
    sc_pid pid = sc_adb_execute(argv, flags);
    return process_check_success_intr(intr, pid, "adb forward --remove", flags);
 }
 bool
 sc_adb_reverse(struct sc_intr *intr, const char *serial,
               const char *device_socket_name, uint16_t local_port,
               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;
    }
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "reverse", remote, local);
    sc_pid pid = sc_adb_execute(argv, flags);
    return process_check_success_intr(intr, pid, "adb reverse", flags);
 }
 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;
    }
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "reverse", "--remove", remote);
    sc_pid pid = sc_adb_execute(argv, flags);
    return process_check_success_intr(intr, pid, "adb reverse --remove", flags);
 }
 bool
 sc_adb_push(struct sc_intr *intr, const char *serial, const char *local,
            const char *remote, unsigned flags) {
 #ifdef __WINDOWS__
    // Windows will parse the string, so the paths must be quoted
    // (see sys/win/command.c)
    local = sc_str_quote(local);
    if (!local) {
        return SC_PROCESS_NONE;
    }
    remote = sc_str_quote(remote);
    if (!remote) {
        free((void *) local);
        return SC_PROCESS_NONE;
    }
 #endif
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "push", local, remote);
    sc_pid pid = sc_adb_execute(argv, flags);
 #ifdef __WINDOWS__
    free((void *) remote);
    free((void *) local);
 #endif
    return process_check_success_intr(intr, pid, "adb push", flags);
 }
 bool
 sc_adb_install(struct sc_intr *intr, const char *serial, const char *local,
               unsigned flags) {
 #ifdef __WINDOWS__
    // Windows will parse the string, so the local name must be quoted
    // (see sys/win/command.c)
    local = sc_str_quote(local);
    if (!local) {
        return SC_PROCESS_NONE;
    }
 #endif
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "install", "-r", local);
    sc_pid pid = sc_adb_execute(argv, flags);
 #ifdef __WINDOWS__
    free((void *) local);
 #endif
    return process_check_success_intr(intr, pid, "adb install", flags);
 }
 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;
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "tcpip", port_string);
    sc_pid pid = sc_adb_execute(argv, flags);
    return process_check_success_intr(intr, pid, "adb tcpip", flags);
 }
 bool
 sc_adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
    const char *const argv[] = SC_ADB_COMMAND("connect", ip_port);
    sc_pipe pout;
    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
    if (pid == SC_PROCESS_NONE) {
        LOGE("Could not execute \"adb connect\"");
        return false;
    }
    // "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".
    char buf[128];
    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf) - 1);
    sc_pipe_close(pout);
    bool ok = process_check_success_intr(intr, pid, "adb connect", flags);
    if (!ok) {
        return false;
    }
    if (r == -1) {
        return false;
    }
    assert((size_t) r < sizeof(buf));
    buf[r] = '\0';
    ok = !strncmp("connected", buf, sizeof("connected") - 1)
        || !strncmp("already connected", buf, sizeof("already 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.
        size_t len = strcspn(buf, "\r\n");
        buf[len] = '\0';
        fprintf(stderr, "%s\n", buf);
    }
    return ok;
 }
 bool
 sc_adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
    assert(ip_port);
    const char *const argv[] = SC_ADB_COMMAND("disconnect", ip_port);
    sc_pid pid = sc_adb_execute(argv, flags);
    return process_check_success_intr(intr, pid, "adb disconnect", flags);
 }
 static bool
 sc_adb_list_devices(struct sc_intr *intr, unsigned flags,
                    struct sc_vec_adb_devices *out_vec) {
    const char *const argv[] = SC_ADB_COMMAND("devices", "-l");
 #define BUFSIZE 65536
    char *buf = malloc(BUFSIZE);
    if (!buf) {
        LOG_OOM();
        return false;
    }
    sc_pipe pout;
    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
    if (pid == SC_PROCESS_NONE) {
        LOGE("Could not execute \"adb devices -l\"");
        free(buf);
        return false;
    }
    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, BUFSIZE - 1);
    sc_pipe_close(pout);
    bool ok = process_check_success_intr(intr, pid, "adb devices -l", flags);
    if (!ok) {
        free(buf);
        return false;
    }
    if (r == -1) {
        free(buf);
        return false;
    }
    assert((size_t) r < BUFSIZE);
    if (r == BUFSIZE - 1)  {
        // The implementation assumes that the output of "adb devices -l" fits
        // 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;
    }
    // It is parsed as a NUL-terminated string
    buf[r] = '\0';
    // List all devices to the output list directly
    ok = sc_adb_parse_devices(buf, out_vec);
    free(buf);
    return ok;
 }
 static bool
 sc_adb_accept_device(const struct sc_adb_device *device,
                     const struct sc_adb_device_selector *selector) {
    switch (selector->type) {
        case SC_ADB_DEVICE_SELECT_ALL:
            return true;
        case SC_ADB_DEVICE_SELECT_SERIAL:
            assert(selector->serial);
            char *device_serial_colon = strchr(device->serial, ':');
            if (device_serial_colon) {
                // The device serial is an IP:port...
                char *serial_colon = strchr(selector->serial, ':');
                if (!serial_colon) {
                    // But the requested serial has no ':', so only consider
                    // the IP part of the device serial. This allows to use
                    // "192.168.1.1" to match any "192.168.1.1:port".
                    size_t serial_len = strlen(selector->serial);
                    size_t device_ip_len = device_serial_colon - device->serial;
                    if (serial_len != device_ip_len) {
                        // They are not equal, they don't even have the same
                        // length
                        return false;
                    }
                    return !strncmp(selector->serial, device->serial,
                                    device_ip_len);
                }
            }
            return !strcmp(selector->serial, device->serial);
        case SC_ADB_DEVICE_SELECT_USB:
            return sc_adb_device_get_type(device->serial) ==
                    SC_ADB_DEVICE_TYPE_USB;
        case SC_ADB_DEVICE_SELECT_TCPIP:
            // Both emulators and TCP/IP devices are selected via -e
            return sc_adb_device_get_type(device->serial) !=
                    SC_ADB_DEVICE_TYPE_USB;
        default:
            assert(!"Missing SC_ADB_DEVICE_SELECT_* handling");
            break;
    }
    return false;
 }
 static size_t
 sc_adb_devices_select(struct sc_adb_device *devices, size_t len,
                      const struct sc_adb_device_selector *selector,
                      size_t *idx_out) {
    size_t count = 0;
    for (size_t i = 0; i < len; ++i) {
        struct sc_adb_device *device = &devices[i];
        device->selected = sc_adb_accept_device(device, selector);
        if (device->selected) {
            if (idx_out && !count) {
                *idx_out = i;
            }
            ++count;
        }
    }
    return count;
 }
 static void
 sc_adb_devices_log(enum sc_log_level level, struct sc_adb_device *devices,
                   size_t count) {
    for (size_t i = 0; i < count; ++i) {
        struct sc_adb_device *d = &devices[i];
        const char *selection = d->selected ? "-->" : "   ";
        bool is_usb =
            sc_adb_device_get_type(d->serial) == SC_ADB_DEVICE_TYPE_USB;
        const char *type = is_usb ? "  (usb)"
                                  : "(tcpip)";
        LOG(level, "    %s %s  %-20s  %16s  %s",
             selection, type, d->serial, d->state, d->model ? d->model : "");
    }
 }
 static bool
 sc_adb_device_check_state(struct sc_adb_device *device,
                          struct sc_adb_device *devices, size_t count) {
    const char *state = device->state;
    if (!strcmp("device", state)) {
        return true;
    }
    if (!strcmp("unauthorized", state)) {
        LOGE("Device is unauthorized:");
        sc_adb_devices_log(SC_LOG_LEVEL_ERROR, devices, count);
        LOGE("A popup should open on the device to request authorization.");
        LOGE("Check the FAQ: "
             "<https://github.com/Genymobile/scrcpy/blob/master/FAQ.md>");
    } else {
        LOGE("Device could not be connected (state=%s)", state);
    }
    return false;
 }
 bool
 sc_adb_select_device(struct sc_intr *intr,
                     const struct sc_adb_device_selector *selector,
                     unsigned flags, struct sc_adb_device *out_device) {
    struct sc_vec_adb_devices vec = SC_VECTOR_INITIALIZER;
    bool ok = sc_adb_list_devices(intr, flags, &vec);
    if (!ok) {
        LOGE("Could not list ADB devices");
        return false;
    }
    if (vec.size == 0) {
        LOGE("Could not find any ADB device");
        return false;
    }
    size_t sel_idx; // index of the single matching device if sel_count == 1
    size_t sel_count =
        sc_adb_devices_select(vec.data, vec.size, selector, &sel_idx);
    if (sel_count == 0) {
        // if count > 0 && sel_count == 0, then necessarily a selection is
        // requested
        assert(selector->type != SC_ADB_DEVICE_SELECT_ALL);
        switch (selector->type) {
            case SC_ADB_DEVICE_SELECT_SERIAL:
                assert(selector->serial);
                LOGE("Could not find ADB device %s:", selector->serial);
                break;
            case SC_ADB_DEVICE_SELECT_USB:
                LOGE("Could not find any ADB device over USB:");
                break;
            case SC_ADB_DEVICE_SELECT_TCPIP:
                LOGE("Could not find any ADB device over TCP/IP:");
                break;
            default:
                assert(!"Unexpected selector type");
                break;
        }
        sc_adb_devices_log(SC_LOG_LEVEL_ERROR, vec.data, vec.size);
        sc_adb_devices_destroy(&vec);
        return false;
    }
    if (sel_count > 1) {
        switch (selector->type) {
            case SC_ADB_DEVICE_SELECT_ALL:
                LOGE("Multiple (%" SC_PRIsizet ") ADB devices:", sel_count);
                break;
            case SC_ADB_DEVICE_SELECT_SERIAL:
                assert(selector->serial);
                LOGE("Multiple (%" SC_PRIsizet ") ADB devices with serial %s:",
                     sel_count, selector->serial);
                break;
            case SC_ADB_DEVICE_SELECT_USB:
                LOGE("Multiple (%" SC_PRIsizet ") ADB devices over USB:",
                     sel_count);
                break;
            case SC_ADB_DEVICE_SELECT_TCPIP:
                LOGE("Multiple (%" SC_PRIsizet ") ADB devices over TCP/IP:",
                     sel_count);
                break;
            default:
                assert(!"Unexpected selector type");
                break;
        }
        sc_adb_devices_log(SC_LOG_LEVEL_ERROR, vec.data, vec.size);
        LOGE("Select a device via -s (--serial), -d (--select-usb) or -e "
             "(--select-tcpip)");
        sc_adb_devices_destroy(&vec);
        return false;
    }
    assert(sel_count == 1); // sel_idx is valid only if sel_count == 1
    struct sc_adb_device *device = &vec.data[sel_idx];
    ok = sc_adb_device_check_state(device, vec.data, vec.size);
    if (!ok) {
        sc_adb_devices_destroy(&vec);
        return false;
    }
    LOGI("ADB device found:");
    sc_adb_devices_log(SC_LOG_LEVEL_INFO, vec.data, vec.size);
    // Move devics into out_device (do not destroy device)
    sc_adb_device_move(out_device, device);
    sc_adb_devices_destroy(&vec);
    return true;
 }
 char *
 sc_adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
               unsigned flags) {
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "shell", "getprop", prop);
    sc_pipe pout;
    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
    if (pid == SC_PROCESS_NONE) {
        LOGE("Could not execute \"adb getprop\"");
        return NULL;
    }
    char buf[128];
    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf) - 1);
    sc_pipe_close(pout);
    bool ok = process_check_success_intr(intr, pid, "adb getprop", flags);
    if (!ok) {
        return NULL;
    }
    if (r == -1) {
        return NULL;
    }
    assert((size_t) r < sizeof(buf));
    buf[r] = '\0';
    size_t len = strcspn(buf, " \r\n");
    buf[len] = '\0';
    return strdup(buf);
 }
 char *
 sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
    assert(serial);
    const char *const argv[] =
        SC_ADB_COMMAND("-s", serial, "shell", "ip", "route");
    sc_pipe pout;
    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
    if (pid == SC_PROCESS_NONE) {
        LOGD("Could not execute \"ip route\"");
        return NULL;
    }
    // "adb shell ip route" output should contain only a few lines
    char buf[1024];
    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf) - 1);
    sc_pipe_close(pout);
    bool ok = process_check_success_intr(intr, pid, "ip route", flags);
    if (!ok) {
        return NULL;
    }
    if (r == -1) {
        return NULL;
    }
    assert((size_t) r < sizeof(buf));
    if (r == sizeof(buf) - 1)  {
        // The implementation assumes that the output of "ip route" fits in the
        // buffer in a single pass
        LOGW("Result of \"ip route\" does not fit in 1Kb. "
             "Please report an issue.");
        return NULL;
    }
    // It is parsed as a NUL-terminated string
    buf[r] = '\0';
    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;
 }
--- a/app/src/adb/adb.h
+++ b/app/src/adb/adb.h
@ -1,129 +0,0 @@
 #ifndef SC_ADB_H
 #define SC_ADB_H
 #include "common.h"
 #include <stdbool.h>
 #include <inttypes.h>
 #include "adb_device.h"
 #include "util/intr.h"
 #define SC_ADB_NO_STDOUT (1 << 0)
 #define SC_ADB_NO_STDERR (1 << 1)
 #define SC_ADB_NO_LOGERR (1 << 2)
 #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);
 enum sc_adb_device_selector_type {
    SC_ADB_DEVICE_SELECT_ALL,
    SC_ADB_DEVICE_SELECT_SERIAL,
    SC_ADB_DEVICE_SELECT_USB,
    SC_ADB_DEVICE_SELECT_TCPIP,
 };
 struct sc_adb_device_selector {
    enum sc_adb_device_selector_type type;
    const char *serial;
 };
 sc_pid
 sc_adb_execute(const char *const argv[], unsigned flags);
 bool
 sc_adb_start_server(struct sc_intr *intr, unsigned flags);
 bool
 sc_adb_kill_server(struct sc_intr *intr, unsigned flags);
 bool
 sc_adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
               const char *device_socket_name, unsigned flags);
 bool
 sc_adb_forward_remove(struct sc_intr *intr, const char *serial,
                      uint16_t local_port, unsigned flags);
 bool
 sc_adb_reverse(struct sc_intr *intr, const char *serial,
               const char *device_socket_name, uint16_t local_port,
               unsigned flags);
 bool
 sc_adb_reverse_remove(struct sc_intr *intr, const char *serial,
                      const char *device_socket_name, unsigned flags);
 bool
 sc_adb_push(struct sc_intr *intr, const char *serial, const char *local,
            const char *remote, unsigned flags);
 bool
 sc_adb_install(struct sc_intr *intr, const char *serial, const char *local,
               unsigned flags);
 /**
 * Execute `adb tcpip <port>`
 */
 bool
 sc_adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
             unsigned flags);
 /**
 * Execute `adb connect <ip_port>`
 *
 * `ip_port` may not be NULL.
 */
 bool
 sc_adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags);
 /**
 * Execute `adb disconnect [<ip_port>]`
 *
 * If `ip_port` is NULL, execute `adb disconnect`.
 * Otherwise, execute `adb disconnect <ip_port>`.
 */
 bool
 sc_adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags);
 /**
 * Execute `adb devices` and parse the result to select a device
 *
 * Return true if a single matching device is found, and write it to out_device.
 */
 bool
 sc_adb_select_device(struct sc_intr *intr,
                     const struct sc_adb_device_selector *selector,
                     unsigned flags, struct sc_adb_device *out_device);
 /**
 * Execute `adb getprop <prop>`
 */
 char *
 sc_adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
               unsigned flags);
 /**
 * Attempt to retrieve the device IP
 *
 * Return the IP as a string of the form "xxx.xxx.xxx.xxx", to be freed by the
 * caller, or NULL on error.
 */
 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
--- a/app/src/adb/adb_device.c
+++ b/app/src/adb/adb_device.c
@ -1,43 +0,0 @@
 #include "adb_device.h"
 #include <stdlib.h>
 #include <string.h>
 void
 sc_adb_device_destroy(struct sc_adb_device *device) {
    free(device->serial);
    free(device->state);
    free(device->model);
 }
 void
 sc_adb_device_move(struct sc_adb_device *dst, struct sc_adb_device *src) {
    *dst = *src;
    src->serial = NULL;
    src->state = NULL;
    src->model = NULL;
 }
 void
 sc_adb_devices_destroy(struct sc_vec_adb_devices *devices) {
    for (size_t i = 0; i < devices->size; ++i) {
        sc_adb_device_destroy(&devices->data[i]);
    }
    sc_vector_destroy(devices);
 }
 enum sc_adb_device_type
 sc_adb_device_get_type(const char *serial) {
    // Starts with "emulator-"
    if (!strncmp(serial, "emulator-", sizeof("emulator-") - 1)) {
        return SC_ADB_DEVICE_TYPE_EMULATOR;
    }
    // If the serial contains a ':', then it is a TCP/IP device (it is
    // sufficient to distinguish an ip:port from a real USB serial)
    if (strchr(serial, ':')) {
        return SC_ADB_DEVICE_TYPE_TCPIP;
    }
    return SC_ADB_DEVICE_TYPE_USB;
 }
--- a/app/src/adb/adb_device.h
+++ b/app/src/adb/adb_device.h
@ -1,50 +0,0 @@
 #ifndef SC_ADB_DEVICE_H
 #define SC_ADB_DEVICE_H
 #include "common.h"
 #include <stdbool.h>
 #include <stddef.h>
 #include "util/vector.h"
 struct sc_adb_device {
    char *serial;
    char *state;
    char *model;
    bool selected;
 };
 enum sc_adb_device_type {
    SC_ADB_DEVICE_TYPE_USB,
    SC_ADB_DEVICE_TYPE_TCPIP,
    SC_ADB_DEVICE_TYPE_EMULATOR,
 };
 struct sc_vec_adb_devices SC_VECTOR(struct sc_adb_device);
 void
 sc_adb_device_destroy(struct sc_adb_device *device);
 /**
 * Move src to dst
 *
 * After this call, the content of src is undefined, except that
 * sc_adb_device_destroy() can be called.
 *
 * This is useful to take a device from a list that will be destroyed, without
 * making unnecessary copies.
 */
 void
 sc_adb_device_move(struct sc_adb_device *dst, struct sc_adb_device *src);
 void
 sc_adb_devices_destroy(struct sc_vec_adb_devices *devices);
 /**
 * Deduce the device type from the serial
 */
 enum sc_adb_device_type
 sc_adb_device_get_type(const char *serial);
 #endif
--- a/app/src/adb/adb_parser.c
+++ b/app/src/adb/adb_parser.c
@ -1,228 +0,0 @@
 #include "adb_parser.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include "util/log.h"
 #include "util/str.h"
 static 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 "
    //     "device:MyDevice transport_id:1"
    if (line[0] == '*') {
        // Garbage lines printed by adb daemon while starting start with a '*'
        return false;
    }
    if (!strncmp("adb server", line, sizeof("adb server") - 1)) {
        // Ignore lines starting with "adb server":
        //   adb server version (41) doesn't match this client (39); killing...
        return false;
    }
    char *s = line; // cursor in the line
    // After the serial:
    //  - "adb devices" writes a single '\t'
    //  - "adb devices -l" writes multiple spaces
    // For flexibility, accept both.
    size_t serial_len = strcspn(s, " \t");
    if (!serial_len) {
        // empty serial
        return false;
    }
    bool eol = s[serial_len] == '\0';
    if (eol) {
        // serial alone is unexpected
        return false;
    }
    s[serial_len] = '\0';
    char *serial = s;
    s += serial_len + 1;
    // After the serial, there might be several spaces
    s += strspn(s, " \t"); // consume all separators
    size_t state_len = strcspn(s, " ");
    if (!state_len) {
        // empty state
        return false;
    }
    eol = s[state_len] == '\0';
    s[state_len] = '\0';
    char *state = s;
    char *model = NULL;
    if (!eol) {
        s += state_len + 1;
        // Iterate over all properties "key:value key:value ..."
        for (;;) {
            size_t token_len = strcspn(s, " ");
            if (!token_len) {
                break;
            }
            eol = s[token_len] == '\0';
            s[token_len] = '\0';
            char *token = s;
            if (!strncmp("model:", token, sizeof("model:") - 1)) {
                model = &token[sizeof("model:") - 1];
                // We only need the model
                break;
            }
            if (eol) {
                break;
            } else {
                s+= token_len + 1;
            }
        }
    }
    device->serial = strdup(serial);
    if (!device->serial) {
        return false;
    }
    device->state = strdup(state);
    if (!device->state) {
        free(device->serial);
        return false;
    }
    if (model) {
        device->model = strdup(model);
        if (!device->model) {
            LOG_OOM();
            // model is optional, do not fail
        }
    } else {
        device->model = NULL;
    }
    device->selected = false;
    return true;
 }
 bool
 sc_adb_parse_devices(char *str, struct sc_vec_adb_devices *out_vec) {
 #define HEADER "List of devices attached"
 #define HEADER_LEN (sizeof(HEADER) - 1)
    bool header_found = false;
    size_t idx_line = 0;
    while (str[idx_line] != '\0') {
        char *line = &str[idx_line];
        size_t len = strcspn(line, "\n");
        // The next line starts after the '\n' (replaced by `\0`)
        idx_line += len;
        if (str[idx_line] != '\0') {
            // The next line starts after the '\n'
            ++idx_line;
        }
        if (!header_found) {
            if (!strncmp(line, HEADER, HEADER_LEN)) {
                header_found = true;
            }
            // Skip everything until the header, there might be garbage lines
            // related to daemon starting before
            continue;
        }
        // The line, but without any trailing '\r'
        size_t line_len = sc_str_remove_trailing_cr(line, len);
        line[line_len] = '\0';
        struct sc_adb_device device;
        bool ok = sc_adb_parse_device(line, &device);
        if (!ok) {
            continue;
        }
        ok = sc_vector_push(out_vec, device);
        if (!ok) {
            LOG_OOM();
            LOGE("Could not push adb_device to vector");
            sc_adb_device_destroy(&device);
            // continue anyway
            continue;
        }
    }
    assert(header_found || out_vec->size == 0);
    return header_found;
 }
 static char *
 sc_adb_parse_device_ip_from_line(char *line) {
    // One line from "ip route" looks like:
    // "192.168.1.0/24 dev wlan0  proto kernel  scope link  src 192.168.1.x"
    // Get the location of the device name (index of "wlan0" in the example)
    ssize_t idx_dev_name = sc_str_index_of_column(line, 2, " ");
    if (idx_dev_name == -1) {
        return NULL;
    }
    // Get the location of the ip address (column 8, but column 6 if we start
    // from column 2). Must be computed before truncating individual columns.
    ssize_t idx_ip = sc_str_index_of_column(&line[idx_dev_name], 6, " ");
    if (idx_ip == -1) {
        return NULL;
    }
    // idx_ip is searched from &line[idx_dev_name]
    idx_ip += idx_dev_name;
    char *dev_name = &line[idx_dev_name];
    size_t dev_name_len = strcspn(dev_name, " \t");
    dev_name[dev_name_len] = '\0';
    char *ip = &line[idx_ip];
    size_t ip_len = strcspn(ip, " \t");
    ip[ip_len] = '\0';
    // Only consider lines where the device name starts with "wlan"
    if (strncmp(dev_name, "wlan", sizeof("wlan") - 1)) {
        LOGD("Device ip lookup: ignoring %s (%s)", ip, dev_name);
        return NULL;
    }
    return strdup(ip);
 }
 char *
 sc_adb_parse_device_ip(char *str) {
    size_t idx_line = 0;
    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);
        line[line_len] = '\0';
        char *ip = sc_adb_parse_device_ip_from_line(line);
        if (ip) {
            // Found
            return ip;
        }
        if (is_last_line) {
            break;
        }
        // The next line starts after the '\n'
        idx_line += len + 1;
    }
    return NULL;
 }
--- a/app/src/adb/adb_parser.h
+++ b/app/src/adb/adb_parser.h
@ -1,30 +0,0 @@
 #ifndef SC_ADB_PARSER_H
 #define SC_ADB_PARSER_H
 #include "common.h"
 #include <stddef.h>
 #include "adb_device.h"
 /**
 * Parse the available devices from the output of `adb devices`
 *
 * The parameter must be a NUL-terminated string.
 *
 * Warning: this function modifies the buffer for optimization purposes.
 */
 bool
 sc_adb_parse_devices(char *str, struct sc_vec_adb_devices *out_vec);
 /**
 * Parse the ip from the output of `adb shell ip route`
 *
 * The parameter must be a NUL-terminated string.
 *
 * Warning: this function modifies the buffer for optimization purposes.
 */
 char *
 sc_adb_parse_device_ip(char *str);
 #endif
--- a/app/src/adb/adb_tunnel.c
+++ b/app/src/adb/adb_tunnel.c
@ -1,172 +0,0 @@
 #include "adb_tunnel.h"
 #include <assert.h>
 #include "adb.h"
 #include "util/log.h"
 #include "util/net_intr.h"
 #include "util/process_intr.h"
 static bool
 listen_on_port(struct sc_intr *intr, sc_socket socket, uint16_t port) {
    return net_listen_intr(intr, socket, IPV4_LOCALHOST, port, 1);
 }
 static bool
 enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
                               struct sc_intr *intr, const char *serial,
                               const char *device_socket_name,
                               struct sc_port_range port_range) {
    uint16_t port = port_range.first;
    for (;;) {
        if (!sc_adb_reverse(intr, serial, device_socket_name, port,
                            SC_ADB_NO_STDOUT)) {
            // the command itself failed, it will fail on any port
            return false;
        }
        // At the application level, the device part is "the server" because it
        // serves video stream and control. However, at the network level, the
        // client listens and the server connects to the client. That way, the
        // client can listen before starting the server app, so there is no
        // need to try to connect until the server socket is listening on the
        // device.
        sc_socket server_socket = net_socket();
        if (server_socket != SC_SOCKET_NONE) {
            bool ok = listen_on_port(intr, server_socket, port);
            if (ok) {
                // success
                tunnel->server_socket = server_socket;
                tunnel->local_port = port;
                tunnel->enabled = true;
                return true;
            }
            net_close(server_socket);
        }
        if (sc_intr_is_interrupted(intr)) {
            // Stop immediately
            return false;
        }
        // failure, disable tunnel and try another port
        if (!sc_adb_reverse_remove(intr, serial, device_socket_name,
                                SC_ADB_NO_STDOUT)) {
            LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
        }
        // check before incrementing to avoid overflow on port 65535
        if (port < port_range.last) {
            LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
                 port, (uint16_t) (port + 1));
            port++;
            continue;
        }
        if (port_range.first == port_range.last) {
            LOGE("Could not listen on port %" PRIu16, port_range.first);
        } else {
            LOGE("Could not listen on any port in range %" PRIu16 ":%" PRIu16,
                 port_range.first, port_range.last);
        }
        return false;
    }
 }
 static bool
 enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
                               struct sc_intr *intr, const char *serial,
                               const char *device_socket_name,
                               struct sc_port_range port_range) {
    tunnel->forward = true;
    uint16_t port = port_range.first;
    for (;;) {
        if (sc_adb_forward(intr, serial, port, device_socket_name,
                           SC_ADB_NO_STDOUT)) {
            // success
            tunnel->local_port = port;
            tunnel->enabled = true;
            return true;
        }
        if (sc_intr_is_interrupted(intr)) {
            // Stop immediately
            return false;
        }
        if (port < port_range.last) {
            LOGW("Could not forward port %" PRIu16", retrying on %" PRIu16,
                 port, (uint16_t) (port + 1));
            port++;
            continue;
        }
        if (port_range.first == port_range.last) {
            LOGE("Could not forward port %" PRIu16, port_range.first);
        } else {
            LOGE("Could not forward any port in range %" PRIu16 ":%" PRIu16,
                 port_range.first, port_range.last);
        }
        return false;
    }
 }
 void
 sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel) {
    tunnel->enabled = false;
    tunnel->forward = false;
    tunnel->server_socket = SC_SOCKET_NONE;
    tunnel->local_port = 0;
 }
 bool
 sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
                   const char *serial, const char *device_socket_name,
                   struct sc_port_range port_range, bool force_adb_forward) {
    assert(!tunnel->enabled);
    if (!force_adb_forward) {
        // Attempt to use "adb reverse"
        if (enable_tunnel_reverse_any_port(tunnel, intr, serial,
                                           device_socket_name, port_range)) {
            return true;
        }
        // if "adb reverse" does not work (e.g. over "adb connect"), it
        // fallbacks to "adb forward", so the app socket is the client
        LOGW("'adb reverse' failed, fallback to 'adb forward'");
    }
    return enable_tunnel_forward_any_port(tunnel, intr, serial,
                                          device_socket_name, port_range);
 }
 bool
 sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
                    const char *serial, const char *device_socket_name) {
    assert(tunnel->enabled);
    bool ret;
    if (tunnel->forward) {
        ret = sc_adb_forward_remove(intr, serial, tunnel->local_port,
                                    SC_ADB_NO_STDOUT);
    } else {
        ret = sc_adb_reverse_remove(intr, serial, device_socket_name,
                                    SC_ADB_NO_STDOUT);
        assert(tunnel->server_socket != SC_SOCKET_NONE);
        if (!net_close(tunnel->server_socket)) {
            LOGW("Could not close server socket");
        }
        // server_socket is never used anymore
    }
    // Consider tunnel disabled even if the command failed
    tunnel->enabled = false;
    return ret;
 }
--- a/app/src/adb/adb_tunnel.h
+++ b/app/src/adb/adb_tunnel.h
@ -1,47 +0,0 @@
 #ifndef SC_ADB_TUNNEL_H
 #define SC_ADB_TUNNEL_H
 #include "common.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include "options.h"
 #include "util/intr.h"
 #include "util/net.h"
 struct sc_adb_tunnel {
    bool enabled;
    bool forward; // use "adb forward" instead of "adb reverse"
    sc_socket server_socket; // only used if !forward
    uint16_t local_port;
 };
 /**
 * Initialize the adb tunnel struct to default values
 */
 void
 sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel);
 /**
 * Open a tunnel
 *
 * Blocking calls may be interrupted asynchronously via `intr`.
 *
 * If `force_adb_forward` is not set, then attempts to set up an "adb reverse"
 * tunnel first. Only if it fails (typical on old Android version connected via
 * TCP/IP), use "adb forward".
 */
 bool
 sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
                   const char *serial, const char *device_socket_name,
                   struct sc_port_range port_range, bool force_adb_forward);
 /**
 * Close the tunnel
 */
 bool
 sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
                    const char *serial, const char *device_socket_name);
 #endif
--- a/app/src/android/input.h
+++ b/app/src/android/input.h
@ -21,7 +21,7 @@
 #define _ANDROID_INPUT_H
 /**
- * Meta key / modifier state.
+ * Meta key / modifer state.
 */
 enum android_metastate {
    /** No meta keys are pressed. */
--- a/app/src/android/keycodes.h
+++ b/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. */
--- a/app/src/audio_player.c
+++ b/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;
 }
--- a/app/src/audio_player.h
+++ b/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
--- a/app/src/audio_regulator.c
+++ b/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);
 }
--- a/app/src/audio_regulator.h
+++ b/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
--- a/app/src/buffer_util.h
+++ b/app/src/buffer_util.h
@ -0,0 +1,46 @@
 #ifndef BUFFER_UTIL_H
 #define BUFFER_UTIL_H
 #include <stdbool.h>
 #include <stdint.h>
 #include "config.h"
 static inline void
 buffer_write16be(uint8_t *buf, uint16_t value) {
    buf[0] = value >> 8;
    buf[1] = value;
 }
 static inline void
 buffer_write32be(uint8_t *buf, uint32_t value) {
    buf[0] = value >> 24;
    buf[1] = value >> 16;
    buf[2] = value >> 8;
    buf[3] = value;
 }
 static inline void
 buffer_write64be(uint8_t *buf, uint64_t value) {
    buffer_write32be(buf, value >> 32);
    buffer_write32be(&buf[4], (uint32_t) value);
 }
 static inline uint16_t
 buffer_read16be(const uint8_t *buf) {
    return (buf[0] << 8) | buf[1];
 }
 static inline uint32_t
 buffer_read32be(const uint8_t *buf) {
    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 }
 static inline
 uint64_t buffer_read64be(const uint8_t *buf) {
    uint32_t msb = buffer_read32be(buf);
    uint32_t lsb = buffer_read32be(&buf[4]);
    return ((uint64_t) msb << 32) | lsb;
 }
 #endif
--- a/app/src/cbuf.h
+++ b/app/src/cbuf.h
@ -0,0 +1,52 @@
 // generic circular buffer (bounded queue) implementation
 #ifndef CBUF_H
 #define CBUF_H
 #include <stdbool.h>
 #include <unistd.h>
 #include "config.h"
 // To define a circular buffer type of 20 ints:
 //     struct cbuf_int CBUF(int, 20);
 //
 // data has length CAP + 1 to distinguish empty vs full.
 #define CBUF(TYPE, CAP) { \
    TYPE data[(CAP) + 1]; \
    size_t head; \
    size_t tail; \
 }
 #define cbuf_size_(PCBUF) \
    (sizeof((PCBUF)->data) / sizeof(*(PCBUF)->data))
 #define cbuf_is_empty(PCBUF) \
    ((PCBUF)->head == (PCBUF)->tail)
 #define cbuf_is_full(PCBUF) \
    (((PCBUF)->head + 1) % cbuf_size_(PCBUF) == (PCBUF)->tail)
 #define cbuf_init(PCBUF) \
    (void) ((PCBUF)->head = (PCBUF)->tail = 0)
 #define cbuf_push(PCBUF, ITEM) \
    ({ \
        bool ok = !cbuf_is_full(PCBUF); \
        if (ok) { \
            (PCBUF)->data[(PCBUF)->head] = (ITEM); \
            (PCBUF)->head = ((PCBUF)->head + 1) % cbuf_size_(PCBUF); \
        } \
        ok; \
    })
 #define cbuf_take(PCBUF, PITEM) \
    ({ \
        bool ok = !cbuf_is_empty(PCBUF); \
        if (ok) { \
            *(PITEM) = (PCBUF)->data[(PCBUF)->tail]; \
            (PCBUF)->tail = ((PCBUF)->tail + 1) % cbuf_size_(PCBUF); \
        } \
        ok; \
    })
 #endif
--- a/app/src/cli.c
+++ b/app/src/cli.c
--- a/app/src/cli.h
+++ b/app/src/cli.h
@ -1,34 +0,0 @@
 #ifndef SCRCPY_CLI_H
 #define SCRCPY_CLI_H
 #include "common.h"
 #include <stdbool.h>
 #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
 scrcpy_print_usage(const char *arg0);
 bool
 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);
 #endif
 #endif
--- a/app/src/clock.c
+++ b/app/src/clock.c
@ -1,38 +0,0 @@
 #include "clock.h"
 #include <assert.h>
 #include "util/log.h"
 //#define SC_CLOCK_DEBUG // uncomment to debug
 #define SC_CLOCK_RANGE 32
 void
 sc_clock_init(struct sc_clock *clock) {
    clock->range = 0;
    clock->offset = 0;
 }
 void
 sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
    if (clock->range < SC_CLOCK_RANGE) {
        ++clock->range;
    }
    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;
 #ifdef SC_CLOCK_DEBUG
    LOGD("Clock estimation: pts + %" PRItick, 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;
 }
--- a/app/src/clock.h
+++ b/app/src/clock.h
@ -1,43 +0,0 @@
 #ifndef SC_CLOCK_H
 #define SC_CLOCK_H
 #include "common.h"
 #include "util/tick.h"
 struct sc_clock_point {
    sc_tick system;
    sc_tick stream;
 };
 /**
 * The clock aims to estimate the affine relation between the stream (device)
 * time and the system time:
 *
 *     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.
 *
 * 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).
 *
 * Therefore, only the offset is estimated.
 */
 struct sc_clock {
    unsigned range;
    sc_tick offset;
 };
 void
 sc_clock_init(struct sc_clock *clock);
 void
 sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream);
 sc_tick
 sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream);
 #endif
--- a/app/src/command.c
+++ b/app/src/command.c
@ -0,0 +1,204 @@
 #include "command.h"
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "config.h"
 #include "common.h"
 #include "log.h"
 #include "str_util.h"
 static const char *adb_command;
 static inline const char *
 get_adb_command(void) {
    if (!adb_command) {
        adb_command = getenv("ADB");
        if (!adb_command)
            adb_command = "adb";
    }
    return adb_command;
 }
 // serialize argv to string "[arg1], [arg2], [arg3]"
 static size_t
 argv_to_string(const char *const *argv, char *buf, size_t bufsize) {
    size_t idx = 0;
    bool first = true;
    while (*argv) {
        const char *arg = *argv;
        size_t len = strlen(arg);
        // count space for "[], ...\0"
        if (idx + len + 8 >= bufsize) {
            // not enough space, truncate
            assert(idx < bufsize - 4);
            memcpy(&buf[idx], "...", 3);
            idx += 3;
            break;
        }
        if (first) {
            first = false;
        } else {
            buf[idx++] = ',';
            buf[idx++] = ' ';
        }
        buf[idx++] = '[';
        memcpy(&buf[idx], arg, len);
        idx += len;
        buf[idx++] = ']';
        argv++;
    }
    assert(idx < bufsize);
    buf[idx] = '\0';
    return idx;
 }
 static void
 show_adb_err_msg(enum process_result err, const char *const argv[]) {
    char buf[512];
    switch (err) {
        case PROCESS_ERROR_GENERIC:
            argv_to_string(argv, buf, sizeof(buf));
            LOGE("Failed to execute: %s", buf);
            break;
        case PROCESS_ERROR_MISSING_BINARY:
            argv_to_string(argv, buf, sizeof(buf));
            LOGE("Command not found: %s", buf);
            LOGE("(make 'adb' accessible from your PATH or define its full"
                 "path in the ADB environment variable)");
            break;
        case PROCESS_SUCCESS:
            // do nothing
            break;
    }
 }
 process_t
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
    const char *cmd[len + 4];
    int i;
    process_t process;
    cmd[0] = get_adb_command();
    if (serial) {
        cmd[1] = "-s";
        cmd[2] = serial;
        i = 3;
    } else {
        i = 1;
    }
    memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
    cmd[len + i] = NULL;
    enum process_result r = cmd_execute(cmd[0], cmd, &process);
    if (r != PROCESS_SUCCESS) {
        show_adb_err_msg(r, cmd);
        return PROCESS_NONE;
    }
    return process;
 }
 process_t
 adb_forward(const char *serial, uint16_t local_port,
            const char *device_socket_name) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
    sprintf(local, "tcp:%" PRIu16, local_port);
    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
    const char *const adb_cmd[] = {"forward", local, remote};
    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 process_t
 adb_forward_remove(const char *serial, uint16_t local_port) {
    char local[4 + 5 + 1]; // tcp:PORT
    sprintf(local, "tcp:%" PRIu16, local_port);
    const char *const adb_cmd[] = {"forward", "--remove", local};
    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 process_t
 adb_reverse(const char *serial, const char *device_socket_name,
            uint16_t local_port) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
    sprintf(local, "tcp:%" PRIu16, local_port);
    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
    const char *const adb_cmd[] = {"reverse", remote, local};
    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 process_t
 adb_reverse_remove(const char *serial, const char *device_socket_name) {
    char remote[108 + 14 + 1]; // localabstract:NAME
    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
    const char *const adb_cmd[] = {"reverse", "--remove", remote};
    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 process_t
 adb_push(const char *serial, const char *local, const char *remote) {
 #ifdef __WINDOWS__
    // Windows will parse the string, so the paths must be quoted
    // (see sys/win/command.c)
    local = strquote(local);
    if (!local) {
        return PROCESS_NONE;
    }
    remote = strquote(remote);
    if (!remote) {
        SDL_free((void *) local);
        return PROCESS_NONE;
    }
 #endif
    const char *const adb_cmd[] = {"push", local, remote};
    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 #ifdef __WINDOWS__
    SDL_free((void *) remote);
    SDL_free((void *) local);
 #endif
    return proc;
 }
 process_t
 adb_install(const char *serial, const char *local) {
 #ifdef __WINDOWS__
    // Windows will parse the string, so the local name must be quoted
    // (see sys/win/command.c)
    local = strquote(local);
    if (!local) {
        return PROCESS_NONE;
    }
 #endif
    const char *const adb_cmd[] = {"install", "-r", local};
    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 #ifdef __WINDOWS__
    SDL_free((void *) local);
 #endif
    return proc;
 }
 bool
 process_check_success(process_t proc, const char *name) {
    if (proc == PROCESS_NONE) {
        LOGE("Could not execute \"%s\"", name);
        return false;
    }
    exit_code_t exit_code;
    if (!cmd_simple_wait(proc, &exit_code)) {
        if (exit_code != NO_EXIT_CODE) {
            LOGE("\"%s\" returned with value %" PRIexitcode, name, exit_code);
        } else {
            LOGE("\"%s\" exited unexpectedly", name);
        }
        return false;
    }
    return true;
 }
--- a/app/src/command.h
+++ b/app/src/command.h
@ -0,0 +1,88 @@
 #ifndef COMMAND_H
 #define COMMAND_H
 #include <stdbool.h>
 #include <inttypes.h>
 #ifdef _WIN32
 // not needed here, but winsock2.h must never be included AFTER windows.h
 # include <winsock2.h>
 # include <windows.h>
 # define PATH_SEPARATOR '\\'
 # define PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
 # ifdef _WIN64
 #   define PRIsizet PRIu64
 # else
 #   define PRIsizet PRIu32
 # endif
 # define PROCESS_NONE NULL
  typedef HANDLE process_t;
  typedef DWORD exit_code_t;
 #else
 # include <sys/types.h>
 # define PATH_SEPARATOR '/'
 # define PRIsizet "zu"
 # define PRIexitcode "d"
 # define PROCESS_NONE -1
  typedef pid_t process_t;
  typedef int exit_code_t;
 #endif
 #include "config.h"
 # define NO_EXIT_CODE -1
 enum process_result {
    PROCESS_SUCCESS,
    PROCESS_ERROR_GENERIC,
    PROCESS_ERROR_MISSING_BINARY,
 };
 enum process_result
 cmd_execute(const char *path, const char *const argv[], process_t *process);
 bool
 cmd_terminate(process_t pid);
 bool
 cmd_simple_wait(process_t pid, exit_code_t *exit_code);
 process_t
 adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
 process_t
 adb_forward(const char *serial, uint16_t local_port,
            const char *device_socket_name);
 process_t
 adb_forward_remove(const char *serial, uint16_t local_port);
 process_t
 adb_reverse(const char *serial, const char *device_socket_name,
            uint16_t local_port);
 process_t
 adb_reverse_remove(const char *serial, const char *device_socket_name);
 process_t
 adb_push(const char *serial, const char *local, const char *remote);
 process_t
 adb_install(const char *serial, const char *local);
 // convenience function to wait for a successful process execution
 // automatically log process errors with the provided process name
 bool
 process_check_success(process_t proc, const char *name);
 // return the absolute path of the executable (the scrcpy binary)
 // may be NULL on error; to be freed by SDL_free
 char *
 get_executable_path(void);
 #endif
--- a/app/src/common.h
+++ b/app/src/common.h
@ -1,15 +1,30 @@
-#ifndef SC_COMMON_H
+#ifndef COMMON_H
-#define SC_COMMON_H
+#define COMMON_H
 #include <stdint.h>
 #include "config.h"
 #include "compat.h"
 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
-#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
+#define MIN(X,Y) (X) < (Y) ? (X) : (Y)
-#define MAX(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) \
+struct size {
-    ((type *) (((char *) (ptr)) - offsetof(type, member)))
+    uint16_t width;
    uint16_t height;
 };
 struct point {
    int32_t x;
    int32_t y;
 };
 struct position {
    // The video screen size may be different from the real device screen size,
    // so store to which size the absolute position apply, to scale it
    // accordingly.
    struct size screen_size;
    struct point point;
 };
 #endif
--- a/app/src/compat.c
+++ b/app/src/compat.c
@ -1,110 +0,0 @@
 #include "compat.h"
 #include "config.h"
 #include <assert.h>
 #ifndef HAVE_REALLOCARRAY
 # include <errno.h>
 #endif
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
 #ifndef HAVE_STRDUP
 char *strdup(const char *s) {
    size_t size = strlen(s) + 1;
    char *dup = malloc(size);
    if (dup) {
        memcpy(dup, s, size);
    }
    return dup;
 }
 #endif
 #ifndef HAVE_ASPRINTF
 int asprintf(char **strp, const char *fmt, ...) {
    va_list va;
    va_start(va, fmt);
    int ret = vasprintf(strp, fmt, va);
    va_end(va);
    return ret;
 }
 #endif
 #ifndef HAVE_VASPRINTF
 int vasprintf(char **strp, const char *fmt, va_list ap) {
    va_list va;
    va_copy(va, ap);
    int len = vsnprintf(NULL, 0, fmt, va);
    va_end(va);
    char *str = malloc(len + 1);
    if (!str) {
        return -1;
    }
    va_copy(va, ap);
    int len2 = vsnprintf(str, len + 1, fmt, va);
    (void) len2;
    assert(len == len2);
    va_end(va);
    *strp = str;
    return len;
 }
 #endif
 #if !defined(HAVE_NRAND48) || !defined(HAVE_JRAND48)
 #define SC_RAND48_MASK UINT64_C(0xFFFFFFFFFFFF) // 48 bits
 #define SC_RAND48_A UINT64_C(0x5DEECE66D)
 #define SC_RAND48_C 0xB
 static inline uint64_t rand_iter48(uint64_t x) {
    assert((x & ~SC_RAND48_MASK) == 0);
    return (x * SC_RAND48_A + SC_RAND48_C) & SC_RAND48_MASK;
 }
 static uint64_t rand_iter48_xsubi(unsigned short xsubi[3]) {
    uint64_t x = ((uint64_t) xsubi[0] << 32)
               | ((uint64_t) xsubi[1] << 16)
               | xsubi[2];
    x = rand_iter48(x);
    xsubi[0] = (x >> 32) & 0XFFFF;
    xsubi[1] = (x >> 16) & 0XFFFF;
    xsubi[2] = x & 0XFFFF;
    return x;
 }
 #ifndef HAVE_NRAND48
 long nrand48(unsigned short xsubi[3]) {
    // range [0, 2^31)
    return rand_iter48_xsubi(xsubi) >> 17;
 }
 #endif
 #ifndef HAVE_JRAND48
 long jrand48(unsigned short xsubi[3]) {
    // range [-2^31, 2^31)
    union {
        uint32_t u;
        int32_t i;
    } v;
    v.u = rand_iter48_xsubi(xsubi) >> 16;
    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
--- a/app/src/compat.h
+++ b/app/src/compat.h
@ -1,19 +1,17 @@
-#ifndef SC_COMPAT_H
+#ifndef COMPAT_H
-#define SC_COMPAT_H
+#define COMPAT_H
 #include "config.h"
 #include <libavcodec/version.h>
 #include <libavformat/version.h>
 #include <libavutil/version.h>
 #include <SDL2/SDL_version.h>
-#ifndef _WIN32
+// In ffmpeg/doc/APIchanges:
-# define PRIu64_ PRIu64
+// 2016-04-11 - 6f69f7a / 9200514 - lavf 57.33.100 / 57.5.0 - avformat.h
-# define SC_PRIsizet "zu"
+//   Add AVStream.codecpar, deprecate AVStream.codec.
-#else
+#if    (LIBAVFORMAT_VERSION_MICRO >= 100 /* FFmpeg */ && \
-# define PRIu64_ "I64u"  // Windows...
+        LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 33, 100)) \
-# define SC_PRIsizet "Iu"
+    || (LIBAVFORMAT_VERSION_MICRO < 100 && /* Libav */ \
        LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 5, 0))
 # define SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_API
 #endif
 // In ffmpeg/doc/APIchanges:
@ -27,43 +25,22 @@
 # 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
+// 2016-04-21 - 7fc329e - lavc 57.37.100 - avcodec.h
-//   Deprecate AVFormatContext filename field which had limited length, use the
+//   Add a new audio/video encoding and decoding API with decoupled input
-//   new dynamically allocated url field instead.
+//   and output -- avcodec_send_packet(), avcodec_receive_frame(),
-//
+//   avcodec_send_frame() and avcodec_receive_packet().
-// 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 37, 100)
-//   Add url field to AVFormatContext and add ff_format_set_url helper function.
+# define SCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
 #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 7, 100)
 # define SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
 #endif
-// Not documented in ffmpeg/doc/APIchanges, but the channel_layout API
+#if SDL_VERSION_ATLEAST(2, 0, 5)
-// has been replaced by chlayout in FFmpeg commit
+// <https://wiki.libsdl.org/SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH>
-// f423497b455da06c1337846902c770028760e094.
+# define SCRCPY_SDL_HAS_HINT_MOUSE_FOCUS_CLICKTHROUGH
-#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(57, 23, 100)
+// <https://wiki.libsdl.org/SDL_GetDisplayUsableBounds>
-# define SCRCPY_LAVU_HAS_CHLAYOUT
+# define SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
-#endif
+// <https://wiki.libsdl.org/SDL_WindowFlags>
-
+# define SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
 // 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
 #endif
 #if SDL_VERSION_ATLEAST(2, 0, 8)
@ -71,32 +48,4 @@
 # 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
 #ifndef HAVE_ASPRINTF
 int asprintf(char **strp, const char *fmt, ...);
 #endif
 #ifndef HAVE_VASPRINTF
 int vasprintf(char **strp, const char *fmt, va_list ap);
 #endif
 #ifndef HAVE_NRAND48
 long nrand48(unsigned short xsubi[3]);
 #endif
 #ifndef HAVE_JRAND48
 long jrand48(unsigned short xsubi[3]);
 #endif
 #ifndef HAVE_REALLOCARRAY
 void *reallocarray(void *ptr, size_t nmemb, size_t size);
 #endif
 #endif
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@ -1,189 +1,83 @@
 #include "control_msg.h"
 #include <assert.h>
 #include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
 #include <SDL2/SDL_assert.h>
-#include "util/binary.h"
+#include "config.h"
-#include "util/log.h"
+#include "buffer_util.h"
-#include "util/str.h"
+#include "log.h"
-
+#include "str_util.h"
 /**
 * Map an enum value to a string based on an array, without crashing on an
 * out-of-bounds index.
 */
 #define ENUM_TO_LABEL(labels, value) \
    ((size_t) (value) < ARRAY_LEN(labels) ? labels[value] : "???")
 #define KEYEVENT_ACTION_LABEL(value) \
    ENUM_TO_LABEL(android_keyevent_action_labels, value)
 #define MOTIONEVENT_ACTION_LABEL(value) \
    ENUM_TO_LABEL(android_motionevent_action_labels, value)
 static const char *const android_keyevent_action_labels[] = {
    "down",
    "up",
    "multi",
 };
 static const char *const android_motionevent_action_labels[] = {
    "down",
    "up",
    "move",
    "cancel",
    "outside",
    "pointer-down",
    "pointer-up",
    "hover-move",
    "scroll",
    "hover-enter",
    "hover-exit",
    "btn-press",
    "btn-release",
 };
 static const char *const copy_key_labels[] = {
    "none",
    "copy",
    "cut",
 };
 static inline const char *
 get_well_known_pointer_id_name(uint64_t pointer_id) {
    switch (pointer_id) {
        case SC_POINTER_ID_MOUSE:
            return "mouse";
        case SC_POINTER_ID_GENERIC_FINGER:
            return "finger";
        case SC_POINTER_ID_VIRTUAL_FINGER:
            return "vfinger";
        default:
            return NULL;
    }
 }
 static void
-write_position(uint8_t *buf, const struct sc_position *position) {
+write_position(uint8_t *buf, const struct position *position) {
-    sc_write32be(&buf[0], position->point.x);
+    buffer_write32be(&buf[0], position->point.x);
-    sc_write32be(&buf[4], position->point.y);
+    buffer_write32be(&buf[4], position->point.y);
-    sc_write16be(&buf[8], position->screen_size.width);
+    buffer_write16be(&buf[8], position->screen_size.width);
-    sc_write16be(&buf[10], position->screen_size.height);
+    buffer_write16be(&buf[10], position->screen_size.height);
 }
-// Write truncated string, and return the size
+// write length (2 bytes) + string (non nul-terminated)
 static size_t
-write_string_payload(uint8_t *payload, const char *utf8, size_t max_len) {
+write_string(const char *utf8, size_t max_len, unsigned char *buf) {
-    if (!utf8) {
+    size_t len = utf8_truncation_index(utf8, max_len);
-        return 0;
+    buffer_write16be(buf, (uint16_t) len);
    memcpy(&buf[2], utf8, len);
    return 2 + len;
 }
 static uint16_t
 to_fixed_point_16(float f) {
    SDL_assert(f >= 0.0f && f <= 1.0f);
    uint32_t u = f * 0x1p16f; // 2^16
    if (u >= 0xffff) {
        u = 0xffff;
    }
-    size_t len = sc_str_utf8_truncation_index(utf8, max_len);
+    return (uint16_t) u;
    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);
    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) {
+control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
    buf[0] = msg->type;
    switch (msg->type) {
-        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
+        case CONTROL_MSG_TYPE_INJECT_KEYCODE:
            buf[1] = msg->inject_keycode.action;
-            sc_write32be(&buf[2], msg->inject_keycode.keycode);
+            buffer_write32be(&buf[2], msg->inject_keycode.keycode);
-            sc_write32be(&buf[6], msg->inject_keycode.repeat);
+            buffer_write32be(&buf[6], msg->inject_keycode.metastate);
-            sc_write32be(&buf[10], msg->inject_keycode.metastate);
+            return 10;
-            return 14;
+        case CONTROL_MSG_TYPE_INJECT_TEXT: {
-        case SC_CONTROL_MSG_TYPE_INJECT_TEXT: {
+            size_t len = write_string(msg->inject_text.text,
-            size_t len = write_string(&buf[1], msg->inject_text.text,
+                                      CONTROL_MSG_TEXT_MAX_LENGTH, &buf[1]);
                                      SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
            return 1 + len;
        }
-        case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
+        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
            buf[1] = msg->inject_touch_event.action;
-            sc_write64be(&buf[2], msg->inject_touch_event.pointer_id);
+            buffer_write64be(&buf[2], msg->inject_touch_event.pointer_id);
            write_position(&buf[10], &msg->inject_touch_event.position);
            uint16_t pressure =
-                sc_float_to_u16fp(msg->inject_touch_event.pressure);
+                to_fixed_point_16(msg->inject_touch_event.pressure);
-            sc_write16be(&buf[22], pressure);
+            buffer_write16be(&buf[22], pressure);
-            sc_write32be(&buf[24], msg->inject_touch_event.action_button);
+            buffer_write32be(&buf[24], msg->inject_touch_event.buttons);
-            sc_write32be(&buf[28], msg->inject_touch_event.buttons);
+            return 28;
-            return 32;
+        case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
            write_position(&buf[1], &msg->inject_scroll_event.position);
-            int16_t hscroll =
+            buffer_write32be(&buf[13],
-                sc_float_to_i16fp(msg->inject_scroll_event.hscroll);
+                             (uint32_t) msg->inject_scroll_event.hscroll);
-            int16_t vscroll =
+            buffer_write32be(&buf[17],
-                sc_float_to_i16fp(msg->inject_scroll_event.vscroll);
+                             (uint32_t) msg->inject_scroll_event.vscroll);
            sc_write16be(&buf[13], (uint16_t) hscroll);
            sc_write16be(&buf[15], (uint16_t) vscroll);
            sc_write32be(&buf[17], msg->inject_scroll_event.buttons);
            return 21;
-        case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
+        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
-            buf[1] = msg->inject_keycode.action;
+            size_t len = write_string(msg->inject_text.text,
-            return 2;
+                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
+                                      &buf[1]);
            buf[1] = msg->get_clipboard.copy_key;
            return 2;
        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);
            return 10 + len;
        case SC_CONTROL_MSG_TYPE_SET_DISPLAY_POWER:
            buf[1] = msg->set_display_power.on;
            return 2;
        case SC_CONTROL_MSG_TYPE_UHID_CREATE:
            sc_write16be(&buf[1], msg->uhid_create.id);
            sc_write16be(&buf[3], msg->uhid_create.vendor_id);
            sc_write16be(&buf[5], msg->uhid_create.product_id);
            size_t index = 7;
            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 CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
-        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
+            buf[1] = msg->set_screen_power_mode.mode;
-        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
+            return 2;
-        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
+        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
-        case SC_CONTROL_MSG_TYPE_OPEN_HARD_KEYBOARD_SETTINGS:
+        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-        case SC_CONTROL_MSG_TYPE_RESET_VIDEO:
+        case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
            // no additional data
            return 1;
        default:
@ -193,154 +87,13 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf) {
 }
 void
-sc_control_msg_log(const struct sc_control_msg *msg) {
+control_msg_destroy(struct control_msg *msg) {
 #define LOG_CMSG(fmt, ...) LOGV("input: " fmt, ## __VA_ARGS__)
    switch (msg->type) {
-        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
+        case CONTROL_MSG_TYPE_INJECT_TEXT:
-            LOG_CMSG("key %-4s code=%d repeat=%" PRIu32 " meta=%06lx",
+            SDL_free(msg->inject_text.text);
                     KEYEVENT_ACTION_LABEL(msg->inject_keycode.action),
                     (int) msg->inject_keycode.keycode,
                     msg->inject_keycode.repeat,
                     (long) msg->inject_keycode.metastate);
            break;
-        case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
+        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
-            LOG_CMSG("text \"%s\"", msg->inject_text.text);
+            SDL_free(msg->set_clipboard.text);
            break;
        case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: {
            int action = msg->inject_touch_event.action
                       & AMOTION_EVENT_ACTION_MASK;
            uint64_t id = msg->inject_touch_event.pointer_id;
            const char *pointer_name = get_well_known_pointer_id_name(id);
            if (pointer_name) {
                // string pointer id
                LOG_CMSG("touch [id=%s] %-4s position=%" PRIi32 ",%" PRIi32
                             " pressure=%f action_button=%06lx 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",
                         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;
        }
        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
            LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%f"
                         " vscroll=%f buttons=%06lx",
                     msg->inject_scroll_event.position.point.x,
                     msg->inject_scroll_event.position.point.y,
                     msg->inject_scroll_event.hscroll,
                     msg->inject_scroll_event.vscroll,
                     (long) msg->inject_scroll_event.buttons);
            break;
        case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
            LOG_CMSG("back-or-screen-on %s",
                     KEYEVENT_ACTION_LABEL(msg->inject_keycode.action));
            break;
        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
            LOG_CMSG("get clipboard copy_key=%s",
                     copy_key_labels[msg->get_clipboard.copy_key]);
            break;
        case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
            LOG_CMSG("clipboard %" PRIu64_ " %s \"%s\"",
                     msg->set_clipboard.sequence,
                     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");
            break;
        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
            LOG_CMSG("expand notification panel");
            break;
        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
            LOG_CMSG("expand settings panel");
            break;
        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
            LOG_CMSG("collapse panels");
            break;
        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 "] %04" PRIx16 ":%04" PRIx16
                     " name=%s%s%s report_desc_size=%" PRIu16,
                     msg->uhid_create.id,
                     msg->uhid_create.vendor_id,
                     msg->uhid_create.product_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) {
        case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
            free(msg->inject_text.text);
            break;
        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
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@ -1,133 +1,79 @@
-#ifndef SC_CONTROLMSG_H
+#ifndef CONTROLMSG_H
-#define SC_CONTROLMSG_H
+#define CONTROLMSG_H
 #include "common.h"
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include "config.h"
 #include "android/input.h"
 #include "android/keycodes.h"
-#include "coords.h"
+#include "common.h"
 #include "hid/hid_event.h"
-#define SC_CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
+#define CONTROL_MSG_TEXT_MAX_LENGTH 300
 #define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH 4093
 #define CONTROL_MSG_SERIALIZED_MAX_SIZE \
    (3 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)
-#define SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
+#define POINTER_ID_MOUSE UINT64_C(-1);
 // 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)
+enum control_msg_type {
-#define SC_POINTER_ID_GENERIC_FINGER UINT64_C(-2)
+    CONTROL_MSG_TYPE_INJECT_KEYCODE,
-
+    CONTROL_MSG_TYPE_INJECT_TEXT,
-// Used for injecting an additional virtual pointer for pinch-to-zoom
+    CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-#define SC_POINTER_ID_VIRTUAL_FINGER UINT64_C(-3)
+    CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
-
+    CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
-enum sc_control_msg_type {
+    CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
-    SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
+    CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
-    SC_CONTROL_MSG_TYPE_INJECT_TEXT,
+    CONTROL_MSG_TYPE_GET_CLIPBOARD,
-    SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
+    CONTROL_MSG_TYPE_SET_CLIPBOARD,
-    SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
+    CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
    SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
    SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
    SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
    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_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_copy_key {
+enum screen_power_mode {
-    SC_COPY_KEY_NONE,
+    // see <https://android.googlesource.com/platform/frameworks/base.git/+/pie-release-2/core/java/android/view/SurfaceControl.java#305>
-    SC_COPY_KEY_COPY,
+    SCREEN_POWER_MODE_OFF = 0,
-    SC_COPY_KEY_CUT,
+    SCREEN_POWER_MODE_NORMAL = 2,
 };
-struct sc_control_msg {
+struct control_msg {
-    enum sc_control_msg_type type;
+    enum control_msg_type type;
    union {
        struct {
            enum android_keyevent_action action;
            enum android_keycode keycode;
            uint32_t repeat;
            enum android_metastate metastate;
        } inject_keycode;
        struct {
-            char *text; // owned, to be freed by free()
+            char *text; // owned, to be freed by SDL_free()
        } 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;
+            struct position position;
            float pressure;
        } inject_touch_event;
        struct {
-            struct sc_position position;
+            struct position position;
-            float hscroll;
+            int32_t hscroll;
-            float vscroll;
+            int32_t vscroll;
            enum android_motionevent_buttons buttons;
        } inject_scroll_event;
        struct {
-            enum android_keyevent_action action; // action for the BACK key
+            char *text; // owned, to be freed by SDL_free()
            // screen may only be turned on on ACTION_DOWN
        } back_or_screen_on;
        struct {
            enum sc_copy_key copy_key;
        } get_clipboard;
        struct {
            uint64_t sequence;
            char *text; // owned, to be freed by free()
            bool paste;
        } set_clipboard;
        struct {
-            bool on;
+            enum screen_power_mode mode;
-        } set_display_power;
+        } set_screen_power_mode;
        struct {
            uint16_t id;
            uint16_t vendor_id;
            uint16_t product_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;
    };
 };
-// buf size must be at least CONTROL_MSG_MAX_SIZE
+// buf size must be at least CONTROL_MSG_SERIALIZED_MAX_SIZE
 // return the number of bytes written
 size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, uint8_t *buf);
+control_msg_serialize(const struct control_msg *msg, unsigned char *buf);
 void
-sc_control_msg_log(const struct sc_control_msg *msg);
+control_msg_destroy(struct 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);
 #endif
--- a/app/src/controller.c
+++ b/app/src/controller.c
@ -1,202 +1,117 @@
 #include "controller.h"
-#include <assert.h>
+#include <SDL2/SDL_assert.h>
-#include "util/log.h"
+#include "config.h"
-
+#include "lock_util.h"
-// Drop droppable events above this limit
+#include "log.h"
 #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,
+controller_init(struct controller *controller, socket_t control_socket) {
-                   const struct sc_controller_callbacks *cbs,
+    cbuf_init(&controller->queue);
                   void *cbs_userdata) {
    sc_vecdeque_init(&controller->queue);
-    // Add 4 to support 4 non-droppable events without re-allocation
+    if (!receiver_init(&controller->receiver, control_socket)) {
    bool ok = sc_vecdeque_reserve(&controller->queue,
                                  SC_CONTROL_MSG_QUEUE_LIMIT + 4);
    if (!ok) {
        return false;
    }
-    static const struct sc_receiver_callbacks receiver_cbs = {
+    if (!(controller->mutex = SDL_CreateMutex())) {
-        .on_ended = sc_controller_receiver_on_ended,
+        receiver_destroy(&controller->receiver);
    };
    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 (!(controller->msg_cond = SDL_CreateCond())) {
-    if (!ok) {
+        receiver_destroy(&controller->receiver);
-        sc_receiver_destroy(&controller->receiver);
+        SDL_DestroyMutex(controller->mutex);
        sc_vecdeque_destroy(&controller->queue);
        return false;
    }
    ok = sc_cond_init(&controller->msg_cond);
    if (!ok) {
        sc_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,
+controller_destroy(struct controller *controller) {
-                        struct sc_acksync *acksync,
+    SDL_DestroyCond(controller->msg_cond);
-                        struct sc_uhid_devices *uhid_devices) {
+    SDL_DestroyMutex(controller->mutex);
    controller->receiver.acksync = acksync;
    controller->receiver.uhid_devices = uhid_devices;
 }
-void
+    struct control_msg msg;
-sc_controller_destroy(struct sc_controller *controller) {
+    while (cbuf_take(&controller->queue, &msg)) {
-    sc_cond_destroy(&controller->msg_cond);
+        control_msg_destroy(&msg);
    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);
    }
    sc_vecdeque_destroy(&controller->queue);
-    sc_receiver_destroy(&controller->receiver);
+    receiver_destroy(&controller->receiver);
 }
 bool
-sc_controller_push_msg(struct sc_controller *controller,
+controller_push_msg(struct controller *controller,
-                       const struct sc_control_msg *msg) {
+                      const struct control_msg *msg) {
-    if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
+    mutex_lock(controller->mutex);
-        sc_control_msg_log(msg);
+    bool was_empty = cbuf_is_empty(&controller->queue);
-    }
+    bool res = cbuf_push(&controller->queue, *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);
+        cond_signal(controller->msg_cond);
    }
-    } else if (!sc_control_msg_is_droppable(msg)) {
+    mutex_unlock(controller->mutex);
-        bool ok = sc_vecdeque_push(&controller->queue, *msg);
+    return res;
        if (ok) {
            pushed = true;
        } else {
            // A non-droppable event must be dropped anyway
            LOG_OOM();
        }
    }
    // Otherwise, the msg is discarded
    sc_mutex_unlock(&controller->mutex);
    return pushed;
 }
 static bool
-process_msg(struct sc_controller *controller,
+process_msg(struct controller *controller,
-            const struct sc_control_msg *msg, bool *eos) {
+              const struct control_msg *msg) {
-    static uint8_t serialized_msg[SC_CONTROL_MSG_MAX_SIZE];
+    unsigned char serialized_msg[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    size_t length = sc_control_msg_serialize(msg, serialized_msg);
+    int length = control_msg_serialize(msg, serialized_msg);
    if (!length) {
        *eos = false;
        return false;
    }
-
+    int w = net_send_all(controller->control_socket, serialized_msg, length);
-    ssize_t w =
+    return w == length;
        net_send_all(controller->control_socket, serialized_msg, length);
    if ((size_t) w != length) {
        *eos = true;
        return false;
    }
    return true;
 }
 static int
 run_controller(void *data) {
-    struct sc_controller *controller = data;
+    struct controller *controller = data;
    bool error = false;
    for (;;) {
-        sc_mutex_lock(&controller->mutex);
+        mutex_lock(controller->mutex);
-        while (!controller->stopped
+        while (!controller->stopped && cbuf_is_empty(&controller->queue)) {
-                && sc_vecdeque_is_empty(&controller->queue)) {
+            cond_wait(controller->msg_cond, controller->mutex);
            sc_cond_wait(&controller->msg_cond, &controller->mutex);
        }
        if (controller->stopped) {
            // stop immediately, do not process further msgs
-            sc_mutex_unlock(&controller->mutex);
+            mutex_unlock(controller->mutex);
            LOGD("Controller stopped");
            break;
        }
        struct control_msg msg;
        bool non_empty = cbuf_take(&controller->queue, &msg);
        SDL_assert(non_empty);
        mutex_unlock(controller->mutex);
-        assert(!sc_vecdeque_is_empty(&controller->queue));
+        bool ok = process_msg(controller, &msg);
-        struct sc_control_msg msg = sc_vecdeque_pop(&controller->queue);
+        control_msg_destroy(&msg);
        sc_mutex_unlock(&controller->mutex);
        bool eos;
        bool ok = process_msg(controller, &msg, &eos);
        sc_control_msg_destroy(&msg);
        if (!ok) {
-            if (eos) {
+            LOGD("Could not write msg to socket");
                LOGD("Controller stopped (socket closed)");
            } // else error already logged
            error = !eos;
            break;
        }
    }
    controller->cbs->on_ended(controller, error, controller->cbs_userdata);
    return 0;
 }
 bool
-sc_controller_start(struct sc_controller *controller) {
+controller_start(struct controller *controller) {
    LOGD("Starting controller thread");
-    bool ok = sc_thread_create(&controller->thread, run_controller,
+    controller->thread = SDL_CreateThread(run_controller, "controller",
-                               "scrcpy-ctl", controller);
+                                          controller);
-    if (!ok) {
+    if (!controller->thread) {
-        LOGE("Could not start controller thread");
+        LOGC("Could not start controller thread");
        return false;
    }
-    if (!sc_receiver_start(&controller->receiver)) {
+    if (!receiver_start(&controller->receiver)) {
-        sc_controller_stop(controller);
+        controller_stop(controller);
-        sc_thread_join(&controller->thread, NULL);
+        SDL_WaitThread(controller->thread, NULL);
        return false;
    }
@ -204,15 +119,15 @@ sc_controller_start(struct sc_controller *controller) {
 }
 void
-sc_controller_stop(struct sc_controller *controller) {
+controller_stop(struct controller *controller) {
-    sc_mutex_lock(&controller->mutex);
+    mutex_lock(controller->mutex);
    controller->stopped = true;
-    sc_cond_signal(&controller->msg_cond);
+    cond_signal(controller->msg_cond);
-    sc_mutex_unlock(&controller->mutex);
+    mutex_unlock(controller->mutex);
 }
 void
-sc_controller_join(struct sc_controller *controller) {
+controller_join(struct controller *controller) {
-    sc_thread_join(&controller->thread, NULL);
+    SDL_WaitThread(controller->thread, NULL);
-    sc_receiver_join(&controller->receiver);
+    receiver_join(&controller->receiver);
 }
--- a/app/src/controller.h
+++ b/app/src/controller.h
@ -1,61 +1,45 @@
-#ifndef SC_CONTROLLER_H
+#ifndef CONTROLLER_H
-#define SC_CONTROLLER_H
+#define CONTROLLER_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
 #include "config.h"
 #include "cbuf.h"
 #include "control_msg.h"
 #include "net.h"
 #include "receiver.h"
 #include "util/acksync.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 control_msg_queue CBUF(struct control_msg, 64);
-struct sc_controller {
+struct controller {
-    sc_socket control_socket;
+    socket_t control_socket;
-    sc_thread thread;
+    SDL_Thread *thread;
-    sc_mutex mutex;
+    SDL_mutex *mutex;
-    sc_cond msg_cond;
+    SDL_cond *msg_cond;
    bool stopped;
-    struct sc_control_msg_queue queue;
+    struct control_msg_queue queue;
-    struct sc_receiver receiver;
+    struct 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);
 };
 bool
-sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
+controller_init(struct controller *controller, socket_t control_socket);
                   const struct sc_controller_callbacks *cbs,
                   void *cbs_userdata);
 void
-sc_controller_configure(struct sc_controller *controller,
+controller_destroy(struct controller *controller);
                        struct sc_acksync *acksync,
                        struct sc_uhid_devices *uhid_devices);
 void
 sc_controller_destroy(struct sc_controller *controller);
 bool
-sc_controller_start(struct sc_controller *controller);
+controller_start(struct controller *controller);
 void
-sc_controller_stop(struct sc_controller *controller);
+controller_stop(struct controller *controller);
 void
-sc_controller_join(struct sc_controller *controller);
+controller_join(struct controller *controller);
 bool
-sc_controller_push_msg(struct sc_controller *controller,
+controller_push_msg(struct controller *controller,
-                       const struct sc_control_msg *msg);
+                    const struct control_msg *msg);
 #endif
--- a/app/src/coords.h
+++ b/app/src/coords.h
@ -1,24 +0,0 @@
 #ifndef SC_COORDS
 #define SC_COORDS
 #include <stdint.h>
 struct sc_size {
    uint16_t width;
    uint16_t height;
 };
 struct sc_point {
    int32_t x;
    int32_t y;
 };
 struct sc_position {
    // The video screen size may be different from the real device screen size,
    // so store to which size the absolute position apply, to scale it
    // accordingly.
    struct sc_size screen_size;
    struct sc_point point;
 };
 #endif
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@ -1,109 +1,103 @@
 #include "decoder.h"
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
-#include <libavutil/channel_layout.h>
+#include <libavutil/time.h>
 #include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
 #include <unistd.h>
 #include "config.h"
 #include "compat.h"
 #include "buffer_util.h"
 #include "events.h"
-#include "trait/frame_sink.h"
+#include "lock_util.h"
-#include "util/log.h"
+#include "log.h"
-
+#include "recorder.h"
-/** Downcast packet_sink to decoder */
+#include "video_buffer.h"
 #define DOWNCAST(SINK) container_of(SINK, struct sc_decoder, packet_sink)
 static bool
 sc_decoder_open(struct sc_decoder *decoder, AVCodecContext *ctx) {
    decoder->frame = av_frame_alloc();
    if (!decoder->frame) {
        LOG_OOM();
        return false;
    }
    if (!sc_frame_source_sinks_open(&decoder->frame_source, ctx)) {
        av_frame_free(&decoder->frame);
        return false;
    }
    decoder->ctx = ctx;
    return true;
 }
 // set the decoded frame as ready for rendering, and notify
 static void
-sc_decoder_close(struct sc_decoder *decoder) {
+push_frame(struct decoder *decoder) {
-    sc_frame_source_sinks_close(&decoder->frame_source);
+    bool previous_frame_skipped;
-    av_frame_free(&decoder->frame);
+    video_buffer_offer_decoded_frame(decoder->video_buffer,
-}
+                                     &previous_frame_skipped);
-
+    if (previous_frame_skipped) {
-static bool
+        // the previous EVENT_NEW_FRAME will consume this frame
-sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {
+        return;
    bool is_config = packet->pts == AV_NOPTS_VALUE;
    if (is_config) {
        // nothing to do
        return true;
    }
-
+    static SDL_Event new_frame_event = {
-    int ret = avcodec_send_packet(decoder->ctx, packet);
+        .type = EVENT_NEW_FRAME,
-    if (ret < 0 && ret != AVERROR(EAGAIN)) {
+    };
-        LOGE("Decoder '%s': could not send video packet: %d",
+    SDL_PushEvent(&new_frame_event);
             decoder->name, 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;
        }
        // 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;
        }
    }
    return true;
 }
 static bool
 sc_decoder_packet_sink_open(struct sc_packet_sink *sink, AVCodecContext *ctx) {
    struct sc_decoder *decoder = DOWNCAST(sink);
    return sc_decoder_open(decoder, ctx);
 }
 static void
 sc_decoder_packet_sink_close(struct sc_packet_sink *sink) {
    struct sc_decoder *decoder = DOWNCAST(sink);
    sc_decoder_close(decoder);
 }
 static bool
 sc_decoder_packet_sink_push(struct sc_packet_sink *sink,
                            const AVPacket *packet) {
    struct sc_decoder *decoder = DOWNCAST(sink);
    return sc_decoder_push(decoder, packet);
 }
 void
-sc_decoder_init(struct sc_decoder *decoder, const char *name) {
+decoder_init(struct decoder *decoder, struct video_buffer *vb) {
-    decoder->name = name; // statically allocated
+    decoder->video_buffer = vb;
-    sc_frame_source_init(&decoder->frame_source);
+}
-
+
-    static const struct sc_packet_sink_ops ops = {
+bool
-        .open = sc_decoder_packet_sink_open,
+decoder_open(struct decoder *decoder, const AVCodec *codec) {
-        .close = sc_decoder_packet_sink_close,
+    decoder->codec_ctx = avcodec_alloc_context3(codec);
-        .push = sc_decoder_packet_sink_push,
+    if (!decoder->codec_ctx) {
-    };
+        LOGC("Could not allocate decoder context");
-
+        return false;
-    decoder->packet_sink.ops = &ops;
+    }
    if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
        LOGE("Could not open codec");
        avcodec_free_context(&decoder->codec_ctx);
        return false;
    }
    return true;
 }
 void
 decoder_close(struct decoder *decoder) {
    avcodec_close(decoder->codec_ctx);
    avcodec_free_context(&decoder->codec_ctx);
 }
 bool
 decoder_push(struct decoder *decoder, const AVPacket *packet) {
 // the new decoding/encoding API has been introduced by:
 // <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=7fc329e2dd6226dfecaa4a1d7adf353bf2773726>
 #ifdef SCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
    int ret;
    if ((ret = avcodec_send_packet(decoder->codec_ctx, packet)) < 0) {
        LOGE("Could not send video packet: %d", ret);
        return false;
    }
    ret = avcodec_receive_frame(decoder->codec_ctx,
                                decoder->video_buffer->decoding_frame);
    if (!ret) {
        // a frame was received
        push_frame(decoder);
    } else if (ret != AVERROR(EAGAIN)) {
        LOGE("Could not receive video frame: %d", ret);
        return false;
    }
 #else
    int got_picture;
    int len = avcodec_decode_video2(decoder->codec_ctx,
                                    decoder->video_buffer->decoding_frame,
                                    &got_picture,
                                    packet);
    if (len < 0) {
        LOGE("Could not decode video packet: %d", len);
        return false;
    }
    if (got_picture) {
        push_frame(decoder);
    }
 #endif
    return true;
 }
 void
 decoder_interrupt(struct decoder *decoder) {
    video_buffer_interrupt(decoder->video_buffer);
 }
--- a/app/src/decoder.h
+++ b/app/src/decoder.h
@ -1,27 +1,31 @@
-#ifndef SC_DECODER_H
+#ifndef DECODER_H
-#define SC_DECODER_H
+#define DECODER_H
 #include "common.h"
 #include "trait/frame_source.h"
 #include "trait/packet_sink.h"
 #include <stdbool.h>
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
-struct sc_decoder {
+#include "config.h"
    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 video_buffer;
-    AVCodecContext *ctx;
+struct decoder {
-    AVFrame *frame;
+    struct video_buffer *video_buffer;
    AVCodecContext *codec_ctx;
 };
 // The name must be statically allocated (e.g. a string literal)
 void
-sc_decoder_init(struct sc_decoder *decoder, const char *name);
+decoder_init(struct decoder *decoder, struct video_buffer *vb);
 bool
 decoder_open(struct decoder *decoder, const AVCodec *codec);
 void
 decoder_close(struct decoder *decoder);
 bool
 decoder_push(struct decoder *decoder, const AVPacket *packet);
 void
 decoder_interrupt(struct decoder *decoder);
 #endif
--- a/app/src/delay_buffer.c
+++ b/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;
 }
--- a/app/src/delay_buffer.h
+++ b/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
--- a/app/src/demuxer.c
+++ b/app/src/demuxer.c
@ -1,319 +0,0 @@
 #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"
 #define SC_PACKET_HEADER_SIZE 12
 #define SC_PACKET_FLAG_CONFIG    (UINT64_C(1) << 63)
 #define SC_PACKET_FLAG_KEY_FRAME (UINT64_C(1) << 62)
 #define SC_PACKET_PTS_MASK (SC_PACKET_FLAG_KEY_FRAME - 1)
 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 "meta" header length is 12 bytes:
    // [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
    //  <-------------> <-----> <-----------------------------...
    //        PTS        packet        raw packet
    //                    size
    //
    // It is followed by <packet_size> bytes containing the packet/frame.
    //
    // The most significant bits of the PTS are used for packet flags:
    //
    //  byte 7   byte 6   byte 5   byte 4   byte 3   byte 2   byte 1   byte 0
    // CK...... ........ ........ ........ ........ ........ ........ ........
    // ^^<------------------------------------------------------------------->
    // ||                                PTS
    // | `- key frame
    //  `-- config packet
    uint8_t header[SC_PACKET_HEADER_SIZE];
    ssize_t r = net_recv_all(demuxer->socket, header, SC_PACKET_HEADER_SIZE);
    if (r < SC_PACKET_HEADER_SIZE) {
        return false;
    }
    uint64_t pts_flags = sc_read64be(header);
    uint32_t len = sc_read32be(&header[8]);
    assert(len);
    if (av_new_packet(packet, len)) {
        LOG_OOM();
        return false;
    }
    r = net_recv_all(demuxer->socket, packet->data, len);
    if (r < 0 || ((uint32_t) r) < len) {
        av_packet_unref(packet);
        return false;
    }
    if (pts_flags & SC_PACKET_FLAG_CONFIG) {
        packet->pts = AV_NOPTS_VALUE;
    } else {
        packet->pts = pts_flags & SC_PACKET_PTS_MASK;
    }
    if (pts_flags & SC_PACKET_FLAG_KEY_FRAME) {
        packet->flags |= AV_PKT_FLAG_KEY;
    }
    packet->dts = packet->pts;
    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);
    if (!codec) {
        LOGE("Demuxer '%s': stream disabled due to missing decoder",
             demuxer->name);
        sc_packet_source_sinks_disable(&demuxer->packet_source);
        goto end;
    }
    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
    if (!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 (avcodec_open2(codec_ctx, codec, NULL) < 0) {
        LOGE("Demuxer '%s': could not open codec", demuxer->name);
        goto finally_free_context;
    }
    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);
    }
    AVPacket *packet = av_packet_alloc();
    if (!packet) {
        LOG_OOM();
        goto finally_close_sinks;
    }
    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);
        av_packet_unref(packet);
        if (!ok) {
            // The sink already logged its concrete error
            break;
        }
    }
    LOGD("Demuxer '%s': end of frames", demuxer->name);
    if (must_merge_config_packet) {
        sc_packet_merger_destroy(&merger);
    }
    av_packet_free(&packet);
 finally_close_sinks:
    sc_packet_source_sinks_close(&demuxer->packet_source);
 finally_free_context:
    avcodec_free_context(&codec_ctx);
 end:
    demuxer->cbs->on_ended(demuxer, status, demuxer->cbs_userdata);
    return 0;
 }
 void
 sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, 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);
    assert(cbs && cbs->on_ended);
    demuxer->cbs = cbs;
    demuxer->cbs_userdata = cbs_userdata;
 }
 bool
 sc_demuxer_start(struct sc_demuxer *demuxer) {
    LOGD("Demuxer '%s': starting thread", demuxer->name);
    bool ok = sc_thread_create(&demuxer->thread, run_demuxer, "scrcpy-demuxer",
                               demuxer);
    if (!ok) {
        LOGE("Demuxer '%s': could not start thread", demuxer->name);
        return false;
    }
    return true;
 }
 void
 sc_demuxer_join(struct sc_demuxer *demuxer) {
    sc_thread_join(&demuxer->thread, NULL);
 }
--- a/app/src/demuxer.h
+++ b/app/src/demuxer.h
@ -1,50 +0,0 @@
 #ifndef SC_DEMUXER_H
 #define SC_DEMUXER_H
 #include "common.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include "trait/packet_source.h"
 #include "trait/packet_sink.h"
 #include "util/net.h"
 #include "util/thread.h"
 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;
    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);
 };
 // 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,
                const struct sc_demuxer_callbacks *cbs, void *cbs_userdata);
 bool
 sc_demuxer_start(struct sc_demuxer *demuxer);
 void
 sc_demuxer_join(struct sc_demuxer *demuxer);
 #endif
--- a/app/src/device.c
+++ b/app/src/device.c
@ -0,0 +1,24 @@
 #include "device.h"
 #include "config.h"
 #include "log.h"
 bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size) {
    unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
    int r = net_recv_all(device_socket, buf, sizeof(buf));
    if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
        LOGE("Could not retrieve device information");
        return false;
    }
    // in case the client sends garbage
    buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
    // strcpy is safe here, since name contains at least
    // DEVICE_NAME_FIELD_LENGTH bytes and strlen(buf) < DEVICE_NAME_FIELD_LENGTH
    strcpy(device_name, (char *) buf);
    size->width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
            | buf[DEVICE_NAME_FIELD_LENGTH + 1];
    size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
    return true;
 }
--- a/app/src/device.h
+++ b/app/src/device.h
@ -0,0 +1,16 @@
 #ifndef DEVICE_H
 #define DEVICE_H
 #include <stdbool.h>
 #include "config.h"
 #include "common.h"
 #include "net.h"
 #define DEVICE_NAME_FIELD_LENGTH 64
 // name must be at least DEVICE_NAME_FIELD_LENGTH bytes
 bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size);
 #endif
--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@ -1,75 +1,39 @@
 #include "device_msg.h"
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <SDL2/SDL_assert.h>
-#include "util/binary.h"
+#include "config.h"
-#include "util/log.h"
+#include "buffer_util.h"
 #include "log.h"
 ssize_t
-sc_device_msg_deserialize(const uint8_t *buf, size_t len,
+device_msg_deserialize(const unsigned char *buf, size_t len,
-                          struct sc_device_msg *msg) {
+                       struct device_msg *msg) {
-    if (!len) {
+    if (len < 3) {
-        return 0; // no message
+        // 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) {
+            uint16_t clipboard_len = buffer_read16be(&buf[1]);
-                // at least type + empty string length
+            if (clipboard_len > len - 3) {
-                return 0; // no complete message
+                return 0; // not available
            }
-            size_t clipboard_len = sc_read32be(&buf[1]);
+            char *text = SDL_malloc(clipboard_len + 1);
            if (clipboard_len > len - 5) {
                return 0; // no complete message
            }
            char *text = malloc(clipboard_len + 1);
            if (!text) {
-                LOG_OOM();
+                LOGW("Could not allocate text for clipboard");
                return -1;
            }
            if (clipboard_len) {
-                memcpy(text, &buf[5], clipboard_len);
+                memcpy(text, &buf[3], clipboard_len);
            }
            text[clipboard_len] = '\0';
            msg->clipboard.text = text;
-            return 5 + clipboard_len;
+            return 3 + 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);
@ -78,16 +42,8 @@ sc_device_msg_deserialize(const uint8_t *buf, size_t len,
 }
 void
-sc_device_msg_destroy(struct sc_device_msg *msg) {
+device_msg_destroy(struct device_msg *msg) {
-    switch (msg->type) {
+    if (msg->type == DEVICE_MSG_TYPE_CLIPBOARD) {
-        case DEVICE_MSG_TYPE_CLIPBOARD:
+        SDL_free(msg->clipboard.text);
            free(msg->clipboard.text);
            break;
        case DEVICE_MSG_TYPE_UHID_OUTPUT:
            free(msg->uhid_output.data);
            break;
        default:
            // nothing to do
            break;
    }
 }
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@ -1,45 +1,34 @@
-#ifndef SC_DEVICEMSG_H
+#ifndef DEVICEMSG_H
-#define SC_DEVICEMSG_H
+#define DEVICEMSG_H
 #include "common.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <unistd.h>
-#define DEVICE_MSG_MAX_SIZE (1 << 18) // 256k
+#include "config.h"
 // type: 1 byte; length: 4 bytes
 #define DEVICE_MSG_TEXT_MAX_LENGTH (DEVICE_MSG_MAX_SIZE - 5)
-enum sc_device_msg_type {
+#define DEVICE_MSG_TEXT_MAX_LENGTH 4093
 #define DEVICE_MSG_SERIALIZED_MAX_SIZE (3 + DEVICE_MSG_TEXT_MAX_LENGTH)
 enum device_msg_type {
    DEVICE_MSG_TYPE_CLIPBOARD,
    DEVICE_MSG_TYPE_ACK_CLIPBOARD,
    DEVICE_MSG_TYPE_UHID_OUTPUT,
 };
-struct sc_device_msg {
+struct device_msg {
-    enum sc_device_msg_type type;
+    enum device_msg_type type;
    union {
        struct {
-            char *text; // owned, to be freed by free()
+            char *text; // owned, to be freed by SDL_free()
        } clipboard;
        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,
+device_msg_deserialize(const unsigned char *buf, size_t len,
-                          struct sc_device_msg *msg);
+                       struct device_msg *msg);
 void
-sc_device_msg_destroy(struct sc_device_msg *msg);
+device_msg_destroy(struct device_msg *msg);
 #endif
--- a/app/src/display.c
+++ b/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;
 }
--- a/app/src/display.h
+++ b/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
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@ -0,0 +1,169 @@
 #include "event_converter.h"
 #include "config.h"
 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false
 bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
    switch (from) {
        MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
        MAP(SDL_KEYUP,   AKEY_EVENT_ACTION_UP);
        FAIL;
    }
 }
 static enum android_metastate
 autocomplete_metastate(enum android_metastate metastate) {
    // fill dependant flags
    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
        metastate |= AMETA_SHIFT_ON;
    }
    if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
        metastate |= AMETA_CTRL_ON;
    }
    if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
        metastate |= AMETA_ALT_ON;
    }
    if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
        metastate |= AMETA_META_ON;
    }
    return metastate;
 }
 enum android_metastate
 convert_meta_state(SDL_Keymod mod) {
    enum android_metastate metastate = 0;
    if (mod & KMOD_LSHIFT) {
        metastate |= AMETA_SHIFT_LEFT_ON;
    }
    if (mod & KMOD_RSHIFT) {
        metastate |= AMETA_SHIFT_RIGHT_ON;
    }
    if (mod & KMOD_LCTRL) {
        metastate |= AMETA_CTRL_LEFT_ON;
    }
    if (mod & KMOD_RCTRL) {
        metastate |= AMETA_CTRL_RIGHT_ON;
    }
    if (mod & KMOD_LALT) {
        metastate |= AMETA_ALT_LEFT_ON;
    }
    if (mod & KMOD_RALT) {
        metastate |= AMETA_ALT_RIGHT_ON;
    }
    if (mod & KMOD_LGUI) { // Windows key
        metastate |= AMETA_META_LEFT_ON;
    }
    if (mod & KMOD_RGUI) { // Windows key
        metastate |= AMETA_META_RIGHT_ON;
    }
    if (mod & KMOD_NUM) {
        metastate |= AMETA_NUM_LOCK_ON;
    }
    if (mod & KMOD_CAPS) {
        metastate |= AMETA_CAPS_LOCK_ON;
    }
    if (mod & KMOD_MODE) { // Alt Gr
        // no mapping?
    }
    // fill the dependent fields
    return autocomplete_metastate(metastate);
 }
 bool
 convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod) {
    switch (from) {
        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
        MAP(SDLK_ESCAPE,       AKEYCODE_ESCAPE);
        MAP(SDLK_BACKSPACE,    AKEYCODE_DEL);
        MAP(SDLK_TAB,          AKEYCODE_TAB);
        MAP(SDLK_PAGEUP,       AKEYCODE_PAGE_UP);
        MAP(SDLK_DELETE,       AKEYCODE_FORWARD_DEL);
        MAP(SDLK_HOME,         AKEYCODE_MOVE_HOME);
        MAP(SDLK_END,          AKEYCODE_MOVE_END);
        MAP(SDLK_PAGEDOWN,     AKEYCODE_PAGE_DOWN);
        MAP(SDLK_RIGHT,        AKEYCODE_DPAD_RIGHT);
        MAP(SDLK_LEFT,         AKEYCODE_DPAD_LEFT);
        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
    }
    if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
        return false;
    }
    // if ALT and META are not pressed, also handle letters and space
    switch (from) {
        MAP(SDLK_a,            AKEYCODE_A);
        MAP(SDLK_b,            AKEYCODE_B);
        MAP(SDLK_c,            AKEYCODE_C);
        MAP(SDLK_d,            AKEYCODE_D);
        MAP(SDLK_e,            AKEYCODE_E);
        MAP(SDLK_f,            AKEYCODE_F);
        MAP(SDLK_g,            AKEYCODE_G);
        MAP(SDLK_h,            AKEYCODE_H);
        MAP(SDLK_i,            AKEYCODE_I);
        MAP(SDLK_j,            AKEYCODE_J);
        MAP(SDLK_k,            AKEYCODE_K);
        MAP(SDLK_l,            AKEYCODE_L);
        MAP(SDLK_m,            AKEYCODE_M);
        MAP(SDLK_n,            AKEYCODE_N);
        MAP(SDLK_o,            AKEYCODE_O);
        MAP(SDLK_p,            AKEYCODE_P);
        MAP(SDLK_q,            AKEYCODE_Q);
        MAP(SDLK_r,            AKEYCODE_R);
        MAP(SDLK_s,            AKEYCODE_S);
        MAP(SDLK_t,            AKEYCODE_T);
        MAP(SDLK_u,            AKEYCODE_U);
        MAP(SDLK_v,            AKEYCODE_V);
        MAP(SDLK_w,            AKEYCODE_W);
        MAP(SDLK_x,            AKEYCODE_X);
        MAP(SDLK_y,            AKEYCODE_Y);
        MAP(SDLK_z,            AKEYCODE_Z);
        MAP(SDLK_SPACE,        AKEYCODE_SPACE);
        FAIL;
    }
 }
 enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state) {
    enum android_motionevent_buttons buttons = 0;
    if (state & SDL_BUTTON_LMASK) {
        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
    }
    if (state & SDL_BUTTON_RMASK) {
        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
    }
    if (state & SDL_BUTTON_MMASK) {
        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
    }
    if (state & SDL_BUTTON_X1) {
        buttons |= AMOTION_EVENT_BUTTON_BACK;
    }
    if (state & SDL_BUTTON_X2) {
        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
    }
    return buttons;
 }
 bool
 convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
    switch (from) {
        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
        FAIL;
    }
 }
 bool
 convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
    switch (from) {
        MAP(SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE);
        MAP(SDL_FINGERDOWN,   AMOTION_EVENT_ACTION_DOWN);
        MAP(SDL_FINGERUP,     AMOTION_EVENT_ACTION_UP);
        FAIL;
    }
 }
--- a/app/src/event_converter.h
+++ b/app/src/event_converter.h
@ -0,0 +1,28 @@
 #ifndef CONVERT_H
 #define CONVERT_H
 #include <stdbool.h>
 #include <SDL2/SDL_events.h>
 #include "config.h"
 #include "control_msg.h"
 bool
 convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to);
 enum android_metastate
 convert_meta_state(SDL_Keymod mod);
 bool
 convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod);
 enum android_motionevent_buttons
 convert_mouse_buttons(uint32_t state);
 bool
 convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to);
 bool
 convert_touch_action(SDL_EventType from, enum android_motionevent_action *to);
 #endif
--- a/app/src/events.c
+++ b/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);
 }
--- a/app/src/events.h
+++ b/app/src/events.h
@ -1,38 +1,3 @@
-#ifndef SC_EVENTS_H
+#define EVENT_NEW_SESSION SDL_USEREVENT
-#define SC_EVENTS_H
+#define EVENT_NEW_FRAME (SDL_USEREVENT + 1)
-
+#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 2)
 #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
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@ -0,0 +1,190 @@
 #include "file_handler.h"
 #include <string.h>
 #include <SDL2/SDL_assert.h>
 #include "config.h"
 #include "command.h"
 #include "lock_util.h"
 #include "log.h"
 #define DEFAULT_PUSH_TARGET "/sdcard/"
 static void
 file_handler_request_destroy(struct file_handler_request *req) {
    SDL_free(req->file);
 }
 bool
 file_handler_init(struct file_handler *file_handler, const char *serial,
                  const char *push_target) {
    cbuf_init(&file_handler->queue);
    if (!(file_handler->mutex = SDL_CreateMutex())) {
        return false;
    }
    if (!(file_handler->event_cond = SDL_CreateCond())) {
        SDL_DestroyMutex(file_handler->mutex);
        return false;
    }
    if (serial) {
        file_handler->serial = SDL_strdup(serial);
        if (!file_handler->serial) {
            LOGW("Could not strdup serial");
            SDL_DestroyCond(file_handler->event_cond);
            SDL_DestroyMutex(file_handler->mutex);
            return false;
        }
    } else {
        file_handler->serial = NULL;
    }
    // lazy initialization
    file_handler->initialized = false;
    file_handler->stopped = false;
    file_handler->current_process = PROCESS_NONE;
    file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
    return true;
 }
 void
 file_handler_destroy(struct file_handler *file_handler) {
    SDL_DestroyCond(file_handler->event_cond);
    SDL_DestroyMutex(file_handler->mutex);
    SDL_free(file_handler->serial);
    struct file_handler_request req;
    while (cbuf_take(&file_handler->queue, &req)) {
        file_handler_request_destroy(&req);
    }
 }
 static process_t
 install_apk(const char *serial, const char *file) {
    return adb_install(serial, file);
 }
 static process_t
 push_file(const char *serial, const char *file, const char *push_target) {
    return adb_push(serial, file, push_target);
 }
 bool
 file_handler_request(struct file_handler *file_handler,
                     file_handler_action_t action, char *file) {
    // start file_handler if it's used for the first time
    if (!file_handler->initialized) {
        if (!file_handler_start(file_handler)) {
            return false;
        }
        file_handler->initialized = true;
    }
    LOGI("Request to %s %s", action == ACTION_INSTALL_APK ? "install" : "push",
                             file);
    struct file_handler_request req = {
        .action = action,
        .file = file,
    };
    mutex_lock(file_handler->mutex);
    bool was_empty = cbuf_is_empty(&file_handler->queue);
    bool res = cbuf_push(&file_handler->queue, req);
    if (was_empty) {
        cond_signal(file_handler->event_cond);
    }
    mutex_unlock(file_handler->mutex);
    return res;
 }
 static int
 run_file_handler(void *data) {
    struct file_handler *file_handler = data;
    for (;;) {
        mutex_lock(file_handler->mutex);
        file_handler->current_process = PROCESS_NONE;
        while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
            cond_wait(file_handler->event_cond, file_handler->mutex);
        }
        if (file_handler->stopped) {
            // stop immediately, do not process further events
            mutex_unlock(file_handler->mutex);
            break;
        }
        struct file_handler_request req;
        bool non_empty = cbuf_take(&file_handler->queue, &req);
        SDL_assert(non_empty);
        process_t process;
        if (req.action == ACTION_INSTALL_APK) {
            LOGI("Installing %s...", req.file);
            process = install_apk(file_handler->serial, req.file);
        } else {
            LOGI("Pushing %s...", req.file);
            process = push_file(file_handler->serial, req.file,
                                file_handler->push_target);
        }
        file_handler->current_process = process;
        mutex_unlock(file_handler->mutex);
        if (req.action == ACTION_INSTALL_APK) {
            if (process_check_success(process, "adb install")) {
                LOGI("%s successfully installed", req.file);
            } else {
                LOGE("Failed to install %s", req.file);
            }
        } else {
            if (process_check_success(process, "adb push")) {
                LOGI("%s successfully pushed to %s", req.file,
                                                     file_handler->push_target);
            } else {
                LOGE("Failed to push %s to %s", req.file,
                                                file_handler->push_target);
            }
        }
        file_handler_request_destroy(&req);
    }
    return 0;
 }
 bool
 file_handler_start(struct file_handler *file_handler) {
    LOGD("Starting file_handler thread");
    file_handler->thread = SDL_CreateThread(run_file_handler, "file_handler",
                                            file_handler);
    if (!file_handler->thread) {
        LOGC("Could not start file_handler thread");
        return false;
    }
    return true;
 }
 void
 file_handler_stop(struct file_handler *file_handler) {
    mutex_lock(file_handler->mutex);
    file_handler->stopped = true;
    cond_signal(file_handler->event_cond);
    if (file_handler->current_process != PROCESS_NONE) {
        if (!cmd_terminate(file_handler->current_process)) {
            LOGW("Could not terminate install process");
        }
        cmd_simple_wait(file_handler->current_process, NULL);
        file_handler->current_process = PROCESS_NONE;
    }
    mutex_unlock(file_handler->mutex);
 }
 void
 file_handler_join(struct file_handler *file_handler) {
    SDL_WaitThread(file_handler->thread, NULL);
 }
--- a/app/src/file_handler.h
+++ b/app/src/file_handler.h
@ -0,0 +1,58 @@
 #ifndef FILE_HANDLER_H
 #define FILE_HANDLER_H
 #include <stdbool.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
 #include "config.h"
 #include "cbuf.h"
 #include "command.h"
 typedef enum {
    ACTION_INSTALL_APK,
    ACTION_PUSH_FILE,
 } file_handler_action_t;
 struct file_handler_request {
    file_handler_action_t action;
    char *file;
 };
 struct file_handler_request_queue CBUF(struct file_handler_request, 16);
 struct file_handler {
    char *serial;
    const char *push_target;
    SDL_Thread *thread;
    SDL_mutex *mutex;
    SDL_cond *event_cond;
    bool stopped;
    bool initialized;
    process_t current_process;
    struct file_handler_request_queue queue;
 };
 bool
 file_handler_init(struct file_handler *file_handler, const char *serial,
                  const char *push_target);
 void
 file_handler_destroy(struct file_handler *file_handler);
 bool
 file_handler_start(struct file_handler *file_handler);
 void
 file_handler_stop(struct file_handler *file_handler);
 void
 file_handler_join(struct file_handler *file_handler);
 // take ownership of file, and will SDL_free() it
 bool
 file_handler_request(struct file_handler *file_handler,
                     file_handler_action_t action,
                     char *file);
 #endif
--- a/app/src/file_pusher.c
+++ b/app/src/file_pusher.c
@ -1,189 +0,0 @@
 #include "file_pusher.h"
 #include <assert.h>
 #include <string.h>
 #include "adb/adb.h"
 #include "util/log.h"
 #include "util/process_intr.h"
 #define DEFAULT_PUSH_TARGET "/sdcard/Download/"
 static void
 sc_file_pusher_request_destroy(struct sc_file_pusher_request *req) {
    free(req->file);
 }
 bool
 sc_file_pusher_init(struct sc_file_pusher *fp, const char *serial,
                    const char *push_target) {
    assert(serial);
    sc_vecdeque_init(&fp->queue);
    bool ok = sc_mutex_init(&fp->mutex);
    if (!ok) {
        return false;
    }
    ok = sc_cond_init(&fp->event_cond);
    if (!ok) {
        sc_mutex_destroy(&fp->mutex);
        return false;
    }
    ok = sc_intr_init(&fp->intr);
    if (!ok) {
        sc_cond_destroy(&fp->event_cond);
        sc_mutex_destroy(&fp->mutex);
        return false;
    }
    fp->serial = strdup(serial);
    if (!fp->serial) {
        LOG_OOM();
        sc_intr_destroy(&fp->intr);
        sc_cond_destroy(&fp->event_cond);
        sc_mutex_destroy(&fp->mutex);
        return false;
    }
    // lazy initialization
    fp->initialized = false;
    fp->stopped = false;
    fp->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
    return true;
 }
 void
 sc_file_pusher_destroy(struct sc_file_pusher *fp) {
    sc_cond_destroy(&fp->event_cond);
    sc_mutex_destroy(&fp->mutex);
    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);
    }
 }
 bool
 sc_file_pusher_request(struct sc_file_pusher *fp,
                       enum sc_file_pusher_action action, char *file) {
    // start file_pusher if it's used for the first time
    if (!fp->initialized) {
        if (!sc_file_pusher_start(fp)) {
            return false;
        }
        fp->initialized = true;
    }
    LOGI("Request to %s %s", action == SC_FILE_PUSHER_ACTION_INSTALL_APK
                                 ? "install" : "push",
                             file);
    struct sc_file_pusher_request req = {
        .action = action,
        .file = file,
    };
    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;
    }
    if (was_empty) {
        sc_cond_signal(&fp->event_cond);
    }
    sc_mutex_unlock(&fp->mutex);
    return true;
 }
 static int
 run_file_pusher(void *data) {
    struct sc_file_pusher *fp = data;
    struct sc_intr *intr = &fp->intr;
    const char *serial = fp->serial;
    assert(serial);
    const char *push_target = fp->push_target;
    assert(push_target);
    for (;;) {
        sc_mutex_lock(&fp->mutex);
        while (!fp->stopped && sc_vecdeque_is_empty(&fp->queue)) {
            sc_cond_wait(&fp->event_cond, &fp->mutex);
        }
        if (fp->stopped) {
            // stop immediately, do not process further events
            sc_mutex_unlock(&fp->mutex);
            break;
        }
        assert(!sc_vecdeque_is_empty(&fp->queue));
        struct sc_file_pusher_request req = sc_vecdeque_pop(&fp->queue);
        sc_mutex_unlock(&fp->mutex);
        if (req.action == SC_FILE_PUSHER_ACTION_INSTALL_APK) {
            LOGI("Installing %s...", req.file);
            bool ok = sc_adb_install(intr, serial, req.file, 0);
            if (ok) {
                LOGI("%s successfully installed", req.file);
            } else {
                LOGE("Failed to install %s", req.file);
            }
        } else {
            LOGI("Pushing %s...", req.file);
            bool ok = sc_adb_push(intr, serial, req.file, push_target, 0);
            if (ok) {
                LOGI("%s successfully pushed to %s", req.file, push_target);
            } else {
                LOGE("Failed to push %s to %s", req.file, push_target);
            }
        }
        sc_file_pusher_request_destroy(&req);
    }
    return 0;
 }
 bool
 sc_file_pusher_start(struct sc_file_pusher *fp) {
    LOGD("Starting file_pusher thread");
    bool ok = sc_thread_create(&fp->thread, run_file_pusher, "scrcpy-file", fp);
    if (!ok) {
        LOGE("Could not start file_pusher thread");
        return false;
    }
    return true;
 }
 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);
    }
 }
 void
 sc_file_pusher_join(struct sc_file_pusher *fp) {
    if (fp->initialized) {
        sc_thread_join(&fp->thread, NULL);
    }
 }
--- a/app/src/file_pusher.h
+++ b/app/src/file_pusher.h
@ -1,58 +0,0 @@
 #ifndef SC_FILE_PUSHER_H
 #define SC_FILE_PUSHER_H
 #include "common.h"
 #include <stdbool.h>
 #include "util/intr.h"
 #include "util/thread.h"
 #include "util/vecdeque.h"
 enum sc_file_pusher_action {
    SC_FILE_PUSHER_ACTION_INSTALL_APK,
    SC_FILE_PUSHER_ACTION_PUSH_FILE,
 };
 struct sc_file_pusher_request {
    enum sc_file_pusher_action action;
    char *file;
 };
 struct sc_file_pusher_request_queue SC_VECDEQUE(struct sc_file_pusher_request);
 struct sc_file_pusher {
    char *serial;
    const char *push_target;
    sc_thread thread;
    sc_mutex mutex;
    sc_cond event_cond;
    bool stopped;
    bool initialized;
    struct sc_file_pusher_request_queue queue;
    struct sc_intr intr;
 };
 bool
 sc_file_pusher_init(struct sc_file_pusher *fp, const char *serial,
                    const char *push_target);
 void
 sc_file_pusher_destroy(struct sc_file_pusher *fp);
 bool
 sc_file_pusher_start(struct sc_file_pusher *fp);
 void
 sc_file_pusher_stop(struct sc_file_pusher *fp);
 void
 sc_file_pusher_join(struct sc_file_pusher *fp);
 // take ownership of file, and will free() it
 bool
 sc_file_pusher_request(struct sc_file_pusher *fp,
                       enum sc_file_pusher_action action, char *file);
 #endif
--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@ -1,52 +1,45 @@
 #include "fps_counter.h"
-#include <assert.h>
+#include <SDL2/SDL_assert.h>
 #include <SDL2/SDL_timer.h>
-#include "util/log.h"
+#include "config.h"
 #include "lock_util.h"
 #include "log.h"
-#define SC_FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1)
+#define FPS_COUNTER_INTERVAL_MS 1000
 bool
-sc_fps_counter_init(struct sc_fps_counter *counter) {
+fps_counter_init(struct fps_counter *counter) {
-    bool ok = sc_mutex_init(&counter->mutex);
+    counter->mutex = SDL_CreateMutex();
-    if (!ok) {
+    if (!counter->mutex) {
        return false;
    }
-    ok = sc_cond_init(&counter->state_cond);
+    counter->state_cond = SDL_CreateCond();
-    if (!ok) {
+    if (!counter->state_cond) {
-        sc_mutex_destroy(&counter->mutex);
+        SDL_DestroyMutex(counter->mutex);
        return false;
    }
-    counter->thread_started = false;
+    counter->thread = NULL;
-    atomic_init(&counter->started, 0);
+    SDL_AtomicSet(&counter->started, 0);
    // no need to initialize the other fields, they are unused until started
    return true;
 }
 void
-sc_fps_counter_destroy(struct sc_fps_counter *counter) {
+fps_counter_destroy(struct fps_counter *counter) {
-    sc_cond_destroy(&counter->state_cond);
+    SDL_DestroyCond(counter->state_cond);
-    sc_mutex_destroy(&counter->mutex);
+    SDL_DestroyMutex(counter->mutex);
 }
 static inline bool
 is_started(struct sc_fps_counter *counter) {
    return atomic_load_explicit(&counter->started, memory_order_acquire);
 }
 static inline void
 set_started(struct sc_fps_counter *counter, bool started) {
    atomic_store_explicit(&counter->started, started, memory_order_release);
 }
 // must be called with mutex locked
 static void
-display_fps(struct sc_fps_counter *counter) {
+display_fps(struct fps_counter *counter) {
    unsigned rendered_per_second =
-        counter->nr_rendered * SC_TICK_FREQ / SC_FPS_COUNTER_INTERVAL;
+        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;
    if (counter->nr_skipped) {
        LOGI("%u fps (+%u frames skipped)", rendered_per_second,
                                            counter->nr_skipped);
@ -57,7 +50,7 @@ display_fps(struct sc_fps_counter *counter) {
 // must be called with mutex locked
 static void
-check_interval_expired(struct sc_fps_counter *counter, sc_tick now) {
+check_interval_expired(struct fps_counter *counter, uint32_t now) {
    if (now < counter->next_timestamp) {
        return;
    }
@ -67,119 +60,111 @@ check_interval_expired(struct sc_fps_counter *counter, sc_tick now) {
    counter->nr_skipped = 0;
    // add a multiple of the interval
    uint32_t elapsed_slices =
-        (now - counter->next_timestamp) / SC_FPS_COUNTER_INTERVAL + 1;
+        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL_MS + 1;
-    counter->next_timestamp += SC_FPS_COUNTER_INTERVAL * elapsed_slices;
+    counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;
 }
 static int
 run_fps_counter(void *data) {
-    struct sc_fps_counter *counter = data;
+    struct fps_counter *counter = data;
-    sc_mutex_lock(&counter->mutex);
+    mutex_lock(counter->mutex);
    while (!counter->interrupted) {
-        while (!counter->interrupted && !is_started(counter)) {
+        while (!counter->interrupted && !SDL_AtomicGet(&counter->started)) {
-            sc_cond_wait(&counter->state_cond, &counter->mutex);
+            cond_wait(counter->state_cond, counter->mutex);
        }
-        while (!counter->interrupted && is_started(counter)) {
+        while (!counter->interrupted && SDL_AtomicGet(&counter->started)) {
-            sc_tick now = sc_tick_now();
+            uint32_t now = SDL_GetTicks();
            check_interval_expired(counter, now);
            SDL_assert(counter->next_timestamp > now);
            uint32_t remaining = counter->next_timestamp - now;
            // ignore the reason (timeout or signaled), we just loop anyway
-            sc_cond_timedwait(&counter->state_cond, &counter->mutex,
+            cond_wait_timeout(counter->state_cond, counter->mutex, remaining);
                              counter->next_timestamp);
        }
    }
-    sc_mutex_unlock(&counter->mutex);
+    mutex_unlock(counter->mutex);
    return 0;
 }
 bool
-sc_fps_counter_start(struct sc_fps_counter *counter) {
+fps_counter_start(struct fps_counter *counter) {
-    sc_mutex_lock(&counter->mutex);
+    mutex_lock(counter->mutex);
-    counter->interrupted = false;
+    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
    counter->next_timestamp = sc_tick_now() + SC_FPS_COUNTER_INTERVAL;
    counter->nr_rendered = 0;
    counter->nr_skipped = 0;
-    sc_mutex_unlock(&counter->mutex);
+    mutex_unlock(counter->mutex);
-    set_started(counter, true);
+    SDL_AtomicSet(&counter->started, 1);
-    sc_cond_signal(&counter->state_cond);
+    cond_signal(counter->state_cond);
-    // counter->thread_started and counter->thread are always accessed from the
+    // counter->thread is always accessed from the same thread, no need to lock
-    // same thread, no need to lock
+    if (!counter->thread) {
-    if (!counter->thread_started) {
+        counter->thread =
-        bool ok = sc_thread_create(&counter->thread, run_fps_counter,
+            SDL_CreateThread(run_fps_counter, "fps counter", counter);
-                                   "scrcpy-fps", counter);
+        if (!counter->thread) {
        if (!ok) {
            LOGE("Could not start FPS counter thread");
            return false;
        }
        counter->thread_started = true;
    }
    LOGI("FPS counter started");
    return true;
 }
 void
-sc_fps_counter_stop(struct sc_fps_counter *counter) {
+fps_counter_stop(struct fps_counter *counter) {
-    set_started(counter, false);
+    SDL_AtomicSet(&counter->started, 0);
-    sc_cond_signal(&counter->state_cond);
+    cond_signal(counter->state_cond);
    LOGI("FPS counter stopped");
 }
 bool
-sc_fps_counter_is_started(struct sc_fps_counter *counter) {
+fps_counter_is_started(struct fps_counter *counter) {
-    return is_started(counter);
+    return SDL_AtomicGet(&counter->started);
 }
 void
-sc_fps_counter_interrupt(struct sc_fps_counter *counter) {
+fps_counter_interrupt(struct fps_counter *counter) {
-    if (!counter->thread_started) {
+    if (!counter->thread) {
        return;
    }
-    sc_mutex_lock(&counter->mutex);
+    mutex_lock(counter->mutex);
    counter->interrupted = true;
-    sc_mutex_unlock(&counter->mutex);
+    mutex_unlock(counter->mutex);
    // wake up blocking wait
-    sc_cond_signal(&counter->state_cond);
+    cond_signal(counter->state_cond);
 }
 void
-sc_fps_counter_join(struct sc_fps_counter *counter) {
+fps_counter_join(struct fps_counter *counter) {
-    if (counter->thread_started) {
+    if (counter->thread) {
-        // interrupted must be set by the thread calling join(), so no need to
+        SDL_WaitThread(counter->thread, NULL);
        // lock for the assertion
        assert(counter->interrupted);
        sc_thread_join(&counter->thread, NULL);
    }
 }
 void
-sc_fps_counter_add_rendered_frame(struct sc_fps_counter *counter) {
+fps_counter_add_rendered_frame(struct fps_counter *counter) {
-    if (!is_started(counter)) {
+    if (!SDL_AtomicGet(&counter->started)) {
        return;
    }
-    sc_mutex_lock(&counter->mutex);
+    mutex_lock(counter->mutex);
-    sc_tick now = sc_tick_now();
+    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_rendered;
-    sc_mutex_unlock(&counter->mutex);
+    mutex_unlock(counter->mutex);
 }
 void
-sc_fps_counter_add_skipped_frame(struct sc_fps_counter *counter) {
+fps_counter_add_skipped_frame(struct fps_counter *counter) {
-    if (!is_started(counter)) {
+    if (!SDL_AtomicGet(&counter->started)) {
        return;
    }
-    sc_mutex_lock(&counter->mutex);
+    mutex_lock(counter->mutex);
-    sc_tick now = sc_tick_now();
+    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_skipped;
-    sc_mutex_unlock(&counter->mutex);
+    mutex_unlock(counter->mutex);
 }
--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@ -1,59 +1,57 @@
-#ifndef SC_FPSCOUNTER_H
+#ifndef FPSCOUNTER_H
-#define SC_FPSCOUNTER_H
+#define FPSCOUNTER_H
 #include "common.h"
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <SDL2/SDL_atomic.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
-#include "util/thread.h"
+#include "config.h"
-struct sc_fps_counter {
+struct fps_counter {
-    sc_thread thread;
+    SDL_Thread *thread;
-    sc_mutex mutex;
+    SDL_mutex *mutex;
-    sc_cond state_cond;
+    SDL_cond *state_cond;
    bool thread_started;
    // atomic so that we can check without locking the mutex
    // if the FPS counter is disabled, we don't want to lock unnecessarily
-    atomic_bool started;
+    SDL_atomic_t started;
    // the following fields are protected by the mutex
    bool interrupted;
    unsigned nr_rendered;
    unsigned nr_skipped;
-    sc_tick next_timestamp;
+    uint32_t next_timestamp;
 };
 bool
-sc_fps_counter_init(struct sc_fps_counter *counter);
+fps_counter_init(struct fps_counter *counter);
 void
-sc_fps_counter_destroy(struct sc_fps_counter *counter);
+fps_counter_destroy(struct fps_counter *counter);
 bool
-sc_fps_counter_start(struct sc_fps_counter *counter);
+fps_counter_start(struct fps_counter *counter);
 void
-sc_fps_counter_stop(struct sc_fps_counter *counter);
+fps_counter_stop(struct fps_counter *counter);
 bool
-sc_fps_counter_is_started(struct sc_fps_counter *counter);
+fps_counter_is_started(struct fps_counter *counter);
 // request to stop the thread (on quit)
-// must be called before sc_fps_counter_join()
+// must be called before fps_counter_join()
 void
-sc_fps_counter_interrupt(struct sc_fps_counter *counter);
+fps_counter_interrupt(struct fps_counter *counter);
 void
-sc_fps_counter_join(struct sc_fps_counter *counter);
+fps_counter_join(struct fps_counter *counter);
 void
-sc_fps_counter_add_rendered_frame(struct sc_fps_counter *counter);
+fps_counter_add_rendered_frame(struct fps_counter *counter);
 void
-sc_fps_counter_add_skipped_frame(struct sc_fps_counter *counter);
+fps_counter_add_skipped_frame(struct fps_counter *counter);
 #endif
--- a/app/src/frame_buffer.c
+++ b/app/src/frame_buffer.c
@ -1,90 +0,0 @@
 #include "frame_buffer.h"
 #include <assert.h>
 #include <libavutil/avutil.h>
 #include <libavformat/avformat.h>
 #include "util/log.h"
 bool
 sc_frame_buffer_init(struct sc_frame_buffer *fb) {
    fb->pending_frame = av_frame_alloc();
    if (!fb->pending_frame) {
        LOG_OOM();
        return false;
    }
    fb->tmp_frame = av_frame_alloc();
    if (!fb->tmp_frame) {
        LOG_OOM();
        av_frame_free(&fb->pending_frame);
        return false;
    }
    bool ok = sc_mutex_init(&fb->mutex);
    if (!ok) {
        av_frame_free(&fb->pending_frame);
        av_frame_free(&fb->tmp_frame);
        return false;
    }
    // there is initially no frame, so consider it has already been consumed
    fb->pending_frame_consumed = true;
    return true;
 }
 void
 sc_frame_buffer_destroy(struct sc_frame_buffer *fb) {
    sc_mutex_destroy(&fb->mutex);
    av_frame_free(&fb->pending_frame);
    av_frame_free(&fb->tmp_frame);
 }
 static inline void
 swap_frames(AVFrame **lhs, AVFrame **rhs) {
    AVFrame *tmp = *lhs;
    *lhs = *rhs;
    *rhs = tmp;
 }
 bool
 sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
                     bool *previous_frame_skipped) {
    // Use a temporary frame to preserve pending_frame in case of error.
    // tmp_frame is an empty frame, no need to call av_frame_unref() beforehand.
    int r = av_frame_ref(fb->tmp_frame, frame);
    if (r) {
        LOGE("Could not ref frame: %d", r);
        return false;
    }
    sc_mutex_lock(&fb->mutex);
    // Now that av_frame_ref() succeeded, we can replace the previous
    // pending_frame
    swap_frames(&fb->pending_frame, &fb->tmp_frame);
    av_frame_unref(fb->tmp_frame);
    if (previous_frame_skipped) {
        *previous_frame_skipped = !fb->pending_frame_consumed;
    }
    fb->pending_frame_consumed = false;
    sc_mutex_unlock(&fb->mutex);
    return true;
 }
 void
 sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst) {
    sc_mutex_lock(&fb->mutex);
    assert(!fb->pending_frame_consumed);
    fb->pending_frame_consumed = true;
    av_frame_move_ref(dst, fb->pending_frame);
    // av_frame_move_ref() resets its source frame, so no need to call
    // av_frame_unref()
    sc_mutex_unlock(&fb->mutex);
 }
--- a/app/src/frame_buffer.h
+++ b/app/src/frame_buffer.h
@ -1,44 +0,0 @@
 #ifndef SC_FRAME_BUFFER_H
 #define SC_FRAME_BUFFER_H
 #include "common.h"
 #include <stdbool.h>
 #include "util/thread.h"
 // forward declarations
 typedef struct AVFrame AVFrame;
 /**
 * A frame buffer holds 1 pending frame, which is the last frame received from
 * the producer (typically, the decoder).
 *
 * If a pending frame has not been consumed when the producer pushes a new
 * frame, then it is lost. The intent is to always provide access to the very
 * last frame to minimize latency.
 */
 struct sc_frame_buffer {
    AVFrame *pending_frame;
    AVFrame *tmp_frame; // To preserve the pending frame on error
    sc_mutex mutex;
    bool pending_frame_consumed;
 };
 bool
 sc_frame_buffer_init(struct sc_frame_buffer *fb);
 void
 sc_frame_buffer_destroy(struct sc_frame_buffer *fb);
 bool
 sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
                     bool *skipped);
 void
 sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst);
 #endif
--- a/app/src/hid/hid_event.h
+++ b/app/src/hid/hid_event.h
@ -1,26 +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 uint8_t *report_desc; // pointer to static memory
    size_t report_desc_size;
 };
 struct sc_hid_close {
    uint16_t hid_id;
 };
 #endif
--- a/app/src/hid/hid_gamepad.c
+++ b/app/src/hid/hid_gamepad.c
@ -1,452 +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 (Rx)  Right stick x
    0x09, 0x33,
    // Usage (Ry)  Right stick y
    0x09, 0x34,
    // 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): 4x2 bytes (X, Y, Z, Rz)
    0x81, 0x02,
    // Usage Page (Generic Desktop)
    0x05, 0x01,
    // Usage (Z)
    0x09, 0x32,
    // Usage (Rz)
    0x09, 0x35,
    // 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): 2x2 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 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.)
 */
 // [-32768 to 32767] -> [0 to 65535]
 #define AXIS_RESCALE(V) (uint16_t) (((int32_t) V) + 0x8000)
 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 = AXIS_RESCALE(0);
    slot->axis_left_y = AXIS_RESCALE(0);
    slot->axis_right_x = AXIS_RESCALE(0);
    slot->axis_right_y = AXIS_RESCALE(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);
    uint16_t hid_id = sc_hid_gamepad_slot_get_id(slot_idx);
    hid_open->hid_id = hid_id;
    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];
    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;
 }
--- a/app/src/hid/hid_gamepad.h
+++ b/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
--- a/app/src/hid/hid_keyboard.c
+++ b/app/src/hid/hid_keyboard.c
@ -1,344 +0,0 @@
 #include "hid_keyboard.h"
 #include <string.h>
 #include "util/log.h"
 #define SC_HID_MOD_NONE 0x00
 #define SC_HID_MOD_LEFT_CONTROL (1 << 0)
 #define SC_HID_MOD_LEFT_SHIFT (1 << 1)
 #define SC_HID_MOD_LEFT_ALT (1 << 2)
 #define SC_HID_MOD_LEFT_GUI (1 << 3)
 #define SC_HID_MOD_RIGHT_CONTROL (1 << 4)
 #define SC_HID_MOD_RIGHT_SHIFT (1 << 5)
 #define SC_HID_MOD_RIGHT_ALT (1 << 6)
 #define SC_HID_MOD_RIGHT_GUI (1 << 7)
 #define SC_HID_KEYBOARD_INDEX_MODS 0
 #define SC_HID_KEYBOARD_INDEX_KEYS 2
 // USB HID protocol says 6 keys in an event is the requirement for BIOS
 // keyboard support, though OS could support more keys via modifying the report
 // desc. 6 should be enough for scrcpy.
 #define SC_HID_KEYBOARD_MAX_KEYS 6
 #define SC_HID_KEYBOARD_INPUT_SIZE \
    (SC_HID_KEYBOARD_INDEX_KEYS + SC_HID_KEYBOARD_MAX_KEYS)
 #define SC_HID_RESERVED 0x00
 #define SC_HID_ERROR_ROLL_OVER 0x01
 /**
 * For HID, only report descriptor is needed.
 *
 * The specification is available here:
 * <https://www.usb.org/document-library/device-class-definition-hid-111>
 *
 * In particular, read:
 *  - §6.2.2 Report Descriptor
 *  - Appendix B.1 Protocol 1 (Keyboard)
 *  - Appendix C: Keyboard Implementation
 *
 * The HID Usage Tables is also useful:
 * <https://www.usb.org/document-library/hid-usage-tables-15>
 *
 * Normally a basic HID keyboard uses 8 bytes:
 *     Modifier Reserved Key Key Key Key Key Key
 *
 * You can dump your device's report descriptor with:
 *
 *     sudo usbhid-dump -m vid:pid -e descriptor
 *
 * (change vid:pid' to your device's vendor ID and product ID).
 */
 static const uint8_t SC_HID_KEYBOARD_REPORT_DESC[] = {
    // Usage Page (Generic Desktop)
    0x05, 0x01,
    // Usage (Keyboard)
    0x09, 0x06,
    // Collection (Application)
    0xA1, 0x01,
    // Usage Page (Key Codes)
    0x05, 0x07,
    // Usage Minimum (224)
    0x19, 0xE0,
    // Usage Maximum (231)
    0x29, 0xE7,
    // Logical Minimum (0)
    0x15, 0x00,
    // Logical Maximum (1)
    0x25, 0x01,
    // Report Size (1)
    0x75, 0x01,
    // Report Count (8)
    0x95, 0x08,
    // Input (Data, Variable, Absolute): Modifier byte
    0x81, 0x02,
    // Report Size (8)
    0x75, 0x08,
    // Report Count (1)
    0x95, 0x01,
    // Input (Constant): Reserved byte
    0x81, 0x01,
    // Usage Page (LEDs)
    0x05, 0x08,
    // Usage Minimum (1)
    0x19, 0x01,
    // Usage Maximum (5)
    0x29, 0x05,
    // Report Size (1)
    0x75, 0x01,
    // Report Count (5)
    0x95, 0x05,
    // Output (Data, Variable, Absolute): LED report
    0x91, 0x02,
    // Report Size (3)
    0x75, 0x03,
    // Report Count (1)
    0x95, 0x01,
    // Output (Constant): LED report padding
    0x91, 0x01,
    // Usage Page (Key Codes)
    0x05, 0x07,
    // Usage Minimum (0)
    0x19, 0x00,
    // Usage Maximum (101)
    0x29, SC_HID_KEYBOARD_KEYS - 1,
    // Logical Minimum (0)
    0x15, 0x00,
    // Logical Maximum(101)
    0x25, SC_HID_KEYBOARD_KEYS - 1,
    // Report Size (8)
    0x75, 0x08,
    // Report Count (6)
    0x95, SC_HID_KEYBOARD_MAX_KEYS,
    // Input (Data, Array): Keys
    0x81, 0x00,
    // End Collection
    0xC0
 };
 /**
 * A keyboard HID input report is 8 bytes long:
 *
 *  - byte 0: modifiers (1 flag per modifier key, 8 possible modifier keys)
 *  - byte 1: reserved (always 0)
 *  - bytes 2 to 7: pressed keys (6 at most)
 *
 *                   7 6 5 4 3 2 1 0
 *                  +---------------+
 *         byte 0:  |. . . . . . . .| modifiers
 *                  +---------------+
 *                   ^ ^ ^ ^ ^ ^ ^ ^
 *                   | | | | | | | `- left Ctrl
 *                   | | | | | | `--- left Shift
 *                   | | | | | `----- left Alt
 *                   | | | | `------- left Gui
 *                   | | | `--------- right Ctrl
 *                   | | `----------- right Shift
 *                   | `------------- right Alt
 *                   `--------------- right Gui
 *
 *                  +---------------+
 *         byte 1:  |0 0 0 0 0 0 0 0| reserved
 *                  +---------------+
 *
 *                  +---------------+
 *   bytes 2 to 7:  |. . . . . . . .| scancode of 1st key pressed
 *                  +---------------+
 *                  |. . . . . . . .| scancode of 2nd key pressed
 *                  +---------------+
 *                  |. . . . . . . .| scancode of 3rd key pressed
 *                  +---------------+
 *                  |. . . . . . . .| scancode of 4th key pressed
 *                  +---------------+
 *                  |. . . . . . . .| scancode of 5th key pressed
 *                  +---------------+
 *                  |. . . . . . . .| scancode of 6th key pressed
 *                  +---------------+
 *
 * If there are less than 6 keys pressed, the last items are set to 0.
 * For example, if A and W are pressed:
 *
 *                  +---------------+
 *   bytes 2 to 7:  |0 0 0 0 0 1 0 0| A is pressed (scancode = 4)
 *                  +---------------+
 *                  |0 0 0 1 1 0 1 0| W is pressed (scancode = 26)
 *                  +---------------+
 *                  |0 0 0 0 0 0 0 0| ^
 *                  +---------------+ |  only 2 keys are pressed, the
 *                  |0 0 0 0 0 0 0 0| |  remaining items are set to 0
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 0| |
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 0| v
 *                  +---------------+
 *
 * Pressing more than 6 keys is not supported. If this happens (typically,
 * never in practice), report a "phantom state":
 *
 *                  +---------------+
 *   bytes 2 to 7:  |0 0 0 0 0 0 0 1| ^
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 1| |  more than 6 keys pressed:
 *                  +---------------+ |  the list is filled with a special
 *                  |0 0 0 0 0 0 0 1| |  rollover error code (0x01)
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 1| |
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 1| |
 *                  +---------------+ |
 *                  |0 0 0 0 0 0 0 1| v
 *                  +---------------+
 */
 static void
 sc_hid_keyboard_input_init(struct sc_hid_input *hid_input) {
    hid_input->hid_id = SC_HID_ID_KEYBOARD;
    hid_input->size = SC_HID_KEYBOARD_INPUT_SIZE;
    uint8_t *data = hid_input->data;
    data[SC_HID_KEYBOARD_INDEX_MODS] = SC_HID_MOD_NONE;
    data[1] = SC_HID_RESERVED;
    memset(&data[SC_HID_KEYBOARD_INDEX_KEYS], 0, SC_HID_KEYBOARD_MAX_KEYS);
 }
 static uint16_t
 sc_hid_mod_from_sdl_keymod(uint16_t mod) {
    uint16_t mods = SC_HID_MOD_NONE;
    if (mod & SC_MOD_LCTRL) {
        mods |= SC_HID_MOD_LEFT_CONTROL;
    }
    if (mod & SC_MOD_LSHIFT) {
        mods |= SC_HID_MOD_LEFT_SHIFT;
    }
    if (mod & SC_MOD_LALT) {
        mods |= SC_HID_MOD_LEFT_ALT;
    }
    if (mod & SC_MOD_LGUI) {
        mods |= SC_HID_MOD_LEFT_GUI;
    }
    if (mod & SC_MOD_RCTRL) {
        mods |= SC_HID_MOD_RIGHT_CONTROL;
    }
    if (mod & SC_MOD_RSHIFT) {
        mods |= SC_HID_MOD_RIGHT_SHIFT;
    }
    if (mod & SC_MOD_RALT) {
        mods |= SC_HID_MOD_RIGHT_ALT;
    }
    if (mod & SC_MOD_RGUI) {
        mods |= SC_HID_MOD_RIGHT_GUI;
    }
    return mods;
 }
 void
 sc_hid_keyboard_init(struct sc_hid_keyboard *hid) {
    memset(hid->keys, false, SC_HID_KEYBOARD_KEYS);
 }
 static inline bool
 scancode_is_modifier(enum sc_scancode scancode) {
    return scancode >= SC_SCANCODE_LCTRL && scancode <= SC_SCANCODE_RGUI;
 }
 bool
 sc_hid_keyboard_generate_input_from_key(struct sc_hid_keyboard *hid,
                                        struct sc_hid_input *hid_input,
                                        const struct sc_key_event *event) {
    enum sc_scancode scancode = event->scancode;
    assert(scancode >= 0);
    // SDL also generates events when only modifiers are pressed, we cannot
    // ignore them totally, for example press 'a' first then press 'Control',
    // if we ignore 'Control' event, only 'a' is sent.
    if (scancode >= SC_HID_KEYBOARD_KEYS && !scancode_is_modifier(scancode)) {
        // Scancode to ignore
        return false;
    }
    sc_hid_keyboard_input_init(hid_input);
    uint16_t mods = sc_hid_mod_from_sdl_keymod(event->mods_state);
    if (scancode < SC_HID_KEYBOARD_KEYS) {
        // Pressed is true and released is false
        hid->keys[scancode] = (event->action == SC_ACTION_DOWN);
        LOGV("keys[%02x] = %s", scancode,
             hid->keys[scancode] ? "true" : "false");
    }
    hid_input->data[SC_HID_KEYBOARD_INDEX_MODS] = mods;
    uint8_t *keys_data = &hid_input->data[SC_HID_KEYBOARD_INDEX_KEYS];
    // Re-calculate pressed keys every time
    int keys_pressed_count = 0;
    for (int i = 0; i < SC_HID_KEYBOARD_KEYS; ++i) {
        if (hid->keys[i]) {
            // USB HID protocol says that if keys exceeds report count, a
            // phantom state should be reported
            if (keys_pressed_count >= SC_HID_KEYBOARD_MAX_KEYS) {
                // Phantom state:
                //  - Modifiers
                //  - Reserved
                //  - ErrorRollOver * HID_MAX_KEYS
                memset(keys_data, SC_HID_ERROR_ROLL_OVER,
                       SC_HID_KEYBOARD_MAX_KEYS);
                goto end;
            }
            keys_data[keys_pressed_count] = i;
            ++keys_pressed_count;
        }
    }
 end:
    LOGV("hid keyboard: key %-4s scancode=%02x (%u) mod=%02x",
         event->action == SC_ACTION_DOWN ? "down" : "up", event->scancode,
         event->scancode, mods);
    return true;
 }
 bool
 sc_hid_keyboard_generate_input_from_mods(struct sc_hid_input *hid_input,
                                         uint16_t mods_state) {
    bool capslock = mods_state & SC_MOD_CAPS;
    bool numlock = mods_state & SC_MOD_NUM;
    if (!capslock && !numlock) {
        // Nothing to do
        return false;
    }
    sc_hid_keyboard_input_init(hid_input);
    unsigned i = 0;
    if (capslock) {
        hid_input->data[SC_HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;
        ++i;
    }
    if (numlock) {
        hid_input->data[SC_HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_NUMLOCK;
        ++i;
    }
    return true;
 }
 void sc_hid_keyboard_generate_open(struct sc_hid_open *hid_open) {
    hid_open->hid_id = SC_HID_ID_KEYBOARD;
    hid_open->report_desc = SC_HID_KEYBOARD_REPORT_DESC;
    hid_open->report_desc_size = sizeof(SC_HID_KEYBOARD_REPORT_DESC);
 }
 void sc_hid_keyboard_generate_close(struct sc_hid_close *hid_close) {
    hid_close->hid_id = SC_HID_ID_KEYBOARD;
 }
--- a/app/src/hid/hid_keyboard.h
+++ b/app/src/hid/hid_keyboard.h
@ -1,53 +0,0 @@
 #ifndef SC_HID_KEYBOARD_H
 #define SC_HID_KEYBOARD_H
 #include "common.h"
 #include <stdbool.h>
 #include "hid/hid_event.h"
 #include "input_events.h"
 // See "SDL2/SDL_scancode.h".
 // Maybe SDL_Keycode is used by most people, but SDL_Scancode is taken from USB
 // HID protocol.
 // 0x65 is Application, typically AT-101 Keyboard ends here.
 #define SC_HID_KEYBOARD_KEYS 0x66
 #define SC_HID_ID_KEYBOARD 1
 /**
 * HID keyboard events are sequence-based, every time keyboard state changes
 * it sends an array of currently pressed keys, the host is responsible for
 * compare events and determine which key becomes pressed and which key becomes
 * released. In order to convert SDL_KeyboardEvent to HID events, we first use
 * an array of keys to save each keys' state. And when a SDL_KeyboardEvent was
 * emitted, we updated our state, and then we use a loop to generate HID
 * events. The sequence of array elements is unimportant and when too much keys
 * pressed at the same time (more than report count), we should generate
 * phantom state. Don't forget that modifiers should be updated too, even for
 * phantom state.
 */
 struct sc_hid_keyboard {
    bool keys[SC_HID_KEYBOARD_KEYS];
 };
 void
 sc_hid_keyboard_init(struct sc_hid_keyboard *hid);
 void
 sc_hid_keyboard_generate_open(struct sc_hid_open *hid_open);
 void
 sc_hid_keyboard_generate_close(struct sc_hid_close *hid_close);
 bool
 sc_hid_keyboard_generate_input_from_key(struct sc_hid_keyboard *hid,
                                        struct sc_hid_input *hid_input,
                                        const struct sc_key_event *event);
 bool
 sc_hid_keyboard_generate_input_from_mods(struct sc_hid_input *hid_input,
                                         uint16_t mods_state);
 #endif
--- a/app/src/hid/hid_mouse.c
+++ b/app/src/hid/hid_mouse.c
@ -1,199 +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->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;
 }
--- a/app/src/hid/hid_mouse.h
+++ b/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
--- a/app/src/icon.c
+++ b/app/src/icon.c
@ -1,283 +0,0 @@
 #include "icon.h"
 #include <assert.h>
 #include <stdbool.h>
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include <libavutil/pixdesc.h>
 #include <libavutil/pixfmt.h>
 #include "config.h"
 #include "compat.h"
 #include "util/env.h"
 #include "util/file.h"
 #include "util/log.h"
 #include "util/str.h"
 #define SCRCPY_PORTABLE_ICON_FILENAME "icon.png"
 #define SCRCPY_DEFAULT_ICON_PATH \
    PREFIX "/share/icons/hicolor/256x256/apps/scrcpy.png"
 static char *
 get_icon_path(void) {
    char *icon_path = sc_get_env("SCRCPY_ICON_PATH");
    if (icon_path) {
        // if the envvar is set, use it
        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);
    if (!icon_path) {
        LOG_OOM();
        return NULL;
    }
 #else
    icon_path = sc_file_get_local_path(SCRCPY_PORTABLE_ICON_FILENAME);
    if (!icon_path) {
        LOGE("Could not get icon path");
        return NULL;
    }
    LOGD("Using icon (portable): %s", icon_path);
 #endif
    return icon_path;
 }
 static AVFrame *
 decode_image(const char *path) {
    AVFrame *result = NULL;
    AVFormatContext *ctx = avformat_alloc_context();
    if (!ctx) {
        LOG_OOM();
        return NULL;
    }
    if (avformat_open_input(&ctx, path, NULL, NULL) < 0) {
        LOGE("Could not open icon image: %s", path);
        goto free_ctx;
    }
    if (avformat_find_stream_info(ctx, NULL) < 0) {
        LOGE("Could not find image stream info");
        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);
    if (stream < 0 ) {
        LOGE("Could not find best image stream");
        goto close_input;
    }
    AVCodecParameters *params = ctx->streams[stream]->codecpar;
    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
        LOG_OOM();
        goto close_input;
    }
    if (avcodec_parameters_to_context(codec_ctx, params) < 0) {
        LOGE("Could not fill codec context");
        goto free_codec_ctx;
    }
    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
        LOGE("Could not open image codec");
        goto free_codec_ctx;
    }
    AVFrame *frame = av_frame_alloc();
    if (!frame) {
        LOG_OOM();
        goto free_codec_ctx;
    }
    AVPacket *packet = av_packet_alloc();
    if (!packet) {
        LOG_OOM();
        av_frame_free(&frame);
        goto free_codec_ctx;
    }
    if (av_read_frame(ctx, packet) < 0) {
        LOGE("Could not read frame");
        av_packet_free(&packet);
        av_frame_free(&frame);
        goto free_codec_ctx;
    }
    int ret;
    if ((ret = avcodec_send_packet(codec_ctx, packet)) < 0) {
        LOGE("Could not send icon packet: %d", ret);
        av_packet_free(&packet);
        av_frame_free(&frame);
        goto free_codec_ctx;
    }
    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;
    }
    av_packet_free(&packet);
    result = frame;
 free_codec_ctx:
    avcodec_free_context(&codec_ctx);
 close_input:
    avformat_close_input(&ctx);
 free_ctx:
    avformat_free_context(ctx);
    return result;
 }
 #if !SDL_VERSION_ATLEAST(2, 0, 10)
 // SDL_PixelFormatEnum has been introduced in SDL 2.0.10. Use int for older SDL
 // versions.
 typedef int SDL_PixelFormatEnum;
 #endif
 static SDL_PixelFormatEnum
 to_sdl_pixel_format(enum AVPixelFormat fmt) {
    switch (fmt) {
        case AV_PIX_FMT_RGB24: return SDL_PIXELFORMAT_RGB24;
        case AV_PIX_FMT_BGR24: return SDL_PIXELFORMAT_BGR24;
        case AV_PIX_FMT_ARGB: return SDL_PIXELFORMAT_ARGB32;
        case AV_PIX_FMT_RGBA: return SDL_PIXELFORMAT_RGBA32;
        case AV_PIX_FMT_ABGR: return SDL_PIXELFORMAT_ABGR32;
        case AV_PIX_FMT_BGRA: return SDL_PIXELFORMAT_BGRA32;
        case AV_PIX_FMT_RGB565BE: return SDL_PIXELFORMAT_RGB565;
        case AV_PIX_FMT_RGB555BE: return SDL_PIXELFORMAT_RGB555;
        case AV_PIX_FMT_BGR565BE: return SDL_PIXELFORMAT_BGR565;
        case AV_PIX_FMT_BGR555BE: return SDL_PIXELFORMAT_BGR555;
        case AV_PIX_FMT_RGB444BE: return SDL_PIXELFORMAT_RGB444;
 #if SDL_VERSION_ATLEAST(2, 0, 12)
        case AV_PIX_FMT_BGR444BE: return SDL_PIXELFORMAT_BGR444;
 #endif
        case AV_PIX_FMT_PAL8: return SDL_PIXELFORMAT_INDEX8;
        default: return SDL_PIXELFORMAT_UNKNOWN;
    }
 }
 static SDL_Surface *
 load_from_path(const char *path) {
    AVFrame *frame = decode_image(path);
    if (!frame) {
        return NULL;
    }
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
    if (!desc) {
        LOGE("Could not get icon format descriptor");
        goto error;
    }
    bool is_packed = !(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
    if (!is_packed) {
        LOGE("Could not load non-packed icon");
        goto error;
    }
    SDL_PixelFormatEnum format = to_sdl_pixel_format(frame->format);
    if (format == SDL_PIXELFORMAT_UNKNOWN) {
        LOGE("Unsupported icon pixel format: %s (%d)", desc->name,
                                                       frame->format);
        goto error;
    }
    int bits_per_pixel = av_get_bits_per_pixel(desc);
    SDL_Surface *surface =
        SDL_CreateRGBSurfaceWithFormatFrom(frame->data[0],
                                           frame->width, frame->height,
                                           bits_per_pixel,
                                           frame->linesize[0],
                                           format);
    if (!surface) {
        LOGE("Could not create icon surface");
        goto error;
    }
    if (frame->format == AV_PIX_FMT_PAL8) {
        // Initialize the SDL palette
        uint8_t *data = frame->data[1];
        SDL_Color colors[256];
        for (int i = 0; i < 256; ++i) {
            SDL_Color *color = &colors[i];
            // The palette is transported in AVFrame.data[1], is 1024 bytes
            // long (256 4-byte entries) and is formatted the same as in
            // AV_PIX_FMT_RGB32 described above (i.e., it is also
            // endian-specific).
            // <https://ffmpeg.org/doxygen/4.1/pixfmt_8h.html#a9a8e335cf3be472042bc9f0cf80cd4c5>
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
            color->a = data[i * 4];
            color->r = data[i * 4 + 1];
            color->g = data[i * 4 + 2];
            color->b = data[i * 4 + 3];
 #else
            color->a = data[i * 4 + 3];
            color->r = data[i * 4 + 2];
            color->g = data[i * 4 + 1];
            color->b = data[i * 4];
 #endif
        }
        SDL_Palette *palette = surface->format->palette;
        assert(palette);
        int ret = SDL_SetPaletteColors(palette, colors, 0, 256);
        if (ret) {
            LOGE("Could not set palette colors");
            SDL_FreeSurface(surface);
            goto error;
        }
    }
    surface->userdata = frame; // frame owns the data
    return surface;
 error:
    av_frame_free(&frame);
    return NULL;
 }
 SDL_Surface *
 scrcpy_icon_load(void) {
    char *icon_path = get_icon_path();
    if (!icon_path) {
        return NULL;
    }
    SDL_Surface *icon = load_from_path(icon_path);
    free(icon_path);
    return icon;
 }
 void
 scrcpy_icon_destroy(SDL_Surface *icon) {
    AVFrame *frame = icon->userdata;
    assert(frame);
    av_frame_free(&frame);
    SDL_FreeSurface(icon);
 }
--- a/app/src/icon.h
+++ b/app/src/icon.h
@ -1,16 +0,0 @@
 #ifndef SC_ICON_H
 #define SC_ICON_H
 #include "common.h"
 #include <stdbool.h>
 #include <SDL2/SDL.h>
 #include <libavformat/avformat.h>
 SDL_Surface *
 scrcpy_icon_load(void);
 void
 scrcpy_icon_destroy(SDL_Surface *icon);
 #endif
--- a/app/src/icon.xpm
+++ b/app/src/icon.xpm
@ -0,0 +1,53 @@
 /* XPM */
 static char * icon_xpm[] = {
 "48 48 2 1",
 " 	c None",
 ".	c #96C13E",
 "              ..                ..              ",
 "              ...              ...              ",
 "               ...   ......   ...               ",
 "                ................                ",
 "                 ..............                 ",
 "                ................                ",
 "               ..................               ",
 "              ....................              ",
 "             .....  ........  .....             ",
 "             .....  ........  .....             ",
 "             ......................             ",
 "            ........................            ",
 "            ........................            ",
 "            ........................            ",
 "                                                ",
 "                                                ",
 "     ....   ........................   ....     ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "    ......  ........................  ......    ",
 "     ....   ........................   ....     ",
 "            ........................            ",
 "             ......................             ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                ......    ......                ",
 "                 ....      ....                 "};
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Romain Vimont	a9275f2555	Use the physical size for the renderer Position and scale the frames manually instead of relying on the renderer "logical size". This will allow to draw elements having a size independant of the device frame.	2019-10-20 21:09:30 +02:00
Romain Vimont	c160825854	Handle window resizing in screen Only the screen knows what to do when the window is resized. This paves the way to do other actions on window resizing.	2019-10-20 16:21:10 +02:00
Romain Vimont	fd9f41548a	Pass screen to mouse event converters Mouse events coordinates depend on the screen size and location, so the converter need to access the screen. The fact that it needs the position or the size is an internal detail, so pass a pointer to the whole screen structure.	2019-10-20 16:21:10 +02:00
Romain Vimont	56527c0808	Move event conversion to input_manager Only keep helper functions separated. This will help to convert coordinates internally when necessary.	2019-10-20 16:09:00 +02:00
Romain Vimont	1315c2b00d	Rename "input_manager" variables to "im" It is used a lot, a short name improves readability.	2019-10-20 16:09:00 +02:00
		`@ -1,2 +0,0 @@`
			`@echo off`
			`scrcpy.exe --pause-on-exit=if-error %*`