Write header file with correct extradata

When recording, the header must be written with extradata set to the
content of the very first packet.

Suggested-by: Steve Lhomme <robux4@ycbcr.xyz>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,29 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
- - [ ] I have read the [FAQ](https://github.com/Genymobile/scrcpy/blob/master/FAQ.md).
- - [ ] I have searched in existing [issues](https://github.com/Genymobile/scrcpy/issues).
-
-**Environment**
- - OS: [e.g. Debian, Windows, macOS...]
- - scrcpy version: [e.g. 1.12.1]
- - installation method: [e.g. manual build, apt, snap, brew, Windows release...]
- - device model:
- - Android version: [e.g. 10]
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-On errors, please provide the output of the console (and `adb logcat` if relevant).
-
-```
-Please paste terminal output in a code block.
-```
-
-Please do not post screenshots of your terminal, just post the content as text instead.

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

.gitignore

@@ -1,9 +1,4 @@
 build/
 /dist/
-/build-*/
-/build_*/
-/release-*/
 .idea/
 .gradle/
-/x/
-local.properties

BUILD.md

@@ -2,66 +2,17 @@
 
 Here are the instructions to build _scrcpy_ (client and server).
 
+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).
 
-## Simple
-
-If you just want to install the latest release from `master`, follow this
-simplified process.
-
-First, you need to install the required packages:
-
-```bash
-# for Debian/Ubuntu
-sudo apt install ffmpeg libsdl2-2.0-0 adb wget \
-                 gcc git pkg-config meson ninja-build libsdl2-dev \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
-                 libusb-1.0-0 libusb-1.0-0-dev
-```
-
-Then clone the repo and execute the installation script
-([source](install_release.sh)):
-
-```bash
-git clone https://github.com/Genymobile/scrcpy
-cd scrcpy
-./install_release.sh
-```
-
-When a new release is out, update the repo and reinstall:
-
-```bash
-git pull
-./install_release.sh
-```
-
-To uninstall:
-
-```bash
-sudo ninja -Cbuild-auto uninstall
-```
-
-
-## Branches
-
-### `master`
-
-The `master` branch concerns the latest release, and is the home page of the
-project on GitHub.
-
-
-### `dev`
-
-`dev` is the current development branch. Every commit present in `dev` will be
-in the next release.
-
-If you want to contribute code, please base your commits on the latest `dev`
-branch.
+[prebuilt server]: #prebuilt-server
 
 
 ## Requirements
 
 You need [adb]. It is available in the [Android SDK platform
-tools][platform-tools], or packaged in your distribution (`adb`).
+tools][platform-tools], or packaged in your distribution (`android-adb-tools`).
 
 On Windows, download the [platform-tools][platform-tools-windows] and extract
 the following files to a directory accessible from your `PATH`:
@@ -89,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 \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
-                 libusb-1.0-0-dev
+sudo apt install make gcc pkg-config meson ninja-build \
+                 libavcodec-dev libavformat-dev libavutil-dev \
+                 libsdl2-dev
 
 # server build dependencies
-sudo apt install openjdk-11-jdk
+sudo apt install openjdk-8-jdk
 ```
 
 On old versions (like Ubuntu 16.04), `meson` is too old. In that case, install
@@ -116,10 +67,10 @@ 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 libusb-devel meson gcc make
+sudo dnf install SDL2-devel ffms2-devel meson gcc make
 
 # server build dependencies
-sudo dnf install java-devel
+sudo dnf install java
 ```
 
 
@@ -139,13 +90,13 @@ sudo apt install mingw-w64 mingw-w64-tools
 You also need the JDK to build the server:
 
 ```bash
-sudo apt install openjdk-11-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/`.
@@ -161,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-libusb
+          mingw-w64-x86_64-ffmpeg
 
 # client build dependencies
 pacman -S mingw-w64-x86_64-make \
@@ -176,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-libusb
+          mingw-w64-i686-ffmpeg
 
 # client build dependencies
 pacman -S mingw-w64-i686-make \
@@ -201,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 8 from Caskroom, and
-make it available from the `PATH`:
+make it avaliable from the `PATH`:
 
 ```bash
-brew tap homebrew/cask-versions
-brew install adoptopenjdk/openjdk/adoptopenjdk11
-export JAVA_HOME="$(/usr/libexec/java_home --version 1.11)"
+brew tap caskroom/versions
+brew cask install java8
+export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
 export PATH="$JAVA_HOME/bin:$PATH"
 ```
 
@@ -224,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
-ninja -Cx  # DO NOT RUN AS ROOT
+meson x --buildtype release --strip -Db_lto=true
+cd x
+ninja
 ```
 
 _Note: `ninja` [must][ninja-user] be run as a non-root user (only `ninja
@@ -270,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-v1.25`][direct-scrcpy-server]  
-   <sub>SHA-256: `ce0306c7bbd06ae72f6d06f7ec0ee33774995a65de71e0a83813ecb67aec9bdb`</sub>
-
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.25/scrcpy-server-v1.25
-
-Download the prebuilt server somewhere, and specify its path during the Meson
-configuration:
-
-```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:
+To run without installing:
 
 ```bash
 ./run x [options]
@@ -302,22 +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/share/scrcpy/scrcpy-server` (server to push to the device)
- - `/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)
+ - `/usr/local/bin/scrcpy`
+ - `/usr/local/share/scrcpy/scrcpy-server.jar`
 
-You can then [run](README.md#run) `scrcpy`.
+Just remove them to "uninstall" the application.
 
-### Uninstall
+You can then [run](README.md#run) _scrcpy_.
+
+
+## Prebuilt server
+
+ - [`scrcpy-server-v1.6.jar`][direct-scrcpy-server]  
+   _(SHA-256: 08df924bf6d10943df9eaacfff548a99871ebfca4641f8c7ddddb73f27cb905b)_
+
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.6/scrcpy-server-v1.6.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
 ```

DEVELOP.md

@@ -3,7 +3,7 @@
 ## Overview
 
 This application is composed of two parts:
- - the server (`scrcpy-server`), to be executed on the device,
+ - 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
@@ -32,7 +32,7 @@ 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
+[main]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/Server.java#L61
 
 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
@@ -49,7 +49,7 @@ 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`).
+`scrcpy-server.jar`).
 
 [dex]: https://en.wikipedia.org/wiki/Dalvik_(software)
 [apk]: https://en.wikipedia.org/wiki/Android_application_package
@@ -65,20 +65,17 @@ 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
+[wrappers]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/wrappers
+[aidl]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/aidl/android/view
 
 
 ### Threading
 
-The server uses 3 threads:
+The server uses 2 threads:
 
  - the **main** thread, encoding and streaming the video to the client;
- - the **controller** thread, listening for _control messages_ (typically,
-   keyboard and mouse events) from the client;
- - the **receiver** thread (managed by the controller), sending _device messages_
-   to the clients (currently, it is only used to send the device clipboard
-   content).
+ - the **controller** thread, listening for _control events_ (typically,
+   keyboard and mouse events) from the client.
 
 Since the video encoding is typically hardware, there would be no benefit in
 encoding and streaming in two different threads.
@@ -92,9 +89,9 @@ 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
+[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/v1.0/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
+[surface]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L63-L64
 
 On device [rotation], the codec, surface and display are reinitialized, and a
 new video stream is produced.
@@ -108,30 +105,30 @@ because it avoids to send unnecessary frames, but there are drawbacks:
 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
+[rotation]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L89-L92
+[repeat]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L125-L126
 [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:
+_Control events_ are received from the client by the [`EventController`] (run in
+a separate thread). There are 5 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).
+ - custom command (e.g. to switch the screen on).
 
-Some of them need to inject input events to the system. To do so, they use the
-_hidden_ method [`InputManager.injectInputEvent`] (exposed by our
+All of them may 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
+[`EventController`]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/EventController.java#L70
 [`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
+[inject-wrapper]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27
 
 
 
@@ -148,15 +145,15 @@ The video stream is decoded by [libav] (FFmpeg).
 ### 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.
+push and start the server on the device, and open a socket 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:
+However, the roles are inverted at the network level:
 
  - the client opens a server socket and listen on a port before starting the
    server,
@@ -165,9 +162,6 @@ However, the roles are reversed at the network level:
 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.
@@ -175,78 +169,52 @@ 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 client uses 3 threads:
 
  - the **main** thread, executing the SDL event loop,
- - the **stream** thread, receiving the video and used for decoding and
-   recording,
- - the **controller** thread, sending _control messages_ to the server,
- - the **receiver** thread (managed by the controller), receiving _device
-   messages_ from the server.
-
-In addition, another thread can be started if necessary to handle APK
-installation or file push requests (via drag&drop on the main window) or to
-print the framerate regularly in the console.
+ - the **decoder** thread, decoding video frames,
+ - the **controller** thread, sending _control events_ to the server.
 
 
+### Decoder
 
-### Stream
+The [decoder] runs in a separate thread. It uses _libav_ to decode the H.264
+stream from the socket, and notifies the main thread when a new frame is
+available.
 
-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:
+There are two [frames] simultaneously in memory:
  - the **decoding** frame, written by the decoder from the decoder thread,
  - the **rendering** frame, rendered in a texture from the main thread.
 
 When a new decoded frame is available, the decoder _swaps_ the decoding and
-rendering frame (with proper synchronization). Thus, it immediately starts
+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 it muxes the raw
-H.264 packet to the output video file.
+[decoder]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/decoder.c
+[frames]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/frames.h
 
-[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.
+The [controller] is responsible to send _control events_ 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
+creates appropriate [_control events_][controlevent]. 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.
+events_ to a blocking queue hold by the controller. On its own thread, the
+controller takes events 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
+[controller]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/controller.h
+[controlevent]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/controlevent.h
+[inputmanager]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/inputmanager.h
+[convert]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/convert.h
 
 
 ### UI and event loop
@@ -257,9 +225,9 @@ 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
+[scrcpy]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/scrcpy.c
+[event loop]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/scrcpy.c#L38
+[screen]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/screen.h
 
 
 ## Hack
@@ -268,42 +236,3 @@ For more details, go read the code!
 
 If you find a bug, or have an awesome idea to implement, please discuss and
 contribute ;-)
-
-
-### Debug the server
-
-The server is pushed to the device by the client on startup.
-
-To debug it, enable the server debugger during configuration:
-
-```bash
-meson setup x -Dserver_debugger=true
-# or, if x is already configured
-meson configure x -Dserver_debugger=true
-```
-
-If your device runs Android 8 or below, set the `server_debugger_method` to
-`old` in addition:
-
-```bash
-meson setup x -Dserver_debugger=true -Dserver_debugger_method=old
-# or, if x is already configured
-meson configure x -Dserver_debugger=true -Dserver_debugger_method=old
-```
-
-Then recompile.
-
-When you start scrcpy, it will start a debugger on port 5005 on the device.
-Redirect that port to the computer:
-
-```bash
-adb forward tcp:5005 tcp:5005
-```
-
-In Android Studio, _Run_ > _Debug_ > _Edit configurations..._ On the left, click on
-`+`, _Remote_, and fill the form:
-
- - Host: `localhost`
- - Port: `5005`
-
-Then click on _Debug_.

FAQ.md

@@ -1,214 +1,50 @@
 # Frequently Asked Questions
 
-[Read in another language](#translations)
+## Common issues
+
+The application is very young, it is not unlikely that you encounter problems
+with it.
 
 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` 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` fails, then scrcpy will not work.
+    adb devices
 
-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
+
+If you still encounter problems, please see [issue 9].
+
+[issue 9]: https://github.com/Genymobile/scrcpy/issues/9
 
 
-### Device unauthorized
-
->     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
-
-
-
-## Control issues
-
-### Mouse and keyboard do not work
+### Mouse clicks do not work
 
 On some devices, you may need to enable an option to allow [simulating input].
-In developer options, enable:
-
-> **USB debugging (Security settings)**  
-> _Allow granting permissions and simulating input via USB debugging_
 
 [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].
-A trick allows to also inject some [accented characters][accented-characters],
-but that's all. See [#37].
+On MacOS, with HiDPI support and multiple screens, input location are wrongly
+scaled. See [issue 15].
 
-Since scrcpy v1.20 on Linux, it is possible to simulate a [physical
-keyboard][hid] (HID).
+[issue 15]: https://github.com/Genymobile/scrcpy/issues/15
 
-[text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
-[accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
-[#37]: https://github.com/Genymobile/scrcpy/issues/37
-[hid]: README.md#physical-keyboard-simulation-hid
-
-
-## Client issues
-
-### The quality is low
-
-If the definition of your client window is smaller than that of your device
-screen, then you might get poor quality, especially visible on text (see [#40]).
-
-[#40]: https://github.com/Genymobile/scrcpy/issues/40
-
-This problem should be fixed in scrcpy v1.22: **update to the latest version**.
-
-On older versions, you must configure the [scaling behavior]:
-
-> `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
-> Override high DPI scaling behavior > Scaling performed by: _Application_.
-
-[scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
-
-Also, to improve downscaling quality, trilinear filtering is enabled
-automatically if the renderer is OpenGL and if it supports mipmapping.
-
-On Windows, you might want to force OpenGL to enable mipmapping:
-
-```
-scrcpy --render-driver=opengl
-```
-
-
-### Issue with Wayland
-
-By default, SDL uses x11 on Linux. The [video driver] can be changed via the
-`SDL_VIDEODRIVER` environment variable:
-
-[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
+A workaround is to build with HiDPI support disabled:
 
 ```bash
-export SDL_VIDEODRIVER=wayland
-scrcpy
+meson x --buildtype release -Dhidpi_support=false
 ```
 
-On some distributions (at least Fedora), the package `libdecor` must be
-installed manually.
-
-See issues [#2554] and [#2559].
-
-[#2554]: https://github.com/Genymobile/scrcpy/issues/2554
-[#2559]: https://github.com/Genymobile/scrcpy/issues/2559
+However, the video will be displayed at lower resolution.
 
 
 ### KWin compositor crashes
@@ -218,114 +54,3 @@ On Plasma Desktop, compositor is disabled while _scrcpy_ is running.
 As a workaround, [disable "Block compositing"][kwin].
 
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
-
-
-## Crashes
-
-### 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:
-
-> ```
-> ERROR: Exception on thread Thread[main,5,main]
-> android.media.MediaCodec$CodecException: Error 0xfffffc0e
-> ...
-> Exit due to uncaughtException in main thread:
-> ERROR: Could not open video stream
-> INFO: Initial texture: 1080x2336
-> ```
-
-or
-
-> ```
-> ERROR: Exception on thread Thread[main,5,main]
-> java.lang.IllegalStateException
->         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
-> ```
-
-Just try with a lower definition:
-
-```
-scrcpy -m 1920
-scrcpy -m 1024
-scrcpy -m 800
-```
-
-Since scrcpy v1.22, scrcpy automatically tries again with a lower definition
-before failing. This behavior can be disabled with `--no-downsize-on-error`.
-
-You could also try another [encoder](README.md#encoder).
-
-
-If you encounter this exception on Android 12, then just upgrade to scrcpy >=
-1.18 (see [#2129]):
-
-```
-> ERROR: Exception on thread Thread[main,5,main]
-java.lang.AssertionError: java.lang.reflect.InvocationTargetException
-    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:75)
-    ...
-Caused by: java.lang.reflect.InvocationTargetException
-    at java.lang.reflect.Method.invoke(Native Method)
-    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:73)
-    ... 7 more
-Caused by: java.lang.IllegalArgumentException: displayToken must not be null
-    at android.view.SurfaceControl$Transaction.setDisplaySurface(SurfaceControl.java:3067)
-    at android.view.SurfaceControl.setDisplaySurface(SurfaceControl.java:2147)
-    ... 9 more
-```
-
-[#2129]: https://github.com/Genymobile/scrcpy/issues/2129
-
-
-## Command line on Windows
-
-Since v1.22, a "shortcut" has been added to directly open a terminal in the
-scrcpy directory. Double-click on `open_a_terminal_here.bat`, then type your
-command. For example:
-
-```
-scrcpy --record file.mkv
-```
-
-You could also open a terminal and go to the scrcpy folder manually:
-
- 1. Press <kbd>Windows</kbd>+<kbd>r</kbd>, this opens a dialog box.
- 2. Type `cmd` and press <kbd>Enter</kbd>, this opens a terminal.
- 3. Go to your _scrcpy_ directory, by typing (adapt the path):
-
-    ```bat
-    cd C:\Users\user\Downloads\scrcpy-win64-xxx
-    ```
-
-    and press <kbd>Enter</kbd>
- 4. Type your command. For example:
-
-    ```bat
-    scrcpy --record file.mkv
-    ```
-
-If you plan to always use the same arguments, create a file `myscrcpy.bat`
-(enable [show file extensions] to avoid confusion) in the `scrcpy` directory,
-containing your command. For example:
-
-```bat
-scrcpy --prefer-text --turn-screen-off --stay-awake
-```
-
-Then just double-click on that file.
-
-You could also edit (a copy of) `scrcpy-console.bat` or `scrcpy-noconsole.vbs`
-to add some arguments.
-
-[show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/
-
-
-## Translations
-
-Translations of this FAQ in other languages are available in the [wiki].
-
-[wiki]: https://github.com/Genymobile/scrcpy/wiki
-
-Only this README file is guaranteed to be up-to-date.

LICENSE

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

Makefile.CrossWindows

@@ -0,0 +1,136 @@
+# 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 "Release created 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 -Dbuild_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 \
+			-Dbuild_server=false \
+			-Doverride_server_path=scrcpy-server.jar )
+	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 \
+			-Dbuild_server=false \
+			-Dwindows_noconsole=true \
+			-Doverride_server_path=scrcpy-server.jar )
+	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 \
+			-Dbuild_server=false \
+			-Doverride_server_path=scrcpy-server.jar )
+	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 \
+			-Dbuild_server=false \
+			-Dwindows_noconsole=true \
+			-Doverride_server_path=scrcpy-server.jar )
+	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-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win32-shared/bin/swresample-3.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.9/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-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.1-win64-shared/bin/swresample-3.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.9/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+
+zip-win32: dist-win32
+	cd "$(DIST)"; \
+		zip -r "$(WIN32_TARGET)" "$(WIN32_TARGET_DIR)"
+
+zip-win64: dist-win64
+	cd "$(DIST)"; \
+		zip -r "$(WIN64_TARGET)" "$(WIN64_TARGET_DIR)"
+
+sums:
+	cd "$(DIST)"; \
+		sha256sum *.zip > SHA256SUMS.txt

app/data/bash-completion/scrcpy

@@ -1,126 +0,0 @@
-_scrcpy() {
-    local cur prev words cword
-    local opts="
-        --always-on-top
-        -b --bit-rate=
-        --codec-options=
-        --crop=
-        -d --select-usb
-        --disable-screensaver
-        --display=
-        --display-buffer=
-        -e --select-tcpip
-        --encoder=
-        --force-adb-forward
-        --forward-all-clicks
-        -f --fullscreen
-        -K --hid-keyboard
-        -h --help
-        --legacy-paste
-        --lock-video-orientation
-        --lock-video-orientation=
-        --max-fps=
-        -M --hid-mouse
-        -m --max-size=
-        --no-cleanup
-        --no-clipboard-on-error
-        --no-downsize-on-error
-        -n --no-control
-        -N --no-display
-        --no-key-repeat
-        --no-mipmaps
-        --no-power-on
-        --otg
-        -p --port=
-        --power-off-on-close
-        --prefer-text
-        --print-fps
-        --push-target=
-        --raw-key-events
-        -r --record=
-        --record-format=
-        --render-driver=
-        --rotation=
-        -s --serial=
-        --shortcut-mod=
-        -S --turn-screen-off
-        -t --show-touches
-        --tcpip
-        --tcpip=
-        --tunnel-host=
-        --tunnel-port=
-        --v4l2-buffer=
-        --v4l2-sink=
-        -V --verbosity=
-        -v --version
-        -w --stay-awake
-        --window-borderless
-        --window-title=
-        --window-x=
-        --window-y=
-        --window-width=
-        --window-height="
-
-    _init_completion -s || return
-
-    case "$prev" in
-        --lock-video-orientation)
-            COMPREPLY=($(compgen -W 'unlocked initial 0 1 2 3' -- "$cur"))
-            return
-            ;;
-        -r|--record)
-            COMPREPLY=($(compgen -f -- "$cur"))
-            return
-            ;;
-        --record-format)
-            COMPREPLY=($(compgen -W 'mkv mp4' -- "$cur"))
-            return
-            ;;
-        --render-driver)
-            COMPREPLY=($(compgen -W 'direct3d opengl opengles2 opengles metal software' -- "$cur"))
-            return
-            ;;
-        --rotation)
-            COMPREPLY=($(compgen -W '0 1 2 3' -- "$cur"))
-            return
-            ;;
-        --shortcut-mod)
-            # Only auto-complete a single key
-            COMPREPLY=($(compgen -W 'lctrl rctrl lalt ralt lsuper rsuper' -- "$cur"))
-            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
-            ;;
-        -b|--bitrate \
-        |--codec-options \
-        |--crop \
-        |--display \
-        |--display-buffer \
-        |--encoder \
-        |--max-fps \
-        |-m|--max-size \
-        |-p|--port \
-        |--push-target \
-        |--tunnel-host \
-        |--tunnel-port \
-        |--v4l2-buffer \
-        |--v4l2-sink \
-        |--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

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>

app/data/open_a_terminal_here.bat

@@ -1 +0,0 @@
-@cmd

app/data/scrcpy-console.bat

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

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/bash --norc --noprofile -i -c '"$SHELL" -i -c scrcpy || read -p "Press any key to quit..."'
-Icon=scrcpy
-Terminal=true
-Type=Application
-Categories=Utility;RemoteAccess;
-StartupNotify=false

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

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

app/data/zsh-completion/_scrcpy

@@ -1,70 +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\)]'
-    {-b,--bit-rate=}'[Encode the video at the given bit-rate]'
-    '--codec-options=[Set a list of comma-separated key\:type=value options for the device encoder]'
-    '--crop=[\[width\:height\:x\:y\] Crop the device screen on the server]'
-    {-d,--select-usb}'[Use USB device]'
-    '--disable-screensaver[Disable screensaver while scrcpy is running]'
-    '--display=[Specify the display id to mirror]'
-    '--display-buffer=[Add a buffering delay \(in milliseconds\) before displaying]'
-    {-e,--select-tcpip}'[Use TCP/IP device]'
-    '--encoder=[Use a specific MediaCodec encoder \(must be a H.264 encoder\)]'
-    '--force-adb-forward[Do not attempt to use \"adb reverse\" to connect to the device]'
-    '--forward-all-clicks[Forward clicks to device]'
-    {-f,--fullscreen}'[Start in fullscreen]'
-    {-K,--hid-keyboard}'[Simulate a physical keyboard by using HID over AOAv2]'
-    {-h,--help}'[Print the help]'
-    '--legacy-paste[Inject computer clipboard text as a sequence of key events on Ctrl+v]'
-    '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 1 2 3)'
-    '--max-fps=[Limit the frame rate of screen capture]'
-    {-M,--hid-mouse}'[Simulate a physical mouse by using HID over AOAv2]'
-    {-m,--max-size=}'[Limit both the width and height of the video to value]'
-    '--no-cleanup[Disable device cleanup actions on exit]'
-    '--no-clipboard-autosync[Disable automatic clipboard synchronization]'
-    '--no-downsize-on-error[Disable lowering definition on MediaCodec error]'
-    {-n,--no-control}'[Disable device control \(mirror the device in read only\)]'
-    {-N,--no-display}'[Do not display device \(during screen recording or when V4L2 sink is enabled\)]'
-    '--no-key-repeat[Do not forward repeated key events when a key is held down]'
-    '--no-mipmaps[Disable the generation of mipmaps]'
-    '--no-power-on[Do not power on the device on start]'
-    '--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]'
-    '--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]'
-    '--raw-key-events[Inject key events for all input keys, and ignore text events]'
-    {-r,--record=}'[Record screen to file]:record file:_files'
-    '--record-format=[Force recording format]:format:(mp4 mkv)'
-    '--render-driver=[Request SDL to use the given render driver]:driver name:(direct3d opengl opengles2 opengles metal software)'
-    '--rotation=[Set the initial display rotation]:rotation values:(0 1 2 3)'
-    {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]:serial:($("${ADB-adb}" devices | awk '\''$2 == "device" {print $1}'\''))'
-    '--shortcut-mod=[\[key1,key2+key3,...\] Specify the modifiers to use for scrcpy shortcuts]:shortcut mod:(lctrl rctrl lalt ralt lsuper rsuper)'
-    {-S,--turn-screen-off}'[Turn the device screen off immediately]'
-    {-t,--show-touches}'[Show physical touches]'
-    '--tcpip[\(optional \[ip\:port\]\) Configure and connect the device over TCP/IP]'
-    '--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,--verbosity=}'[Set the log level]:verbosity:(verbose debug info warn error)'
-    {-v,--version}'[Print the version of scrcpy]'
-    {-w,--stay-awake}'[Keep the device on while scrcpy is running, when the device is plugged in]'
-    '--window-borderless[Disable window decorations \(display borderless window\)]'
-    '--window-title=[Set a custom window title]'
-    '--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

app/meson.build

@@ -1,120 +1,44 @@
 src = [
     'src/main.c',
-    'src/adb/adb.c',
-    'src/adb/adb_device.c',
-    'src/adb/adb_parser.c',
-    'src/adb/adb_tunnel.c',
-    'src/cli.c',
-    'src/clock.c',
-    'src/compat.c',
-    'src/control_msg.c',
+    'src/command.c',
+    'src/control_event.c',
     'src/controller.c',
+    'src/convert.c',
     'src/decoder.c',
-    'src/demuxer.c',
-    'src/device_msg.c',
-    'src/icon.c',
-    'src/file_pusher.c',
+    'src/device.c',
+    'src/file_handler.c',
     'src/fps_counter.c',
-    'src/frame_buffer.c',
+    'src/frames.c',
     'src/input_manager.c',
-    'src/keyboard_inject.c',
-    'src/mouse_inject.c',
-    'src/opengl.c',
-    'src/options.c',
-    'src/receiver.c',
+    'src/lock_util.c',
+    'src/net.c',
     'src/recorder.c',
     'src/scrcpy.c',
     'src/screen.c',
     'src/server.c',
-    'src/version.c',
-    'src/video_buffer.c',
-    'src/util/acksync.c',
-    'src/util/file.c',
-    'src/util/intmap.c',
-    'src/util/intr.c',
-    'src/util/log.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/str_util.c',
+    'src/tiny_xpm.c',
 ]
 
-conf = configuration_data()
-
-conf.set('_POSIX_C_SOURCE', '200809L')
-conf.set('_XOPEN_SOURCE', '700')
-conf.set('_GNU_SOURCE', true)
-
-if host_machine.system() == 'windows'
-    windows = import('windows')
-    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'
-if v4l2_support
-    src += [ 'src/v4l2_sink.c' ]
-endif
-
-usb_support = get_option('usb')
-if usb_support
-    src += [
-        'src/usb/aoa_hid.c',
-        'src/usb/hid_keyboard.c',
-        'src/usb/hid_mouse.c',
-        'src/usb/scrcpy_otg.c',
-        'src/usb/screen_otg.c',
-        'src/usb/usb.c',
-    ]
-endif
-
-cc = meson.get_compiler('c')
-
-crossbuild_windows = meson.is_cross_build() and host_machine.system() == 'windows'
-
-if not crossbuild_windows
+if not get_option('crossbuild_windows')
 
     # native build
     dependencies = [
-        dependency('libavformat', version: '>= 57.33'),
-        dependency('libavcodec', version: '>= 57.37'),
+        dependency('libavformat'),
+        dependency('libavcodec'),
         dependency('libavutil'),
-        dependency('sdl2', version: '>= 2.0.5'),
+        dependency('sdl2'),
     ]
 
-    if v4l2_support
-        dependencies += dependency('libavdevice')
-    endif
-
-    if usb_support
-        dependencies += dependency('libusb-1.0')
-    endif
-
 else
+
     # cross-compile mingw32 build (from Linux to Windows)
+    cc = meson.get_compiler('c')
+
     prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
-    sdl2_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_sdl2 + '/bin'
-    sdl2_lib_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_sdl2 + '/lib'
-    sdl2_include_dir = 'prebuilt-deps/data/' + prebuilt_sdl2 + '/include'
+    sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
+    sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/lib'
+    sdl2_include_dir = '../prebuilt-deps/' + prebuilt_sdl2 + '/include'
 
     sdl2 = declare_dependency(
         dependencies: [
@@ -124,66 +48,42 @@ else
         include_directories: include_directories(sdl2_include_dir)
     )
 
-    prebuilt_ffmpeg = meson.get_cross_property('prebuilt_ffmpeg')
-    ffmpeg_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_ffmpeg + '/bin'
-    ffmpeg_include_dir = 'prebuilt-deps/data/' + prebuilt_ffmpeg + '/include'
-
-    # ffmpeg versions are different for win32 and win64 builds
-    ffmpeg_avcodec = meson.get_cross_property('ffmpeg_avcodec')
-    ffmpeg_avformat = meson.get_cross_property('ffmpeg_avformat')
-    ffmpeg_avutil = meson.get_cross_property('ffmpeg_avutil')
-
+    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(ffmpeg_avcodec, dirs: ffmpeg_bin_dir),
-            cc.find_library(ffmpeg_avformat, dirs: ffmpeg_bin_dir),
-            cc.find_library(ffmpeg_avutil, dirs: ffmpeg_bin_dir),
+            cc.find_library('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)
     )
 
-    prebuilt_libusb = meson.get_cross_property('prebuilt_libusb')
-    prebuilt_libusb_root = meson.get_cross_property('prebuilt_libusb_root')
-    libusb_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_libusb
-    libusb_include_dir = 'prebuilt-deps/data/' + prebuilt_libusb_root + '/include'
-
-    libusb = declare_dependency(
-        dependencies: [
-            cc.find_library('msys-usb-1.0', dirs: libusb_bin_dir),
-        ],
-        include_directories: include_directories(libusb_include_dir)
-    )
-
     dependencies = [
         ffmpeg,
         sdl2,
-        libusb,
         cc.find_library('mingw32')
     ]
 
 endif
 
+cc = meson.get_compiler('c')
+
 if host_machine.system() == 'windows'
+    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 = [
-    'strdup',
-    'asprintf',
-    'vasprintf',
-    'nrand48',
-    'jrand48',
-]
+conf = configuration_data()
 
-foreach f : check_functions
-  if cc.has_function(f)
-    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'))
+# expose the build type
+conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')
 
 # the version, updated on release
 conf.set_quoted('SCRCPY_VERSION', meson.project_version())
@@ -191,127 +91,69 @@ 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
-# directory as the executable)
-conf.set('PORTABLE', get_option('portable'))
+# the path of the server, which will be appended to the prefix
+# ignored if OVERRIDE_SERVER_PATH if defined
+# must be consistent with the install_dir in server/meson.build
+conf.set_quoted('PREFIXED_SERVER_PATH', '/share/scrcpy/scrcpy-server.jar')
 
-# the default client TCP port range for the "adb reverse" tunnel
+# the path of the server to be used "as is"
+# this is useful for building a "portable" version (with the server in the same
+# directory as the client)
+override_server_path = get_option('override_server_path')
+if override_server_path != ''
+    conf.set_quoted('OVERRIDE_SERVER_PATH', override_server_path)
+else
+    # undefine it
+    conf.set('OVERRIDE_SERVER_PATH', false)
+endif
+
+# 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_RANGE_LAST', '27199')
+conf.set('DEFAULT_LOCAL_PORT', '27183')
+
+# the default max video size for both dimensions, in pixels
+# overridden by option --max-size
+conf.set('DEFAULT_MAX_SIZE', '0')  # 0: unlimited
 
 # the default video bitrate, in bits/second
 # overridden by option --bit-rate
 conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
 
-# run a server debugger and wait for a client to be attached
-conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
+# whether the app should always display the most recent available frame, even
+# if the previous one has not been displayed
+# SKIP_FRAMES improves latency at the cost of framerate
+conf.set('SKIP_FRAMES', get_option('skip_frames'))
 
-# select the debugger method ('old' for Android < 9, 'new' for Android >= 9)
-conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == 'new')
+# enable High DPI support
+conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
 
-# enable V4L2 support (linux only)
-conf.set('HAVE_V4L2', v4l2_support)
-
-# enable HID over AOA support (linux only)
-conf.set('HAVE_USB', usb_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')
 
-executable('scrcpy', src,
-           dependencies: dependencies,
-           include_directories: src_dir,
-           install: true,
-           c_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'))
+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, link_args: link_args)
+
 
 ### TESTS
 
-# do not build tests in release (assertions would not be executed at all)
-if get_option('buildtype') == 'debug'
-    tests = [
-        ['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', [
-            'tests/test_binary.c',
-        ]],
-        ['test_cbuf', [
-            'tests/test_cbuf.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_clock', [
-            'tests/test_clock.c',
-            'src/clock.c',
-        ]],
-        ['test_control_msg_serialize', [
-            'tests/test_control_msg_serialize.c',
-            'src/control_msg.c',
-            'src/util/str.c',
-            'src/util/strbuf.c',
-        ]],
-        ['test_device_msg_deserialize', [
-            'tests/test_device_msg_deserialize.c',
-            'src/device_msg.c',
-        ]],
-        ['test_queue', [
-            'tests/test_queue.c',
-        ]],
-        ['test_strbuf', [
-            'tests/test_strbuf.c',
-            'src/util/strbuf.c',
-        ]],
-        ['test_str', [
-            'tests/test_str.c',
-            'src/util/str.c',
-            'src/util/strbuf.c',
-        ]],
-        ['test_vector', [
-            'tests/test_vector.c',
-        ]],
-    ]
+tests = [
+    ['test_control_event_queue', ['tests/test_control_event_queue.c', 'src/control_event.c']],
+    ['test_control_event_serialize', ['tests/test_control_event_serialize.c', 'src/control_event.c']],
+    ['test_strutil', ['tests/test_strutil.c', 'src/str_util.c']],
+]
 
-    foreach t : tests
-        exe = executable(t[0], t[1],
-                         include_directories: src_dir,
-                         dependencies: dependencies,
-                         c_args: ['-DSDL_MAIN_HANDLED', '-DSC_TEST'])
-        test(t[0], exe)
-    endforeach
-endif
+foreach t : tests
+    exe = executable(t[0], t[1], include_directories: src_dir, dependencies: dependencies)
+    test(t[0], exe)
+endforeach

app/prebuilt-deps/.gitignore

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

app/prebuilt-deps/common

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

app/prebuilt-deps/prepare-adb.sh

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

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

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

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

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

app/prebuilt-deps/prepare-libusb.sh

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

app/prebuilt-deps/prepare-sdl.sh

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

app/scrcpy-windows.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>

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", "1.25"
-    END
-  END
-  BLOCK "VarFileInfo"
-  BEGIN
-    VALUE "Translation", 0x409, 1252
-  END
-END

app/scrcpy.1

@@ -1,532 +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 "\-b, \-\-bit\-rate " value
-Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
-
-Default is 8000000.
-
-.TP
-.BI "\-\-codec " name
-Select a video codec (h264, h265 or av1).
-
-.TP
-.BI "\-\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
-Set a list of comma-separated key:type=value options for the device encoder.
-
-The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
-
-The list of possible codec options is available in the Android documentation
-.UR https://d.android.com/reference/android/media/MediaFormat
-.UE .
-
-.TP
-.BI "\-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
-Crop the device screen on the server.
-
-The values are expressed in the device natural orientation (typically, portrait for a phone, landscape for a tablet). Any
-.B \-\-max\-size
-value is computed on the cropped size.
-
-.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
-Specify the display id to mirror.
-
-The list of possible display ids can be listed by "adb shell dumpsys display"
-(search "mDisplayId=" in the output).
-
-Default is 0.
-
-.TP
-.BI "\-\-display\-buffer ms
-Add a buffering delay (in milliseconds) before displaying. This increases latency to compensate for jitter.
-
-Default is 0 (no buffering).
-
-.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
-.BI "\-\-encoder " name
-Use a specific MediaCodec encoder (must be a H.264 encoder).
-
-.TP
-.B \-\-force\-adb\-forward
-Do not attempt to use "adb reverse" to connect to the device.
-
-.TP
-.B \-\-forward\-all\-clicks
-By default, right-click triggers BACK (or POWER on) and middle-click triggers HOME. This option disables these shortcuts and forward the clicks to the device instead.
-
-.TP
-.B \-f, \-\-fullscreen
-Start in fullscreen.
-
-.TP
-.B \-h, \-\-help
-Print this help.
-
-.TP
-.B \-K, \-\-hid\-keyboard
-Simulate a physical keyboard by using HID over AOAv2.
-
-This provides a better experience for IME users, and allows to generate non-ASCII characters, contrary to the default injection method.
-
-It may only work over USB.
-
-The keyboard layout must be configured (once and for all) on the device, via Settings -> System -> Languages and input -> Physical keyboard. This settings page can be started directly:
-
-    adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
-
-However, the option is only available when the HID keyboard is enabled (or a physical keyboard is connected).
-
-Also see \fB\-\-hid\-mouse\fR.
-
-.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
-\fB\-\-lock\-video\-orientation\fR[=\fIvalue\fR]
-Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees rotation counterclockwise.
-
-Default is "unlocked".
-
-Passing the option without argument is equivalent to passing "initial".
-
-.TP
-.BI "\-\-max\-fps " value
-Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
-
-.TP
-.BI "\-m, \-\-max\-size " value
-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, \-\-hid\-mouse
-Simulate a physical mouse by using HID over AOAv2.
-
-In this mode, the computer mouse is captured to control the device directly (relative mouse mode).
-
-LAlt, LSuper or RSuper toggle the capture mode, to give control of the mouse back to the computer.
-
-It may only work over USB.
-
-Also see \fB\-\-hid\-keyboard\fR.
-
-.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 \-n, \-\-no\-control
-Disable device control (mirror the device in read\-only).
-
-.TP
-.B \-N, \-\-no\-display
-Do not display device (only when screen recording is enabled).
-
-.TP
-.B \-\-no\-key\-repeat
-Do not forward repeated key events when a key is held down.
-
-.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\-power\-on
-Do not power on the device on start.
-
-.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\-\-hid\-keyboard\fR and \fB\-\-hid\-mouse\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
-.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
-.B \-\-raw\-key\-events
-Inject key events for all input keys, and ignore text events.
-
-.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 (.mp4 or .mkv).
-
-.TP
-.BI "\-\-record\-format " format
-Force recording format (either mp4 or mkv).
-
-.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".
-
-.UR https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER
-.UE
-
-.TP
-.BI "\-\-rotation " value
-Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each increment adds a 90 degrees rotation counterclockwise.
-
-.TP
-.BI "\-s, \-\-serial " number
-The device serial number. Mandatory only if several devices are connected to adb.
-
-.TP
-.BI "\-\-shortcut\-mod " key\fR[+...]][,...]
-Specify the modifiers to use for scrcpy shortcuts. Possible keys are "lctrl", "rctrl", "lalt", "ralt", "lsuper" and "rsuper".
-
-A shortcut can consist in several keys, separated by '+'. Several shortcuts can be specified, separated by ','.
-
-For example, to use either LCtrl+LAlt or LSuper for scrcpy shortcuts, pass "lctrl+lalt,lsuper".
-
-Default is "lalt,lsuper" (left-Alt or left-Super).
-
-.TP
-.BI "\-\-tcpip\fR[=\fIip\fR[:\fIport\fR]]
-Configure and reconnect 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.
-
-.TP
-.B \-S, \-\-turn\-screen\-off
-Turn the device screen off immediately.
-
-.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 "\-\-tunnel\-host " ip
-Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
-
-Default is localhost.
-
-.TP
-.BI "\-\-tunnel\-port " port
-Set the TCP port of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
-
-Default is 0 (not forced): the local port used for establishing the tunnel will be used.
-
-.TP
-.BI "\-\-v4l2-sink " /dev/videoN
-Output to v4l2loopback device.
-
-It requires to lock the video orientation (see \fB\-\-lock\-video\-orientation\fR).
-
-.TP
-.BI "\-\-v4l2-buffer " ms
-Add a buffering delay (in milliseconds) before pushing frames. This increases latency to compensate for jitter.
-
-This option is similar to \fB\-\-display\-buffer\fR, but specific to V4L2 sink.
-
-Default is 0 (no buffering).
-
-.TP
-.BI "\-V, \-\-verbosity " value
-Set the log level ("verbose", "debug", "info", "warn" or "error").
-
-Default is "info" for release builds, "debug" for debug builds.
-
-.TP
-.B \-v, \-\-version
-Print the version of scrcpy.
-
-.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+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+i
-Enable/disable FPS counter (print frames/second in logs)
-
-.TP
-.B Ctrl+click-and-move
-Pinch-to-zoom from the center of the screen
-
-.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 (-s, -d, -e or --tcpip=<addr>) 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
-.UR https://github.com/Genymobile/scrcpy/issues
-.UE .
-
-.SH COPYRIGHT
-Copyright \(co 2018 Genymobile
-.UR https://www.genymobile.com
-Genymobile
-.UE
-
-Copyright \(co 2018\-2022
-.MT rom@rom1v.com
-Romain Vimont
-.ME
-
-Licensed under the Apache License, Version 2.0.
-
-.SH WWW
-.UR https://github.com/Genymobile/scrcpy
-.UE

app/src/adb/adb.c

@@ -1,715 +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/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 const char *adb_executable;
-
-const char *
-sc_adb_get_executable(void) {
-    if (!adb_executable) {
-        adb_executable = getenv("ADB");
-        if (!adb_executable)
-            adb_executable = "adb";
-    }
-    return adb_executable;
-}
-
-// 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() {
-#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
-    sprintf(local, "tcp:%" PRIu16, local_port);
-    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
-
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "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
-    sprintf(local, "tcp:%" PRIu16, local_port);
-
-    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
-    sprintf(local, "tcp:%" PRIu16, local_port);
-    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
-    assert(serial);
-    const char *const argv[] =
-        SC_ADB_COMMAND("-s", serial, "reverse", remote, local);
-
-    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
-    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
-
-    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];
-    sprintf(port_string, "%" PRIu16, port);
-
-    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".
-    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);
-    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.");
-        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;
-    }
-
-    LOGD("ADB device found:");
-    sc_adb_devices_log(SC_LOG_LEVEL_DEBUG, vec.data, vec.size);
-
-    // Move devics into out_device (do not destroy device)
-    sc_adb_device_move(out_device, device);
-    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);
-}

app/src/adb/adb.h

@@ -1,117 +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)
-
-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);
-
-#endif

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;
-}

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

app/src/adb/adb_parser.c

@@ -1,227 +0,0 @@
-#include "adb_parser.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "util/log.h"
-#include "util/str.h"
-
-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");
-
-        // 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;
-        }
-
-        idx_line += len;
-
-        if (str[idx_line] != '\0') {
-            // The next line starts after the '\n'
-            ++idx_line;
-        }
-    }
-
-    return NULL;
-}

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

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;
-}

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

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

app/src/buffer_util.h

@@ -0,0 +1,28 @@
+#ifndef BUFFER_UTIL_H
+#define BUFFER_UTIL_H
+
+#include <SDL2/SDL_stdinc.h>
+
+static inline void buffer_write16be(Uint8 *buf, Uint16 value) {
+    buf[0] = value >> 8;
+    buf[1] = value;
+}
+
+static inline void buffer_write32be(Uint8 *buf, Uint32 value) {
+    buf[0] = value >> 24;
+    buf[1] = value >> 16;
+    buf[2] = value >> 8;
+    buf[3] = value;
+}
+
+static inline Uint32 buffer_read32be(Uint8 *buf) {
+    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+}
+
+static inline Uint64 buffer_read64be(Uint8 *buf) {
+    Uint32 msb = buffer_read32be(buf);
+    Uint32 lsb = buffer_read32be(&buf[4]);
+    return ((Uint64) msb << 32) | lsb;
+}
+
+#endif

app/src/cli.h

@@ -1,27 +0,0 @@
-#ifndef SCRCPY_CLI_H
-#define SCRCPY_CLI_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "options.h"
-
-struct scrcpy_cli_args {
-    struct scrcpy_options opts;
-    bool help;
-    bool version;
-};
-
-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, struct sc_shortcut_mods *mods);
-#endif
-
-#endif

app/src/clock.c

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

app/src/clock.h

@@ -1,70 +0,0 @@
-#ifndef SC_CLOCK_H
-#define SC_CLOCK_H
-
-#include "common.h"
-
-#include <assert.h>
-
-#include "util/tick.h"
-
-#define SC_CLOCK_RANGE 32
-static_assert(!(SC_CLOCK_RANGE & 1), "SC_CLOCK_RANGE must be even");
-
-struct sc_clock_point {
-    sc_tick system;
-    sc_tick stream;
-};
-
-/**
- * The clock aims to estimate the affine relation between the stream (device)
- * time and the system time:
- *
- *     f(stream) = slope * stream + offset
- *
- * To that end, it stores the SC_CLOCK_RANGE last clock points (the timestamps
- * of a frame expressed both in stream time and system time) in a circular
- * array.
- *
- * To estimate the slope, it splits the last SC_CLOCK_RANGE points into two
- * sets of SC_CLOCK_RANGE/2 points, and computes their centroid ("average
- * point"). The slope of the estimated affine function is that of the line
- * passing through these two points.
- *
- * To estimate the offset, it computes the centroid of all the SC_CLOCK_RANGE
- * points. The resulting affine function passes by this centroid.
- *
- * With a circular array, the rolling sums (and average) are quick to compute.
- * In practice, the estimation is stable and the evolution is smooth.
- */
-struct sc_clock {
-    // Circular array
-    struct sc_clock_point points[SC_CLOCK_RANGE];
-
-    // Number of points in the array (count <= SC_CLOCK_RANGE)
-    unsigned count;
-
-    // Index of the next point to write
-    unsigned head;
-
-    // Sum of the first count/2 points
-    struct sc_clock_point left_sum;
-
-    // Sum of the last (count+1)/2 points
-    struct sc_clock_point right_sum;
-
-    // Estimated slope and offset
-    // (computed on sc_clock_update(), used by sc_clock_to_system_time())
-    double slope;
-    sc_tick offset;
-};
-
-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

app/src/command.c

@@ -0,0 +1,153 @@
+#include "command.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.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;
+}
+
+static void show_adb_err_msg(enum process_result err) {
+    switch (err) {
+        case PROCESS_ERROR_GENERIC:
+            LOGE("Failed to execute adb");
+            break;
+        case PROCESS_ERROR_MISSING_BINARY:
+            LOGE("'adb' command not found (make it 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[], int 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);
+        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) {
+        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__
+    free((void *) remote);
+    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__
+    free((void *) local);
+#endif
+
+    return proc;
+}
+
+SDL_bool process_check_success(process_t proc, const char *name) {
+    if (proc == PROCESS_NONE) {
+        LOGE("Could not execute \"%s\"", name);
+        return SDL_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 SDL_FALSE;
+    }
+    return SDL_TRUE;
+}

app/src/command.h

@@ -0,0 +1,57 @@
+#ifndef COMMAND_H
+#define COMMAND_H
+
+#include <inttypes.h>
+#include <SDL2/SDL_stdinc.h>
+#include <SDL2/SDL_platform.h>
+
+// <https://stackoverflow.com/a/44383330/1987178>
+#ifdef _WIN32
+# define PRIexitcode "lu"
+# ifdef _WIN64
+#   define PRIsizet PRIu64
+# else
+#   define PRIsizet PRIu32
+# endif
+#else
+# define PRIsizet "zu"
+# define PRIexitcode "d"
+#endif
+
+#ifdef __WINDOWS__
+# include <winsock2.h> // not needed here, but must never be included AFTER windows.h
+# include <windows.h>
+# define PROCESS_NONE NULL
+  typedef HANDLE process_t;
+  typedef DWORD exit_code_t;
+#else
+# include <sys/types.h>
+# define PROCESS_NONE -1
+  typedef pid_t process_t;
+  typedef int exit_code_t;
+#endif
+# 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);
+SDL_bool cmd_terminate(process_t pid);
+SDL_bool cmd_simple_wait(process_t pid, exit_code_t *exit_code);
+
+process_t adb_execute(const char *serial, const char *const adb_cmd[], int 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
+SDL_bool process_check_success(process_t process, const char *name);
+
+#endif

app/src/common.h

@@ -1,15 +1,27 @@
-#ifndef SC_COMMON_H
-#define SC_COMMON_H
+#ifndef COMMON_H
+#define COMMON_H
 
-#include "config.h"
-#include "compat.h"
+#include <SDL2/SDL_stdinc.h>
 
 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
 #define MIN(X,Y) (X) < (Y) ? (X) : (Y)
 #define MAX(X,Y) (X) > (Y) ? (X) : (Y)
-#define CLAMP(V,X,Y) MIN( MAX((V),(X)), (Y) )
 
-#define container_of(ptr, type, member) \
-    ((type *) (((char *) (ptr)) - offsetof(type, member)))
+struct size {
+    Uint16 width;
+    Uint16 height;
+};
+
+struct point {
+    Sint32 x;
+    Sint32 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

app/src/compat.c

@@ -1,97 +0,0 @@
-#include "compat.h"
-
-#include "config.h"
-
-#include <assert.h>
-#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

app/src/compat.h

@@ -1,70 +0,0 @@
-#ifndef SC_COMPAT_H
-#define SC_COMPAT_H
-
-#include "config.h"
-
-#include <libavformat/version.h>
-#include <SDL2/SDL_version.h>
-
-#ifndef __WIN32
-# define PRIu64_ PRIu64
-# define SC_PRIsizet "zu"
-#else
-# define PRIu64_ "I64u"  // Windows...
-# define SC_PRIsizet "Iu"
-#endif
-
-// In ffmpeg/doc/APIchanges:
-// 2018-02-06 - 0694d87024 - lavf 58.9.100 - avformat.h
-//   Deprecate use of av_register_input_format(), av_register_output_format(),
-//   av_register_all(), av_iformat_next(), av_oformat_next().
-//   Add av_demuxer_iterate(), and av_muxer_iterate().
-#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 9, 100)
-# define SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
-#else
-# define SCRCPY_LAVF_REQUIRES_REGISTER_ALL
-#endif
-
-
-// In ffmpeg/doc/APIchanges:
-// 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
-//   Deprecate AVFormatContext filename field which had limited length, use the
-//   new dynamically allocated url field instead.
-//
-// 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
-//   Add url field to AVFormatContext and add ff_format_set_url helper function.
-#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 7, 100)
-# define SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
-#endif
-
-#if SDL_VERSION_ATLEAST(2, 0, 6)
-// <https://github.com/libsdl-org/SDL/commit/d7a318de563125e5bb465b1000d6bc9576fbc6fc>
-# define SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
-#endif
-
-#if SDL_VERSION_ATLEAST(2, 0, 8)
-// <https://hg.libsdl.org/SDL/rev/dfde5d3f9781>
-# define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
-#endif
-
-#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
-
-#endif

app/src/control_event.c

@@ -0,0 +1,100 @@
+#include "control_event.h"
+
+#include <SDL2/SDL_stdinc.h>
+#include <string.h>
+
+#include "buffer_util.h"
+#include "lock_util.h"
+#include "log.h"
+
+static void write_position(Uint8 *buf, const struct position *position) {
+    buffer_write32be(&buf[0], position->point.x);
+    buffer_write32be(&buf[4], position->point.y);
+    buffer_write16be(&buf[8], position->screen_size.width);
+    buffer_write16be(&buf[10], position->screen_size.height);
+}
+
+int control_event_serialize(const struct control_event *event, unsigned char *buf) {
+    buf[0] = event->type;
+    switch (event->type) {
+        case CONTROL_EVENT_TYPE_KEYCODE:
+            buf[1] = event->keycode_event.action;
+            buffer_write32be(&buf[2], event->keycode_event.keycode);
+            buffer_write32be(&buf[6], event->keycode_event.metastate);
+            return 10;
+        case CONTROL_EVENT_TYPE_TEXT: {
+            // write length (2 bytes) + string (non nul-terminated)
+            size_t len = strlen(event->text_event.text);
+            if (len > TEXT_MAX_LENGTH) {
+                // injecting a text takes time, so limit the text length
+                len = TEXT_MAX_LENGTH;
+            }
+            buffer_write16be(&buf[1], (Uint16) len);
+            memcpy(&buf[3], event->text_event.text, len);
+            return 3 + len;
+        }
+        case CONTROL_EVENT_TYPE_MOUSE:
+            buf[1] = event->mouse_event.action;
+            buffer_write32be(&buf[2], event->mouse_event.buttons);
+            write_position(&buf[6], &event->mouse_event.position);
+            return 18;
+        case CONTROL_EVENT_TYPE_SCROLL:
+            write_position(&buf[1], &event->scroll_event.position);
+            buffer_write32be(&buf[13], (Uint32) event->scroll_event.hscroll);
+            buffer_write32be(&buf[17], (Uint32) event->scroll_event.vscroll);
+            return 21;
+        case CONTROL_EVENT_TYPE_COMMAND:
+            buf[1] = event->command_event.action;
+            return 2;
+        default:
+            LOGW("Unknown event type: %u", (unsigned) event->type);
+            return 0;
+    }
+}
+
+void control_event_destroy(struct control_event *event) {
+    if (event->type == CONTROL_EVENT_TYPE_TEXT) {
+        SDL_free(event->text_event.text);
+    }
+}
+
+SDL_bool control_event_queue_is_empty(const struct control_event_queue *queue) {
+    return queue->head == queue->tail;
+}
+
+SDL_bool control_event_queue_is_full(const struct control_event_queue *queue) {
+    return (queue->head + 1) % CONTROL_EVENT_QUEUE_SIZE == queue->tail;
+}
+
+SDL_bool control_event_queue_init(struct control_event_queue *queue) {
+    queue->head = 0;
+    queue->tail = 0;
+    // the current implementation may not fail
+    return SDL_TRUE;
+}
+
+void control_event_queue_destroy(struct control_event_queue *queue) {
+    int i = queue->tail;
+    while (i != queue->head) {
+        control_event_destroy(&queue->data[i]);
+        i = (i + 1) % CONTROL_EVENT_QUEUE_SIZE;
+    }
+}
+
+SDL_bool control_event_queue_push(struct control_event_queue *queue, const struct control_event *event) {
+    if (control_event_queue_is_full(queue)) {
+        return SDL_FALSE;
+    }
+    queue->data[queue->head] = *event;
+    queue->head = (queue->head + 1) % CONTROL_EVENT_QUEUE_SIZE;
+    return SDL_TRUE;
+}
+
+SDL_bool control_event_queue_take(struct control_event_queue *queue, struct control_event *event) {
+    if (control_event_queue_is_empty(queue)) {
+        return SDL_FALSE;
+    }
+    *event = queue->data[queue->tail];
+    queue->tail = (queue->tail + 1) % CONTROL_EVENT_QUEUE_SIZE;
+    return SDL_TRUE;
+}

app/src/control_event.h

@@ -0,0 +1,73 @@
+#ifndef CONTROLEVENT_H
+#define CONTROLEVENT_H
+
+#include <SDL2/SDL_mutex.h>
+#include <SDL2/SDL_stdinc.h>
+
+#include "android/input.h"
+#include "android/keycodes.h"
+#include "common.h"
+
+#define CONTROL_EVENT_QUEUE_SIZE 64
+#define TEXT_MAX_LENGTH 300
+#define SERIALIZED_EVENT_MAX_SIZE 3 + TEXT_MAX_LENGTH
+
+enum control_event_type {
+    CONTROL_EVENT_TYPE_KEYCODE,
+    CONTROL_EVENT_TYPE_TEXT,
+    CONTROL_EVENT_TYPE_MOUSE,
+    CONTROL_EVENT_TYPE_SCROLL,
+    CONTROL_EVENT_TYPE_COMMAND,
+};
+
+#define CONTROL_EVENT_COMMAND_BACK_OR_SCREEN_ON 0
+
+struct control_event {
+    enum control_event_type type;
+    union {
+        struct {
+            enum android_keyevent_action action;
+            enum android_keycode keycode;
+            enum android_metastate metastate;
+        } keycode_event;
+        struct {
+            char *text; // owned, to be freed by SDL_free()
+        } text_event;
+        struct {
+            enum android_motionevent_action action;
+            enum android_motionevent_buttons buttons;
+            struct position position;
+        } mouse_event;
+        struct {
+            struct position position;
+            Sint32 hscroll;
+            Sint32 vscroll;
+        } scroll_event;
+        struct {
+            int action;
+        } command_event;
+    };
+};
+
+struct control_event_queue {
+    struct control_event data[CONTROL_EVENT_QUEUE_SIZE];
+    int head;
+    int tail;
+};
+
+// buf size must be at least SERIALIZED_EVENT_MAX_SIZE
+int control_event_serialize(const struct control_event *event, unsigned char *buf);
+
+SDL_bool control_event_queue_init(struct control_event_queue *queue);
+void control_event_queue_destroy(struct control_event_queue *queue);
+
+SDL_bool control_event_queue_is_empty(const struct control_event_queue *queue);
+SDL_bool control_event_queue_is_full(const struct control_event_queue *queue);
+
+// event is copied, the queue does not use the event after the function returns
+SDL_bool control_event_queue_push(struct control_event_queue *queue, const struct control_event *event);
+SDL_bool control_event_queue_take(struct control_event_queue *queue, struct control_event *event);
+
+void control_event_destroy(struct control_event *event);
+
+#endif

app/src/control_msg.c

@@ -1,264 +0,0 @@
-#include "control_msg.h"
-
-#include <assert.h>
-#include <inttypes.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "util/binary.h"
-#include "util/log.h"
-#include "util/str.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)
-
-#define SCREEN_POWER_MODE_LABEL(value) \
-    ENUM_TO_LABEL(screen_power_mode_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 screen_power_mode_labels[] = {
-    "off",
-    "doze",
-    "normal",
-    "doze-suspend",
-    "suspend",
-};
-
-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 POINTER_ID_MOUSE:
-            return "mouse";
-        case POINTER_ID_GENERIC_FINGER:
-            return "finger";
-        case POINTER_ID_VIRTUAL_MOUSE:
-            return "vmouse";
-        case POINTER_ID_VIRTUAL_FINGER:
-            return "vfinger";
-        default:
-            return NULL;
-    }
-}
-
-static void
-write_position(uint8_t *buf, const struct sc_position *position) {
-    sc_write32be(&buf[0], position->point.x);
-    sc_write32be(&buf[4], position->point.y);
-    sc_write16be(&buf[8], position->screen_size.width);
-    sc_write16be(&buf[10], position->screen_size.height);
-}
-
-// write length (4 bytes) + string (non null-terminated)
-static size_t
-write_string(const char *utf8, size_t max_len, unsigned char *buf) {
-    size_t len = sc_str_utf8_truncation_index(utf8, max_len);
-    sc_write32be(buf, len);
-    memcpy(&buf[4], utf8, len);
-    return 4 + len;
-}
-
-size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
-    buf[0] = msg->type;
-    switch (msg->type) {
-        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
-            buf[1] = msg->inject_keycode.action;
-            sc_write32be(&buf[2], msg->inject_keycode.keycode);
-            sc_write32be(&buf[6], msg->inject_keycode.repeat);
-            sc_write32be(&buf[10], msg->inject_keycode.metastate);
-            return 14;
-        case SC_CONTROL_MSG_TYPE_INJECT_TEXT: {
-            size_t len =
-                write_string(msg->inject_text.text,
-                             SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
-            return 1 + len;
-        }
-        case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
-            buf[1] = msg->inject_touch_event.action;
-            sc_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);
-            sc_write16be(&buf[22], pressure);
-            sc_write32be(&buf[24], msg->inject_touch_event.action_button);
-            sc_write32be(&buf[28], msg->inject_touch_event.buttons);
-            return 32;
-        case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
-            write_position(&buf[1], &msg->inject_scroll_event.position);
-            int16_t hscroll =
-                sc_float_to_i16fp(msg->inject_scroll_event.hscroll);
-            int16_t vscroll =
-                sc_float_to_i16fp(msg->inject_scroll_event.vscroll);
-            sc_write16be(&buf[13], (uint16_t) hscroll);
-            sc_write16be(&buf[15], (uint16_t) vscroll);
-            sc_write32be(&buf[17], msg->inject_scroll_event.buttons);
-            return 21;
-        case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
-            buf[1] = msg->inject_keycode.action;
-            return 2;
-        case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
-            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(msg->set_clipboard.text,
-                                      SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-                                      &buf[10]);
-            return 10 + len;
-        case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
-            buf[1] = msg->set_screen_power_mode.mode;
-            return 2;
-        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-        case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
-        case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
-        case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
-            // no additional data
-            return 1;
-        default:
-            LOGW("Unknown message type: %u", (unsigned) msg->type);
-            return 0;
-    }
-}
-
-void
-sc_control_msg_log(const struct sc_control_msg *msg) {
-#define LOG_CMSG(fmt, ...) LOGV("input: " fmt, ## __VA_ARGS__)
-    switch (msg->type) {
-        case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
-            LOG_CMSG("key %-4s code=%d repeat=%" PRIu32 " meta=%06lx",
-                     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:
-            LOG_CMSG("text \"%s\"", msg->inject_text.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_SCREEN_POWER_MODE:
-            LOG_CMSG("power mode %s",
-                     SCREEN_POWER_MODE_LABEL(msg->set_screen_power_mode.mode));
-            break;
-        case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-            LOG_CMSG("expand notification panel");
-            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;
-        default:
-            LOG_CMSG("unknown type: %u", (unsigned) msg->type);
-            break;
-    }
-}
-
-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;
-        default:
-            // do nothing
-            break;
-    }
-}

app/src/control_msg.h

@@ -1,109 +0,0 @@
-#ifndef SC_CONTROLMSG_H
-#define SC_CONTROLMSG_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "android/input.h"
-#include "android/keycodes.h"
-#include "coords.h"
-
-#define SC_CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
-
-#define SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
-// 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 POINTER_ID_MOUSE UINT64_C(-1)
-#define POINTER_ID_GENERIC_FINGER UINT64_C(-2)
-
-// Used for injecting an additional virtual pointer for pinch-to-zoom
-#define POINTER_ID_VIRTUAL_MOUSE UINT64_C(-3)
-#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-4)
-
-enum sc_control_msg_type {
-    SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
-    SC_CONTROL_MSG_TYPE_INJECT_TEXT,
-    SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-    SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
-    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_SCREEN_POWER_MODE,
-    SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
-};
-
-enum sc_screen_power_mode {
-    // see <https://android.googlesource.com/platform/frameworks/base.git/+/pie-release-2/core/java/android/view/SurfaceControl.java#305>
-    SC_SCREEN_POWER_MODE_OFF = 0,
-    SC_SCREEN_POWER_MODE_NORMAL = 2,
-};
-
-enum sc_copy_key {
-    SC_COPY_KEY_NONE,
-    SC_COPY_KEY_COPY,
-    SC_COPY_KEY_CUT,
-};
-
-struct sc_control_msg {
-    enum sc_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()
-        } 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;
-            float pressure;
-        } inject_touch_event;
-        struct {
-            struct sc_position position;
-            float hscroll;
-            float vscroll;
-            enum android_motionevent_buttons buttons;
-        } inject_scroll_event;
-        struct {
-            enum android_keyevent_action action; // action for the BACK key
-            // 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 {
-            enum sc_screen_power_mode mode;
-        } set_screen_power_mode;
-    };
-};
-
-// buf size must be at least CONTROL_MSG_MAX_SIZE
-// return the number of bytes written
-size_t
-sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf);
-
-void
-sc_control_msg_log(const struct sc_control_msg *msg);
-
-void
-sc_control_msg_destroy(struct sc_control_msg *msg);
-
-#endif

app/src/controller.c

@@ -1,141 +1,105 @@
 #include "controller.h"
 
-#include <assert.h>
+#include <SDL2/SDL_assert.h>
+#include "config.h"
+#include "lock_util.h"
+#include "log.h"
 
-#include "util/log.h"
-
-bool
-sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
-                   struct sc_acksync *acksync) {
-    cbuf_init(&controller->queue);
-
-    bool ok = receiver_init(&controller->receiver, control_socket, acksync);
-    if (!ok) {
-        return false;
+SDL_bool controller_init(struct controller *controller, socket_t video_socket) {
+    if (!control_event_queue_init(&controller->queue)) {
+        return SDL_FALSE;
     }
 
-    ok = sc_mutex_init(&controller->mutex);
-    if (!ok) {
-        receiver_destroy(&controller->receiver);
-        return false;
+    if (!(controller->mutex = SDL_CreateMutex())) {
+        return SDL_FALSE;
     }
 
-    ok = sc_cond_init(&controller->msg_cond);
-    if (!ok) {
-        receiver_destroy(&controller->receiver);
-        sc_mutex_destroy(&controller->mutex);
-        return false;
+    if (!(controller->event_cond = SDL_CreateCond())) {
+        SDL_DestroyMutex(controller->mutex);
+        return SDL_FALSE;
     }
 
-    controller->control_socket = control_socket;
-    controller->stopped = false;
+    controller->video_socket = video_socket;
+    controller->stopped = SDL_FALSE;
 
-    return true;
+    return SDL_TRUE;
 }
 
-void
-sc_controller_destroy(struct sc_controller *controller) {
-    sc_cond_destroy(&controller->msg_cond);
-    sc_mutex_destroy(&controller->mutex);
-
-    struct sc_control_msg msg;
-    while (cbuf_take(&controller->queue, &msg)) {
-        sc_control_msg_destroy(&msg);
-    }
-
-    receiver_destroy(&controller->receiver);
+void controller_destroy(struct controller *controller) {
+    SDL_DestroyCond(controller->event_cond);
+    SDL_DestroyMutex(controller->mutex);
+    control_event_queue_destroy(&controller->queue);
 }
 
-bool
-sc_controller_push_msg(struct sc_controller *controller,
-                       const struct sc_control_msg *msg) {
-    if (sc_get_log_level() <= SC_LOG_LEVEL_VERBOSE) {
-        sc_control_msg_log(msg);
-    }
-
-    sc_mutex_lock(&controller->mutex);
-    bool was_empty = cbuf_is_empty(&controller->queue);
-    bool res = cbuf_push(&controller->queue, *msg);
+SDL_bool controller_push_event(struct controller *controller, const struct control_event *event) {
+    SDL_bool res;
+    mutex_lock(controller->mutex);
+    SDL_bool was_empty = control_event_queue_is_empty(&controller->queue);
+    res = control_event_queue_push(&controller->queue, event);
     if (was_empty) {
-        sc_cond_signal(&controller->msg_cond);
+        cond_signal(controller->event_cond);
     }
-    sc_mutex_unlock(&controller->mutex);
+    mutex_unlock(controller->mutex);
     return res;
 }
 
-static bool
-process_msg(struct sc_controller *controller,
-            const struct sc_control_msg *msg) {
-    static unsigned char serialized_msg[SC_CONTROL_MSG_MAX_SIZE];
-    size_t length = sc_control_msg_serialize(msg, serialized_msg);
+static SDL_bool process_event(struct controller *controller, const struct control_event *event) {
+    unsigned char serialized_event[SERIALIZED_EVENT_MAX_SIZE];
+    int length = control_event_serialize(event, serialized_event);
     if (!length) {
-        return false;
+        return SDL_FALSE;
     }
-    ssize_t w =
-        net_send_all(controller->control_socket, serialized_msg, length);
-    return (size_t) w == length;
+    int w = net_send_all(controller->video_socket, serialized_event, length);
+    return w == length;
 }
 
-static int
-run_controller(void *data) {
-    struct sc_controller *controller = data;
+static int run_controller(void *data) {
+    struct controller *controller = data;
 
     for (;;) {
-        sc_mutex_lock(&controller->mutex);
-        while (!controller->stopped && cbuf_is_empty(&controller->queue)) {
-            sc_cond_wait(&controller->msg_cond, &controller->mutex);
+        mutex_lock(controller->mutex);
+        while (!controller->stopped && control_event_queue_is_empty(&controller->queue)) {
+            cond_wait(controller->event_cond, controller->mutex);
         }
         if (controller->stopped) {
-            // stop immediately, do not process further msgs
-            sc_mutex_unlock(&controller->mutex);
+            // stop immediately, do not process further events
+            mutex_unlock(controller->mutex);
             break;
         }
-        struct sc_control_msg msg;
-        bool non_empty = cbuf_take(&controller->queue, &msg);
-        assert(non_empty);
-        (void) non_empty;
-        sc_mutex_unlock(&controller->mutex);
+        struct control_event event;
+        SDL_bool non_empty = control_event_queue_take(&controller->queue, &event);
+        SDL_assert(non_empty);
+        mutex_unlock(controller->mutex);
 
-        bool ok = process_msg(controller, &msg);
-        sc_control_msg_destroy(&msg);
+        SDL_bool ok = process_event(controller, &event);
+        control_event_destroy(&event);
         if (!ok) {
-            LOGD("Could not write msg to socket");
+            LOGD("Cannot write event to socket");
             break;
         }
     }
     return 0;
 }
 
-bool
-sc_controller_start(struct sc_controller *controller) {
+SDL_bool controller_start(struct controller *controller) {
     LOGD("Starting controller thread");
 
-    bool ok = sc_thread_create(&controller->thread, run_controller,
-                               "scrcpy-ctl", controller);
-    if (!ok) {
-        LOGE("Could not start controller thread");
-        return false;
+    controller->thread = SDL_CreateThread(run_controller, "controller", controller);
+    if (!controller->thread) {
+        LOGC("Could not start controller thread");
+        return SDL_FALSE;
     }
 
-    if (!receiver_start(&controller->receiver)) {
-        sc_controller_stop(controller);
-        sc_thread_join(&controller->thread, NULL);
-        return false;
-    }
-
-    return true;
+    return SDL_TRUE;
 }
 
-void
-sc_controller_stop(struct sc_controller *controller) {
-    sc_mutex_lock(&controller->mutex);
-    controller->stopped = true;
-    sc_cond_signal(&controller->msg_cond);
-    sc_mutex_unlock(&controller->mutex);
+void controller_stop(struct controller *controller) {
+    mutex_lock(controller->mutex);
+    controller->stopped = SDL_TRUE;
+    cond_signal(controller->event_cond);
+    mutex_unlock(controller->mutex);
 }
 
-void
-sc_controller_join(struct sc_controller *controller) {
-    sc_thread_join(&controller->thread, NULL);
-    receiver_join(&controller->receiver);
+void controller_join(struct controller *controller) {
+    SDL_WaitThread(controller->thread, NULL);
 }

app/src/controller.h

@@ -1,47 +1,31 @@
-#ifndef SC_CONTROLLER_H
-#define SC_CONTROLLER_H
+#ifndef CONTROL_H
+#define CONTROL_H
 
-#include "common.h"
+#include "control_event.h"
 
-#include <stdbool.h>
+#include <SDL2/SDL_mutex.h>
+#include <SDL2/SDL_stdinc.h>
+#include <SDL2/SDL_thread.h>
 
-#include "control_msg.h"
-#include "receiver.h"
-#include "util/acksync.h"
-#include "util/cbuf.h"
-#include "util/net.h"
-#include "util/thread.h"
+#include "net.h"
 
-struct sc_control_msg_queue CBUF(struct sc_control_msg, 64);
-
-struct sc_controller {
-    sc_socket control_socket;
-    sc_thread thread;
-    sc_mutex mutex;
-    sc_cond msg_cond;
-    bool stopped;
-    struct sc_control_msg_queue queue;
-    struct receiver receiver;
+struct controller {
+    socket_t video_socket;
+    SDL_Thread *thread;
+    SDL_mutex *mutex;
+    SDL_cond *event_cond;
+    SDL_bool stopped;
+    struct control_event_queue queue;
 };
 
-bool
-sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
-                   struct sc_acksync *acksync);
+SDL_bool controller_init(struct controller *controller, socket_t video_socket);
+void controller_destroy(struct controller *controller);
 
-void
-sc_controller_destroy(struct sc_controller *controller);
+SDL_bool controller_start(struct controller *controller);
+void controller_stop(struct controller *controller);
+void controller_join(struct controller *controller);
 
-bool
-sc_controller_start(struct sc_controller *controller);
-
-void
-sc_controller_stop(struct sc_controller *controller);
-
-void
-sc_controller_join(struct sc_controller *controller);
-
-bool
-sc_controller_push_msg(struct sc_controller *controller,
-                       const struct sc_control_msg *msg);
+// expose simple API to hide control_event_queue
+SDL_bool controller_push_event(struct controller *controller, const struct control_event *event);
 
 #endif

app/src/convert.c

@@ -0,0 +1,217 @@
+#include "convert.h"
+
+#define MAP(FROM, TO) case FROM: *to = TO; return SDL_TRUE
+#define FAIL default: return SDL_FALSE
+
+static SDL_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;
+}
+
+
+static 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);
+}
+
+static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to, Uint16 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_HOME,         AKEYCODE_HOME);
+        MAP(SDLK_PAGEUP,       AKEYCODE_PAGE_UP);
+        MAP(SDLK_DELETE,       AKEYCODE_FORWARD_DEL);
+        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 SDL_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;
+    }
+}
+
+static SDL_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;
+    }
+}
+
+static enum android_motionevent_buttons convert_mouse_buttons(Uint32 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;
+}
+
+SDL_bool input_key_from_sdl_to_android(const SDL_KeyboardEvent *from,
+                                       struct control_event *to) {
+    to->type = CONTROL_EVENT_TYPE_KEYCODE;
+
+    if (!convert_keycode_action(from->type, &to->keycode_event.action)) {
+        return SDL_FALSE;
+    }
+
+    Uint16 mod = from->keysym.mod;
+    if (!convert_keycode(from->keysym.sym, &to->keycode_event.keycode, mod)) {
+        return SDL_FALSE;
+    }
+
+    to->keycode_event.metastate = convert_meta_state(mod);
+
+    return SDL_TRUE;
+}
+
+SDL_bool mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from,
+                                          struct size screen_size,
+                                          struct control_event *to) {
+    to->type = CONTROL_EVENT_TYPE_MOUSE;
+
+    if (!convert_mouse_action(from->type, &to->mouse_event.action)) {
+        return SDL_FALSE;
+    }
+
+    to->mouse_event.buttons = convert_mouse_buttons(SDL_BUTTON(from->button));
+    to->mouse_event.position.screen_size = screen_size;
+    to->mouse_event.position.point.x = from->x;
+    to->mouse_event.position.point.y = from->y;
+
+    return SDL_TRUE;
+}
+
+SDL_bool mouse_motion_from_sdl_to_android(const SDL_MouseMotionEvent *from,
+                                          struct size screen_size,
+                                          struct control_event *to) {
+    to->type = CONTROL_EVENT_TYPE_MOUSE;
+    to->mouse_event.action = AMOTION_EVENT_ACTION_MOVE;
+    to->mouse_event.buttons = convert_mouse_buttons(from->state);
+    to->mouse_event.position.screen_size = screen_size;
+    to->mouse_event.position.point.x = from->x;
+    to->mouse_event.position.point.y = from->y;
+
+    return SDL_TRUE;
+}
+
+SDL_bool mouse_wheel_from_sdl_to_android(const SDL_MouseWheelEvent *from,
+                                         struct position position,
+                                         struct control_event *to) {
+    to->type = CONTROL_EVENT_TYPE_SCROLL;
+
+    to->scroll_event.position = position;
+
+    int mul = from->direction == SDL_MOUSEWHEEL_NORMAL ? 1 : -1;
+    // SDL behavior seems inconsistent between horizontal and vertical scrolling
+    // so reverse the horizontal
+    // <https://wiki.libsdl.org/SDL_MouseWheelEvent#Remarks>
+    to->scroll_event.hscroll = -mul * from->x;
+    to->scroll_event.vscroll = mul * from->y;
+
+    return SDL_TRUE;
+}

app/src/convert.h

@@ -0,0 +1,35 @@
+#ifndef CONVERT_H
+#define CONVERT_H
+
+#include <SDL2/SDL_stdinc.h>
+#include <SDL2/SDL_events.h>
+#include "control_event.h"
+
+struct complete_mouse_motion_event {
+    SDL_MouseMotionEvent *mouse_motion_event;
+    struct size screen_size;
+};
+
+struct complete_mouse_wheel_event {
+    SDL_MouseWheelEvent *mouse_wheel_event;
+    struct point position;
+};
+
+SDL_bool input_key_from_sdl_to_android(const SDL_KeyboardEvent *from,
+                                       struct control_event *to);
+SDL_bool mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from,
+                                          struct size screen_size,
+                                          struct control_event *to);
+
+// the video size may be different from the real device size, so we need the size
+// to which the absolute position apply, to scale it accordingly
+SDL_bool mouse_motion_from_sdl_to_android(const SDL_MouseMotionEvent *from,
+                                          struct size screen_size,
+                                          struct control_event *to);
+
+// on Android, a scroll event requires the current mouse position
+SDL_bool mouse_wheel_from_sdl_to_android(const SDL_MouseWheelEvent *from,
+                                         struct position position,
+                                         struct control_event *to);
+
+#endif

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

app/src/decoder.c

@@ -1,164 +1,324 @@
 #include "decoder.h"
 
-#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.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 "buffer_util.h"
 #include "events.h"
-#include "video_buffer.h"
-#include "trait/frame_sink.h"
-#include "util/log.h"
+#include "frames.h"
+#include "lock_util.h"
+#include "log.h"
+#include "recorder.h"
 
-/** Downcast packet_sink to decoder */
-#define DOWNCAST(SINK) container_of(SINK, struct sc_decoder, packet_sink)
+#define BUFSIZE 0x10000
 
-static void
-sc_decoder_close_first_sinks(struct sc_decoder *decoder, unsigned count) {
-    while (count) {
-        struct sc_frame_sink *sink = decoder->sinks[--count];
-        sink->ops->close(sink);
+#define HEADER_SIZE 12
+#define NO_PTS UINT64_C(-1)
+
+static struct frame_meta *frame_meta_new(uint64_t pts) {
+    struct frame_meta *meta = malloc(sizeof(*meta));
+    if (!meta) {
+        return meta;
     }
+    meta->pts = pts;
+    meta->next = NULL;
+    return meta;
 }
 
-static inline void
-sc_decoder_close_sinks(struct sc_decoder *decoder) {
-    sc_decoder_close_first_sinks(decoder, decoder->sink_count);
+static void frame_meta_delete(struct frame_meta *frame_meta) {
+    free(frame_meta);
 }
 
-static bool
-sc_decoder_open_sinks(struct sc_decoder *decoder) {
-    for (unsigned i = 0; i < decoder->sink_count; ++i) {
-        struct sc_frame_sink *sink = decoder->sinks[i];
-        if (!sink->ops->open(sink)) {
-            LOGE("Could not open frame sink %d", i);
-            sc_decoder_close_first_sinks(decoder, i);
-            return false;
+static SDL_bool receiver_state_push_meta(struct receiver_state *state,
+                                         uint64_t pts) {
+    struct frame_meta *frame_meta = frame_meta_new(pts);
+    if (!frame_meta) {
+        return SDL_FALSE;
+    }
+
+    // append to the list
+    // (iterate to find the last item, in practice the list should be tiny)
+    struct frame_meta **p = &state->frame_meta_queue;
+    while (*p) {
+        p = &(*p)->next;
+    }
+    *p = frame_meta;
+    return SDL_TRUE;
+}
+
+static uint64_t receiver_state_take_meta(struct receiver_state *state) {
+    struct frame_meta *frame_meta = state->frame_meta_queue; // first item
+    SDL_assert(frame_meta); // must not be empty
+    uint64_t pts = frame_meta->pts;
+    state->frame_meta_queue = frame_meta->next; // remove the item
+    frame_meta_delete(frame_meta);
+    return pts;
+}
+
+static int read_packet_with_meta(void *opaque, uint8_t *buf, int buf_size) {
+    struct decoder *decoder = opaque;
+    struct receiver_state *state = &decoder->receiver_state;
+
+    // The video stream contains raw packets, without time information. When we
+    // record, we retrieve the timestamps separately, from a "meta" header
+    // added by the server before each raw packet.
+    //
+    // The "meta" header length is 12 bytes:
+    // [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
+    //  <-------------> <-----> <-----------------------------...
+    //        PTS        packet        raw packet
+    //                    size
+    //
+    // It is followed by <packet_size> bytes containing the packet/frame.
+
+    if (!state->remaining) {
+#define HEADER_SIZE 12
+        uint8_t header[HEADER_SIZE];
+        ssize_t r = net_recv_all(decoder->video_socket, header, HEADER_SIZE);
+        if (r == -1) {
+            return AVERROR(errno);
+        }
+        if (r == 0) {
+            return AVERROR_EOF;
+        }
+        // no partial read (net_recv_all())
+        SDL_assert_release(r == HEADER_SIZE);
+
+        uint64_t pts = buffer_read64be(header);
+        state->remaining = buffer_read32be(&header[8]);
+
+        if (pts != NO_PTS && !receiver_state_push_meta(state, pts)) {
+            LOGE("Could not store PTS for recording");
+            // we cannot save the PTS, the recording would be broken
+            return AVERROR(ENOMEM);
         }
     }
 
-    return true;
-}
+    SDL_assert(state->remaining);
 
-static bool
-sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
-    decoder->codec_ctx = avcodec_alloc_context3(codec);
-    if (!decoder->codec_ctx) {
-        LOG_OOM();
-        return false;
+    if (buf_size > state->remaining)
+        buf_size = state->remaining;
+
+    ssize_t r = net_recv(decoder->video_socket, buf, buf_size);
+    if (r == -1) {
+        return AVERROR(errno);
+    }
+    if (r == 0) {
+        return AVERROR_EOF;
     }
 
-    decoder->codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;
+    SDL_assert(state->remaining >= r);
+    state->remaining -= r;
 
-    if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
-        LOGE("Could not open codec");
-        avcodec_free_context(&decoder->codec_ctx);
-        return false;
-    }
-
-    decoder->frame = av_frame_alloc();
-    if (!decoder->frame) {
-        LOG_OOM();
-        avcodec_close(decoder->codec_ctx);
-        avcodec_free_context(&decoder->codec_ctx);
-        return false;
-    }
-
-    if (!sc_decoder_open_sinks(decoder)) {
-        LOGE("Could not open decoder sinks");
-        av_frame_free(&decoder->frame);
-        avcodec_close(decoder->codec_ctx);
-        avcodec_free_context(&decoder->codec_ctx);
-        return false;
-    }
-
-    return true;
+    return r;
 }
 
-static void
-sc_decoder_close(struct sc_decoder *decoder) {
-    sc_decoder_close_sinks(decoder);
-    av_frame_free(&decoder->frame);
-    avcodec_close(decoder->codec_ctx);
-    avcodec_free_context(&decoder->codec_ctx);
-}
-
-static bool
-push_frame_to_sinks(struct sc_decoder *decoder, const AVFrame *frame) {
-    for (unsigned i = 0; i < decoder->sink_count; ++i) {
-        struct sc_frame_sink *sink = decoder->sinks[i];
-        if (!sink->ops->push(sink, frame)) {
-            LOGE("Could not send frame to sink %d", i);
-            return false;
-        }
+static int read_raw_packet(void *opaque, uint8_t *buf, int buf_size) {
+    struct decoder *decoder = opaque;
+    ssize_t r = net_recv(decoder->video_socket, buf, buf_size);
+    if (r == -1) {
+        return AVERROR(errno);
     }
-
-    return true;
-}
-
-static bool
-sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {
-    bool is_config = packet->pts == AV_NOPTS_VALUE;
-    if (is_config) {
-        // nothing to do
-        return true;
+    if (r == 0) {
+        return AVERROR_EOF;
     }
+    return r;
+}
 
-    int ret = avcodec_send_packet(decoder->codec_ctx, packet);
-    if (ret < 0 && ret != AVERROR(EAGAIN)) {
-        LOGE("Could not send video packet: %d", ret);
-        return false;
+// set the decoded frame as ready for rendering, and notify
+static void push_frame(struct decoder *decoder) {
+    SDL_bool previous_frame_consumed = frames_offer_decoded_frame(decoder->frames);
+    if (!previous_frame_consumed) {
+        // the previous EVENT_NEW_FRAME will consume this frame
+        return;
     }
-    ret = avcodec_receive_frame(decoder->codec_ctx, decoder->frame);
-    if (!ret) {
-        // a frame was received
-        bool ok = push_frame_to_sinks(decoder, decoder->frame);
-        // A frame lost should not make the whole pipeline fail. The error, if
-        // any, is already logged.
-        (void) ok;
-
-        av_frame_unref(decoder->frame);
-    } else if (ret != AVERROR(EAGAIN)) {
-        LOGE("Could not receive video frame: %d", ret);
-        return false;
-    }
-    return true;
-}
-
-static bool
-sc_decoder_packet_sink_open(struct sc_packet_sink *sink, const AVCodec *codec) {
-    struct sc_decoder *decoder = DOWNCAST(sink);
-    return sc_decoder_open(decoder, codec);
-}
-
-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) {
-    decoder->sink_count = 0;
-
-    static const struct sc_packet_sink_ops ops = {
-        .open = sc_decoder_packet_sink_open,
-        .close = sc_decoder_packet_sink_close,
-        .push = sc_decoder_packet_sink_push,
+    static SDL_Event new_frame_event = {
+        .type = EVENT_NEW_FRAME,
     };
-
-    decoder->packet_sink.ops = &ops;
+    SDL_PushEvent(&new_frame_event);
 }
 
-void
-sc_decoder_add_sink(struct sc_decoder *decoder, struct sc_frame_sink *sink) {
-    assert(decoder->sink_count < SC_DECODER_MAX_SINKS);
-    assert(sink);
-    assert(sink->ops);
-    decoder->sinks[decoder->sink_count++] = sink;
+static void notify_stopped(void) {
+    SDL_Event stop_event;
+    stop_event.type = EVENT_DECODER_STOPPED;
+    SDL_PushEvent(&stop_event);
+}
+
+static int run_decoder(void *data) {
+    struct decoder *decoder = data;
+
+    AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
+    if (!codec) {
+        LOGE("H.264 decoder not found");
+        goto run_end;
+    }
+
+    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
+    if (!codec_ctx) {
+        LOGC("Could not allocate decoder context");
+        goto run_end;
+    }
+
+    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
+        LOGE("Could not open H.264 codec");
+        goto run_finally_free_codec_ctx;
+    }
+
+    AVFormatContext *format_ctx = avformat_alloc_context();
+    if (!format_ctx) {
+        LOGC("Could not allocate format context");
+        goto run_finally_close_codec;
+    }
+
+    unsigned char *buffer = av_malloc(BUFSIZE);
+    if (!buffer) {
+        LOGC("Could not allocate buffer");
+        goto run_finally_free_format_ctx;
+    }
+
+    // initialize the receiver state
+    decoder->receiver_state.frame_meta_queue = NULL;
+    decoder->receiver_state.remaining = 0;
+
+    // if recording is enabled, a "header" is sent between raw packets
+    int (*read_packet)(void *, uint8_t *, int) =
+            decoder->recorder ? read_packet_with_meta : read_raw_packet;
+    AVIOContext *avio_ctx = avio_alloc_context(buffer, BUFSIZE, 0, decoder,
+                                               read_packet, NULL, NULL);
+    if (!avio_ctx) {
+        LOGC("Could not allocate avio context");
+        // avformat_open_input takes ownership of 'buffer'
+        // so only free the buffer before avformat_open_input()
+        av_free(buffer);
+        goto run_finally_free_format_ctx;
+    }
+
+    format_ctx->pb = avio_ctx;
+
+    if (avformat_open_input(&format_ctx, NULL, NULL, NULL) < 0) {
+        LOGE("Could not open video stream");
+        goto run_finally_free_avio_ctx;
+    }
+
+    if (decoder->recorder &&
+            !recorder_open(decoder->recorder, codec)) {
+        LOGE("Could not open recorder");
+        goto run_finally_close_input;
+    }
+
+    AVPacket packet;
+    av_init_packet(&packet);
+    packet.data = NULL;
+    packet.size = 0;
+
+    while (!av_read_frame(format_ctx, &packet)) {
+// the new decoding/encoding API has been introduced by:
+// <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=7fc329e2dd6226dfecaa4a1d7adf353bf2773726>
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 37, 0)
+        int ret;
+        if ((ret = avcodec_send_packet(codec_ctx, &packet)) < 0) {
+            LOGE("Could not send video packet: %d", ret);
+            goto run_quit;
+        }
+        ret = avcodec_receive_frame(codec_ctx, decoder->frames->decoding_frame);
+        if (!ret) {
+            // a frame was received
+            push_frame(decoder);
+        } else if (ret != AVERROR(EAGAIN)) {
+            LOGE("Could not receive video frame: %d", ret);
+            av_packet_unref(&packet);
+            goto run_quit;
+        }
+#else
+        while (packet.size > 0) {
+            int got_picture;
+            int len = avcodec_decode_video2(codec_ctx, decoder->frames->decoding_frame, &got_picture, &packet);
+            if (len < 0) {
+                LOGE("Could not decode video packet: %d", len);
+                av_packet_unref(&packet);
+                goto run_quit;
+            }
+            if (got_picture) {
+                push_frame(decoder);
+            }
+            packet.size -= len;
+            packet.data += len;
+        }
+#endif
+
+        if (decoder->recorder) {
+            // we retrieve the PTS in order they were received, so they will
+            // be assigned to the correct frame
+            uint64_t pts = receiver_state_take_meta(&decoder->receiver_state);
+            packet.pts = pts;
+            packet.dts = pts;
+
+            // no need to rescale with av_packet_rescale_ts(), the timestamps
+            // are in microseconds both in input and output
+            if (!recorder_write(decoder->recorder, &packet)) {
+                LOGE("Could not write frame to output file");
+                av_packet_unref(&packet);
+                goto run_quit;
+            }
+        }
+
+        av_packet_unref(&packet);
+
+        if (avio_ctx->eof_reached) {
+            break;
+        }
+    }
+
+    LOGD("End of frames");
+
+run_quit:
+    if (decoder->recorder) {
+        recorder_close(decoder->recorder);
+    }
+run_finally_close_input:
+    avformat_close_input(&format_ctx);
+run_finally_free_avio_ctx:
+    av_free(avio_ctx->buffer);
+    av_free(avio_ctx);
+run_finally_free_format_ctx:
+    avformat_free_context(format_ctx);
+run_finally_close_codec:
+    avcodec_close(codec_ctx);
+run_finally_free_codec_ctx:
+    avcodec_free_context(&codec_ctx);
+    notify_stopped();
+run_end:
+    return 0;
+}
+
+void decoder_init(struct decoder *decoder, struct frames *frames,
+                  socket_t video_socket, struct recorder *recorder) {
+    decoder->frames = frames;
+    decoder->video_socket = video_socket;
+    decoder->recorder = recorder;
+}
+
+SDL_bool decoder_start(struct decoder *decoder) {
+    LOGD("Starting decoder thread");
+
+    decoder->thread = SDL_CreateThread(run_decoder, "video_decoder", decoder);
+    if (!decoder->thread) {
+        LOGC("Could not start decoder thread");
+        return SDL_FALSE;
+    }
+    return SDL_TRUE;
+}
+
+void decoder_stop(struct decoder *decoder) {
+    frames_stop(decoder->frames);
+}
+
+void decoder_join(struct decoder *decoder) {
+    SDL_WaitThread(decoder->thread, NULL);
 }

app/src/decoder.h

@@ -1,30 +1,36 @@
-#ifndef SC_DECODER_H
-#define SC_DECODER_H
+#ifndef DECODER_H
+#define DECODER_H
+
+#include <SDL2/SDL_stdinc.h>
+#include <SDL2/SDL_thread.h>
 
 #include "common.h"
+#include "net.h"
 
-#include "trait/packet_sink.h"
+struct frames;
 
-#include <stdbool.h>
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-
-#define SC_DECODER_MAX_SINKS 2
-
-struct sc_decoder {
-    struct sc_packet_sink packet_sink; // packet sink trait
-
-    struct sc_frame_sink *sinks[SC_DECODER_MAX_SINKS];
-    unsigned sink_count;
-
-    AVCodecContext *codec_ctx;
-    AVFrame *frame;
+struct frame_meta {
+    uint64_t pts;
+    struct frame_meta *next;
 };
 
-void
-sc_decoder_init(struct sc_decoder *decoder);
+struct decoder {
+    struct frames *frames;
+    socket_t video_socket;
+    SDL_Thread *thread;
+    SDL_mutex *mutex;
+    struct recorder *recorder;
+    struct receiver_state {
+        // meta (in order) for frames not consumed yet
+        struct frame_meta *frame_meta_queue;
+        size_t remaining; // remaining bytes to receive for the current frame
+    } receiver_state;
+};
 
-void
-sc_decoder_add_sink(struct sc_decoder *decoder, struct sc_frame_sink *sink);
+void decoder_init(struct decoder *decoder, struct frames *frames,
+                  socket_t video_socket, struct recorder *recoder);
+SDL_bool decoder_start(struct decoder *decoder);
+void decoder_stop(struct decoder *decoder);
+void decoder_join(struct decoder *decoder);
 
 #endif

app/src/demuxer.c

@@ -1,309 +0,0 @@
-#include "demuxer.h"
-
-#include <assert.h>
-#include <libavutil/time.h>
-#include <unistd.h>
-
-#include "decoder.h"
-#include "events.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_recv_codec_id(struct sc_demuxer *demuxer) {
-    uint8_t data[4];
-    ssize_t r = net_recv_all(demuxer->socket, data, 4);
-    if (r < 4) {
-        return false;
-    }
-
-#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
-    uint32_t codec_id = sc_read32be(data);
-    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:
-            return AV_CODEC_ID_AV1;
-        default:
-            LOGE("Unknown codec id 0x%08" PRIx32, codec_id);
-            return AV_CODEC_ID_NONE;
-    }
-}
-
-static bool
-sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
-    // The video stream contains raw packets, without time information. When we
-    // record, we retrieve the timestamps separately, from a "meta" header
-    // added by the server before each raw packet.
-    //
-    // The "meta" header length is 12 bytes:
-    // [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
-    //  <-------------> <-----> <-----------------------------...
-    //        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 bool
-push_packet_to_sinks(struct sc_demuxer *demuxer, const AVPacket *packet) {
-    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
-        struct sc_packet_sink *sink = demuxer->sinks[i];
-        if (!sink->ops->push(sink, packet)) {
-            LOGE("Could not send config packet to sink %d", i);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static bool
-sc_demuxer_push_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
-    bool is_config = packet->pts == AV_NOPTS_VALUE;
-
-    // A config packet must not be decoded immediately (it contains no
-    // frame); instead, it must be concatenated with the future data packet.
-    if (demuxer->pending || is_config) {
-        if (demuxer->pending) {
-            size_t offset = demuxer->pending->size;
-            if (av_grow_packet(demuxer->pending, packet->size)) {
-                LOG_OOM();
-                return false;
-            }
-
-            memcpy(demuxer->pending->data + offset, packet->data, packet->size);
-        } else {
-            demuxer->pending = av_packet_alloc();
-            if (!demuxer->pending) {
-                LOG_OOM();
-                return false;
-            }
-            if (av_packet_ref(demuxer->pending, packet)) {
-                LOG_OOM();
-                av_packet_free(&demuxer->pending);
-                return false;
-            }
-        }
-
-        if (!is_config) {
-            // prepare the concat packet to send to the decoder
-            demuxer->pending->pts = packet->pts;
-            demuxer->pending->dts = packet->dts;
-            demuxer->pending->flags = packet->flags;
-            packet = demuxer->pending;
-        }
-    }
-
-    bool ok = push_packet_to_sinks(demuxer, packet);
-
-    if (!is_config && demuxer->pending) {
-        // the pending packet must be discarded (consumed or error)
-        av_packet_free(&demuxer->pending);
-    }
-
-    if (!ok) {
-        LOGE("Could not process packet");
-        return false;
-    }
-
-    return true;
-}
-
-static void
-sc_demuxer_close_first_sinks(struct sc_demuxer *demuxer, unsigned count) {
-    while (count) {
-        struct sc_packet_sink *sink = demuxer->sinks[--count];
-        sink->ops->close(sink);
-    }
-}
-
-static inline void
-sc_demuxer_close_sinks(struct sc_demuxer *demuxer) {
-    sc_demuxer_close_first_sinks(demuxer, demuxer->sink_count);
-}
-
-static bool
-sc_demuxer_open_sinks(struct sc_demuxer *demuxer, const AVCodec *codec) {
-    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
-        struct sc_packet_sink *sink = demuxer->sinks[i];
-        if (!sink->ops->open(sink, codec)) {
-            LOGE("Could not open packet sink %d", i);
-            sc_demuxer_close_first_sinks(demuxer, i);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static int
-run_demuxer(void *data) {
-    struct sc_demuxer *demuxer = data;
-
-    enum AVCodecID codec_id = sc_demuxer_recv_codec_id(demuxer);
-    if (codec_id == AV_CODEC_ID_NONE) {
-        // Error already logged
-        goto end;
-    }
-
-    const AVCodec *codec = avcodec_find_decoder(codec_id);
-    if (!codec) {
-        LOGE("H.264 decoder not found");
-        goto end;
-    }
-
-    demuxer->codec_ctx = avcodec_alloc_context3(codec);
-    if (!demuxer->codec_ctx) {
-        LOG_OOM();
-        goto end;
-    }
-
-    if (!sc_demuxer_open_sinks(demuxer, codec)) {
-        LOGE("Could not open demuxer sinks");
-        goto finally_free_codec_ctx;
-    }
-
-    demuxer->parser = av_parser_init(codec_id);
-    if (!demuxer->parser) {
-        LOGE("Could not initialize parser");
-        goto finally_close_sinks;
-    }
-
-    // We must only pass complete frames to av_parser_parse2()!
-    // It's more complicated, but this allows to reduce the latency by 1 frame!
-    demuxer->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
-
-    AVPacket *packet = av_packet_alloc();
-    if (!packet) {
-        LOG_OOM();
-        goto finally_close_parser;
-    }
-
-    for (;;) {
-        bool ok = sc_demuxer_recv_packet(demuxer, packet);
-        if (!ok) {
-            // end of stream
-            break;
-        }
-
-        ok = sc_demuxer_push_packet(demuxer, packet);
-        av_packet_unref(packet);
-        if (!ok) {
-            // cannot process packet (error already logged)
-            break;
-        }
-    }
-
-    LOGD("End of frames");
-
-    if (demuxer->pending) {
-        av_packet_free(&demuxer->pending);
-    }
-
-    av_packet_free(&packet);
-finally_close_parser:
-    av_parser_close(demuxer->parser);
-finally_close_sinks:
-    sc_demuxer_close_sinks(demuxer);
-finally_free_codec_ctx:
-    avcodec_free_context(&demuxer->codec_ctx);
-end:
-    demuxer->cbs->on_eos(demuxer, demuxer->cbs_userdata);
-
-    return 0;
-}
-
-void
-sc_demuxer_init(struct sc_demuxer *demuxer, sc_socket socket,
-                const struct sc_demuxer_callbacks *cbs, void *cbs_userdata) {
-    demuxer->socket = socket;
-    demuxer->pending = NULL;
-    demuxer->sink_count = 0;
-
-    assert(cbs && cbs->on_eos);
-
-    demuxer->cbs = cbs;
-    demuxer->cbs_userdata = cbs_userdata;
-}
-
-void
-sc_demuxer_add_sink(struct sc_demuxer *demuxer, struct sc_packet_sink *sink) {
-    assert(demuxer->sink_count < SC_DEMUXER_MAX_SINKS);
-    assert(sink);
-    assert(sink->ops);
-    demuxer->sinks[demuxer->sink_count++] = sink;
-}
-
-bool
-sc_demuxer_start(struct sc_demuxer *demuxer) {
-    LOGD("Starting demuxer thread");
-
-    bool ok = sc_thread_create(&demuxer->thread, run_demuxer, "scrcpy-demuxer",
-                               demuxer);
-    if (!ok) {
-        LOGE("Could not start demuxer thread");
-        return false;
-    }
-    return true;
-}
-
-void
-sc_demuxer_join(struct sc_demuxer *demuxer) {
-    sc_thread_join(&demuxer->thread, NULL);
-}

app/src/demuxer.h

@@ -1,51 +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_sink.h"
-#include "util/net.h"
-#include "util/thread.h"
-
-#define SC_DEMUXER_MAX_SINKS 2
-
-struct sc_demuxer {
-    sc_socket socket;
-    sc_thread thread;
-
-    struct sc_packet_sink *sinks[SC_DEMUXER_MAX_SINKS];
-    unsigned sink_count;
-
-    AVCodecContext *codec_ctx;
-    AVCodecParserContext *parser;
-    // successive packets may need to be concatenated, until a non-config
-    // packet is available
-    AVPacket *pending;
-
-    const struct sc_demuxer_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct sc_demuxer_callbacks {
-    void (*on_eos)(struct sc_demuxer *demuxer, void *userdata);
-};
-
-void
-sc_demuxer_init(struct sc_demuxer *demuxer, sc_socket socket,
-                const struct sc_demuxer_callbacks *cbs, void *cbs_userdata);
-
-void
-sc_demuxer_add_sink(struct sc_demuxer *demuxer, struct sc_packet_sink *sink);
-
-bool
-sc_demuxer_start(struct sc_demuxer *demuxer);
-
-void
-sc_demuxer_join(struct sc_demuxer *demuxer);
-
-#endif

app/src/device.c

@@ -0,0 +1,18 @@
+#include "device.h"
+#include "log.h"
+
+SDL_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 SDL_FALSE;
+    }
+    buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0'; // in case the client sends garbage
+    // 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 SDL_TRUE;
+}

app/src/device.h

@@ -0,0 +1,15 @@
+#ifndef DEVICE_H
+#define DEVICE_H
+
+#include <SDL2/SDL_stdinc.h>
+
+#include "common.h"
+#include "net.h"
+
+#define DEVICE_NAME_FIELD_LENGTH 64
+#define DEVICE_SDCARD_PATH "/sdcard/"
+
+// name must be at least DEVICE_NAME_FIELD_LENGTH bytes
+SDL_bool device_read_info(socket_t device_socket, char *name, struct size *frame_size);
+
+#endif

app/src/device_msg.c

@@ -1,54 +0,0 @@
-#include "device_msg.h"
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "util/binary.h"
-#include "util/log.h"
-
-ssize_t
-device_msg_deserialize(const unsigned char *buf, size_t len,
-                       struct device_msg *msg) {
-    if (len < 5) {
-        // at least type + empty string length
-        return 0; // not available
-    }
-
-    msg->type = buf[0];
-    switch (msg->type) {
-        case DEVICE_MSG_TYPE_CLIPBOARD: {
-            size_t clipboard_len = sc_read32be(&buf[1]);
-            if (clipboard_len > len - 5) {
-                return 0; // not available
-            }
-            char *text = malloc(clipboard_len + 1);
-            if (!text) {
-                LOG_OOM();
-                return -1;
-            }
-            if (clipboard_len) {
-                memcpy(text, &buf[5], clipboard_len);
-            }
-            text[clipboard_len] = '\0';
-
-            msg->clipboard.text = text;
-            return 5 + clipboard_len;
-        }
-        case DEVICE_MSG_TYPE_ACK_CLIPBOARD: {
-            uint64_t sequence = sc_read64be(&buf[1]);
-            msg->ack_clipboard.sequence = sequence;
-            return 9;
-        }
-        default:
-            LOGW("Unknown device message type: %d", (int) msg->type);
-            return -1; // error, we cannot recover
-    }
-}
-
-void
-device_msg_destroy(struct device_msg *msg) {
-    if (msg->type == DEVICE_MSG_TYPE_CLIPBOARD) {
-        free(msg->clipboard.text);
-    }
-}

app/src/device_msg.h

@@ -1,39 +0,0 @@
-#ifndef SC_DEVICEMSG_H
-#define SC_DEVICEMSG_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <unistd.h>
-
-#define DEVICE_MSG_MAX_SIZE (1 << 18) // 256k
-// type: 1 byte; length: 4 bytes
-#define DEVICE_MSG_TEXT_MAX_LENGTH (DEVICE_MSG_MAX_SIZE - 5)
-
-enum device_msg_type {
-    DEVICE_MSG_TYPE_CLIPBOARD,
-    DEVICE_MSG_TYPE_ACK_CLIPBOARD,
-};
-
-struct device_msg {
-    enum device_msg_type type;
-    union {
-        struct {
-            char *text; // owned, to be freed by free()
-        } clipboard;
-        struct {
-            uint64_t sequence;
-        } ack_clipboard;
-    };
-};
-
-// return the number of bytes consumed (0 for no msg available, -1 on error)
-ssize_t
-device_msg_deserialize(const unsigned char *buf, size_t len,
-                       struct device_msg *msg);
-
-void
-device_msg_destroy(struct device_msg *msg);
-
-#endif

app/src/events.h

@@ -1,5 +1,3 @@
-#define EVENT_NEW_FRAME                 SDL_USEREVENT
-#define EVENT_STREAM_STOPPED           (SDL_USEREVENT + 1)
-#define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
-#define EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
-#define EVENT_USB_DEVICE_DISCONNECTED  (SDL_USEREVENT + 4)
+#define EVENT_NEW_SESSION SDL_USEREVENT
+#define EVENT_NEW_FRAME (SDL_USEREVENT + 1)
+#define EVENT_DECODER_STOPPED (SDL_USEREVENT + 2)

app/src/file_handler.c

@@ -0,0 +1,231 @@
+#include "file_handler.h"
+
+#include <string.h>
+#include <SDL2/SDL_assert.h>
+#include "config.h"
+#include "command.h"
+#include "device.h"
+#include "lock_util.h"
+#include "log.h"
+
+struct request {
+    file_handler_action_t action;
+    const char *file;
+};
+
+static struct request *request_new(file_handler_action_t action, const char *file) {
+    struct request *req = SDL_malloc(sizeof(*req));
+    if (!req) {
+        return NULL;
+    }
+    req->action = action;
+    req->file = file;
+    return req;
+}
+
+static void request_free(struct request *req) {
+    if (!req) {
+        return;
+    }
+    SDL_free((void *) req->file);
+    SDL_free((void *) req);
+}
+
+static SDL_bool request_queue_is_empty(const struct request_queue *queue) {
+    return queue->head == queue->tail;
+}
+
+static SDL_bool request_queue_is_full(const struct request_queue *queue) {
+    return (queue->head + 1) % REQUEST_QUEUE_SIZE == queue->tail;
+}
+
+static SDL_bool request_queue_init(struct request_queue *queue) {
+    queue->head = 0;
+    queue->tail = 0;
+    return SDL_TRUE;
+}
+
+static void request_queue_destroy(struct request_queue *queue) {
+    int i = queue->tail;
+    while (i != queue->head) {
+        request_free(queue->reqs[i]);
+        i = (i + 1) % REQUEST_QUEUE_SIZE;
+    }
+}
+
+static SDL_bool request_queue_push(struct request_queue *queue, struct request *req) {
+    if (request_queue_is_full(queue)) {
+        return SDL_FALSE;
+    }
+    queue->reqs[queue->head] = req;
+    queue->head = (queue->head + 1) % REQUEST_QUEUE_SIZE;
+    return SDL_TRUE;
+}
+
+static SDL_bool request_queue_take(struct request_queue *queue, struct request **req) {
+    if (request_queue_is_empty(queue)) {
+        return SDL_FALSE;
+    }
+    // transfer ownership
+    *req = queue->reqs[queue->tail];
+    queue->tail = (queue->tail + 1) % REQUEST_QUEUE_SIZE;
+    return SDL_TRUE;
+}
+
+SDL_bool file_handler_init(struct file_handler *file_handler, const char *serial) {
+
+    if (!request_queue_init(&file_handler->queue)) {
+        return SDL_FALSE;
+    }
+
+    if (!(file_handler->mutex = SDL_CreateMutex())) {
+        return SDL_FALSE;
+    }
+
+    if (!(file_handler->event_cond = SDL_CreateCond())) {
+        SDL_DestroyMutex(file_handler->mutex);
+        return SDL_FALSE;
+    }
+
+    if (serial) {
+        file_handler->serial = SDL_strdup(serial);
+        if (!file_handler->serial) {
+            LOGW("Cannot strdup serial");
+            SDL_DestroyMutex(file_handler->mutex);
+            return SDL_FALSE;
+        }
+    } else {
+        file_handler->serial = NULL;
+    }
+
+    // lazy initialization
+    file_handler->initialized = SDL_FALSE;
+
+    file_handler->stopped = SDL_FALSE;
+    file_handler->current_process = PROCESS_NONE;
+
+    return SDL_TRUE;
+}
+
+void file_handler_destroy(struct file_handler *file_handler) {
+    SDL_DestroyCond(file_handler->event_cond);
+    SDL_DestroyMutex(file_handler->mutex);
+    request_queue_destroy(&file_handler->queue);
+    SDL_free((void *) file_handler->serial);
+}
+
+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) {
+    return adb_push(serial, file, DEVICE_SDCARD_PATH);
+}
+
+SDL_bool file_handler_request(struct file_handler *file_handler,
+                              file_handler_action_t action,
+                              const char *file) {
+    SDL_bool res;
+
+    // start file_handler if it's used for the first time
+    if (!file_handler->initialized) {
+        if (!file_handler_start(file_handler)) {
+            return SDL_FALSE;
+        }
+        file_handler->initialized = SDL_TRUE;
+    }
+
+    LOGI("Request to %s %s", action == ACTION_INSTALL_APK ? "install" : "push", file);
+    struct request *req = request_new(action, file);
+    if (!req) {
+        LOGE("Could not create request");
+        return SDL_FALSE;
+    }
+
+    mutex_lock(file_handler->mutex);
+    SDL_bool was_empty = request_queue_is_empty(&file_handler->queue);
+    res = request_queue_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 && request_queue_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 request *req;
+        SDL_bool non_empty = request_queue_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->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 /sdcard/", req->file);
+            } else {
+                LOGE("Failed to push %s to /sdcard/", req->file);
+            }
+        }
+
+        request_free(req);
+    }
+    return 0;
+}
+
+SDL_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 SDL_FALSE;
+    }
+
+    return SDL_TRUE;
+}
+
+void file_handler_stop(struct file_handler *file_handler) {
+    mutex_lock(file_handler->mutex);
+    file_handler->stopped = SDL_TRUE;
+    cond_signal(file_handler->event_cond);
+    if (file_handler->current_process != PROCESS_NONE) {
+        if (!cmd_terminate(file_handler->current_process)) {
+            LOGW("Cannot 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);
+}

app/src/file_handler.h

@@ -0,0 +1,44 @@
+#ifndef FILE_HANDLER_H
+#define FILE_HANDLER_H
+
+#include <SDL2/SDL_mutex.h>
+#include <SDL2/SDL_stdinc.h>
+#include <SDL2/SDL_thread.h>
+#include "command.h"
+
+#define REQUEST_QUEUE_SIZE 16
+
+typedef enum {
+    ACTION_INSTALL_APK,
+    ACTION_PUSH_FILE,
+} file_handler_action_t;
+
+struct request_queue {
+    struct request *reqs[REQUEST_QUEUE_SIZE];
+    int tail;
+    int head;
+};
+
+struct file_handler {
+    const char *serial;
+    SDL_Thread *thread;
+    SDL_mutex *mutex;
+    SDL_cond *event_cond;
+    SDL_bool stopped;
+    SDL_bool initialized;
+    process_t current_process;
+    struct request_queue queue;
+};
+
+SDL_bool file_handler_init(struct file_handler *file_handler, const char *serial);
+void file_handler_destroy(struct file_handler *file_handler);
+
+SDL_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);
+
+SDL_bool file_handler_request(struct file_handler *file_handler,
+                              file_handler_action_t action,
+                              const char *file);
+
+#endif

app/src/file_pusher.c

@@ -1,178 +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);
-
-    cbuf_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);
-
-    struct sc_file_pusher_request req;
-    while (cbuf_take(&fp->queue, &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 = cbuf_is_empty(&fp->queue);
-    bool res = cbuf_push(&fp->queue, req);
-    if (was_empty) {
-        sc_cond_signal(&fp->event_cond);
-    }
-    sc_mutex_unlock(&fp->mutex);
-    return res;
-}
-
-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 && cbuf_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;
-        }
-        struct sc_file_pusher_request req;
-        bool non_empty = cbuf_take(&fp->queue, &req);
-        assert(non_empty);
-        (void) non_empty;
-        sc_mutex_unlock(&fp->mutex);
-
-        if (req.action == SC_FILE_PUSHER_ACTION_INSTALL_APK) {
-            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) {
-    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) {
-    sc_thread_join(&fp->thread, NULL);
-}

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/cbuf.h"
-#include "util/thread.h"
-#include "util/intr.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 CBUF(struct sc_file_pusher_request, 16);
-
-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

app/src/fps_counter.c

@@ -1,184 +1,62 @@
 #include "fps_counter.h"
 
-#include <assert.h>
+#include <SDL2/SDL_timer.h>
 
-#include "util/log.h"
+#include "log.h"
 
-#define SC_FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1)
-
-bool
-sc_fps_counter_init(struct sc_fps_counter *counter) {
-    bool ok = sc_mutex_init(&counter->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&counter->state_cond);
-    if (!ok) {
-        sc_mutex_destroy(&counter->mutex);
-        return false;
-    }
-
-    counter->thread_started = false;
-    atomic_init(&counter->started, 0);
-    // no need to initialize the other fields, they are unused until started
-
-    return true;
+void fps_counter_init(struct fps_counter *counter) {
+    counter->started = SDL_FALSE;
+    // no need to initialize the other fields, they are meaningful only when
+    // started is true
 }
 
-void
-sc_fps_counter_destroy(struct sc_fps_counter *counter) {
-    sc_cond_destroy(&counter->state_cond);
-    sc_mutex_destroy(&counter->mutex);
+void fps_counter_start(struct fps_counter *counter) {
+    counter->started = SDL_TRUE;
+    counter->slice_start = SDL_GetTicks();
+    counter->nr_rendered = 0;
+#ifdef SKIP_FRAMES
+    counter->nr_skipped = 0;
+#endif
 }
 
-static inline bool
-is_started(struct sc_fps_counter *counter) {
-    return atomic_load_explicit(&counter->started, memory_order_acquire);
+void fps_counter_stop(struct fps_counter *counter) {
+    counter->started = SDL_FALSE;
 }
 
-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) {
-    unsigned rendered_per_second =
-        counter->nr_rendered * SC_TICK_FREQ / SC_FPS_COUNTER_INTERVAL;
+static void display_fps(struct fps_counter *counter) {
+#ifdef SKIP_FRAMES
     if (counter->nr_skipped) {
-        LOGI("%u fps (+%u frames skipped)", rendered_per_second,
-                                            counter->nr_skipped);
+        LOGI("%d fps (+%d frames skipped)", counter->nr_rendered, counter->nr_skipped);
     } else {
-        LOGI("%u fps", rendered_per_second);
+#endif
+    LOGI("%d fps", counter->nr_rendered);
+#ifdef SKIP_FRAMES
+    }
+#endif
+}
+
+static void check_expired(struct fps_counter *counter) {
+    Uint32 now = SDL_GetTicks();
+    if (now - counter->slice_start >= 1000) {
+        display_fps(counter);
+        // add a multiple of one second
+        Uint32 elapsed_slices = (now - counter->slice_start) / 1000;
+        counter->slice_start += 1000 * elapsed_slices;
+        counter->nr_rendered = 0;
+#ifdef SKIP_FRAMES
+        counter->nr_skipped = 0;
+#endif
     }
 }
 
-// must be called with mutex locked
-static void
-check_interval_expired(struct sc_fps_counter *counter, sc_tick now) {
-    if (now < counter->next_timestamp) {
-        return;
-    }
-
-    display_fps(counter);
-    counter->nr_rendered = 0;
-    counter->nr_skipped = 0;
-    // add a multiple of the interval
-    uint32_t elapsed_slices =
-        (now - counter->next_timestamp) / SC_FPS_COUNTER_INTERVAL + 1;
-    counter->next_timestamp += SC_FPS_COUNTER_INTERVAL * elapsed_slices;
-}
-
-static int
-run_fps_counter(void *data) {
-    struct sc_fps_counter *counter = data;
-
-    sc_mutex_lock(&counter->mutex);
-    while (!counter->interrupted) {
-        while (!counter->interrupted && !is_started(counter)) {
-            sc_cond_wait(&counter->state_cond, &counter->mutex);
-        }
-        while (!counter->interrupted && is_started(counter)) {
-            sc_tick now = sc_tick_now();
-            check_interval_expired(counter, now);
-
-            // ignore the reason (timeout or signaled), we just loop anyway
-            sc_cond_timedwait(&counter->state_cond, &counter->mutex,
-                              counter->next_timestamp);
-        }
-    }
-    sc_mutex_unlock(&counter->mutex);
-    return 0;
-}
-
-bool
-sc_fps_counter_start(struct sc_fps_counter *counter) {
-    sc_mutex_lock(&counter->mutex);
-    counter->next_timestamp = sc_tick_now() + SC_FPS_COUNTER_INTERVAL;
-    counter->nr_rendered = 0;
-    counter->nr_skipped = 0;
-    sc_mutex_unlock(&counter->mutex);
-
-    set_started(counter, true);
-    sc_cond_signal(&counter->state_cond);
-
-    // counter->thread_started and counter->thread are always accessed from the
-    // same thread, no need to lock
-    if (!counter->thread_started) {
-        bool ok = sc_thread_create(&counter->thread, run_fps_counter,
-                                   "scrcpy-fps", counter);
-        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) {
-    set_started(counter, false);
-    sc_cond_signal(&counter->state_cond);
-    LOGI("FPS counter stopped");
-}
-
-bool
-sc_fps_counter_is_started(struct sc_fps_counter *counter) {
-    return is_started(counter);
-}
-
-void
-sc_fps_counter_interrupt(struct sc_fps_counter *counter) {
-    if (!counter->thread_started) {
-        return;
-    }
-
-    sc_mutex_lock(&counter->mutex);
-    counter->interrupted = true;
-    sc_mutex_unlock(&counter->mutex);
-    // wake up blocking wait
-    sc_cond_signal(&counter->state_cond);
-}
-
-void
-sc_fps_counter_join(struct sc_fps_counter *counter) {
-    if (counter->thread_started) {
-        // interrupted must be set by the thread calling join(), so no need to
-        // 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) {
-    if (!is_started(counter)) {
-        return;
-    }
-
-    sc_mutex_lock(&counter->mutex);
-    sc_tick now = sc_tick_now();
-    check_interval_expired(counter, now);
+void fps_counter_add_rendered_frame(struct fps_counter *counter) {
+    check_expired(counter);
     ++counter->nr_rendered;
-    sc_mutex_unlock(&counter->mutex);
 }
 
-void
-sc_fps_counter_add_skipped_frame(struct sc_fps_counter *counter) {
-    if (!is_started(counter)) {
-        return;
-    }
-
-    sc_mutex_lock(&counter->mutex);
-    sc_tick now = sc_tick_now();
-    check_interval_expired(counter, now);
+#ifdef SKIP_FRAMES
+void fps_counter_add_skipped_frame(struct fps_counter *counter) {
+    check_expired(counter);
     ++counter->nr_skipped;
-    sc_mutex_unlock(&counter->mutex);
 }
+#endif

app/src/fps_counter.h

@@ -1,59 +1,26 @@
-#ifndef SC_FPSCOUNTER_H
-#define SC_FPSCOUNTER_H
+#ifndef FPSCOUNTER_H
+#define FPSCOUNTER_H
 
-#include "common.h"
+#include <SDL2/SDL_stdinc.h>
 
-#include <stdatomic.h>
-#include <stdbool.h>
-#include <stdint.h>
+#include "config.h"
 
-#include "util/thread.h"
-
-struct sc_fps_counter {
-    sc_thread thread;
-    sc_mutex mutex;
-    sc_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;
-
-    // the following fields are protected by the mutex
-    bool interrupted;
-    unsigned nr_rendered;
-    unsigned nr_skipped;
-    sc_tick next_timestamp;
+struct fps_counter {
+    SDL_bool started;
+    Uint32 slice_start; // initialized by SDL_GetTicks()
+    int nr_rendered;
+#ifdef SKIP_FRAMES
+    int nr_skipped;
+#endif
 };
 
-bool
-sc_fps_counter_init(struct sc_fps_counter *counter);
+void fps_counter_init(struct fps_counter *counter);
+void fps_counter_start(struct fps_counter *counter);
+void fps_counter_stop(struct fps_counter *counter);
 
-void
-sc_fps_counter_destroy(struct sc_fps_counter *counter);
-
-bool
-sc_fps_counter_start(struct sc_fps_counter *counter);
-
-void
-sc_fps_counter_stop(struct sc_fps_counter *counter);
-
-bool
-sc_fps_counter_is_started(struct sc_fps_counter *counter);
-
-// request to stop the thread (on quit)
-// must be called before sc_fps_counter_join()
-void
-sc_fps_counter_interrupt(struct sc_fps_counter *counter);
-
-void
-sc_fps_counter_join(struct sc_fps_counter *counter);
-
-void
-sc_fps_counter_add_rendered_frame(struct sc_fps_counter *counter);
-
-void
-sc_fps_counter_add_skipped_frame(struct sc_fps_counter *counter);
+void fps_counter_add_rendered_frame(struct fps_counter *counter);
+#ifdef SKIP_FRAMES
+void fps_counter_add_skipped_frame(struct fps_counter *counter);
+#endif
 
 #endif

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);
-}

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

app/src/frames.c

@@ -0,0 +1,110 @@
+#include "frames.h"
+
+#include <SDL2/SDL_assert.h>
+#include <SDL2/SDL_mutex.h>
+#include <libavutil/avutil.h>
+#include <libavformat/avformat.h>
+
+#include "config.h"
+#include "lock_util.h"
+#include "log.h"
+
+SDL_bool frames_init(struct frames *frames) {
+    if (!(frames->decoding_frame = av_frame_alloc())) {
+        goto error_0;
+    }
+
+    if (!(frames->rendering_frame = av_frame_alloc())) {
+        goto error_1;
+    }
+
+    if (!(frames->mutex = SDL_CreateMutex())) {
+        goto error_2;
+    }
+
+#ifndef SKIP_FRAMES
+    if (!(frames->rendering_frame_consumed_cond = SDL_CreateCond())) {
+        SDL_DestroyMutex(frames->mutex);
+        goto error_2;
+    }
+    frames->stopped = SDL_FALSE;
+#endif
+
+    // there is initially no rendering frame, so consider it has already been
+    // consumed
+    frames->rendering_frame_consumed = SDL_TRUE;
+    fps_counter_init(&frames->fps_counter);
+
+    return SDL_TRUE;
+
+error_2:
+    av_frame_free(&frames->rendering_frame);
+error_1:
+    av_frame_free(&frames->decoding_frame);
+error_0:
+    return SDL_FALSE;
+}
+
+void frames_destroy(struct frames *frames) {
+#ifndef SKIP_FRAMES
+    SDL_DestroyCond(frames->rendering_frame_consumed_cond);
+#endif
+    SDL_DestroyMutex(frames->mutex);
+    av_frame_free(&frames->rendering_frame);
+    av_frame_free(&frames->decoding_frame);
+}
+
+static void frames_swap(struct frames *frames) {
+    AVFrame *tmp = frames->decoding_frame;
+    frames->decoding_frame = frames->rendering_frame;
+    frames->rendering_frame = tmp;
+}
+
+SDL_bool frames_offer_decoded_frame(struct frames *frames) {
+    mutex_lock(frames->mutex);
+#ifndef SKIP_FRAMES
+    // if SKIP_FRAMES is disabled, then the decoder must wait for the current
+    // frame to be consumed
+    while (!frames->rendering_frame_consumed && !frames->stopped) {
+        cond_wait(frames->rendering_frame_consumed_cond, frames->mutex);
+    }
+#else
+    if (frames->fps_counter.started && !frames->rendering_frame_consumed) {
+        fps_counter_add_skipped_frame(&frames->fps_counter);
+    }
+#endif
+
+    frames_swap(frames);
+
+    SDL_bool previous_frame_consumed = frames->rendering_frame_consumed;
+    frames->rendering_frame_consumed = SDL_FALSE;
+
+    mutex_unlock(frames->mutex);
+    return previous_frame_consumed;
+}
+
+const AVFrame *frames_consume_rendered_frame(struct frames *frames) {
+    SDL_assert(!frames->rendering_frame_consumed);
+    frames->rendering_frame_consumed = SDL_TRUE;
+    if (frames->fps_counter.started) {
+        fps_counter_add_rendered_frame(&frames->fps_counter);
+    }
+#ifndef SKIP_FRAMES
+    // if SKIP_FRAMES is disabled, then notify the decoder the current frame is
+    // consumed, so that it may push a new one
+    cond_signal(frames->rendering_frame_consumed_cond);
+#endif
+    return frames->rendering_frame;
+}
+
+void frames_stop(struct frames *frames) {
+#ifdef SKIP_FRAMES
+    (void) frames; // unused
+#else
+    mutex_lock(frames->mutex);
+    frames->stopped = SDL_TRUE;
+    mutex_unlock(frames->mutex);
+    // wake up blocking wait
+    cond_signal(frames->rendering_frame_consumed_cond);
+#endif
+}

app/src/frames.h

@@ -0,0 +1,42 @@
+#ifndef FRAMES_H
+#define FRAMES_H
+
+#include <SDL2/SDL_mutex.h>
+#include <SDL2/SDL_stdinc.h>
+
+#include "config.h"
+#include "fps_counter.h"
+
+// forward declarations
+typedef struct AVFrame AVFrame;
+
+struct frames {
+    AVFrame *decoding_frame;
+    AVFrame *rendering_frame;
+    SDL_mutex *mutex;
+#ifndef SKIP_FRAMES
+    SDL_bool stopped;
+    SDL_cond *rendering_frame_consumed_cond;
+#endif
+    SDL_bool rendering_frame_consumed;
+    struct fps_counter fps_counter;
+};
+
+SDL_bool frames_init(struct frames *frames);
+void frames_destroy(struct frames *frames);
+
+// set the decoder frame as ready for rendering
+// this function locks frames->mutex during its execution
+// returns true if the previous frame had been consumed
+SDL_bool frames_offer_decoded_frame(struct frames *frames);
+
+// mark the rendering frame as consumed and return it
+// MUST be called with frames->mutex locked!!!
+// the caller is expected to render the returned frame to some texture before
+// unlocking frames->mutex
+const AVFrame *frames_consume_rendered_frame(struct frames *frames);
+
+// wake up and avoid any blocking call
+void frames_stop(struct frames *frames);
+
+#endif

app/src/icon.c

@@ -1,291 +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/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) {
-#ifdef __WINDOWS__
-    const wchar_t *icon_path_env = _wgetenv(L"SCRCPY_ICON_PATH");
-#else
-    const char *icon_path_env = getenv("SCRCPY_ICON_PATH");
-#endif
-    if (icon_path_env) {
-        // if the envvar is set, use it
-#ifdef __WINDOWS__
-        char *icon_path = sc_str_from_wchars(icon_path_env);
-#else
-        char *icon_path = strdup(icon_path_env);
-#endif
-        if (!icon_path) {
-            LOG_OOM();
-            return NULL;
-        }
-        LOGD("Using SCRCPY_ICON_PATH: %s", icon_path);
-        return icon_path;
-    }
-
-#ifndef PORTABLE
-    LOGD("Using icon: " SCRCPY_DEFAULT_ICON_PATH);
-    char *icon_path = strdup(SCRCPY_DEFAULT_ICON_PATH);
-    if (!icon_path) {
-        LOG_OOM();
-        return NULL;
-    }
-#else
-    char *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 image codec: %s", path);
-        goto free_ctx;
-    }
-
-    if (avformat_find_stream_info(ctx, NULL) < 0) {
-        LOGE("Could not find image stream info");
-        goto close_input;
-    }
-
-    int stream = av_find_best_stream(ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
-    if (stream < 0 ) {
-        LOGE("Could not find best image stream");
-        goto close_input;
-    }
-
-    AVCodecParameters *params = ctx->streams[stream]->codecpar;
-
-    const AVCodec *codec = avcodec_find_decoder(params->codec_id);
-    if (!codec) {
-        LOGE("Could not find image decoder");
-        goto close_input;
-    }
-
-    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
-    if (!codec_ctx) {
-        LOG_OOM();
-        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 close_codec;
-    }
-
-    AVPacket *packet = av_packet_alloc();
-    if (!packet) {
-        LOG_OOM();
-        av_frame_free(&frame);
-        goto close_codec;
-    }
-
-    if (av_read_frame(ctx, packet) < 0) {
-        LOGE("Could not read frame");
-        av_packet_free(&packet);
-        av_frame_free(&frame);
-        goto close_codec;
-    }
-
-    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 close_codec;
-    }
-
-    if ((ret = avcodec_receive_frame(codec_ctx, frame)) != 0) {
-        LOGE("Could not receive icon frame: %d", ret);
-        av_packet_free(&packet);
-        av_frame_free(&frame);
-        goto close_codec;
-    }
-
-    av_packet_free(&packet);
-
-    result = frame;
-
-close_codec:
-    avcodec_close(codec_ctx);
-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() {
-    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);
-}

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

app/src/icon.xpm

@@ -0,0 +1,53 @@
+/* XPM */
+static char * icon_xpm[] = {
+"48 48 2 1",
+" 	c None",
+".	c #96C13E",
+"              ..                ..              ",
+"              ...              ...              ",
+"               ...   ......   ...               ",
+"                ................                ",
+"                 ..............                 ",
+"                ................                ",
+"               ..................               ",
+"              ....................              ",
+"             .....  ........  .....             ",
+"             .....  ........  .....             ",
+"             ......................             ",
+"            ........................            ",
+"            ........................            ",
+"            ........................            ",
+"                                                ",
+"                                                ",
+"     ....   ........................   ....     ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"    ......  ........................  ......    ",
+"     ....   ........................   ....     ",
+"            ........................            ",
+"             ......................             ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                ......    ......                ",
+"                 ....      ....                 "};

app/src/input_events.h

@@ -1,454 +0,0 @@
-#ifndef SC_INPUT_EVENTS_H
-#define SC_INPUT_EVENTS_H
-
-#include "common.h"
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <SDL2/SDL_events.h>
-
-#include "coords.h"
-
-/* The representation of input events in scrcpy is very close to the SDL API,
- * for simplicity.
- *
- * This scrcpy input events API is designed to be consumed by input event
- * processors (sc_key_processor and sc_mouse_processor, see app/src/trait/).
- *
- * One major semantic difference between SDL input events and scrcpy input
- * events is their frame of reference (for mouse and touch events): SDL events
- * coordinates are expressed in SDL window coordinates (the visible UI), while
- * scrcpy events are expressed in device frame coordinates.
- *
- * In particular, the window may be visually scaled or rotated (with --rotation
- * or MOD+Left/Right), but this does not impact scrcpy input events (contrary
- * to SDL input events). This allows to abstract these display details from the
- * input event processors (and to make them independent from the "screen").
- *
- * For many enums below, the values are purposely the same as the SDL
- * constants (though not all SDL values are represented), so that the
- * implementation to convert from the SDL version to the scrcpy version is
- * straightforward.
- *
- * In practice, there are 3 levels of input events:
- *  1. SDL input events (as received from SDL)
- *  2. scrcpy input events (this API)
- *  3. the key/mouse processors input events (Android API or HID events)
- *
- * An input event is first received (1), then (if accepted) converted to an
- * scrcpy input event (2), then submitted to the relevant key/mouse processor,
- * which (if accepted) is converted to an Android event (to be sent to the
- * server) or to an HID event (to be sent over USB/AOA directly).
- */
-
-enum sc_mod {
-    SC_MOD_LSHIFT = KMOD_LSHIFT,
-    SC_MOD_RSHIFT = KMOD_RSHIFT,
-    SC_MOD_LCTRL = KMOD_LCTRL,
-    SC_MOD_RCTRL = KMOD_RCTRL,
-    SC_MOD_LALT = KMOD_LALT,
-    SC_MOD_RALT = KMOD_RALT,
-    SC_MOD_LGUI = KMOD_LGUI,
-    SC_MOD_RGUI = KMOD_RGUI,
-
-    SC_MOD_NUM = KMOD_NUM,
-    SC_MOD_CAPS = KMOD_CAPS,
-};
-
-enum sc_action {
-    SC_ACTION_DOWN, // key or button pressed
-    SC_ACTION_UP, // key or button released
-};
-
-enum sc_keycode {
-    SC_KEYCODE_UNKNOWN = SDLK_UNKNOWN,
-
-    SC_KEYCODE_RETURN = SDLK_RETURN,
-    SC_KEYCODE_ESCAPE = SDLK_ESCAPE,
-    SC_KEYCODE_BACKSPACE = SDLK_BACKSPACE,
-    SC_KEYCODE_TAB = SDLK_TAB,
-    SC_KEYCODE_SPACE = SDLK_SPACE,
-    SC_KEYCODE_EXCLAIM = SDLK_EXCLAIM,
-    SC_KEYCODE_QUOTEDBL = SDLK_QUOTEDBL,
-    SC_KEYCODE_HASH = SDLK_HASH,
-    SC_KEYCODE_PERCENT = SDLK_PERCENT,
-    SC_KEYCODE_DOLLAR = SDLK_DOLLAR,
-    SC_KEYCODE_AMPERSAND = SDLK_AMPERSAND,
-    SC_KEYCODE_QUOTE = SDLK_QUOTE,
-    SC_KEYCODE_LEFTPAREN = SDLK_LEFTPAREN,
-    SC_KEYCODE_RIGHTPAREN = SDLK_RIGHTPAREN,
-    SC_KEYCODE_ASTERISK = SDLK_ASTERISK,
-    SC_KEYCODE_PLUS = SDLK_PLUS,
-    SC_KEYCODE_COMMA = SDLK_COMMA,
-    SC_KEYCODE_MINUS = SDLK_MINUS,
-    SC_KEYCODE_PERIOD = SDLK_PERIOD,
-    SC_KEYCODE_SLASH = SDLK_SLASH,
-    SC_KEYCODE_0 = SDLK_0,
-    SC_KEYCODE_1 = SDLK_1,
-    SC_KEYCODE_2 = SDLK_2,
-    SC_KEYCODE_3 = SDLK_3,
-    SC_KEYCODE_4 = SDLK_4,
-    SC_KEYCODE_5 = SDLK_5,
-    SC_KEYCODE_6 = SDLK_6,
-    SC_KEYCODE_7 = SDLK_7,
-    SC_KEYCODE_8 = SDLK_8,
-    SC_KEYCODE_9 = SDLK_9,
-    SC_KEYCODE_COLON = SDLK_COLON,
-    SC_KEYCODE_SEMICOLON = SDLK_SEMICOLON,
-    SC_KEYCODE_LESS = SDLK_LESS,
-    SC_KEYCODE_EQUALS = SDLK_EQUALS,
-    SC_KEYCODE_GREATER = SDLK_GREATER,
-    SC_KEYCODE_QUESTION = SDLK_QUESTION,
-    SC_KEYCODE_AT = SDLK_AT,
-
-    SC_KEYCODE_LEFTBRACKET = SDLK_LEFTBRACKET,
-    SC_KEYCODE_BACKSLASH = SDLK_BACKSLASH,
-    SC_KEYCODE_RIGHTBRACKET = SDLK_RIGHTBRACKET,
-    SC_KEYCODE_CARET = SDLK_CARET,
-    SC_KEYCODE_UNDERSCORE = SDLK_UNDERSCORE,
-    SC_KEYCODE_BACKQUOTE = SDLK_BACKQUOTE,
-    SC_KEYCODE_a = SDLK_a,
-    SC_KEYCODE_b = SDLK_b,
-    SC_KEYCODE_c = SDLK_c,
-    SC_KEYCODE_d = SDLK_d,
-    SC_KEYCODE_e = SDLK_e,
-    SC_KEYCODE_f = SDLK_f,
-    SC_KEYCODE_g = SDLK_g,
-    SC_KEYCODE_h = SDLK_h,
-    SC_KEYCODE_i = SDLK_i,
-    SC_KEYCODE_j = SDLK_j,
-    SC_KEYCODE_k = SDLK_k,
-    SC_KEYCODE_l = SDLK_l,
-    SC_KEYCODE_m = SDLK_m,
-    SC_KEYCODE_n = SDLK_n,
-    SC_KEYCODE_o = SDLK_o,
-    SC_KEYCODE_p = SDLK_p,
-    SC_KEYCODE_q = SDLK_q,
-    SC_KEYCODE_r = SDLK_r,
-    SC_KEYCODE_s = SDLK_s,
-    SC_KEYCODE_t = SDLK_t,
-    SC_KEYCODE_u = SDLK_u,
-    SC_KEYCODE_v = SDLK_v,
-    SC_KEYCODE_w = SDLK_w,
-    SC_KEYCODE_x = SDLK_x,
-    SC_KEYCODE_y = SDLK_y,
-    SC_KEYCODE_z = SDLK_z,
-
-    SC_KEYCODE_CAPSLOCK = SDLK_CAPSLOCK,
-
-    SC_KEYCODE_F1 = SDLK_F1,
-    SC_KEYCODE_F2 = SDLK_F2,
-    SC_KEYCODE_F3 = SDLK_F3,
-    SC_KEYCODE_F4 = SDLK_F4,
-    SC_KEYCODE_F5 = SDLK_F5,
-    SC_KEYCODE_F6 = SDLK_F6,
-    SC_KEYCODE_F7 = SDLK_F7,
-    SC_KEYCODE_F8 = SDLK_F8,
-    SC_KEYCODE_F9 = SDLK_F9,
-    SC_KEYCODE_F10 = SDLK_F10,
-    SC_KEYCODE_F11 = SDLK_F11,
-    SC_KEYCODE_F12 = SDLK_F12,
-
-    SC_KEYCODE_PRINTSCREEN = SDLK_PRINTSCREEN,
-    SC_KEYCODE_SCROLLLOCK = SDLK_SCROLLLOCK,
-    SC_KEYCODE_PAUSE = SDLK_PAUSE,
-    SC_KEYCODE_INSERT = SDLK_INSERT,
-    SC_KEYCODE_HOME = SDLK_HOME,
-    SC_KEYCODE_PAGEUP = SDLK_PAGEUP,
-    SC_KEYCODE_DELETE = SDLK_DELETE,
-    SC_KEYCODE_END = SDLK_END,
-    SC_KEYCODE_PAGEDOWN = SDLK_PAGEDOWN,
-    SC_KEYCODE_RIGHT = SDLK_RIGHT,
-    SC_KEYCODE_LEFT = SDLK_LEFT,
-    SC_KEYCODE_DOWN = SDLK_DOWN,
-    SC_KEYCODE_UP = SDLK_UP,
-
-    SC_KEYCODE_KP_DIVIDE = SDLK_KP_DIVIDE,
-    SC_KEYCODE_KP_MULTIPLY = SDLK_KP_MULTIPLY,
-    SC_KEYCODE_KP_MINUS = SDLK_KP_MINUS,
-    SC_KEYCODE_KP_PLUS = SDLK_KP_PLUS,
-    SC_KEYCODE_KP_ENTER = SDLK_KP_ENTER,
-    SC_KEYCODE_KP_1 = SDLK_KP_1,
-    SC_KEYCODE_KP_2 = SDLK_KP_2,
-    SC_KEYCODE_KP_3 = SDLK_KP_3,
-    SC_KEYCODE_KP_4 = SDLK_KP_4,
-    SC_KEYCODE_KP_5 = SDLK_KP_5,
-    SC_KEYCODE_KP_6 = SDLK_KP_6,
-    SC_KEYCODE_KP_7 = SDLK_KP_7,
-    SC_KEYCODE_KP_8 = SDLK_KP_8,
-    SC_KEYCODE_KP_9 = SDLK_KP_9,
-    SC_KEYCODE_KP_0 = SDLK_KP_0,
-    SC_KEYCODE_KP_PERIOD = SDLK_KP_PERIOD,
-    SC_KEYCODE_KP_EQUALS = SDLK_KP_EQUALS,
-    SC_KEYCODE_KP_LEFTPAREN = SDLK_KP_LEFTPAREN,
-    SC_KEYCODE_KP_RIGHTPAREN = SDLK_KP_RIGHTPAREN,
-
-    SC_KEYCODE_LCTRL = SDLK_LCTRL,
-    SC_KEYCODE_LSHIFT = SDLK_LSHIFT,
-    SC_KEYCODE_LALT = SDLK_LALT,
-    SC_KEYCODE_LGUI = SDLK_LGUI,
-    SC_KEYCODE_RCTRL = SDLK_RCTRL,
-    SC_KEYCODE_RSHIFT = SDLK_RSHIFT,
-    SC_KEYCODE_RALT = SDLK_RALT,
-    SC_KEYCODE_RGUI = SDLK_RGUI,
-};
-
-enum sc_scancode {
-    SC_SCANCODE_UNKNOWN = SDL_SCANCODE_UNKNOWN,
-
-    SC_SCANCODE_A = SDL_SCANCODE_A,
-    SC_SCANCODE_B = SDL_SCANCODE_B,
-    SC_SCANCODE_C = SDL_SCANCODE_C,
-    SC_SCANCODE_D = SDL_SCANCODE_D,
-    SC_SCANCODE_E = SDL_SCANCODE_E,
-    SC_SCANCODE_F = SDL_SCANCODE_F,
-    SC_SCANCODE_G = SDL_SCANCODE_G,
-    SC_SCANCODE_H = SDL_SCANCODE_H,
-    SC_SCANCODE_I = SDL_SCANCODE_I,
-    SC_SCANCODE_J = SDL_SCANCODE_J,
-    SC_SCANCODE_K = SDL_SCANCODE_K,
-    SC_SCANCODE_L = SDL_SCANCODE_L,
-    SC_SCANCODE_M = SDL_SCANCODE_M,
-    SC_SCANCODE_N = SDL_SCANCODE_N,
-    SC_SCANCODE_O = SDL_SCANCODE_O,
-    SC_SCANCODE_P = SDL_SCANCODE_P,
-    SC_SCANCODE_Q = SDL_SCANCODE_Q,
-    SC_SCANCODE_R = SDL_SCANCODE_R,
-    SC_SCANCODE_S = SDL_SCANCODE_S,
-    SC_SCANCODE_T = SDL_SCANCODE_T,
-    SC_SCANCODE_U = SDL_SCANCODE_U,
-    SC_SCANCODE_V = SDL_SCANCODE_V,
-    SC_SCANCODE_W = SDL_SCANCODE_W,
-    SC_SCANCODE_X = SDL_SCANCODE_X,
-    SC_SCANCODE_Y = SDL_SCANCODE_Y,
-    SC_SCANCODE_Z = SDL_SCANCODE_Z,
-
-    SC_SCANCODE_1 = SDL_SCANCODE_1,
-    SC_SCANCODE_2 = SDL_SCANCODE_2,
-    SC_SCANCODE_3 = SDL_SCANCODE_3,
-    SC_SCANCODE_4 = SDL_SCANCODE_4,
-    SC_SCANCODE_5 = SDL_SCANCODE_5,
-    SC_SCANCODE_6 = SDL_SCANCODE_6,
-    SC_SCANCODE_7 = SDL_SCANCODE_7,
-    SC_SCANCODE_8 = SDL_SCANCODE_8,
-    SC_SCANCODE_9 = SDL_SCANCODE_9,
-    SC_SCANCODE_0 = SDL_SCANCODE_0,
-
-    SC_SCANCODE_RETURN = SDL_SCANCODE_RETURN,
-    SC_SCANCODE_ESCAPE = SDL_SCANCODE_ESCAPE,
-    SC_SCANCODE_BACKSPACE = SDL_SCANCODE_BACKSPACE,
-    SC_SCANCODE_TAB = SDL_SCANCODE_TAB,
-    SC_SCANCODE_SPACE = SDL_SCANCODE_SPACE,
-
-    SC_SCANCODE_MINUS = SDL_SCANCODE_MINUS,
-    SC_SCANCODE_EQUALS = SDL_SCANCODE_EQUALS,
-    SC_SCANCODE_LEFTBRACKET = SDL_SCANCODE_LEFTBRACKET,
-    SC_SCANCODE_RIGHTBRACKET = SDL_SCANCODE_RIGHTBRACKET,
-    SC_SCANCODE_BACKSLASH = SDL_SCANCODE_BACKSLASH,
-    SC_SCANCODE_NONUSHASH = SDL_SCANCODE_NONUSHASH,
-    SC_SCANCODE_SEMICOLON = SDL_SCANCODE_SEMICOLON,
-    SC_SCANCODE_APOSTROPHE = SDL_SCANCODE_APOSTROPHE,
-    SC_SCANCODE_GRAVE = SDL_SCANCODE_GRAVE,
-    SC_SCANCODE_COMMA = SDL_SCANCODE_COMMA,
-    SC_SCANCODE_PERIOD = SDL_SCANCODE_PERIOD,
-    SC_SCANCODE_SLASH = SDL_SCANCODE_SLASH,
-
-    SC_SCANCODE_CAPSLOCK = SDL_SCANCODE_CAPSLOCK,
-
-    SC_SCANCODE_F1 = SDL_SCANCODE_F1,
-    SC_SCANCODE_F2 = SDL_SCANCODE_F2,
-    SC_SCANCODE_F3 = SDL_SCANCODE_F3,
-    SC_SCANCODE_F4 = SDL_SCANCODE_F4,
-    SC_SCANCODE_F5 = SDL_SCANCODE_F5,
-    SC_SCANCODE_F6 = SDL_SCANCODE_F6,
-    SC_SCANCODE_F7 = SDL_SCANCODE_F7,
-    SC_SCANCODE_F8 = SDL_SCANCODE_F8,
-    SC_SCANCODE_F9 = SDL_SCANCODE_F9,
-    SC_SCANCODE_F10 = SDL_SCANCODE_F10,
-    SC_SCANCODE_F11 = SDL_SCANCODE_F11,
-    SC_SCANCODE_F12 = SDL_SCANCODE_F12,
-
-    SC_SCANCODE_PRINTSCREEN = SDL_SCANCODE_PRINTSCREEN,
-    SC_SCANCODE_SCROLLLOCK = SDL_SCANCODE_SCROLLLOCK,
-    SC_SCANCODE_PAUSE = SDL_SCANCODE_PAUSE,
-    SC_SCANCODE_INSERT = SDL_SCANCODE_INSERT,
-    SC_SCANCODE_HOME = SDL_SCANCODE_HOME,
-    SC_SCANCODE_PAGEUP = SDL_SCANCODE_PAGEUP,
-    SC_SCANCODE_DELETE = SDL_SCANCODE_DELETE,
-    SC_SCANCODE_END = SDL_SCANCODE_END,
-    SC_SCANCODE_PAGEDOWN = SDL_SCANCODE_PAGEDOWN,
-    SC_SCANCODE_RIGHT = SDL_SCANCODE_RIGHT,
-    SC_SCANCODE_LEFT = SDL_SCANCODE_LEFT,
-    SC_SCANCODE_DOWN = SDL_SCANCODE_DOWN,
-    SC_SCANCODE_UP = SDL_SCANCODE_UP,
-
-    SC_SCANCODE_NUMLOCK = SDL_SCANCODE_NUMLOCKCLEAR,
-    SC_SCANCODE_KP_DIVIDE = SDL_SCANCODE_KP_DIVIDE,
-    SC_SCANCODE_KP_MULTIPLY = SDL_SCANCODE_KP_MULTIPLY,
-    SC_SCANCODE_KP_MINUS = SDL_SCANCODE_KP_MINUS,
-    SC_SCANCODE_KP_PLUS = SDL_SCANCODE_KP_PLUS,
-    SC_SCANCODE_KP_ENTER = SDL_SCANCODE_KP_ENTER,
-    SC_SCANCODE_KP_1 = SDL_SCANCODE_KP_1,
-    SC_SCANCODE_KP_2 = SDL_SCANCODE_KP_2,
-    SC_SCANCODE_KP_3 = SDL_SCANCODE_KP_3,
-    SC_SCANCODE_KP_4 = SDL_SCANCODE_KP_4,
-    SC_SCANCODE_KP_5 = SDL_SCANCODE_KP_5,
-    SC_SCANCODE_KP_6 = SDL_SCANCODE_KP_6,
-    SC_SCANCODE_KP_7 = SDL_SCANCODE_KP_7,
-    SC_SCANCODE_KP_8 = SDL_SCANCODE_KP_8,
-    SC_SCANCODE_KP_9 = SDL_SCANCODE_KP_9,
-    SC_SCANCODE_KP_0 = SDL_SCANCODE_KP_0,
-    SC_SCANCODE_KP_PERIOD = SDL_SCANCODE_KP_PERIOD,
-
-    SC_SCANCODE_LCTRL = SDL_SCANCODE_LCTRL,
-    SC_SCANCODE_LSHIFT = SDL_SCANCODE_LSHIFT,
-    SC_SCANCODE_LALT = SDL_SCANCODE_LALT,
-    SC_SCANCODE_LGUI = SDL_SCANCODE_LGUI,
-    SC_SCANCODE_RCTRL = SDL_SCANCODE_RCTRL,
-    SC_SCANCODE_RSHIFT = SDL_SCANCODE_RSHIFT,
-    SC_SCANCODE_RALT = SDL_SCANCODE_RALT,
-    SC_SCANCODE_RGUI = SDL_SCANCODE_RGUI,
-};
-
-// On purpose, only use the "mask" values (1, 2, 4, 8, 16) for a single button,
-// to avoid unnecessary conversions (and confusion).
-enum sc_mouse_button {
-    SC_MOUSE_BUTTON_UNKNOWN = 0,
-    SC_MOUSE_BUTTON_LEFT = SDL_BUTTON(SDL_BUTTON_LEFT),
-    SC_MOUSE_BUTTON_RIGHT = SDL_BUTTON(SDL_BUTTON_RIGHT),
-    SC_MOUSE_BUTTON_MIDDLE = SDL_BUTTON(SDL_BUTTON_MIDDLE),
-    SC_MOUSE_BUTTON_X1 = SDL_BUTTON(SDL_BUTTON_X1),
-    SC_MOUSE_BUTTON_X2 = SDL_BUTTON(SDL_BUTTON_X2),
-};
-
-static_assert(sizeof(enum sc_mod) >= sizeof(SDL_Keymod),
-              "SDL_Keymod must be convertible to sc_mod");
-
-static_assert(sizeof(enum sc_keycode) >= sizeof(SDL_Keycode),
-              "SDL_Keycode must be convertible to sc_keycode");
-
-static_assert(sizeof(enum sc_scancode) >= sizeof(SDL_Scancode),
-              "SDL_Scancode must be convertible to sc_scancode");
-
-enum sc_touch_action {
-    SC_TOUCH_ACTION_MOVE,
-    SC_TOUCH_ACTION_DOWN,
-    SC_TOUCH_ACTION_UP,
-};
-
-struct sc_key_event {
-    enum sc_action action;
-    enum sc_keycode keycode;
-    enum sc_scancode scancode;
-    uint16_t mods_state; // bitwise-OR of sc_mod values
-    bool repeat;
-};
-
-struct sc_text_event {
-    const char *text; // not owned
-};
-
-struct sc_mouse_click_event {
-    struct sc_position position;
-    enum sc_action action;
-    enum sc_mouse_button button;
-    uint64_t pointer_id;
-    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
-};
-
-struct sc_mouse_scroll_event {
-    struct sc_position position;
-    float hscroll;
-    float vscroll;
-    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
-};
-
-struct sc_mouse_motion_event {
-    struct sc_position position;
-    uint64_t pointer_id;
-    int32_t xrel;
-    int32_t yrel;
-    uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
-};
-
-struct sc_touch_event {
-    struct sc_position position;
-    enum sc_touch_action action;
-    uint64_t pointer_id;
-    float pressure;
-};
-
-static inline uint16_t
-sc_mods_state_from_sdl(uint16_t mods_state) {
-    return mods_state;
-}
-
-static inline enum sc_keycode
-sc_keycode_from_sdl(SDL_Keycode keycode) {
-    return (enum sc_keycode) keycode;
-}
-
-static inline enum sc_scancode
-sc_scancode_from_sdl(SDL_Scancode scancode) {
-    return (enum sc_scancode) scancode;
-}
-
-static inline enum sc_action
-sc_action_from_sdl_keyboard_type(uint32_t type) {
-    assert(type == SDL_KEYDOWN || type == SDL_KEYUP);
-    if (type == SDL_KEYDOWN) {
-        return SC_ACTION_DOWN;
-    }
-    return SC_ACTION_UP;
-}
-
-static inline enum sc_action
-sc_action_from_sdl_mousebutton_type(uint32_t type) {
-    assert(type == SDL_MOUSEBUTTONDOWN || type == SDL_MOUSEBUTTONUP);
-    if (type == SDL_MOUSEBUTTONDOWN) {
-        return SC_ACTION_DOWN;
-    }
-    return SC_ACTION_UP;
-}
-
-static inline enum sc_touch_action
-sc_touch_action_from_sdl(uint32_t type) {
-    assert(type == SDL_FINGERMOTION || type == SDL_FINGERDOWN ||
-           type == SDL_FINGERUP);
-    if (type == SDL_FINGERMOTION) {
-        return SC_TOUCH_ACTION_MOVE;
-    }
-    if (type == SDL_FINGERDOWN) {
-        return SC_TOUCH_ACTION_DOWN;
-    }
-    return SC_TOUCH_ACTION_UP;
-}
-
-static inline enum sc_mouse_button
-sc_mouse_button_from_sdl(uint8_t button) {
-    if (button >= SDL_BUTTON_LEFT && button <= SDL_BUTTON_X2) {
-        // SC_MOUSE_BUTTON_* constants are initialized from SDL_BUTTON(index)
-        return SDL_BUTTON(button);
-    }
-
-    return SC_MOUSE_BUTTON_UNKNOWN;
-}
-
-static inline uint8_t
-sc_mouse_buttons_state_from_sdl(uint32_t buttons_state,
-                                bool forward_all_clicks) {
-    assert(buttons_state < 0x100); // fits in uint8_t
-
-    uint8_t mask = SC_MOUSE_BUTTON_LEFT;
-    if (forward_all_clicks) {
-        mask |= SC_MOUSE_BUTTON_RIGHT
-              | SC_MOUSE_BUTTON_MIDDLE
-              | SC_MOUSE_BUTTON_X1
-              | SC_MOUSE_BUTTON_X2;
-    }
-
-    return buttons_state & mask;
-}
-
-#endif

app/src/input_manager.h

@@ -1,66 +1,27 @@
-#ifndef SC_INPUTMANAGER_H
-#define SC_INPUTMANAGER_H
+#ifndef INPUTMANAGER_H
+#define INPUTMANAGER_H
 
 #include "common.h"
-
-#include <stdbool.h>
-
-#include <SDL2/SDL.h>
-
 #include "controller.h"
-#include "file_pusher.h"
 #include "fps_counter.h"
-#include "options.h"
-#include "trait/key_processor.h"
-#include "trait/mouse_processor.h"
+#include "frames.h"
+#include "screen.h"
 
-struct sc_input_manager {
-    struct sc_controller *controller;
-    struct sc_file_pusher *fp;
-    struct sc_screen *screen;
-
-    struct sc_key_processor *kp;
-    struct sc_mouse_processor *mp;
-
-    bool forward_all_clicks;
-    bool legacy_paste;
-    bool clipboard_autosync;
-
-    struct {
-        unsigned data[SC_MAX_SHORTCUT_MODS];
-        unsigned count;
-    } sdl_shortcut_mods;
-
-    bool vfinger_down;
-
-    // Tracks the number of identical consecutive shortcut key down events.
-    // Not to be confused with event->repeat, which counts the number of
-    // system-generated repeated key presses.
-    unsigned key_repeat;
-    SDL_Keycode last_keycode;
-    uint16_t last_mod;
-
-    uint64_t next_sequence; // used for request acknowledgements
+struct input_manager {
+    struct controller *controller;
+    struct frames *frames;
+    struct screen *screen;
 };
 
-struct sc_input_manager_params {
-    struct sc_controller *controller;
-    struct sc_file_pusher *fp;
-    struct sc_screen *screen;
-    struct sc_key_processor *kp;
-    struct sc_mouse_processor *mp;
-
-    bool forward_all_clicks;
-    bool legacy_paste;
-    bool clipboard_autosync;
-    const struct sc_shortcut_mods *shortcut_mods;
-};
-
-void
-sc_input_manager_init(struct sc_input_manager *im,
-                      const struct sc_input_manager_params *params);
-
-void
-sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event);
+void input_manager_process_text_input(struct input_manager *input_manager,
+                                      const SDL_TextInputEvent *event);
+void input_manager_process_key(struct input_manager *input_manager,
+                               const SDL_KeyboardEvent *event);
+void input_manager_process_mouse_motion(struct input_manager *input_manager,
+                                        const SDL_MouseMotionEvent *event);
+void input_manager_process_mouse_button(struct input_manager *input_manager,
+                                        const SDL_MouseButtonEvent *event);
+void input_manager_process_mouse_wheel(struct input_manager *input_manager,
+                                       const SDL_MouseWheelEvent *event);
 
 #endif

app/src/keyboard_inject.c

@@ -1,344 +0,0 @@
-#include "keyboard_inject.h"
-
-#include <assert.h>
-
-#include "android/input.h"
-#include "control_msg.h"
-#include "controller.h"
-#include "input_events.h"
-#include "util/intmap.h"
-#include "util/log.h"
-
-/** Downcast key processor to sc_keyboard_inject */
-#define DOWNCAST(KP) container_of(KP, struct sc_keyboard_inject, key_processor)
-
-static enum android_keyevent_action
-convert_keycode_action(enum sc_action action) {
-    if (action == SC_ACTION_DOWN) {
-        return AKEY_EVENT_ACTION_DOWN;
-    }
-    assert(action == SC_ACTION_UP);
-    return AKEY_EVENT_ACTION_UP;
-}
-
-static bool
-convert_keycode(enum sc_keycode from, enum android_keycode *to, uint16_t mod,
-                enum sc_key_inject_mode key_inject_mode) {
-    // Navigation keys and ENTER.
-    // Used in all modes.
-    static const struct sc_intmap_entry special_keys[] = {
-        {SC_KEYCODE_RETURN,    AKEYCODE_ENTER},
-        {SC_KEYCODE_KP_ENTER,  AKEYCODE_NUMPAD_ENTER},
-        {SC_KEYCODE_ESCAPE,    AKEYCODE_ESCAPE},
-        {SC_KEYCODE_BACKSPACE, AKEYCODE_DEL},
-        {SC_KEYCODE_TAB,       AKEYCODE_TAB},
-        {SC_KEYCODE_PAGEUP,    AKEYCODE_PAGE_UP},
-        {SC_KEYCODE_DELETE,    AKEYCODE_FORWARD_DEL},
-        {SC_KEYCODE_HOME,      AKEYCODE_MOVE_HOME},
-        {SC_KEYCODE_END,       AKEYCODE_MOVE_END},
-        {SC_KEYCODE_PAGEDOWN,  AKEYCODE_PAGE_DOWN},
-        {SC_KEYCODE_RIGHT,     AKEYCODE_DPAD_RIGHT},
-        {SC_KEYCODE_LEFT,      AKEYCODE_DPAD_LEFT},
-        {SC_KEYCODE_DOWN,      AKEYCODE_DPAD_DOWN},
-        {SC_KEYCODE_UP,        AKEYCODE_DPAD_UP},
-        {SC_KEYCODE_LCTRL,     AKEYCODE_CTRL_LEFT},
-        {SC_KEYCODE_RCTRL,     AKEYCODE_CTRL_RIGHT},
-        {SC_KEYCODE_LSHIFT,    AKEYCODE_SHIFT_LEFT},
-        {SC_KEYCODE_RSHIFT,    AKEYCODE_SHIFT_RIGHT},
-    };
-
-    // Numpad navigation keys.
-    // Used in all modes, when NumLock and Shift are disabled.
-    static const struct sc_intmap_entry kp_nav_keys[] = {
-        {SC_KEYCODE_KP_0,      AKEYCODE_INSERT},
-        {SC_KEYCODE_KP_1,      AKEYCODE_MOVE_END},
-        {SC_KEYCODE_KP_2,      AKEYCODE_DPAD_DOWN},
-        {SC_KEYCODE_KP_3,      AKEYCODE_PAGE_DOWN},
-        {SC_KEYCODE_KP_4,      AKEYCODE_DPAD_LEFT},
-        {SC_KEYCODE_KP_6,      AKEYCODE_DPAD_RIGHT},
-        {SC_KEYCODE_KP_7,      AKEYCODE_MOVE_HOME},
-        {SC_KEYCODE_KP_8,      AKEYCODE_DPAD_UP},
-        {SC_KEYCODE_KP_9,      AKEYCODE_PAGE_UP},
-        {SC_KEYCODE_KP_PERIOD, AKEYCODE_FORWARD_DEL},
-    };
-
-    // Letters and space.
-    // Used in non-text mode.
-    static const struct sc_intmap_entry alphaspace_keys[] = {
-        {SC_KEYCODE_a,         AKEYCODE_A},
-        {SC_KEYCODE_b,         AKEYCODE_B},
-        {SC_KEYCODE_c,         AKEYCODE_C},
-        {SC_KEYCODE_d,         AKEYCODE_D},
-        {SC_KEYCODE_e,         AKEYCODE_E},
-        {SC_KEYCODE_f,         AKEYCODE_F},
-        {SC_KEYCODE_g,         AKEYCODE_G},
-        {SC_KEYCODE_h,         AKEYCODE_H},
-        {SC_KEYCODE_i,         AKEYCODE_I},
-        {SC_KEYCODE_j,         AKEYCODE_J},
-        {SC_KEYCODE_k,         AKEYCODE_K},
-        {SC_KEYCODE_l,         AKEYCODE_L},
-        {SC_KEYCODE_m,         AKEYCODE_M},
-        {SC_KEYCODE_n,         AKEYCODE_N},
-        {SC_KEYCODE_o,         AKEYCODE_O},
-        {SC_KEYCODE_p,         AKEYCODE_P},
-        {SC_KEYCODE_q,         AKEYCODE_Q},
-        {SC_KEYCODE_r,         AKEYCODE_R},
-        {SC_KEYCODE_s,         AKEYCODE_S},
-        {SC_KEYCODE_t,         AKEYCODE_T},
-        {SC_KEYCODE_u,         AKEYCODE_U},
-        {SC_KEYCODE_v,         AKEYCODE_V},
-        {SC_KEYCODE_w,         AKEYCODE_W},
-        {SC_KEYCODE_x,         AKEYCODE_X},
-        {SC_KEYCODE_y,         AKEYCODE_Y},
-        {SC_KEYCODE_z,         AKEYCODE_Z},
-        {SC_KEYCODE_SPACE,     AKEYCODE_SPACE},
-    };
-
-    // Numbers and punctuation keys.
-    // Used in raw mode only.
-    static const struct sc_intmap_entry numbers_punct_keys[] = {
-        {SC_KEYCODE_HASH,          AKEYCODE_POUND},
-        {SC_KEYCODE_PERCENT,       AKEYCODE_PERIOD},
-        {SC_KEYCODE_QUOTE,         AKEYCODE_APOSTROPHE},
-        {SC_KEYCODE_ASTERISK,      AKEYCODE_STAR},
-        {SC_KEYCODE_PLUS,          AKEYCODE_PLUS},
-        {SC_KEYCODE_COMMA,         AKEYCODE_COMMA},
-        {SC_KEYCODE_MINUS,         AKEYCODE_MINUS},
-        {SC_KEYCODE_PERIOD,        AKEYCODE_PERIOD},
-        {SC_KEYCODE_SLASH,         AKEYCODE_SLASH},
-        {SC_KEYCODE_0,             AKEYCODE_0},
-        {SC_KEYCODE_1,             AKEYCODE_1},
-        {SC_KEYCODE_2,             AKEYCODE_2},
-        {SC_KEYCODE_3,             AKEYCODE_3},
-        {SC_KEYCODE_4,             AKEYCODE_4},
-        {SC_KEYCODE_5,             AKEYCODE_5},
-        {SC_KEYCODE_6,             AKEYCODE_6},
-        {SC_KEYCODE_7,             AKEYCODE_7},
-        {SC_KEYCODE_8,             AKEYCODE_8},
-        {SC_KEYCODE_9,             AKEYCODE_9},
-        {SC_KEYCODE_SEMICOLON,     AKEYCODE_SEMICOLON},
-        {SC_KEYCODE_EQUALS,        AKEYCODE_EQUALS},
-        {SC_KEYCODE_AT,            AKEYCODE_AT},
-        {SC_KEYCODE_LEFTBRACKET,   AKEYCODE_LEFT_BRACKET},
-        {SC_KEYCODE_BACKSLASH,     AKEYCODE_BACKSLASH},
-        {SC_KEYCODE_RIGHTBRACKET,  AKEYCODE_RIGHT_BRACKET},
-        {SC_KEYCODE_BACKQUOTE,     AKEYCODE_GRAVE},
-        {SC_KEYCODE_KP_1,          AKEYCODE_NUMPAD_1},
-        {SC_KEYCODE_KP_2,          AKEYCODE_NUMPAD_2},
-        {SC_KEYCODE_KP_3,          AKEYCODE_NUMPAD_3},
-        {SC_KEYCODE_KP_4,          AKEYCODE_NUMPAD_4},
-        {SC_KEYCODE_KP_5,          AKEYCODE_NUMPAD_5},
-        {SC_KEYCODE_KP_6,          AKEYCODE_NUMPAD_6},
-        {SC_KEYCODE_KP_7,          AKEYCODE_NUMPAD_7},
-        {SC_KEYCODE_KP_8,          AKEYCODE_NUMPAD_8},
-        {SC_KEYCODE_KP_9,          AKEYCODE_NUMPAD_9},
-        {SC_KEYCODE_KP_0,          AKEYCODE_NUMPAD_0},
-        {SC_KEYCODE_KP_DIVIDE,     AKEYCODE_NUMPAD_DIVIDE},
-        {SC_KEYCODE_KP_MULTIPLY,   AKEYCODE_NUMPAD_MULTIPLY},
-        {SC_KEYCODE_KP_MINUS,      AKEYCODE_NUMPAD_SUBTRACT},
-        {SC_KEYCODE_KP_PLUS,       AKEYCODE_NUMPAD_ADD},
-        {SC_KEYCODE_KP_PERIOD,     AKEYCODE_NUMPAD_DOT},
-        {SC_KEYCODE_KP_EQUALS,     AKEYCODE_NUMPAD_EQUALS},
-        {SC_KEYCODE_KP_LEFTPAREN,  AKEYCODE_NUMPAD_LEFT_PAREN},
-        {SC_KEYCODE_KP_RIGHTPAREN, AKEYCODE_NUMPAD_RIGHT_PAREN},
-    };
-
-    const struct sc_intmap_entry *entry =
-        SC_INTMAP_FIND_ENTRY(special_keys, from);
-    if (entry) {
-        *to = entry->value;
-        return true;
-    }
-
-    if (!(mod & (SC_MOD_NUM | SC_MOD_LSHIFT | SC_MOD_RSHIFT))) {
-        // Handle Numpad events when Num Lock is disabled
-        // If SHIFT is pressed, a text event will be sent instead
-        entry = SC_INTMAP_FIND_ENTRY(kp_nav_keys, from);
-        if (entry) {
-            *to = entry->value;
-            return true;
-        }
-    }
-
-    if (key_inject_mode == SC_KEY_INJECT_MODE_TEXT &&
-            !(mod & (SC_MOD_LCTRL | SC_MOD_RCTRL))) {
-        // do not forward alpha and space key events (unless Ctrl is pressed)
-        return false;
-    }
-
-    if (mod & (SC_MOD_LALT | SC_MOD_RALT | SC_MOD_LGUI | SC_MOD_RGUI)) {
-        return false;
-    }
-
-    // if ALT and META are not pressed, also handle letters and space
-    entry = SC_INTMAP_FIND_ENTRY(alphaspace_keys, from);
-    if (entry) {
-        *to = entry->value;
-        return true;
-    }
-
-    if (key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
-        entry = SC_INTMAP_FIND_ENTRY(numbers_punct_keys, from);
-        if (entry) {
-            *to = entry->value;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-static enum android_metastate
-autocomplete_metastate(enum android_metastate metastate) {
-    // fill dependent 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;
-}
-
-static enum android_metastate
-convert_meta_state(uint16_t mod) {
-    enum android_metastate metastate = 0;
-    if (mod & SC_MOD_LSHIFT) {
-        metastate |= AMETA_SHIFT_LEFT_ON;
-    }
-    if (mod & SC_MOD_RSHIFT) {
-        metastate |= AMETA_SHIFT_RIGHT_ON;
-    }
-    if (mod & SC_MOD_LCTRL) {
-        metastate |= AMETA_CTRL_LEFT_ON;
-    }
-    if (mod & SC_MOD_RCTRL) {
-        metastate |= AMETA_CTRL_RIGHT_ON;
-    }
-    if (mod & SC_MOD_LALT) {
-        metastate |= AMETA_ALT_LEFT_ON;
-    }
-    if (mod & SC_MOD_RALT) {
-        metastate |= AMETA_ALT_RIGHT_ON;
-    }
-    if (mod & SC_MOD_LGUI) { // Windows key
-        metastate |= AMETA_META_LEFT_ON;
-    }
-    if (mod & SC_MOD_RGUI) { // Windows key
-        metastate |= AMETA_META_RIGHT_ON;
-    }
-    if (mod & SC_MOD_NUM) {
-        metastate |= AMETA_NUM_LOCK_ON;
-    }
-    if (mod & SC_MOD_CAPS) {
-        metastate |= AMETA_CAPS_LOCK_ON;
-    }
-
-    // fill the dependent fields
-    return autocomplete_metastate(metastate);
-}
-
-static bool
-convert_input_key(const struct sc_key_event *event, struct sc_control_msg *msg,
-                  enum sc_key_inject_mode key_inject_mode, uint32_t repeat) {
-    msg->type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE;
-
-    if (!convert_keycode(event->keycode, &msg->inject_keycode.keycode,
-                         event->mods_state, key_inject_mode)) {
-        return false;
-    }
-
-    msg->inject_keycode.action = convert_keycode_action(event->action);
-    msg->inject_keycode.repeat = repeat;
-    msg->inject_keycode.metastate = convert_meta_state(event->mods_state);
-
-    return true;
-}
-
-static void
-sc_key_processor_process_key(struct sc_key_processor *kp,
-                             const struct sc_key_event *event,
-                             uint64_t ack_to_wait) {
-    // The device clipboard synchronization and the key event messages are
-    // serialized, there is nothing special to do to ensure that the clipboard
-    // is set before injecting Ctrl+v.
-    (void) ack_to_wait;
-
-    struct sc_keyboard_inject *ki = DOWNCAST(kp);
-
-    if (event->repeat) {
-        if (!ki->forward_key_repeat) {
-            return;
-        }
-        ++ki->repeat;
-    } else {
-        ki->repeat = 0;
-    }
-
-    struct sc_control_msg msg;
-    if (convert_input_key(event, &msg, ki->key_inject_mode, ki->repeat)) {
-        if (!sc_controller_push_msg(ki->controller, &msg)) {
-            LOGW("Could not request 'inject keycode'");
-        }
-    }
-}
-
-static void
-sc_key_processor_process_text(struct sc_key_processor *kp,
-                              const struct sc_text_event *event) {
-    struct sc_keyboard_inject *ki = DOWNCAST(kp);
-
-    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_RAW) {
-        // Never inject text events
-        return;
-    }
-
-    if (ki->key_inject_mode == SC_KEY_INJECT_MODE_MIXED) {
-        char c = event->text[0];
-        if (isalpha(c) || c == ' ') {
-            assert(event->text[1] == '\0');
-            // Letters and space are handled as raw key events
-            return;
-        }
-    }
-
-    struct sc_control_msg msg;
-    msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = strdup(event->text);
-    if (!msg.inject_text.text) {
-        LOGW("Could not strdup input text");
-        return;
-    }
-    if (!sc_controller_push_msg(ki->controller, &msg)) {
-        free(msg.inject_text.text);
-        LOGW("Could not request 'inject text'");
-    }
-}
-
-void
-sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
-                        struct sc_controller *controller,
-                        enum sc_key_inject_mode key_inject_mode,
-                        bool forward_key_repeat) {
-    ki->controller = controller;
-    ki->key_inject_mode = key_inject_mode;
-    ki->forward_key_repeat = forward_key_repeat;
-
-    ki->repeat = 0;
-
-    static const struct sc_key_processor_ops ops = {
-        .process_key = sc_key_processor_process_key,
-        .process_text = sc_key_processor_process_text,
-    };
-
-    // Key injection and clipboard synchronization are serialized
-    ki->key_processor.async_paste = false;
-    ki->key_processor.ops = &ops;
-}

app/src/keyboard_inject.h

@@ -1,31 +0,0 @@
-#ifndef SC_KEYBOARD_INJECT_H
-#define SC_KEYBOARD_INJECT_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "controller.h"
-#include "options.h"
-#include "trait/key_processor.h"
-
-struct sc_keyboard_inject {
-    struct sc_key_processor key_processor; // key processor trait
-
-    struct sc_controller *controller;
-
-    // SDL reports repeated events as a boolean, but Android expects the actual
-    // number of repetitions. This variable keeps track of the count.
-    unsigned repeat;
-
-    enum sc_key_inject_mode key_inject_mode;
-    bool forward_key_repeat;
-};
-
-void
-sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
-                        struct sc_controller *controller,
-                        enum sc_key_inject_mode key_inject_mode,
-                        bool forward_key_repeat);
-
-#endif

app/src/lock_util.c

@@ -0,0 +1,34 @@
+#include <lock_util.h>
+#include <stdlib.h>
+#include <SDL2/SDL_mutex.h>
+
+#include "log.h"
+
+void mutex_lock(SDL_mutex *mutex) {
+    if (SDL_LockMutex(mutex)) {
+        LOGC("Could not lock mutex");
+        abort();
+    }
+}
+
+void mutex_unlock(SDL_mutex *mutex) {
+    if (SDL_UnlockMutex(mutex)) {
+        LOGC("Could not unlock mutex");
+        abort();
+    }
+}
+
+void cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
+    if (SDL_CondWait(cond, mutex)) {
+        LOGC("Could not wait on condition");
+        abort();
+    }
+}
+
+void cond_signal(SDL_cond *cond) {
+    if (SDL_CondSignal(cond)) {
+        LOGC("Could not signal a condition");
+        abort();
+    }
+}
+

app/src/lock_util.h

@@ -0,0 +1,13 @@
+#ifndef LOCKUTIL_H
+#define LOCKUTIL_H
+
+// forward declarations
+typedef struct SDL_mutex SDL_mutex;
+typedef struct SDL_cond SDL_cond;
+
+void mutex_lock(SDL_mutex *mutex);
+void mutex_unlock(SDL_mutex *mutex);
+void cond_wait(SDL_cond *cond, SDL_mutex *mutex);
+void cond_signal(SDL_cond *cond);
+
+#endif

app/src/log.h

@@ -0,0 +1,13 @@
+#ifndef LOG_H
+#define LOG_H
+
+#include <SDL2/SDL_log.h>
+
+#define LOGV(...) SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+#define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+#define LOGI(...) SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+#define LOGW(...) SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+#define LOGE(...) SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+#define LOGC(...) SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
+
+#endif

app/src/main.c

@@ -1,135 +1,349 @@
-#include "common.h"
+#include "scrcpy.h"
 
-#include <assert.h>
-#include <stdbool.h>
+#include <getopt.h>
 #include <unistd.h>
 #include <libavformat/avformat.h>
-#ifdef _WIN32
-#include <windows.h>
-#include "util/str.h"
-#endif
-#ifdef HAVE_V4L2
-# include <libavdevice/avdevice.h>
-#endif
-#define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
 #include <SDL2/SDL.h>
 
-#include "cli.h"
-#include "options.h"
-#include "scrcpy.h"
-#include "usb/scrcpy_otg.h"
-#include "util/log.h"
-#include "version.h"
+#include "config.h"
+#include "log.h"
 
-int
-main_scrcpy(int argc, char *argv[]) {
-#ifdef _WIN32
+struct args {
+    const char *serial;
+    const char *crop;
+    const char *record_filename;
+    SDL_bool fullscreen;
+    SDL_bool help;
+    SDL_bool version;
+    SDL_bool show_touches;
+    Uint16 port;
+    Uint16 max_size;
+    Uint32 bit_rate;
+    SDL_bool always_on_top;
+};
+
+static void usage(const char *arg0) {
+    fprintf(stderr,
+        "Usage: %s [options]\n"
+        "\n"
+        "Options:\n"
+        "\n"
+        "    -b, --bit-rate value\n"
+        "        Encode the video at the given bit-rate, expressed in bits/s.\n"
+        "        Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
+        "        Default is %d.\n"
+        "\n"
+        "    -c, --crop width:height:x:y\n"
+        "        Crop the device screen on the server.\n"
+        "        The values are expressed in the device natural orientation\n"
+        "        (typically, portrait for a phone, landscape for a tablet).\n"
+        "        Any --max-size value is computed on the cropped size.\n"
+        "\n"
+        "    -f, --fullscreen\n"
+        "        Start in fullscreen.\n"
+        "\n"
+        "    -h, --help\n"
+        "        Print this help.\n"
+        "\n"
+        "    -m, --max-size value\n"
+        "        Limit both the width and height of the video to value. The\n"
+        "        other dimension is computed so that the device aspect-ratio\n"
+        "        is preserved.\n"
+        "        Default is %d%s.\n"
+        "\n"
+        "    -p, --port port\n"
+        "        Set the TCP port the client listens on.\n"
+        "        Default is %d.\n"
+        "\n"
+        "    -r, --record file.mp4\n"
+        "        Record screen to file.\n"
+        "\n"
+        "    -s, --serial\n"
+        "        The device serial number. Mandatory only if several devices\n"
+        "        are connected to adb.\n"
+        "\n"
+        "    -t, --show-touches\n"
+        "        Enable \"show touches\" on start, disable on quit.\n"
+        "        It only shows physical touches (not clicks from scrcpy).\n"
+        "\n"
+        "    -T, --always-on-top\n"
+        "        Make scrcpy window always on top (above other windows).\n"
+        "\n"
+        "    -v, --version\n"
+        "        Print the version of scrcpy.\n"
+        "\n"
+        "Shortcuts:\n"
+        "\n"
+        "    Ctrl+f\n"
+        "        switch fullscreen mode\n"
+        "\n"
+        "    Ctrl+g\n"
+        "        resize window to 1:1 (pixel-perfect)\n"
+        "\n"
+        "    Ctrl+x\n"
+        "    Double-click on black borders\n"
+        "        resize window to remove black borders\n"
+        "\n"
+        "    Ctrl+h\n"
+        "    Home\n"
+        "    Middle-click\n"
+        "        click on HOME\n"
+        "\n"
+        "    Ctrl+b\n"
+        "    Ctrl+Backspace\n"
+        "    Right-click (when screen is on)\n"
+        "        click on BACK\n"
+        "\n"
+        "    Ctrl+s\n"
+        "        click on APP_SWITCH\n"
+        "\n"
+        "    Ctrl+m\n"
+        "        click on MENU\n"
+        "\n"
+        "    Ctrl+Up\n"
+        "        click on VOLUME_UP\n"
+        "\n"
+        "    Ctrl+Down\n"
+        "        click on VOLUME_DOWN\n"
+        "\n"
+        "    Ctrl+p\n"
+        "        click on POWER (turn screen on/off)\n"
+        "\n"
+        "    Right-click (when screen is off)\n"
+        "        turn screen on\n"
+        "\n"
+        "    Ctrl+v\n"
+        "        paste computer clipboard to device\n"
+        "\n"
+        "    Ctrl+i\n"
+        "        enable/disable FPS counter (print frames/second in logs)\n"
+        "\n"
+        "    Drag & drop APK file\n"
+        "        install APK from computer\n"
+        "\n",
+        arg0,
+        DEFAULT_BIT_RATE,
+        DEFAULT_MAX_SIZE, DEFAULT_MAX_SIZE ? "" : " (unlimited)",
+        DEFAULT_LOCAL_PORT);
+}
+
+static void print_version(void) {
+    fprintf(stderr, "scrcpy %s\n\n", SCRCPY_VERSION);
+
+    fprintf(stderr, "dependencies:\n");
+    fprintf(stderr, " - SDL %d.%d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
+    fprintf(stderr, " - libavcodec %d.%d.%d\n", LIBAVCODEC_VERSION_MAJOR, LIBAVCODEC_VERSION_MINOR, LIBAVCODEC_VERSION_MICRO);
+    fprintf(stderr, " - libavformat %d.%d.%d\n", LIBAVFORMAT_VERSION_MAJOR, LIBAVFORMAT_VERSION_MINOR, LIBAVFORMAT_VERSION_MICRO);
+    fprintf(stderr, " - libavutil %d.%d.%d\n", LIBAVUTIL_VERSION_MAJOR, LIBAVUTIL_VERSION_MINOR, LIBAVUTIL_VERSION_MICRO);
+}
+
+static SDL_bool parse_bit_rate(char *optarg, Uint32 *bit_rate) {
+    char *endptr;
+    if (*optarg == '\0') {
+        LOGE("Bit-rate parameter is empty");
+        return SDL_FALSE;
+    }
+    long value = strtol(optarg, &endptr, 0);
+    int mul = 1;
+    if (*endptr != '\0') {
+        if (optarg == endptr) {
+            LOGE("Invalid bit-rate: %s", optarg);
+            return SDL_FALSE;
+        }
+        if ((*endptr == 'M' || *endptr == 'm') && endptr[1] == '\0') {
+            mul = 1000000;
+        } else if ((*endptr == 'K' || *endptr == 'k') && endptr[1] == '\0') {
+            mul = 1000;
+        } else {
+            LOGE("Invalid bit-rate unit: %s", optarg);
+            return SDL_FALSE;
+        }
+    }
+    if (value < 0 || ((Uint32) -1) / mul < value) {
+        LOGE("Bitrate must be positive and less than 2^32: %s", optarg);
+        return SDL_FALSE;
+    }
+
+    *bit_rate = (Uint32) value * mul;
+    return SDL_TRUE;
+}
+
+static SDL_bool parse_max_size(char *optarg, Uint16 *max_size) {
+    char *endptr;
+    if (*optarg == '\0') {
+        LOGE("Max size parameter is empty");
+        return SDL_FALSE;
+    }
+    long value = strtol(optarg, &endptr, 0);
+    if (*endptr != '\0') {
+        LOGE("Invalid max size: %s", optarg);
+        return SDL_FALSE;
+    }
+    if (value & ~0xffff) {
+        LOGE("Max size must be between 0 and 65535: %ld", value);
+        return SDL_FALSE;
+    }
+
+    *max_size = (Uint16) value;
+    return SDL_TRUE;
+}
+
+static SDL_bool parse_port(char *optarg, Uint16 *port) {
+    char *endptr;
+    if (*optarg == '\0') {
+        LOGE("Invalid port parameter is empty");
+        return SDL_FALSE;
+    }
+    long value = strtol(optarg, &endptr, 0);
+    if (*endptr != '\0') {
+        LOGE("Invalid port: %s", optarg);
+        return SDL_FALSE;
+    }
+    if (value & ~0xffff) {
+        LOGE("Port out of range: %ld", value);
+        return SDL_FALSE;
+    }
+
+    *port = (Uint16) value;
+    return SDL_TRUE;
+}
+
+static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
+    static const struct option long_options[] = {
+        {"always-on-top", no_argument,       NULL, 'T'},
+        {"bit-rate",      required_argument, NULL, 'b'},
+        {"crop",          required_argument, NULL, 'c'},
+        {"fullscreen",    no_argument,       NULL, 'f'},
+        {"help",          no_argument,       NULL, 'h'},
+        {"max-size",      required_argument, NULL, 'm'},
+        {"port",          required_argument, NULL, 'p'},
+        {"record",        required_argument, NULL, 'r'},
+        {"serial",        required_argument, NULL, 's'},
+        {"show-touches",  no_argument,       NULL, 't'},
+        {"version",       no_argument,       NULL, 'v'},
+        {NULL,            0,                 NULL, 0  },
+    };
+    int c;
+    while ((c = getopt_long(argc, argv, "b:c:fhm:p:r:s:tTv", long_options, NULL)) != -1) {
+        switch (c) {
+            case 'b':
+                if (!parse_bit_rate(optarg, &args->bit_rate)) {
+                    return SDL_FALSE;
+                }
+                break;
+            case 'c':
+                args->crop = optarg;
+                break;
+            case 'f':
+                args->fullscreen = SDL_TRUE;
+                break;
+            case 'h':
+                args->help = SDL_TRUE;
+                break;
+            case 'm':
+                if (!parse_max_size(optarg, &args->max_size)) {
+                    return SDL_FALSE;
+                }
+                break;
+            case 'p':
+                if (!parse_port(optarg, &args->port)) {
+                    return SDL_FALSE;
+                }
+                break;
+            case 'r':
+                args->record_filename = optarg;
+                break;
+            case 's':
+                args->serial = optarg;
+                break;
+            case 't':
+                args->show_touches = SDL_TRUE;
+                break;
+            case 'T':
+                args->always_on_top = SDL_TRUE;
+                break;
+            case 'v':
+                args->version = SDL_TRUE;
+                break;
+            default:
+                // getopt prints the error message on stderr
+                return SDL_FALSE;
+        }
+    }
+
+    int index = optind;
+    if (index < argc) {
+        LOGE("Unexpected additional argument: %s", argv[index]);
+        return SDL_FALSE;
+    }
+    return SDL_TRUE;
+}
+
+int main(int argc, char *argv[]) {
+#ifdef __WINDOWS__
     // disable buffering, we want logs immediately
     // even line buffering (setvbuf() with mode _IOLBF) is not sufficient
     setbuf(stdout, NULL);
     setbuf(stderr, NULL);
 #endif
-
-    printf("scrcpy " SCRCPY_VERSION
-           " <https://github.com/Genymobile/scrcpy>\n");
-
-    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
-        .help = false,
-        .version = false,
+    struct args args = {
+        .serial = NULL,
+        .crop = NULL,
+        .record_filename = NULL,
+        .help = SDL_FALSE,
+        .version = SDL_FALSE,
+        .show_touches = SDL_FALSE,
+        .port = DEFAULT_LOCAL_PORT,
+        .max_size = DEFAULT_MAX_SIZE,
+        .bit_rate = DEFAULT_BIT_RATE,
+        .always_on_top = SDL_FALSE,
     };
-
-#ifndef NDEBUG
-    args.opts.log_level = SC_LOG_LEVEL_DEBUG;
-#endif
-
-    if (!scrcpy_parse_args(&args, argc, argv)) {
-        return SCRCPY_EXIT_FAILURE;
+    if (!parse_args(&args, argc, argv)) {
+        return 1;
     }
 
-    sc_set_log_level(args.opts.log_level);
-
     if (args.help) {
-        scrcpy_print_usage(argv[0]);
-        return SCRCPY_EXIT_SUCCESS;
+        usage(argv[0]);
+        return 0;
     }
 
     if (args.version) {
-        scrcpy_print_version();
-        return SCRCPY_EXIT_SUCCESS;
+        print_version();
+        return 0;
     }
 
-#ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 9, 100)
     av_register_all();
 #endif
 
-#ifdef HAVE_V4L2
-    if (args.opts.v4l2_device) {
-        avdevice_register_all();
-    }
-#endif
-
     if (avformat_network_init()) {
-        return SCRCPY_EXIT_FAILURE;
+        return 1;
     }
 
-#ifdef HAVE_USB
-    enum scrcpy_exit_code ret = args.opts.otg ? scrcpy_otg(&args.opts)
-                                              : scrcpy(&args.opts);
-#else
-    enum scrcpy_exit_code ret = scrcpy(&args.opts);
+#ifdef BUILD_DEBUG
+    SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
 #endif
 
+    struct scrcpy_options options = {
+        .serial = args.serial,
+        .crop = args.crop,
+        .port = args.port,
+        .record_filename = args.record_filename,
+        .max_size = args.max_size,
+        .bit_rate = args.bit_rate,
+        .show_touches = args.show_touches,
+        .fullscreen = args.fullscreen,
+        .always_on_top = args.always_on_top,
+    };
+    int res = scrcpy(&options) ? 0 : 1;
+
     avformat_network_deinit(); // ignore failure
 
-    return ret;
-}
-
-int
-main(int argc, char *argv[]) {
-#ifndef _WIN32
-    return main_scrcpy(argc, argv);
-#else
-    (void) argc;
-    (void) argv;
-    int wargc;
-    wchar_t **wargv = CommandLineToArgvW(GetCommandLineW(), &wargc);
-    if (!wargv) {
-        LOG_OOM();
-        return SCRCPY_EXIT_FAILURE;
+#if defined (__WINDOWS__) && ! defined (WINDOWS_NOCONSOLE)
+    if (res != 0) {
+        fprintf(stderr, "Press any key to continue...\n");
+        getchar();
     }
-
-    char **argv_utf8 = malloc((wargc + 1) * sizeof(*argv_utf8));
-    if (!argv_utf8) {
-        LOG_OOM();
-        LocalFree(wargv);
-        return SCRCPY_EXIT_FAILURE;
-    }
-
-    argv_utf8[wargc] = NULL;
-
-    for (int i = 0; i < wargc; ++i) {
-        argv_utf8[i] = sc_str_from_wchars(wargv[i]);
-        if (!argv_utf8[i]) {
-            LOG_OOM();
-            for (int j = 0; j < i; ++j) {
-                free(argv_utf8[j]);
-            }
-            LocalFree(wargv);
-            free(argv_utf8);
-            return SCRCPY_EXIT_FAILURE;
-        }
-    }
-
-    LocalFree(wargv);
-
-    int ret = main_scrcpy(wargc, argv_utf8);
-
-    for (int i = 0; i < wargc; ++i) {
-        free(argv_utf8[i]);
-    }
-    free(argv_utf8);
-
-    return ret;
 #endif
+    return res;
 }

app/src/mouse_inject.c

@@ -1,162 +0,0 @@
-#include "mouse_inject.h"
-
-#include <assert.h>
-
-#include "android/input.h"
-#include "control_msg.h"
-#include "controller.h"
-#include "input_events.h"
-#include "util/intmap.h"
-#include "util/log.h"
-
-/** Downcast mouse processor to sc_mouse_inject */
-#define DOWNCAST(MP) container_of(MP, struct sc_mouse_inject, mouse_processor)
-
-static enum android_motionevent_buttons
-convert_mouse_buttons(uint32_t state) {
-    enum android_motionevent_buttons buttons = 0;
-    if (state & SC_MOUSE_BUTTON_LEFT) {
-        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
-    }
-    if (state & SC_MOUSE_BUTTON_RIGHT) {
-        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
-    }
-    if (state & SC_MOUSE_BUTTON_MIDDLE) {
-        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
-    }
-    if (state & SC_MOUSE_BUTTON_X1) {
-        buttons |= AMOTION_EVENT_BUTTON_BACK;
-    }
-    if (state & SC_MOUSE_BUTTON_X2) {
-        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
-    }
-    return buttons;
-}
-
-static enum android_motionevent_action
-convert_mouse_action(enum sc_action action) {
-    if (action == SC_ACTION_DOWN) {
-        return AMOTION_EVENT_ACTION_DOWN;
-    }
-    assert(action == SC_ACTION_UP);
-    return AMOTION_EVENT_ACTION_UP;
-}
-
-static enum android_motionevent_action
-convert_touch_action(enum sc_touch_action action) {
-    switch (action) {
-        case SC_TOUCH_ACTION_MOVE:
-            return AMOTION_EVENT_ACTION_MOVE;
-        case SC_TOUCH_ACTION_DOWN:
-            return AMOTION_EVENT_ACTION_DOWN;
-        default:
-            assert(action == SC_TOUCH_ACTION_UP);
-            return AMOTION_EVENT_ACTION_UP;
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_motion_event *event) {
-    if (!event->buttons_state) {
-        // Do not send motion events when no click is pressed
-        return;
-    }
-
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-        .inject_touch_event = {
-            .action = AMOTION_EVENT_ACTION_MOVE,
-            .pointer_id = event->pointer_id,
-            .position = event->position,
-            .pressure = 1.f,
-            .buttons = convert_mouse_buttons(event->buttons_state),
-        },
-    };
-
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
-        LOGW("Could not request 'inject mouse motion event'");
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
-                                    const struct sc_mouse_click_event *event) {
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-        .inject_touch_event = {
-            .action = convert_mouse_action(event->action),
-            .pointer_id = event->pointer_id,
-            .position = event->position,
-            .pressure = event->action == SC_ACTION_DOWN ? 1.f : 0.f,
-            .action_button = convert_mouse_buttons(event->button),
-            .buttons = convert_mouse_buttons(event->buttons_state),
-        },
-    };
-
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
-        LOGW("Could not request 'inject mouse click event'");
-    }
-}
-
-static void
-sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
-                                   const struct sc_mouse_scroll_event *event) {
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
-        .inject_scroll_event = {
-            .position = event->position,
-            .hscroll = event->hscroll,
-            .vscroll = event->vscroll,
-            .buttons = convert_mouse_buttons(event->buttons_state),
-        },
-    };
-
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
-        LOGW("Could not request 'inject mouse scroll event'");
-    }
-}
-
-static void
-sc_mouse_processor_process_touch(struct sc_mouse_processor *mp,
-                                 const struct sc_touch_event *event) {
-    struct sc_mouse_inject *mi = DOWNCAST(mp);
-
-    struct sc_control_msg msg = {
-        .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-        .inject_touch_event = {
-            .action = convert_touch_action(event->action),
-            .pointer_id = event->pointer_id,
-            .position = event->position,
-            .pressure = event->pressure,
-            .buttons = 0,
-        },
-    };
-
-    if (!sc_controller_push_msg(mi->controller, &msg)) {
-        LOGW("Could not request 'inject touch event'");
-    }
-}
-
-void
-sc_mouse_inject_init(struct sc_mouse_inject *mi,
-                     struct sc_controller *controller) {
-    mi->controller = controller;
-
-    static const struct sc_mouse_processor_ops ops = {
-        .process_mouse_motion = sc_mouse_processor_process_mouse_motion,
-        .process_mouse_click = sc_mouse_processor_process_mouse_click,
-        .process_mouse_scroll = sc_mouse_processor_process_mouse_scroll,
-        .process_touch = sc_mouse_processor_process_touch,
-    };
-
-    mi->mouse_processor.ops = &ops;
-
-    mi->mouse_processor.relative_mode = false;
-}

app/src/mouse_inject.h

@@ -1,22 +0,0 @@
-#ifndef SC_MOUSE_INJECT_H
-#define SC_MOUSE_INJECT_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "controller.h"
-#include "screen.h"
-#include "trait/mouse_processor.h"
-
-struct sc_mouse_inject {
-    struct sc_mouse_processor mouse_processor; // mouse processor trait
-
-    struct sc_controller *controller;
-};
-
-void
-sc_mouse_inject_init(struct sc_mouse_inject *mi,
-                     struct sc_controller *controller);
-
-#endif

app/src/net.c

@@ -0,0 +1,104 @@
+#include "net.h"
+
+#include <stdio.h>
+
+#include "log.h"
+
+#ifdef __WINDOWS__
+  typedef int socklen_t;
+#else
+# include <sys/types.h>
+# include <sys/socket.h>
+# include <netinet/in.h>
+# include <arpa/inet.h>
+# include <unistd.h>
+# define SOCKET_ERROR -1
+  typedef struct sockaddr_in SOCKADDR_IN;
+  typedef struct sockaddr SOCKADDR;
+  typedef struct in_addr IN_ADDR;
+#endif
+
+socket_t net_connect(Uint32 addr, Uint16 port) {
+    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock == INVALID_SOCKET) {
+        perror("socket");
+        return INVALID_SOCKET;
+    }
+
+    SOCKADDR_IN sin;
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = htonl(addr);
+    sin.sin_port = htons(port);
+
+    if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
+        perror("connect");
+        return INVALID_SOCKET;
+    }
+
+    return sock;
+}
+
+socket_t net_listen(Uint32 addr, Uint16 port, int backlog) {
+    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock == INVALID_SOCKET) {
+        perror("socket");
+        return INVALID_SOCKET;
+    }
+
+    int reuse = 1;
+    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse, sizeof(reuse)) == -1) {
+        perror("setsockopt(SO_REUSEADDR)");
+    }
+
+    SOCKADDR_IN sin;
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = htonl(addr); // htonl() harmless on INADDR_ANY
+    sin.sin_port = htons(port);
+
+    if (bind(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
+        perror("bind");
+        return INVALID_SOCKET;
+    }
+
+    if (listen(sock, backlog) == SOCKET_ERROR) {
+        perror("listen");
+        return INVALID_SOCKET;
+    }
+
+    return sock;
+}
+
+socket_t net_accept(socket_t server_socket) {
+    SOCKADDR_IN csin;
+    socklen_t sinsize = sizeof(csin);
+    return accept(server_socket, (SOCKADDR *) &csin, &sinsize);
+}
+
+ssize_t net_recv(socket_t socket, void *buf, size_t len) {
+    return recv(socket, buf, len, 0);
+}
+
+ssize_t net_recv_all(socket_t socket, void *buf, size_t len) {
+    return recv(socket, buf, len, MSG_WAITALL);
+}
+
+ssize_t net_send(socket_t socket, const void *buf, size_t len) {
+    return send(socket, buf, len, 0);
+}
+
+ssize_t net_send_all(socket_t socket, const void *buf, size_t len) {
+    ssize_t w = 0;
+    while (len > 0) {
+        w = send(socket, buf, len, 0);
+        if (w == -1) {
+            return -1;
+        }
+        len -= w;
+        buf = (char *) buf + w;
+    }
+    return w;
+}
+
+SDL_bool net_shutdown(socket_t socket, int how) {
+    return !shutdown(socket, how);
+}

app/src/net.h

@@ -0,0 +1,35 @@
+#ifndef NET_H
+#define NET_H
+
+#include <SDL2/SDL_platform.h>
+#include <SDL2/SDL_stdinc.h>
+
+#ifdef __WINDOWS__
+# include <winsock2.h>
+  #define SHUT_RD SD_RECEIVE
+  #define SHUT_WR SD_SEND
+  #define SHUT_RDWR SD_BOTH
+  typedef SOCKET socket_t;
+#else
+# include <sys/socket.h>
+# define INVALID_SOCKET -1
+  typedef int socket_t;
+#endif
+
+SDL_bool net_init(void);
+void net_cleanup(void);
+
+socket_t net_connect(Uint32 addr, Uint16 port);
+socket_t net_listen(Uint32 addr, Uint16 port, int backlog);
+socket_t net_accept(socket_t server_socket);
+
+// the _all versions wait/retry until len bytes have been written/read
+ssize_t net_recv(socket_t socket, void *buf, size_t len);
+ssize_t net_recv_all(socket_t socket, void *buf, size_t len);
+ssize_t net_send(socket_t socket, const void *buf, size_t len);
+ssize_t net_send_all(socket_t socket, const void *buf, size_t len);
+// how is SHUT_RD (read), SHUT_WR (write) or SHUT_RDWR (both)
+SDL_bool net_shutdown(socket_t socket, int how);
+SDL_bool net_close(socket_t socket);
+
+#endif

app/src/opengl.c

@@ -1,56 +0,0 @@
-#include "opengl.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include "SDL2/SDL.h"
-
-void
-sc_opengl_init(struct sc_opengl *gl) {
-    gl->GetString = SDL_GL_GetProcAddress("glGetString");
-    assert(gl->GetString);
-
-    gl->TexParameterf = SDL_GL_GetProcAddress("glTexParameterf");
-    assert(gl->TexParameterf);
-
-    gl->TexParameteri = SDL_GL_GetProcAddress("glTexParameteri");
-    assert(gl->TexParameteri);
-
-    // optional
-    gl->GenerateMipmap = SDL_GL_GetProcAddress("glGenerateMipmap");
-
-    const char *version = (const char *) gl->GetString(GL_VERSION);
-    assert(version);
-    gl->version = version;
-
-#define OPENGL_ES_PREFIX "OpenGL ES "
-    /* starts with "OpenGL ES " */
-    gl->is_opengles = !strncmp(gl->version, OPENGL_ES_PREFIX,
-                               sizeof(OPENGL_ES_PREFIX) - 1);
-    if (gl->is_opengles) {
-        /* skip the prefix */
-        version += sizeof(OPENGL_ES_PREFIX) - 1;
-    }
-
-    int r = sscanf(version, "%d.%d", &gl->version_major, &gl->version_minor);
-    if (r != 2) {
-        // failed to parse the version
-        gl->version_major = 0;
-        gl->version_minor = 0;
-    }
-}
-
-bool
-sc_opengl_version_at_least(struct sc_opengl *gl,
-                           int minver_major, int minver_minor,
-                           int minver_es_major, int minver_es_minor)
-{
-    if (gl->is_opengles) {
-        return gl->version_major > minver_es_major
-            || (gl->version_major == minver_es_major
-             && gl->version_minor >= minver_es_minor);
-    }
-
-    return gl->version_major > minver_major
-        || (gl->version_major == minver_major
-         && gl->version_minor >= minver_minor);
-}

app/src/opengl.h

@@ -1,36 +0,0 @@
-#ifndef SC_OPENGL_H
-#define SC_OPENGL_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <SDL2/SDL_opengl.h>
-
-struct sc_opengl {
-    const char *version;
-    bool is_opengles;
-    int version_major;
-    int version_minor;
-
-    const GLubyte *
-    (*GetString)(GLenum name);
-
-    void
-    (*TexParameterf)(GLenum target, GLenum pname, GLfloat param);
-
-    void
-    (*TexParameteri)(GLenum target, GLenum pname, GLint param);
-
-    void
-    (*GenerateMipmap)(GLenum target);
-};
-
-void
-sc_opengl_init(struct sc_opengl *gl);
-
-bool
-sc_opengl_version_at_least(struct sc_opengl *gl,
-                           int minver_major, int minver_minor,
-                           int minver_es_major, int minver_es_minor);
-
-#endif

app/src/options.c

@@ -1,69 +0,0 @@
-#include "options.h"
-
-const struct scrcpy_options scrcpy_options_default = {
-    .serial = NULL,
-    .crop = NULL,
-    .record_filename = NULL,
-    .window_title = NULL,
-    .push_target = NULL,
-    .render_driver = NULL,
-    .codec_options = NULL,
-    .encoder_name = NULL,
-#ifdef HAVE_V4L2
-    .v4l2_device = NULL,
-#endif
-    .log_level = SC_LOG_LEVEL_INFO,
-    .codec = SC_CODEC_H264,
-    .record_format = SC_RECORD_FORMAT_AUTO,
-    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
-    .port_range = {
-        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
-        .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
-    },
-    .tunnel_host = 0,
-    .tunnel_port = 0,
-    .shortcut_mods = {
-        .data = {SC_SHORTCUT_MOD_LALT, SC_SHORTCUT_MOD_LSUPER},
-        .count = 2,
-    },
-    .max_size = 0,
-    .bit_rate = DEFAULT_BIT_RATE,
-    .max_fps = 0,
-    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
-    .rotation = 0,
-    .window_x = SC_WINDOW_POSITION_UNDEFINED,
-    .window_y = SC_WINDOW_POSITION_UNDEFINED,
-    .window_width = 0,
-    .window_height = 0,
-    .display_id = 0,
-    .display_buffer = 0,
-    .v4l2_buffer = 0,
-#ifdef HAVE_USB
-    .otg = false,
-#endif
-    .show_touches = false,
-    .fullscreen = false,
-    .always_on_top = false,
-    .control = true,
-    .display = true,
-    .turn_screen_off = false,
-    .key_inject_mode = SC_KEY_INJECT_MODE_MIXED,
-    .window_borderless = false,
-    .mipmaps = true,
-    .stay_awake = false,
-    .force_adb_forward = false,
-    .disable_screensaver = false,
-    .forward_key_repeat = true,
-    .forward_all_clicks = false,
-    .legacy_paste = false,
-    .power_off_on_close = false,
-    .clipboard_autosync = true,
-    .downsize_on_error = true,
-    .tcpip = false,
-    .tcpip_dst = NULL,
-    .select_tcpip = false,
-    .select_usb = false,
-    .cleanup = true,
-    .start_fps_counter = false,
-    .power_on = true,
-};

app/src/options.h

@@ -1,154 +0,0 @@
-#ifndef SCRCPY_OPTIONS_H
-#define SCRCPY_OPTIONS_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "util/tick.h"
-
-enum sc_log_level {
-    SC_LOG_LEVEL_VERBOSE,
-    SC_LOG_LEVEL_DEBUG,
-    SC_LOG_LEVEL_INFO,
-    SC_LOG_LEVEL_WARN,
-    SC_LOG_LEVEL_ERROR,
-};
-
-enum sc_record_format {
-    SC_RECORD_FORMAT_AUTO,
-    SC_RECORD_FORMAT_MP4,
-    SC_RECORD_FORMAT_MKV,
-};
-
-enum sc_codec {
-    SC_CODEC_H264,
-    SC_CODEC_H265,
-    SC_CODEC_AV1,
-};
-
-enum sc_lock_video_orientation {
-    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
-    // lock the current orientation when scrcpy starts
-    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
-    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
-    SC_LOCK_VIDEO_ORIENTATION_1,
-    SC_LOCK_VIDEO_ORIENTATION_2,
-    SC_LOCK_VIDEO_ORIENTATION_3,
-};
-
-enum sc_keyboard_input_mode {
-    SC_KEYBOARD_INPUT_MODE_INJECT,
-    SC_KEYBOARD_INPUT_MODE_HID,
-};
-
-enum sc_mouse_input_mode {
-    SC_MOUSE_INPUT_MODE_INJECT,
-    SC_MOUSE_INPUT_MODE_HID,
-};
-
-enum sc_key_inject_mode {
-    // Inject special keys, letters and space as key events.
-    // Inject numbers and punctuation as text events.
-    // This is the default mode.
-    SC_KEY_INJECT_MODE_MIXED,
-
-    // Inject special keys as key events.
-    // Inject letters and space, numbers and punctuation as text events.
-    SC_KEY_INJECT_MODE_TEXT,
-
-    // Inject everything as key events.
-    SC_KEY_INJECT_MODE_RAW,
-};
-
-#define SC_MAX_SHORTCUT_MODS 8
-
-enum sc_shortcut_mod {
-    SC_SHORTCUT_MOD_LCTRL = 1 << 0,
-    SC_SHORTCUT_MOD_RCTRL = 1 << 1,
-    SC_SHORTCUT_MOD_LALT = 1 << 2,
-    SC_SHORTCUT_MOD_RALT = 1 << 3,
-    SC_SHORTCUT_MOD_LSUPER = 1 << 4,
-    SC_SHORTCUT_MOD_RSUPER = 1 << 5,
-};
-
-struct sc_shortcut_mods {
-    unsigned data[SC_MAX_SHORTCUT_MODS];
-    unsigned count;
-};
-
-struct sc_port_range {
-    uint16_t first;
-    uint16_t last;
-};
-
-#define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
-
-struct scrcpy_options {
-    const char *serial;
-    const char *crop;
-    const char *record_filename;
-    const char *window_title;
-    const char *push_target;
-    const char *render_driver;
-    const char *codec_options;
-    const char *encoder_name;
-#ifdef HAVE_V4L2
-    const char *v4l2_device;
-#endif
-    enum sc_log_level log_level;
-    enum sc_codec codec;
-    enum sc_record_format record_format;
-    enum sc_keyboard_input_mode keyboard_input_mode;
-    enum sc_mouse_input_mode mouse_input_mode;
-    struct sc_port_range port_range;
-    uint32_t tunnel_host;
-    uint16_t tunnel_port;
-    struct sc_shortcut_mods shortcut_mods;
-    uint16_t max_size;
-    uint32_t bit_rate;
-    uint16_t max_fps;
-    enum sc_lock_video_orientation lock_video_orientation;
-    uint8_t rotation;
-    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
-    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
-    uint16_t window_width;
-    uint16_t window_height;
-    uint32_t display_id;
-    sc_tick display_buffer;
-    sc_tick v4l2_buffer;
-#ifdef HAVE_USB
-    bool otg;
-#endif
-    bool show_touches;
-    bool fullscreen;
-    bool always_on_top;
-    bool control;
-    bool display;
-    bool turn_screen_off;
-    enum sc_key_inject_mode key_inject_mode;
-    bool window_borderless;
-    bool mipmaps;
-    bool stay_awake;
-    bool force_adb_forward;
-    bool disable_screensaver;
-    bool forward_key_repeat;
-    bool forward_all_clicks;
-    bool legacy_paste;
-    bool power_off_on_close;
-    bool clipboard_autosync;
-    bool downsize_on_error;
-    bool tcpip;
-    const char *tcpip_dst;
-    bool select_usb;
-    bool select_tcpip;
-    bool cleanup;
-    bool start_fps_counter;
-    bool power_on;
-};
-
-extern const struct scrcpy_options scrcpy_options_default;
-
-#endif

app/src/receiver.c

@@ -1,127 +0,0 @@
-#include "receiver.h"
-
-#include <assert.h>
-#include <SDL2/SDL_clipboard.h>
-
-#include "device_msg.h"
-#include "util/log.h"
-
-bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
-              struct sc_acksync *acksync) {
-    bool ok = sc_mutex_init(&receiver->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    receiver->control_socket = control_socket;
-    receiver->acksync = acksync;
-
-    return true;
-}
-
-void
-receiver_destroy(struct receiver *receiver) {
-    sc_mutex_destroy(&receiver->mutex);
-}
-
-static void
-process_msg(struct receiver *receiver, struct device_msg *msg) {
-    switch (msg->type) {
-        case DEVICE_MSG_TYPE_CLIPBOARD: {
-            char *current = SDL_GetClipboardText();
-            bool same = current && !strcmp(current, msg->clipboard.text);
-            SDL_free(current);
-            if (same) {
-                LOGD("Computer clipboard unchanged");
-                return;
-            }
-
-            LOGI("Device clipboard copied");
-            SDL_SetClipboardText(msg->clipboard.text);
-            break;
-        }
-        case DEVICE_MSG_TYPE_ACK_CLIPBOARD:
-            assert(receiver->acksync);
-            LOGD("Ack device clipboard sequence=%" PRIu64_,
-                 msg->ack_clipboard.sequence);
-            sc_acksync_ack(receiver->acksync, msg->ack_clipboard.sequence);
-            break;
-    }
-}
-
-static ssize_t
-process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
-    size_t head = 0;
-    for (;;) {
-        struct device_msg msg;
-        ssize_t r = device_msg_deserialize(&buf[head], len - head, &msg);
-        if (r == -1) {
-            return -1;
-        }
-        if (r == 0) {
-            return head;
-        }
-
-        process_msg(receiver, &msg);
-        device_msg_destroy(&msg);
-
-        head += r;
-        assert(head <= len);
-        if (head == len) {
-            return head;
-        }
-    }
-}
-
-static int
-run_receiver(void *data) {
-    struct receiver *receiver = data;
-
-    static unsigned char buf[DEVICE_MSG_MAX_SIZE];
-    size_t head = 0;
-
-    for (;;) {
-        assert(head < DEVICE_MSG_MAX_SIZE);
-        ssize_t r = net_recv(receiver->control_socket, buf + head,
-                             DEVICE_MSG_MAX_SIZE - head);
-        if (r <= 0) {
-            LOGD("Receiver stopped");
-            break;
-        }
-
-        head += r;
-        ssize_t consumed = process_msgs(receiver, buf, head);
-        if (consumed == -1) {
-            // an error occurred
-            break;
-        }
-
-        if (consumed) {
-            head -= consumed;
-            // shift the remaining data in the buffer
-            memmove(buf, &buf[consumed], head);
-        }
-    }
-
-    return 0;
-}
-
-bool
-receiver_start(struct receiver *receiver) {
-    LOGD("Starting receiver thread");
-
-    bool ok = sc_thread_create(&receiver->thread, run_receiver,
-                               "scrcpy-receiver", receiver);
-    if (!ok) {
-        LOGE("Could not start receiver thread");
-        return false;
-    }
-
-    return true;
-}
-
-void
-receiver_join(struct receiver *receiver) {
-    sc_thread_join(&receiver->thread, NULL);
-}

app/src/receiver.h

@@ -1,37 +0,0 @@
-#ifndef SC_RECEIVER_H
-#define SC_RECEIVER_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "util/acksync.h"
-#include "util/net.h"
-#include "util/thread.h"
-
-// receive events from the device
-// managed by the controller
-struct receiver {
-    sc_socket control_socket;
-    sc_thread thread;
-    sc_mutex mutex;
-
-    struct sc_acksync *acksync;
-};
-
-bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
-              struct sc_acksync *acksync);
-
-void
-receiver_destroy(struct receiver *receiver);
-
-bool
-receiver_start(struct receiver *receiver);
-
-// no receiver_stop(), it will automatically stop on control_socket shutdown
-
-void
-receiver_join(struct receiver *receiver);
-
-#endif

app/src/recorder.c

@@ -1,416 +1,155 @@
 #include "recorder.h"
 
-#include <assert.h>
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
 #include <libavutil/time.h>
 
-#include "util/log.h"
-#include "util/str.h"
+#include "config.h"
+#include "log.h"
 
-/** Downcast packet_sink to recorder */
-#define DOWNCAST(SINK) container_of(SINK, struct sc_recorder, packet_sink)
+// In ffmpeg/doc/APIchanges:
+// 2016-04-11 - 6f69f7a / 9200514 - lavf 57.33.100 / 57.5.0 - avformat.h
+//   Add AVStream.codecpar, deprecate AVStream.codec.
+#if    (LIBAVFORMAT_VERSION_MICRO >= 100 /* FFmpeg */ && \
+        LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 33, 100)) \
+    || (LIBAVFORMAT_VERSION_MICRO < 100 && /* Libav */ \
+        LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 5, 0))
+# define LAVF_NEW_CODEC_API
+#endif
 
-#define SC_PTS_ORIGIN_NONE UINT64_C(-1)
-
-static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
-
-static const AVOutputFormat *
-find_muxer(const char *name) {
-#ifdef SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
+static const AVOutputFormat *find_mp4_muxer(void) {
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 9, 100)
     void *opaque = NULL;
 #endif
     const AVOutputFormat *oformat = NULL;
     do {
-#ifdef SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 9, 100)
         oformat = av_muxer_iterate(&opaque);
 #else
         oformat = av_oformat_next(oformat);
 #endif
-        // until null or containing the requested name
-    } while (oformat && !sc_str_list_contains(oformat->name, ',', name));
+        // until null or with name "mp4"
+    } while (oformat && strcmp(oformat->name, "mp4"));
     return oformat;
 }
 
-static struct sc_record_packet *
-sc_record_packet_new(const AVPacket *packet) {
-    struct sc_record_packet *rec = malloc(sizeof(*rec));
-    if (!rec) {
-        LOG_OOM();
-        return NULL;
+SDL_bool recorder_init(struct recorder *recorder, const char *filename,
+                       struct size declared_frame_size) {
+    recorder->filename = SDL_strdup(filename);
+    if (!recorder->filename) {
+        LOGE("Cannot strdup filename");
+        return SDL_FALSE;
     }
 
-    rec->packet = av_packet_alloc();
-    if (!rec->packet) {
-        LOG_OOM();
-        free(rec);
-        return NULL;
-    }
+    recorder->declared_frame_size = declared_frame_size;
+    recorder->header_written = SDL_FALSE;
 
-    if (av_packet_ref(rec->packet, packet)) {
-        av_packet_free(&rec->packet);
-        free(rec);
-        return NULL;
-    }
-    return rec;
+    return SDL_TRUE;
 }
 
-static void
-sc_record_packet_delete(struct sc_record_packet *rec) {
-    av_packet_free(&rec->packet);
-    free(rec);
+void recorder_destroy(struct recorder *recorder) {
+    SDL_free(recorder->filename);
 }
 
-static void
-sc_recorder_queue_clear(struct sc_recorder_queue *queue) {
-    while (!sc_queue_is_empty(queue)) {
-        struct sc_record_packet *rec;
-        sc_queue_take(queue, next, &rec);
-        sc_record_packet_delete(rec);
-    }
-}
-
-static const char *
-sc_recorder_get_format_name(enum sc_record_format format) {
-    switch (format) {
-        case SC_RECORD_FORMAT_MP4: return "mp4";
-        case SC_RECORD_FORMAT_MKV: return "matroska";
-        default: return NULL;
-    }
-}
-
-static bool
-sc_recorder_write_header(struct sc_recorder *recorder, const AVPacket *packet) {
-    AVStream *ostream = recorder->ctx->streams[0];
-
-    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
-    if (!extradata) {
-        LOG_OOM();
-        return false;
-    }
-
-    // copy the first packet to the extra data
-    memcpy(extradata, packet->data, packet->size);
-
-    ostream->codecpar->extradata = extradata;
-    ostream->codecpar->extradata_size = packet->size;
-
-    int ret = avformat_write_header(recorder->ctx, NULL);
-    if (ret < 0) {
-        LOGE("Failed to write header to %s", recorder->filename);
-        return false;
-    }
-
-    return true;
-}
-
-static void
-sc_recorder_rescale_packet(struct sc_recorder *recorder, AVPacket *packet) {
-    AVStream *ostream = recorder->ctx->streams[0];
-    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
-}
-
-static bool
-sc_recorder_write(struct sc_recorder *recorder, AVPacket *packet) {
-    if (!recorder->header_written) {
-        if (packet->pts != AV_NOPTS_VALUE) {
-            LOGE("The first packet is not a config packet");
-            return false;
-        }
-        bool ok = sc_recorder_write_header(recorder, packet);
-        if (!ok) {
-            return false;
-        }
-        recorder->header_written = true;
-        return true;
-    }
-
-    if (packet->pts == AV_NOPTS_VALUE) {
-        // ignore config packets
-        return true;
-    }
-
-    sc_recorder_rescale_packet(recorder, packet);
-    return av_write_frame(recorder->ctx, packet) >= 0;
-}
-
-static int
-run_recorder(void *data) {
-    struct sc_recorder *recorder = data;
-
-    for (;;) {
-        sc_mutex_lock(&recorder->mutex);
-
-        while (!recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
-            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
-        }
-
-        // if stopped is set, continue to process the remaining events (to
-        // finish the recording) before actually stopping
-
-        if (recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
-            sc_mutex_unlock(&recorder->mutex);
-            struct sc_record_packet *last = recorder->previous;
-            if (last) {
-                // assign an arbitrary duration to the last packet
-                last->packet->duration = 100000;
-                bool ok = sc_recorder_write(recorder, last->packet);
-                if (!ok) {
-                    // failing to write the last frame is not very serious, no
-                    // future frame may depend on it, so the resulting file
-                    // will still be valid
-                    LOGW("Could not record last packet");
-                }
-                sc_record_packet_delete(last);
-            }
-            break;
-        }
-
-        struct sc_record_packet *rec;
-        sc_queue_take(&recorder->queue, next, &rec);
-
-        sc_mutex_unlock(&recorder->mutex);
-
-        if (recorder->pts_origin == SC_PTS_ORIGIN_NONE
-                && rec->packet->pts != AV_NOPTS_VALUE) {
-            // First PTS received
-            recorder->pts_origin = rec->packet->pts;
-        }
-
-        if (rec->packet->pts != AV_NOPTS_VALUE) {
-            // Set PTS relatve to the origin
-            rec->packet->pts -= recorder->pts_origin;
-            rec->packet->dts = rec->packet->pts;
-        }
-
-        // recorder->previous is only written from this thread, no need to lock
-        struct sc_record_packet *previous = recorder->previous;
-        recorder->previous = rec;
-
-        if (!previous) {
-            // we just received the first packet
-            continue;
-        }
-
-        // config packets have no PTS, we must ignore them
-        if (rec->packet->pts != AV_NOPTS_VALUE
-            && previous->packet->pts != AV_NOPTS_VALUE) {
-            // we now know the duration of the previous packet
-            previous->packet->duration =
-                rec->packet->pts - previous->packet->pts;
-        }
-
-        bool ok = sc_recorder_write(recorder, previous->packet);
-        sc_record_packet_delete(previous);
-        if (!ok) {
-            LOGE("Could not record packet");
-
-            sc_mutex_lock(&recorder->mutex);
-            recorder->failed = true;
-            // discard pending packets
-            sc_recorder_queue_clear(&recorder->queue);
-            sc_mutex_unlock(&recorder->mutex);
-            break;
-        }
-    }
-
-    if (!recorder->failed) {
-        if (recorder->header_written) {
-            int ret = av_write_trailer(recorder->ctx);
-            if (ret < 0) {
-                LOGE("Failed to write trailer to %s", recorder->filename);
-                recorder->failed = true;
-            }
-        } else {
-            // the recorded file is empty
-            recorder->failed = true;
-        }
-    }
-
-    if (recorder->failed) {
-        LOGE("Recording failed to %s", recorder->filename);
-    } else {
-        const char *format_name = sc_recorder_get_format_name(recorder->format);
-        LOGI("Recording complete to %s file: %s", format_name,
-                                                  recorder->filename);
-    }
-
-    LOGD("Recorder thread ended");
-
-    return 0;
-}
-
-static bool
-sc_recorder_open(struct sc_recorder *recorder, const AVCodec *input_codec) {
-    bool ok = sc_mutex_init(&recorder->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&recorder->queue_cond);
-    if (!ok) {
-        goto error_mutex_destroy;
-    }
-
-    sc_queue_init(&recorder->queue);
-    recorder->stopped = false;
-    recorder->failed = false;
-    recorder->header_written = false;
-    recorder->previous = NULL;
-    recorder->pts_origin = SC_PTS_ORIGIN_NONE;
-
-    const char *format_name = sc_recorder_get_format_name(recorder->format);
-    assert(format_name);
-    const AVOutputFormat *format = find_muxer(format_name);
-    if (!format) {
-        LOGE("Could not find muxer");
-        goto error_cond_destroy;
+SDL_bool recorder_open(struct recorder *recorder, AVCodec *input_codec) {
+    const AVOutputFormat *mp4 = find_mp4_muxer();
+    if (!mp4) {
+        LOGE("Could not find mp4 muxer");
+        return SDL_FALSE;
     }
 
     recorder->ctx = avformat_alloc_context();
     if (!recorder->ctx) {
-        LOG_OOM();
-        goto error_cond_destroy;
+        LOGE("Could not allocate output context");
+        return SDL_FALSE;
     }
 
     // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
     // returns (on purpose) a pointer-to-const, but AVFormatContext.oformat
     // still expects a pointer-to-non-const (it has not be updated accordingly)
     // <https://github.com/FFmpeg/FFmpeg/commit/0694d8702421e7aff1340038559c438b61bb30dd>
-    recorder->ctx->oformat = (AVOutputFormat *) format;
-
-    av_dict_set(&recorder->ctx->metadata, "comment",
-                "Recorded by scrcpy " SCRCPY_VERSION, 0);
+    recorder->ctx->oformat = (AVOutputFormat *) mp4;
 
     AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
     if (!ostream) {
-        goto error_avformat_free_context;
+        avformat_free_context(recorder->ctx);
+        return SDL_FALSE;
     }
 
+#ifdef LAVF_NEW_CODEC_API
     ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
     ostream->codecpar->codec_id = input_codec->id;
     ostream->codecpar->format = AV_PIX_FMT_YUV420P;
     ostream->codecpar->width = recorder->declared_frame_size.width;
     ostream->codecpar->height = recorder->declared_frame_size.height;
+#else
+    ostream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+    ostream->codec->codec_id = input_codec->id;
+    ostream->codec->pix_fmt = AV_PIX_FMT_YUV420P;
+    ostream->codec->width = recorder->declared_frame_size.width;
+    ostream->codec->height = recorder->declared_frame_size.height;
+#endif
+    ostream->time_base = (AVRational) {1, 1000000}; // timestamps in us
 
     int ret = avio_open(&recorder->ctx->pb, recorder->filename,
                         AVIO_FLAG_WRITE);
     if (ret < 0) {
         LOGE("Failed to open output file: %s", recorder->filename);
         // ostream will be cleaned up during context cleaning
-        goto error_avformat_free_context;
+        avformat_free_context(recorder->ctx);
+        return SDL_FALSE;
     }
 
-    LOGD("Starting recorder thread");
-    ok = sc_thread_create(&recorder->thread, run_recorder, "scrcpy-recorder",
-                          recorder);
-    if (!ok) {
-        LOGE("Could not start recorder thread");
-        goto error_avio_close;
-    }
-
-    LOGI("Recording started to %s file: %s", format_name, recorder->filename);
-
-    return true;
-
-error_avio_close:
-    avio_close(recorder->ctx->pb);
-error_avformat_free_context:
-    avformat_free_context(recorder->ctx);
-error_cond_destroy:
-    sc_cond_destroy(&recorder->queue_cond);
-error_mutex_destroy:
-    sc_mutex_destroy(&recorder->mutex);
-
-    return false;
+    return SDL_TRUE;
 }
 
-static void
-sc_recorder_close(struct sc_recorder *recorder) {
-    sc_mutex_lock(&recorder->mutex);
-    recorder->stopped = true;
-    sc_cond_signal(&recorder->queue_cond);
-    sc_mutex_unlock(&recorder->mutex);
-
-    sc_thread_join(&recorder->thread, NULL);
-
+void recorder_close(struct recorder *recorder) {
+    int ret = av_write_trailer(recorder->ctx);
+    if (ret < 0) {
+        LOGE("Failed to write trailer to %s", recorder->filename);
+    }
     avio_close(recorder->ctx->pb);
     avformat_free_context(recorder->ctx);
-    sc_cond_destroy(&recorder->queue_cond);
-    sc_mutex_destroy(&recorder->mutex);
 }
 
-static bool
-sc_recorder_push(struct sc_recorder *recorder, const AVPacket *packet) {
-    sc_mutex_lock(&recorder->mutex);
-    assert(!recorder->stopped);
+SDL_bool recorder_write_header(struct recorder *recorder, AVPacket *packet) {
+    AVStream *ostream = recorder->ctx->streams[0];
 
-    if (recorder->failed) {
-        // reject any new packet (this will stop the stream)
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
+    uint8_t *extradata = SDL_malloc(packet->size * sizeof(uint8_t));
+    if (!extradata) {
+        LOGC("Cannot allocate extradata");
+        return SDL_FALSE;
     }
 
-    struct sc_record_packet *rec = sc_record_packet_new(packet);
-    if (!rec) {
-        LOG_OOM();
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
+    // copy the first packet to the extra data
+    memcpy(extradata, packet->data, packet->size);
+
+#ifdef LAVF_NEW_CODEC_API
+    ostream->codecpar->extradata = extradata;
+    ostream->codecpar->extradata_size = packet->size;
+#else
+    ostream->codec->extradata = extradata;
+    ostream->codec->extradata_size = packet->size;
+#endif
+
+    int ret = avformat_write_header(recorder->ctx, NULL);
+    if (ret < 0) {
+        LOGE("Failed to write header to %s", recorder->filename);
+        SDL_free(extradata);
+        avio_closep(&recorder->ctx->pb);
+        avformat_free_context(recorder->ctx);
+        return SDL_FALSE;
     }
 
-    sc_queue_push(&recorder->queue, next, rec);
-    sc_cond_signal(&recorder->queue_cond);
-
-    sc_mutex_unlock(&recorder->mutex);
-    return true;
+    return SDL_TRUE;
 }
 
-static bool
-sc_recorder_packet_sink_open(struct sc_packet_sink *sink,
-                             const AVCodec *codec) {
-    struct sc_recorder *recorder = DOWNCAST(sink);
-    return sc_recorder_open(recorder, codec);
-}
-
-static void
-sc_recorder_packet_sink_close(struct sc_packet_sink *sink) {
-    struct sc_recorder *recorder = DOWNCAST(sink);
-    sc_recorder_close(recorder);
-}
-
-static bool
-sc_recorder_packet_sink_push(struct sc_packet_sink *sink,
-                             const AVPacket *packet) {
-    struct sc_recorder *recorder = DOWNCAST(sink);
-    return sc_recorder_push(recorder, packet);
-}
-
-bool
-sc_recorder_init(struct sc_recorder *recorder,
-                 const char *filename,
-                 enum sc_record_format format,
-                 struct sc_size declared_frame_size) {
-    recorder->filename = strdup(filename);
-    if (!recorder->filename) {
-        LOG_OOM();
-        return false;
+SDL_bool recorder_write(struct recorder *recorder, AVPacket *packet) {
+    if (!recorder->header_written) {
+        SDL_bool ok = recorder_write_header(recorder, packet);
+        if (!ok) {
+            return SDL_FALSE;
+        }
+        recorder->header_written = SDL_TRUE;
     }
 
-    recorder->format = format;
-    recorder->declared_frame_size = declared_frame_size;
-
-    static const struct sc_packet_sink_ops ops = {
-        .open = sc_recorder_packet_sink_open,
-        .close = sc_recorder_packet_sink_close,
-        .push = sc_recorder_packet_sink_push,
-    };
-
-    recorder->packet_sink.ops = &ops;
-
-    return true;
-}
-
-void
-sc_recorder_destroy(struct sc_recorder *recorder) {
-    free(recorder->filename);
+    return av_write_frame(recorder->ctx, packet) >= 0;
 }