Support Android API 19

Since "adb forward" fallback has been implemented, it is easy to support
API 19.

Replace the incompatible calls related to MediaCodec to use
minSdkVersion 19 instead of 21.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,25 +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).
-Format them between code blocks (delimited by ```).
-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

@@ -2,4 +2,3 @@ build/
 /dist/
 .idea/
 .gradle/
-/x/

BUILD.md

@@ -1,268 +0,0 @@
-# Build scrcpy
-
-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).
-
-[prebuilt server]: #prebuilt-server
-
-## 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.
-
-
-## Requirements
-
-You need [adb]. It is available in the [Android SDK platform
-tools][platform-tools], or packaged in your distribution (`adb`).
-
-On Windows, download the [platform-tools][platform-tools-windows] and extract
-the following files to a directory accessible from your `PATH`:
- - `adb.exe`
- - `AdbWinApi.dll`
- - `AdbWinUsbApi.dll`
-
-The client requires [FFmpeg] and [LibSDL2]. Just follow the instructions.
-
-[adb]: https://developer.android.com/studio/command-line/adb.html
-[platform-tools]: https://developer.android.com/studio/releases/platform-tools.html
-[platform-tools-windows]: https://dl.google.com/android/repository/platform-tools-latest-windows.zip
-[ffmpeg]: https://en.wikipedia.org/wiki/FFmpeg
-[LibSDL2]: https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer
-
-
-
-## System-specific steps
-
-### Linux
-
-Install the required packages from your package manager.
-
-#### Debian/Ubuntu
-
-```bash
-# runtime dependencies
-sudo apt install ffmpeg libsdl2-2.0-0 adb
-
-# client build dependencies
-sudo apt install gcc git pkg-config meson ninja-build \
-                 libavcodec-dev libavformat-dev libavutil-dev \
-                 libsdl2-dev
-
-# server build dependencies
-sudo apt install openjdk-8-jdk
-```
-
-On old versions (like Ubuntu 16.04), `meson` is too old. In that case, install
-it from `pip3`:
-
-```bash
-sudo apt install python3-pip
-pip3 install meson
-```
-
-
-#### Fedora
-
-```bash
-# enable RPM fusion free
-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 meson gcc make
-
-# server build dependencies
-sudo dnf install java-devel
-```
-
-
-
-### Windows
-
-#### Cross-compile from Linux
-
-This is the preferred method (and the way the release is built).
-
-From _Debian_, install _mingw_:
-
-```bash
-sudo apt install mingw-w64 mingw-w64-tools
-```
-
-You also need the JDK to build the server:
-
-```bash
-sudo apt install openjdk-8-jdk
-```
-
-Then generate the releases:
-
-```bash
-make -f Makefile.CrossWindows
-```
-
-It will generate win32 and win64 releases into `dist/`.
-
-
-#### In MSYS2
-
-From Windows, you need [MSYS2] to build the project. From an MSYS2 terminal,
-install the required packages:
-
-[MSYS2]: http://www.msys2.org/
-
-```bash
-# runtime dependencies
-pacman -S mingw-w64-x86_64-SDL2 \
-          mingw-w64-x86_64-ffmpeg
-
-# client build dependencies
-pacman -S mingw-w64-x86_64-make \
-          mingw-w64-x86_64-gcc \
-          mingw-w64-x86_64-pkg-config \
-          mingw-w64-x86_64-meson
-```
-
-For a 32 bits version, replace `x86_64` by `i686`:
-
-```bash
-# runtime dependencies
-pacman -S mingw-w64-i686-SDL2 \
-          mingw-w64-i686-ffmpeg
-
-# client build dependencies
-pacman -S mingw-w64-i686-make \
-          mingw-w64-i686-gcc \
-          mingw-w64-i686-pkg-config \
-          mingw-w64-i686-meson
-```
-
-Java (>= 7) is not available in MSYS2, so if you plan to build the server,
-install it manually and make it available from the `PATH`:
-
-```bash
-export PATH="$JAVA_HOME/bin:$PATH"
-```
-
-### Mac OS
-
-Install the packages with [Homebrew]:
-
-[Homebrew]: https://brew.sh/
-
-```bash
-# runtime dependencies
-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 avaliable from the `PATH`:
-
-```bash
-brew tap caskroom/versions
-brew cask install java8
-export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
-export PATH="$JAVA_HOME/bin:$PATH"
-```
-
-### Docker
-
-See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).
-
-
-## Common steps
-
-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
-```
-
-Then, build:
-
-```bash
-meson x --buildtype release --strip -Db_lto=true
-ninja -Cx
-```
-
-_Note: `ninja` [must][ninja-user] be run as a non-root user (only `ninja
-install` must be run as root)._
-
-[ninja-user]: https://github.com/Genymobile/scrcpy/commit/4c49b27e9f6be02b8e63b508b60535426bd0291a
-
-
-### Run
-
-To run without installing:
-
-```bash
-./run x [options]
-```
-
-
-### Install
-
-After a successful build, you can install _scrcpy_ on the system:
-
-```bash
-sudo ninja -Cx install    # without sudo on Windows
-```
-
-This installs two files:
-
- - `/usr/local/bin/scrcpy`
- - `/usr/local/share/scrcpy/scrcpy-server`
-
-Just remove them to "uninstall" the application.
-
-You can then [run](README.md#run) _scrcpy_.
-
-
-## Prebuilt server
-
- - [`scrcpy-server-v1.13`][direct-scrcpy-server]  
-   _(SHA-256: 5fee64ca1ccdc2f38550f31f5353c66de3de30c2e929a964e30fa2d005d5f885)_
-
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.13/scrcpy-server-v1.13
-
-Download the prebuilt server somewhere, and specify its path during the Meson
-configuration:
-
-```bash
-meson x --buildtype release --strip -Db_lto=true \
-    -Dprebuilt_server=/path/to/scrcpy-server
-ninja -Cx
-sudo ninja -Cx install
-```
-
-The server only works with a matching client version (this server works with the
-`master` branch).

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
+[wrappers]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/wrappers
-[aidl]: https://github.com/Genymobile/scrcpy/tree/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/aidl/android/view
+[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,
+ - the **controller** thread, listening for _control events_ (typically,
-   keyboard and mouse events) from the client;
+   keyboard and mouse events) from the client.
- - the **receiver** thread (managed by the controller), sending _device messges_
-   to the clients (currently, it is only used to send the device clipboard
-   content).
 
 Since the video encoding is typically hardware, there would be no benefit in
 encoding and streaming in two different threads.
@@ -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
+[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/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L147-L148
+[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
+_Control events_ are received from the client by the [`EventController`] (run in
-separate thread). There are several types of input events:
+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
+All of them may need to inject input events to the system. To do so, they use
-_hidden_ method [`InputManager.injectInputEvent`] (exposed by our
+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
+push and start the server on the device, and open a socket so that they may
-stream, one for control) so that they may communicate.
+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,38 +169,25 @@ 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
+ - the **decoder** thread, decoding video frames,
-   recording,
+ - the **controller** thread, sending _control events_ to the server.
- - 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.
 
 
+### 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
+There are two [frames] simultaneously in memory:
-device) in a separate thread.
-
-If a [decoder] is present (i.e. `--no-display` is not set), then it uses _libav_
-to decode the H.264 stream from the socket, and notifies the main thread when a
-new frame is available.
-
-There are two [frames][video_buffer] simultaneously in memory:
  - the **decoding** frame, written by the decoder from the decoder thread,
  - the **rendering** frame, rendered in a texture from the main thread.
 
@@ -214,39 +195,26 @@ When a new decoded frame is available, the decoder _swaps_ the decoding and
 rendering frame (with proper synchronization). Thus, it immediatly starts
 to decode a new frame while the main thread renders the last one.
 
-If a [recorder] is present (i.e. `--record` is enabled), then it muxes the raw
+[decoder]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/decoder.c
-H.264 packet to the output video file.
+[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
+The [controller] is responsible to send _control events_ to the device. It runs
-runs in a separate thread, to avoid I/O on the main thread.
+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
+events_ to a blocking queue hold by the controller. On its own thread, the
-takes messages from the queue, that it serializes and sends to the client.
+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
+[controller]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/controller.h
-[controlmsg]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/control_msg.h
+[controlevent]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/controlevent.h
-[inputmanager]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/input_manager.h
+[inputmanager]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/inputmanager.h
-[convert]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/convert.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
+[scrcpy]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/scrcpy.c
-[event loop]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/scrcpy.c#L201
+[event loop]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/scrcpy.c#L38
-[screen]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/screen.h
+[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 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 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.ko.md

@@ -1,84 +0,0 @@
-# 자주하는 질문 (FAQ)
-
-다음은 자주 제보되는 문제들과 그들의 현황입니다.
-
-
-### Window 운영체제에서, 디바이스가 발견되지 않습니다.
-
-가장 흔한 제보는 `adb`에 발견되지 않는 디바이스 혹은 권한 관련 문제입니다.
-다음 명령어를 호출하여 모든 것들에 이상이 없는지 확인하세요:
-
-    adb devices
-
-Window는 당신의 디바이스를 감지하기 위해 [drivers]가 필요할 수도 있습니다.
-
-[drivers]: https://developer.android.com/studio/run/oem-usb.html
-
-
-### 내 디바이스의 미러링만 가능하고, 디바이스와 상호작용을 할 수 없습니다.
-
-일부 디바이스에서는, [simulating input]을 허용하기 위해서 한가지 옵션을 활성화해야 할 수도 있습니다.
-개발자 옵션에서 (developer options) 다음을 활성화 하세요:
-
-> **USB debugging (Security settings)**
-> _권한 부여와 USB 디버깅을 통한 simulating input을 허용한다_
-
-[simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-### 마우스 클릭이 다른 곳에 적용됩니다.
-
-Mac 운영체제에서, HiDPI support 와 여러 스크린 창이 있는 경우, 입력 위치가 잘못 파악될 수 있습니다.
-[issue 15]를 참고하세요.
-
-[issue 15]: https://github.com/Genymobile/scrcpy/issues/15
-
-차선책은 HiDPI support을 비활성화 하고 build하는 방법입니다:
-
-```bash
-meson x --buildtype release -Dhidpi_support=false
-```
-
-하지만, 동영상은 낮은 해상도로 재생될 것 입니다.
-
-
-### HiDPI display의 화질이 낮습니다.
-
-Windows에서는, [scaling behavior] 환경을 설정해야 할 수도 있습니다.
-
-> `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
-> Override high DPI scaling behavior > Scaling performed by: _Application_.
-
-[scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
-
-
-### KWin compositor가 실행되지 않습니다
-
-Plasma Desktop에서는,_scrcpy_ 가 실행중에는 compositor가 비활성화 됩니다.
-
-차석책으로는, ["Block compositing"를 비활성화하세요][kwin].
-
-[kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
-
-
-###비디오 스트림을 열 수 없는 에러가 발생합니다.(Could not open video stream).
-
-여러가지 원인이 있을 수 있습니다. 가장 흔한 원인은 디바이스의 하드웨어 인코더(hardware encoder)가
-주어진 해상도를 인코딩할 수 없는 경우입니다.
-
-```
-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
-```
-
-더 낮은 해상도로 시도 해보세요:
-
-```
-scrcpy -m 1920
-scrcpy -m 1024
-scrcpy -m 800
-```

FAQ.md

@@ -1,110 +1,66 @@
 # Frequently Asked Questions
 
+## 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.
 
+### On Windows, I have no output in the console
 
-## `adb` issues
+When run in `cmd.exe`, the application does not print anything. Even `scrcpy
+--help` have no output. We don't know why yet.
 
-`scrcpy` execute `adb` commands to initialize the connection with the device. If
+However, if you run the very same `scrcpy.exe` from
-`adb` fails, then scrcpy will not work.
+[MSYS2](https://www.msys2.org/) (`mingw64`), then it correctly prints output.
 
-In that case, it will print this error:
+As a workaround, redirect outputs to files, so that you can read the files
-
+afterwards:
->     ERROR: "adb push" returned with value 1
-
-This is typically not a bug in _scrcpy_, but a problem in your environment.
-
-To find out the cause, execute:
 
 ```bash
-adb devices
+scrcpy >stdout 2>stderr
+type stdout
+type stderr
 ```
 
-### `adb` not found
+_Note that all SDL logs are printed to stderr._
-
-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 unauthorized
+### On Windows, when I start the application, nothing happens
 
-Check [stackoverflow][device-unauthorized].
+The previous problem does not help to get a clue about the cause.
 
-[device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
+The most common is your device not being detected by `adb`, or is unauthorized.
+Check everything is ok by calling:
 
+    adb devices
 
-### Device not detected
+Windows may need some [drivers] to detect your device.
-
-If your device is not detected, you may need some [drivers] (on Windows).
 
 [drivers]: https://developer.android.com/studio/run/oem-usb.html
 
+If you still encounter problems, please see [issue 9].
 
-### Several devices connected
+[issue 9]: https://github.com/Genymobile/scrcpy/issues/9
-
-If several devices are connected, you will encounter this error:
-
->     adb: error: failed to get feature set: more than one device/emulator
-
-the identifier of the device you want to mirror must be provided:
-
-```bash
-scrcpy -s 01234567890abcdef
-```
-
-Note that if your device is connected over TCP/IP, you'll 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
+### I get a black screen for some applications like Silence
 
->     adb server version (41) doesn't match this client (39); killing...
+This is expected, they requested to protect the screen.
 
-This error occurs when you use several `adb` versions simultaneously. You must
+In [Silence], you can disable it in settings → Privacy → Screen security.
-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
+[silence]: https://f-droid.org/en/packages/org.smssecure.smssecure/
-use a specific `adb` binary, by setting the `ADB` environment variable:
 
-```bash
+See [issue 36].
-set ADB=/path/to/your/adb
+
-scrcpy
+[issue 36]: https://github.com/Genymobile/scrcpy/issues/36
-```
 
 
-### Device disconnected
+### Mouse clicks do not work
-
-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
 
 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
 
@@ -112,88 +68,14 @@ In developer options, enable:
 ### Mouse clicks at wrong location
 
 On MacOS, with HiDPI support and multiple screens, input location are wrongly
-scaled. See [#15].
+scaled. See [issue 15].
 
-[#15]: https://github.com/Genymobile/scrcpy/issues/15
+[issue 15]: https://github.com/Genymobile/scrcpy/issues/15
 
-Open _scrcpy_ directly on the monitor you use it.
+A workaround is to build with HiDPI support disabled:
 
-
+```bash
-### Special characters do not work
+meson x --buildtype release -Dhidpi_support=false
-
-Injecting text input is [limited to ASCII characters][text-input]. A trick
-allows to also inject some [accented characters][accented-characters], but
-that's all. See [#37].
-
-[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
-
-
-## 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
-
-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:
-
-```
-scrcpy --render-driver=opengl
 ```
 
-You may also need to configure the [scaling behavior]:
+However, the video will be displayed at lower resolution.
-
-> `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
-> Override high DPI scaling behavior > Scaling performed by: _Application_.
-
-[scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
-
-
-
-### KWin compositor crashes
-
-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
-```

LICENSE

@@ -188,7 +188,6 @@
       identification within third-party archives.
 
    Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2020 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

@@ -0,0 +1,62 @@
+# This makefile provides recipes to build a "portable" version of scrcpy.
+#
+# 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.
+#
+# "make release-portable" builds a zip containing the client and the server.
+#
+# This is a simple Makefile because Meson is not flexible enough to execute some
+# arbitrary commands.
+
+.PHONY: default clean build-portable release-portable dist-portable dist-portable-zip sums test check
+
+GRADLE ?= ./gradlew
+
+PORTABLE_BUILD_DIR := build-portable
+DIST := dist
+TARGET_DIR := scrcpy
+
+VERSION := $(shell git describe --tags --always)
+TARGET := $(TARGET_DIR)-$(VERSION).zip
+
+default:
+	@echo 'You must specify a target. Try: make release-portable'
+
+clean:
+	$(GRADLE) clean
+	rm -rf "$(PORTABLE_BUILD_DIR)" "$(DIST)"
+
+build-portable:
+	[ -d "$(PORTABLE_BUILD_DIR)" ] || ( mkdir "$(PORTABLE_BUILD_DIR)" && \
+		meson "$(PORTABLE_BUILD_DIR)" \
+			--buildtype release --strip -Db_lto=true \
+			-Doverride_server_path=scrcpy-server.jar )
+	ninja -C "$(PORTABLE_BUILD_DIR)"
+
+release-portable: clean dist-portable-zip sums
+	@echo "Release created in $(DIST)/."
+
+dist-portable: build-portable
+	mkdir -p "$(DIST)/$(TARGET_DIR)"
+	cp "$(PORTABLE_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(TARGET_DIR)/"
+	cp "$(PORTABLE_BUILD_DIR)"/app/scrcpy "$(DIST)/$(TARGET_DIR)/"
+
+dist-portable-zip: dist-portable
+	cd "$(DIST)"; \
+		zip -r "$(TARGET)" "$(TARGET_DIR)"
+
+sums:
+	cd "$(DIST)"; \
+		sha256sum *.zip > SHA256SUM.txt
+
+test: build-portable
+	$(GRADLE) test
+	ninja -C "$(PORTABLE_BUILD_DIR)" test
+
+check: build-portable
+	$(GRADLE) check
+	ninja -C "$(PORTABLE_BUILD_DIR)" test

Makefile.CrossWindows

@@ -1,138 +0,0 @@
-# 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).
-#
-# In particular, this implies to change the location from where the client push
-# the server to the device.
-
-.PHONY: default clean \
-	build-server \
-	prepare-deps-win32 prepare-deps-win64 \
-	build-win32 build-win32-noconsole \
-	build-win64 build-win64-noconsole \
-	dist-win32 dist-win64 \
-	zip-win32 zip-win64 \
-	sums release
-
-GRADLE ?= ./gradlew
-
-SERVER_BUILD_DIR := build-server
-WIN32_BUILD_DIR := build-win32
-WIN32_NOCONSOLE_BUILD_DIR := build-win32-noconsole
-WIN64_BUILD_DIR := build-win64
-WIN64_NOCONSOLE_BUILD_DIR := build-win64-noconsole
-
-DIST := dist
-WIN32_TARGET_DIR := scrcpy-win32
-WIN64_TARGET_DIR := scrcpy-win64
-
-VERSION := $(shell git describe --tags --always)
-WIN32_TARGET := $(WIN32_TARGET_DIR)-$(VERSION).zip
-WIN64_TARGET := $(WIN64_TARGET_DIR)-$(VERSION).zip
-
-release: clean zip-win32 zip-win64 sums
-	@echo "Windows archives generated in $(DIST)/"
-
-clean:
-	$(GRADLE) clean
-	rm -rf "$(SERVER_BUILD_DIR)" "$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)" \
-		   "$(WIN32_NOCONSOLE_BUILD_DIR)" "$(WIN64_NOCONSOLE_BUILD_DIR)" "$(DIST)"
-
-build-server:
-	[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
-		meson "$(SERVER_BUILD_DIR)" \
-			--buildtype release -Dcompile_app=false )
-		ninja -C "$(SERVER_BUILD_DIR)"
-
-prepare-deps-win32:
-	-$(MAKE) -C prebuilt-deps prepare-win32
-
-build-win32: prepare-deps-win32
-	[ -d "$(WIN32_BUILD_DIR)" ] || ( mkdir "$(WIN32_BUILD_DIR)" && \
-		meson "$(WIN32_BUILD_DIR)" \
-			--cross-file cross_win32.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
-			-Dportable=true )
-	ninja -C "$(WIN32_BUILD_DIR)"
-
-build-win32-noconsole: prepare-deps-win32
-	[ -d "$(WIN32_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN32_NOCONSOLE_BUILD_DIR)" && \
-		meson "$(WIN32_NOCONSOLE_BUILD_DIR)" \
-			--cross-file cross_win32.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
-			-Dwindows_noconsole=true \
-			-Dportable=true )
-	ninja -C "$(WIN32_NOCONSOLE_BUILD_DIR)"
-
-prepare-deps-win64:
-	-$(MAKE) -C prebuilt-deps prepare-win64
-
-build-win64: prepare-deps-win64
-	[ -d "$(WIN64_BUILD_DIR)" ] || ( mkdir "$(WIN64_BUILD_DIR)" && \
-		meson "$(WIN64_BUILD_DIR)" \
-			--cross-file cross_win64.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
-			-Dportable=true )
-	ninja -C "$(WIN64_BUILD_DIR)"
-
-build-win64-noconsole: prepare-deps-win64
-	[ -d "$(WIN64_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN64_NOCONSOLE_BUILD_DIR)" && \
-		meson "$(WIN64_NOCONSOLE_BUILD_DIR)" \
-			--cross-file cross_win64.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
-			-Dwindows_noconsole=true \
-			-Dportable=true )
-	ninja -C "$(WIN64_NOCONSOLE_BUILD_DIR)"
-
-dist-win32: build-server build-win32 build-win32-noconsole
-	mkdir -p "$(DIST)/$(WIN32_TARGET_DIR)"
-	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(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.2.2-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.12/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 "$(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.2.2-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.12/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-
-zip-win32: dist-win32
-	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
-		zip -r "../$(WIN32_TARGET)" .
-
-zip-win64: dist-win64
-	cd "$(DIST)/$(WIN64_TARGET_DIR)"; \
-		zip -r "../$(WIN64_TARGET)" .
-
-sums:
-	cd "$(DIST)"; \
-		sha256sum *.zip > SHA256SUMS.txt

README.ko.md

@@ -1,498 +0,0 @@
-# scrcpy (v1.11)
-
-This document will be updated frequently along with the original Readme file
-이 문서는 원어 리드미 파일의 업데이트에 따라 종종 업데이트 될 것입니다
-
- 이 어플리케이션은 UBS ( 혹은 [TCP/IP][article-tcpip] ) 로 연결된 Android 디바이스를 화면에 보여주고 관리하는 것을 제공합니다.
- _GNU/Linux_, _Windows_ 와 _macOS_ 상에서 작동합니다.
- (아래 설명에서 디바이스는 안드로이드 핸드폰을 의미합니다.)
-
-[article-tcpip]:https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
-
-![screenshot](https://github.com/Genymobile/scrcpy/blob/master/assets/screenshot-debian-600.jpg?raw=true)
-
-주요 기능은 다음과 같습니다.
-
- - **가벼움** (기본적이며 디바이스의 화면만을 보여줌)
- - **뛰어난 성능** (30~60fps)
- - **높은 품질** (1920×1080 이상의 해상도)
- - **빠른 반응 속도** ([35~70ms][lowlatency])
- - **짧은 부팅 시간** (첫 사진을 보여주는데 최대 1초 소요됨)
- - **장치 설치와는 무관함** (디바이스에 설치하지 않아도 됨)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-
-## 요구사항
-
-안드로이드 장치는 최소 API 21 (Android 5.0) 을 필요로 합니다.
-
-디바이스에 [adb debugging][enable-adb]이 가능한지 확인하십시오.
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-어떤 디바이스에서는, 키보드와 마우스를 사용하기 위해서 [추가 옵션][control] 이 필요하기도 합니다.
-
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-## 앱 설치하기
-
-
-### Linux (리눅스)
-
-리눅스 상에서는 보통 [어플을 직접 설치][BUILD] 해야합니다. 어렵지 않으므로 걱정하지 않아도 됩니다.
-
-[BUILD]:https://github.com/Genymobile/scrcpy/blob/master/BUILD.md
-
-[Snap] 패키지가 가능합니다 : [`scrcpy`][snap-link].
-
-[snap-link]: https://snapstats.org/snaps/scrcpy
-
-[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
-
-Arch Linux에서, [AUR] 패키지가 가능합니다 : [`scrcpy`][aur-link].
-
-[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
-
-Gentoo에서 ,[Ebuild] 가 가능합니다 : [`scrcpy/`][ebuild-link].
-
-[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
-[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-
-
-### Windows (윈도우)
-
-윈도우 상에서, 간단하게 설치하기 위해 종속성이 있는 사전 구축된 아카이브가 제공됩니다 (`adb` 포함) :
-해당 파일은 Readme원본 링크를 통해서 다운로드가 가능합니다.
- - [`scrcpy-win`][direct-win]
-
-[direct-win]: https://github.com/Genymobile/scrcpy/blob/master/README.md#windows
-
-
-[어플을 직접 설치][BUILD] 할 수도 있습니다.
-
-
-### macOS (맥 OS)
-
-이 어플리케이션은 아래 사항을 따라 설치한다면 [Homebrew] 에서도 사용 가능합니다 :
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-`PATH` 로부터 접근 가능한 `adb` 가 필요합니다. 아직 설치하지 않았다면 다음을 따라 설치해야 합니다 :
-
-```bash
-brew cask install android-platform-tools
-```
-
-[어플을 직접 설치][BUILD] 할 수도 있습니다.
-
-
-## 실행
-
-안드로이드 디바이스를 연결하고 실행하십시오:
-
-```bash
-scrcpy
-```
-
-다음과 같이 명령창 옵션 기능도 제공합니다.
-
-```bash
-scrcpy --help
-```
-
-## 기능
-
-### 캡쳐 환경 설정
-
-
-###사이즈 재정의
-
-가끔씩 성능을 향상시키기위해 안드로이드 디바이스를 낮은 해상도에서 미러링하는 것이 유용할 때도 있습니다.
-
-너비와 높이를 제한하기 위해 특정 값으로 지정할 수 있습니다 (e.g. 1024) :
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # 축약 버전
-```
-
-이 외의 크기도 디바이스의 가로 세로 비율이 유지된 상태에서 계산됩니다.
-이러한 방식으로 디바이스 상에서 1920×1080 는 모니터 상에서1024×576로 미러링될 것 입니다.
-
-
-### bit-rate 변경
-
-기본 bit-rate 는 8 Mbps입니다. 비디오 bit-rate 를 변경하기 위해선 다음과 같이 입력하십시오 (e.g. 2 Mbps로 변경):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # 축약 버전
-```
-
-###프레임 비율 제한
-
-안드로이드 버전 10이상의 디바이스에서는, 다음의 명령어로 캡쳐 화면의 프레임 비율을 제한할 수 있습니다:
-
-```bash
-scrcpy --max-fps 15
-```
-
-
-### Crop (잘라내기)
-
-디바이스 화면은 화면의 일부만 미러링하기 위해 잘라질 것입니다.
-
-예를 들어, *Oculus Go* 의 한 쪽 눈만 미러링할 때 유용합니다 :
-
-```bash
-scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
-scrcpy -c 1224:1440:0:0       # 축약 버전
-```
-
-만약 `--max-size` 도 지정하는 경우, 잘라낸 다음에 재정의된 크기가 적용될 것입니다.
-
-
-### 화면 녹화
-
-미러링하는 동안 화면 녹화를 할 수 있습니다 :
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-녹화하는 동안 미러링을 멈출 수 있습니다 :
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# Ctrl+C 로 녹화를 중단할 수 있습니다.
-# 윈도우 상에서 Ctrl+C 는 정상정으로 종료되지 않을 수 있으므로, 디바이스 연결을 해제하십시오.
-```
-
-"skipped frames" 은 모니터 화면에 보여지지 않았지만 녹화되었습니다 ( 성능 문제로 인해 ). 프레임은 디바이스 상에서 _타임 스탬프 ( 어느 시점에 데이터가 존재했다는 사실을 증명하기 위해 특정 위치에 시각을 표시 )_ 되었으므로, [packet delay
-variation] 은 녹화된 파일에 영향을 끼치지 않습니다.
-
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-## 연결
-
-### 무선연결
-
-_Scrcpy_ 장치와 정보를 주고받기 위해 `adb` 를 사용합니다.  `adb` 는 TCIP/IP 를 통해 디바이스와 [연결][connect] 할 수 있습니다 :
-
-1. 컴퓨터와 디바이스를 동일한 Wi-Fi 에 연결합니다.
-2. 디바이스의 IP address 를 확인합니다 (설정 → 내 기기 → 상태 / 혹은 인터넷에 '내 IP'검색 시 확인 가능합니다. ).
-3. TCP/IP 를 통해 디바이스에서 adb 를 사용할 수 있게 합니다: `adb tcpip 5555`.
-4. 디바이스 연결을 해제합니다.
-5. adb 를 통해 디바이스에 연결을 합니다\: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` 대신)_.
-6. `scrcpy` 실행합니다.
-
-다음은 bit-rate 와 해상도를 줄이는데 유용합니다 :
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # 축약 버전
-```
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-
-### 여러 디바이스 사용 가능
-
-만약에 여러 디바이스들이 `adb devices` 목록에 표시되었다면, _serial_ 을 명시해야합니다:
-
-```bash
-scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # 축약 버전
-```
-
-_scrcpy_ 로 여러 디바이스를 연결해 사용할 수 있습니다.
-
-
-#### SSH tunnel
-
-떨어져 있는 디바이스와 연결하기 위해서는, 로컬 `adb` client와 떨어져 있는 `adb` 서버를 연결해야 합니다.  (디바이스와 클라이언트가 동일한 버전의 _adb_ protocol을 사용할 경우에 제공됩니다.):
-
-```bash
-adb kill-server    # 5037의 로컬 local adb server를 중단
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# 실행 유지
-```
-
-다른 터미널에서는 :
-
-```bash
-scrcpy
-```
-
-무선 연결과 동일하게, 화질을 줄이는 것이 나을 수 있습니다:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-## Window에서의 배치
-
-### 맞춤형 window 제목
-
-기본적으로, window의 이름은 디바이스의 모델명 입니다.
-다음의 명령어를 통해 변경하세요.
-
-```bash
-scrcpy --window-title 'My device'
-```
-
-
-### 배치와 크기
-
-초기 window창의 배치와 크기는 다음과 같이 설정할 수 있습니다:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-
-### 경계 없애기
-
-윈도우 장식(경계선 등)을 다음과 같이 제거할 수 있습니다:
-
-```bash
-scrcpy --window-borderless
-```
-
-### 항상 모든 윈도우 위에 실행창 고정
-
-이 어플리케이션의 윈도우 창은 다음의 명령어로 다른 window 위에 디스플레이 할 수 있습니다:
-
-```bash
-scrcpy --always-on-top
-scrcpy -T  # 축약 버전
-```
-
-### 전체 화면
-
-이 어플리케이션은 전체화면으로 바로 시작할 수 있습니다.
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # short version
-```
-
-전체 화면은  `Ctrl`+`f`키로 끄거나 켤 수 있습니다.
-
-
-## 다른 미러링 옵션
-
-### 읽기 전용(Read-only)
-
-권한을 제한하기 위해서는 (디바이스와 관련된 모든 것: 입력 키, 마우스 이벤트 , 파일의 드래그 앤 드랍(drag&drop)):
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-### 화면 끄기
-
-미러링을 실행하는 와중에 디바이스의 화면을 끌 수 있게 하기 위해서는
-다음의 커맨드 라인 옵션을(command line option) 입력하세요:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-혹은 `Ctrl`+`o`을 눌러 언제든지 디바이스의 화면을 끌 수 있습니다.
-
-다시 화면을 켜기 위해서는`POWER` (혹은 `Ctrl`+`p`)를 누르세요.
-
-
-### 유효기간이 지난 프레임 제공 (Render expired frames)
-
-디폴트로, 대기시간을 최소화하기 위해 _scrcpy_ 는 항상 마지막으로 디코딩된 프레임을 제공합니다
-과거의 프레임은 하나씩 삭제합니다.
-
-모든 프레임을 강제로 렌더링하기 위해서는 (대기 시간이 증가될 수 있습니다)
-다음의 명령어를 사용하세요:
-
-```bash
-scrcpy --render-expired-frames
-```
-
-
-### 화면에 터치 나타내기
-
-발표를 할 때, 물리적인 기기에 한 물리적 터치를 나타내는 것이 유용할 수 있습니다.
-
-안드로이드 운영체제는 이런 기능을 _Developers options_에서 제공합니다.
-
-_Scrcpy_ 는 이런 기능을 시작할 때와 종료할 때 옵션으로 제공합니다.
-
-```bash
-scrcpy --show-touches
-scrcpy -t
-```
-
-화면에 _물리적인 터치만_ 나타나는 것에 유의하세요 (손가락을 디바이스에 대는 행위).
-
-
-### 입력 제어
-
-#### 복사-붙여넣기
-
-컴퓨터와 디바이스 양방향으로 클립보드를 복사하는 것이 가능합니다:
-
- - `Ctrl`+`c` 디바이스의 클립보드를 컴퓨터로 복사합니다;
- - `Ctrl`+`Shift`+`v` 컴퓨터의 클립보드를 디바이스로 복사합니다;
- - `Ctrl`+`v` 컴퓨터의 클립보드를 text event 로써 _붙여넣습니다_  ( 그러나, ASCII 코드가 아닌 경우 실행되지 않습니다 )
-
-#### 텍스트 삽입 우선 순위
-
-텍스트를 입력할 때 생성되는 두 가지의 [events][textevents] 가 있습니다:
- - _key events_, 키가 눌려있는 지에 대한 신호;
- - _text events_, 텍스트가 입력되었는지에 대한 신호.
-
-기본적으로, 글자들은 key event 를 이용해 입력되기 때문에, 키보드는 게임에서처럼 처리합니다 ( 보통 WASD 키에 대해서 ).
-
-그러나 이는 [issues 를 발생][prefertext]시킵니다. 이와 관련된 문제를 접할 경우, 아래와 같이 피할 수 있습니다:
-
-```bash
-scrcpy --prefer-text
-```
-
-( 그러나 이는 게임에서의 처리를 중단할 수 있습니다 )
-
-[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
-[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-
-
-### 파일 드랍
-
-### APK 실행하기
-
-APK를 실행하기 위해서는, APK file(파일명이`.apk`로 끝나는 파일)을  드래그하고 _scrcpy_ window에 드랍하세요 (drag and drop)
-
-시각적인 피드백은 없고,log 하나가 콘솔에 출력될 것입니다.
-
-### 디바이스에 파일 push하기
-
-디바이스의`/sdcard/`에 파일을 push하기 위해서는,
-APK파일이 아닌 파일을_scrcpy_ window에 드래그하고 드랍하세요.(drag and drop).
-
-시각적인 피드백은 없고,log 하나가 콘솔에 출력될 것입니다.
-
-해당 디렉토리는 시작할 때 변경이 가능합니다:
-
-```bash
-scrcpy --push-target /sdcard/foo/bar/
-```
-
-### 오디오의 전달
-
-_scrcpy_는 오디오를 직접 전달해주지 않습니다. [USBaudio] (Linux-only)를 사용하세요.
-
-추가적으로 [issue #14]를 참고하세요.
-
-[USBaudio]: https://github.com/rom1v/usbaudio
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
-
-## 단축키
-
- | 실행내용                                |   단축키                       |   단축키 (macOS)
- | -------------------------------------- |:----------------------------- |:-----------------------------
- | 전체화면 모드로 전환                      | `Ctrl`+`f`                    | `Cmd`+`f`
- | window를 1:1비율로 전환하기(픽셀 맞춤)   | `Ctrl`+`g`                    | `Cmd`+`g`
- | 검은 공백 제거 위한 window 크기 조정  | `Ctrl`+`x` \| _Double-click¹_ | `Cmd`+`x`  \| _Double-click¹_
- |`HOME` 클릭                        | `Ctrl`+`h` \| _Middle-click_  | `Ctrl`+`h` \| _Middle-click_
- | `BACK` 클릭                      | `Ctrl`+`b` \| _Right-click²_  | `Cmd`+`b`  \| _Right-click²_
- | `APP_SWITCH` 클릭                 | `Ctrl`+`s`                    | `Cmd`+`s`
- | `MENU` 클릭                       | `Ctrl`+`m`                    | `Ctrl`+`m`
- | `VOLUME_UP` 클릭                   | `Ctrl`+`↑` _(up)_             | `Cmd`+`↑` _(up)_
- | `VOLUME_DOWN` 클릭                | `Ctrl`+`↓` _(down)_           | `Cmd`+`↓` _(down)_
- | `POWER` 클릭                      | `Ctrl`+`p`                    | `Cmd`+`p`
- | 전원 켜기                               | _Right-click²_                | _Right-click²_
- | 미러링 중 디바이스 화면 끄기    | `Ctrl`+`o`                    | `Cmd`+`o`
- | 알림 패널 늘리기               | `Ctrl`+`n`                    | `Cmd`+`n`
- | 알림 패널 닫기            | `Ctrl`+`Shift`+`n`            | `Cmd`+`Shift`+`n`
- | 디바이스의 clipboard 컴퓨터로 복사하기      | `Ctrl`+`c`                    | `Cmd`+`c`
- | 컴퓨터의 clipboard 디바이스에 붙여넣기     | `Ctrl`+`v`                    | `Cmd`+`v`
- | Copy computer clipboard to device      | `Ctrl`+`Shift`+`v`            | `Cmd`+`Shift`+`v`
- | Enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    | `Cmd`+`i`
-
-_¹검은 공백을 제거하기 위해서는 그 부분을 더블 클릭하세요_
-_²화면이 꺼진 상태에서 우클릭 시 다시 켜지며, 그 외의 상태에서는 뒤로 돌아갑니다.
-
-## 맞춤 경로 (custom path)
-
-특정한 _adb_ binary를 사용하기 위해서는, 그것의 경로를 환경변수로 설정하세요.
-`ADB`:
-
-    ADB=/path/to/adb scrcpy
-
-`scrcpy-server.jar`파일의 경로에 오버라이드 하기 위해서는, 그것의 경로를 `SCRCPY_SERVER_PATH`에 저장하세요.
-
-[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
-
-
-## _scrcpy_ 인 이유?
-
-한 동료가 [gnirehtet]와 같이 발음하기 어려운 이름을 찾을 수 있는지 도발했습니다.
-
-[`strcpy`] 는 **str**ing을 copy하고; `scrcpy`는 **scr**een을 copy합니다.
-
-[gnirehtet]: https://github.com/Genymobile/gnirehtet
-[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
-
-
-
-## 빌드하는 방법?
-
-[BUILD]을 참고하세요.
-
-[BUILD]: BUILD.md
-
-## 흔한 issue
-
-[FAQ](FAQ.md)을 참고하세요.
-
-
-## 개발자들
-
-[developers page]를 참고하세요.
-
-[developers page]: DEVELOP.md
-
-
-## 라이선스
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## 관련 글 (articles)
-
-- [scrcpy 소개][article-intro]
-- [무선으로 연결하는 Scrcpy][article-tcpip]
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/

README.md

@@ -1,122 +1,222 @@
-# scrcpy (v1.13)
+# scrcpy
 
 This application provides display and control of Android devices connected on
-USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
+USB. It does not require any _root_ access. It works on _GNU/Linux_, _Windows_
-It works on _GNU/Linux_, _Windows_ and _macOS_.
+and _MacOS_.
 
 ![screenshot](assets/screenshot-debian-600.jpg)
 
-It focuses on:
-
- - **lightness** (native, displays only the device screen)
- - **performance** (30~60fps)
- - **quality** (1920×1080 or above)
- - **low latency** ([35~70ms][lowlatency])
- - **low startup time** (~1 second to display the first image)
- - **non-intrusiveness** (nothing is left installed on the device)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
 
 ## Requirements
 
-The Android device requires at least API 21 (Android 5.0).
+The Android part requires at least API 19 (Android 4.4).
+
+You need [adb]. It is available in the [Android SDK platform
+tools][platform-tools], or packaged in your distribution (`android-adb-tools`).
+
+On Windows, if you use the [prebuilt application](#windows), it is already
+included. Otherwise, just download the [platform-tools][platform-tools-windows]
+and extract the following files to a directory accessible from your `PATH`:
+ - `adb.exe`
+ - `AdbWinApi.dll`
+ - `AdbWinUsbApi.dll`
 
 Make sure you [enabled adb debugging][enable-adb] on your device(s).
 
+The client requires [FFmpeg] and [LibSDL2].
+
+[adb]: https://developer.android.com/studio/command-line/adb.html
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
+[platform-tools]: https://developer.android.com/studio/releases/platform-tools.html
+[platform-tools-windows]: https://dl.google.com/android/repository/platform-tools-latest-windows.zip
+[ffmpeg]: https://en.wikipedia.org/wiki/FFmpeg
+[LibSDL2]: https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer
 
-On some devices, you also need to enable [an additional option][control] to
+## Build and install
-control it using keyboard and mouse.
 
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
+### System-specific steps
 
+#### Linux
 
-## Get the app
+Install the required packages from your package manager.
 
+##### Debian/Ubuntu
 
-### Linux
+```bash
+# runtime dependencies
+sudo apt install ffmpeg libsdl2-2.0.0
 
-On Debian (_testing_ and _sid_ for now) and Ubuntu (20.04):
+# client build dependencies
+sudo apt install make gcc pkg-config meson \
+                 libavcodec-dev libavformat-dev libavutil-dev \
+                 libsdl2-dev
 
-```
+# server build dependencies
-apt install scrcpy
+sudo apt install openjdk-8-jdk
 ```
 
-A [Snap] package is available: [`scrcpy`][snap-link].
+##### Fedora
 
-[snap-link]: https://snapstats.org/snaps/scrcpy
+```bash
+# enable RPM fusion free
+sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
 
-[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
+# client build dependencies
+sudo dnf install SDL2-devel ffms2-devel meson gcc make
 
-For Arch Linux, an [AUR] package is available: [`scrcpy`][aur-link].
+# server build dependencies
+sudo dnf install java
+```
+
+##### Arch Linux
+
+Two [AUR] packages have been created by users:
+
+ - [`scrcpy`](https://aur.archlinux.org/packages/scrcpy/)
+ - [`scrcpy-prebuiltserver`](https://aur.archlinux.org/packages/scrcpy-prebuiltserver/)
 
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
-
-For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
-
-[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
-[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-
-You could also [build the app manually][BUILD] (don't worry, it's not that
-hard).
 
 
-
+#### Windows
-### Windows
 
 For Windows, for simplicity, a prebuilt archive with all the dependencies
 (including `adb`) is available:
 
- - [`scrcpy-win64-v1.13.zip`][direct-win64]  
+ - [`scrcpy-windows-with-deps-v1.1.zip`][direct-windows-with-deps].  
-   _(SHA-256: 806aafc00d4db01513193addaa24f47858893ba5efe75770bfef6ae1ea987d27)_
+   _(SHA-256: 27eb36c15937601d1062c1dc0b45faae0e06fefea2019aadeb4fa7f76a07bb4c)_
 
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.13/scrcpy-win64-v1.13.zip
+[direct-windows-with-deps]: https://github.com/Genymobile/scrcpy/releases/download/v1.1/scrcpy-windows-with-deps-v1.1.zip
 
-It is also available in [Chocolatey]:
+_(It's just a portable version including _dll_ copied from MSYS2.)_
 
-[Chocolatey]: https://chocolatey.org/
+Instead, you may want to build it manually. You need [MSYS2] to build the
+project. From an MSYS2 terminal, install the required packages:
+
+[MSYS2]: http://www.msys2.org/
 
 ```bash
-choco install scrcpy
+# runtime dependencies
-choco install adb    # if you don't have it yet
+pacman -S mingw-w64-x86_64-SDL2 \
+          mingw-w64-x86_64-ffmpeg
+
+# client build dependencies
+pacman -S mingw-w64-x86_64-make \
+          mingw-w64-x86_64-gcc \
+          mingw-w64-x86_64-pkg-config \
+          mingw-w64-x86_64-meson
 ```
 
-And in [Scoop]:
+Java (>= 7) is not available in MSYS2, so if you plan to build the server,
+install it manually and make it available from the `PATH`:
 
 ```bash
-scoop install scrcpy
+export PATH="$JAVA_HOME/bin:$PATH"
-scoop install adb    # if you don't have it yet
 ```
 
-[Scoop]: https://scoop.sh
+#### Mac OS
 
-You can also [build the app manually][BUILD].
+Use [Homebrew] to install the packages:
-
-
-### macOS
-
-The application is available in [Homebrew]. Just install it:
 
 [Homebrew]: https://brew.sh/
 
 ```bash
-brew install scrcpy
+# runtime dependencies
+brew install sdl2 ffmpeg
+
+# client build dependencies
+brew install pkg-config meson
 ```
 
-You need `adb`, accessible from your `PATH`. If you don't have it yet:
+Additionally, if you want to build the server, install Java 8 from Caskroom, and
+make it avaliable from the `PATH`:
 
 ```bash
-brew cask install android-platform-tools
+brew tap caskroom/versions
+brew cask install java8
+export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
+export PATH="$JAVA_HOME/bin:$PATH"
 ```
 
-You can also [build the app manually][BUILD].
+#### Docker
 
+See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).
+
+### Common steps
+
+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
+```
+
+Clone the project:
+
+```bash
+git clone https://github.com/Genymobile/scrcpy
+cd scrcpy
+```
+
+Then, build:
+
+```bash
+meson x --buildtype release --strip -Db_lto=true
+cd x
+ninja
+```
+
+You can test it from here:
+
+```bash
+ninja run
+```
+
+Or you can install it on the system:
+
+```bash
+sudo ninja install    # without sudo on Windows
+```
+
+This installs two files:
+
+ - `/usr/local/bin/scrcpy`
+ - `/usr/local/share/scrcpy/scrcpy-server.jar`
+
+Just remove them to "uninstall" the application.
+
+
+#### Prebuilt server
+
+Since the server binary, that will be pushed to the Android device, does not
+depend on your system and architecture, you may want to use the prebuilt binary
+instead:
+
+ - [`scrcpy-server-v1.1.jar`][direct-scrcpy-server].  
+   _(SHA-256: 14826512bf38447ec94adf3b531676ce038d19e7e06757fb4e537882b17e77b3)_
+
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.1/scrcpy-server-v1.1.jar
+
+In that case, the build does not require Java or the Android SDK.
+
+Download the prebuilt server somewhere, and specify its path during the Meson
+configuration:
+
+```bash
+meson x --buildtype release --strip -Db_lto=true \
+    -Dprebuilt_server=/path/to/scrcpy-server.jar
+cd x
+ninja
+sudo ninja install
+```
 
 ## Run
 
-Plug an Android device, and execute:
+_At runtime, `adb` must be accessible from your `PATH`._
+
+If everything is ok, just plug an Android device, and execute:
 
 ```bash
 scrcpy
@@ -128,455 +228,62 @@ It accepts command-line arguments, listed by:
 scrcpy --help
 ```
 
-## Features
+For example, to decrease video bitrate to 2Mbps (default is 8Mbps):
-
-### Capture configuration
-
-#### Reduce size
-
-Sometimes, it is useful to mirror an Android device at a lower definition to
-increase performance.
-
-To limit both the width and height to some value (e.g. 1024):
 
 ```bash
-scrcpy --max-size 1024
+scrcpy -b 2M
-scrcpy -m 1024  # short version
 ```
 
-The other dimension is computed to that the device aspect ratio is preserved.
+To limit the video dimensions (e.g. if the device is 2540×1440, but the host
-That way, a device in 1920×1080 will be mirrored at 1024×576.
+screen is smaller, or cannot decode such a high definition):
-
-
-#### Change bit-rate
-
-The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):
 
 ```bash
-scrcpy --bit-rate 2M
+scrcpy -m 1024
-scrcpy -b 2M  # short version
 ```
 
-#### Limit frame rate
-
-The capture frame rate can be limited:
-
-```bash
-scrcpy --max-fps 15
-```
-
-This is officially supported since Android 10, but may work on earlier versions.
-
-#### Crop
-
-The device screen may be cropped to mirror only part of the screen.
-
-This is useful for example to mirror only one eye of the Oculus Go:
-
-```bash
-scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
-```
-
-If `--max-size` is also specified, resizing is applied after cropping.
-
-
-#### Lock video orientation
-
-
-To lock the orientation of the mirroring:
-
-```bash
-scrcpy --lock-video-orientation 0   # natural orientation
-scrcpy --lock-video-orientation 1   # 90° counterclockwise
-scrcpy --lock-video-orientation 2   # 180°
-scrcpy --lock-video-orientation 3   # 90° clockwise
-```
-
-This affects recording orientation.
-
-
-### Recording
-
-It is possible to record the screen while mirroring:
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-To disable mirroring while recording:
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# interrupt recording with Ctrl+C
-```
-
-"Skipped frames" are recorded, even if they are not displayed in real time (for
-performance reasons). Frames are _timestamped_ on the device, so [packet delay
-variation] does not impact the recorded file.
-
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-
-### Connection
-
-#### Wireless
-
-_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
-device over TCP/IP:
-
-1. Connect the device to the same Wi-Fi as your computer.
-2. Get your device IP address (in Settings → About phone → Status).
-3. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
-4. Unplug your device.
-5. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`)_.
-6. Run `scrcpy` as usual.
-
-It may be useful to decrease the bit-rate and the definition:
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # short version
-```
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-#### Multi-devices
-
 If several devices are listed in `adb devices`, you must specify the _serial_:
 
 ```bash
-scrcpy --serial 0123456789abcdef
+scrcpy -s 0123456789abcdef
-scrcpy -s 0123456789abcdef  # short version
 ```
 
-If the device is connected over TCP/IP:
+To show physical touches while scrcpy is running:
 
 ```bash
-scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # short version
-```
-
-You can start several instances of _scrcpy_ for several devices.
-
-#### Autostart on device connection
-
-You could use [AutoAdb]:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
-
-#### SSH tunnel
-
-To connect to a remote device, it is possible to connect a local `adb` client to
-a remote `adb` server (provided they use the same version of the _adb_
-protocol):
-
-```bash
-adb kill-server    # kill the local adb server on 5037
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# keep this open
-```
-
-From another terminal:
-
-```bash
-scrcpy
-```
-
-Like for wireless connections, it may be useful to reduce quality:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-### Window configuration
-
-#### Title
-
-By default, the window title is the device model. It can be changed:
-
-```bash
-scrcpy --window-title 'My device'
-```
-
-#### Position and size
-
-The initial window position and size may be specified:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-#### Borderless
-
-To disable window decorations:
-
-```bash
-scrcpy --window-borderless
-```
-
-#### Always on top
-
-To keep the scrcpy window always on top:
-
-```bash
-scrcpy --always-on-top
-```
-
-#### Fullscreen
-
-The app may be started directly in fullscreen:
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # short version
-```
-
-Fullscreen can then be toggled dynamically with `Ctrl`+`f`.
-
-#### Rotation
-
-The window may be rotated:
-
-```bash
-scrcpy --rotation 1
-```
-
-Possibles values are:
- - `0`: no rotation
- - `1`: 90 degrees counterclockwise
- - `2`: 180 degrees
- - `3`: 90 degrees clockwise
-
-The rotation can also be changed dynamically with `Ctrl`+`←` _(left)_ and
-`Ctrl`+`→` _(right)_.
-
-Note that _scrcpy_ manages 3 different rotations:
- - `Ctrl`+`r` requests the device to switch between portrait and landscape (the
-   current running app may refuse, if it does support the requested
-   orientation).
- - `--lock-video-orientation` changes the mirroring orientation (the orientation
-   of the video sent from the device to the computer). This affects the
-   recording.
- - `--rotation` (or `Ctrl`+`←`/`Ctrl`+`→`) rotates only the window content. This
-   affects only the display, not the recording.
-
-
-### Other mirroring options
-
-#### Read-only
-
-To disable controls (everything which can interact with the device: input keys,
-mouse events, drag&drop files):
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-#### Display
-
-If several displays are available, it is possible to select the display to
-mirror:
-
-```bash
-scrcpy --display 1
-```
-
-The list of display ids can be retrieved by:
-
-```
-adb shell dumpsys display   # search "mDisplayId=" in the output
-```
-
-#### Stay awake
-
-To prevent the device to sleep after some delay:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w
-```
-
-The initial state is restored when scrcpy is closed.
-
-
-#### Turn screen off
-
-It is possible to turn the device screen off while mirroring on start with a
-command-line option:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-Or by pressing `Ctrl`+`o` at any time.
-
-To turn it back on, press `POWER` (or `Ctrl`+`p`).
-
-It can be useful to also prevent the device to sleep:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw
-```
-
-
-#### Render expired frames
-
-By default, to minimize latency, _scrcpy_ always renders the last decoded frame
-available, and drops any previous one.
-
-To force the rendering of all frames (at a cost of a possible increased
-latency), use:
-
-```bash
-scrcpy --render-expired-frames
-```
-
-#### Show touches
-
-For presentations, it may be useful to show physical touches (on the physical
-device).
-
-Android provides this feature in _Developers options_.
-
-_Scrcpy_ provides an option to enable this feature on start and restore the
-initial value on exit:
-
-```bash
-scrcpy --show-touches
 scrcpy -t
 ```
 
-Note that it only shows _physical_ touches (with the finger on the device).
+To run without installing:
-
-
-### Input control
-
-#### Rotate device screen
-
-Press `Ctrl`+`r` to switch between portrait and landscape modes.
-
-Note that it rotates only if the application in foreground supports the
-requested orientation.
-
-#### Copy-paste
-
-It is possible to synchronize clipboards between the computer and the device, in
-both directions:
-
- - `Ctrl`+`c` copies the device clipboard to the computer clipboard;
- - `Ctrl`+`Shift`+`v` copies the computer clipboard to the device clipboard;
- - `Ctrl`+`v` _pastes_ the computer clipboard as a sequence of text events (but
-   breaks non-ASCII characters).
-
-#### Text injection preference
-
-There are two kinds of [events][textevents] generated when typing text:
- - _key events_, signaling that a key is pressed or released;
- - _text events_, signaling that a text has been entered.
-
-By default, letters are injected using key events, so that the keyboard behaves
-as expected in games (typically for WASD keys).
-
-But this may [cause issues][prefertext]. If you encounter such a problem, you
-can avoid it by:
 
 ```bash
-scrcpy --prefer-text
+./run x [options]
 ```
 
-(but this will break keyboard behavior in games)
+(where `x` is your build directory).
-
-[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
-[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-
-
-### File drop
-
-#### Install APK
-
-To install an APK, drag & drop an APK file (ending with `.apk`) to the _scrcpy_
-window.
-
-There is no visual feedback, a log is printed to the console.
-
-
-#### Push file to device
-
-To push a file to `/sdcard/` on the device, drag & drop a (non-APK) file to the
-_scrcpy_ window.
-
-There is no visual feedback, a log is printed to the console.
-
-The target directory can be changed on start:
-
-```bash
-scrcpy --push-target /sdcard/foo/bar/
-```
-
-
-### Audio forwarding
-
-Audio is not forwarded by _scrcpy_. Use [USBaudio] (Linux-only).
-
-Also see [issue #14].
-
-[USBaudio]: https://github.com/rom1v/usbaudio
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 
 
 ## Shortcuts
 
- | Action                                 |   Shortcut                    |   Shortcut (macOS)
+ | Action                                 |   Shortcut                    |
- | -------------------------------------- |:----------------------------- |:-----------------------------
+ | -------------------------------------- |:----------------------------  |
- | Switch fullscreen mode                 | `Ctrl`+`f`                    | `Cmd`+`f`
+ | switch fullscreen mode                 | `Ctrl`+`f`                    |
- | Rotate display left                    | `Ctrl`+`←` _(left)_           | `Cmd`+`←` _(left)_
+ | resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`                    |
- | Rotate display right                   | `Ctrl`+`→` _(right)_          | `Cmd`+`→` _(right)_
+ | resize window to remove black borders  | `Ctrl`+`x` \| _Double-click¹_ |
- | Resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`                    | `Cmd`+`g`
+ | click on `HOME`                        | `Ctrl`+`h` \| _Middle-click_  |
- | Resize window to remove black borders  | `Ctrl`+`x` \| _Double-click¹_ | `Cmd`+`x`  \| _Double-click¹_
+ | click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  |
- | Click on `HOME`                        | `Ctrl`+`h` \| _Middle-click_  | `Ctrl`+`h` \| _Middle-click_
+ | click on `APP_SWITCH`                  | `Ctrl`+`s`                    |
- | Click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  | `Cmd`+`b`  \| _Right-click²_
+ | click on `MENU`                        | `Ctrl`+`m`                    |
- | Click on `APP_SWITCH`                  | `Ctrl`+`s`                    | `Cmd`+`s`
+ | click on `VOLUME_UP`                   | `Ctrl`+`+`                    |
- | Click on `MENU`                        | `Ctrl`+`m`                    | `Ctrl`+`m`
+ | click on `VOLUME_DOWN`                 | `Ctrl`+`-`                    |
- | Click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_             | `Cmd`+`↑` _(up)_
+ | click on `POWER`                       | `Ctrl`+`p`                    |
- | Click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_           | `Cmd`+`↓` _(down)_
+ | turn screen on                         | _Right-click²_                |
- | Click on `POWER`                       | `Ctrl`+`p`                    | `Cmd`+`p`
+ | paste computer clipboard to device     | `Ctrl`+`v`                    |
- | Power on                               | _Right-click²_                | _Right-click²_
+ | enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    |
- | Turn device screen off (keep mirroring)| `Ctrl`+`o`                    | `Cmd`+`o`
- | Rotate device screen                   | `Ctrl`+`r`                    | `Cmd`+`r`
- | Expand notification panel              | `Ctrl`+`n`                    | `Cmd`+`n`
- | Collapse notification panel            | `Ctrl`+`Shift`+`n`            | `Cmd`+`Shift`+`n`
- | Copy device clipboard to computer      | `Ctrl`+`c`                    | `Cmd`+`c`
- | Paste computer clipboard to device     | `Ctrl`+`v`                    | `Cmd`+`v`
- | Copy computer clipboard to device      | `Ctrl`+`Shift`+`v`            | `Cmd`+`Shift`+`v`
- | Enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    | `Cmd`+`i`
 
 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._
 
 
-## Custom paths
-
-To use a specific _adb_ binary, configure its path in the environment variable
-`ADB`:
-
-    ADB=/path/to/adb scrcpy
-
-To override the path of the `scrcpy-server` file, configure its path in
-`SCRCPY_SERVER_PATH`.
-
-[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
-
-
 ## Why _scrcpy_?
 
 A colleague challenged me to find a name as unpronounceable as [gnirehtet].
@@ -587,13 +294,6 @@ A colleague challenged me to find a name as unpronounceable as [gnirehtet].
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 
 
-## How to build?
-
-See [BUILD].
-
-[BUILD]: BUILD.md
-
-
 ## Common issues
 
 See the [FAQ](FAQ.md).
@@ -609,7 +309,6 @@ Read the [developers page].
 ## Licence
 
     Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -625,8 +324,5 @@ Read the [developers page].
 
 ## Articles
 
-- [Introducing scrcpy][article-intro]
+- [Introducing scrcpy](https://blog.rom1v.com/2018/03/introducing-scrcpy/)
-- [Scrcpy now works wirelessly][article-tcpip]
+- [Scrcpy now works wirelessly](https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/)
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/

app/meson.build

@@ -1,192 +1,103 @@
 src = [
     'src/main.c',
-    'src/cli.c',
     'src/command.c',
-    'src/control_msg.c',
+    'src/controlevent.c',
     'src/controller.c',
+    'src/convert.c',
     'src/decoder.c',
     'src/device.c',
-    'src/device_msg.c',
+    'src/fpscounter.c',
-    'src/event_converter.c',
+    'src/frames.c',
-    'src/file_handler.c',
+    'src/inputmanager.c',
-    'src/fps_counter.c',
+    'src/lockutil.c',
-    'src/input_manager.c',
+    'src/net.c',
-    'src/opengl.c',
-    'src/receiver.c',
-    'src/recorder.c',
     'src/scrcpy.c',
     'src/screen.c',
     'src/server.c',
-    'src/stream.c',
+    'src/strutil.c',
-    'src/tiny_xpm.c',
+    'src/tinyxpm.c',
-    'src/video_buffer.c',
-    'src/util/net.c',
-    'src/util/str_util.c'
 ]
 
-if not get_option('crossbuild_windows')
+dependencies = [
-
+    dependency('libavformat'),
-    # native build
+    dependency('libavcodec'),
-    dependencies = [
+    dependency('libavutil'),
-        dependency('libavformat'),
+    dependency('sdl2'),
-        dependency('libavcodec'),
+]
-        dependency('libavutil'),
-        dependency('sdl2'),
-    ]
-
-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/' + 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: [
-            cc.find_library('SDL2', dirs: sdl2_bin_dir),
-            cc.find_library('SDL2main', dirs: sdl2_lib_dir),
-        ],
-        include_directories: include_directories(sdl2_include_dir)
-    )
-
-    prebuilt_ffmpeg_shared = meson.get_cross_property('prebuilt_ffmpeg_shared')
-    prebuilt_ffmpeg_dev = meson.get_cross_property('prebuilt_ffmpeg_dev')
-    ffmpeg_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_ffmpeg_shared + '/bin'
-    ffmpeg_include_dir = '../prebuilt-deps/' + prebuilt_ffmpeg_dev + '/include'
-    ffmpeg = declare_dependency(
-        dependencies: [
-            cc.find_library('avcodec-58', dirs: ffmpeg_bin_dir),
-            cc.find_library('avformat-58', dirs: ffmpeg_bin_dir),
-            cc.find_library('avutil-56', dirs: ffmpeg_bin_dir),
-        ],
-        include_directories: include_directories(ffmpeg_include_dir)
-    )
-
-    dependencies = [
-        ffmpeg,
-        sdl2,
-        cc.find_library('mingw32')
-    ]
-
-endif
 
 cc = meson.get_compiler('c')
 
 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
 
 conf = configuration_data()
 
 # expose the build type
-conf.set('NDEBUG', get_option('buildtype') != 'debug')
+conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')
 
 # the version, updated on release
-conf.set_quoted('SCRCPY_VERSION', meson.project_version())
+conf.set_quoted('SCRCPY_VERSION', '1.1')
 
 # 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
+# the path of the server, which will be appended to the prefix
-# directory as the executable)
+# ignored if OVERRIDE_SERVER_PATH if defined
-conf.set('PORTABLE', get_option('portable'))
+# 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', '27183')
-conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')
 
 # 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 orientation
-# natural device orientation is 0 and each increment adds 90 degrees
-# counterclockwise
-# overridden by option --lock-video-orientation
-conf.set('DEFAULT_LOCK_VIDEO_ORIENTATION', '-1')  # -1: unlocked
-
 # the default video bitrate, in bits/second
 # overridden by option --bit-rate
 conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
 
+# 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'))
+
 # enable High DPI support
 conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
 
-# disable console on Windows
-conf.set('WINDOWS_NOCONSOLE', get_option('windows_noconsole'))
-
-# run a server debugger and wait for a client to be attached
-conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
-
-# select the debugger method ('old' for Android < 9, 'new' for Android >= 9)
-conf.set('SERVER_DEBUGGER_METHOD_NEW', get_option('server_debugger_method') == 'new')
-
 configure_file(configuration: conf, output: 'config.h')
 
 src_dir = include_directories('src')
-
+executable('scrcpy', src, dependencies: dependencies, include_directories: src_dir, install: true)
-if get_option('windows_noconsole')
-    link_args = [ '-Wl,--subsystem,windows' ]
-else
-    link_args = []
-endif
-
-executable('scrcpy', src,
-           dependencies: dependencies,
-           include_directories: src_dir,
-           install: true,
-           c_args: [],
-           link_args: link_args)
-
-install_man('scrcpy.1')
 
 
 ### TESTS
 
-# do not build tests in release (assertions would not be executed at all)
+tests = [
-if get_option('buildtype') == 'debug'
+    ['test_control_event_queue', ['tests/test_control_event_queue.c', 'src/controlevent.c']],
-    tests = [
+    ['test_control_event_serialize', ['tests/test_control_event_serialize.c', 'src/controlevent.c']],
-        ['test_buffer_util', [
+    ['test_strutil', ['tests/test_strutil.c', 'src/strutil.c']],
-            'tests/test_buffer_util.c'
+]
-        ]],
-        ['test_cbuf', [
-            'tests/test_cbuf.c',
-        ]],
-        ['test_cli', [
-            'tests/test_cli.c',
-            'src/cli.c',
-            'src/util/str_util.c',
-        ]],
-        ['test_control_event_serialize', [
-            'tests/test_control_msg_serialize.c',
-            'src/control_msg.c',
-            'src/util/str_util.c',
-        ]],
-        ['test_device_event_deserialize', [
-            'tests/test_device_msg_deserialize.c',
-            'src/device_msg.c',
-        ]],
-        ['test_queue', [
-            'tests/test_queue.c',
-        ]],
-        ['test_strutil', [
-            'tests/test_strutil.c',
-            'src/util/str_util.c',
-        ]],
-    ]
 
-    foreach t : tests
+foreach t : tests
-        exe = executable(t[0], t[1],
+    exe = executable(t[0], t[1], include_directories: src_dir, dependencies: dependencies)
-                         include_directories: src_dir,
+    test(t[0], exe)
-                         dependencies: dependencies,
+endforeach
-                         c_args: ['-DSDL_MAIN_HANDLED'])
-        test(t[0], exe)
-    endforeach
-endif

app/scrcpy.1

@@ -1,316 +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 "\-\-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
-.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
-.B \-f, \-\-fullscreen
-Start in fullscreen.
-
-.TP
-.B \-h, \-\-help
-Print this help.
-
-.TP
-.BI "\-\-lock\-video\-orientation " value
-Lock video orientation to \fIvalue\fR. Possible values are -1 (unlocked), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
-
-Default is -1 (unlocked).
-
-.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 \-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\-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
-.BI "\-p, \-\-port " port[:port]
-Set the TCP port (range) used by the client to listen.
-
-Default is 27183:27199.
-
-.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
-.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/".
-
-.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
-.B \-\-render\-expired\-frames
-By default, to minimize latency, scrcpy always renders the last available decoded frame, and drops any previous ones. This flag forces to render all frames, at a cost of a possible increased latency.
-
-.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
-.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
-.B \-v, \-\-version
-Print the version of scrcpy.
-
-.TP
-.B \-w, \-\-stay-awake
-Keep the device on while scrcpy is running.
-
-.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".\n
-
-.TP
-.BI "\-\-window\-y " value
-Set the initial window vertical position.
-
-Default is "auto".\n
-
-.TP
-.BI "\-\-window\-width " value
-Set the initial window width.
-
-Default is 0 (automatic).\n
-
-.TP
-.BI "\-\-window\-height " value
-Set the initial window height.
-
-Default is 0 (automatic).\n
-
-.SH SHORTCUTS
-
-.TP
-.B Ctrl+f
-Switch fullscreen mode
-
-.TP
-.B Ctrl+Left
-Rotate display left
-
-.TP
-.B Ctrl+Right
-Rotate display right
-
-.TP
-.B Ctrl+g
-Resize window to 1:1 (pixel\-perfect)
-
-.TP
-.B Ctrl+x, Double\-click on black borders
-Resize window to remove black borders
-
-.TP
-.B Ctrl+h, Home, Middle\-click
-Click on HOME
-
-.TP
-.B Ctrl+b, Ctrl+Backspace, Right\-click (when screen is on)
-Click on BACK
-
-.TP
-.B Ctrl+s
-Click on APP_SWITCH
-
-.TP
-.B Ctrl+m
-Click on MENU
-
-.TP
-.B Ctrl+Up
-Click on VOLUME_UP
-
-.TP
-.B Ctrl+Down
-Click on VOLUME_DOWN
-
-.TP
-.B Ctrl+p
-Click on POWER (turn screen on/off)
-
-.TP
-.B Right\-click (when screen is off)
-Turn screen on
-
-.TP
-.B Ctrl+o
-Turn device screen off (keep mirroring)
-
-.TP
-.B Ctrl+r
-Rotate device screen
-
-.TP
-.B Ctrl+n
-Expand notification panel
-
-.TP
-.B Ctrl+Shift+n
-Collapse notification panel
-
-.TP
-.B Ctrl+c
-Copy device clipboard to computer
-
-.TP
-.B Ctrl+v
-Paste computer clipboard to device
-
-.TP
-.B Ctrl+Shift+v
-Copy computer clipboard to device
-
-.TP
-.B Ctrl+i
-Enable/disable FPS counter (print frames/second in logs)
-
-.TP
-.B Drag & drop APK file
-Install APK from computer
-
-
-.SH Environment variables
-
-.TP
-.B ADB
-Specify the path to adb.
-
-.TP
-.B SCRCPY_SERVER_PATH
-Specify the path to 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\-2020
-.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/android/input.h

@@ -777,6 +777,9 @@ enum android_input_source {
     AINPUT_SOURCE_JOYSTICK = 0x01000000 | AINPUT_SOURCE_CLASS_JOYSTICK,
     /** rotary encoder */
     AINPUT_SOURCE_ROTARY_ENCODER = 0x00400000 | AINPUT_SOURCE_CLASS_NONE,
+
+    /** any */
+    AINPUT_SOURCE_ANY = 0xffffff00,
 };
 
 /**

app/src/cli.c

@@ -1,692 +0,0 @@
-#include "cli.h"
-
-#include <assert.h>
-#include <getopt.h>
-#include <stdint.h>
-#include <unistd.h>
-
-#include "config.h"
-#include "recorder.h"
-#include "util/log.h"
-#include "util/str_util.h"
-
-void
-scrcpy_print_usage(const char *arg0) {
-#ifdef __APPLE__
-# define CTRL_OR_CMD "Cmd"
-#else
-# define CTRL_OR_CMD "Ctrl"
-#endif
-    fprintf(stderr,
-        "Usage: %s [options]\n"
-        "\n"
-        "Options:\n"
-        "\n"
-        "    --always-on-top\n"
-        "        Make scrcpy window always on top (above other windows).\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"
-        "    --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"
-        "    --display id\n"
-        "        Specify the display id to mirror.\n"
-        "\n"
-        "        The list of possible display ids can be listed by:\n"
-        "            adb shell dumpsys display\n"
-        "        (search \"mDisplayId=\" in the output)\n"
-        "\n"
-        "        Default is 0.\n"
-        "\n"
-        "    -f, --fullscreen\n"
-        "        Start in fullscreen.\n"
-        "\n"
-        "    -h, --help\n"
-        "        Print this help.\n"
-        "\n"
-        "    --lock-video-orientation value\n"
-        "        Lock video orientation to value.\n"
-        "        Possible values are -1 (unlocked), 0, 1, 2 and 3.\n"
-        "        Natural device orientation is 0, and each increment adds a\n"
-        "        90 degrees rotation counterclockwise.\n"
-        "        Default is %d%s.\n"
-        "\n"
-        "    --max-fps value\n"
-        "        Limit the frame rate of screen capture (officially supported\n"
-        "        since Android 10, but may work on earlier versions).\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"
-        "    -n, --no-control\n"
-        "        Disable device control (mirror the device in read-only).\n"
-        "\n"
-        "    -N, --no-display\n"
-        "        Do not display device (only when screen recording is\n"
-        "        enabled).\n"
-        "\n"
-        "    --no-mipmaps\n"
-        "        If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then\n"
-        "        mipmaps are automatically generated to improve downscaling\n"
-        "        quality. This option disables the generation of mipmaps.\n"
-        "\n"
-        "    -p, --port port[:port]\n"
-        "        Set the TCP port (range) used by the client to listen.\n"
-        "        Default is %d:%d.\n"
-        "\n"
-        "    --prefer-text\n"
-        "        Inject alpha characters and space as text events instead of\n"
-        "        key events.\n"
-        "        This avoids issues when combining multiple keys to enter a\n"
-        "        special character, but breaks the expected behavior of alpha\n"
-        "        keys in games (typically WASD).\n"
-        "\n"
-        "    --push-target path\n"
-        "        Set the target directory for pushing files to the device by\n"
-        "        drag & drop. It is passed as-is to \"adb push\".\n"
-        "        Default is \"/sdcard/\".\n"
-        "\n"
-        "    -r, --record file.mp4\n"
-        "        Record screen to file.\n"
-        "        The format is determined by the --record-format option if\n"
-        "        set, or by the file extension (.mp4 or .mkv).\n"
-        "\n"
-        "    --record-format format\n"
-        "        Force recording format (either mp4 or mkv).\n"
-        "\n"
-        "    --render-driver name\n"
-        "        Request SDL to use the given render driver (this is just a\n"
-        "        hint).\n"
-        "        Supported names are currently \"direct3d\", \"opengl\",\n"
-        "        \"opengles2\", \"opengles\", \"metal\" and \"software\".\n"
-        "        <https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER>\n"
-        "\n"
-        "    --render-expired-frames\n"
-        "        By default, to minimize latency, scrcpy always renders the\n"
-        "        last available decoded frame, and drops any previous ones.\n"
-        "        This flag forces to render all frames, at a cost of a\n"
-        "        possible increased latency.\n"
-        "\n"
-        "    --rotation value\n"
-        "        Set the initial display rotation.\n"
-        "        Possibles values are 0, 1, 2 and 3. Each increment adds a 90\n"
-        "        degrees rotation counterclockwise.\n"
-        "\n"
-        "    -s, --serial serial\n"
-        "        The device serial number. Mandatory only if several devices\n"
-        "        are connected to adb.\n"
-        "\n"
-        "    -S, --turn-screen-off\n"
-        "        Turn the device screen off immediately.\n"
-        "\n"
-        "    -t, --show-touches\n"
-        "        Enable \"show touches\" on start, restore the initial value\n"
-        "        on exit.\n"
-        "        It only shows physical touches (not clicks from scrcpy).\n"
-        "\n"
-        "    -v, --version\n"
-        "        Print the version of scrcpy.\n"
-        "\n"
-        "    -w, --stay-awake\n"
-        "        Keep the device on while scrcpy is running.\n"
-        "\n"
-        "    --window-borderless\n"
-        "        Disable window decorations (display borderless window).\n"
-        "\n"
-        "    --window-title text\n"
-        "        Set a custom window title.\n"
-        "\n"
-        "    --window-x value\n"
-        "        Set the initial window horizontal position.\n"
-        "        Default is \"auto\".\n"
-        "\n"
-        "    --window-y value\n"
-        "        Set the initial window vertical position.\n"
-        "        Default is \"auto\".\n"
-        "\n"
-        "    --window-width value\n"
-        "        Set the initial window width.\n"
-        "        Default is 0 (automatic).\n"
-        "\n"
-        "    --window-height value\n"
-        "        Set the initial window width.\n"
-        "        Default is 0 (automatic).\n"
-        "\n"
-        "Shortcuts:\n"
-        "\n"
-        "    " CTRL_OR_CMD "+f\n"
-        "        Switch fullscreen mode\n"
-        "\n"
-        "    " CTRL_OR_CMD "+Left\n"
-        "        Rotate display left\n"
-        "\n"
-        "    " CTRL_OR_CMD "+Right\n"
-        "        Rotate display right\n"
-        "\n"
-        "    " CTRL_OR_CMD "+g\n"
-        "        Resize window to 1:1 (pixel-perfect)\n"
-        "\n"
-        "    " CTRL_OR_CMD "+x\n"
-        "    Double-click on black borders\n"
-        "        Resize window to remove black borders\n"
-        "\n"
-        "    Ctrl+h\n"
-        "    Middle-click\n"
-        "        Click on HOME\n"
-        "\n"
-        "    " CTRL_OR_CMD "+b\n"
-        "    " CTRL_OR_CMD "+Backspace\n"
-        "    Right-click (when screen is on)\n"
-        "        Click on BACK\n"
-        "\n"
-        "    " CTRL_OR_CMD "+s\n"
-        "        Click on APP_SWITCH\n"
-        "\n"
-        "    Ctrl+m\n"
-        "        Click on MENU\n"
-        "\n"
-        "    " CTRL_OR_CMD "+Up\n"
-        "        Click on VOLUME_UP\n"
-        "\n"
-        "    " CTRL_OR_CMD "+Down\n"
-        "        Click on VOLUME_DOWN\n"
-        "\n"
-        "    " CTRL_OR_CMD "+p\n"
-        "        Click on POWER (turn screen on/off)\n"
-        "\n"
-        "    Right-click (when screen is off)\n"
-        "        Power on\n"
-        "\n"
-        "    " CTRL_OR_CMD "+o\n"
-        "        Turn device screen off (keep mirroring)\n"
-        "\n"
-        "    " CTRL_OR_CMD "+r\n"
-        "        Rotate device screen\n"
-        "\n"
-        "    " CTRL_OR_CMD "+n\n"
-        "        Expand notification panel\n"
-        "\n"
-        "    " CTRL_OR_CMD "+Shift+n\n"
-        "        Collapse notification panel\n"
-        "\n"
-        "    " CTRL_OR_CMD "+c\n"
-        "        Copy device clipboard to computer\n"
-        "\n"
-        "    " CTRL_OR_CMD "+v\n"
-        "        Paste computer clipboard to device\n"
-        "\n"
-        "    " CTRL_OR_CMD "+Shift+v\n"
-        "        Copy computer clipboard to device\n"
-        "\n"
-        "    " CTRL_OR_CMD "+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_LOCK_VIDEO_ORIENTATION, DEFAULT_LOCK_VIDEO_ORIENTATION >= 0 ? "" : " (unlocked)",
-        DEFAULT_MAX_SIZE, DEFAULT_MAX_SIZE ? "" : " (unlimited)",
-        DEFAULT_LOCAL_PORT_RANGE_FIRST, DEFAULT_LOCAL_PORT_RANGE_LAST);
-}
-
-static bool
-parse_integer_arg(const char *s, long *out, bool accept_suffix, long min,
-                  long max, const char *name) {
-    long value;
-    bool ok;
-    if (accept_suffix) {
-        ok = parse_integer_with_suffix(s, &value);
-    } else {
-        ok = parse_integer(s, &value);
-    }
-    if (!ok) {
-        LOGE("Could not parse %s: %s", name, s);
-        return false;
-    }
-
-    if (value < min || value > max) {
-        LOGE("Could not parse %s: value (%ld) out-of-range (%ld; %ld)",
-             name, value, min, max);
-        return false;
-    }
-
-    *out = value;
-    return true;
-}
-
-static size_t
-parse_integers_arg(const char *s, size_t max_items, long *out, long min,
-                   long max, const char *name) {
-    size_t count = parse_integers(s, ':', max_items, out);
-    if (!count) {
-        LOGE("Could not parse %s: %s", name, s);
-        return 0;
-    }
-
-    for (size_t i = 0; i < count; ++i) {
-        long value = out[i];
-        if (value < min || value > max) {
-            LOGE("Could not parse %s: value (%ld) out-of-range (%ld; %ld)",
-                 name, value, min, max);
-            return 0;
-        }
-    }
-
-    return count;
-}
-
-static bool
-parse_bit_rate(const char *s, uint32_t *bit_rate) {
-    long value;
-    // long may be 32 bits (it is the case on mingw), so do not use more than
-    // 31 bits (long is signed)
-    bool ok = parse_integer_arg(s, &value, true, 0, 0x7FFFFFFF, "bit-rate");
-    if (!ok) {
-        return false;
-    }
-
-    *bit_rate = (uint32_t) value;
-    return true;
-}
-
-static bool
-parse_max_size(const char *s, uint16_t *max_size) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF, "max size");
-    if (!ok) {
-        return false;
-    }
-
-    *max_size = (uint16_t) value;
-    return true;
-}
-
-static bool
-parse_max_fps(const char *s, uint16_t *max_fps) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 1000, "max fps");
-    if (!ok) {
-        return false;
-    }
-
-    *max_fps = (uint16_t) value;
-    return true;
-}
-
-static bool
-parse_lock_video_orientation(const char *s, int8_t *lock_video_orientation) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, -1, 3,
-                                "lock video orientation");
-    if (!ok) {
-        return false;
-    }
-
-    *lock_video_orientation = (int8_t) value;
-    return true;
-}
-
-static bool
-parse_rotation(const char *s, uint8_t *rotation) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 3, "rotation");
-    if (!ok) {
-        return false;
-    }
-
-    *rotation = (uint8_t) value;
-    return true;
-}
-
-static bool
-parse_window_position(const char *s, int16_t *position) {
-    // special value for "auto"
-    static_assert(WINDOW_POSITION_UNDEFINED == -0x8000, "unexpected value");
-
-    if (!strcmp(s, "auto")) {
-        *position = WINDOW_POSITION_UNDEFINED;
-        return true;
-    }
-
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, -0x7FFF, 0x7FFF,
-                                "window position");
-    if (!ok) {
-        return false;
-    }
-
-    *position = (int16_t) value;
-    return true;
-}
-
-static bool
-parse_window_dimension(const char *s, uint16_t *dimension) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF,
-                                "window dimension");
-    if (!ok) {
-        return false;
-    }
-
-    *dimension = (uint16_t) value;
-    return true;
-}
-
-static bool
-parse_port_range(const char *s, struct port_range *port_range) {
-    long values[2];
-    size_t count = parse_integers_arg(s, 2, values, 0, 0xFFFF, "port");
-    if (!count) {
-        return false;
-    }
-
-    uint16_t v0 = (uint16_t) values[0];
-    if (count == 1) {
-        port_range->first = v0;
-        port_range->last = v0;
-        return true;
-    }
-
-    assert(count == 2);
-    uint16_t v1 = (uint16_t) values[1];
-    if (v0 < v1) {
-        port_range->first = v0;
-        port_range->last = v1;
-    } else {
-        port_range->first = v1;
-        port_range->last = v0;
-    }
-
-    return true;
-}
-
-static bool
-parse_display_id(const char *s, uint16_t *display_id) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF, "display id");
-    if (!ok) {
-        return false;
-    }
-
-    *display_id = (uint16_t) value;
-    return true;
-}
-
-static bool
-parse_record_format(const char *optarg, enum recorder_format *format) {
-    if (!strcmp(optarg, "mp4")) {
-        *format = RECORDER_FORMAT_MP4;
-        return true;
-    }
-    if (!strcmp(optarg, "mkv")) {
-        *format = RECORDER_FORMAT_MKV;
-        return true;
-    }
-    LOGE("Unsupported format: %s (expected mp4 or mkv)", optarg);
-    return false;
-}
-
-static enum recorder_format
-guess_record_format(const char *filename) {
-    size_t len = strlen(filename);
-    if (len < 4) {
-        return 0;
-    }
-    const char *ext = &filename[len - 4];
-    if (!strcmp(ext, ".mp4")) {
-        return RECORDER_FORMAT_MP4;
-    }
-    if (!strcmp(ext, ".mkv")) {
-        return RECORDER_FORMAT_MKV;
-    }
-    return 0;
-}
-
-#define OPT_RENDER_EXPIRED_FRAMES  1000
-#define OPT_WINDOW_TITLE           1001
-#define OPT_PUSH_TARGET            1002
-#define OPT_ALWAYS_ON_TOP          1003
-#define OPT_CROP                   1004
-#define OPT_RECORD_FORMAT          1005
-#define OPT_PREFER_TEXT            1006
-#define OPT_WINDOW_X               1007
-#define OPT_WINDOW_Y               1008
-#define OPT_WINDOW_WIDTH           1009
-#define OPT_WINDOW_HEIGHT          1010
-#define OPT_WINDOW_BORDERLESS      1011
-#define OPT_MAX_FPS                1012
-#define OPT_LOCK_VIDEO_ORIENTATION 1013
-#define OPT_DISPLAY_ID             1014
-#define OPT_ROTATION               1015
-#define OPT_RENDER_DRIVER          1016
-#define OPT_NO_MIPMAPS             1017
-
-bool
-scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
-    static const struct option long_options[] = {
-        {"always-on-top",          no_argument,       NULL, OPT_ALWAYS_ON_TOP},
-        {"bit-rate",               required_argument, NULL, 'b'},
-        {"crop",                   required_argument, NULL, OPT_CROP},
-        {"display",                required_argument, NULL, OPT_DISPLAY_ID},
-        {"fullscreen",             no_argument,       NULL, 'f'},
-        {"help",                   no_argument,       NULL, 'h'},
-        {"lock-video-orientation", required_argument, NULL,
-                                                  OPT_LOCK_VIDEO_ORIENTATION},
-        {"max-fps",                required_argument, NULL, OPT_MAX_FPS},
-        {"max-size",               required_argument, NULL, 'm'},
-        {"no-control",             no_argument,       NULL, 'n'},
-        {"no-display",             no_argument,       NULL, 'N'},
-        {"no-mipmaps",             no_argument,       NULL, OPT_NO_MIPMAPS},
-        {"port",                   required_argument, NULL, 'p'},
-        {"prefer-text",            no_argument,       NULL, OPT_PREFER_TEXT},
-        {"push-target",            required_argument, NULL, OPT_PUSH_TARGET},
-        {"record",                 required_argument, NULL, 'r'},
-        {"record-format",          required_argument, NULL, OPT_RECORD_FORMAT},
-        {"render-driver",          required_argument, NULL, OPT_RENDER_DRIVER},
-        {"render-expired-frames",  no_argument,       NULL,
-                                                  OPT_RENDER_EXPIRED_FRAMES},
-        {"rotation",               required_argument, NULL, OPT_ROTATION},
-        {"serial",                 required_argument, NULL, 's'},
-        {"show-touches",           no_argument,       NULL, 't'},
-        {"stay-awake",             no_argument,       NULL, 'w'},
-        {"turn-screen-off",        no_argument,       NULL, 'S'},
-        {"version",                no_argument,       NULL, 'v'},
-        {"window-title",           required_argument, NULL, OPT_WINDOW_TITLE},
-        {"window-x",               required_argument, NULL, OPT_WINDOW_X},
-        {"window-y",               required_argument, NULL, OPT_WINDOW_Y},
-        {"window-width",           required_argument, NULL, OPT_WINDOW_WIDTH},
-        {"window-height",          required_argument, NULL, OPT_WINDOW_HEIGHT},
-        {"window-borderless",      no_argument,       NULL,
-                                                  OPT_WINDOW_BORDERLESS},
-        {NULL,                     0,                 NULL, 0  },
-    };
-
-    struct scrcpy_options *opts = &args->opts;
-
-    optind = 0; // reset to start from the first argument in tests
-
-    int c;
-    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTvw", long_options,
-                            NULL)) != -1) {
-        switch (c) {
-            case 'b':
-                if (!parse_bit_rate(optarg, &opts->bit_rate)) {
-                    return false;
-                }
-                break;
-            case 'c':
-                LOGW("Deprecated option -c. Use --crop instead.");
-                // fall through
-            case OPT_CROP:
-                opts->crop = optarg;
-                break;
-            case OPT_DISPLAY_ID:
-                if (!parse_display_id(optarg, &opts->display_id)) {
-                    return false;
-                }
-                break;
-            case 'f':
-                opts->fullscreen = true;
-                break;
-            case 'F':
-                LOGW("Deprecated option -F. Use --record-format instead.");
-                // fall through
-            case OPT_RECORD_FORMAT:
-                if (!parse_record_format(optarg, &opts->record_format)) {
-                    return false;
-                }
-                break;
-            case 'h':
-                args->help = true;
-                break;
-            case OPT_MAX_FPS:
-                if (!parse_max_fps(optarg, &opts->max_fps)) {
-                    return false;
-                }
-                break;
-            case 'm':
-                if (!parse_max_size(optarg, &opts->max_size)) {
-                    return false;
-                }
-                break;
-            case OPT_LOCK_VIDEO_ORIENTATION:
-                if (!parse_lock_video_orientation(optarg, &opts->lock_video_orientation)) {
-                    return false;
-                }
-                break;
-            case 'n':
-                opts->control = false;
-                break;
-            case 'N':
-                opts->display = false;
-                break;
-            case 'p':
-                if (!parse_port_range(optarg, &opts->port_range)) {
-                    return false;
-                }
-                break;
-            case 'r':
-                opts->record_filename = optarg;
-                break;
-            case 's':
-                opts->serial = optarg;
-                break;
-            case 'S':
-                opts->turn_screen_off = true;
-                break;
-            case 't':
-                opts->show_touches = true;
-                break;
-            case 'T':
-                LOGW("Deprecated option -T. Use --always-on-top instead.");
-                // fall through
-            case OPT_ALWAYS_ON_TOP:
-                opts->always_on_top = true;
-                break;
-            case 'v':
-                args->version = true;
-                break;
-            case 'w':
-                opts->stay_awake = true;
-                break;
-            case OPT_RENDER_EXPIRED_FRAMES:
-                opts->render_expired_frames = true;
-                break;
-            case OPT_WINDOW_TITLE:
-                opts->window_title = optarg;
-                break;
-            case OPT_WINDOW_X:
-                if (!parse_window_position(optarg, &opts->window_x)) {
-                    return false;
-                }
-                break;
-            case OPT_WINDOW_Y:
-                if (!parse_window_position(optarg, &opts->window_y)) {
-                    return false;
-                }
-                break;
-            case OPT_WINDOW_WIDTH:
-                if (!parse_window_dimension(optarg, &opts->window_width)) {
-                    return false;
-                }
-                break;
-            case OPT_WINDOW_HEIGHT:
-                if (!parse_window_dimension(optarg, &opts->window_height)) {
-                    return false;
-                }
-                break;
-            case OPT_WINDOW_BORDERLESS:
-                opts->window_borderless = true;
-                break;
-            case OPT_PUSH_TARGET:
-                opts->push_target = optarg;
-                break;
-            case OPT_PREFER_TEXT:
-                opts->prefer_text = true;
-                break;
-            case OPT_ROTATION:
-                if (!parse_rotation(optarg, &opts->rotation)) {
-                    return false;
-                }
-                break;
-            case OPT_RENDER_DRIVER:
-                opts->render_driver = optarg;
-                break;
-            case OPT_NO_MIPMAPS:
-                opts->mipmaps = false;
-                break;
-            default:
-                // getopt prints the error message on stderr
-                return false;
-        }
-    }
-
-    if (!opts->display && !opts->record_filename) {
-        LOGE("-N/--no-display requires screen recording (-r/--record)");
-        return false;
-    }
-
-    int index = optind;
-    if (index < argc) {
-        LOGE("Unexpected additional argument: %s", argv[index]);
-        return false;
-    }
-
-    if (opts->record_format && !opts->record_filename) {
-        LOGE("Record format specified without recording");
-        return false;
-    }
-
-    if (opts->record_filename && !opts->record_format) {
-        opts->record_format = guess_record_format(opts->record_filename);
-        if (!opts->record_format) {
-            LOGE("No format specified for \"%s\" (try with -F mkv)",
-                 opts->record_filename);
-            return false;
-        }
-    }
-
-    if (!opts->control && opts->turn_screen_off) {
-        LOGE("Could not request to turn screen off if control is disabled");
-        return false;
-    }
-
-    if (!opts->control && opts->stay_awake) {
-        LOGE("Could not request to stay awake if control is disabled");
-        return false;
-    }
-
-    return true;
-}

app/src/cli.h

@@ -1,21 +0,0 @@
-#ifndef SCRCPY_CLI_H
-#define SCRCPY_CLI_H
-
-#include <stdbool.h>
-
-#include "config.h"
-#include "scrcpy.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[]);
-
-#endif

app/src/command.c

@@ -1,19 +1,15 @@
 #include "command.h"
 
-#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "config.h"
 #include "common.h"
-#include "util/log.h"
+#include "log.h"
-#include "util/str_util.h"
 
 static const char *adb_command;
 
-static inline const char *
+static inline const char *get_adb_command() {
-get_adb_command(void) {
     if (!adb_command) {
         adb_command = getenv("ADB");
         if (!adb_command)
@@ -22,91 +18,9 @@ get_adb_command(void) {
     return adb_command;
 }
 
-// serialize argv to string "[arg1], [arg2], [arg3]"
+process_t adb_execute(const char *serial, const char *const adb_cmd[], int len) {
-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 (cmd_search(pkg_managers[i].binary)) {
-            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
-            return;
-        }
-    }
-#endif
-
-    LOGI("You may download and install 'adb' from "
-         "https://developer.android.com/studio/releases/platform-tools");
-}
-
-static void
-show_adb_err_msg(enum process_result err, const char *const argv[]) {
-    char buf[512];
-    switch (err) {
-        case PROCESS_ERROR_GENERIC:
-            argv_to_string(argv, buf, sizeof(buf));
-            LOGE("Failed to execute: %s", buf);
-            break;
-        case PROCESS_ERROR_MISSING_BINARY:
-            argv_to_string(argv, buf, sizeof(buf));
-            LOGE("Command not found: %s", buf);
-            LOGE("(make 'adb' accessible from your PATH or define its full"
-                 "path in the ADB environment variable)");
-            show_adb_installation_msg();
-            break;
-        case PROCESS_SUCCESS:
-            // do nothing
-            break;
-    }
-}
-
-process_t
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
     const char *cmd[len + 4];
     int i;
-    process_t process;
     cmd[0] = get_adb_command();
     if (serial) {
         cmd[1] = "-s";
@@ -118,17 +32,10 @@ adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
 
     memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
     cmd[len + i] = NULL;
-    enum process_result r = cmd_execute(cmd, &process);
+    return cmd_execute(cmd[0], cmd);
-    if (r != PROCESS_SUCCESS) {
-        show_adb_err_msg(r, cmd);
-        return PROCESS_NONE;
-    }
-    return process;
 }
 
-process_t
+process_t adb_forward(const char *serial, uint16_t local_port, const char *device_socket_name) {
-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);
@@ -137,17 +44,14 @@ adb_forward(const char *serial, uint16_t local_port,
     return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
-process_t
+process_t adb_forward_remove(const char *serial, uint16_t local_port) {
-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
+process_t adb_reverse(const char *serial, const char *device_socket_name, uint16_t local_port) {
-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);
@@ -156,67 +60,27 @@ adb_reverse(const char *serial, const char *device_socket_name,
     return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }
 
-process_t
+process_t adb_reverse_remove(const char *serial, const char *device_socket_name) {
-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
+process_t adb_push(const char *serial, const char *local, const char *remote) {
-adb_push(const char *serial, const char *local, const char *remote) {
-#ifdef __WINDOWS__
-    // Windows will parse the string, so the paths must be quoted
-    // (see sys/win/command.c)
-    local = strquote(local);
-    if (!local) {
-        return PROCESS_NONE;
-    }
-    remote = strquote(remote);
-    if (!remote) {
-        SDL_free((void *) local);
-        return PROCESS_NONE;
-    }
-#endif
-
     const char *const adb_cmd[] = {"push", local, remote};
-    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
-
-#ifdef __WINDOWS__
-    SDL_free((void *) remote);
-    SDL_free((void *) local);
-#endif
-
-    return proc;
 }
 
-process_t
+process_t adb_remove_path(const char *serial, const char *path) {
-adb_install(const char *serial, const char *local) {
+    const char *const adb_cmd[] = {"shell", "rm", path};
-#ifdef __WINDOWS__
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
-    // Windows will parse the string, so the local name must be quoted
-    // (see sys/win/command.c)
-    local = strquote(local);
-    if (!local) {
-        return PROCESS_NONE;
-    }
-#endif
-
-    const char *const adb_cmd[] = {"install", "-r", local};
-    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
-
-#ifdef __WINDOWS__
-    SDL_free((void *) local);
-#endif
-
-    return proc;
 }
 
-bool
+SDL_bool process_check_success(process_t proc, const char *name) {
-process_check_success(process_t proc, const char *name) {
     if (proc == PROCESS_NONE) {
         LOGE("Could not execute \"%s\"", name);
-        return false;
+        return SDL_FALSE;
     }
     exit_code_t exit_code;
     if (!cmd_simple_wait(proc, &exit_code)) {
@@ -225,7 +89,7 @@ process_check_success(process_t proc, const char *name) {
         } else {
             LOGE("\"%s\" exited unexpectedly", name);
         }
-        return false;
+        return SDL_FALSE;
     }
-    return true;
+    return SDL_TRUE;
 }

app/src/command.h

@@ -1,97 +1,51 @@
 #ifndef COMMAND_H
 #define COMMAND_H
 
-#include <stdbool.h>
 #include <inttypes.h>
+#include <SDL2/SDL_stdinc.h>
+#include <SDL2/SDL_platform.h>
 
-#ifdef _WIN32
-
- // not needed here, but winsock2.h must never be included AFTER windows.h
-# include <winsock2.h>
-# include <windows.h>
-# define PATH_SEPARATOR '\\'
-# define PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
+#ifdef _WIN32
+# define PRIexitcode "lu"
 # ifdef _WIN64
 #   define PRIsizet PRIu64
 # else
 #   define PRIsizet PRIu32
 # endif
-# define PROCESS_NONE NULL
-# define NO_EXIT_CODE -1u // max value as unsigned
-  typedef HANDLE process_t;
-  typedef DWORD exit_code_t;
-
 #else
-
-# include <sys/types.h>
-# define PATH_SEPARATOR '/'
 # 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
-# define NO_EXIT_CODE -1
   typedef pid_t process_t;
   typedef int exit_code_t;
-
 #endif
+# define NO_EXIT_CODE -1
 
-#include "config.h"
+process_t cmd_execute(const char *path, const char *const argv[]);
+SDL_bool cmd_terminate(process_t pid);
+SDL_bool cmd_simple_wait(process_t pid, exit_code_t *exit_code);
 
-enum process_result {
+process_t adb_execute(const char *serial, const char *const adb_cmd[], int len);
-    PROCESS_SUCCESS,
+process_t adb_forward(const char *serial, uint16_t local_port, const char *device_socket_name);
-    PROCESS_ERROR_GENERIC,
+process_t adb_forward_remove(const char *serial, uint16_t local_port);
-    PROCESS_ERROR_MISSING_BINARY,
+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);
-#ifndef __WINDOWS__
+process_t adb_remove_path(const char *serial, const char *path);
-bool
-cmd_search(const char *file);
-#endif
-
-enum process_result
-cmd_execute(const char *const argv[], process_t *process);
-
-bool
-cmd_terminate(process_t pid);
-
-bool
-cmd_simple_wait(process_t pid, exit_code_t *exit_code);
-
-process_t
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
-
-process_t
-adb_forward(const char *serial, uint16_t local_port,
-            const char *device_socket_name);
-
-process_t
-adb_forward_remove(const char *serial, uint16_t local_port);
-
-process_t
-adb_reverse(const char *serial, const char *device_socket_name,
-            uint16_t local_port);
-
-process_t
-adb_reverse_remove(const char *serial, const char *device_socket_name);
-
-process_t
-adb_push(const char *serial, const char *local, const char *remote);
-
-process_t
-adb_install(const char *serial, const char *local);
 
 // convenience function to wait for a successful process execution
 // automatically log process errors with the provided process name
-bool
+SDL_bool process_check_success(process_t process, const char *name);
-process_check_success(process_t proc, const char *name);
-
-// return the absolute path of the executable (the scrcpy binary)
-// may be NULL on error; to be freed by SDL_free
-char *
-get_executable_path(void);
-
-// returns true if the file exists and is not a directory
-bool
-is_regular_file(const char *path);
 
 #endif

app/src/common.h

@@ -1,35 +1,27 @@
 #ifndef COMMON_H
 #define COMMON_H
 
-#include <stdint.h>
+#include <SDL2/SDL_stdinc.h>
-
-#include "config.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)
 
 struct size {
-    uint16_t width;
+    Uint16 width;
-    uint16_t height;
+    Uint16 height;
 };
 
 struct point {
-    int32_t x;
+    Uint16 x;
-    int32_t y;
+    Uint16 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
+    // so store to which size the absolute position apply, to scale it accordingly.
-    // accordingly.
     struct size screen_size;
     struct point point;
 };
 
-struct port_range {
-    uint16_t first;
-    uint16_t last;
-};
-
 #endif

app/src/compat.h

@@ -1,51 +0,0 @@
-#ifndef COMPAT_H
-#define COMPAT_H
-
-#include <libavformat/version.h>
-#include <SDL2/SDL_version.h>
-
-// 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 SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_API
-#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:
-// 2016-04-21 - 7fc329e - lavc 57.37.100 - avcodec.h
-//   Add a new audio/video encoding and decoding API with decoupled input
-//   and output -- avcodec_send_packet(), avcodec_receive_frame(),
-//   avcodec_send_frame() and avcodec_receive_packet().
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 37, 100)
-# define SCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
-#endif
-
-#if SDL_VERSION_ATLEAST(2, 0, 5)
-// <https://wiki.libsdl.org/SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH>
-# define SCRCPY_SDL_HAS_HINT_MOUSE_FOCUS_CLICKTHROUGH
-// <https://wiki.libsdl.org/SDL_GetDisplayUsableBounds>
-# define SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
-// <https://wiki.libsdl.org/SDL_WindowFlags>
-# define SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
-#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
-
-#endif

app/src/control_msg.c

@@ -1,104 +0,0 @@
-#include "control_msg.h"
-
-#include <assert.h>
-#include <string.h>
-
-#include "config.h"
-#include "util/buffer_util.h"
-#include "util/log.h"
-#include "util/str_util.h"
-
-static void
-write_position(uint8_t *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);
-}
-
-// write length (2 bytes) + string (non nul-terminated)
-static size_t
-write_string(const char *utf8, size_t max_len, unsigned char *buf) {
-    size_t len = utf8_truncation_index(utf8, max_len);
-    buffer_write16be(buf, (uint16_t) len);
-    memcpy(&buf[2], utf8, len);
-    return 2 + len;
-}
-
-static uint16_t
-to_fixed_point_16(float f) {
-    assert(f >= 0.0f && f <= 1.0f);
-    uint32_t u = f * 0x1p16f; // 2^16
-    if (u >= 0xffff) {
-        u = 0xffff;
-    }
-    return (uint16_t) u;
-}
-
-size_t
-control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
-    buf[0] = msg->type;
-    switch (msg->type) {
-        case CONTROL_MSG_TYPE_INJECT_KEYCODE:
-            buf[1] = msg->inject_keycode.action;
-            buffer_write32be(&buf[2], msg->inject_keycode.keycode);
-            buffer_write32be(&buf[6], msg->inject_keycode.metastate);
-            return 10;
-        case CONTROL_MSG_TYPE_INJECT_TEXT: {
-            size_t len =
-                write_string(msg->inject_text.text,
-                             CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
-            return 1 + len;
-        }
-        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
-            buf[1] = msg->inject_touch_event.action;
-            buffer_write64be(&buf[2], msg->inject_touch_event.pointer_id);
-            write_position(&buf[10], &msg->inject_touch_event.position);
-            uint16_t pressure =
-                to_fixed_point_16(msg->inject_touch_event.pressure);
-            buffer_write16be(&buf[22], pressure);
-            buffer_write32be(&buf[24], msg->inject_touch_event.buttons);
-            return 28;
-        case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
-            write_position(&buf[1], &msg->inject_scroll_event.position);
-            buffer_write32be(&buf[13],
-                             (uint32_t) msg->inject_scroll_event.hscroll);
-            buffer_write32be(&buf[17],
-                             (uint32_t) msg->inject_scroll_event.vscroll);
-            return 21;
-        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
-            size_t len = write_string(msg->inject_text.text,
-                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-                                      &buf[1]);
-            return 1 + len;
-        }
-        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
-            buf[1] = msg->set_screen_power_mode.mode;
-            return 2;
-        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
-        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
-        case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
-        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
-        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
-            // no additional data
-            return 1;
-        default:
-            LOGW("Unknown message type: %u", (unsigned) msg->type);
-            return 0;
-    }
-}
-
-void
-control_msg_destroy(struct control_msg *msg) {
-    switch (msg->type) {
-        case CONTROL_MSG_TYPE_INJECT_TEXT:
-            SDL_free(msg->inject_text.text);
-            break;
-        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
-            SDL_free(msg->set_clipboard.text);
-            break;
-        default:
-            // do nothing
-            break;
-    }
-}

app/src/control_msg.h

@@ -1,80 +0,0 @@
-#ifndef CONTROLMSG_H
-#define CONTROLMSG_H
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "config.h"
-#include "android/input.h"
-#include "android/keycodes.h"
-#include "common.h"
-
-#define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
-#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH 4093
-#define CONTROL_MSG_SERIALIZED_MAX_SIZE \
-    (3 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)
-
-#define POINTER_ID_MOUSE UINT64_C(-1);
-
-enum control_msg_type {
-    CONTROL_MSG_TYPE_INJECT_KEYCODE,
-    CONTROL_MSG_TYPE_INJECT_TEXT,
-    CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-    CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
-    CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
-    CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
-    CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
-    CONTROL_MSG_TYPE_GET_CLIPBOARD,
-    CONTROL_MSG_TYPE_SET_CLIPBOARD,
-    CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
-    CONTROL_MSG_TYPE_ROTATE_DEVICE,
-};
-
-enum screen_power_mode {
-    // see <https://android.googlesource.com/platform/frameworks/base.git/+/pie-release-2/core/java/android/view/SurfaceControl.java#305>
-    SCREEN_POWER_MODE_OFF = 0,
-    SCREEN_POWER_MODE_NORMAL = 2,
-};
-
-struct control_msg {
-    enum control_msg_type type;
-    union {
-        struct {
-            enum android_keyevent_action action;
-            enum android_keycode keycode;
-            enum android_metastate metastate;
-        } inject_keycode;
-        struct {
-            char *text; // owned, to be freed by SDL_free()
-        } inject_text;
-        struct {
-            enum android_motionevent_action action;
-            enum android_motionevent_buttons buttons;
-            uint64_t pointer_id;
-            struct position position;
-            float pressure;
-        } inject_touch_event;
-        struct {
-            struct position position;
-            int32_t hscroll;
-            int32_t vscroll;
-        } inject_scroll_event;
-        struct {
-            char *text; // owned, to be freed by SDL_free()
-        } set_clipboard;
-        struct {
-            enum screen_power_mode mode;
-        } set_screen_power_mode;
-    };
-};
-
-// buf size must be at least CONTROL_MSG_SERIALIZED_MAX_SIZE
-// return the number of bytes written
-size_t
-control_msg_serialize(const struct control_msg *msg, unsigned char *buf);
-
-void
-control_msg_destroy(struct control_msg *msg);
-
-#endif

app/src/controlevent.c

@@ -0,0 +1,110 @@
+#include "controlevent.h"
+
+#include <SDL2/SDL_stdinc.h>
+
+#include "lockutil.h"
+#include "log.h"
+
+static inline void write16(Uint8 *buf, Uint16 value) {
+    buf[0] = value >> 8;
+    buf[1] = value;
+}
+
+static inline void write32(Uint8 *buf, Uint32 value) {
+    buf[0] = value >> 24;
+    buf[1] = value >> 16;
+    buf[2] = value >> 8;
+    buf[3] = value;
+}
+
+static void write_position(Uint8 *buf, const struct position *position) {
+    write16(&buf[0], position->point.x);
+    write16(&buf[2], position->point.y);
+    write16(&buf[4], position->screen_size.width);
+    write16(&buf[6], 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;
+            write32(&buf[2], event->keycode_event.keycode);
+            write32(&buf[6], event->keycode_event.metastate);
+            return 10;
+        case CONTROL_EVENT_TYPE_TEXT: {
+            // write length (1 byte) + date (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;
+            }
+            write16(&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;
+            write32(&buf[2], event->mouse_event.buttons);
+            write_position(&buf[6], &event->mouse_event.position);
+            return 14;
+        case CONTROL_EVENT_TYPE_SCROLL:
+            write_position(&buf[1], &event->scroll_event.position);
+            write32(&buf[9], (Uint32) event->scroll_event.hscroll);
+            write32(&buf[13], (Uint32) event->scroll_event.vscroll);
+            return 17;
+        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/controlevent.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/controller.c

@@ -1,134 +1,102 @@
 #include "controller.h"
 
-#include <assert.h>
+#include "lockutil.h"
+#include "log.h"
 
-#include "config.h"
+SDL_bool controller_init(struct controller *controller, socket_t video_socket) {
-#include "util/lock.h"
+    if (!control_event_queue_init(&controller->queue)) {
-#include "util/log.h"
+        return SDL_FALSE;
-
-bool
-controller_init(struct controller *controller, socket_t control_socket) {
-    cbuf_init(&controller->queue);
-
-    if (!receiver_init(&controller->receiver, control_socket)) {
-        return false;
     }
 
     if (!(controller->mutex = SDL_CreateMutex())) {
-        receiver_destroy(&controller->receiver);
+        return SDL_FALSE;
-        return false;
     }
 
-    if (!(controller->msg_cond = SDL_CreateCond())) {
+    if (!(controller->event_cond = SDL_CreateCond())) {
-        receiver_destroy(&controller->receiver);
         SDL_DestroyMutex(controller->mutex);
-        return false;
+        return SDL_FALSE;
     }
 
-    controller->control_socket = control_socket;
+    controller->video_socket = video_socket;
-    controller->stopped = false;
+    controller->stopped = SDL_FALSE;
 
-    return true;
+    return SDL_TRUE;
 }
 
-void
+void controller_destroy(struct controller *controller) {
-controller_destroy(struct controller *controller) {
+    SDL_DestroyCond(controller->event_cond);
-    SDL_DestroyCond(controller->msg_cond);
     SDL_DestroyMutex(controller->mutex);
-
+    control_event_queue_destroy(&controller->queue);
-    struct control_msg msg;
-    while (cbuf_take(&controller->queue, &msg)) {
-        control_msg_destroy(&msg);
-    }
-
-    receiver_destroy(&controller->receiver);
 }
 
-bool
+SDL_bool controller_push_event(struct controller *controller, const struct control_event *event) {
-controller_push_msg(struct controller *controller,
+    SDL_bool res;
-                      const struct control_msg *msg) {
     mutex_lock(controller->mutex);
-    bool was_empty = cbuf_is_empty(&controller->queue);
+    SDL_bool was_empty = control_event_queue_is_empty(&controller->queue);
-    bool res = cbuf_push(&controller->queue, *msg);
+    res = control_event_queue_push(&controller->queue, event);
     if (was_empty) {
-        cond_signal(controller->msg_cond);
+        cond_signal(controller->event_cond);
     }
     mutex_unlock(controller->mutex);
     return res;
 }
 
-static bool
+static SDL_bool process_event(struct controller *controller, const struct control_event *event) {
-process_msg(struct controller *controller,
+    unsigned char serialized_event[SERIALIZED_EVENT_MAX_SIZE];
-              const struct control_msg *msg) {
+    int length = control_event_serialize(event, serialized_event);
-    unsigned char serialized_msg[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int length = control_msg_serialize(msg, serialized_msg);
     if (!length) {
-        return false;
+        return SDL_FALSE;
     }
-    int w = net_send_all(controller->control_socket, serialized_msg, length);
+    int w = net_send_all(controller->video_socket, serialized_event, length);
     return w == length;
 }
 
-static int
+static int run_controller(void *data) {
-run_controller(void *data) {
     struct controller *controller = data;
 
+    mutex_lock(controller->mutex);
     for (;;) {
-        mutex_lock(controller->mutex);
+        while (!controller->stopped && control_event_queue_is_empty(&controller->queue)) {
-        while (!controller->stopped && cbuf_is_empty(&controller->queue)) {
+            cond_wait(controller->event_cond, controller->mutex);
-            cond_wait(controller->msg_cond, controller->mutex);
         }
         if (controller->stopped) {
-            // stop immediately, do not process further msgs
+            // stop immediately, do not process further events
-            mutex_unlock(controller->mutex);
             break;
         }
-        struct control_msg msg;
+        struct control_event event;
-        bool non_empty = cbuf_take(&controller->queue, &msg);
+        while (control_event_queue_take(&controller->queue, &event)) {
-        assert(non_empty);
+            SDL_bool ok = process_event(controller, &event);
-        (void) non_empty;
+            control_event_destroy(&event);
-        mutex_unlock(controller->mutex);
+            if (!ok) {
-
+                LOGD("Cannot write event to socket");
-        bool ok = process_msg(controller, &msg);
+                goto end;
-        control_msg_destroy(&msg);
+            }
-        if (!ok) {
-            LOGD("Could not write msg to socket");
-            break;
         }
     }
+end:
+    mutex_unlock(controller->mutex);
     return 0;
 }
 
-bool
+SDL_bool controller_start(struct controller *controller) {
-controller_start(struct controller *controller) {
     LOGD("Starting controller thread");
 
-    controller->thread = SDL_CreateThread(run_controller, "controller",
+    controller->thread = SDL_CreateThread(run_controller, "controller", controller);
-                                          controller);
     if (!controller->thread) {
         LOGC("Could not start controller thread");
-        return false;
+        return SDL_FALSE;
     }
 
-    if (!receiver_start(&controller->receiver)) {
+    return SDL_TRUE;
-        controller_stop(controller);
-        SDL_WaitThread(controller->thread, NULL);
-        return false;
-    }
-
-    return true;
 }
 
-void
+void controller_stop(struct controller *controller) {
-controller_stop(struct controller *controller) {
     mutex_lock(controller->mutex);
-    controller->stopped = true;
+    controller->stopped = SDL_TRUE;
-    cond_signal(controller->msg_cond);
+    cond_signal(controller->event_cond);
     mutex_unlock(controller->mutex);
 }
 
-void
+void controller_join(struct controller *controller) {
-controller_join(struct controller *controller) {
     SDL_WaitThread(controller->thread, NULL);
-    receiver_join(&controller->receiver);
 }

app/src/controller.h

@@ -1,45 +1,31 @@
-#ifndef CONTROLLER_H
+#ifndef CONTROL_H
-#define CONTROLLER_H
+#define CONTROL_H
+
+#include "controlevent.h"
 
-#include <stdbool.h>
 #include <SDL2/SDL_mutex.h>
+#include <SDL2/SDL_stdinc.h>
 #include <SDL2/SDL_thread.h>
 
-#include "config.h"
+#include "net.h"
-#include "control_msg.h"
-#include "receiver.h"
-#include "util/cbuf.h"
-#include "util/net.h"
-
-struct control_msg_queue CBUF(struct control_msg, 64);
 
 struct controller {
-    socket_t control_socket;
+    socket_t video_socket;
     SDL_Thread *thread;
     SDL_mutex *mutex;
-    SDL_cond *msg_cond;
+    SDL_cond *event_cond;
-    bool stopped;
+    SDL_bool stopped;
-    struct control_msg_queue queue;
+    struct control_event_queue queue;
-    struct receiver receiver;
 };
 
-bool
+SDL_bool controller_init(struct controller *controller, socket_t video_socket);
-controller_init(struct controller *controller, socket_t control_socket);
+void controller_destroy(struct controller *controller);
 
-void
+SDL_bool controller_start(struct controller *controller);
-controller_destroy(struct controller *controller);
+void controller_stop(struct controller *controller);
+void controller_join(struct controller *controller);
 
-bool
+// expose simple API to hide control_event_queue
-controller_start(struct controller *controller);
+SDL_bool controller_push_event(struct controller *controller, const struct control_event *event);
-
-void
-controller_stop(struct controller *controller);
-
-void
-controller_join(struct controller *controller);
-
-bool
-controller_push_msg(struct controller *controller,
-                    const struct control_msg *msg);
 
 #endif

app/src/convert.c

@@ -0,0 +1,182 @@
+#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) {
+    switch (from) {
+        MAP(SDLK_RETURN,       AKEYCODE_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);
+        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;
+    }
+
+    if (!convert_keycode(from->keysym.sym, &to->keycode_event.keycode)) {
+        return SDL_FALSE;
+    }
+
+    to->keycode_event.metastate = convert_meta_state(from->keysym.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 "controlevent.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/decoder.c

@@ -1,27 +1,28 @@
 #include "decoder.h"
 
 #include <libavformat/avformat.h>
-#include <libavutil/time.h>
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>
 #include <unistd.h>
 
 #include "config.h"
-#include "compat.h"
 #include "events.h"
-#include "recorder.h"
+#include "frames.h"
-#include "video_buffer.h"
+#include "lockutil.h"
-#include "util/buffer_util.h"
+#include "log.h"
-#include "util/log.h"
+
+#define BUFSIZE 0x10000
+
+static int read_packet(void *opaque, uint8_t *buf, int buf_size) {
+    struct decoder *decoder = opaque;
+    return net_recv(decoder->video_socket, buf, buf_size);
+}
 
 // set the decoded frame as ready for rendering, and notify
-static void
+static void push_frame(struct decoder *decoder) {
-push_frame(struct decoder *decoder) {
+    SDL_bool previous_frame_consumed = frames_offer_decoded_frame(decoder->frames);
-    bool previous_frame_skipped;
+    if (!previous_frame_consumed) {
-    video_buffer_offer_decoded_frame(decoder->video_buffer,
-                                     &previous_frame_skipped);
-    if (previous_frame_skipped) {
         // the previous EVENT_NEW_FRAME will consume this frame
         return;
     }
@@ -31,71 +32,143 @@ push_frame(struct decoder *decoder) {
     SDL_PushEvent(&new_frame_event);
 }
 
-void
+static void notify_stopped(void) {
-decoder_init(struct decoder *decoder, struct video_buffer *vb) {
+    SDL_Event stop_event;
-    decoder->video_buffer = vb;
+    stop_event.type = EVENT_DECODER_STOPPED;
+    SDL_PushEvent(&stop_event);
 }
 
-bool
+static int run_decoder(void *data) {
-decoder_open(struct decoder *decoder, const AVCodec *codec) {
+    struct decoder *decoder = data;
-    decoder->codec_ctx = avcodec_alloc_context3(codec);
+
-    if (!decoder->codec_ctx) {
+    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");
-        return false;
+        goto run_end;
     }
 
-    if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
+    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
-        LOGE("Could not open codec");
+        LOGE("Could not open H.264 codec");
-        avcodec_free_context(&decoder->codec_ctx);
+        goto run_finally_free_codec_ctx;
-        return false;
     }
 
-    return true;
+    AVFormatContext *format_ctx = avformat_alloc_context();
-}
+    if (!format_ctx) {
+        LOGC("Could not allocate format context");
+        goto run_finally_close_codec;
+    }
 
-void
+    unsigned char *buffer = av_malloc(BUFSIZE);
-decoder_close(struct decoder *decoder) {
+    if (!buffer) {
-    avcodec_close(decoder->codec_ctx);
+        LOGC("Could not allocate buffer");
-    avcodec_free_context(&decoder->codec_ctx);
+        goto run_finally_free_format_ctx;
-}
+    }
 
-bool
+    AVIOContext *avio_ctx = avio_alloc_context(buffer, BUFSIZE, 0, decoder, read_packet, NULL, NULL);
-decoder_push(struct decoder *decoder, const AVPacket *packet) {
+    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;
+    }
+
+    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>
-#ifdef SCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 37, 0)
-    int ret;
+        int ret;
-    if ((ret = avcodec_send_packet(decoder->codec_ctx, packet)) < 0) {
+        if ((ret = avcodec_send_packet(codec_ctx, &packet)) < 0) {
-        LOGE("Could not send video packet: %d", ret);
+            LOGE("Could not send video packet: %d", ret);
-        return false;
+            goto run_quit;
-    }
+        }
-    ret = avcodec_receive_frame(decoder->codec_ctx,
+        ret = avcodec_receive_frame(codec_ctx, decoder->frames->decoding_frame);
-                                decoder->video_buffer->decoding_frame);
+        if (!ret) {
-    if (!ret) {
+            // a frame was received
-        // a frame was received
+            push_frame(decoder);
-        push_frame(decoder);
+        } else if (ret != AVERROR(EAGAIN)) {
-    } else if (ret != AVERROR(EAGAIN)) {
+            LOGE("Could not receive video frame: %d", ret);
-        LOGE("Could not receive video frame: %d", ret);
+            av_packet_unref(&packet);
-        return false;
+            goto run_quit;
-    }
+        }
 #else
-    int got_picture;
+        while (packet.size > 0) {
-    int len = avcodec_decode_video2(decoder->codec_ctx,
+            int got_picture;
-                                    decoder->video_buffer->decoding_frame,
+            int len = avcodec_decode_video2(codec_ctx, decoder->frames->decoding_frame, &got_picture, &packet);
-                                    &got_picture,
+            if (len < 0) {
-                                    packet);
+                LOGE("Could not decode video packet: %d", len);
-    if (len < 0) {
+                goto run_quit;
-        LOGE("Could not decode video packet: %d", len);
+            }
-        return false;
+            if (got_picture) {
-    }
+                push_frame(decoder);
-    if (got_picture) {
+            }
-        push_frame(decoder);
+            packet.size -= len;
-    }
+            packet.data += len;
+        }
 #endif
-    return true;
+        av_packet_unref(&packet);
+
+        if (avio_ctx->eof_reached) {
+            break;
+        }
+    }
+
+    LOGD("End of frames");
+
+run_quit:
+    avformat_close_input(&format_ctx);
+run_finally_free_avio_ctx:
+    av_freep(&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
+void decoder_init(struct decoder *decoder, struct frames *frames, socket_t video_socket) {
-decoder_interrupt(struct decoder *decoder) {
+    decoder->frames = frames;
-    video_buffer_interrupt(decoder->video_buffer);
+    decoder->video_socket = video_socket;
+}
+
+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,31 +1,23 @@
 #ifndef DECODER_H
 #define DECODER_H
 
-#include <stdbool.h>
+#include <SDL2/SDL_stdinc.h>
-#include <libavformat/avformat.h>
+#include <SDL2/SDL_thread.h>
 
-#include "config.h"
+#include "net.h"
 
-struct video_buffer;
+struct frames;
 
 struct decoder {
-    struct video_buffer *video_buffer;
+    struct frames *frames;
-    AVCodecContext *codec_ctx;
+    socket_t video_socket;
+    SDL_Thread *thread;
+    SDL_mutex *mutex;
 };
 
-void
+void decoder_init(struct decoder *decoder, struct frames *frames, socket_t video_socket);
-decoder_init(struct decoder *decoder, struct video_buffer *vb);
+SDL_bool decoder_start(struct decoder *decoder);
-
+void decoder_stop(struct decoder *decoder);
-bool
+void decoder_join(struct decoder *decoder);
-decoder_open(struct decoder *decoder, const AVCodec *codec);
-
-void
-decoder_close(struct decoder *decoder);
-
-bool
-decoder_push(struct decoder *decoder, const AVPacket *packet);
-
-void
-decoder_interrupt(struct decoder *decoder);
 
 #endif

app/src/device.c

@@ -1,24 +1,18 @@
 #include "device.h"
+#include "log.h"
 
-#include "config.h"
+SDL_bool device_read_info(socket_t device_socket, char *device_name, struct size *size) {
-#include "util/log.h"
-
-bool
-device_read_info(socket_t device_socket, char *device_name, struct size *size) {
     unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
     int r = net_recv_all(device_socket, buf, sizeof(buf));
     if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
         LOGE("Could not retrieve device information");
-        return false;
+        return SDL_FALSE;
     }
-    // in case the client sends garbage
+    buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0'; // in case the client sends garbage
-    buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
+    // strcpy is safe here, since name contains at least DEVICE_NAME_FIELD_LENGTH bytes
-    // strcpy is safe here, since name contains at least
+    // and strlen(buf) < DEVICE_NAME_FIELD_LENGTH
-    // 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)
+    size->width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8) | buf[DEVICE_NAME_FIELD_LENGTH + 1];
-            | buf[DEVICE_NAME_FIELD_LENGTH + 1];
+    size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8) | buf[DEVICE_NAME_FIELD_LENGTH + 3];
-    size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
+    return SDL_TRUE;
-            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
-    return true;
 }

app/src/device.h

@@ -1,16 +1,14 @@
 #ifndef DEVICE_H
 #define DEVICE_H
 
-#include <stdbool.h>
+#include <SDL2/SDL_stdinc.h>
 
-#include "config.h"
 #include "common.h"
-#include "util/net.h"
+#include "net.h"
 
 #define DEVICE_NAME_FIELD_LENGTH 64
 
 // name must be at least DEVICE_NAME_FIELD_LENGTH bytes
-bool
+SDL_bool device_read_info(socket_t device_socket, char *name, struct size *frame_size);
-device_read_info(socket_t device_socket, char *device_name, struct size *size);
 
 #endif

app/src/device_msg.c

@@ -1,48 +0,0 @@
-#include "device_msg.h"
-
-#include <string.h>
-
-#include "config.h"
-#include "util/buffer_util.h"
-#include "util/log.h"
-
-ssize_t
-device_msg_deserialize(const unsigned char *buf, size_t len,
-                       struct device_msg *msg) {
-    if (len < 3) {
-        // at least type + empty string length
-        return 0; // not available
-    }
-
-    msg->type = buf[0];
-    switch (msg->type) {
-        case DEVICE_MSG_TYPE_CLIPBOARD: {
-            uint16_t clipboard_len = buffer_read16be(&buf[1]);
-            if (clipboard_len > len - 3) {
-                return 0; // not available
-            }
-            char *text = SDL_malloc(clipboard_len + 1);
-            if (!text) {
-                LOGW("Could not allocate text for clipboard");
-                return -1;
-            }
-            if (clipboard_len) {
-                memcpy(text, &buf[3], clipboard_len);
-            }
-            text[clipboard_len] = '\0';
-
-            msg->clipboard.text = text;
-            return 3 + clipboard_len;
-        }
-        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) {
-        SDL_free(msg->clipboard.text);
-    }
-}

app/src/device_msg.h

@@ -1,34 +0,0 @@
-#ifndef DEVICEMSG_H
-#define DEVICEMSG_H
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <unistd.h>
-
-#include "config.h"
-
-#define DEVICE_MSG_TEXT_MAX_LENGTH 4093
-#define DEVICE_MSG_SERIALIZED_MAX_SIZE (3 + DEVICE_MSG_TEXT_MAX_LENGTH)
-
-enum device_msg_type {
-    DEVICE_MSG_TYPE_CLIPBOARD,
-};
-
-struct device_msg {
-    enum device_msg_type type;
-    union {
-        struct {
-            char *text; // owned, to be freed by SDL_free()
-        } 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/event_converter.c

@@ -1,193 +0,0 @@
-#include "event_converter.h"
-
-#include "config.h"
-
-#define MAP(FROM, TO) case FROM: *to = TO; return true
-#define FAIL default: return false
-
-bool
-convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) {
-    switch (from) {
-        MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN);
-        MAP(SDL_KEYUP,   AKEY_EVENT_ACTION_UP);
-        FAIL;
-    }
-}
-
-static enum android_metastate
-autocomplete_metastate(enum android_metastate metastate) {
-    // fill dependant flags
-    if (metastate & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
-        metastate |= AMETA_SHIFT_ON;
-    }
-    if (metastate & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
-        metastate |= AMETA_CTRL_ON;
-    }
-    if (metastate & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
-        metastate |= AMETA_ALT_ON;
-    }
-    if (metastate & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
-        metastate |= AMETA_META_ON;
-    }
-
-    return metastate;
-}
-
-enum android_metastate
-convert_meta_state(SDL_Keymod mod) {
-    enum android_metastate metastate = 0;
-    if (mod & KMOD_LSHIFT) {
-        metastate |= AMETA_SHIFT_LEFT_ON;
-    }
-    if (mod & KMOD_RSHIFT) {
-        metastate |= AMETA_SHIFT_RIGHT_ON;
-    }
-    if (mod & KMOD_LCTRL) {
-        metastate |= AMETA_CTRL_LEFT_ON;
-    }
-    if (mod & KMOD_RCTRL) {
-        metastate |= AMETA_CTRL_RIGHT_ON;
-    }
-    if (mod & KMOD_LALT) {
-        metastate |= AMETA_ALT_LEFT_ON;
-    }
-    if (mod & KMOD_RALT) {
-        metastate |= AMETA_ALT_RIGHT_ON;
-    }
-    if (mod & KMOD_LGUI) { // Windows key
-        metastate |= AMETA_META_LEFT_ON;
-    }
-    if (mod & KMOD_RGUI) { // Windows key
-        metastate |= AMETA_META_RIGHT_ON;
-    }
-    if (mod & KMOD_NUM) {
-        metastate |= AMETA_NUM_LOCK_ON;
-    }
-    if (mod & KMOD_CAPS) {
-        metastate |= AMETA_CAPS_LOCK_ON;
-    }
-    if (mod & KMOD_MODE) { // Alt Gr
-        // no mapping?
-    }
-
-    // fill the dependent fields
-    return autocomplete_metastate(metastate);
-}
-
-bool
-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
-                bool prefer_text) {
-    switch (from) {
-        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
-        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
-        MAP(SDLK_ESCAPE,       AKEYCODE_ESCAPE);
-        MAP(SDLK_BACKSPACE,    AKEYCODE_DEL);
-        MAP(SDLK_TAB,          AKEYCODE_TAB);
-        MAP(SDLK_PAGEUP,       AKEYCODE_PAGE_UP);
-        MAP(SDLK_DELETE,       AKEYCODE_FORWARD_DEL);
-        MAP(SDLK_HOME,         AKEYCODE_MOVE_HOME);
-        MAP(SDLK_END,          AKEYCODE_MOVE_END);
-        MAP(SDLK_PAGEDOWN,     AKEYCODE_PAGE_DOWN);
-        MAP(SDLK_RIGHT,        AKEYCODE_DPAD_RIGHT);
-        MAP(SDLK_LEFT,         AKEYCODE_DPAD_LEFT);
-        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
-        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
-    }
-
-    if (!(mod & (KMOD_NUM | KMOD_SHIFT))) {
-        // Handle Numpad events when Num Lock is disabled
-        // If SHIFT is pressed, a text event will be sent instead
-        switch(from) {
-            MAP(SDLK_KP_0,            AKEYCODE_INSERT);
-            MAP(SDLK_KP_1,            AKEYCODE_MOVE_END);
-            MAP(SDLK_KP_2,            AKEYCODE_DPAD_DOWN);
-            MAP(SDLK_KP_3,            AKEYCODE_PAGE_DOWN);
-            MAP(SDLK_KP_4,            AKEYCODE_DPAD_LEFT);
-            MAP(SDLK_KP_6,            AKEYCODE_DPAD_RIGHT);
-            MAP(SDLK_KP_7,            AKEYCODE_MOVE_HOME);
-            MAP(SDLK_KP_8,            AKEYCODE_DPAD_UP);
-            MAP(SDLK_KP_9,            AKEYCODE_PAGE_UP);
-            MAP(SDLK_KP_PERIOD,       AKEYCODE_FORWARD_DEL);
-        }
-    }
-
-    if (prefer_text) {
-        // do not forward alpha and space key events
-        return false;
-    }
-
-    if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
-        return false;
-    }
-    // if ALT and META are not pressed, also handle letters and space
-    switch (from) {
-        MAP(SDLK_a,            AKEYCODE_A);
-        MAP(SDLK_b,            AKEYCODE_B);
-        MAP(SDLK_c,            AKEYCODE_C);
-        MAP(SDLK_d,            AKEYCODE_D);
-        MAP(SDLK_e,            AKEYCODE_E);
-        MAP(SDLK_f,            AKEYCODE_F);
-        MAP(SDLK_g,            AKEYCODE_G);
-        MAP(SDLK_h,            AKEYCODE_H);
-        MAP(SDLK_i,            AKEYCODE_I);
-        MAP(SDLK_j,            AKEYCODE_J);
-        MAP(SDLK_k,            AKEYCODE_K);
-        MAP(SDLK_l,            AKEYCODE_L);
-        MAP(SDLK_m,            AKEYCODE_M);
-        MAP(SDLK_n,            AKEYCODE_N);
-        MAP(SDLK_o,            AKEYCODE_O);
-        MAP(SDLK_p,            AKEYCODE_P);
-        MAP(SDLK_q,            AKEYCODE_Q);
-        MAP(SDLK_r,            AKEYCODE_R);
-        MAP(SDLK_s,            AKEYCODE_S);
-        MAP(SDLK_t,            AKEYCODE_T);
-        MAP(SDLK_u,            AKEYCODE_U);
-        MAP(SDLK_v,            AKEYCODE_V);
-        MAP(SDLK_w,            AKEYCODE_W);
-        MAP(SDLK_x,            AKEYCODE_X);
-        MAP(SDLK_y,            AKEYCODE_Y);
-        MAP(SDLK_z,            AKEYCODE_Z);
-        MAP(SDLK_SPACE,        AKEYCODE_SPACE);
-        FAIL;
-    }
-}
-
-enum android_motionevent_buttons
-convert_mouse_buttons(uint32_t state) {
-    enum android_motionevent_buttons buttons = 0;
-    if (state & SDL_BUTTON_LMASK) {
-        buttons |= AMOTION_EVENT_BUTTON_PRIMARY;
-    }
-    if (state & SDL_BUTTON_RMASK) {
-        buttons |= AMOTION_EVENT_BUTTON_SECONDARY;
-    }
-    if (state & SDL_BUTTON_MMASK) {
-        buttons |= AMOTION_EVENT_BUTTON_TERTIARY;
-    }
-    if (state & SDL_BUTTON_X1MASK) {
-        buttons |= AMOTION_EVENT_BUTTON_BACK;
-    }
-    if (state & SDL_BUTTON_X2MASK) {
-        buttons |= AMOTION_EVENT_BUTTON_FORWARD;
-    }
-    return buttons;
-}
-
-bool
-convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) {
-    switch (from) {
-        MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN);
-        MAP(SDL_MOUSEBUTTONUP,   AMOTION_EVENT_ACTION_UP);
-        FAIL;
-    }
-}
-
-bool
-convert_touch_action(SDL_EventType from, enum android_motionevent_action *to) {
-    switch (from) {
-        MAP(SDL_FINGERMOTION, AMOTION_EVENT_ACTION_MOVE);
-        MAP(SDL_FINGERDOWN,   AMOTION_EVENT_ACTION_DOWN);
-        MAP(SDL_FINGERUP,     AMOTION_EVENT_ACTION_UP);
-        FAIL;
-    }
-}

app/src/event_converter.h

@@ -1,29 +0,0 @@
-#ifndef CONVERT_H
-#define CONVERT_H
-
-#include <stdbool.h>
-#include <SDL2/SDL_events.h>
-
-#include "config.h"
-#include "control_msg.h"
-
-bool
-convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to);
-
-enum android_metastate
-convert_meta_state(SDL_Keymod mod);
-
-bool
-convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
-                bool prefer_text);
-
-enum android_motionevent_buttons
-convert_mouse_buttons(uint32_t state);
-
-bool
-convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to);
-
-bool
-convert_touch_action(SDL_EventType from, enum android_motionevent_action *to);
-
-#endif

app/src/events.h

@@ -1,3 +1,3 @@
 #define EVENT_NEW_SESSION SDL_USEREVENT
 #define EVENT_NEW_FRAME (SDL_USEREVENT + 1)
-#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 2)
+#define EVENT_DECODER_STOPPED (SDL_USEREVENT + 2)

app/src/file_handler.c

@@ -1,191 +0,0 @@
-#include "file_handler.h"
-
-#include <assert.h>
-#include <string.h>
-
-#include "config.h"
-#include "command.h"
-#include "util/lock.h"
-#include "util/log.h"
-
-#define DEFAULT_PUSH_TARGET "/sdcard/"
-
-static void
-file_handler_request_destroy(struct file_handler_request *req) {
-    SDL_free(req->file);
-}
-
-bool
-file_handler_init(struct file_handler *file_handler, const char *serial,
-                  const char *push_target) {
-
-    cbuf_init(&file_handler->queue);
-
-    if (!(file_handler->mutex = SDL_CreateMutex())) {
-        return false;
-    }
-
-    if (!(file_handler->event_cond = SDL_CreateCond())) {
-        SDL_DestroyMutex(file_handler->mutex);
-        return false;
-    }
-
-    if (serial) {
-        file_handler->serial = SDL_strdup(serial);
-        if (!file_handler->serial) {
-            LOGW("Could not strdup serial");
-            SDL_DestroyCond(file_handler->event_cond);
-            SDL_DestroyMutex(file_handler->mutex);
-            return false;
-        }
-    } else {
-        file_handler->serial = NULL;
-    }
-
-    // lazy initialization
-    file_handler->initialized = false;
-
-    file_handler->stopped = false;
-    file_handler->current_process = PROCESS_NONE;
-
-    file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;
-
-    return true;
-}
-
-void
-file_handler_destroy(struct file_handler *file_handler) {
-    SDL_DestroyCond(file_handler->event_cond);
-    SDL_DestroyMutex(file_handler->mutex);
-    SDL_free(file_handler->serial);
-
-    struct file_handler_request req;
-    while (cbuf_take(&file_handler->queue, &req)) {
-        file_handler_request_destroy(&req);
-    }
-}
-
-static process_t
-install_apk(const char *serial, const char *file) {
-    return adb_install(serial, file);
-}
-
-static process_t
-push_file(const char *serial, const char *file, const char *push_target) {
-    return adb_push(serial, file, push_target);
-}
-
-bool
-file_handler_request(struct file_handler *file_handler,
-                     file_handler_action_t action, char *file) {
-    // start file_handler if it's used for the first time
-    if (!file_handler->initialized) {
-        if (!file_handler_start(file_handler)) {
-            return false;
-        }
-        file_handler->initialized = true;
-    }
-
-    LOGI("Request to %s %s", action == ACTION_INSTALL_APK ? "install" : "push",
-                             file);
-    struct file_handler_request req = {
-        .action = action,
-        .file = file,
-    };
-
-    mutex_lock(file_handler->mutex);
-    bool was_empty = cbuf_is_empty(&file_handler->queue);
-    bool res = cbuf_push(&file_handler->queue, req);
-    if (was_empty) {
-        cond_signal(file_handler->event_cond);
-    }
-    mutex_unlock(file_handler->mutex);
-    return res;
-}
-
-static int
-run_file_handler(void *data) {
-    struct file_handler *file_handler = data;
-
-    for (;;) {
-        mutex_lock(file_handler->mutex);
-        file_handler->current_process = PROCESS_NONE;
-        while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
-            cond_wait(file_handler->event_cond, file_handler->mutex);
-        }
-        if (file_handler->stopped) {
-            // stop immediately, do not process further events
-            mutex_unlock(file_handler->mutex);
-            break;
-        }
-        struct file_handler_request req;
-        bool non_empty = cbuf_take(&file_handler->queue, &req);
-        assert(non_empty);
-        (void) non_empty;
-
-        process_t process;
-        if (req.action == ACTION_INSTALL_APK) {
-            LOGI("Installing %s...", req.file);
-            process = install_apk(file_handler->serial, req.file);
-        } else {
-            LOGI("Pushing %s...", req.file);
-            process = push_file(file_handler->serial, req.file,
-                                file_handler->push_target);
-        }
-        file_handler->current_process = process;
-        mutex_unlock(file_handler->mutex);
-
-        if (req.action == ACTION_INSTALL_APK) {
-            if (process_check_success(process, "adb install")) {
-                LOGI("%s successfully installed", req.file);
-            } else {
-                LOGE("Failed to install %s", req.file);
-            }
-        } else {
-            if (process_check_success(process, "adb push")) {
-                LOGI("%s successfully pushed to %s", req.file,
-                                                     file_handler->push_target);
-            } else {
-                LOGE("Failed to push %s to %s", req.file,
-                                                file_handler->push_target);
-            }
-        }
-
-        file_handler_request_destroy(&req);
-    }
-    return 0;
-}
-
-bool
-file_handler_start(struct file_handler *file_handler) {
-    LOGD("Starting file_handler thread");
-
-    file_handler->thread = SDL_CreateThread(run_file_handler, "file_handler",
-                                            file_handler);
-    if (!file_handler->thread) {
-        LOGC("Could not start file_handler thread");
-        return false;
-    }
-
-    return true;
-}
-
-void
-file_handler_stop(struct file_handler *file_handler) {
-    mutex_lock(file_handler->mutex);
-    file_handler->stopped = true;
-    cond_signal(file_handler->event_cond);
-    if (file_handler->current_process != PROCESS_NONE) {
-        if (!cmd_terminate(file_handler->current_process)) {
-            LOGW("Could not terminate install process");
-        }
-        cmd_simple_wait(file_handler->current_process, NULL);
-        file_handler->current_process = PROCESS_NONE;
-    }
-    mutex_unlock(file_handler->mutex);
-}
-
-void
-file_handler_join(struct file_handler *file_handler) {
-    SDL_WaitThread(file_handler->thread, NULL);
-}

app/src/file_handler.h

@@ -1,58 +0,0 @@
-#ifndef FILE_HANDLER_H
-#define FILE_HANDLER_H
-
-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
-
-#include "config.h"
-#include "command.h"
-#include "util/cbuf.h"
-
-typedef enum {
-    ACTION_INSTALL_APK,
-    ACTION_PUSH_FILE,
-} file_handler_action_t;
-
-struct file_handler_request {
-    file_handler_action_t action;
-    char *file;
-};
-
-struct file_handler_request_queue CBUF(struct file_handler_request, 16);
-
-struct file_handler {
-    char *serial;
-    const char *push_target;
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *event_cond;
-    bool stopped;
-    bool initialized;
-    process_t current_process;
-    struct file_handler_request_queue queue;
-};
-
-bool
-file_handler_init(struct file_handler *file_handler, const char *serial,
-                  const char *push_target);
-
-void
-file_handler_destroy(struct file_handler *file_handler);
-
-bool
-file_handler_start(struct file_handler *file_handler);
-
-void
-file_handler_stop(struct file_handler *file_handler);
-
-void
-file_handler_join(struct file_handler *file_handler);
-
-// take ownership of file, and will SDL_free() it
-bool
-file_handler_request(struct file_handler *file_handler,
-                     file_handler_action_t action,
-                     char *file);
-
-#endif

app/src/fps_counter.c

@@ -1,180 +0,0 @@
-#include "fps_counter.h"
-
-#include <assert.h>
-#include <SDL2/SDL_timer.h>
-
-#include "config.h"
-#include "util/lock.h"
-#include "util/log.h"
-
-#define FPS_COUNTER_INTERVAL_MS 1000
-
-bool
-fps_counter_init(struct fps_counter *counter) {
-    counter->mutex = SDL_CreateMutex();
-    if (!counter->mutex) {
-        return false;
-    }
-
-    counter->state_cond = SDL_CreateCond();
-    if (!counter->state_cond) {
-        SDL_DestroyMutex(counter->mutex);
-        return false;
-    }
-
-    counter->thread = NULL;
-    atomic_init(&counter->started, 0);
-    // no need to initialize the other fields, they are unused until started
-
-    return true;
-}
-
-void
-fps_counter_destroy(struct fps_counter *counter) {
-    SDL_DestroyCond(counter->state_cond);
-    SDL_DestroyMutex(counter->mutex);
-}
-
-static inline bool
-is_started(struct fps_counter *counter) {
-    return atomic_load_explicit(&counter->started, memory_order_acquire);
-}
-
-static inline void
-set_started(struct 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 fps_counter *counter) {
-    unsigned rendered_per_second =
-        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;
-    if (counter->nr_skipped) {
-        LOGI("%u fps (+%u frames skipped)", rendered_per_second,
-                                            counter->nr_skipped);
-    } else {
-        LOGI("%u fps", rendered_per_second);
-    }
-}
-
-// must be called with mutex locked
-static void
-check_interval_expired(struct fps_counter *counter, uint32_t 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) / FPS_COUNTER_INTERVAL_MS + 1;
-    counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;
-}
-
-static int
-run_fps_counter(void *data) {
-    struct fps_counter *counter = data;
-
-    mutex_lock(counter->mutex);
-    while (!counter->interrupted) {
-        while (!counter->interrupted && !is_started(counter)) {
-            cond_wait(counter->state_cond, counter->mutex);
-        }
-        while (!counter->interrupted && is_started(counter)) {
-            uint32_t now = SDL_GetTicks();
-            check_interval_expired(counter, now);
-
-            assert(counter->next_timestamp > now);
-            uint32_t remaining = counter->next_timestamp - now;
-
-            // ignore the reason (timeout or signaled), we just loop anyway
-            cond_wait_timeout(counter->state_cond, counter->mutex, remaining);
-        }
-    }
-    mutex_unlock(counter->mutex);
-    return 0;
-}
-
-bool
-fps_counter_start(struct fps_counter *counter) {
-    mutex_lock(counter->mutex);
-    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
-    counter->nr_rendered = 0;
-    counter->nr_skipped = 0;
-    mutex_unlock(counter->mutex);
-
-    set_started(counter, true);
-    cond_signal(counter->state_cond);
-
-    // counter->thread is always accessed from the same thread, no need to lock
-    if (!counter->thread) {
-        counter->thread =
-            SDL_CreateThread(run_fps_counter, "fps counter", counter);
-        if (!counter->thread) {
-            LOGE("Could not start FPS counter thread");
-            return false;
-        }
-    }
-
-    return true;
-}
-
-void
-fps_counter_stop(struct fps_counter *counter) {
-    set_started(counter, false);
-    cond_signal(counter->state_cond);
-}
-
-bool
-fps_counter_is_started(struct fps_counter *counter) {
-    return is_started(counter);
-}
-
-void
-fps_counter_interrupt(struct fps_counter *counter) {
-    if (!counter->thread) {
-        return;
-    }
-
-    mutex_lock(counter->mutex);
-    counter->interrupted = true;
-    mutex_unlock(counter->mutex);
-    // wake up blocking wait
-    cond_signal(counter->state_cond);
-}
-
-void
-fps_counter_join(struct fps_counter *counter) {
-    if (counter->thread) {
-        SDL_WaitThread(counter->thread, NULL);
-    }
-}
-
-void
-fps_counter_add_rendered_frame(struct fps_counter *counter) {
-    if (!is_started(counter)) {
-        return;
-    }
-
-    mutex_lock(counter->mutex);
-    uint32_t now = SDL_GetTicks();
-    check_interval_expired(counter, now);
-    ++counter->nr_rendered;
-    mutex_unlock(counter->mutex);
-}
-
-void
-fps_counter_add_skipped_frame(struct fps_counter *counter) {
-    if (!is_started(counter)) {
-        return;
-    }
-
-    mutex_lock(counter->mutex);
-    uint32_t now = SDL_GetTicks();
-    check_interval_expired(counter, now);
-    ++counter->nr_skipped;
-    mutex_unlock(counter->mutex);
-}

app/src/fps_counter.h

@@ -1,57 +0,0 @@
-#ifndef FPSCOUNTER_H
-#define FPSCOUNTER_H
-
-#include <stdatomic.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
-
-#include "config.h"
-
-struct fps_counter {
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *state_cond;
-
-    // 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;
-    uint32_t next_timestamp;
-};
-
-bool
-fps_counter_init(struct fps_counter *counter);
-
-void
-fps_counter_destroy(struct fps_counter *counter);
-
-bool
-fps_counter_start(struct fps_counter *counter);
-
-void
-fps_counter_stop(struct fps_counter *counter);
-
-bool
-fps_counter_is_started(struct fps_counter *counter);
-
-// request to stop the thread (on quit)
-// must be called before fps_counter_join()
-void
-fps_counter_interrupt(struct fps_counter *counter);
-
-void
-fps_counter_join(struct fps_counter *counter);
-
-void
-fps_counter_add_rendered_frame(struct fps_counter *counter);
-
-void
-fps_counter_add_skipped_frame(struct fps_counter *counter);
-
-#endif

app/src/fpscounter.c

@@ -0,0 +1,62 @@
+#include "fpscounter.h"
+
+#include <SDL2/SDL_timer.h>
+
+#include "log.h"
+
+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 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
+}
+
+void fps_counter_stop(struct fps_counter *counter) {
+    counter->started = SDL_FALSE;
+}
+
+static void display_fps(struct fps_counter *counter) {
+#ifdef SKIP_FRAMES
+    if (counter->nr_skipped) {
+        LOGI("%d fps (+%d frames skipped)", counter->nr_rendered, counter->nr_skipped);
+    } else {
+#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
+    }
+}
+
+void fps_counter_add_rendered_frame(struct fps_counter *counter) {
+    check_expired(counter);
+    ++counter->nr_rendered;
+}
+
+#ifdef SKIP_FRAMES
+void fps_counter_add_skipped_frame(struct fps_counter *counter) {
+    check_expired(counter);
+    ++counter->nr_skipped;
+}
+#endif

app/src/fpscounter.h

@@ -0,0 +1,26 @@
+#ifndef FPSCOUNTER_H
+#define FPSCOUNTER_H
+
+#include <SDL2/SDL_stdinc.h>
+
+#include "config.h"
+
+struct fps_counter {
+    SDL_bool started;
+    Uint32 slice_start; // initialized by SDL_GetTicks()
+    int nr_rendered;
+#ifdef SKIP_FRAMES
+    int nr_skipped;
+#endif
+};
+
+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 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/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 "lockutil.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 "fpscounter.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/input_manager.c

@@ -1,605 +0,0 @@
-#include "input_manager.h"
-
-#include <assert.h>
-
-#include "config.h"
-#include "event_converter.h"
-#include "util/lock.h"
-#include "util/log.h"
-
-// Convert window coordinates (as provided by SDL_GetMouseState() to renderer
-// coordinates (as provided in SDL mouse events)
-//
-// See my question:
-// <https://stackoverflow.com/questions/49111054/how-to-get-mouse-position-on-mouse-wheel-event>
-static void
-convert_to_renderer_coordinates(SDL_Renderer *renderer, int *x, int *y) {
-    SDL_Rect viewport;
-    float scale_x, scale_y;
-    SDL_RenderGetViewport(renderer, &viewport);
-    SDL_RenderGetScale(renderer, &scale_x, &scale_y);
-    *x = (int) (*x / scale_x) - viewport.x;
-    *y = (int) (*y / scale_y) - viewport.y;
-}
-
-static struct point
-get_mouse_point(struct screen *screen) {
-    int x;
-    int y;
-    SDL_GetMouseState(&x, &y);
-    convert_to_renderer_coordinates(screen->renderer, &x, &y);
-    return (struct point) {
-        .x = x,
-        .y = y,
-    };
-}
-
-static const int ACTION_DOWN = 1;
-static const int ACTION_UP = 1 << 1;
-
-static void
-send_keycode(struct controller *controller, enum android_keycode keycode,
-             int actions, const char *name) {
-    // send DOWN event
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
-    msg.inject_keycode.keycode = keycode;
-    msg.inject_keycode.metastate = 0;
-
-    if (actions & ACTION_DOWN) {
-        msg.inject_keycode.action = AKEY_EVENT_ACTION_DOWN;
-        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'inject %s (DOWN)'", name);
-            return;
-        }
-    }
-
-    if (actions & ACTION_UP) {
-        msg.inject_keycode.action = AKEY_EVENT_ACTION_UP;
-        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'inject %s (UP)'", name);
-        }
-    }
-}
-
-static inline void
-action_home(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_HOME, actions, "HOME");
-}
-
-static inline void
-action_back(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_BACK, actions, "BACK");
-}
-
-static inline void
-action_app_switch(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_APP_SWITCH, actions, "APP_SWITCH");
-}
-
-static inline void
-action_power(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_POWER, actions, "POWER");
-}
-
-static inline void
-action_volume_up(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_VOLUME_UP, actions, "VOLUME_UP");
-}
-
-static inline void
-action_volume_down(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_VOLUME_DOWN, actions, "VOLUME_DOWN");
-}
-
-static inline void
-action_menu(struct controller *controller, int actions) {
-    send_keycode(controller, AKEYCODE_MENU, actions, "MENU");
-}
-
-// turn the screen on if it was off, press BACK otherwise
-static void
-press_back_or_turn_screen_on(struct controller *controller) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON;
-
-    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request 'press back or turn screen on'");
-    }
-}
-
-static void
-expand_notification_panel(struct controller *controller) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL;
-
-    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request 'expand notification panel'");
-    }
-}
-
-static void
-collapse_notification_panel(struct controller *controller) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL;
-
-    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request 'collapse notification panel'");
-    }
-}
-
-static void
-request_device_clipboard(struct controller *controller) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_GET_CLIPBOARD;
-
-    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request device clipboard");
-    }
-}
-
-static void
-set_device_clipboard(struct controller *controller) {
-    char *text = SDL_GetClipboardText();
-    if (!text) {
-        LOGW("Could not get clipboard text: %s", SDL_GetError());
-        return;
-    }
-    if (!*text) {
-        // empty text
-        SDL_free(text);
-        return;
-    }
-
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
-    msg.set_clipboard.text = text;
-
-    if (!controller_push_msg(controller, &msg)) {
-        SDL_free(text);
-        LOGW("Could not request 'set device clipboard'");
-    }
-}
-
-static void
-set_screen_power_mode(struct controller *controller,
-                      enum screen_power_mode mode) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
-    msg.set_screen_power_mode.mode = mode;
-
-    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request 'set screen power mode'");
-    }
-}
-
-static void
-switch_fps_counter_state(struct fps_counter *fps_counter) {
-    // the started state can only be written from the current thread, so there
-    // is no ToCToU issue
-    if (fps_counter_is_started(fps_counter)) {
-        fps_counter_stop(fps_counter);
-        LOGI("FPS counter stopped");
-    } else {
-        if (fps_counter_start(fps_counter)) {
-            LOGI("FPS counter started");
-        } else {
-            LOGE("FPS counter starting failed");
-        }
-    }
-}
-
-static void
-clipboard_paste(struct controller *controller) {
-    char *text = SDL_GetClipboardText();
-    if (!text) {
-        LOGW("Could not get clipboard text: %s", SDL_GetError());
-        return;
-    }
-    if (!*text) {
-        // empty text
-        SDL_free(text);
-        return;
-    }
-
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = text;
-    if (!controller_push_msg(controller, &msg)) {
-        SDL_free(text);
-        LOGW("Could not request 'paste clipboard'");
-    }
-}
-
-static void
-rotate_device(struct controller *controller) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_ROTATE_DEVICE;
-
-    if (!controller_push_msg(controller, &msg)) {
-        LOGW("Could not request device rotation");
-    }
-}
-
-static void
-rotate_client_left(struct screen *screen) {
-    unsigned new_rotation = (screen->rotation + 1) % 4;
-    screen_set_rotation(screen, new_rotation);
-}
-
-static void
-rotate_client_right(struct screen *screen) {
-    unsigned new_rotation = (screen->rotation + 3) % 4;
-    screen_set_rotation(screen, new_rotation);
-}
-
-void
-input_manager_process_text_input(struct input_manager *im,
-                                 const SDL_TextInputEvent *event) {
-    if (!im->prefer_text) {
-        char c = event->text[0];
-        if (isalpha(c) || c == ' ') {
-            assert(event->text[1] == '\0');
-            // letters and space are handled as raw key event
-            return;
-        }
-    }
-
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = SDL_strdup(event->text);
-    if (!msg.inject_text.text) {
-        LOGW("Could not strdup input text");
-        return;
-    }
-    if (!controller_push_msg(im->controller, &msg)) {
-        SDL_free(msg.inject_text.text);
-        LOGW("Could not request 'inject text'");
-    }
-}
-
-static bool
-convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
-                  bool prefer_text) {
-    to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE;
-
-    if (!convert_keycode_action(from->type, &to->inject_keycode.action)) {
-        return false;
-    }
-
-    uint16_t mod = from->keysym.mod;
-    if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod,
-                         prefer_text)) {
-        return false;
-    }
-
-    to->inject_keycode.metastate = convert_meta_state(mod);
-
-    return true;
-}
-
-void
-input_manager_process_key(struct input_manager *im,
-                          const SDL_KeyboardEvent *event,
-                          bool control) {
-    // control: indicates the state of the command-line option --no-control
-    // ctrl: the Ctrl key
-
-    bool ctrl = event->keysym.mod & (KMOD_LCTRL | KMOD_RCTRL);
-    bool alt = event->keysym.mod & (KMOD_LALT | KMOD_RALT);
-    bool meta = event->keysym.mod & (KMOD_LGUI | KMOD_RGUI);
-
-    // use Cmd on macOS, Ctrl on other platforms
-#ifdef __APPLE__
-    bool cmd = !ctrl && meta;
-#else
-    if (meta) {
-        // no shortcuts involve Meta on platforms other than macOS, and it must
-        // not be forwarded to the device
-        return;
-    }
-    bool cmd = ctrl; // && !meta, already guaranteed
-#endif
-
-    if (alt) {
-        // no shortcuts involve Alt, and it must not be forwarded to the device
-        return;
-    }
-
-    struct controller *controller = im->controller;
-
-    // capture all Ctrl events
-    if (ctrl || cmd) {
-        SDL_Keycode keycode = event->keysym.sym;
-        bool down = event->type == SDL_KEYDOWN;
-        int action = down ? ACTION_DOWN : ACTION_UP;
-        bool repeat = event->repeat;
-        bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
-        switch (keycode) {
-            case SDLK_h:
-                // Ctrl+h on all platform, since Cmd+h is already captured by
-                // the system on macOS to hide the window
-                if (control && ctrl && !meta && !shift && !repeat) {
-                    action_home(controller, action);
-                }
-                return;
-            case SDLK_b: // fall-through
-            case SDLK_BACKSPACE:
-                if (control && cmd && !shift && !repeat) {
-                    action_back(controller, action);
-                }
-                return;
-            case SDLK_s:
-                if (control && cmd && !shift && !repeat) {
-                    action_app_switch(controller, action);
-                }
-                return;
-            case SDLK_m:
-                // Ctrl+m on all platform, since Cmd+m is already captured by
-                // the system on macOS to minimize the window
-                if (control && ctrl && !meta && !shift && !repeat) {
-                    action_menu(controller, action);
-                }
-                return;
-            case SDLK_p:
-                if (control && cmd && !shift && !repeat) {
-                    action_power(controller, action);
-                }
-                return;
-            case SDLK_o:
-                if (control && cmd && !shift && down) {
-                    set_screen_power_mode(controller, SCREEN_POWER_MODE_OFF);
-                }
-                return;
-            case SDLK_DOWN:
-                if (control && cmd && !shift) {
-                    // forward repeated events
-                    action_volume_down(controller, action);
-                }
-                return;
-            case SDLK_UP:
-                if (control && cmd && !shift) {
-                    // forward repeated events
-                    action_volume_up(controller, action);
-                }
-                return;
-            case SDLK_LEFT:
-                if (cmd && !shift && down) {
-                    rotate_client_left(im->screen);
-                }
-                return;
-            case SDLK_RIGHT:
-                if (cmd && !shift && down) {
-                    rotate_client_right(im->screen);
-                }
-                return;
-            case SDLK_c:
-                if (control && cmd && !shift && !repeat && down) {
-                    request_device_clipboard(controller);
-                }
-                return;
-            case SDLK_v:
-                if (control && cmd && !repeat && down) {
-                    if (shift) {
-                        // store the text in the device clipboard
-                        set_device_clipboard(controller);
-                    } else {
-                        // inject the text as input events
-                        clipboard_paste(controller);
-                    }
-                }
-                return;
-            case SDLK_f:
-                if (!shift && cmd && !repeat && down) {
-                    screen_switch_fullscreen(im->screen);
-                }
-                return;
-            case SDLK_x:
-                if (!shift && cmd && !repeat && down) {
-                    screen_resize_to_fit(im->screen);
-                }
-                return;
-            case SDLK_g:
-                if (!shift && cmd && !repeat && down) {
-                    screen_resize_to_pixel_perfect(im->screen);
-                }
-                return;
-            case SDLK_i:
-                if (!shift && cmd && !repeat && down) {
-                    struct fps_counter *fps_counter =
-                        im->video_buffer->fps_counter;
-                    switch_fps_counter_state(fps_counter);
-                }
-                return;
-            case SDLK_n:
-                if (control && cmd && !repeat && down) {
-                    if (shift) {
-                        collapse_notification_panel(controller);
-                    } else {
-                        expand_notification_panel(controller);
-                    }
-                }
-                return;
-            case SDLK_r:
-                if (control && cmd && !shift && !repeat && down) {
-                    rotate_device(controller);
-                }
-                return;
-        }
-
-        return;
-    }
-
-    if (!control) {
-        return;
-    }
-
-    struct control_msg msg;
-    if (convert_input_key(event, &msg, im->prefer_text)) {
-        if (!controller_push_msg(controller, &msg)) {
-            LOGW("Could not request 'inject keycode'");
-        }
-    }
-}
-
-static bool
-convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
-                     struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
-        screen_convert_to_frame_coords(screen, from->x, from->y);
-    to->inject_touch_event.pressure = 1.f;
-    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);
-
-    return true;
-}
-
-void
-input_manager_process_mouse_motion(struct input_manager *im,
-                                   const SDL_MouseMotionEvent *event) {
-    if (!event->state) {
-        // do not send motion events when no button is pressed
-        return;
-    }
-    if (event->which == SDL_TOUCH_MOUSEID) {
-        // simulated from touch events, so it's a duplicate
-        return;
-    }
-    struct control_msg msg;
-    if (convert_mouse_motion(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject mouse motion event'");
-        }
-    }
-}
-
-static bool
-convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
-              struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-
-    if (!convert_touch_action(from->type, &to->inject_touch_event.action)) {
-        return false;
-    }
-
-    to->inject_touch_event.pointer_id = from->fingerId;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    // SDL touch event coordinates are normalized in the range [0; 1]
-    float x = from->x * screen->content_size.width;
-    float y = from->y * screen->content_size.height;
-    to->inject_touch_event.position.point =
-        screen_convert_to_frame_coords(screen, x, y);
-    to->inject_touch_event.pressure = from->pressure;
-    to->inject_touch_event.buttons = 0;
-    return true;
-}
-
-void
-input_manager_process_touch(struct input_manager *im,
-                            const SDL_TouchFingerEvent *event) {
-    struct control_msg msg;
-    if (convert_touch(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject touch event'");
-        }
-    }
-}
-
-static bool
-is_outside_device_screen(struct input_manager *im, int x, int y)
-{
-    return x < 0 || x >= im->screen->content_size.width ||
-           y < 0 || y >= im->screen->content_size.height;
-}
-
-static bool
-convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
-                     struct control_msg *to) {
-    to->type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT;
-
-    if (!convert_mouse_action(from->type, &to->inject_touch_event.action)) {
-        return false;
-    }
-
-    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
-        screen_convert_to_frame_coords(screen, from->x, from->y);
-    to->inject_touch_event.pressure = 1.f;
-    to->inject_touch_event.buttons =
-        convert_mouse_buttons(SDL_BUTTON(from->button));
-
-    return true;
-}
-
-void
-input_manager_process_mouse_button(struct input_manager *im,
-                                   const SDL_MouseButtonEvent *event,
-                                   bool control) {
-    if (event->which == SDL_TOUCH_MOUSEID) {
-        // simulated from touch events, so it's a duplicate
-        return;
-    }
-    if (event->type == SDL_MOUSEBUTTONDOWN) {
-        if (control && event->button == SDL_BUTTON_RIGHT) {
-            press_back_or_turn_screen_on(im->controller);
-            return;
-        }
-        if (control && event->button == SDL_BUTTON_MIDDLE) {
-            action_home(im->controller, ACTION_DOWN | ACTION_UP);
-            return;
-        }
-        // double-click on black borders resize to fit the device screen
-        if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
-            bool outside =
-                is_outside_device_screen(im, event->x, event->y);
-            if (outside) {
-                screen_resize_to_fit(im->screen);
-                return;
-            }
-        }
-        // otherwise, send the click event to the device
-    }
-
-    if (!control) {
-        return;
-    }
-
-    struct control_msg msg;
-    if (convert_mouse_button(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject mouse button event'");
-        }
-    }
-}
-
-static bool
-convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
-                    struct control_msg *to) {
-    struct position position = {
-        .screen_size = screen->frame_size,
-        .point = get_mouse_point(screen),
-    };
-
-    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
-
-    to->inject_scroll_event.position = position;
-    to->inject_scroll_event.hscroll = from->x;
-    to->inject_scroll_event.vscroll = from->y;
-
-    return true;
-}
-
-void
-input_manager_process_mouse_wheel(struct input_manager *im,
-                                  const SDL_MouseWheelEvent *event) {
-    struct control_msg msg;
-    if (convert_mouse_wheel(event, im->screen, &msg)) {
-        if (!controller_push_msg(im->controller, &msg)) {
-            LOGW("Could not request 'inject mouse wheel event'");
-        }
-    }
-}

app/src/input_manager.h

@@ -1,46 +0,0 @@
-#ifndef INPUTMANAGER_H
-#define INPUTMANAGER_H
-
-#include <stdbool.h>
-
-#include "config.h"
-#include "common.h"
-#include "controller.h"
-#include "fps_counter.h"
-#include "video_buffer.h"
-#include "screen.h"
-
-struct input_manager {
-    struct controller *controller;
-    struct video_buffer *video_buffer;
-    struct screen *screen;
-    bool prefer_text;
-};
-
-void
-input_manager_process_text_input(struct input_manager *im,
-                                 const SDL_TextInputEvent *event);
-
-void
-input_manager_process_key(struct input_manager *im,
-                          const SDL_KeyboardEvent *event,
-                          bool control);
-
-void
-input_manager_process_mouse_motion(struct input_manager *im,
-                                   const SDL_MouseMotionEvent *event);
-
-void
-input_manager_process_touch(struct input_manager *im,
-                            const SDL_TouchFingerEvent *event);
-
-void
-input_manager_process_mouse_button(struct input_manager *im,
-                                   const SDL_MouseButtonEvent *event,
-                                   bool control);
-
-void
-input_manager_process_mouse_wheel(struct input_manager *im,
-                                  const SDL_MouseWheelEvent *event);
-
-#endif

app/src/inputmanager.c

@@ -0,0 +1,277 @@
+#include "inputmanager.h"
+
+#include "convert.h"
+#include "lockutil.h"
+#include "log.h"
+
+// Convert window coordinates (as provided by SDL_GetMouseState() to renderer coordinates (as provided in SDL mouse events)
+//
+// See my question:
+// <https://stackoverflow.com/questions/49111054/how-to-get-mouse-position-on-mouse-wheel-event>
+static void convert_to_renderer_coordinates(SDL_Renderer *renderer, int *x, int *y) {
+    SDL_Rect viewport;
+    float scale_x, scale_y;
+    SDL_RenderGetViewport(renderer, &viewport);
+    SDL_RenderGetScale(renderer, &scale_x, &scale_y);
+    *x = (int) (*x / scale_x) - viewport.x;
+    *y = (int) (*y / scale_y) - viewport.y;
+}
+
+static struct point get_mouse_point(struct screen *screen) {
+    int x;
+    int y;
+    SDL_GetMouseState(&x, &y);
+    convert_to_renderer_coordinates(screen->renderer, &x, &y);
+    SDL_assert_release(x >= 0 && x < 0x10000 && y >= 0 && y < 0x10000);
+    return (struct point) {
+        .x = (Uint16) x,
+        .y = (Uint16) y,
+    };
+}
+
+static SDL_bool is_ctrl_down(void) {
+    const Uint8 *state = SDL_GetKeyboardState(NULL);
+    return state[SDL_SCANCODE_LCTRL] || state[SDL_SCANCODE_RCTRL];
+}
+
+static void send_keycode(struct controller *controller, enum android_keycode keycode, const char *name) {
+    // send DOWN event
+    struct control_event control_event;
+    control_event.type = CONTROL_EVENT_TYPE_KEYCODE;
+    control_event.keycode_event.action = AKEY_EVENT_ACTION_DOWN;
+    control_event.keycode_event.keycode = keycode;
+    control_event.keycode_event.metastate = 0;
+
+    if (!controller_push_event(controller, &control_event)) {
+        LOGW("Cannot send %s (DOWN)", name);
+        return;
+    }
+
+    // send UP event
+    control_event.keycode_event.action = AKEY_EVENT_ACTION_UP;
+    if (!controller_push_event(controller, &control_event)) {
+        LOGW("Cannot send %s (UP)", name);
+    }
+}
+
+static inline void action_home(struct controller *controller) {
+    send_keycode(controller, AKEYCODE_HOME, "HOME");
+}
+
+static inline void action_back(struct controller *controller) {
+    send_keycode(controller, AKEYCODE_BACK, "BACK");
+}
+
+static inline void action_app_switch(struct controller *controller) {
+    send_keycode(controller, AKEYCODE_APP_SWITCH, "APP_SWITCH");
+}
+
+static inline void action_power(struct controller *controller) {
+    send_keycode(controller, AKEYCODE_POWER, "POWER");
+}
+
+static inline void action_volume_up(struct controller *controller) {
+    send_keycode(controller, AKEYCODE_VOLUME_UP, "VOLUME_UP");
+}
+
+static inline void action_volume_down(struct controller *controller) {
+    send_keycode(controller, AKEYCODE_VOLUME_DOWN, "VOLUME_DOWN");
+}
+
+static inline void action_menu(struct controller *controller) {
+    send_keycode(controller, AKEYCODE_MENU, "MENU");
+}
+
+// turn the screen on if it was off, press BACK otherwise
+static void press_back_or_turn_screen_on(struct controller *controller) {
+    struct control_event control_event;
+    control_event.type = CONTROL_EVENT_TYPE_COMMAND;
+    control_event.command_event.action = CONTROL_EVENT_COMMAND_BACK_OR_SCREEN_ON;
+
+    if (!controller_push_event(controller, &control_event)) {
+        LOGW("Cannot turn screen on");
+    }
+}
+
+static void switch_fps_counter_state(struct frames *frames) {
+    mutex_lock(frames->mutex);
+    if (frames->fps_counter.started) {
+        LOGI("FPS counter stopped");
+        fps_counter_stop(&frames->fps_counter);
+    } else {
+        LOGI("FPS counter started");
+        fps_counter_start(&frames->fps_counter);
+    }
+    mutex_unlock(frames->mutex);
+}
+
+static void clipboard_paste(struct controller *controller) {
+    char *text = SDL_GetClipboardText();
+    if (!text) {
+        LOGW("Cannot get clipboard text: %s", SDL_GetError());
+        return;
+    }
+    if (!*text) {
+        // empty text
+        SDL_free(text);
+        return;
+    }
+
+    struct control_event control_event;
+    control_event.type = CONTROL_EVENT_TYPE_TEXT;
+    control_event.text_event.text = text;
+    if (!controller_push_event(controller, &control_event)) {
+        SDL_free(text);
+        LOGW("Cannot send clipboard paste event");
+    }
+}
+
+void input_manager_process_text_input(struct input_manager *input_manager,
+                                      const SDL_TextInputEvent *event) {
+    if (is_ctrl_down()) {
+        switch (event->text[0]) {
+            case '+':
+                action_volume_up(input_manager->controller);
+                break;
+            case '-':
+                action_volume_down(input_manager->controller);
+                break;
+        }
+        return;
+    }
+
+    struct control_event control_event;
+    control_event.type = CONTROL_EVENT_TYPE_TEXT;
+    control_event.text_event.text = SDL_strdup(event->text);
+    if (!control_event.text_event.text) {
+        LOGW("Cannot strdup input text");
+        return;
+    }
+    if (!controller_push_event(input_manager->controller, &control_event)) {
+        LOGW("Cannot send text event");
+    }
+}
+
+void input_manager_process_key(struct input_manager *input_manager,
+                               const SDL_KeyboardEvent *event) {
+    SDL_bool ctrl = event->keysym.mod & (KMOD_LCTRL | KMOD_RCTRL);
+
+    // capture all Ctrl events
+    if (ctrl) {
+        SDL_bool repeat = event->repeat;
+
+        // only consider keydown events, and ignore repeated events
+        if (repeat || event->type != SDL_KEYDOWN) {
+            return;
+        }
+
+        SDL_bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
+        if (shift) {
+            // currently, there is no shortcut implying SHIFT
+            return;
+        }
+
+        SDL_Keycode keycode = event->keysym.sym;
+        switch (keycode) {
+            case SDLK_h:
+                action_home(input_manager->controller);
+                return;
+            case SDLK_b: // fall-through
+            case SDLK_BACKSPACE:
+                action_back(input_manager->controller);
+                return;
+            case SDLK_s:
+                action_app_switch(input_manager->controller);
+                return;
+            case SDLK_m:
+                action_menu(input_manager->controller);
+                return;
+            case SDLK_p:
+                action_power(input_manager->controller);
+                return;
+            case SDLK_v:
+                clipboard_paste(input_manager->controller);
+                return;
+            case SDLK_f:
+                screen_switch_fullscreen(input_manager->screen);
+                return;
+            case SDLK_x:
+                screen_resize_to_fit(input_manager->screen);
+                return;
+            case SDLK_g:
+                screen_resize_to_pixel_perfect(input_manager->screen);
+                return;
+            case SDLK_i:
+                switch_fps_counter_state(input_manager->frames);
+                return;
+        }
+
+        return;
+    }
+
+    struct control_event control_event;
+    if (input_key_from_sdl_to_android(event, &control_event)) {
+        if (!controller_push_event(input_manager->controller, &control_event)) {
+            LOGW("Cannot send control event");
+        }
+    }
+}
+
+void input_manager_process_mouse_motion(struct input_manager *input_manager,
+                                        const SDL_MouseMotionEvent *event) {
+    if (!event->state) {
+        // do not send motion events when no button is pressed
+        return;
+    }
+    struct control_event control_event;
+    if (mouse_motion_from_sdl_to_android(event, input_manager->screen->frame_size, &control_event)) {
+        if (!controller_push_event(input_manager->controller, &control_event)) {
+            LOGW("Cannot send mouse motion event");
+        }
+    }
+}
+
+void input_manager_process_mouse_button(struct input_manager *input_manager,
+                                        const SDL_MouseButtonEvent *event) {
+    if (event->type == SDL_MOUSEBUTTONDOWN) {
+        if (event->button == SDL_BUTTON_RIGHT) {
+            press_back_or_turn_screen_on(input_manager->controller);
+            return;
+        }
+        if (event->button == SDL_BUTTON_MIDDLE) {
+            action_home(input_manager->controller);
+            return;
+        }
+        // double-click on black borders resize to fit the device screen
+        if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
+            SDL_bool outside_device_screen =
+                    event->x < 0 || event->x >= input_manager->screen->frame_size.width ||
+                    event->y < 0 || event->y >= input_manager->screen->frame_size.height;
+            if (outside_device_screen) {
+                screen_resize_to_fit(input_manager->screen);
+                return;
+            }
+            // otherwise, send the click event to the device
+        }
+    };
+    struct control_event control_event;
+    if (mouse_button_from_sdl_to_android(event, input_manager->screen->frame_size, &control_event)) {
+        if (!controller_push_event(input_manager->controller, &control_event)) {
+            LOGW("Cannot send mouse button event");
+        }
+    }
+}
+
+void input_manager_process_mouse_wheel(struct input_manager *input_manager,
+                                       const SDL_MouseWheelEvent *event) {
+    struct position position = {
+        .screen_size = input_manager->screen->frame_size,
+        .point = get_mouse_point(input_manager->screen),
+    };
+    struct control_event control_event;
+    if (mouse_wheel_from_sdl_to_android(event, position, &control_event)) {
+        if (!controller_push_event(input_manager->controller, &control_event)) {
+            LOGW("Cannot send mouse wheel event");
+        }
+    }
+}

app/src/inputmanager.h

@@ -0,0 +1,27 @@
+#ifndef INPUTMANAGER_H
+#define INPUTMANAGER_H
+
+#include "common.h"
+#include "controller.h"
+#include "fpscounter.h"
+#include "frames.h"
+#include "screen.h"
+
+struct input_manager {
+    struct controller *controller;
+    struct frames *frames;
+    struct screen *screen;
+};
+
+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/lockutil.c

@@ -0,0 +1,33 @@
+#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/lockutil.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

@@ -3,7 +3,6 @@
 
 #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__)

app/src/main.c

@@ -1,59 +1,268 @@
 #include "scrcpy.h"
 
-#include <stdbool.h>
+#include <getopt.h>
 #include <unistd.h>
 #include <libavformat/avformat.h>
-#define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
 #include <SDL2/SDL.h>
 
 #include "config.h"
-#include "cli.h"
+#include "log.h"
-#include "compat.h"
-#include "util/log.h"
 
-static void
+struct args {
-print_version(void) {
+    const char *serial;
-    fprintf(stderr, "scrcpy %s\n\n", SCRCPY_VERSION);
+    SDL_bool help;
+    SDL_bool version;
+    SDL_bool show_touches;
+    Uint16 port;
+    Uint16 max_size;
+    Uint32 bit_rate;
+};
 
-    fprintf(stderr, "dependencies:\n");
+static void usage(const char *arg0) {
-    fprintf(stderr, " - SDL %d.%d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION,
+    fprintf(stderr,
-                                         SDL_PATCHLEVEL);
+        "Usage: %s [options]\n"
-    fprintf(stderr, " - libavcodec %d.%d.%d\n", LIBAVCODEC_VERSION_MAJOR,
+        "\n"
-                                                LIBAVCODEC_VERSION_MINOR,
+        "Options:\n"
-                                                LIBAVCODEC_VERSION_MICRO);
+        "\n"
-    fprintf(stderr, " - libavformat %d.%d.%d\n", LIBAVFORMAT_VERSION_MAJOR,
+        "    -b, --bit-rate value\n"
-                                                 LIBAVFORMAT_VERSION_MINOR,
+        "        Encode the video at the given bit-rate, expressed in bits/s.\n"
-                                                 LIBAVFORMAT_VERSION_MICRO);
+        "        Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
-    fprintf(stderr, " - libavutil %d.%d.%d\n", LIBAVUTIL_VERSION_MAJOR,
+        "        Default is %d.\n"
-                                               LIBAVUTIL_VERSION_MINOR,
+        "\n"
-                                               LIBAVUTIL_VERSION_MICRO);
+        "    -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"
+        "    -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"
+        "    -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+'+'\n"
+        "        click on VOLUME_UP\n"
+        "\n"
+        "    Ctrl+'-'\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",
+        arg0,
+        DEFAULT_BIT_RATE,
+        DEFAULT_MAX_SIZE, DEFAULT_MAX_SIZE ? "" : " (unlimited)",
+        DEFAULT_LOCAL_PORT);
 }
 
-int
+static void print_version(void) {
-main(int argc, char *argv[]) {
+    fprintf(stderr, "scrcpy v%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[] = {
+        {"bit-rate",     required_argument, NULL, 'b'},
+        {"help",         no_argument,       NULL, 'h'},
+        {"max-size",     required_argument, NULL, 'm'},
+        {"port",         required_argument, NULL, 'p'},
+        {"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:hm:p:s:tv", long_options, NULL)) != -1) {
+        switch (c) {
+            case 'b':
+                if (!parse_bit_rate(optarg, &args->bit_rate)) {
+                    return SDL_FALSE;
+                }
+                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 's':
+                args->serial = optarg;
+                break;
+            case 't':
+                args->show_touches = 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
-
+    struct args args = {
-#ifndef NDEBUG
+        .serial = NULL,
-    SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
+        .help = SDL_FALSE,
-#endif
+        .version = SDL_FALSE,
-
+        .show_touches = SDL_FALSE,
-    struct scrcpy_cli_args args = {
+        .port = DEFAULT_LOCAL_PORT,
-        .opts = SCRCPY_OPTIONS_DEFAULT,
+        .max_size = DEFAULT_MAX_SIZE,
-        .help = false,
+        .bit_rate = DEFAULT_BIT_RATE,
-        .version = false,
     };
-
+    if (!parse_args(&args, argc, argv)) {
-    if (!scrcpy_parse_args(&args, argc, argv)) {
         return 1;
     }
 
     if (args.help) {
-        scrcpy_print_usage(argv[0]);
+        usage(argv[0]);
         return 0;
     }
 
@@ -62,25 +271,26 @@ main(int argc, char *argv[]) {
         return 0;
     }
 
-    LOGI("scrcpy " SCRCPY_VERSION " <https://github.com/Genymobile/scrcpy>");
-
-#ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
     av_register_all();
-#endif
 
     if (avformat_network_init()) {
         return 1;
     }
 
-    int res = scrcpy(&args.opts) ? 0 : 1;
+#ifdef BUILD_DEBUG
+    SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
+#endif
+
+    struct scrcpy_options options = {
+        .serial = args.serial,
+        .port = args.port,
+        .max_size = args.max_size,
+        .bit_rate = args.bit_rate,
+        .show_touches = args.show_touches,
+    };
+    int res = scrcpy(&options) ? 0 : 1;
 
     avformat_network_deinit(); // ignore failure
 
-#if defined (__WINDOWS__) && ! defined (WINDOWS_NOCONSOLE)
-    if (res != 0) {
-        fprintf(stderr, "Press any key to continue...\n");
-        getchar();
-    }
-#endif
     return res;
 }

app/src/net.c

@@ -1,9 +1,7 @@
 #include "net.h"
 
 #include <stdio.h>
-#include <SDL2/SDL_platform.h>
 
-#include "config.h"
 #include "log.h"
 
 #ifdef __WINDOWS__
@@ -20,8 +18,7 @@
   typedef struct in_addr IN_ADDR;
 #endif
 
-socket_t
+socket_t net_connect(Uint32 addr, Uint16 port) {
-net_connect(uint32_t addr, uint16_t port) {
     socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
     if (sock == INVALID_SOCKET) {
         perror("socket");
@@ -35,15 +32,13 @@ net_connect(uint32_t addr, uint16_t port) {
 
     if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
         perror("connect");
-        net_close(sock);
         return INVALID_SOCKET;
     }
 
     return sock;
 }
 
-socket_t
+socket_t net_listen(Uint32 addr, Uint16 port, int backlog) {
-net_listen(uint32_t addr, uint16_t port, int backlog) {
     socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
     if (sock == INVALID_SOCKET) {
         perror("socket");
@@ -51,8 +46,7 @@ net_listen(uint32_t addr, uint16_t port, int backlog) {
     }
 
     int reuse = 1;
-    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
+    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse, sizeof(reuse)) == -1) {
-                   sizeof(reuse)) == -1) {
         perror("setsockopt(SO_REUSEADDR)");
     }
 
@@ -63,85 +57,48 @@ net_listen(uint32_t addr, uint16_t port, int backlog) {
 
     if (bind(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
         perror("bind");
-        net_close(sock);
         return INVALID_SOCKET;
     }
 
     if (listen(sock, backlog) == SOCKET_ERROR) {
         perror("listen");
-        net_close(sock);
         return INVALID_SOCKET;
     }
 
     return sock;
 }
 
-socket_t
+socket_t net_accept(socket_t server_socket) {
-net_accept(socket_t server_socket) {
     SOCKADDR_IN csin;
     socklen_t sinsize = sizeof(csin);
     return accept(server_socket, (SOCKADDR *) &csin, &sinsize);
 }
 
-ssize_t
+ssize_t net_recv(socket_t socket, void *buf, size_t len) {
-net_recv(socket_t socket, void *buf, size_t len) {
     return recv(socket, buf, len, 0);
 }
 
-ssize_t
+ssize_t net_recv_all(socket_t socket, void *buf, size_t len) {
-net_recv_all(socket_t socket, void *buf, size_t len) {
     return recv(socket, buf, len, MSG_WAITALL);
 }
 
-ssize_t
+ssize_t net_send(socket_t socket, void *buf, size_t len) {
-net_send(socket_t socket, const void *buf, size_t len) {
     return send(socket, buf, len, 0);
 }
 
-ssize_t
+ssize_t net_send_all(socket_t socket, void *buf, size_t len) {
-net_send_all(socket_t socket, const void *buf, size_t len) {
+    ssize_t w;
-    ssize_t w = 0;
     while (len > 0) {
         w = send(socket, buf, len, 0);
         if (w == -1) {
             return -1;
         }
         len -= w;
-        buf = (char *) buf + w;
+        buf += w;
     }
     return w;
 }
 
-bool
+SDL_bool net_shutdown(socket_t socket, int how) {
-net_shutdown(socket_t socket, int how) {
     return !shutdown(socket, how);
 }
-
-bool
-net_init(void) {
-#ifdef __WINDOWS__
-    WSADATA wsa;
-    int res = WSAStartup(MAKEWORD(2, 2), &wsa) < 0;
-    if (res < 0) {
-        LOGC("WSAStartup failed with error %d", res);
-        return false;
-    }
-#endif
-    return true;
-}
-
-void
-net_cleanup(void) {
-#ifdef __WINDOWS__
-    WSACleanup();
-#endif
-}
-
-bool
-net_close(socket_t socket) {
-#ifdef __WINDOWS__
-    return !closesocket(socket);
-#else
-    return !close(socket);
-#endif
-}

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, void *buf, size_t len);
+ssize_t net_send_all(socket_t socket, 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(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 <stdbool.h>
-#include <SDL2/SDL_opengl.h>
-
-#include "config.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/receiver.c

@@ -1,107 +0,0 @@
-#include "receiver.h"
-
-#include <assert.h>
-#include <SDL2/SDL_clipboard.h>
-
-#include "config.h"
-#include "device_msg.h"
-#include "util/lock.h"
-#include "util/log.h"
-
-bool
-receiver_init(struct receiver *receiver, socket_t control_socket) {
-    if (!(receiver->mutex = SDL_CreateMutex())) {
-        return false;
-    }
-    receiver->control_socket = control_socket;
-    return true;
-}
-
-void
-receiver_destroy(struct receiver *receiver) {
-    SDL_DestroyMutex(receiver->mutex);
-}
-
-static void
-process_msg(struct device_msg *msg) {
-    switch (msg->type) {
-        case DEVICE_MSG_TYPE_CLIPBOARD:
-            LOGI("Device clipboard copied");
-            SDL_SetClipboardText(msg->clipboard.text);
-            break;
-    }
-}
-
-static ssize_t
-process_msgs(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(&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;
-
-    unsigned char buf[DEVICE_MSG_SERIALIZED_MAX_SIZE];
-    size_t head = 0;
-
-    for (;;) {
-        assert(head < DEVICE_MSG_SERIALIZED_MAX_SIZE);
-        ssize_t r = net_recv(receiver->control_socket, buf,
-                             DEVICE_MSG_SERIALIZED_MAX_SIZE - head);
-        if (r <= 0) {
-            LOGD("Receiver stopped");
-            break;
-        }
-
-        ssize_t consumed = process_msgs(buf, r);
-        if (consumed == -1) {
-            // an error occurred
-            break;
-        }
-
-        if (consumed) {
-            // shift the remaining data in the buffer
-            memmove(buf, &buf[consumed], r - consumed);
-            head = r - consumed;
-        }
-    }
-
-    return 0;
-}
-
-bool
-receiver_start(struct receiver *receiver) {
-    LOGD("Starting receiver thread");
-
-    receiver->thread = SDL_CreateThread(run_receiver, "receiver", receiver);
-    if (!receiver->thread) {
-        LOGC("Could not start receiver thread");
-        return false;
-    }
-
-    return true;
-}
-
-void
-receiver_join(struct receiver *receiver) {
-    SDL_WaitThread(receiver->thread, NULL);
-}

app/src/receiver.h

@@ -1,33 +0,0 @@
-#ifndef RECEIVER_H
-#define RECEIVER_H
-
-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
-
-#include "config.h"
-#include "util/net.h"
-
-// receive events from the device
-// managed by the controller
-struct receiver {
-    socket_t control_socket;
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-};
-
-bool
-receiver_init(struct receiver *receiver, socket_t control_socket);
-
-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,378 +0,0 @@
-#include "recorder.h"
-
-#include <assert.h>
-#include <libavutil/time.h>
-
-#include "config.h"
-#include "compat.h"
-#include "util/lock.h"
-#include "util/log.h"
-
-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
-    void *opaque = NULL;
-#endif
-    const AVOutputFormat *oformat = NULL;
-    do {
-#ifdef SCRCPY_LAVF_HAS_NEW_MUXER_ITERATOR_API
-        oformat = av_muxer_iterate(&opaque);
-#else
-        oformat = av_oformat_next(oformat);
-#endif
-        // until null or with name "mp4"
-    } while (oformat && strcmp(oformat->name, name));
-    return oformat;
-}
-
-static struct record_packet *
-record_packet_new(const AVPacket *packet) {
-    struct record_packet *rec = SDL_malloc(sizeof(*rec));
-    if (!rec) {
-        return NULL;
-    }
-
-    // av_packet_ref() does not initialize all fields in old FFmpeg versions
-    // See <https://github.com/Genymobile/scrcpy/issues/707>
-    av_init_packet(&rec->packet);
-
-    if (av_packet_ref(&rec->packet, packet)) {
-        SDL_free(rec);
-        return NULL;
-    }
-    return rec;
-}
-
-static void
-record_packet_delete(struct record_packet *rec) {
-    av_packet_unref(&rec->packet);
-    SDL_free(rec);
-}
-
-static void
-recorder_queue_clear(struct recorder_queue *queue) {
-    while (!queue_is_empty(queue)) {
-        struct record_packet *rec;
-        queue_take(queue, next, &rec);
-        record_packet_delete(rec);
-    }
-}
-
-bool
-recorder_init(struct recorder *recorder,
-              const char *filename,
-              enum recorder_format format,
-              struct size declared_frame_size) {
-    recorder->filename = SDL_strdup(filename);
-    if (!recorder->filename) {
-        LOGE("Could not strdup filename");
-        return false;
-    }
-
-    recorder->mutex = SDL_CreateMutex();
-    if (!recorder->mutex) {
-        LOGC("Could not create mutex");
-        SDL_free(recorder->filename);
-        return false;
-    }
-
-    recorder->queue_cond = SDL_CreateCond();
-    if (!recorder->queue_cond) {
-        LOGC("Could not create cond");
-        SDL_DestroyMutex(recorder->mutex);
-        SDL_free(recorder->filename);
-        return false;
-    }
-
-    queue_init(&recorder->queue);
-    recorder->stopped = false;
-    recorder->failed = false;
-    recorder->format = format;
-    recorder->declared_frame_size = declared_frame_size;
-    recorder->header_written = false;
-    recorder->previous = NULL;
-
-    return true;
-}
-
-void
-recorder_destroy(struct recorder *recorder) {
-    SDL_DestroyCond(recorder->queue_cond);
-    SDL_DestroyMutex(recorder->mutex);
-    SDL_free(recorder->filename);
-}
-
-static const char *
-recorder_get_format_name(enum recorder_format format) {
-    switch (format) {
-        case RECORDER_FORMAT_MP4: return "mp4";
-        case RECORDER_FORMAT_MKV: return "matroska";
-        default: return NULL;
-    }
-}
-
-bool
-recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
-    const char *format_name = recorder_get_format_name(recorder->format);
-    assert(format_name);
-    const AVOutputFormat *format = find_muxer(format_name);
-    if (!format) {
-        LOGE("Could not find muxer");
-        return false;
-    }
-
-    recorder->ctx = avformat_alloc_context();
-    if (!recorder->ctx) {
-        LOGE("Could not allocate output context");
-        return 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);
-
-    AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
-    if (!ostream) {
-        avformat_free_context(recorder->ctx);
-        return false;
-    }
-
-#ifdef SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_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
-
-    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
-        avformat_free_context(recorder->ctx);
-        return false;
-    }
-
-    LOGI("Recording started to %s file: %s", format_name, recorder->filename);
-
-    return true;
-}
-
-void
-recorder_close(struct recorder *recorder) {
-    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;
-    }
-    avio_close(recorder->ctx->pb);
-    avformat_free_context(recorder->ctx);
-
-    if (recorder->failed) {
-        LOGE("Recording failed to %s", recorder->filename);
-    } else {
-        const char *format_name = recorder_get_format_name(recorder->format);
-        LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
-    }
-}
-
-static bool
-recorder_write_header(struct recorder *recorder, const AVPacket *packet) {
-    AVStream *ostream = recorder->ctx->streams[0];
-
-    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
-    if (!extradata) {
-        LOGC("Could not allocate extradata");
-        return false;
-    }
-
-    // copy the first packet to the extra data
-    memcpy(extradata, packet->data, packet->size);
-
-#ifdef SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_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);
-        return false;
-    }
-
-    return true;
-}
-
-static void
-recorder_rescale_packet(struct recorder *recorder, AVPacket *packet) {
-    AVStream *ostream = recorder->ctx->streams[0];
-    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
-}
-
-bool
-recorder_write(struct 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 = 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;
-    }
-
-    recorder_rescale_packet(recorder, packet);
-    return av_write_frame(recorder->ctx, packet) >= 0;
-}
-
-static int
-run_recorder(void *data) {
-    struct recorder *recorder = data;
-
-    for (;;) {
-        mutex_lock(recorder->mutex);
-
-        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
-            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 && queue_is_empty(&recorder->queue)) {
-            mutex_unlock(recorder->mutex);
-            struct record_packet *last = recorder->previous;
-            if (last) {
-                // assign an arbitrary duration to the last packet
-                last->packet.duration = 100000;
-                bool ok = 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");
-                }
-                record_packet_delete(last);
-            }
-            break;
-        }
-
-        struct record_packet *rec;
-        queue_take(&recorder->queue, next, &rec);
-
-        mutex_unlock(recorder->mutex);
-
-        // recorder->previous is only written from this thread, no need to lock
-        struct 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 = recorder_write(recorder, &previous->packet);
-        record_packet_delete(previous);
-        if (!ok) {
-            LOGE("Could not record packet");
-
-            mutex_lock(recorder->mutex);
-            recorder->failed = true;
-            // discard pending packets
-            recorder_queue_clear(&recorder->queue);
-            mutex_unlock(recorder->mutex);
-            break;
-        }
-
-    }
-
-    LOGD("Recorder thread ended");
-
-    return 0;
-}
-
-bool
-recorder_start(struct recorder *recorder) {
-    LOGD("Starting recorder thread");
-
-    recorder->thread = SDL_CreateThread(run_recorder, "recorder", recorder);
-    if (!recorder->thread) {
-        LOGC("Could not start recorder thread");
-        return false;
-    }
-
-    return true;
-}
-
-void
-recorder_stop(struct recorder *recorder) {
-    mutex_lock(recorder->mutex);
-    recorder->stopped = true;
-    cond_signal(recorder->queue_cond);
-    mutex_unlock(recorder->mutex);
-}
-
-void
-recorder_join(struct recorder *recorder) {
-    SDL_WaitThread(recorder->thread, NULL);
-}
-
-bool
-recorder_push(struct recorder *recorder, const AVPacket *packet) {
-    mutex_lock(recorder->mutex);
-    assert(!recorder->stopped);
-
-    if (recorder->failed) {
-        // reject any new packet (this will stop the stream)
-        return false;
-    }
-
-    struct record_packet *rec = record_packet_new(packet);
-    if (!rec) {
-        LOGC("Could not allocate record packet");
-        return false;
-    }
-
-    queue_push(&recorder->queue, next, rec);
-    cond_signal(recorder->queue_cond);
-
-    mutex_unlock(recorder->mutex);
-    return true;
-}

app/src/recorder.h

@@ -1,72 +0,0 @@
-#ifndef RECORDER_H
-#define RECORDER_H
-
-#include <stdbool.h>
-#include <libavformat/avformat.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
-
-#include "config.h"
-#include "common.h"
-#include "util/queue.h"
-
-enum recorder_format {
-    RECORDER_FORMAT_AUTO,
-    RECORDER_FORMAT_MP4,
-    RECORDER_FORMAT_MKV,
-};
-
-struct record_packet {
-    AVPacket packet;
-    struct record_packet *next;
-};
-
-struct recorder_queue QUEUE(struct record_packet);
-
-struct recorder {
-    char *filename;
-    enum recorder_format format;
-    AVFormatContext *ctx;
-    struct size declared_frame_size;
-    bool header_written;
-
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *queue_cond;
-    bool stopped; // set on recorder_stop() by the stream reader
-    bool failed; // set on packet write failure
-    struct recorder_queue queue;
-
-    // we can write a packet only once we received the next one so that we can
-    // set its duration (next_pts - current_pts)
-    // "previous" is only accessed from the recorder thread, so it does not
-    // need to be protected by the mutex
-    struct record_packet *previous;
-};
-
-bool
-recorder_init(struct recorder *recorder, const char *filename,
-              enum recorder_format format, struct size declared_frame_size);
-
-void
-recorder_destroy(struct recorder *recorder);
-
-bool
-recorder_open(struct recorder *recorder, const AVCodec *input_codec);
-
-void
-recorder_close(struct recorder *recorder);
-
-bool
-recorder_start(struct recorder *recorder);
-
-void
-recorder_stop(struct recorder *recorder);
-
-void
-recorder_join(struct recorder *recorder);
-
-bool
-recorder_push(struct recorder *recorder, const AVPacket *packet);
-
-#endif

app/src/scrcpy.c

@@ -7,118 +7,34 @@
 #include <sys/time.h>
 #include <SDL2/SDL.h>
 
-#ifdef _WIN32
-# include <windows.h>
-#endif
-
-#include "config.h"
 #include "command.h"
 #include "common.h"
-#include "compat.h"
 #include "controller.h"
 #include "decoder.h"
 #include "device.h"
 #include "events.h"
-#include "file_handler.h"
+#include "frames.h"
-#include "fps_counter.h"
+#include "fpscounter.h"
-#include "input_manager.h"
+#include "inputmanager.h"
-#include "recorder.h"
+#include "log.h"
+#include "lockutil.h"
+#include "net.h"
 #include "screen.h"
 #include "server.h"
-#include "stream.h"
+#include "tinyxpm.h"
-#include "tiny_xpm.h"
-#include "video_buffer.h"
-#include "util/lock.h"
-#include "util/log.h"
-#include "util/net.h"
 
 static struct server server = SERVER_INITIALIZER;
 static struct screen screen = SCREEN_INITIALIZER;
-static struct fps_counter fps_counter;
+static struct frames frames;
-static struct video_buffer video_buffer;
-static struct stream stream;
 static struct decoder decoder;
-static struct recorder recorder;
 static struct controller controller;
-static struct file_handler file_handler;
 
 static struct input_manager input_manager = {
     .controller = &controller,
-    .video_buffer = &video_buffer,
+    .frames = &frames,
     .screen = &screen,
-    .prefer_text = false, // initialized later
 };
 
-#ifdef _WIN32
-BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
-    if (ctrl_type == CTRL_C_EVENT) {
-        SDL_Event event;
-        event.type = SDL_QUIT;
-        SDL_PushEvent(&event);
-        return TRUE;
-    }
-    return FALSE;
-}
-#endif // _WIN32
-
-// init SDL and set appropriate hints
-static bool
-sdl_init_and_configure(bool display, const char *render_driver) {
-    uint32_t flags = display ? SDL_INIT_VIDEO : SDL_INIT_EVENTS;
-    if (SDL_Init(flags)) {
-        LOGC("Could not initialize SDL: %s", SDL_GetError());
-        return false;
-    }
-
-    atexit(SDL_Quit);
-
-#ifdef _WIN32
-    // Clean up properly on Ctrl+C on Windows
-    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
-    if (!ok) {
-        LOGW("Could not set Ctrl+C handler");
-    }
-#endif // _WIN32
-
-    if (!display) {
-        return true;
-    }
-
-    if (render_driver && !SDL_SetHint(SDL_HINT_RENDER_DRIVER, render_driver)) {
-        LOGW("Could not set render driver");
-    }
-
-    // Linear filtering
-    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
-        LOGW("Could not enable linear filtering");
-    }
-
-#ifdef SCRCPY_SDL_HAS_HINT_MOUSE_FOCUS_CLICKTHROUGH
-    // Handle a click to gain focus as any other click
-    if (!SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1")) {
-        LOGW("Could not enable mouse focus clickthrough");
-    }
-#endif
-
-#ifdef SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
-    // Disable compositor bypassing on X11
-    if (!SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0")) {
-        LOGW("Could not disable X11 compositor bypass");
-    }
-#endif
-
-    // Do not minimize on focus loss
-    if (!SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0")) {
-        LOGW("Could not disable minimize on focus loss");
-    }
-
-    // Do not disable the screensaver when scrcpy is running
-    SDL_EnableScreenSaver();
-
-    return true;
-}
-
-
 #if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif
@@ -129,355 +45,186 @@ sdl_init_and_configure(bool display, const char *render_driver) {
 //
 // <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
 // <https://stackoverflow.com/a/40693139/1987178>
-static int
+static int event_watcher(void *data, SDL_Event *event) {
-event_watcher(void *data, SDL_Event *event) {
+    if (event->type == SDL_WINDOWEVENT && event->window.event == SDL_WINDOWEVENT_RESIZED) {
-    (void) data;
+        // called from another thread, not very safe, but it's a workaround!
-    if (event->type == SDL_WINDOWEVENT
-            && event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
-        // In practice, it seems to always be called from the same thread in
-        // that specific case. Anyway, it's just a workaround.
         screen_render(&screen);
     }
     return 0;
 }
 #endif
 
-static bool
+static void event_loop(void) {
-is_apk(const char *file) {
-    const char *ext = strrchr(file, '.');
-    return ext && !strcmp(ext, ".apk");
-}
-
-enum event_result {
-    EVENT_RESULT_CONTINUE,
-    EVENT_RESULT_STOPPED_BY_USER,
-    EVENT_RESULT_STOPPED_BY_EOS,
-};
-
-static enum event_result
-handle_event(SDL_Event *event, bool control) {
-    switch (event->type) {
-        case EVENT_STREAM_STOPPED:
-            LOGD("Video stream stopped");
-            return EVENT_RESULT_STOPPED_BY_EOS;
-        case SDL_QUIT:
-            LOGD("User requested to quit");
-            return EVENT_RESULT_STOPPED_BY_USER;
-        case EVENT_NEW_FRAME:
-            if (!screen.has_frame) {
-                screen.has_frame = true;
-                // this is the very first frame, show the window
-                screen_show_window(&screen);
-            }
-            if (!screen_update_frame(&screen, &video_buffer)) {
-                return EVENT_RESULT_CONTINUE;
-            }
-            break;
-        case SDL_WINDOWEVENT:
-            screen_handle_window_event(&screen, &event->window);
-            break;
-        case SDL_TEXTINPUT:
-            if (!control) {
-                break;
-            }
-            input_manager_process_text_input(&input_manager, &event->text);
-            break;
-        case SDL_KEYDOWN:
-        case SDL_KEYUP:
-            // some key events do not interact with the device, so process the
-            // event even if control is disabled
-            input_manager_process_key(&input_manager, &event->key, control);
-            break;
-        case SDL_MOUSEMOTION:
-            if (!control) {
-                break;
-            }
-            input_manager_process_mouse_motion(&input_manager, &event->motion);
-            break;
-        case SDL_MOUSEWHEEL:
-            if (!control) {
-                break;
-            }
-            input_manager_process_mouse_wheel(&input_manager, &event->wheel);
-            break;
-        case SDL_MOUSEBUTTONDOWN:
-        case SDL_MOUSEBUTTONUP:
-            // some mouse events do not interact with the device, so process
-            // the event even if control is disabled
-            input_manager_process_mouse_button(&input_manager, &event->button,
-                                               control);
-            break;
-        case SDL_FINGERMOTION:
-        case SDL_FINGERDOWN:
-        case SDL_FINGERUP:
-            input_manager_process_touch(&input_manager, &event->tfinger);
-            break;
-        case SDL_DROPFILE: {
-            if (!control) {
-                break;
-            }
-            file_handler_action_t action;
-            if (is_apk(event->drop.file)) {
-                action = ACTION_INSTALL_APK;
-            } else {
-                action = ACTION_PUSH_FILE;
-            }
-            file_handler_request(&file_handler, action, event->drop.file);
-            break;
-        }
-    }
-    return EVENT_RESULT_CONTINUE;
-}
-
-static bool
-event_loop(bool display, bool control) {
-    (void) display;
 #ifdef CONTINUOUS_RESIZING_WORKAROUND
-    if (display) {
+    SDL_AddEventWatch(event_watcher, NULL);
-        SDL_AddEventWatch(event_watcher, NULL);
-    }
 #endif
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
-        enum event_result result = handle_event(&event, control);
+        switch (event.type) {
-        switch (result) {
+            case EVENT_DECODER_STOPPED:
-            case EVENT_RESULT_STOPPED_BY_USER:
+                LOGD("Video decoder stopped");
-                return true;
+                return;
-            case EVENT_RESULT_STOPPED_BY_EOS:
+            case SDL_QUIT:
-                LOGW("Device disconnected");
+                LOGD("User requested to quit");
-                return false;
+                return;
-            case EVENT_RESULT_CONTINUE:
+            case EVENT_NEW_FRAME:
+                if (!screen.has_frame) {
+                    screen.has_frame = SDL_TRUE;
+                    // this is the very first frame, show the window
+                    screen_show_window(&screen);
+                }
+                if (!screen_update_frame(&screen, &frames)) {
+                    return;
+                }
+                break;
+            case SDL_WINDOWEVENT:
+                switch (event.window.event) {
+                    case SDL_WINDOWEVENT_EXPOSED:
+                    case SDL_WINDOWEVENT_SIZE_CHANGED:
+                        screen_render(&screen);
+                        break;
+                }
+                break;
+            case SDL_TEXTINPUT:
+                input_manager_process_text_input(&input_manager, &event.text);
+                break;
+            case SDL_KEYDOWN:
+            case SDL_KEYUP:
+                input_manager_process_key(&input_manager, &event.key);
+                break;
+            case SDL_MOUSEMOTION:
+                input_manager_process_mouse_motion(&input_manager, &event.motion);
+                break;
+            case SDL_MOUSEWHEEL:
+                input_manager_process_mouse_wheel(&input_manager, &event.wheel);
+                break;
+            case SDL_MOUSEBUTTONDOWN:
+            case SDL_MOUSEBUTTONUP:
+                input_manager_process_mouse_button(&input_manager, &event.button);
                 break;
         }
     }
-    return false;
 }
 
-static SDL_LogPriority
+static process_t set_show_touches_enabled(const char *serial, SDL_bool enabled) {
-sdl_priority_from_av_level(int level) {
+    const char *value = enabled ? "1" : "0";
-    switch (level) {
+    const char *const adb_cmd[] = {
-        case AV_LOG_PANIC:
+        "shell", "settings", "put", "system", "show_touches", value
-        case AV_LOG_FATAL:
-            return SDL_LOG_PRIORITY_CRITICAL;
-        case AV_LOG_ERROR:
-            return SDL_LOG_PRIORITY_ERROR;
-        case AV_LOG_WARNING:
-            return SDL_LOG_PRIORITY_WARN;
-        case AV_LOG_INFO:
-            return SDL_LOG_PRIORITY_INFO;
-    }
-    // do not forward others, which are too verbose
-    return 0;
-}
-
-static void
-av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
-    (void) avcl;
-    SDL_LogPriority priority = sdl_priority_from_av_level(level);
-    if (priority == 0) {
-        return;
-    }
-    char *local_fmt = SDL_malloc(strlen(fmt) + 10);
-    if (!local_fmt) {
-        LOGC("Could not allocate string");
-        return;
-    }
-    // strcpy is safe here, the destination is large enough
-    strcpy(local_fmt, "[FFmpeg] ");
-    strcpy(local_fmt + 9, fmt);
-    SDL_LogMessageV(SDL_LOG_CATEGORY_VIDEO, priority, local_fmt, vl);
-    SDL_free(local_fmt);
-}
-
-bool
-scrcpy(const struct scrcpy_options *options) {
-    bool record = !!options->record_filename;
-    struct server_params params = {
-        .crop = options->crop,
-        .port_range = options->port_range,
-        .max_size = options->max_size,
-        .bit_rate = options->bit_rate,
-        .max_fps = options->max_fps,
-        .lock_video_orientation = options->lock_video_orientation,
-        .control = options->control,
-        .display_id = options->display_id,
-        .show_touches = options->show_touches,
-        .stay_awake = options->stay_awake,
     };
-    if (!server_start(&server, options->serial, &params)) {
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
-        return false;
+}
+
+static void wait_show_touches(process_t process) {
+    // reap the process, ignore the result
+    process_check_success(process, "show_touches");
+}
+
+SDL_bool scrcpy(const struct scrcpy_options *options) {
+    if (!server_start(&server, options->serial, options->port,
+                      options->max_size, options->bit_rate)) {
+        return SDL_FALSE;
     }
 
-    bool ret = false;
+    process_t proc_show_touches;
-
+    SDL_bool show_touches_waited;
-    bool fps_counter_initialized = false;
+    if (options->show_touches) {
-    bool video_buffer_initialized = false;
+        LOGI("Enable show_touches");
-    bool file_handler_initialized = false;
+        proc_show_touches = set_show_touches_enabled(options->serial, SDL_TRUE);
-    bool recorder_initialized = false;
+        show_touches_waited = SDL_FALSE;
-    bool stream_started = false;
-    bool controller_initialized = false;
-    bool controller_started = false;
-
-    if (!sdl_init_and_configure(options->display, options->render_driver)) {
-        goto end;
     }
 
-    if (!server_connect_to(&server)) {
+    SDL_bool ret = SDL_TRUE;
-        goto end;
+
+    if (!SDL_SetHint(SDL_HINT_NO_SIGNAL_HANDLERS, "1")) {
+        LOGW("Cannot request to keep default signal handlers");
+    }
+
+    if (!sdl_init_and_configure()) {
+        ret = SDL_FALSE;
+        goto finally_destroy_server;
+    }
+
+    socket_t device_socket = server_connect_to(&server);
+    if (device_socket == INVALID_SOCKET) {
+        server_stop(&server);
+        ret = SDL_FALSE;
+        goto finally_destroy_server;
     }
 
     char device_name[DEVICE_NAME_FIELD_LENGTH];
     struct size frame_size;
 
-    // screenrecord does not send frames when the screen content does not
+    // screenrecord does not send frames when the screen content does not change
-    // change therefore, we transmit the screen size before the video stream,
+    // therefore, we transmit the screen size before the video stream, to be able
-    // to be able to init the window immediately
+    // to init the window immediately
-    if (!device_read_info(server.video_socket, device_name, &frame_size)) {
+    if (!device_read_info(device_socket, device_name, &frame_size)) {
-        goto end;
+        server_stop(&server);
+        ret = SDL_FALSE;
+        goto finally_destroy_server;
     }
 
-    struct decoder *dec = NULL;
+    if (!frames_init(&frames)) {
-    if (options->display) {
+        server_stop(&server);
-        if (!fps_counter_init(&fps_counter)) {
+        ret = SDL_FALSE;
-            goto end;
+        goto finally_destroy_server;
-        }
-        fps_counter_initialized = true;
-
-        if (!video_buffer_init(&video_buffer, &fps_counter,
-                               options->render_expired_frames)) {
-            goto end;
-        }
-        video_buffer_initialized = true;
-
-        if (options->control) {
-            if (!file_handler_init(&file_handler, server.serial,
-                                   options->push_target)) {
-                goto end;
-            }
-            file_handler_initialized = true;
-        }
-
-        decoder_init(&decoder, &video_buffer);
-        dec = &decoder;
     }
 
-    struct recorder *rec = NULL;
+    decoder_init(&decoder, &frames, device_socket);
-    if (record) {
-        if (!recorder_init(&recorder,
-                           options->record_filename,
-                           options->record_format,
-                           frame_size)) {
-            goto end;
-        }
-        rec = &recorder;
-        recorder_initialized = true;
-    }
-
-    av_log_set_callback(av_log_callback);
-
-    stream_init(&stream, server.video_socket, dec, rec);
 
     // now we consumed the header values, the socket receives the video stream
-    // start the stream
+    // start the decoder
-    if (!stream_start(&stream)) {
+    if (!decoder_start(&decoder)) {
-        goto end;
+        ret = SDL_FALSE;
-    }
+        server_stop(&server);
-    stream_started = true;
+        goto finally_destroy_frames;
-
-    if (options->display) {
-        if (options->control) {
-            if (!controller_init(&controller, server.control_socket)) {
-                goto end;
-            }
-            controller_initialized = true;
-
-            if (!controller_start(&controller)) {
-                goto end;
-            }
-            controller_started = true;
-        }
-
-        const char *window_title =
-            options->window_title ? options->window_title : device_name;
-
-        if (!screen_init_rendering(&screen, window_title, frame_size,
-                                   options->always_on_top, options->window_x,
-                                   options->window_y, options->window_width,
-                                   options->window_height,
-                                   options->window_borderless,
-                                   options->rotation, options-> mipmaps)) {
-            goto end;
-        }
-
-        if (options->turn_screen_off) {
-            struct control_msg msg;
-            msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
-            msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF;
-
-            if (!controller_push_msg(&controller, &msg)) {
-                LOGW("Could not request 'set screen power mode'");
-            }
-        }
-
-        if (options->fullscreen) {
-            screen_switch_fullscreen(&screen);
-        }
     }
 
-    input_manager.prefer_text = options->prefer_text;
+    if (!controller_init(&controller, device_socket)) {
+        ret = SDL_FALSE;
+        goto finally_stop_decoder;
+    }
 
-    ret = event_loop(options->display, options->control);
+    if (!controller_start(&controller)) {
+        ret = SDL_FALSE;
+        goto finally_destroy_controller;
+    }
+
+    if (!screen_init_rendering(&screen, device_name, frame_size)) {
+        ret = SDL_FALSE;
+        goto finally_stop_and_join_controller;
+    }
+
+    if (options->show_touches) {
+        wait_show_touches(proc_show_touches);
+        show_touches_waited = SDL_TRUE;
+    }
+
+    event_loop();
     LOGD("quit...");
 
     screen_destroy(&screen);
 
-end:
+finally_stop_and_join_controller:
-    // stop stream and controller so that they don't continue once their socket
+    controller_stop(&controller);
-    // is shutdown
+    controller_join(&controller);
-    if (stream_started) {
+finally_destroy_controller:
-        stream_stop(&stream);
+    controller_destroy(&controller);
-    }
+finally_stop_decoder:
-    if (controller_started) {
+    decoder_stop(&decoder);
-        controller_stop(&controller);
+    // stop the server before decoder_join() to wake up the decoder
-    }
-    if (file_handler_initialized) {
-        file_handler_stop(&file_handler);
-    }
-    if (fps_counter_initialized) {
-        fps_counter_interrupt(&fps_counter);
-    }
-
-    // shutdown the sockets and kill the server
     server_stop(&server);
-
+    decoder_join(&decoder);
-    // now that the sockets are shutdown, the stream and controller are
+finally_destroy_frames:
-    // interrupted, we can join them
+    frames_destroy(&frames);
-    if (stream_started) {
+finally_destroy_server:
-        stream_join(&stream);
+    if (options->show_touches) {
-    }
+        if (!show_touches_waited) {
-    if (controller_started) {
+            // wait the process which enabled "show touches"
-        controller_join(&controller);
+            wait_show_touches(proc_show_touches);
-    }
+        }
-    if (controller_initialized) {
+        LOGI("Disable show_touches");
-        controller_destroy(&controller);
+        proc_show_touches = set_show_touches_enabled(options->serial, SDL_FALSE);
-    }
+        wait_show_touches(proc_show_touches);
-
-    if (recorder_initialized) {
-        recorder_destroy(&recorder);
-    }
-
-    if (file_handler_initialized) {
-        file_handler_join(&file_handler);
-        file_handler_destroy(&file_handler);
-    }
-
-    if (video_buffer_initialized) {
-        video_buffer_destroy(&video_buffer);
-    }
-
-    if (fps_counter_initialized) {
-        fps_counter_join(&fps_counter);
-        fps_counter_destroy(&fps_counter);
     }
 
     server_destroy(&server);

app/src/scrcpy.h

@@ -1,82 +1,16 @@
 #ifndef SCRCPY_H
 #define SCRCPY_H
 
-#include <stdbool.h>
+#include <SDL2/SDL_stdinc.h>
-#include <stdint.h>
-
-#include "config.h"
-#include "common.h"
-#include "input_manager.h"
-#include "recorder.h"
 
 struct scrcpy_options {
     const char *serial;
-    const char *crop;
+    Uint16 port;
-    const char *record_filename;
+    Uint16 max_size;
-    const char *window_title;
+    Uint32 bit_rate;
-    const char *push_target;
+    SDL_bool show_touches;
-    const char *render_driver;
-    enum recorder_format record_format;
-    struct port_range port_range;
-    uint16_t max_size;
-    uint32_t bit_rate;
-    uint16_t max_fps;
-    int8_t lock_video_orientation;
-    uint8_t rotation;
-    int16_t window_x; // WINDOW_POSITION_UNDEFINED for "auto"
-    int16_t window_y; // WINDOW_POSITION_UNDEFINED for "auto"
-    uint16_t window_width;
-    uint16_t window_height;
-    uint16_t display_id;
-    bool show_touches;
-    bool fullscreen;
-    bool always_on_top;
-    bool control;
-    bool display;
-    bool turn_screen_off;
-    bool render_expired_frames;
-    bool prefer_text;
-    bool window_borderless;
-    bool mipmaps;
-    bool stay_awake;
 };
 
-#define SCRCPY_OPTIONS_DEFAULT { \
+SDL_bool scrcpy(const struct scrcpy_options *options);
-    .serial = NULL, \
-    .crop = NULL, \
-    .record_filename = NULL, \
-    .window_title = NULL, \
-    .push_target = NULL, \
-    .render_driver = NULL, \
-    .record_format = RECORDER_FORMAT_AUTO, \
-    .port_range = { \
-        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
-        .last = DEFAULT_LOCAL_PORT_RANGE_LAST, \
-    }, \
-    .max_size = DEFAULT_MAX_SIZE, \
-    .bit_rate = DEFAULT_BIT_RATE, \
-    .max_fps = 0, \
-    .lock_video_orientation = DEFAULT_LOCK_VIDEO_ORIENTATION, \
-    .rotation = 0, \
-    .window_x = WINDOW_POSITION_UNDEFINED, \
-    .window_y = WINDOW_POSITION_UNDEFINED, \
-    .window_width = 0, \
-    .window_height = 0, \
-    .display_id = 0, \
-    .show_touches = false, \
-    .fullscreen = false, \
-    .always_on_top = false, \
-    .control = true, \
-    .display = true, \
-    .turn_screen_off = false, \
-    .render_expired_frames = false, \
-    .prefer_text = false, \
-    .window_borderless = false, \
-    .mipmaps = true, \
-    .stay_awake = false, \
-}
-
-bool
-scrcpy(const struct scrcpy_options *options);
 
 #endif

app/src/screen.c

@@ -1,39 +1,43 @@
 #include "screen.h"
 
-#include <assert.h>
-#include <string.h>
 #include <SDL2/SDL.h>
+#include <string.h>
 
-#include "config.h"
-#include "common.h"
-#include "compat.h"
 #include "icon.xpm"
-#include "tiny_xpm.h"
+#include "lockutil.h"
-#include "video_buffer.h"
+#include "log.h"
-#include "util/lock.h"
+#include "tinyxpm.h"
-#include "util/log.h"
 
 #define DISPLAY_MARGINS 96
 
-static inline struct size
+SDL_bool sdl_init_and_configure(void) {
-get_rotated_size(struct size size, int rotation) {
+    if (SDL_Init(SDL_INIT_VIDEO)) {
-    struct size rotated_size;
+        LOGC("Could not initialize SDL: %s", SDL_GetError());
-    if (rotation & 1) {
+        return SDL_FALSE;
-        rotated_size.width = size.height;
-        rotated_size.height = size.width;
-    } else {
-        rotated_size.width = size.width;
-        rotated_size.height = size.height;
     }
-    return rotated_size;
+
+    atexit(SDL_Quit);
+
+    // Use the best available scale quality
+    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "2")) {
+        LOGW("Could not enable bilinear filtering");
+    }
+
+#if SDL_VERSION_ATLEAST(2, 0, 5)
+    // Handle a click to gain focus as any other click
+    if (!SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1")) {
+        LOGW("Could not enable mouse focus clickthrough");
+    }
+#endif
+
+    return SDL_TRUE;
 }
 
 // get the window size in a struct size
-static struct size
+static struct size get_native_window_size(SDL_Window *window) {
-get_window_size(const struct screen *screen) {
     int width;
     int height;
-    SDL_GetWindowSize(screen->window, &width, &height);
+    SDL_GetWindowSize(window, &width, &height);
 
     struct size size;
     size.width = width;
@@ -41,52 +45,61 @@ get_window_size(const struct screen *screen) {
     return size;
 }
 
+// get the windowed window size
+static struct size get_window_size(const struct screen *screen) {
+    if (screen->fullscreen) {
+        return screen->windowed_window_size;
+    }
+    return get_native_window_size(screen->window);
+}
+
 // set the window size to be applied when fullscreen is disabled
-static void
+static void set_window_size(struct screen *screen, struct size new_size) {
-set_window_size(struct screen *screen, struct size new_size) {
+    // setting the window size during fullscreen is implementation defined,
-    assert(!screen->fullscreen);
+    // so apply the resize only after fullscreen is disabled
-    assert(!screen->maximized);
+    if (screen->fullscreen) {
-    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
+        // SDL_SetWindowSize will be called when fullscreen will be disabled
+        screen->windowed_window_size = new_size;
+    } else {
+        SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
+    }
 }
 
 // get the preferred display bounds (i.e. the screen bounds with some margins)
-static bool
+static SDL_bool get_preferred_display_bounds(struct size *bounds) {
-get_preferred_display_bounds(struct size *bounds) {
     SDL_Rect rect;
-#ifdef SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
+#if SDL_VERSION_ATLEAST(2, 0, 5)
 # define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayUsableBounds((i), (r))
 #else
 # define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayBounds((i), (r))
 #endif
     if (GET_DISPLAY_BOUNDS(0, &rect)) {
         LOGW("Could not get display usable bounds: %s", SDL_GetError());
-        return false;
+        return SDL_FALSE;
     }
 
     bounds->width = MAX(0, rect.w - DISPLAY_MARGINS);
     bounds->height = MAX(0, rect.h - DISPLAY_MARGINS);
-    return true;
+    return SDL_TRUE;
 }
 
 // return the optimal size of the window, with the following constraints:
-//  - it attempts to keep at least one dimension of the current_size (i.e. it
+//  - it attempts to keep at least one dimension of the current_size (i.e. it crops the black borders)
-//    crops the black borders)
 //  - it keeps the aspect ratio
 //  - it scales down to make it fit in the display_size
-static struct size
+static struct size get_optimal_size(struct size current_size, struct size frame_size) {
-get_optimal_size(struct size current_size, struct size content_size) {
+    if (frame_size.width == 0 || frame_size.height == 0) {
-    if (content_size.width == 0 || content_size.height == 0) {
         // avoid division by 0
         return current_size;
     }
 
     struct size display_size;
     // 32 bits because we need to multiply two 16 bits values
-    uint32_t w;
+    Uint32 w;
-    uint32_t h;
+    Uint32 h;
 
     if (!get_preferred_display_bounds(&display_size)) {
-        // could not get display bounds, do not constraint the size
+        // cannot get display bounds, do not constraint the size
         w = current_size.width;
         h = current_size.height;
     } else {
@@ -94,211 +107,93 @@ get_optimal_size(struct size current_size, struct size content_size) {
         h = MIN(current_size.height, display_size.height);
     }
 
-    if (h == w * content_size.height / content_size.width
+    SDL_bool keep_width = frame_size.width * h > frame_size.height * w;
-     || w == h * content_size.width / content_size.height) {
-        // The size is already optimal, if we ignore rounding errors due to
-        // integer window dimensions
-        return (struct size) {w, h};
-    }
-
-    bool keep_width = content_size.width * h > content_size.height * w;
     if (keep_width) {
         // remove black borders on top and bottom
-        h = content_size.height * w / content_size.width;
+        h = frame_size.height * w / frame_size.width;
     } else {
-        // remove black borders on left and right (or none at all if it already
+        // remove black borders on left and right (or none at all if it already fits)
-        // fits)
+        w = frame_size.width * h / frame_size.height;
-        w = content_size.width * h / content_size.height;
     }
 
     // w and h must fit into 16 bits
-    assert(w < 0x10000 && h < 0x10000);
+    SDL_assert_release(w < 0x10000 && h < 0x10000);
     return (struct size) {w, h};
 }
 
 // same as get_optimal_size(), but read the current size from the window
-static inline struct size
+static inline struct size get_optimal_window_size(const struct screen *screen, struct size frame_size) {
-get_optimal_window_size(const struct screen *screen, struct size content_size) {
+    struct size current_size = get_window_size(screen);
-    struct size window_size = get_window_size(screen);
+    return get_optimal_size(current_size, frame_size);
-    return get_optimal_size(window_size, content_size);
 }
 
 // initially, there is no current size, so use the frame size as current size
-// req_width and req_height, if not 0, are the sizes requested by the user
+static inline struct size get_initial_optimal_size(struct size frame_size) {
-static inline struct size
+    return get_optimal_size(frame_size, frame_size);
-get_initial_optimal_size(struct size content_size, uint16_t req_width,
-                         uint16_t req_height) {
-    struct size window_size;
-    if (!req_width && !req_height) {
-        window_size = get_optimal_size(content_size, content_size);
-    } else {
-        if (req_width) {
-            window_size.width = req_width;
-        } else {
-            // compute from the requested height
-            window_size.width = (uint32_t) req_height * content_size.width
-                              / content_size.height;
-        }
-        if (req_height) {
-            window_size.height = req_height;
-        } else {
-            // compute from the requested width
-            window_size.height = (uint32_t) req_width * content_size.height
-                               / content_size.width;
-        }
-    }
-    return window_size;
 }
 
-void
+void screen_init(struct screen *screen) {
-screen_init(struct screen *screen) {
     *screen = (struct screen) SCREEN_INITIALIZER;
 }
 
-static inline SDL_Texture *
+static inline SDL_Texture *create_texture(SDL_Renderer *renderer, struct size frame_size) {
-create_texture(struct screen *screen) {
+    return SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
-    SDL_Renderer *renderer = screen->renderer;
+                             frame_size.width, frame_size.height);
-    struct size size = screen->frame_size;
-    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
-                                             SDL_TEXTUREACCESS_STREAMING,
-                                             size.width, size.height);
-    if (!texture) {
-        return NULL;
-    }
-
-    if (screen->mipmaps) {
-        struct sc_opengl *gl = &screen->gl;
-
-        SDL_GL_BindTexture(texture, NULL, NULL);
-
-        // Enable trilinear filtering for downscaling
-        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -.5f);
-
-        SDL_GL_UnbindTexture(texture);
-    }
-
-    return texture;
 }
 
-bool
+SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, struct size frame_size) {
-screen_init_rendering(struct screen *screen, const char *window_title,
-                      struct size frame_size, bool always_on_top,
-                      int16_t window_x, int16_t window_y, uint16_t window_width,
-                      uint16_t window_height, bool window_borderless,
-                      uint8_t rotation, bool mipmaps) {
     screen->frame_size = frame_size;
-    screen->rotation = rotation;
-    if (rotation) {
-        LOGI("Initial display rotation set to %u", rotation);
-    }
-    struct size content_size = get_rotated_size(frame_size, screen->rotation);
-    screen->content_size = content_size;
 
-    struct size window_size =
+    struct size window_size = get_initial_optimal_size(frame_size);
-        get_initial_optimal_size(content_size, window_width, window_height);
+    Uint32 window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
-    uint32_t window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
 #ifdef HIDPI_SUPPORT
     window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
 #endif
-    if (always_on_top) {
+    screen->window = SDL_CreateWindow(device_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
-#ifdef SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
+                                      window_size.width, window_size.height, window_flags);
-        window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
-#else
-        LOGW("The 'always on top' flag is not available "
-             "(compile with SDL >= 2.0.5 to enable it)");
-#endif
-    }
-    if (window_borderless) {
-        window_flags |= SDL_WINDOW_BORDERLESS;
-    }
-
-    int x = window_x != WINDOW_POSITION_UNDEFINED
-          ? window_x : (int) SDL_WINDOWPOS_UNDEFINED;
-    int y = window_y != WINDOW_POSITION_UNDEFINED
-          ? window_y : (int) SDL_WINDOWPOS_UNDEFINED;
-    screen->window = SDL_CreateWindow(window_title, x, y,
-                                      window_size.width, window_size.height,
-                                      window_flags);
     if (!screen->window) {
         LOGC("Could not create window: %s", SDL_GetError());
-        return false;
+        return SDL_FALSE;
     }
 
-    screen->renderer = SDL_CreateRenderer(screen->window, -1,
+    screen->renderer = SDL_CreateRenderer(screen->window, -1, SDL_RENDERER_ACCELERATED);
-                                          SDL_RENDERER_ACCELERATED);
     if (!screen->renderer) {
         LOGC("Could not create renderer: %s", SDL_GetError());
         screen_destroy(screen);
-        return false;
+        return SDL_FALSE;
     }
 
-    SDL_RendererInfo renderer_info;
+    if (SDL_RenderSetLogicalSize(screen->renderer, frame_size.width, frame_size.height)) {
-    int r = SDL_GetRendererInfo(screen->renderer, &renderer_info);
-    const char *renderer_name = r ? NULL : renderer_info.name;
-    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
-
-    if (SDL_RenderSetLogicalSize(screen->renderer, content_size.width,
-                                 content_size.height)) {
         LOGE("Could not set renderer logical size: %s", SDL_GetError());
         screen_destroy(screen);
-        return false;
+        return SDL_FALSE;
-    }
-
-    // starts with "opengl"
-    screen->use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (screen->use_opengl) {
-        struct sc_opengl *gl = &screen->gl;
-        sc_opengl_init(gl);
-
-        LOGI("OpenGL version: %s", gl->version);
-
-        if (mipmaps) {
-            bool supports_mipmaps =
-                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
-                                               2, 0  /* OpenGL ES 2.0+ */);
-            if (supports_mipmaps) {
-                LOGI("Trilinear filtering enabled");
-                screen->mipmaps = true;
-            } else {
-                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required)");
-            }
-        } else {
-            LOGI("Trilinear filtering disabled");
-        }
-    } else {
-        LOGW("Trilinear filtering disabled (not an OpenGL renderer)");
     }
 
     SDL_Surface *icon = read_xpm(icon_xpm);
-    if (icon) {
+    if (!icon) {
-        SDL_SetWindowIcon(screen->window, icon);
+        LOGE("Could not load icon: %s", SDL_GetError());
-        SDL_FreeSurface(icon);
+        screen_destroy(screen);
-    } else {
+        return SDL_FALSE;
-        LOGW("Could not load icon");
     }
+    SDL_SetWindowIcon(screen->window, icon);
+    SDL_FreeSurface(icon);
 
-    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width,
+    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width, frame_size.height);
-                                                  frame_size.height);
+    screen->texture = create_texture(screen->renderer, frame_size);
-    screen->texture = create_texture(screen);
     if (!screen->texture) {
         LOGC("Could not create texture: %s", SDL_GetError());
         screen_destroy(screen);
-        return false;
+        return SDL_FALSE;
     }
 
-    return true;
+    return SDL_TRUE;
 }
 
-void
+void screen_show_window(struct screen *screen) {
-screen_show_window(struct screen *screen) {
     SDL_ShowWindow(screen->window);
 }
 
-void
+void screen_destroy(struct screen *screen) {
-screen_destroy(struct screen *screen) {
     if (screen->texture) {
         SDL_DestroyTexture(screen->texture);
     }
@@ -310,280 +205,100 @@ screen_destroy(struct screen *screen) {
     }
 }
 
-static void
-resize_for_content(struct screen *screen, struct size old_content_size,
-                                                 struct size new_content_size) {
-    struct size window_size = get_window_size(screen);
-    struct size target_size = {
-        .width = (uint32_t) window_size.width * new_content_size.width
-                / old_content_size.width,
-        .height = (uint32_t) window_size.height * new_content_size.height
-                / old_content_size.height,
-    };
-    target_size = get_optimal_size(target_size, new_content_size);
-    set_window_size(screen, target_size);
-}
-
-static void
-set_content_size(struct screen *screen, struct size new_content_size) {
-    if (!screen->fullscreen && !screen->maximized) {
-        resize_for_content(screen, screen->content_size, new_content_size);
-    } else if (!screen->resize_pending) {
-        // Store the windowed size to be able to compute the optimal size once
-        // fullscreen and maximized are disabled
-        screen->windowed_content_size = screen->content_size;
-        screen->resize_pending = true;
-    }
-
-    screen->content_size = new_content_size;
-}
-
-static void
-apply_pending_resize(struct screen *screen) {
-    assert(!screen->fullscreen);
-    assert(!screen->maximized);
-    if (screen->resize_pending) {
-        resize_for_content(screen, screen->windowed_content_size,
-                                   screen->content_size);
-        screen->resize_pending = false;
-    }
-}
-
-void
-screen_set_rotation(struct screen *screen, unsigned rotation) {
-    assert(rotation < 4);
-    if (rotation == screen->rotation) {
-        return;
-    }
-
-    struct size new_content_size =
-        get_rotated_size(screen->frame_size, rotation);
-
-    if (SDL_RenderSetLogicalSize(screen->renderer,
-                                 new_content_size.width,
-                                 new_content_size.height)) {
-        LOGE("Could not set renderer logical size: %s", SDL_GetError());
-        return;
-    }
-
-    set_content_size(screen, new_content_size);
-    screen->rotation = rotation;
-    LOGI("Display rotation set to %u", rotation);
-
-    screen_render(screen);
-}
-
 // recreate the texture and resize the window if the frame size has changed
-static bool
+static SDL_bool prepare_for_frame(struct screen *screen, struct size new_frame_size) {
-prepare_for_frame(struct screen *screen, struct size new_frame_size) {
+    if (screen->frame_size.width != new_frame_size.width || screen->frame_size.height != new_frame_size.height) {
-    if (screen->frame_size.width != new_frame_size.width
+        if (SDL_RenderSetLogicalSize(screen->renderer, new_frame_size.width, new_frame_size.height)) {
-            || screen->frame_size.height != new_frame_size.height) {
-        struct size new_content_size =
-            get_rotated_size(new_frame_size, screen->rotation);
-        if (SDL_RenderSetLogicalSize(screen->renderer,
-                                     new_content_size.width,
-                                     new_content_size.height)) {
             LOGE("Could not set renderer logical size: %s", SDL_GetError());
-            return false;
+            return SDL_FALSE;
         }
 
         // frame dimension changed, destroy texture
         SDL_DestroyTexture(screen->texture);
 
-        set_content_size(screen, new_content_size);
+        struct size current_size = get_window_size(screen);
+        struct size target_size = {
+            (Uint32) current_size.width * new_frame_size.width / screen->frame_size.width,
+            (Uint32) current_size.height * new_frame_size.height / screen->frame_size.height,
+        };
+        target_size = get_optimal_size(target_size, new_frame_size);
+        set_window_size(screen, target_size);
+
         screen->frame_size = new_frame_size;
 
-        LOGI("New texture: %" PRIu16 "x%" PRIu16,
+        LOGD("New texture: %" PRIu16 "x%" PRIu16,
                      screen->frame_size.width, screen->frame_size.height);
-        screen->texture = create_texture(screen);
+        screen->texture = create_texture(screen->renderer, new_frame_size);
         if (!screen->texture) {
             LOGC("Could not create texture: %s", SDL_GetError());
-            return false;
+            return SDL_FALSE;
         }
     }
 
-    return true;
+    return SDL_TRUE;
 }
 
 // write the frame into the texture
-static void
+static void update_texture(struct screen *screen, const AVFrame *frame) {
-update_texture(struct screen *screen, const AVFrame *frame) {
     SDL_UpdateYUVTexture(screen->texture, NULL,
             frame->data[0], frame->linesize[0],
             frame->data[1], frame->linesize[1],
             frame->data[2], frame->linesize[2]);
-
-    if (screen->mipmaps) {
-        assert(screen->use_opengl);
-        SDL_GL_BindTexture(screen->texture, NULL, NULL);
-        screen->gl.GenerateMipmap(GL_TEXTURE_2D);
-        SDL_GL_UnbindTexture(screen->texture);
-    }
 }
 
-bool
+SDL_bool screen_update_frame(struct screen *screen, struct frames *frames) {
-screen_update_frame(struct screen *screen, struct video_buffer *vb) {
+    mutex_lock(frames->mutex);
-    mutex_lock(vb->mutex);
+    const AVFrame *frame = frames_consume_rendered_frame(frames);
-    const AVFrame *frame = video_buffer_consume_rendered_frame(vb);
     struct size new_frame_size = {frame->width, frame->height};
     if (!prepare_for_frame(screen, new_frame_size)) {
-        mutex_unlock(vb->mutex);
+        mutex_unlock(frames->mutex);
-        return false;
+        return SDL_FALSE;
     }
     update_texture(screen, frame);
-    mutex_unlock(vb->mutex);
+    mutex_unlock(frames->mutex);
 
     screen_render(screen);
-    return true;
+    return SDL_TRUE;
 }
 
-void
+void screen_render(struct screen *screen) {
-screen_render(struct screen *screen) {
     SDL_RenderClear(screen->renderer);
-    if (screen->rotation == 0) {
+    SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
-    } else {
-        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
-        // counterclockwise (to be consistent with --lock-video-orientation)
-        int cw_rotation = (4 - screen->rotation) % 4;
-        double angle = 90 * cw_rotation;
-
-        SDL_Rect *dstrect = NULL;
-        SDL_Rect rect;
-        if (screen->rotation & 1) {
-            struct size size = screen->content_size;
-            rect.x = (size.width - size.height) / 2;
-            rect.y = (size.height - size.width) / 2;
-            rect.w = size.height;
-            rect.h = size.width;
-            dstrect = &rect;
-        }
-
-        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
-                         angle, NULL, 0);
-    }
     SDL_RenderPresent(screen->renderer);
 }
 
-void
+void screen_switch_fullscreen(struct screen *screen) {
-screen_switch_fullscreen(struct screen *screen) {
+    if (!screen->fullscreen) {
-    uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
+        // going to fullscreen, store the current windowed window size
+        screen->windowed_window_size = get_native_window_size(screen->window);
+    }
+    Uint32 new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
     if (SDL_SetWindowFullscreen(screen->window, new_mode)) {
         LOGW("Could not switch fullscreen mode: %s", SDL_GetError());
         return;
     }
 
     screen->fullscreen = !screen->fullscreen;
-    if (!screen->fullscreen && !screen->maximized) {
+    if (!screen->fullscreen) {
-        apply_pending_resize(screen);
+        // fullscreen disabled, restore expected windowed window size
+        SDL_SetWindowSize(screen->window, screen->windowed_window_size.width, screen->windowed_window_size.height);
     }
 
     LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
     screen_render(screen);
 }
 
-void
+void screen_resize_to_fit(struct screen *screen) {
-screen_resize_to_fit(struct screen *screen) {
+    if (!screen->fullscreen) {
-    if (screen->fullscreen) {
+        struct size optimal_size = get_optimal_window_size(screen, screen->frame_size);
-        return;
+        SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
-    }
+        LOGD("Resized to optimal size");
-
-    if (screen->maximized) {
-        SDL_RestoreWindow(screen->window);
-        screen->maximized = false;
-    }
-
-    struct size optimal_size =
-        get_optimal_window_size(screen, screen->content_size);
-    SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
-    LOGD("Resized to optimal size: %ux%u", optimal_size.width,
-                                           optimal_size.height);
-}
-
-void
-screen_resize_to_pixel_perfect(struct screen *screen) {
-    if (screen->fullscreen) {
-        return;
-    }
-
-    if (screen->maximized) {
-        SDL_RestoreWindow(screen->window);
-        screen->maximized = false;
-    }
-
-    struct size content_size = screen->content_size;
-    SDL_SetWindowSize(screen->window, content_size.width, content_size.height);
-    LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
-                                            content_size.height);
-}
-
-static inline bool
-is_fullscreen(const struct screen *screen) {
-    uint32_t flags = SDL_GetWindowFlags(screen->window);
-    return !!(flags & (SDL_WINDOW_FULLSCREEN | SDL_WINDOW_FULLSCREEN_DESKTOP));
-}
-
-static void
-update_fullscreen_state(struct screen *screen) {
-    // There is no SDL event to detect fullscreen changes, so store the
-    // state in a field and compare on every "size changed" event
-    bool fullscreen = is_fullscreen(screen);
-    if (fullscreen != screen->fullscreen) {
-        // Fullscreen state have changed
-        screen->fullscreen = fullscreen;
-        if (!fullscreen && !screen->maximized) {
-            apply_pending_resize(screen);
-        }
     }
 }
 
-void
+void screen_resize_to_pixel_perfect(struct screen *screen) {
-screen_handle_window_event(struct screen *screen,
+    if (!screen->fullscreen) {
-                           const SDL_WindowEvent *event) {
+        SDL_SetWindowSize(screen->window, screen->frame_size.width, screen->frame_size.height);
-    switch (event->event) {
+        LOGD("Resized to pixel-perfect");
-        case SDL_WINDOWEVENT_EXPOSED:
-            screen_render(screen);
-            break;
-        case SDL_WINDOWEVENT_SIZE_CHANGED:
-            update_fullscreen_state(screen);
-            screen_render(screen);
-            break;
-        case SDL_WINDOWEVENT_MAXIMIZED:
-            screen->maximized = true;
-            break;
-        case SDL_WINDOWEVENT_RESTORED:
-            screen->maximized = false;
-            apply_pending_resize(screen);
-            break;
     }
 }
-
-struct point
-screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y) {
-    unsigned rotation = screen->rotation;
-    assert(rotation < 4);
-
-    int32_t w = screen->content_size.width;
-    int32_t h = screen->content_size.height;
-    struct point result;
-    switch (rotation) {
-        case 0:
-            result.x = x;
-            result.y = y;
-            break;
-        case 1:
-            result.x = h - y;
-            result.y = x;
-            break;
-        case 2:
-            result.x = w - x;
-            result.y = h - y;
-            break;
-        default:
-            assert(rotation == 3);
-            result.x = y;
-            result.y = w - x;
-            break;
-    }
-    return result;
-}

app/src/screen.h

@@ -1,120 +1,69 @@
 #ifndef SCREEN_H
 #define SCREEN_H
 
-#include <stdbool.h>
 #include <SDL2/SDL.h>
 #include <libavformat/avformat.h>
 
-#include "config.h"
 #include "common.h"
-#include "opengl.h"
+#include "frames.h"
-
-#define WINDOW_POSITION_UNDEFINED (-0x8000)
-
-struct video_buffer;
 
 struct screen {
     SDL_Window *window;
     SDL_Renderer *renderer;
     SDL_Texture *texture;
-    bool use_opengl;
-    struct sc_opengl gl;
     struct size frame_size;
-    struct size content_size; // rotated frame_size
+    //used only in fullscreen mode to know the windowed window size
-
+    struct size windowed_window_size;
-    bool resize_pending; // resize requested while fullscreen or maximized
+    SDL_bool has_frame;
-    // The content size the last time the window was not maximized or
+    SDL_bool fullscreen;
-    // fullscreen (meaningful only when resize_pending is true)
-    struct size windowed_content_size;
-
-    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
-    unsigned rotation;
-    bool has_frame;
-    bool fullscreen;
-    bool maximized;
-    bool no_window;
-    bool mipmaps;
 };
 
-#define SCREEN_INITIALIZER { \
+#define SCREEN_INITIALIZER {  \
-    .window = NULL, \
+    .window = NULL,           \
-    .renderer = NULL, \
+    .renderer = NULL,         \
-    .texture = NULL, \
+    .texture = NULL,          \
-    .use_opengl = false, \
+    .frame_size = {           \
-    .gl = {0}, \
+        .width = 0,           \
-    .frame_size = { \
+        .height = 0,          \
-        .width = 0, \
+    },                        \
-        .height = 0, \
+    .windowed_window_size = { \
-    }, \
+        .width = 0,           \
-    .content_size = { \
+        .height = 0,          \
-        .width = 0, \
+    },                        \
-        .height = 0, \
+    .has_frame = SDL_FALSE,   \
-    }, \
+    .fullscreen = SDL_FALSE,  \
-    .resize_pending = false, \
-    .windowed_content_size = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
-    .rotation = 0, \
-    .has_frame = false, \
-    .fullscreen = false, \
-    .maximized = false, \
-    .no_window = false, \
-    .mipmaps = false, \
 }
 
+// init SDL and set appropriate hints
+SDL_bool sdl_init_and_configure(void);
+
 // initialize default values
-void
+void screen_init(struct screen *screen);
-screen_init(struct screen *screen);
 
 // initialize screen, create window, renderer and texture (window is hidden)
-// window_x and window_y accept WINDOW_POSITION_UNDEFINED
+SDL_bool screen_init_rendering(struct screen *screen,
-bool
+                               const char *device_name,
-screen_init_rendering(struct screen *screen, const char *window_title,
+                               struct size frame_size);
-                      struct size frame_size, bool always_on_top,
-                      int16_t window_x, int16_t window_y, uint16_t window_width,
-                      uint16_t window_height, bool window_borderless,
-                      uint8_t rotation, bool mipmaps);
 
 // show the window
-void
+void screen_show_window(struct screen *screen);
-screen_show_window(struct screen *screen);
 
 // destroy window, renderer and texture (if any)
-void
+void screen_destroy(struct screen *screen);
-screen_destroy(struct screen *screen);
 
 // resize if necessary and write the rendered frame into the texture
-bool
+SDL_bool screen_update_frame(struct screen *screen, struct frames *frames);
-screen_update_frame(struct screen *screen, struct video_buffer *vb);
 
 // render the texture to the renderer
-void
+void screen_render(struct screen *screen);
-screen_render(struct screen *screen);
 
 // switch the fullscreen mode
-void
+void screen_switch_fullscreen(struct screen *screen);
-screen_switch_fullscreen(struct screen *screen);
 
 // resize window to optimal size (remove black borders)
-void
+void screen_resize_to_fit(struct screen *screen);
-screen_resize_to_fit(struct screen *screen);
 
 // resize window to 1:1 (pixel-perfect)
-void
+void screen_resize_to_pixel_perfect(struct screen *screen);
-screen_resize_to_pixel_perfect(struct screen *screen);
-
-// set the display rotation (0, 1, 2 or 3, x90 degrees counterclockwise)
-void
-screen_set_rotation(struct screen *screen, unsigned rotation);
-
-// react to window events
-void
-screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);
-
-// convert point from window coordinates to frame coordinates
-// x and y are expressed in pixels
-struct point
-screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y);
 
 #endif

app/src/server.c

@@ -1,292 +1,106 @@
 #include "server.h"
 
-#include <assert.h>
 #include <errno.h>
 #include <inttypes.h>
-#include <libgen.h>
+#include <stdint.h>
-#include <stdio.h>
+#include <SDL2/SDL_assert.h>
-#include <SDL2/SDL_thread.h>
 #include <SDL2/SDL_timer.h>
-#include <SDL2/SDL_platform.h>
 
 #include "config.h"
-#include "command.h"
+#include "log.h"
-#include "util/log.h"
+#include "net.h"
-#include "util/net.h"
-#include "util/str_util.h"
 
 #define SOCKET_NAME "scrcpy"
-#define SERVER_FILENAME "scrcpy-server"
 
-#define DEFAULT_SERVER_PATH PREFIX "/share/scrcpy/" SERVER_FILENAME
+#ifdef OVERRIDE_SERVER_PATH
+# define DEFAULT_SERVER_PATH OVERRIDE_SERVER_PATH
+#else
+# define DEFAULT_SERVER_PATH PREFIX PREFIXED_SERVER_PATH
+#endif
+
 #define DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"
 
-static char *
+static const char *get_server_path(void) {
-get_server_path(void) {
+    const char *server_path = getenv("SCRCPY_SERVER_PATH");
-#ifdef __WINDOWS__
-    const wchar_t *server_path_env = _wgetenv(L"SCRCPY_SERVER_PATH");
-#else
-    const char *server_path_env = getenv("SCRCPY_SERVER_PATH");
-#endif
-    if (server_path_env) {
-        // if the envvar is set, use it
-#ifdef __WINDOWS__
-        char *server_path = utf8_from_wide_char(server_path_env);
-#else
-        char *server_path = SDL_strdup(server_path_env);
-#endif
-        if (!server_path) {
-            LOGE("Could not allocate memory");
-            return NULL;
-        }
-        LOGD("Using SCRCPY_SERVER_PATH: %s", server_path);
-        return server_path;
-    }
-
-#ifndef PORTABLE
-    LOGD("Using server: " DEFAULT_SERVER_PATH);
-    char *server_path = SDL_strdup(DEFAULT_SERVER_PATH);
     if (!server_path) {
-        LOGE("Could not allocate memory");
+        server_path = DEFAULT_SERVER_PATH;
-        return NULL;
     }
-    // the absolute path is hardcoded
     return server_path;
-#else
-
-    // use scrcpy-server in the same directory as the executable
-    char *executable_path = get_executable_path();
-    if (!executable_path) {
-        LOGE("Could not get executable path, "
-             "using " SERVER_FILENAME " from current directory");
-        // not found, use current directory
-        return SERVER_FILENAME;
-    }
-    char *dir = dirname(executable_path);
-    size_t dirlen = strlen(dir);
-
-    // sizeof(SERVER_FILENAME) gives statically the size including the null byte
-    size_t len = dirlen + 1 + sizeof(SERVER_FILENAME);
-    char *server_path = SDL_malloc(len);
-    if (!server_path) {
-        LOGE("Could not alloc server path string, "
-             "using " SERVER_FILENAME " from current directory");
-        SDL_free(executable_path);
-        return SERVER_FILENAME;
-    }
-
-    memcpy(server_path, dir, dirlen);
-    server_path[dirlen] = PATH_SEPARATOR;
-    memcpy(&server_path[dirlen + 1], SERVER_FILENAME, sizeof(SERVER_FILENAME));
-    // the final null byte has been copied with SERVER_FILENAME
-
-    SDL_free(executable_path);
-
-    LOGD("Using server (portable): %s", server_path);
-    return server_path;
-#endif
 }
 
-static bool
+static SDL_bool push_server(const char *serial) {
-push_server(const char *serial) {
+    process_t process = adb_push(serial, get_server_path(), DEVICE_SERVER_PATH);
-    char *server_path = get_server_path();
-    if (!server_path) {
-        return false;
-    }
-    if (!is_regular_file(server_path)) {
-        LOGE("'%s' does not exist or is not a regular file\n", server_path);
-        SDL_free(server_path);
-        return false;
-    }
-    process_t process = adb_push(serial, server_path, DEVICE_SERVER_PATH);
-    SDL_free(server_path);
     return process_check_success(process, "adb push");
 }
 
-static bool
+static SDL_bool remove_server(const char *serial) {
-enable_tunnel_reverse(const char *serial, uint16_t local_port) {
+    process_t process = adb_remove_path(serial, DEVICE_SERVER_PATH);
+    return process_check_success(process, "adb shell rm");
+}
+
+static SDL_bool enable_tunnel_reverse(const char *serial, Uint16 local_port) {
     process_t process = adb_reverse(serial, SOCKET_NAME, local_port);
     return process_check_success(process, "adb reverse");
 }
 
-static bool
+static SDL_bool disable_tunnel_reverse(const char *serial) {
-disable_tunnel_reverse(const char *serial) {
     process_t process = adb_reverse_remove(serial, SOCKET_NAME);
     return process_check_success(process, "adb reverse --remove");
 }
 
-static bool
+static SDL_bool enable_tunnel_forward(const char *serial, Uint16 local_port) {
-enable_tunnel_forward(const char *serial, uint16_t local_port) {
     process_t process = adb_forward(serial, local_port, SOCKET_NAME);
     return process_check_success(process, "adb forward");
 }
 
-static bool
+static SDL_bool disable_tunnel_forward(const char *serial, Uint16 local_port) {
-disable_tunnel_forward(const char *serial, uint16_t local_port) {
     process_t process = adb_forward_remove(serial, local_port);
     return process_check_success(process, "adb forward --remove");
 }
 
-static bool
+static SDL_bool enable_tunnel(struct server *server) {
-disable_tunnel(struct server *server) {
+    if (enable_tunnel_reverse(server->serial, server->local_port)) {
+        return SDL_TRUE;
+    }
+
+    LOGW("'adb reverse' failed, fallback to 'adb forward'");
+    server->tunnel_forward = SDL_TRUE;
+    return enable_tunnel_forward(server->serial, server->local_port);
+}
+
+static SDL_bool disable_tunnel(struct server *server) {
     if (server->tunnel_forward) {
         return disable_tunnel_forward(server->serial, server->local_port);
     }
     return disable_tunnel_reverse(server->serial);
 }
 
-static socket_t
+static process_t execute_server(const char *serial,
-listen_on_port(uint16_t port) {
+                                Uint16 max_size, Uint32 bit_rate, SDL_bool tunnel_forward) {
+    char max_size_string[6];
+    char bit_rate_string[11];
+    sprintf(max_size_string, "%"PRIu16, max_size);
+    sprintf(bit_rate_string, "%"PRIu32, bit_rate);
+    const char *const cmd[] = {
+        "shell",
+        "CLASSPATH=/data/local/tmp/scrcpy-server.jar",
+        "app_process",
+        "/", // unused
+        "com.genymobile.scrcpy.Server",
+        max_size_string,
+        bit_rate_string,
+        tunnel_forward ? "true" : "false",
+    };
+    return adb_execute(serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
+}
+
 #define IPV4_LOCALHOST 0x7F000001
+
+static socket_t listen_on_port(Uint16 port) {
     return net_listen(IPV4_LOCALHOST, port, 1);
 }
 
-static bool
+static socket_t connect_and_read_byte(Uint16 port) {
-enable_tunnel_reverse_any_port(struct server *server,
-                               struct port_range port_range) {
-    uint16_t port = port_range.first;
-    for (;;) {
-        if (!enable_tunnel_reverse(server->serial, port)) {
-            // 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.
-        server->server_socket = listen_on_port(port);
-        if (server->server_socket != INVALID_SOCKET) {
-            // success
-            server->local_port = port;
-            return true;
-        }
-
-        // failure, disable tunnel and try another port
-        if (!disable_tunnel_reverse(server->serial)) {
-            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 server *server,
-                               struct port_range port_range) {
-    server->tunnel_forward = true;
-    uint16_t port = port_range.first;
-    for (;;) {
-        if (enable_tunnel_forward(server->serial, port)) {
-            // success
-            server->local_port = port;
-            return true;
-        }
-
-        if (port < port_range.last) {
-            LOGW("Could not forward port %" PRIu16", retrying on %" PRIu16,
-                 port, 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;
-    }
-}
-
-static bool
-enable_tunnel_any_port(struct server *server, struct port_range port_range) {
-    if (enable_tunnel_reverse_any_port(server, 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(server, port_range);
-}
-
-static process_t
-execute_server(struct server *server, const struct server_params *params) {
-    char max_size_string[6];
-    char bit_rate_string[11];
-    char max_fps_string[6];
-    char lock_video_orientation_string[3];
-    char display_id_string[6];
-    sprintf(max_size_string, "%"PRIu16, params->max_size);
-    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
-    sprintf(max_fps_string, "%"PRIu16, params->max_fps);
-    sprintf(lock_video_orientation_string, "%"PRIi8, params->lock_video_orientation);
-    sprintf(display_id_string, "%"PRIu16, params->display_id);
-    const char *const cmd[] = {
-        "shell",
-        "CLASSPATH=" DEVICE_SERVER_PATH,
-        "app_process",
-#ifdef SERVER_DEBUGGER
-# define SERVER_DEBUGGER_PORT "5005"
-# ifdef SERVER_DEBUGGER_METHOD_NEW
-        /* Android 9 and above */
-        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,server=y,address="
-# else
-        /* Android 8 and below */
-        "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
-# endif
-            SERVER_DEBUGGER_PORT,
-#endif
-        "/", // unused
-        "com.genymobile.scrcpy.Server",
-        SCRCPY_VERSION,
-        max_size_string,
-        bit_rate_string,
-        max_fps_string,
-        lock_video_orientation_string,
-        server->tunnel_forward ? "true" : "false",
-        params->crop ? params->crop : "-",
-        "true", // always send frame meta (packet boundaries + timestamp)
-        params->control ? "true" : "false",
-        display_id_string,
-        params->show_touches ? "true" : "false",
-        params->stay_awake ? "true" : "false",
-    };
-#ifdef SERVER_DEBUGGER
-    LOGI("Server debugger waiting for a client on device port "
-         SERVER_DEBUGGER_PORT "...");
-    // From the computer, run
-    //     adb forward tcp:5005 tcp:5005
-    // Then, from Android Studio: Run > Debug > Edit configurations...
-    // On the left, click on '+', "Remote", with:
-    //     Host: localhost
-    //     Port: 5005
-    // Then click on "Debug"
-#endif
-    return adb_execute(server->serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
-}
-
-static socket_t
-connect_and_read_byte(uint16_t port) {
     socket_t socket = net_connect(IPV4_LOCALHOST, port);
     if (socket == INVALID_SOCKET) {
         return INVALID_SOCKET;
@@ -295,16 +109,14 @@ connect_and_read_byte(uint16_t port) {
     char byte;
     // the connection may succeed even if the server behind the "adb tunnel"
     // is not listening, so read one byte to detect a working connection
-    if (net_recv(socket, &byte, 1) != 1) {
+    if (net_recv_all(socket, &byte, 1) != 1) {
         // the server is not listening yet behind the adb tunnel
-        net_close(socket);
         return INVALID_SOCKET;
     }
     return socket;
 }
 
-static socket_t
+static socket_t connect_to_server(Uint16 port, Uint32 attempts, Uint32 delay) {
-connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
     do {
         LOGD("Remaining connection attempts: %d", (int) attempts);
         socket_t socket = connect_and_read_byte(port);
@@ -319,165 +131,125 @@ connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
     return INVALID_SOCKET;
 }
 
-static void
+static void close_socket(socket_t *socket) {
-close_socket(socket_t socket) {
+    SDL_assert(*socket != INVALID_SOCKET);
-    assert(socket != INVALID_SOCKET);
+    net_shutdown(*socket, SHUT_RDWR);
-    net_shutdown(socket, SHUT_RDWR);
+    if (!net_close(*socket)) {
-    if (!net_close(socket)) {
+        LOGW("Cannot close socket");
-        LOGW("Could not close socket");
+        return;
     }
+    *socket = INVALID_SOCKET;
 }
 
-void
+void server_init(struct server *server) {
-server_init(struct server *server) {
     *server = (struct server) SERVER_INITIALIZER;
 }
 
-static int
+SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port,
-run_wait_server(void *data) {
+                      Uint16 max_size, Uint32 bit_rate) {
-    struct server *server = data;
+    server->local_port = local_port;
-    cmd_simple_wait(server->process, NULL); // ignore exit code
-    // no need for synchronization, server_socket is initialized before this
-    // thread was created
-    if (server->server_socket != INVALID_SOCKET
-            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
-        // On Linux, accept() is unblocked by shutdown(), but on Windows, it is
-        // unblocked by closesocket(). Therefore, call both (close_socket()).
-        close_socket(server->server_socket);
-    }
-    LOGD("Server terminated");
-    return 0;
-}
-
-bool
-server_start(struct server *server, const char *serial,
-             const struct server_params *params) {
-    server->port_range = params->port_range;
 
     if (serial) {
         server->serial = SDL_strdup(serial);
-        if (!server->serial) {
-            return false;
-        }
     }
 
     if (!push_server(serial)) {
-        goto error1;
+        return SDL_FALSE;
     }
 
-    if (!enable_tunnel_any_port(server, params->port_range)) {
+    server->server_copied_to_device = SDL_TRUE;
-        goto error1;
+
+    if (!enable_tunnel(server)) {
+        return SDL_FALSE;
+    }
+
+    // if "adb reverse" does not work (e.g. over "adb connect"), it fallbacks to
+    // "adb forward", so the app socket is the client
+    if (!server->tunnel_forward) {
+        // 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.
+
+        server->server_socket = listen_on_port(local_port);
+        if (server->server_socket == INVALID_SOCKET) {
+            LOGE("Could not listen on port %" PRIu16, local_port);
+            disable_tunnel(server);
+            return SDL_FALSE;
+        }
     }
 
     // server will connect to our server socket
-    server->process = execute_server(server, params);
+    server->process = execute_server(serial, max_size, bit_rate, server->tunnel_forward);
     if (server->process == PROCESS_NONE) {
-        goto error2;
+        if (!server->tunnel_forward) {
+            close_socket(&server->server_socket);
+        }
+        disable_tunnel(server);
+        return SDL_FALSE;
     }
 
-    // If the server process dies before connecting to the server socket, then
+    server->tunnel_enabled = SDL_TRUE;
-    // the client will be stuck forever on accept(). To avoid the problem, we
-    // must be able to wake up the accept() call when the server dies. To keep
-    // things simple and multiplatform, just spawn a new thread waiting for the
-    // server process and calling shutdown()/close() on the server socket if
-    // necessary to wake up any accept() blocking call.
-    server->wait_server_thread =
-        SDL_CreateThread(run_wait_server, "wait-server", server);
-    if (!server->wait_server_thread) {
-        cmd_terminate(server->process);
-        cmd_simple_wait(server->process, NULL); // ignore exit code
-        goto error2;
-    }
 
-    server->tunnel_enabled = true;
+    return SDL_TRUE;
-
-    return true;
-
-error2:
-    if (!server->tunnel_forward) {
-        bool was_closed =
-            atomic_flag_test_and_set(&server->server_socket_closed);
-        // the thread is not started, the flag could not be already set
-        assert(!was_closed);
-        (void) was_closed;
-        close_socket(server->server_socket);
-    }
-    disable_tunnel(server);
-error1:
-    SDL_free(server->serial);
-    return false;
 }
 
-bool
+socket_t server_connect_to(struct server *server) {
-server_connect_to(struct server *server) {
     if (!server->tunnel_forward) {
-        server->video_socket = net_accept(server->server_socket);
+        server->device_socket = net_accept(server->server_socket);
-        if (server->video_socket == INVALID_SOCKET) {
-            return false;
-        }
-
-        server->control_socket = net_accept(server->server_socket);
-        if (server->control_socket == INVALID_SOCKET) {
-            // the video_socket will be cleaned up on destroy
-            return false;
-        }
-
-        // we don't need the server socket anymore
-        if (!atomic_flag_test_and_set(&server->server_socket_closed)) {
-            // close it from here
-            close_socket(server->server_socket);
-            // otherwise, it is closed by run_wait_server()
-        }
     } else {
-        uint32_t attempts = 100;
+        Uint32 attempts = 50;
-        uint32_t delay = 100; // ms
+        Uint32 delay = 100; // ms
-        server->video_socket =
+        server->device_socket = connect_to_server(server->local_port, attempts, delay);
-            connect_to_server(server->local_port, attempts, delay);
-        if (server->video_socket == INVALID_SOCKET) {
-            return false;
-        }
-
-        // we know that the device is listening, we don't need several attempts
-        server->control_socket =
-            net_connect(IPV4_LOCALHOST, server->local_port);
-        if (server->control_socket == INVALID_SOCKET) {
-            return false;
-        }
     }
 
+    if (server->device_socket == INVALID_SOCKET) {
+        return INVALID_SOCKET;
+    }
+
+    if (!server->tunnel_forward) {
+        // we don't need the server socket anymore
+        close_socket(&server->server_socket);
+    }
+
+    // the server is started, we can clean up the jar from the temporary folder
+    remove_server(server->serial); // ignore failure
+    server->server_copied_to_device = SDL_FALSE;
+
     // we don't need the adb tunnel anymore
     disable_tunnel(server); // ignore failure
-    server->tunnel_enabled = false;
+    server->tunnel_enabled = SDL_FALSE;
 
-    return true;
+    return server->device_socket;
 }
 
-void
+void server_stop(struct server *server) {
-server_stop(struct server *server) {
+    SDL_assert(server->process != PROCESS_NONE);
-    if (server->server_socket != INVALID_SOCKET
+
-            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
+    if (!cmd_terminate(server->process)) {
-        close_socket(server->server_socket);
+        LOGW("Cannot terminate server");
-    }
-    if (server->video_socket != INVALID_SOCKET) {
-        close_socket(server->video_socket);
-    }
-    if (server->control_socket != INVALID_SOCKET) {
-        close_socket(server->control_socket);
     }
 
-    assert(server->process != PROCESS_NONE);
+    cmd_simple_wait(server->process, NULL); // ignore exit code
-
+    LOGD("Server terminated");
-    cmd_terminate(server->process);
 
     if (server->tunnel_enabled) {
         // ignore failure
         disable_tunnel(server);
     }
 
-    SDL_WaitThread(server->wait_server_thread, NULL);
+    if (server->server_copied_to_device) {
+        remove_server(server->serial); // ignore failure
+    }
 }
 
-void
+void server_destroy(struct server *server) {
-server_destroy(struct server *server) {
+    if (server->server_socket != INVALID_SOCKET) {
-    SDL_free(server->serial);
+        close_socket(&server->server_socket);
+    }
+    if (server->device_socket != INVALID_SOCKET) {
+        close_socket(&server->device_socket);
+    }
+    SDL_free((void *) server->serial);
 }

app/src/server.h

@@ -1,79 +1,45 @@
 #ifndef SERVER_H
 #define SERVER_H
 
-#include <stdatomic.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <SDL2/SDL_thread.h>
-
-#include "config.h"
 #include "command.h"
-#include "common.h"
+#include "net.h"
-#include "util/net.h"
 
 struct server {
-    char *serial;
+    const char *serial;
     process_t process;
-    SDL_Thread *wait_server_thread;
-    atomic_flag server_socket_closed;
     socket_t server_socket; // only used if !tunnel_forward
-    socket_t video_socket;
+    socket_t device_socket;
-    socket_t control_socket;
+    Uint16 local_port;
-    struct port_range port_range;
+    SDL_bool tunnel_enabled;
-    uint16_t local_port; // selected from port_range
+    SDL_bool tunnel_forward; // use "adb forward" instead of "adb reverse"
-    bool tunnel_enabled;
+    SDL_bool server_copied_to_device;
-    bool tunnel_forward; // use "adb forward" instead of "adb reverse"
 };
 
-#define SERVER_INITIALIZER { \
+#define SERVER_INITIALIZER {              \
-    .serial = NULL, \
+    .serial = NULL,                       \
-    .process = PROCESS_NONE, \
+    .process = PROCESS_NONE,              \
-    .wait_server_thread = NULL, \
+    .server_socket = INVALID_SOCKET,      \
-    .server_socket_closed = ATOMIC_FLAG_INIT, \
+    .device_socket = INVALID_SOCKET,      \
-    .server_socket = INVALID_SOCKET, \
+    .local_port = 0,                      \
-    .video_socket = INVALID_SOCKET, \
+    .tunnel_enabled = SDL_FALSE,          \
-    .control_socket = INVALID_SOCKET, \
+    .tunnel_forward = SDL_FALSE,          \
-    .port_range = { \
+    .server_copied_to_device = SDL_FALSE, \
-        .first = 0, \
-        .last = 0, \
-    }, \
-    .local_port = 0, \
-    .tunnel_enabled = false, \
-    .tunnel_forward = false, \
 }
 
-struct server_params {
-    const char *crop;
-    struct port_range port_range;
-    uint16_t max_size;
-    uint32_t bit_rate;
-    uint16_t max_fps;
-    int8_t lock_video_orientation;
-    bool control;
-    uint16_t display_id;
-    bool show_touches;
-    bool stay_awake;
-};
-
 // init default values
-void
+void server_init(struct server *server);
-server_init(struct server *server);
 
 // push, enable tunnel et start the server
-bool
+SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port,
-server_start(struct server *server, const char *serial,
+                      Uint16 max_size, Uint32 bit_rate);
-             const struct server_params *params);
 
 // block until the communication with the server is established
-bool
+socket_t server_connect_to(struct server *server);
-server_connect_to(struct server *server);
 
 // disconnect and kill the server process
-void
+void server_stop(struct server *server);
-server_stop(struct server *server);
 
 // close and release sockets
-void
+void server_destroy(struct server *server);
-server_destroy(struct server *server);
 
 #endif

app/src/stream.c

@@ -1,302 +0,0 @@
-#include "stream.h"
-
-#include <assert.h>
-#include <libavformat/avformat.h>
-#include <libavutil/time.h>
-#include <SDL2/SDL_events.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
-#include <unistd.h>
-
-#include "config.h"
-#include "compat.h"
-#include "decoder.h"
-#include "events.h"
-#include "recorder.h"
-#include "util/buffer_util.h"
-#include "util/log.h"
-
-#define BUFSIZE 0x10000
-
-#define HEADER_SIZE 12
-#define NO_PTS UINT64_C(-1)
-
-static bool
-stream_recv_packet(struct stream *stream, 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.
-
-    uint8_t header[HEADER_SIZE];
-    ssize_t r = net_recv_all(stream->socket, header, HEADER_SIZE);
-    if (r < HEADER_SIZE) {
-        return false;
-    }
-
-    uint64_t pts = buffer_read64be(header);
-    uint32_t len = buffer_read32be(&header[8]);
-    assert(pts == NO_PTS || (pts & 0x8000000000000000) == 0);
-    assert(len);
-
-    if (av_new_packet(packet, len)) {
-        LOGE("Could not allocate packet");
-        return false;
-    }
-
-    r = net_recv_all(stream->socket, packet->data, len);
-    if (r < 0 || ((uint32_t) r) < len) {
-        av_packet_unref(packet);
-        return false;
-    }
-
-    packet->pts = pts != NO_PTS ? (int64_t) pts : AV_NOPTS_VALUE;
-
-    return true;
-}
-
-static void
-notify_stopped(void) {
-    SDL_Event stop_event;
-    stop_event.type = EVENT_STREAM_STOPPED;
-    SDL_PushEvent(&stop_event);
-}
-
-static bool
-process_config_packet(struct stream *stream, AVPacket *packet) {
-    if (stream->recorder && !recorder_push(stream->recorder, packet)) {
-        LOGE("Could not send config packet to recorder");
-        return false;
-    }
-    return true;
-}
-
-static bool
-process_frame(struct stream *stream, AVPacket *packet) {
-    if (stream->decoder && !decoder_push(stream->decoder, packet)) {
-        return false;
-    }
-
-    if (stream->recorder) {
-        packet->dts = packet->pts;
-
-        if (!recorder_push(stream->recorder, packet)) {
-            LOGE("Could not send packet to recorder");
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static bool
-stream_parse(struct stream *stream, AVPacket *packet) {
-    uint8_t *in_data = packet->data;
-    int in_len = packet->size;
-    uint8_t *out_data = NULL;
-    int out_len = 0;
-    int r = av_parser_parse2(stream->parser, stream->codec_ctx,
-                             &out_data, &out_len, in_data, in_len,
-                             AV_NOPTS_VALUE, AV_NOPTS_VALUE, -1);
-
-    // PARSER_FLAG_COMPLETE_FRAMES is set
-    assert(r == in_len);
-    (void) r;
-    assert(out_len == in_len);
-
-    if (stream->parser->key_frame == 1) {
-        packet->flags |= AV_PKT_FLAG_KEY;
-    }
-
-    bool ok = process_frame(stream, packet);
-    if (!ok) {
-        LOGE("Could not process frame");
-        return false;
-    }
-
-    return true;
-}
-
-static bool
-stream_push_packet(struct stream *stream, AVPacket *packet) {
-    bool is_config = packet->pts == AV_NOPTS_VALUE;
-
-    // A config packet must not be decoded immetiately (it contains no
-    // frame); instead, it must be concatenated with the future data packet.
-    if (stream->has_pending || is_config) {
-        size_t offset;
-        if (stream->has_pending) {
-            offset = stream->pending.size;
-            if (av_grow_packet(&stream->pending, packet->size)) {
-                LOGE("Could not grow packet");
-                return false;
-            }
-        } else {
-            offset = 0;
-            if (av_new_packet(&stream->pending, packet->size)) {
-                LOGE("Could not create packet");
-                return false;
-            }
-            stream->has_pending = true;
-        }
-
-        memcpy(stream->pending.data + offset, packet->data, packet->size);
-
-        if (!is_config) {
-            // prepare the concat packet to send to the decoder
-            stream->pending.pts = packet->pts;
-            stream->pending.dts = packet->dts;
-            stream->pending.flags = packet->flags;
-            packet = &stream->pending;
-        }
-    }
-
-    if (is_config) {
-        // config packet
-        bool ok = process_config_packet(stream, packet);
-        if (!ok) {
-            return false;
-        }
-    } else {
-        // data packet
-        bool ok = stream_parse(stream, packet);
-
-        if (stream->has_pending) {
-            // the pending packet must be discarded (consumed or error)
-            stream->has_pending = false;
-            av_packet_unref(&stream->pending);
-        }
-
-        if (!ok) {
-            return false;
-        }
-    }
-    return true;
-}
-
-static int
-run_stream(void *data) {
-    struct stream *stream = data;
-
-    AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
-    if (!codec) {
-        LOGE("H.264 decoder not found");
-        goto end;
-    }
-
-    stream->codec_ctx = avcodec_alloc_context3(codec);
-    if (!stream->codec_ctx) {
-        LOGC("Could not allocate codec context");
-        goto end;
-    }
-
-    if (stream->decoder && !decoder_open(stream->decoder, codec)) {
-        LOGE("Could not open decoder");
-        goto finally_free_codec_ctx;
-    }
-
-    if (stream->recorder) {
-        if (!recorder_open(stream->recorder, codec)) {
-            LOGE("Could not open recorder");
-            goto finally_close_decoder;
-        }
-
-        if (!recorder_start(stream->recorder)) {
-            LOGE("Could not start recorder");
-            goto finally_close_recorder;
-        }
-    }
-
-    stream->parser = av_parser_init(AV_CODEC_ID_H264);
-    if (!stream->parser) {
-        LOGE("Could not initialize parser");
-        goto finally_stop_and_join_recorder;
-    }
-
-    // We must only pass complete frames to av_parser_parse2()!
-    // It's more complicated, but this allows to reduce the latency by 1 frame!
-    stream->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
-
-    for (;;) {
-        AVPacket packet;
-        bool ok = stream_recv_packet(stream, &packet);
-        if (!ok) {
-            // end of stream
-            break;
-        }
-
-        ok = stream_push_packet(stream, &packet);
-        av_packet_unref(&packet);
-        if (!ok) {
-            // cannot process packet (error already logged)
-            break;
-        }
-    }
-
-    LOGD("End of frames");
-
-    if (stream->has_pending) {
-        av_packet_unref(&stream->pending);
-    }
-
-    av_parser_close(stream->parser);
-finally_stop_and_join_recorder:
-    if (stream->recorder) {
-        recorder_stop(stream->recorder);
-        LOGI("Finishing recording...");
-        recorder_join(stream->recorder);
-    }
-finally_close_recorder:
-    if (stream->recorder) {
-        recorder_close(stream->recorder);
-    }
-finally_close_decoder:
-    if (stream->decoder) {
-        decoder_close(stream->decoder);
-    }
-finally_free_codec_ctx:
-    avcodec_free_context(&stream->codec_ctx);
-end:
-    notify_stopped();
-    return 0;
-}
-
-void
-stream_init(struct stream *stream, socket_t socket,
-            struct decoder *decoder, struct recorder *recorder) {
-    stream->socket = socket;
-    stream->decoder = decoder,
-    stream->recorder = recorder;
-    stream->has_pending = false;
-}
-
-bool
-stream_start(struct stream *stream) {
-    LOGD("Starting stream thread");
-
-    stream->thread = SDL_CreateThread(run_stream, "stream", stream);
-    if (!stream->thread) {
-        LOGC("Could not start stream thread");
-        return false;
-    }
-    return true;
-}
-
-void
-stream_stop(struct stream *stream) {
-    if (stream->decoder) {
-        decoder_interrupt(stream->decoder);
-    }
-}
-
-void
-stream_join(struct stream *stream) {
-    SDL_WaitThread(stream->thread, NULL);
-}

app/src/stream.h

@@ -1,42 +0,0 @@
-#ifndef STREAM_H
-#define STREAM_H
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <libavformat/avformat.h>
-#include <SDL2/SDL_atomic.h>
-#include <SDL2/SDL_thread.h>
-
-#include "config.h"
-#include "util/net.h"
-
-struct video_buffer;
-
-struct stream {
-    socket_t socket;
-    struct video_buffer *video_buffer;
-    SDL_Thread *thread;
-    struct decoder *decoder;
-    struct recorder *recorder;
-    AVCodecContext *codec_ctx;
-    AVCodecParserContext *parser;
-    // successive packets may need to be concatenated, until a non-config
-    // packet is available
-    bool has_pending;
-    AVPacket pending;
-};
-
-void
-stream_init(struct stream *stream, socket_t socket,
-            struct decoder *decoder, struct recorder *recorder);
-
-bool
-stream_start(struct stream *stream);
-
-void
-stream_stop(struct stream *stream);
-
-void
-stream_join(struct stream *stream);
-
-#endif

app/src/strutil.c

@@ -0,0 +1,33 @@
+#include "strutil.h"
+
+size_t xstrncpy(char *dest, const char *src, size_t n) {
+    size_t i;
+    for (i = 0; i < n - 1 && src[i] != '\0'; ++i)
+        dest[i] = src[i];
+    if (n)
+        dest[i] = '\0';
+    return src[i] == '\0' ? i : n;
+}
+
+size_t xstrjoin(char *dst, const char *const tokens[], char sep, size_t n) {
+    const char *const *remaining = tokens;
+    const char *token = *remaining++;
+    size_t i = 0;
+    while (token) {
+        if (i) {
+            dst[i++] = sep;
+            if (i == n)
+                goto truncated;
+        }
+        size_t w = xstrncpy(dst + i, token, n - i);
+        if (w >= n - i)
+            goto truncated;
+        i += w;
+        token = *remaining++;
+    }
+    return i;
+
+truncated:
+    dst[n - 1] = '\0';
+    return n;
+}

app/src/strutil.h

@@ -0,0 +1,19 @@
+#ifndef STRUTIL_H
+#define STRUTIL_H
+
+#include <stddef.h>
+
+// like strncpy, except:
+//  - it copies at most n-1 chars
+//  - the dest string is nul-terminated
+//  - it does not write useless bytes if strlen(src) < n
+//  - it returns the number of chars actually written (max n-1) if src has
+//    been copied completely, or n if src has been truncated
+size_t xstrncpy(char *dest, const char *src, size_t n);
+
+// join tokens by sep into dst
+// returns the number of chars actually written (max n-1) if no trucation
+// occurred, or n if truncated
+size_t xstrjoin(char *dst, const char *const tokens[], char sep, size_t n);
+
+#endif

app/src/sys/unix/command.c

@@ -1,142 +1,33 @@
-// for portability
-#define _POSIX_SOURCE // for kill()
-#define _BSD_SOURCE // for readlink()
-
-// modern glibc will complain without this
-#define _DEFAULT_SOURCE
-
 #include "command.h"
 
-#include "config.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
 #include <signal.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
 #include <sys/types.h>
-#include <sys/stat.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
-#include "util/log.h"
+pid_t cmd_execute(const char *path, const char *const argv[]) {
-
+    pid_t pid = fork();
-bool
+    if (pid == -1) {
-cmd_search(const char *file) {
-    char *path = getenv("PATH");
-    if (!path)
-        return false;
-    path = strdup(path);
-    if (!path)
-        return false;
-
-    bool ret = false;
-    size_t file_len = strlen(file);
-    char *saveptr;
-    for (char *dir = strtok_r(path, ":", &saveptr); dir;
-            dir = strtok_r(NULL, ":", &saveptr)) {
-        size_t dir_len = strlen(dir);
-        char *fullpath = malloc(dir_len + file_len + 2);
-        if (!fullpath)
-            continue;
-        memcpy(fullpath, dir, dir_len);
-        fullpath[dir_len] = '/';
-        memcpy(fullpath + dir_len + 1, file, file_len + 1);
-
-        struct stat sb;
-        bool fullpath_executable = stat(fullpath, &sb) == 0 &&
-            sb.st_mode & S_IXUSR;
-        free(fullpath);
-        if (fullpath_executable) {
-            ret = true;
-            break;
-        }
-    }
-
-    free(path);
-    return ret;
-}
-
-enum process_result
-cmd_execute(const char *const argv[], pid_t *pid) {
-    int fd[2];
-
-    if (pipe(fd) == -1) {
-        perror("pipe");
-        return PROCESS_ERROR_GENERIC;
-    }
-
-    enum process_result ret = PROCESS_SUCCESS;
-
-    *pid = fork();
-    if (*pid == -1) {
         perror("fork");
-        ret = PROCESS_ERROR_GENERIC;
+        return -1;
-        goto end;
     }
-
+    if (pid == 0) {
-    if (*pid > 0) {
+        execvp(path, (char *const *)argv);
-        // parent close write side
+        perror("exec");
-        close(fd[1]);
-        fd[1] = -1;
-        // wait for EOF or receive errno from child
-        if (read(fd[0], &ret, sizeof(ret)) == -1) {
-            perror("read");
-            ret = PROCESS_ERROR_GENERIC;
-            goto end;
-        }
-    } else if (*pid == 0) {
-        // child close read side
-        close(fd[0]);
-        if (fcntl(fd[1], F_SETFD, FD_CLOEXEC) == 0) {
-            execvp(argv[0], (char *const *)argv);
-            if (errno == ENOENT) {
-                ret = PROCESS_ERROR_MISSING_BINARY;
-            } else {
-                ret = PROCESS_ERROR_GENERIC;
-            }
-            perror("exec");
-        } else {
-            perror("fcntl");
-            ret = PROCESS_ERROR_GENERIC;
-        }
-        // send ret to the parent
-        if (write(fd[1], &ret, sizeof(ret)) == -1) {
-            perror("write");
-        }
-        // close write side before exiting
-        close(fd[1]);
         _exit(1);
     }
-
+    return pid;
-end:
-    if (fd[0] != -1) {
-        close(fd[0]);
-    }
-    if (fd[1] != -1) {
-        close(fd[1]);
-    }
-    return ret;
 }
 
-bool
+SDL_bool cmd_terminate(pid_t pid) {
-cmd_terminate(pid_t pid) {
-    if (pid <= 0) {
-        LOGC("Requested to kill %d, this is an error. Please report the bug.\n",
-             (int) pid);
-        abort();
-    }
     return kill(pid, SIGTERM) != -1;
 }
 
-bool
+SDL_bool cmd_simple_wait(pid_t pid, int *exit_code) {
-cmd_simple_wait(pid_t pid, int *exit_code) {
     int status;
     int code;
     if (waitpid(pid, &status, 0) == -1 || !WIFEXITED(status)) {
-        // could not wait, or exited unexpectedly, probably by a signal
+        // cannot wait, or exited unexpectedly, probably by a signal
         code = -1;
     } else {
         code = WEXITSTATUS(status);
@@ -146,34 +37,3 @@ cmd_simple_wait(pid_t pid, int *exit_code) {
     }
     return !code;
 }
-
-char *
-get_executable_path(void) {
-// <https://stackoverflow.com/a/1024937/1987178>
-#ifdef __linux__
-    char buf[PATH_MAX + 1]; // +1 for the null byte
-    ssize_t len = readlink("/proc/self/exe", buf, PATH_MAX);
-    if (len == -1) {
-        perror("readlink");
-        return NULL;
-    }
-    buf[len] = '\0';
-    return SDL_strdup(buf);
-#else
-    // in practice, we only need this feature for portable builds, only used on
-    // Windows, so we don't care implementing it for every platform
-    // (it's useful to have a working version on Linux for debugging though)
-    return NULL;
-#endif
-}
-
-bool
-is_regular_file(const char *path) {
-    struct stat path_stat;
-
-    if (stat(path, &path_stat)) {
-        perror("stat");
-        return false;
-    }
-    return S_ISREG(path_stat.st_mode);
-}

app/src/sys/unix/net.c

@@ -0,0 +1,16 @@
+#include "net.h"
+
+# include <unistd.h>
+
+SDL_bool net_init(void) {
+    // do nothing
+    return SDL_TRUE;
+}
+
+void net_cleanup(void) {
+    // do nothing
+}
+
+SDL_bool net_close(socket_t socket) {
+    return !close(socket);
+}

app/src/sys/win/command.c

@@ -1,75 +1,40 @@
 #include "command.h"
 
-#include <sys/stat.h>
+#include "log.h"
+#include "strutil.h"
 
-#include "config.h"
+HANDLE cmd_execute(const char *path, const char *const argv[]) {
-#include "util/log.h"
+    STARTUPINFO si;
-#include "util/str_util.h"
-
-static int
-build_cmd(char *cmd, size_t len, const char *const argv[]) {
-    // Windows command-line parsing is WTF:
-    // <http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS>
-    // only make it work for this very specific program
-    // (don't handle escaping nor quotes)
-    size_t ret = xstrjoin(cmd, argv, ' ', len);
-    if (ret >= len) {
-        LOGE("Command too long (%" PRIsizet " chars)", len - 1);
-        return -1;
-    }
-    return 0;
-}
-
-enum process_result
-cmd_execute(const char *const argv[], HANDLE *handle) {
-    STARTUPINFOW si;
     PROCESS_INFORMATION pi;
     memset(&si, 0, sizeof(si));
     si.cb = sizeof(si);
 
+    // Windows command-line parsing is WTF:
+    // <http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS>
+    // only make it work for this very specific program
+    // (don't handle escaping nor quotes)
     char cmd[256];
-    if (build_cmd(cmd, sizeof(cmd), argv)) {
+    size_t ret = xstrjoin(cmd, argv, ' ', sizeof(cmd));
-        *handle = NULL;
+    if (ret >= sizeof(cmd)) {
-        return PROCESS_ERROR_GENERIC;
+        LOGE("Command too long (%" PRIsizet " chars)", sizeof(cmd) - 1);
+        return NULL;
     }
 
-    wchar_t *wide = utf8_to_wide_char(cmd);
+    if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) {
-    if (!wide) {
+        return NULL;
-        LOGC("Could not allocate wide char string");
-        return PROCESS_ERROR_GENERIC;
     }
 
-#ifdef WINDOWS_NOCONSOLE
+    return pi.hProcess;
-    int flags = CREATE_NO_WINDOW;
-#else
-    int flags = 0;
-#endif
-    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, flags, NULL, NULL, &si,
-                        &pi)) {
-        SDL_free(wide);
-        *handle = NULL;
-        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
-            return PROCESS_ERROR_MISSING_BINARY;
-        }
-        return PROCESS_ERROR_GENERIC;
-    }
-
-    SDL_free(wide);
-    *handle = pi.hProcess;
-    return PROCESS_SUCCESS;
 }
 
-bool
+SDL_bool cmd_terminate(HANDLE handle) {
-cmd_terminate(HANDLE handle) {
     return TerminateProcess(handle, 1) && CloseHandle(handle);
 }
 
-bool
+SDL_bool cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
-cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
     DWORD code;
-    if (WaitForSingleObject(handle, INFINITE) != WAIT_OBJECT_0
+    if (WaitForSingleObject(handle, INFINITE) != WAIT_OBJECT_0 || !GetExitCodeProcess(handle, &code)) {
-            || !GetExitCodeProcess(handle, &code)) {
+        // cannot wait or retrieve the exit code
-        // could not wait or retrieve the exit code
         code = -1; // max value, it's unsigned
     }
     if (exit_code) {
@@ -77,37 +42,3 @@ cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
     }
     return !code;
 }
-
-char *
-get_executable_path(void) {
-    HMODULE hModule = GetModuleHandleW(NULL);
-    if (!hModule) {
-        return NULL;
-    }
-    WCHAR buf[MAX_PATH + 1]; // +1 for the null byte
-    int len = GetModuleFileNameW(hModule, buf, MAX_PATH);
-    if (!len) {
-        return NULL;
-    }
-    buf[len] = '\0';
-    return utf8_from_wide_char(buf);
-}
-
-bool
-is_regular_file(const char *path) {
-    wchar_t *wide_path = utf8_to_wide_char(path);
-    if (!wide_path) {
-        LOGC("Could not allocate wide char string");
-        return false;
-    }
-
-    struct _stat path_stat;
-    int r = _wstat(wide_path, &path_stat);
-    SDL_free(wide_path);
-
-    if (r) {
-        perror("stat");
-        return false;
-    }
-    return S_ISREG(path_stat.st_mode);
-}

app/src/sys/win/net.c

@@ -0,0 +1,21 @@
+#include "net.h"
+
+#include "log.h"
+
+SDL_bool net_init(void) {
+    WSADATA wsa;
+    int res = WSAStartup(MAKEWORD(2, 2), &wsa) < 0;
+    if (res < 0) {
+        LOGC("WSAStartup failed with error %d", res);
+        return SDL_FALSE;
+    }
+    return SDL_TRUE;
+}
+
+void net_cleanup(void) {
+    WSACleanup();
+}
+
+SDL_bool net_close(socket_t socket) {
+    return !closesocket(socket);
+}

app/src/tinyxpm.c

@@ -1,30 +1,25 @@
-#include "tiny_xpm.h"
+#include "tinyxpm.h"
 
-#include <assert.h>
-#include <stdbool.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "config.h"
+#include "log.h"
-#include "util/log.h"
 
 struct index {
     char c;
-    uint32_t color;
+    Uint32 color;
 };
 
-static bool
+static SDL_bool find_color(struct index *index, int len, char c, Uint32 *color) {
-find_color(struct index *index, int len, char c, uint32_t *color) {
     // there are typically very few color, so it's ok to iterate over the array
     for (int i = 0; i < len; ++i) {
         if (index[i].c == c) {
             *color = index[i].color;
-            return true;
+            return SDL_TRUE;
         }
     }
     *color = 0;
-    return false;
+    return SDL_FALSE;
 }
 
 // We encounter some problems with SDL2_image on MSYS2 (Windows),
@@ -35,9 +30,8 @@ find_color(struct index *index, int len, char c, uint32_t *color) {
 //
 // Parameter is not "const char *" because XPM formats are generally stored in a
 // (non-const) "char *"
-SDL_Surface *
+SDL_Surface *read_xpm(char *xpm[]) {
-read_xpm(char *xpm[]) {
+#if SDL_ASSERT_LEVEL >= 2
-#ifndef NDEBUG
     // patch the XPM to change the icon color in debug mode
     xpm[2] = ".	c #CC00CC";
 #endif
@@ -46,38 +40,36 @@ read_xpm(char *xpm[]) {
     // *** No error handling, assume the XPM source is valid ***
     // (it's in our source repo)
     // Assertions are only checked in debug
-    int width = strtol(xpm[0], &endptr, 10);
+    Uint32 width = strtol(xpm[0], &endptr, 10);
-    int height = strtol(endptr + 1, &endptr, 10);
+    Uint32 height = strtol(endptr + 1, &endptr, 10);
-    int colors = strtol(endptr + 1, &endptr, 10);
+    Uint32 colors = strtol(endptr + 1, &endptr, 10);
-    int chars = strtol(endptr + 1, &endptr, 10);
+    Uint32 chars = strtol(endptr + 1, &endptr, 10);
 
     // sanity checks
-    assert(0 <= width && width < 256);
+    SDL_assert(width < 256);
-    assert(0 <= height && height < 256);
+    SDL_assert(height < 256);
-    assert(0 <= colors && colors < 256);
+    SDL_assert(colors < 256);
-    assert(chars == 1); // this implementation does not support more
+    SDL_assert(chars == 1); // this implementation does not support more
-
-    (void) chars;
 
     // init index
     struct index index[colors];
     for (int i = 0; i < colors; ++i) {
         const char *line = xpm[1+i];
         index[i].c = line[0];
-        assert(line[1] == '\t');
+        SDL_assert(line[1] == '\t');
-        assert(line[2] == 'c');
+        SDL_assert(line[2] == 'c');
-        assert(line[3] == ' ');
+        SDL_assert(line[3] == ' ');
         if (line[4] == '#') {
             index[i].color = 0xff000000 | strtol(&line[5], &endptr, 0x10);
-            assert(*endptr == '\0');
+            SDL_assert(*endptr == '\0');
         } else {
-            assert(!strcmp("None", &line[4]));
+            SDL_assert(!strcmp("None", &line[4]));
             index[i].color = 0;
         }
     }
 
     // parse image
-    uint32_t *pixels = SDL_malloc(4 * width * height);
+    Uint32 *pixels = SDL_malloc(4 * width * height);
     if (!pixels) {
         LOGE("Could not allocate icon memory");
         return NULL;
@@ -86,34 +78,29 @@ read_xpm(char *xpm[]) {
         const char *line = xpm[1 + colors + y];
         for (int x = 0; x < width; ++x) {
             char c = line[x];
-            uint32_t color;
+            Uint32 color;
-            bool color_found = find_color(index, colors, c, &color);
+            SDL_bool color_found = find_color(index, colors, c, &color);
-            assert(color_found);
+            SDL_assert(color_found);
-            (void) color_found;
             pixels[y * width + x] = color;
         }
     }
 
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    uint32_t amask = 0x000000ff;
+    Uint32 amask = 0x000000ff;
-    uint32_t rmask = 0x0000ff00;
+    Uint32 rmask = 0x0000ff00;
-    uint32_t gmask = 0x00ff0000;
+    Uint32 gmask = 0x00ff0000;
-    uint32_t bmask = 0xff000000;
+    Uint32 bmask = 0xff000000;
 #else // little endian, like x86
-    uint32_t amask = 0xff000000;
+    Uint32 amask = 0xff000000;
-    uint32_t rmask = 0x00ff0000;
+    Uint32 rmask = 0x00ff0000;
-    uint32_t gmask = 0x0000ff00;
+    Uint32 gmask = 0x0000ff00;
-    uint32_t bmask = 0x000000ff;
+    Uint32 bmask = 0x000000ff;
 #endif
 
     SDL_Surface *surface = SDL_CreateRGBSurfaceFrom(pixels,
                                                     width, height,
                                                     32, 4 * width,
                                                     rmask, gmask, bmask, amask);
-    if (!surface) {
-        LOGE("Could not create icon surface");
-        return NULL;
-    }
     // make the surface own the raw pixels
     surface->flags &= ~SDL_PREALLOC;
     return surface;

app/src/tinyxpm.h

@@ -3,9 +3,6 @@
 
 #include <SDL2/SDL.h>
 
-#include "config.h"
+SDL_Surface *read_xpm(char *xpm[]);
-
-SDL_Surface *
-read_xpm(char *xpm[]);
 
 #endif

app/src/util/buffer_util.h

@@ -1,46 +0,0 @@
-#ifndef BUFFER_UTIL_H
-#define BUFFER_UTIL_H
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "config.h"
-
-static inline void
-buffer_write16be(uint8_t *buf, uint16_t value) {
-    buf[0] = value >> 8;
-    buf[1] = value;
-}
-
-static inline void
-buffer_write32be(uint8_t *buf, uint32_t value) {
-    buf[0] = value >> 24;
-    buf[1] = value >> 16;
-    buf[2] = value >> 8;
-    buf[3] = value;
-}
-
-static inline void
-buffer_write64be(uint8_t *buf, uint64_t value) {
-    buffer_write32be(buf, value >> 32);
-    buffer_write32be(&buf[4], (uint32_t) value);
-}
-
-static inline uint16_t
-buffer_read16be(const uint8_t *buf) {
-    return (buf[0] << 8) | buf[1];
-}
-
-static inline uint32_t
-buffer_read32be(const uint8_t *buf) {
-    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
-}
-
-static inline uint64_t
-buffer_read64be(const uint8_t *buf) {
-    uint32_t msb = buffer_read32be(buf);
-    uint32_t lsb = buffer_read32be(&buf[4]);
-    return ((uint64_t) msb << 32) | lsb;
-}
-
-#endif

app/src/util/cbuf.h

@@ -1,52 +0,0 @@
-// generic circular buffer (bounded queue) implementation
-#ifndef CBUF_H
-#define CBUF_H
-
-#include <stdbool.h>
-#include <unistd.h>
-
-#include "config.h"
-
-// To define a circular buffer type of 20 ints:
-//     struct cbuf_int CBUF(int, 20);
-//
-// data has length CAP + 1 to distinguish empty vs full.
-#define CBUF(TYPE, CAP) { \
-    TYPE data[(CAP) + 1]; \
-    size_t head; \
-    size_t tail; \
-}
-
-#define cbuf_size_(PCBUF) \
-    (sizeof((PCBUF)->data) / sizeof(*(PCBUF)->data))
-
-#define cbuf_is_empty(PCBUF) \
-    ((PCBUF)->head == (PCBUF)->tail)
-
-#define cbuf_is_full(PCBUF) \
-    (((PCBUF)->head + 1) % cbuf_size_(PCBUF) == (PCBUF)->tail)
-
-#define cbuf_init(PCBUF) \
-    (void) ((PCBUF)->head = (PCBUF)->tail = 0)
-
-#define cbuf_push(PCBUF, ITEM) \
-    ({ \
-        bool ok = !cbuf_is_full(PCBUF); \
-        if (ok) { \
-            (PCBUF)->data[(PCBUF)->head] = (ITEM); \
-            (PCBUF)->head = ((PCBUF)->head + 1) % cbuf_size_(PCBUF); \
-        } \
-        ok; \
-    })
-
-#define cbuf_take(PCBUF, PITEM) \
-    ({ \
-        bool ok = !cbuf_is_empty(PCBUF); \
-        if (ok) { \
-            *(PITEM) = (PCBUF)->data[(PCBUF)->tail]; \
-            (PCBUF)->tail = ((PCBUF)->tail + 1) % cbuf_size_(PCBUF); \
-        } \
-        ok; \
-    })
-
-#endif

app/src/util/lock.h

@@ -1,74 +0,0 @@
-#ifndef LOCK_H
-#define LOCK_H
-
-#include <stdint.h>
-#include <SDL2/SDL_mutex.h>
-
-#include "config.h"
-#include "log.h"
-
-static inline void
-mutex_lock(SDL_mutex *mutex) {
-    int r = SDL_LockMutex(mutex);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not lock mutex: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-static inline void
-mutex_unlock(SDL_mutex *mutex) {
-    int r = SDL_UnlockMutex(mutex);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not unlock mutex: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-static inline void
-cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
-    int r = SDL_CondWait(cond, mutex);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not wait on condition: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-static inline int
-cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
-    int r = SDL_CondWaitTimeout(cond, mutex, ms);
-#ifndef NDEBUG
-    if (r < 0) {
-        LOGC("Could not wait on condition with timeout: %s", SDL_GetError());
-        abort();
-    }
-#endif
-    return r;
-}
-
-static inline void
-cond_signal(SDL_cond *cond) {
-    int r = SDL_CondSignal(cond);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not signal a condition: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-#endif

app/src/util/net.h

@@ -1,57 +0,0 @@
-#ifndef NET_H
-#define NET_H
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <SDL2/SDL_platform.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
-
-#include "config.h"
-
-bool
-net_init(void);
-
-void
-net_cleanup(void);
-
-socket_t
-net_connect(uint32_t addr, uint16_t port);
-
-socket_t
-net_listen(uint32_t addr, uint16_t 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)
-bool
-net_shutdown(socket_t socket, int how);
-
-bool
-net_close(socket_t socket);
-
-#endif

app/src/util/queue.h

@@ -1,77 +0,0 @@
-// generic intrusive FIFO queue
-#ifndef QUEUE_H
-#define QUEUE_H
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stddef.h>
-
-#include "config.h"
-
-// To define a queue type of "struct foo":
-//    struct queue_foo QUEUE(struct foo);
-#define QUEUE(TYPE) { \
-    TYPE *first; \
-    TYPE *last; \
-}
-
-#define queue_init(PQ) \
-    (void) ((PQ)->first = (PQ)->last = NULL)
-
-#define queue_is_empty(PQ) \
-    !(PQ)->first
-
-// NEXTFIELD is the field in the ITEM type used for intrusive linked-list
-//
-// For example:
-//    struct foo {
-//        int value;
-//        struct foo *next;
-//    };
-//
-//    // define the type "struct my_queue"
-//    struct my_queue QUEUE(struct foo);
-//
-//    struct my_queue queue;
-//    queue_init(&queue);
-//
-//    struct foo v1 = { .value = 42 };
-//    struct foo v2 = { .value = 27 };
-//
-//    queue_push(&queue, next, v1);
-//    queue_push(&queue, next, v2);
-//
-//    struct foo *foo;
-//    queue_take(&queue, next, &foo);
-//    assert(foo->value == 42);
-//    queue_take(&queue, next, &foo);
-//    assert(foo->value == 27);
-//    assert(queue_is_empty(&queue));
-//
-
-// push a new item into the queue
-#define queue_push(PQ, NEXTFIELD, ITEM) \
-    (void) ({ \
-        (ITEM)->NEXTFIELD = NULL; \
-        if (queue_is_empty(PQ)) { \
-            (PQ)->first = (PQ)->last = (ITEM); \
-        } else { \
-            (PQ)->last->NEXTFIELD = (ITEM); \
-            (PQ)->last = (ITEM); \
-        } \
-    })
-
-// take the next item and remove it from the queue (the queue must not be empty)
-// the result is stored in *(PITEM)
-// (without typeof(), we could not store a local variable having the correct
-// type so that we can "return" it)
-#define queue_take(PQ, NEXTFIELD, PITEM) \
-    (void) ({ \
-        assert(!queue_is_empty(PQ)); \
-        *(PITEM) = (PQ)->first; \
-        (PQ)->first = (PQ)->first->NEXTFIELD; \
-    })
-    // no need to update (PQ)->last if the queue is left empty:
-    // (PQ)->last is undefined if !(PQ)->first anyway
-
-#endif

app/src/util/str_util.c

@@ -1,197 +0,0 @@
-#include "str_util.h"
-
-#include <errno.h>
-#include <limits.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef _WIN32
-# include <windows.h>
-# include <tchar.h>
-#endif
-
-#include <SDL2/SDL_stdinc.h>
-
-#include "config.h"
-
-size_t
-xstrncpy(char *dest, const char *src, size_t n) {
-    size_t i;
-    for (i = 0; i < n - 1 && src[i] != '\0'; ++i)
-        dest[i] = src[i];
-    if (n)
-        dest[i] = '\0';
-    return src[i] == '\0' ? i : n;
-}
-
-size_t
-xstrjoin(char *dst, const char *const tokens[], char sep, size_t n) {
-    const char *const *remaining = tokens;
-    const char *token = *remaining++;
-    size_t i = 0;
-    while (token) {
-        if (i) {
-            dst[i++] = sep;
-            if (i == n)
-                goto truncated;
-        }
-        size_t w = xstrncpy(dst + i, token, n - i);
-        if (w >= n - i)
-            goto truncated;
-        i += w;
-        token = *remaining++;
-    }
-    return i;
-
-truncated:
-    dst[n - 1] = '\0';
-    return n;
-}
-
-char *
-strquote(const char *src) {
-    size_t len = strlen(src);
-    char *quoted = SDL_malloc(len + 3);
-    if (!quoted) {
-        return NULL;
-    }
-    memcpy(&quoted[1], src, len);
-    quoted[0] = '"';
-    quoted[len + 1] = '"';
-    quoted[len + 2] = '\0';
-    return quoted;
-}
-
-bool
-parse_integer(const char *s, long *out) {
-    char *endptr;
-    if (*s == '\0') {
-        return false;
-    }
-    errno = 0;
-    long value = strtol(s, &endptr, 0);
-    if (errno == ERANGE) {
-        return false;
-    }
-    if (*endptr != '\0') {
-        return false;
-    }
-
-    *out = value;
-    return true;
-}
-
-size_t
-parse_integers(const char *s, const char sep, size_t max_items, long *out) {
-    size_t count = 0;
-    char *endptr;
-    do {
-        errno = 0;
-        long value = strtol(s, &endptr, 0);
-        if (errno == ERANGE) {
-            return 0;
-        }
-
-        if (endptr == s || (*endptr != sep && *endptr != '\0')) {
-            return 0;
-        }
-
-        out[count++] = value;
-        if (*endptr == sep) {
-            if (count >= max_items) {
-                // max items already reached, could not accept a new item
-                return 0;
-            }
-            // parse the next token during the next iteration
-            s = endptr + 1;
-        }
-    } while (*endptr != '\0');
-
-    return count;
-}
-
-bool
-parse_integer_with_suffix(const char *s, long *out) {
-    char *endptr;
-    if (*s == '\0') {
-        return false;
-    }
-    errno = 0;
-    long value = strtol(s, &endptr, 0);
-    if (errno == ERANGE) {
-        return false;
-    }
-    int mul = 1;
-    if (*endptr != '\0') {
-        if (s == endptr) {
-            return false;
-        }
-        if ((*endptr == 'M' || *endptr == 'm') && endptr[1] == '\0') {
-            mul = 1000000;
-        } else if ((*endptr == 'K' || *endptr == 'k') && endptr[1] == '\0') {
-            mul = 1000;
-        } else {
-            return false;
-        }
-    }
-
-    if ((value < 0 && LONG_MIN / mul > value) ||
-        (value > 0 && LONG_MAX / mul < value)) {
-        return false;
-    }
-
-    *out = value * mul;
-    return true;
-}
-
-size_t
-utf8_truncation_index(const char *utf8, size_t max_len) {
-    size_t len = strlen(utf8);
-    if (len <= max_len) {
-        return len;
-    }
-    len = max_len;
-    // see UTF-8 encoding <https://en.wikipedia.org/wiki/UTF-8#Description>
-    while ((utf8[len] & 0x80) != 0 && (utf8[len] & 0xc0) != 0xc0) {
-        // the next byte is not the start of a new UTF-8 codepoint
-        // so if we would cut there, the character would be truncated
-        len--;
-    }
-    return len;
-}
-
-#ifdef _WIN32
-
-wchar_t *
-utf8_to_wide_char(const char *utf8) {
-    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
-    if (!len) {
-        return NULL;
-    }
-
-    wchar_t *wide = SDL_malloc(len * sizeof(wchar_t));
-    if (!wide) {
-        return NULL;
-    }
-
-    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wide, len);
-    return wide;
-}
-
-char *
-utf8_from_wide_char(const wchar_t *ws) {
-    int len = WideCharToMultiByte(CP_UTF8, 0, ws, -1, NULL, 0, NULL, NULL);
-    if (!len) {
-        return NULL;
-    }
-
-    char *utf8 = SDL_malloc(len);
-    if (!utf8) {
-        return NULL;
-    }
-
-    WideCharToMultiByte(CP_UTF8, 0, ws, -1, utf8, len, NULL, NULL);
-    return utf8;
-}
-
-#endif

app/src/util/str_util.h

@@ -1,60 +0,0 @@
-#ifndef STRUTIL_H
-#define STRUTIL_H
-
-#include <stdbool.h>
-#include <stddef.h>
-
-#include "config.h"
-
-// like strncpy, except:
-//  - it copies at most n-1 chars
-//  - the dest string is nul-terminated
-//  - it does not write useless bytes if strlen(src) < n
-//  - it returns the number of chars actually written (max n-1) if src has
-//    been copied completely, or n if src has been truncated
-size_t
-xstrncpy(char *dest, const char *src, size_t n);
-
-// join tokens by sep into dst
-// returns the number of chars actually written (max n-1) if no trucation
-// occurred, or n if truncated
-size_t
-xstrjoin(char *dst, const char *const tokens[], char sep, size_t n);
-
-// quote a string
-// returns the new allocated string, to be freed by the caller
-char *
-strquote(const char *src);
-
-// parse s as an integer into value
-// returns true if the conversion succeeded, false otherwise
-bool
-parse_integer(const char *s, long *out);
-
-// parse s as integers separated by sep (for example '1234:2000')
-// returns the number of integers on success, 0 on failure
-size_t
-parse_integers(const char *s, const char sep, size_t max_items, long *out);
-
-// parse s as an integer into value
-// like parse_integer(), but accept 'k'/'K' (x1000) and 'm'/'M' (x1000000) as
-// suffix
-// returns true if the conversion succeeded, false otherwise
-bool
-parse_integer_with_suffix(const char *s, long *out);
-
-// return the index to truncate a UTF-8 string at a valid position
-size_t
-utf8_truncation_index(const char *utf8, size_t max_len);
-
-#ifdef _WIN32
-// convert a UTF-8 string to a wchar_t string
-// returns the new allocated string, to be freed by the caller
-wchar_t *
-utf8_to_wide_char(const char *utf8);
-
-char *
-utf8_from_wide_char(const wchar_t *s);
-#endif
-
-#endif

app/src/video_buffer.c

@@ -1,113 +0,0 @@
-#include "video_buffer.h"
-
-#include <assert.h>
-#include <SDL2/SDL_mutex.h>
-#include <libavutil/avutil.h>
-#include <libavformat/avformat.h>
-
-#include "config.h"
-#include "util/lock.h"
-#include "util/log.h"
-
-bool
-video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
-                  bool render_expired_frames) {
-    vb->fps_counter = fps_counter;
-
-    if (!(vb->decoding_frame = av_frame_alloc())) {
-        goto error_0;
-    }
-
-    if (!(vb->rendering_frame = av_frame_alloc())) {
-        goto error_1;
-    }
-
-    if (!(vb->mutex = SDL_CreateMutex())) {
-        goto error_2;
-    }
-
-    vb->render_expired_frames = render_expired_frames;
-    if (render_expired_frames) {
-        if (!(vb->rendering_frame_consumed_cond = SDL_CreateCond())) {
-            SDL_DestroyMutex(vb->mutex);
-            goto error_2;
-        }
-        // interrupted is not used if expired frames are not rendered
-        // since offering a frame will never block
-        vb->interrupted = false;
-    }
-
-    // there is initially no rendering frame, so consider it has already been
-    // consumed
-    vb->rendering_frame_consumed = true;
-
-    return true;
-
-error_2:
-    av_frame_free(&vb->rendering_frame);
-error_1:
-    av_frame_free(&vb->decoding_frame);
-error_0:
-    return false;
-}
-
-void
-video_buffer_destroy(struct video_buffer *vb) {
-    if (vb->render_expired_frames) {
-        SDL_DestroyCond(vb->rendering_frame_consumed_cond);
-    }
-    SDL_DestroyMutex(vb->mutex);
-    av_frame_free(&vb->rendering_frame);
-    av_frame_free(&vb->decoding_frame);
-}
-
-static void
-video_buffer_swap_frames(struct video_buffer *vb) {
-    AVFrame *tmp = vb->decoding_frame;
-    vb->decoding_frame = vb->rendering_frame;
-    vb->rendering_frame = tmp;
-}
-
-void
-video_buffer_offer_decoded_frame(struct video_buffer *vb,
-                                 bool *previous_frame_skipped) {
-    mutex_lock(vb->mutex);
-    if (vb->render_expired_frames) {
-        // wait for the current (expired) frame to be consumed
-        while (!vb->rendering_frame_consumed && !vb->interrupted) {
-            cond_wait(vb->rendering_frame_consumed_cond, vb->mutex);
-        }
-    } else if (!vb->rendering_frame_consumed) {
-        fps_counter_add_skipped_frame(vb->fps_counter);
-    }
-
-    video_buffer_swap_frames(vb);
-
-    *previous_frame_skipped = !vb->rendering_frame_consumed;
-    vb->rendering_frame_consumed = false;
-
-    mutex_unlock(vb->mutex);
-}
-
-const AVFrame *
-video_buffer_consume_rendered_frame(struct video_buffer *vb) {
-    assert(!vb->rendering_frame_consumed);
-    vb->rendering_frame_consumed = true;
-    fps_counter_add_rendered_frame(vb->fps_counter);
-    if (vb->render_expired_frames) {
-        // unblock video_buffer_offer_decoded_frame()
-        cond_signal(vb->rendering_frame_consumed_cond);
-    }
-    return vb->rendering_frame;
-}
-
-void
-video_buffer_interrupt(struct video_buffer *vb) {
-    if (vb->render_expired_frames) {
-        mutex_lock(vb->mutex);
-        vb->interrupted = true;
-        mutex_unlock(vb->mutex);
-        // wake up blocking wait
-        cond_signal(vb->rendering_frame_consumed_cond);
-    }
-}

app/src/video_buffer.h

@@ -1,49 +0,0 @@
-#ifndef VIDEO_BUFFER_H
-#define VIDEO_BUFFER_H
-
-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-
-#include "config.h"
-#include "fps_counter.h"
-
-// forward declarations
-typedef struct AVFrame AVFrame;
-
-struct video_buffer {
-    AVFrame *decoding_frame;
-    AVFrame *rendering_frame;
-    SDL_mutex *mutex;
-    bool render_expired_frames;
-    bool interrupted;
-    SDL_cond *rendering_frame_consumed_cond;
-    bool rendering_frame_consumed;
-    struct fps_counter *fps_counter;
-};
-
-bool
-video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
-                  bool render_expired_frames);
-
-void
-video_buffer_destroy(struct video_buffer *vb);
-
-// set the decoded frame as ready for rendering
-// this function locks frames->mutex during its execution
-// the output flag is set to report whether the previous frame has been skipped
-void
-video_buffer_offer_decoded_frame(struct video_buffer *vb,
-                                 bool *previous_frame_skipped);
-
-// 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 *
-video_buffer_consume_rendered_frame(struct video_buffer *vb);
-
-// wake up and avoid any blocking call
-void
-video_buffer_interrupt(struct video_buffer *vb);
-
-#endif

app/tests/test_buffer_util.c

@@ -1,76 +0,0 @@
-#include <assert.h>
-
-#include "util/buffer_util.h"
-
-static void test_buffer_write16be(void) {
-    uint16_t val = 0xABCD;
-    uint8_t buf[2];
-
-    buffer_write16be(buf, val);
-
-    assert(buf[0] == 0xAB);
-    assert(buf[1] == 0xCD);
-}
-
-static void test_buffer_write32be(void) {
-    uint32_t val = 0xABCD1234;
-    uint8_t buf[4];
-
-    buffer_write32be(buf, val);
-
-    assert(buf[0] == 0xAB);
-    assert(buf[1] == 0xCD);
-    assert(buf[2] == 0x12);
-    assert(buf[3] == 0x34);
-}
-
-static void test_buffer_write64be(void) {
-    uint64_t val = 0xABCD1234567890EF;
-    uint8_t buf[8];
-
-    buffer_write64be(buf, val);
-
-    assert(buf[0] == 0xAB);
-    assert(buf[1] == 0xCD);
-    assert(buf[2] == 0x12);
-    assert(buf[3] == 0x34);
-    assert(buf[4] == 0x56);
-    assert(buf[5] == 0x78);
-    assert(buf[6] == 0x90);
-    assert(buf[7] == 0xEF);
-}
-
-static void test_buffer_read16be(void) {
-    uint8_t buf[2] = {0xAB, 0xCD};
-
-    uint16_t val = buffer_read16be(buf);
-
-    assert(val == 0xABCD);
-}
-
-static void test_buffer_read32be(void) {
-    uint8_t buf[4] = {0xAB, 0xCD, 0x12, 0x34};
-
-    uint32_t val = buffer_read32be(buf);
-
-    assert(val == 0xABCD1234);
-}
-
-static void test_buffer_read64be(void) {
-    uint8_t buf[8] = {0xAB, 0xCD, 0x12, 0x34,
-                      0x56, 0x78, 0x90, 0xEF};
-
-    uint64_t val = buffer_read64be(buf);
-
-    assert(val == 0xABCD1234567890EF);
-}
-
-int main(void) {
-    test_buffer_write16be();
-    test_buffer_write32be();
-    test_buffer_write64be();
-    test_buffer_read16be();
-    test_buffer_read32be();
-    test_buffer_read64be();
-    return 0;
-}

app/tests/test_cbuf.c

@@ -1,73 +0,0 @@
-#include <assert.h>
-#include <string.h>
-
-#include "util/cbuf.h"
-
-struct int_queue CBUF(int, 32);
-
-static void test_cbuf_empty(void) {
-    struct int_queue queue;
-    cbuf_init(&queue);
-
-    assert(cbuf_is_empty(&queue));
-
-    bool push_ok = cbuf_push(&queue, 42);
-    assert(push_ok);
-    assert(!cbuf_is_empty(&queue));
-
-    int item;
-    bool take_ok = cbuf_take(&queue, &item);
-    assert(take_ok);
-    assert(cbuf_is_empty(&queue));
-
-    bool take_empty_ok = cbuf_take(&queue, &item);
-    assert(!take_empty_ok); // the queue is empty
-}
-
-static void test_cbuf_full(void) {
-    struct int_queue queue;
-    cbuf_init(&queue);
-
-    assert(!cbuf_is_full(&queue));
-
-    // fill the queue
-    for (int i = 0; i < 32; ++i) {
-        bool ok = cbuf_push(&queue, i);
-        assert(ok);
-    }
-    bool ok = cbuf_push(&queue, 42);
-    assert(!ok); // the queue if full
-
-    int item;
-    bool take_ok = cbuf_take(&queue, &item);
-    assert(take_ok);
-    assert(!cbuf_is_full(&queue));
-}
-
-static void test_cbuf_push_take(void) {
-    struct int_queue queue;
-    cbuf_init(&queue);
-
-    bool push1_ok = cbuf_push(&queue, 42);
-    assert(push1_ok);
-
-    bool push2_ok = cbuf_push(&queue, 35);
-    assert(push2_ok);
-
-    int item;
-
-    bool take1_ok = cbuf_take(&queue, &item);
-    assert(take1_ok);
-    assert(item == 42);
-
-    bool take2_ok = cbuf_take(&queue, &item);
-    assert(take2_ok);
-    assert(item == 35);
-}
-
-int main(void) {
-    test_cbuf_empty();
-    test_cbuf_full();
-    test_cbuf_push_take();
-    return 0;
-}

app/tests/test_cli.c

@@ -1,131 +0,0 @@
-#include <assert.h>
-
-#include "cli.h"
-#include "common.h"
-
-static void test_flag_version(void) {
-    struct scrcpy_cli_args args = {
-        .opts = SCRCPY_OPTIONS_DEFAULT,
-        .help = false,
-        .version = false,
-    };
-
-    char *argv[] = {"scrcpy", "-v"};
-
-    bool ok = scrcpy_parse_args(&args, 2, argv);
-    assert(ok);
-    assert(!args.help);
-    assert(args.version);
-}
-
-static void test_flag_help(void) {
-    struct scrcpy_cli_args args = {
-        .opts = SCRCPY_OPTIONS_DEFAULT,
-        .help = false,
-        .version = false,
-    };
-
-    char *argv[] = {"scrcpy", "-v"};
-
-    bool ok = scrcpy_parse_args(&args, 2, argv);
-    assert(ok);
-    assert(!args.help);
-    assert(args.version);
-}
-
-static void test_options(void) {
-    struct scrcpy_cli_args args = {
-        .opts = SCRCPY_OPTIONS_DEFAULT,
-        .help = false,
-        .version = false,
-    };
-
-    char *argv[] = {
-        "scrcpy",
-        "--always-on-top",
-        "--bit-rate", "5M",
-        "--crop", "100:200:300:400",
-        "--fullscreen",
-        "--max-fps", "30",
-        "--max-size", "1024",
-        "--lock-video-orientation", "2",
-        // "--no-control" is not compatible with "--turn-screen-off"
-        // "--no-display" is not compatible with "--fulscreen"
-        "--port", "1234:1236",
-        "--push-target", "/sdcard/Movies",
-        "--record", "file",
-        "--record-format", "mkv",
-        "--render-expired-frames",
-        "--serial", "0123456789abcdef",
-        "--show-touches",
-        "--turn-screen-off",
-        "--prefer-text",
-        "--window-title", "my device",
-        "--window-x", "100",
-        "--window-y", "-1",
-        "--window-width", "600",
-        "--window-height", "0",
-        "--window-borderless",
-    };
-
-    bool ok = scrcpy_parse_args(&args, ARRAY_LEN(argv), argv);
-    assert(ok);
-
-    const struct scrcpy_options *opts = &args.opts;
-    assert(opts->always_on_top);
-    fprintf(stderr, "%d\n", (int) opts->bit_rate);
-    assert(opts->bit_rate == 5000000);
-    assert(!strcmp(opts->crop, "100:200:300:400"));
-    assert(opts->fullscreen);
-    assert(opts->max_fps == 30);
-    assert(opts->max_size == 1024);
-    assert(opts->lock_video_orientation == 2);
-    assert(opts->port_range.first == 1234);
-    assert(opts->port_range.last == 1236);
-    assert(!strcmp(opts->push_target, "/sdcard/Movies"));
-    assert(!strcmp(opts->record_filename, "file"));
-    assert(opts->record_format == RECORDER_FORMAT_MKV);
-    assert(opts->render_expired_frames);
-    assert(!strcmp(opts->serial, "0123456789abcdef"));
-    assert(opts->show_touches);
-    assert(opts->turn_screen_off);
-    assert(opts->prefer_text);
-    assert(!strcmp(opts->window_title, "my device"));
-    assert(opts->window_x == 100);
-    assert(opts->window_y == -1);
-    assert(opts->window_width == 600);
-    assert(opts->window_height == 0);
-    assert(opts->window_borderless);
-}
-
-static void test_options2(void) {
-    struct scrcpy_cli_args args = {
-        .opts = SCRCPY_OPTIONS_DEFAULT,
-        .help = false,
-        .version = false,
-    };
-
-    char *argv[] = {
-        "scrcpy",
-        "--no-control",
-        "--no-display",
-        "--record", "file.mp4", // cannot enable --no-display without recording
-    };
-
-    bool ok = scrcpy_parse_args(&args, ARRAY_LEN(argv), argv);
-    assert(ok);
-
-    const struct scrcpy_options *opts = &args.opts;
-    assert(!opts->control);
-    assert(!opts->display);
-    assert(!strcmp(opts->record_filename, "file.mp4"));
-    assert(opts->record_format == RECORDER_FORMAT_MP4);
-}
-
-int main(void) {
-    test_flag_version();
-    test_flag_help();
-    test_options();
-    test_options2();
-    return 0;
-};

app/tests/test_control_event_queue.c

@@ -0,0 +1,94 @@
+#include <assert.h>
+
+#include "controlevent.h"
+
+static void test_control_event_queue_empty() {
+    struct control_event_queue queue;
+    SDL_bool init_ok = control_event_queue_init(&queue);
+    assert(init_ok);
+
+    assert(control_event_queue_is_empty(&queue));
+
+    struct control_event dummy_event;
+    SDL_bool push_ok = control_event_queue_push(&queue, &dummy_event);
+    assert(push_ok);
+    assert(!control_event_queue_is_empty(&queue));
+
+    SDL_bool take_ok = control_event_queue_take(&queue, &dummy_event);
+    assert(take_ok);
+    assert(control_event_queue_is_empty(&queue));
+
+    SDL_bool take_empty_ok = control_event_queue_take(&queue, &dummy_event);
+    assert(!take_empty_ok); // the queue is empty
+
+    control_event_queue_destroy(&queue);
+}
+
+static void test_control_event_queue_full() {
+    struct control_event_queue queue;
+    SDL_bool init_ok = control_event_queue_init(&queue);
+    assert(init_ok);
+
+    assert(!control_event_queue_is_full(&queue));
+
+    struct control_event dummy_event;
+    // fill the queue
+    while (control_event_queue_push(&queue, &dummy_event));
+
+    SDL_bool take_ok = control_event_queue_take(&queue, &dummy_event);
+    assert(take_ok);
+    assert(!control_event_queue_is_full(&queue));
+
+    control_event_queue_destroy(&queue);
+}
+
+static void test_control_event_queue_push_take() {
+    struct control_event_queue queue;
+    SDL_bool init_ok = control_event_queue_init(&queue);
+    assert(init_ok);
+
+    struct control_event event = {
+        .type = CONTROL_EVENT_TYPE_KEYCODE,
+        .keycode_event = {
+            .action = AKEY_EVENT_ACTION_DOWN,
+            .keycode = AKEYCODE_ENTER,
+            .metastate = AMETA_CTRL_LEFT_ON | AMETA_CTRL_ON,
+        },
+    };
+
+    SDL_bool push1_ok = control_event_queue_push(&queue, &event);
+    assert(push1_ok);
+
+    event = (struct control_event) {
+        .type = CONTROL_EVENT_TYPE_TEXT,
+        .text_event = {
+            .text = "abc",
+        },
+    };
+
+    SDL_bool push2_ok = control_event_queue_push(&queue, &event);
+    assert(push2_ok);
+
+    // overwrite event
+    SDL_bool take1_ok = control_event_queue_take(&queue, &event);
+    assert(take1_ok);
+    assert(event.type == CONTROL_EVENT_TYPE_KEYCODE);
+    assert(event.keycode_event.action == AKEY_EVENT_ACTION_DOWN);
+    assert(event.keycode_event.keycode == AKEYCODE_ENTER);
+    assert(event.keycode_event.metastate == (AMETA_CTRL_LEFT_ON | AMETA_CTRL_ON));
+
+    // overwrite event
+    SDL_bool take2_ok = control_event_queue_take(&queue, &event);
+    assert(take2_ok);
+    assert(event.type == CONTROL_EVENT_TYPE_TEXT);
+    assert(!strcmp(event.text_event.text, "abc"));
+
+    control_event_queue_destroy(&queue);
+}
+
+int main() {
+    test_control_event_queue_empty();
+    test_control_event_queue_full();
+    test_control_event_queue_push_take();
+    return 0;
+}

app/tests/test_control_event_serialize.c

@@ -0,0 +1,141 @@
+#include <assert.h>
+
+#include "controlevent.h"
+
+static void test_serialize_keycode_event() {
+    struct control_event event = {
+        .type = CONTROL_EVENT_TYPE_KEYCODE,
+        .keycode_event = {
+            .action = AKEY_EVENT_ACTION_UP,
+            .keycode = AKEYCODE_ENTER,
+            .metastate = AMETA_SHIFT_ON | AMETA_SHIFT_LEFT_ON,
+        },
+    };
+
+    unsigned char buf[SERIALIZED_EVENT_MAX_SIZE];
+    int size = control_event_serialize(&event, buf);
+    assert(size == 10);
+
+    const unsigned char expected[] = {
+        0x00, // CONTROL_EVENT_TYPE_KEYCODE
+        0x01, // AKEY_EVENT_ACTION_UP
+        0x00, 0x00, 0x00, 0x42, // AKEYCODE_ENTER
+        0x00, 0x00, 0x00, 0x41, // AMETA_SHIFT_ON | AMETA_SHIFT_LEFT_ON
+    };
+    assert(!memcmp(buf, expected, sizeof(expected)));
+}
+
+static void test_serialize_text_event() {
+    struct control_event event = {
+        .type = CONTROL_EVENT_TYPE_TEXT,
+        .text_event = {
+            .text = "hello, world!",
+        },
+    };
+
+    unsigned char buf[SERIALIZED_EVENT_MAX_SIZE];
+    int size = control_event_serialize(&event, buf);
+    assert(size == 16);
+
+    const unsigned char expected[] = {
+        0x01, // CONTROL_EVENT_TYPE_KEYCODE
+        0x00, 0x0d, // text length
+        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
+    };
+    assert(!memcmp(buf, expected, sizeof(expected)));
+}
+
+static void test_serialize_long_text_event() {
+    struct control_event event;
+    event.type = CONTROL_EVENT_TYPE_TEXT;
+    char text[TEXT_MAX_LENGTH];
+    memset(text, 'a', sizeof(text));
+    event.text_event.text = text;
+
+    unsigned char buf[SERIALIZED_EVENT_MAX_SIZE];
+    int size = control_event_serialize(&event, buf);
+    assert(size == 3 + sizeof(text));
+
+    unsigned char expected[3 + TEXT_MAX_LENGTH];
+    expected[0] = 0x01; // CONTROL_EVENT_TYPE_KEYCODE
+    expected[1] = 0x01;
+    expected[2] = 0x2c; // text length (16 bits)
+    memset(&expected[3], 'a', TEXT_MAX_LENGTH);
+
+    assert(!memcmp(buf, expected, sizeof(expected)));
+}
+
+static void test_serialize_mouse_event() {
+    struct control_event event = {
+        .type = CONTROL_EVENT_TYPE_MOUSE,
+        .mouse_event = {
+            .action = AMOTION_EVENT_ACTION_DOWN,
+            .buttons = AMOTION_EVENT_BUTTON_PRIMARY,
+            .position = {
+                .point = {
+                    .x = 260,
+                    .y = 1026,
+                },
+                .screen_size = {
+                    .width = 1080,
+                    .height = 1920,
+                },
+            },
+        },
+    };
+
+    unsigned char buf[SERIALIZED_EVENT_MAX_SIZE];
+    int size = control_event_serialize(&event, buf);
+    assert(size == 14);
+
+    const unsigned char expected[] = {
+        0x02, // CONTROL_EVENT_TYPE_MOUSE
+        0x00, // AKEY_EVENT_ACTION_DOWN
+        0x00, 0x00, 0x00, 0x01, // AMOTION_EVENT_BUTTON_PRIMARY
+        0x01, 0x04, 0x04, 0x02, // 260 1026
+        0x04, 0x38, 0x07, 0x80, // 1080 1920
+    };
+    assert(!memcmp(buf, expected, sizeof(expected)));
+}
+
+static void test_serialize_scroll_event() {
+    struct control_event event = {
+        .type = CONTROL_EVENT_TYPE_SCROLL,
+        .scroll_event = {
+            .position = {
+                .point = {
+                    .x = 260,
+                    .y = 1026,
+                },
+                .screen_size = {
+                    .width = 1080,
+                    .height = 1920,
+                },
+            },
+            .hscroll = 1,
+            .vscroll = -1,
+        },
+    };
+
+    unsigned char buf[SERIALIZED_EVENT_MAX_SIZE];
+    int size = control_event_serialize(&event, buf);
+    assert(size == 17);
+
+    const unsigned char expected[] = {
+        0x03, // CONTROL_EVENT_TYPE_SCROLL
+        0x01, 0x04, 0x04, 0x02, // 260 1026
+        0x04, 0x38, 0x07, 0x80, // 1080 1920
+        0x00, 0x00, 0x00, 0x01, // 1
+        0xFF, 0xFF, 0xFF, 0xFF, // -1
+    };
+    assert(!memcmp(buf, expected, sizeof(expected)));
+}
+
+int main() {
+    test_serialize_keycode_event();
+    test_serialize_text_event();
+    test_serialize_long_text_event();
+    test_serialize_mouse_event();
+    test_serialize_scroll_event();
+    return 0;
+}

app/tests/test_control_msg_serialize.c

@@ -1,268 +0,0 @@
-#include <assert.h>
-#include <string.h>
-
-#include "control_msg.h"
-
-static void test_serialize_inject_keycode(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_KEYCODE,
-        .inject_keycode = {
-            .action = AKEY_EVENT_ACTION_UP,
-            .keycode = AKEYCODE_ENTER,
-            .metastate = AMETA_SHIFT_ON | AMETA_SHIFT_LEFT_ON,
-        },
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 10);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_INJECT_KEYCODE,
-        0x01, // AKEY_EVENT_ACTION_UP
-        0x00, 0x00, 0x00, 0x42, // AKEYCODE_ENTER
-        0x00, 0x00, 0x00, 0x41, // AMETA_SHIFT_ON | AMETA_SHIFT_LEFT_ON
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_inject_text(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_TEXT,
-        .inject_text = {
-            .text = "hello, world!",
-        },
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 16);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_INJECT_TEXT,
-        0x00, 0x0d, // text length
-        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_inject_text_long(void) {
-    struct control_msg msg;
-    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    char text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1];
-    memset(text, 'a', sizeof(text));
-    text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
-    msg.inject_text.text = text;
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 3 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
-
-    unsigned char expected[3 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
-    expected[0] = CONTROL_MSG_TYPE_INJECT_TEXT;
-    expected[1] = 0x01;
-    expected[2] = 0x2c; // text length (16 bits)
-    memset(&expected[3], 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
-
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_inject_touch_event(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-        .inject_touch_event = {
-            .action = AMOTION_EVENT_ACTION_DOWN,
-            .pointer_id = 0x1234567887654321L,
-            .position = {
-                .point = {
-                    .x = 100,
-                    .y = 200,
-                },
-                .screen_size = {
-                    .width = 1080,
-                    .height = 1920,
-                },
-            },
-            .pressure = 1.0f,
-            .buttons = AMOTION_EVENT_BUTTON_PRIMARY,
-        },
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 28);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
-        0x00, // AKEY_EVENT_ACTION_DOWN
-        0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21, // pointer id
-        0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0xc8, // 100 200
-        0x04, 0x38, 0x07, 0x80, // 1080 1920
-        0xff, 0xff, // pressure
-        0x00, 0x00, 0x00, 0x01 // AMOTION_EVENT_BUTTON_PRIMARY
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_inject_scroll_event(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
-        .inject_scroll_event = {
-            .position = {
-                .point = {
-                    .x = 260,
-                    .y = 1026,
-                },
-                .screen_size = {
-                    .width = 1080,
-                    .height = 1920,
-                },
-            },
-            .hscroll = 1,
-            .vscroll = -1,
-        },
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 21);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
-        0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x02, // 260 1026
-        0x04, 0x38, 0x07, 0x80, // 1080 1920
-        0x00, 0x00, 0x00, 0x01, // 1
-        0xFF, 0xFF, 0xFF, 0xFF, // -1
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_back_or_screen_on(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 1);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_expand_notification_panel(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 1);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_collapse_notification_panel(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 1);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_get_clipboard(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_GET_CLIPBOARD,
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 1);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_GET_CLIPBOARD,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_set_clipboard(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_SET_CLIPBOARD,
-        .inject_text = {
-            .text = "hello, world!",
-        },
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 16);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_SET_CLIPBOARD,
-        0x00, 0x0d, // text length
-        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_set_screen_power_mode(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
-        .set_screen_power_mode = {
-            .mode = SCREEN_POWER_MODE_NORMAL,
-        },
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 2);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
-        0x02, // SCREEN_POWER_MODE_NORMAL
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-static void test_serialize_rotate_device(void) {
-    struct control_msg msg = {
-        .type = CONTROL_MSG_TYPE_ROTATE_DEVICE,
-    };
-
-    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
-    assert(size == 1);
-
-    const unsigned char expected[] = {
-        CONTROL_MSG_TYPE_ROTATE_DEVICE,
-    };
-    assert(!memcmp(buf, expected, sizeof(expected)));
-}
-
-int main(void) {
-    test_serialize_inject_keycode();
-    test_serialize_inject_text();
-    test_serialize_inject_text_long();
-    test_serialize_inject_touch_event();
-    test_serialize_inject_scroll_event();
-    test_serialize_back_or_screen_on();
-    test_serialize_expand_notification_panel();
-    test_serialize_collapse_notification_panel();
-    test_serialize_get_clipboard();
-    test_serialize_set_clipboard();
-    test_serialize_set_screen_power_mode();
-    test_serialize_rotate_device();
-    return 0;
-}

app/tests/test_device_msg_deserialize.c

@@ -1,28 +0,0 @@
-#include <assert.h>
-#include <string.h>
-
-#include "device_msg.h"
-
-#include <stdio.h>
-static void test_deserialize_clipboard(void) {
-    const unsigned char input[] = {
-        DEVICE_MSG_TYPE_CLIPBOARD,
-        0x00, 0x03, // text length
-        0x41, 0x42, 0x43, // "ABC"
-    };
-
-    struct device_msg msg;
-    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
-    assert(r == 6);
-
-    assert(msg.type == DEVICE_MSG_TYPE_CLIPBOARD);
-    assert(msg.clipboard.text);
-    assert(!strcmp("ABC", msg.clipboard.text));
-
-    device_msg_destroy(&msg);
-}
-
-int main(void) {
-    test_deserialize_clipboard();
-    return 0;
-}

app/tests/test_queue.c

@@ -1,38 +0,0 @@
-#include <assert.h>
-
-#include "util/queue.h"
-
-struct foo {
-    int value;
-    struct foo *next;
-};
-
-static void test_queue(void) {
-    struct my_queue QUEUE(struct foo) queue;
-    queue_init(&queue);
-
-    assert(queue_is_empty(&queue));
-
-    struct foo v1 = { .value = 42 };
-    struct foo v2 = { .value = 27 };
-
-    queue_push(&queue, next, &v1);
-    queue_push(&queue, next, &v2);
-
-    struct foo *foo;
-
-    assert(!queue_is_empty(&queue));
-    queue_take(&queue, next, &foo);
-    assert(foo->value == 42);
-
-    assert(!queue_is_empty(&queue));
-    queue_take(&queue, next, &foo);
-    assert(foo->value == 27);
-
-    assert(queue_is_empty(&queue));
-}
-
-int main(void) {
-    test_queue();
-    return 0;
-}

app/tests/test_strutil.c

@@ -1,12 +1,9 @@
 #include <assert.h>
-#include <limits.h>
-#include <stdio.h>
 #include <string.h>
-#include <SDL2/SDL.h>
 
-#include "util/str_util.h"
+#include "strutil.h"
 
-static void test_xstrncpy_simple(void) {
+static void test_xstrncpy_simple() {
     char s[] = "xxxxxxxxxx";
     size_t w = xstrncpy(s, "abcdef", sizeof(s));
 
@@ -23,7 +20,7 @@ static void test_xstrncpy_simple(void) {
     assert(!strcmp("abcdef", s));
 }
 
-static void test_xstrncpy_just_fit(void) {
+static void test_xstrncpy_just_fit() {
     char s[] = "xxxxxx";
     size_t w = xstrncpy(s, "abcdef", sizeof(s));
 
@@ -37,7 +34,7 @@ static void test_xstrncpy_just_fit(void) {
     assert(!strcmp("abcdef", s));
 }
 
-static void test_xstrncpy_truncated(void) {
+static void test_xstrncpy_truncated() {
     char s[] = "xxx";
     size_t w = xstrncpy(s, "abcdef", sizeof(s));
 
@@ -51,7 +48,7 @@ static void test_xstrncpy_truncated(void) {
     assert(!strncmp("abcdef", s, 3));
 }
 
-static void test_xstrjoin_simple(void) {
+static void test_xstrjoin_simple() {
     const char *const tokens[] = { "abc", "de", "fghi", NULL };
     char s[] = "xxxxxxxxxxxxxx";
     size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
@@ -69,7 +66,7 @@ static void test_xstrjoin_simple(void) {
     assert(!strcmp("abc de fghi", s));
 }
 
-static void test_xstrjoin_just_fit(void) {
+static void test_xstrjoin_just_fit() {
     const char *const tokens[] = { "abc", "de", "fghi", NULL };
     char s[] = "xxxxxxxxxxx";
     size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
@@ -84,7 +81,7 @@ static void test_xstrjoin_just_fit(void) {
     assert(!strcmp("abc de fghi", s));
 }
 
-static void test_xstrjoin_truncated_in_token(void) {
+static void test_xstrjoin_truncated_in_token() {
     const char *const tokens[] = { "abc", "de", "fghi", NULL };
     char s[] = "xxxxx";
     size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
@@ -99,7 +96,7 @@ static void test_xstrjoin_truncated_in_token(void) {
     assert(!strcmp("abc d", s));
 }
 
-static void test_xstrjoin_truncated_before_sep(void) {
+static void test_xstrjoin_truncated_before_sep() {
     const char *const tokens[] = { "abc", "de", "fghi", NULL };
     char s[] = "xxxxxx";
     size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
@@ -114,7 +111,7 @@ static void test_xstrjoin_truncated_before_sep(void) {
     assert(!strcmp("abc de", s));
 }
 
-static void test_xstrjoin_truncated_after_sep(void) {
+static void test_xstrjoin_truncated_after_sep() {
     const char *const tokens[] = { "abc", "de", "fghi", NULL };
     char s[] = "xxxxxxx";
     size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
@@ -129,164 +126,7 @@ static void test_xstrjoin_truncated_after_sep(void) {
     assert(!strcmp("abc de ", s));
 }
 
-static void test_strquote(void) {
+int main() {
-    const char *s = "abcde";
-    char *out = strquote(s);
-
-    // add '"' at the beginning and the end
-    assert(!strcmp("\"abcde\"", out));
-
-    SDL_free(out);
-}
-
-static void test_utf8_truncate(void) {
-    const char *s = "aÉbÔc";
-    assert(strlen(s) == 7); // É and Ô are 2 bytes-wide
-
-    size_t count;
-
-    count = utf8_truncation_index(s, 1);
-    assert(count == 1);
-
-    count = utf8_truncation_index(s, 2);
-    assert(count == 1); // É is 2 bytes-wide
-
-    count = utf8_truncation_index(s, 3);
-    assert(count == 3);
-
-    count = utf8_truncation_index(s, 4);
-    assert(count == 4);
-
-    count = utf8_truncation_index(s, 5);
-    assert(count == 4); // Ô is 2 bytes-wide
-
-    count = utf8_truncation_index(s, 6);
-    assert(count == 6);
-
-    count = utf8_truncation_index(s, 7);
-    assert(count == 7);
-
-    count = utf8_truncation_index(s, 8);
-    assert(count == 7); // no more chars
-}
-
-static void test_parse_integer(void) {
-    long value;
-    bool ok = parse_integer("1234", &value);
-    assert(ok);
-    assert(value == 1234);
-
-    ok = parse_integer("-1234", &value);
-    assert(ok);
-    assert(value == -1234);
-
-    ok = parse_integer("1234k", &value);
-    assert(!ok);
-
-    ok = parse_integer("123456789876543212345678987654321", &value);
-    assert(!ok); // out-of-range
-}
-
-static void test_parse_integers(void) {
-    long values[5];
-
-    size_t count = parse_integers("1234", ':', 5, values);
-    assert(count == 1);
-    assert(values[0] == 1234);
-
-    count = parse_integers("1234:5678", ':', 5, values);
-    assert(count == 2);
-    assert(values[0] == 1234);
-    assert(values[1] == 5678);
-
-    count = parse_integers("1234:5678", ':', 2, values);
-    assert(count == 2);
-    assert(values[0] == 1234);
-    assert(values[1] == 5678);
-
-    count = parse_integers("1234:-5678", ':', 2, values);
-    assert(count == 2);
-    assert(values[0] == 1234);
-    assert(values[1] == -5678);
-
-    count = parse_integers("1:2:3:4:5", ':', 5, values);
-    assert(count == 5);
-    assert(values[0] == 1);
-    assert(values[1] == 2);
-    assert(values[2] == 3);
-    assert(values[3] == 4);
-    assert(values[4] == 5);
-
-    count = parse_integers("1234:5678", ':', 1, values);
-    assert(count == 0); // max_items == 1
-
-    count = parse_integers("1:2:3:4:5", ':', 3, values);
-    assert(count == 0); // max_items == 3
-
-    count = parse_integers(":1234", ':', 5, values);
-    assert(count == 0); // invalid
-
-    count = parse_integers("1234:", ':', 5, values);
-    assert(count == 0); // invalid
-
-    count = parse_integers("1234:", ':', 1, values);
-    assert(count == 0); // invalid, even when max_items == 1
-
-    count = parse_integers("1234::5678", ':', 5, values);
-    assert(count == 0); // invalid
-}
-
-static void test_parse_integer_with_suffix(void) {
-    long value;
-    bool ok = parse_integer_with_suffix("1234", &value);
-    assert(ok);
-    assert(value == 1234);
-
-    ok = parse_integer_with_suffix("-1234", &value);
-    assert(ok);
-    assert(value == -1234);
-
-    ok = parse_integer_with_suffix("1234k", &value);
-    assert(ok);
-    assert(value == 1234000);
-
-    ok = parse_integer_with_suffix("1234m", &value);
-    assert(ok);
-    assert(value == 1234000000);
-
-    ok = parse_integer_with_suffix("-1234k", &value);
-    assert(ok);
-    assert(value == -1234000);
-
-    ok = parse_integer_with_suffix("-1234m", &value);
-    assert(ok);
-    assert(value == -1234000000);
-
-    ok = parse_integer_with_suffix("123456789876543212345678987654321", &value);
-    assert(!ok); // out-of-range
-
-    char buf[32];
-
-    sprintf(buf, "%ldk", LONG_MAX / 2000);
-    ok = parse_integer_with_suffix(buf, &value);
-    assert(ok);
-    assert(value == LONG_MAX / 2000 * 1000);
-
-    sprintf(buf, "%ldm", LONG_MAX / 2000);
-    ok = parse_integer_with_suffix(buf, &value);
-    assert(!ok);
-
-    sprintf(buf, "%ldk", LONG_MIN / 2000);
-    ok = parse_integer_with_suffix(buf, &value);
-    assert(ok);
-    assert(value == LONG_MIN / 2000 * 1000);
-
-    sprintf(buf, "%ldm", LONG_MIN / 2000);
-    ok = parse_integer_with_suffix(buf, &value);
-    assert(!ok);
-}
-
-int main(void) {
     test_xstrncpy_simple();
     test_xstrncpy_just_fit();
     test_xstrncpy_truncated();
@@ -295,10 +135,5 @@ int main(void) {
     test_xstrjoin_truncated_in_token();
     test_xstrjoin_truncated_before_sep();
     test_xstrjoin_truncated_after_sep();
-    test_strquote();
-    test_utf8_truncate();
-    test_parse_integer();
-    test_parse_integers();
-    test_parse_integer_with_suffix();
     return 0;
 }

build.gradle

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

config/checkstyle/checkstyle.xml

@@ -54,7 +54,7 @@ page at http://checkstyle.sourceforge.net/config.html -->
     <module name="SuppressWarningsHolder"/>
 
     <!-- Checks for imports                              -->
-    <!-- See http://checkstyle.sf.net/config_imports.html -->
+    <!-- See http://checkstyle.sf.net/config_import.html -->
     <module name="AvoidStarImport">
       <property name="allowStaticMemberImports" value="true" />
     </module>
@@ -99,7 +99,7 @@ page at http://checkstyle.sourceforge.net/config.html -->
     <module name="WhitespaceAround" />
 
     <!-- Modifier Checks                                    -->
-    <!-- See http://checkstyle.sf.net/config_modifier.html -->
+    <!-- See http://checkstyle.sf.net/config_modifiers.html -->
     <module name="ModifierOrder" />
     <module name="RedundantModifier" />
 
@@ -129,6 +129,11 @@ page at http://checkstyle.sourceforge.net/config.html -->
     </module>
     <module name="IllegalInstantiation" />
     <module name="InnerAssignment" />
+    <module name="MagicNumber">
+      <property name="severity" value="info" />
+      <property name="ignoreHashCodeMethod" value="true" />
+      <property name="ignoreAnnotation" value="true" />
+    </module>
     <module name="MissingSwitchDefault" />
     <module name="SimplifyBooleanExpression" />
     <module name="SimplifyBooleanReturn" />

cross_win32.txt

@@ -1,20 +0,0 @@
-# apt install mingw-w64 mingw-w64-tools
-
-[binaries]
-name = 'mingw'
-c = '/usr/bin/i686-w64-mingw32-gcc'
-cpp = '/usr/bin/i686-w64-mingw32-g++'
-ar = '/usr/bin/i686-w64-mingw32-ar'
-strip = '/usr/bin/i686-w64-mingw32-strip'
-pkgconfig = '/usr/bin/i686-w64-mingw32-pkg-config'
-
-[host_machine]
-system = 'windows'
-cpu_family = 'x86'
-cpu = 'i686'
-endian = 'little'
-
-[properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.2.2-win32-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.2.2-win32-dev'
-prebuilt_sdl2 = 'SDL2-2.0.12/i686-w64-mingw32'

cross_win64.txt

@@ -1,20 +0,0 @@
-# apt install mingw-w64 mingw-w64-tools
-
-[binaries]
-name = 'mingw'
-c = '/usr/bin/x86_64-w64-mingw32-gcc'
-cpp = '/usr/bin/x86_64-w64-mingw32-g++'
-ar = '/usr/bin/x86_64-w64-mingw32-ar'
-strip = '/usr/bin/x86_64-w64-mingw32-strip'
-pkgconfig = '/usr/bin/x86_64-w64-mingw32-pkg-config'
-
-[host_machine]
-system = 'windows'
-cpu_family = 'x86'
-cpu = 'x86_64'
-endian = 'little'
-
-[properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.2.2-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.2.2-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.12/x86_64-w64-mingw32'