Upgrade FFmpeg (6.0) for Windows

Use the latest version (specifically built for scrcpy).

Refs <https://www.ffmpeg.org/download.html#release_6.0>

BUILD.md

@@ -2,16 +2,57 @@
 
 Here are the instructions to build _scrcpy_ (client and server).
 
-If you just want to build and install the latest release, follow the simplified
+
-process described in [doc/linux.md](linux.md).
+## Simple
+
+If you just want to install the latest release from `master`, follow this
+simplified process.
+
+First, you need to install the required packages:
+
+```bash
+# for Debian/Ubuntu
+sudo apt install ffmpeg libsdl2-2.0-0 adb wget \
+                 gcc git pkg-config meson ninja-build libsdl2-dev \
+                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
+                 libusb-1.0-0 libusb-1.0-0-dev
+```
+
+Then clone the repo and execute the installation script
+([source](install_release.sh)):
+
+```bash
+git clone https://github.com/Genymobile/scrcpy
+cd scrcpy
+./install_release.sh
+```
+
+When a new release is out, update the repo and reinstall:
+
+```bash
+git pull
+./install_release.sh
+```
+
+To uninstall:
+
+```bash
+sudo ninja -Cbuild-auto uninstall
+```
+
 
 ## Branches
 
-There are two main branches:
+### `master`
- - `master`: contains the latest release. It is the home page of the project on
+
-   GitHub.
+The `master` branch concerns the latest release, and is the home page of the
- - `dev`: the current development branch. Every commit present in `dev` will be
+project on GitHub.
-   in the next release.
+
+
+### `dev`
+
+`dev` is the current development branch. Every commit present in `dev` will be
+in the next release.
 
 If you want to contribute code, please base your commits on the latest `dev`
 branch.
@@ -28,8 +69,6 @@ the following files to a directory accessible from your `PATH`:
  - `AdbWinApi.dll`
  - `AdbWinUsbApi.dll`
 
-It is also available in scrcpy releases.
-
 The client requires [FFmpeg] and [LibSDL2]. Just follow the instructions.
 
 [adb]: https://developer.android.com/studio/command-line/adb.html
@@ -55,7 +94,7 @@ sudo apt install ffmpeg libsdl2-2.0-0 adb libusb-1.0-0
 # client build dependencies
 sudo apt install gcc git pkg-config meson ninja-build libsdl2-dev \
                  libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
-                 libswresample-dev libusb-1.0-0-dev
+                 libusb-1.0-0-dev
 
 # server build dependencies
 sudo apt install openjdk-11-jdk
@@ -233,10 +272,10 @@ install` must be run as root)._
 
 #### Option 2: Use prebuilt server
 
- - [`scrcpy-server-v2.0`][direct-scrcpy-server]  
+ - [`scrcpy-server-v1.25`][direct-scrcpy-server]  
-   <sub>SHA-256: `9e241615f578cd690bb43311000debdecf6a9c50a7082b001952f18f6f21ddc2`</sub>
+   <sub>SHA-256: `ce0306c7bbd06ae72f6d06f7ec0ee33774995a65de71e0a83813ecb67aec9bdb`</sub>
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v2.0/scrcpy-server-v2.0
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.25/scrcpy-server-v1.25
 
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
@@ -275,8 +314,7 @@ This installs several files:
  - `/usr/local/share/zsh/site-functions/_scrcpy` (zsh completion)
  - `/usr/local/share/bash-completion/completions/scrcpy` (bash completion)
 
-You can then run `scrcpy`.
+You can then [run](README.md#run) `scrcpy`.
-
 
 ### Uninstall
 

DEVELOP.md

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

FAQ.md

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

LICENSE

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

app/data/bash-completion/scrcpy

@@ -3,12 +3,9 @@ _scrcpy() {
     local opts="
         --always-on-top
         --audio-bit-rate=
-        --audio-buffer=
         --audio-codec=
         --audio-codec-options=
         --audio-encoder=
-        --audio-source=
-        --audio-output-buffer=
         -b --video-bit-rate=
         --crop=
         -d --select-usb
@@ -16,57 +13,51 @@ _scrcpy() {
         --display=
         --display-buffer=
         -e --select-tcpip
-        -f --fullscreen
         --force-adb-forward
         --forward-all-clicks
-        -h --help
+        -f --fullscreen
-        --kill-adb-on-close
         -K --hid-keyboard
+        -h --help
         --legacy-paste
         --list-displays
         --list-encoders
         --lock-video-orientation
         --lock-video-orientation=
-        -m --max-size=
-        -M --hid-mouse
         --max-fps=
-        -n --no-control
+        -M --hid-mouse
-        -N --no-playback
+        -m --max-size=
         --no-audio
-        --no-audio-playback
         --no-cleanup
         --no-clipboard-autosync
         --no-downsize-on-error
+        -n --no-control
+        -N --no-display
         --no-key-repeat
         --no-mipmaps
         --no-power-on
-        --no-video
-        --no-video-playback
         --otg
         -p --port=
         --power-off-on-close
         --prefer-text
         --print-fps
         --push-target=
-        -r --record=
         --raw-key-events
+        -r --record=
         --record-format=
         --render-driver=
-        --require-audio
         --rotation=
         -s --serial=
-        -S --turn-screen-off
         --shortcut-mod=
+        -S --turn-screen-off
         -t --show-touches
         --tcpip
         --tcpip=
-        --time-limit=
         --tunnel-host=
         --tunnel-port=
         --v4l2-buffer=
         --v4l2-sink=
-        -v --version
         -V --verbosity=
+        -v --version
         --video-codec=
         --video-codec-options=
         --video-encoder=
@@ -86,11 +77,7 @@ _scrcpy() {
             return
             ;;
         --audio-codec)
-            COMPREPLY=($(compgen -W 'opus aac raw' -- "$cur"))
+            COMPREPLY=($(compgen -W 'opus aac' -- "$cur"))
-            return
-            ;;
-        --audio-source)
-            COMPREPLY=($(compgen -W 'output mic' -- "$cur"))
             return
             ;;
         --lock-video-orientation)
@@ -127,26 +114,20 @@ _scrcpy() {
             COMPREPLY=($(compgen -W "$("${ADB:-adb}" devices | awk '$2 == "device" {print $1}')" -- ${cur}))
             return
             ;;
-        --audio-bit-rate \
+        -b|--video-bit-rate \
-        |--audio-buffer \
+        |--codec-options \
-        |-b|--video-bit-rate \
-        |--audio-codec-options \
-        |--audio-encoder \
-        |--audio-output-buffer \
         |--crop \
         |--display \
         |--display-buffer \
+        |--encoder \
         |--max-fps \
         |-m|--max-size \
         |-p|--port \
         |--push-target \
-        |--rotation \
         |--tunnel-host \
         |--tunnel-port \
         |--v4l2-buffer \
         |--v4l2-sink \
-        |--video-codec-options \
-        |--video-encoder \
         |--tcpip \
         |--window-*)
             # Option accepting an argument, but nothing to auto-complete

app/data/scrcpy-console.desktop

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

app/data/scrcpy.desktop

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

app/data/zsh-completion/_scrcpy

@@ -10,12 +10,9 @@ local arguments
 arguments=(
     '--always-on-top[Make scrcpy window always on top \(above other windows\)]'
     '--audio-bit-rate=[Encode the audio at the given bit-rate]'
-    '--audio-buffer=[Configure the audio buffering delay (in milliseconds)]'
+    '--audio-codec=[Select the audio codec]:codec:(opus aac)'
-    '--audio-codec=[Select the audio codec]:codec:(opus aac raw)'
     '--audio-codec-options=[Set a list of comma-separated key\:type=value options for the device audio encoder]'
     '--audio-encoder=[Use a specific MediaCodec audio encoder]'
-    '--audio-source=[Select the audio source]:source:(output mic)'
-    '--audio-output-buffer=[Configure the size of the SDL audio output buffer (in milliseconds)]'
     {-b,--video-bit-rate=}'[Encode the video at the given bit-rate]'
     '--crop=[\[width\:height\:x\:y\] Crop the device screen on the server]'
     {-d,--select-usb}'[Use USB device]'
@@ -23,55 +20,49 @@ arguments=(
     '--display=[Specify the display id to mirror]'
     '--display-buffer=[Add a buffering delay \(in milliseconds\) before displaying]'
     {-e,--select-tcpip}'[Use TCP/IP device]'
-    {-f,--fullscreen}'[Start in fullscreen]'
     '--force-adb-forward[Do not attempt to use \"adb reverse\" to connect to the device]'
     '--forward-all-clicks[Forward clicks to device]'
-    {-h,--help}'[Print the help]'
+    {-f,--fullscreen}'[Start in fullscreen]'
-    '--kill-adb-on-close[Kill adb when scrcpy terminates]'
     {-K,--hid-keyboard}'[Simulate a physical keyboard by using HID over AOAv2]'
+    {-h,--help}'[Print the help]'
     '--legacy-paste[Inject computer clipboard text as a sequence of key events on Ctrl+v]'
     '--list-displays[List displays available on the device]'
     '--list-encoders[List video and audio encoders available on the device]'
     '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 1 2 3)'
-    {-m,--max-size=}'[Limit both the width and height of the video to value]'
-    {-M,--hid-mouse}'[Simulate a physical mouse by using HID over AOAv2]'
     '--max-fps=[Limit the frame rate of screen capture]'
-    {-n,--no-control}'[Disable device control \(mirror the device in read only\)]'
+    {-M,--hid-mouse}'[Simulate a physical mouse by using HID over AOAv2]'
-    {-N,--no-playback}'[Disable video and audio playback]'
+    {-m,--max-size=}'[Limit both the width and height of the video to value]'
     '--no-audio[Disable audio forwarding]'
-    '--no-audio-playback[Disable audio playback]'
     '--no-cleanup[Disable device cleanup actions on exit]'
     '--no-clipboard-autosync[Disable automatic clipboard synchronization]'
     '--no-downsize-on-error[Disable lowering definition on MediaCodec error]'
+    {-n,--no-control}'[Disable device control \(mirror the device in read only\)]'
+    {-N,--no-display}'[Do not display device \(during screen recording or when V4L2 sink is enabled\)]'
     '--no-key-repeat[Do not forward repeated key events when a key is held down]'
     '--no-mipmaps[Disable the generation of mipmaps]'
     '--no-power-on[Do not power on the device on start]'
-    '--no-video[Disable video forwarding]'
-    '--no-video-playback[Disable video playback]'
     '--otg[Run in OTG mode \(simulating physical keyboard and mouse\)]'
     {-p,--port=}'[\[port\[\:port\]\] Set the TCP port \(range\) used by the client to listen]'
     '--power-off-on-close[Turn the device screen off when closing scrcpy]'
     '--prefer-text[Inject alpha characters and space as text events instead of key events]'
     '--print-fps[Start FPS counter, to print frame logs to the console]'
     '--push-target=[Set the target directory for pushing files to the device by drag and drop]'
-    {-r,--record=}'[Record screen to file]:record file:_files'
     '--raw-key-events[Inject key events for all input keys, and ignore text events]'
+    {-r,--record=}'[Record screen to file]:record file:_files'
     '--record-format=[Force recording format]:format:(mp4 mkv)'
     '--render-driver=[Request SDL to use the given render driver]:driver name:(direct3d opengl opengles2 opengles metal software)'
-    '--require-audio=[Make scrcpy fail if audio is enabled but does not work]'
     '--rotation=[Set the initial display rotation]:rotation values:(0 1 2 3)'
     {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]:serial:($("${ADB-adb}" devices | awk '\''$2 == "device" {print $1}'\''))'
-    {-S,--turn-screen-off}'[Turn the device screen off immediately]'
     '--shortcut-mod=[\[key1,key2+key3,...\] Specify the modifiers to use for scrcpy shortcuts]:shortcut mod:(lctrl rctrl lalt ralt lsuper rsuper)'
+    {-S,--turn-screen-off}'[Turn the device screen off immediately]'
     {-t,--show-touches}'[Show physical touches]'
     '--tcpip[\(optional \[ip\:port\]\) Configure and connect the device over TCP/IP]'
-    '--time-limit=[Set the maximum mirroring time, in seconds]'
     '--tunnel-host=[Set the IP address of the adb tunnel to reach the scrcpy server]'
     '--tunnel-port=[Set the TCP port of the adb tunnel to reach the scrcpy server]'
     '--v4l2-buffer=[Add a buffering delay \(in milliseconds\) before pushing frames]'
     '--v4l2-sink=[\[\/dev\/videoN\] Output to v4l2loopback device]'
-    {-v,--version}'[Print the version of scrcpy]'
     {-V,--verbosity=}'[Set the log level]:verbosity:(verbose debug info warn error)'
+    {-v,--version}'[Print the version of scrcpy]'
     '--video-codec=[Select the video codec]:codec:(h264 h265 av1)'
     '--video-codec-options=[Set a list of comma-separated key\:type=value options for the device video encoder]'
     '--video-encoder=[Use a specific MediaCodec video encoder]'

app/meson.build

@@ -11,10 +11,8 @@ src = [
     'src/control_msg.c',
     'src/controller.c',
     'src/decoder.c',
-    'src/delay_buffer.c',
     'src/demuxer.c',
     'src/device_msg.c',
-    'src/display.c',
     'src/icon.c',
     'src/file_pusher.c',
     'src/fps_counter.c',
@@ -31,8 +29,7 @@ src = [
     'src/screen.c',
     'src/server.c',
     'src/version.c',
-    'src/trait/frame_source.c',
+    'src/video_buffer.c',
-    'src/trait/packet_source.c',
     'src/util/acksync.c',
     'src/util/average.c',
     'src/util/bytebuf.c',
@@ -40,7 +37,6 @@ src = [
     'src/util/intmap.c',
     'src/util/intr.c',
     'src/util/log.c',
-    'src/util/memory.c',
     'src/util/net.c',
     'src/util/net_intr.c',
     'src/util/process.c',
@@ -51,7 +47,6 @@ src = [
     'src/util/term.c',
     'src/util/thread.c',
     'src/util/tick.c',
-    'src/util/timeout.c',
 ]
 
 conf = configuration_data()
@@ -178,7 +173,6 @@ check_functions = [
     'vasprintf',
     'nrand48',
     'jrand48',
-    'reallocarray',
 ]
 
 foreach f : check_functions
@@ -269,6 +263,9 @@ if get_option('buildtype') == 'debug'
             'tests/test_bytebuf.c',
             'src/util/bytebuf.c',
         ]],
+        ['test_cbuf', [
+            'tests/test_cbuf.c',
+        ]],
         ['test_cli', [
             'tests/test_cli.c',
             'src/cli.c',
@@ -279,6 +276,10 @@ if get_option('buildtype') == 'debug'
             'src/util/strbuf.c',
             'src/util/term.c',
         ]],
+        ['test_clock', [
+            'tests/test_clock.c',
+            'src/clock.c',
+        ]],
         ['test_control_msg_serialize', [
             'tests/test_control_msg_serialize.c',
             'src/control_msg.c',
@@ -289,6 +290,9 @@ if get_option('buildtype') == 'debug'
             'tests/test_device_msg_deserialize.c',
             'src/device_msg.c',
         ]],
+        ['test_queue', [
+            'tests/test_queue.c',
+        ]],
         ['test_strbuf', [
             'tests/test_strbuf.c',
             'src/util/strbuf.c',
@@ -298,18 +302,13 @@ if get_option('buildtype') == 'debug'
             'src/util/str.c',
             'src/util/strbuf.c',
         ]],
-        ['test_vecdeque', [
-            'tests/test_vecdeque.c',
-            'src/util/memory.c',
-        ]],
         ['test_vector', [
             'tests/test_vector.c',
         ]],
     ]
 
     foreach t : tests
-        sources = t[1] + ['src/compat.c']
+        exe = executable(t[0], t[1],
-        exe = executable(t[0], sources,
                          include_directories: src_dir,
                          dependencies: dependencies,
                          c_args: ['-DSDL_MAIN_HANDLED', '-DSC_TEST'])

app/prebuilt-deps/prepare-adb.sh

@@ -6,10 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
 
-DEP_DIR=platform-tools-34.0.1
+DEP_DIR=platform-tools-33.0.3
 
-FILENAME=platform-tools_r34.0.1-windows.zip
+FILENAME=platform-tools_r33.0.3-windows.zip
-SHA256SUM=5dd9c2be744c224fa3a7cbe30ba02d2cb378c763bd0f797a7e47e9f3156a5daa
+SHA256SUM=1e59afd40a74c5c0eab0a9fad3f0faf8a674267106e0b19921be9f67081808c2
 
 if [[ -d "$DEP_DIR" ]]
 then

app/prebuilt-deps/prepare-ffmpeg.sh

@@ -6,11 +6,11 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
 
-VERSION=6.0-scrcpy-4
+VERSION=6.0-scrcpy
 DEP_DIR="ffmpeg-$VERSION"
 
 FILENAME="$DEP_DIR".7z
-SHA256SUM=39274b321491ce83e76cab5d24e7cbe3f402d3ccf382f739b13be5651c146b60
+SHA256SUM=f3956295b4325a84aada05447ba3f314fbed96697811666d495de4de40d59f98
 
 if [[ -d "$DEP_DIR" ]]
 then

app/prebuilt-deps/prepare-sdl.sh

@@ -6,10 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
 
-DEP_DIR=SDL2-2.28.0
+DEP_DIR=SDL2-2.26.1
 
-FILENAME=SDL2-devel-2.28.0-mingw.tar.gz
+FILENAME=SDL2-devel-2.26.1-mingw.tar.gz
-SHA256SUM=b91ce59eeacd4a9db403f976fd2337d9360b21ada374124417d716065c380e20
+SHA256SUM=aa43e1531a89551f9f9e14b27953a81d4ac946a9e574b5813cd0f2b36e83cc1c
 
 if [[ -d "$DEP_DIR" ]]
 then

app/scrcpy-windows.rc

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

app/scrcpy.1

@@ -23,52 +23,20 @@ Make scrcpy window always on top (above other windows).
 .BI "\-\-audio\-bit\-rate " value
 Encode the audio at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
 
-Default is 128K (128000).
+Default is 196K (196000).
-
-.TP
-.BI "\-\-audio\-buffer ms
-Configure the audio buffering delay (in milliseconds).
-
-Lower values decrease the latency, but increase the likelyhood of buffer underrun (causing audio glitches).
-
-Default is 50.
 
 .TP
 .BI "\-\-audio\-codec " name
-Select an audio codec (opus, aac or raw).
+Select an audio codec (opus or aac).
 
 Default is opus.
 
-.TP
-.BI "\-\-audio\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
-Set a list of comma-separated key:type=value options for the device audio encoder.
-
-The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
-
-The list of possible codec options is available in the Android documentation
-.UR https://d.android.com/reference/android/media/MediaFormat
-.UE .
-
 .TP
 .BI "\-\-audio\-encoder " name
 Use a specific MediaCodec audio encoder (depending on the codec provided by \fB\-\-audio\-codec\fR).
 
 The available encoders can be listed by \-\-list\-encoders.
 
-.TP
-.BI "\-\-audio\-source " source
-Select the audio source (output or mic).
-
-Default is output.
-
-.TP
-.BI "\-\-audio\-output\-buffer ms
-Configure the size of the SDL audio output buffer (in milliseconds).
-
-If you get "robotic" audio playback, you should test with a higher value (10). Do not change this setting otherwise.
-
-Default is 5.
-
 .TP
 .BI "\-b, \-\-video\-bit\-rate " value
 Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
@@ -113,10 +81,6 @@ Use TCP/IP device (if there is exactly one, like adb -e).
 
 Also see \fB\-d\fR (\fB\-\-select\-usb\fR).
 
-.TP
-.B \-f, \-\-fullscreen
-Start in fullscreen.
-
 .TP
 .B \-\-force\-adb\-forward
 Do not attempt to use "adb reverse" to connect to the device.
@@ -126,12 +90,12 @@ Do not attempt to use "adb reverse" to connect to the device.
 By default, right-click triggers BACK (or POWER on) and middle-click triggers HOME. This option disables these shortcuts and forward the clicks to the device instead.
 
 .TP
-.B \-h, \-\-help
+.B \-f, \-\-fullscreen
-Print this help.
+Start in fullscreen.
 
 .TP
-.B \-\-kill\-adb\-on\-close
+.B \-h, \-\-help
-Kill adb when scrcpy terminates.
+Print this help.
 
 .TP
 .B \-K, \-\-hid\-keyboard
@@ -171,6 +135,10 @@ Default is "unlocked".
 
 Passing the option without argument is equivalent to passing "initial".
 
+.TP
+.BI "\-\-max\-fps " value
+Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
+
 .TP
 .BI "\-m, \-\-max\-size " value
 Limit both the width and height of the video to \fIvalue\fR. The other dimension is computed so that the device aspect\-ratio is preserved.
@@ -189,26 +157,6 @@ It may only work over USB.
 
 Also see \fB\-\-hid\-keyboard\fR.
 
-.TP
-.BI "\-\-max\-fps " value
-Limit the framerate of screen capture (officially supported since Android 10, but may work on earlier versions).
-
-.TP
-.B \-n, \-\-no\-control
-Disable device control (mirror the device in read\-only).
-
-.TP
-.B \-N, \-\-no\-playback
-Disable video and audio playback on the computer (equivalent to --no-video-playback --no-audio-playback).
-
-.TP
-.B \-\-no\-audio
-Disable audio forwarding.
-
-.TP
-.B \-\-no\-audio\-playback
-Disable audio playback on the computer.
-
 .TP
 .B \-\-no\-cleanup
 By default, scrcpy removes the server binary from the device and restores the device state (show touches, stay awake and power mode) on exit.
@@ -227,6 +175,14 @@ By default, on MediaCodec error, scrcpy automatically tries again with a lower d
 
 This option disables this behavior.
 
+.TP
+.B \-n, \-\-no\-control
+Disable device control (mirror the device in read\-only).
+
+.TP
+.B \-N, \-\-no\-display
+Do not display device (only when screen recording is enabled).
+
 .TP
 .B \-\-no\-key\-repeat
 Do not forward repeated key events when a key is held down.
@@ -239,14 +195,6 @@ If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then mipmaps are automatically
 .B \-\-no\-power\-on
 Do not power on the device on start.
 
-.TP
-.B \-\-no\-video
-Disable video forwarding.
-
-.TP
-.B \-\-no\-video\-playback
-Disable video playback on the computer.
-
 .TP
 .B \-\-otg
 Run in OTG mode: simulate physical keyboard and mouse, as if the computer keyboard and mouse were plugged directly to the device via an OTG cable.
@@ -288,6 +236,10 @@ Set the target directory for pushing files to the device by drag & drop. It is p
 
 Default is "/sdcard/Download/".
 
+.TP
+.B \-\-raw\-key\-events
+Inject key events for all input keys, and ignore text events.
+
 .TP
 .BI "\-r, \-\-record " file
 Record screen to
@@ -297,10 +249,6 @@ The format is determined by the
 .B \-\-record\-format
 option if set, or by the file extension (.mp4 or .mkv).
 
-.TP
-.B \-\-raw\-key\-events
-Inject key events for all input keys, and ignore text events.
-
 .TP
 .BI "\-\-record\-format " format
 Force recording format (either mp4 or mkv).
@@ -314,10 +262,6 @@ Supported names are currently "direct3d", "opengl", "opengles2", "opengles", "me
 .UR https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER
 .UE
 
-.TP
-.B \-\-require\-audio
-By default, scrcpy mirrors only the video if audio capture fails on the device. This option makes scrcpy fail if audio is enabled but does not work.
-
 .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.
@@ -326,10 +270,6 @@ Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each incre
 .BI "\-s, \-\-serial " number
 The device serial number. Mandatory only if several devices are connected to adb.
 
-.TP
-.B \-S, \-\-turn\-screen\-off
-Turn the device screen off immediately.
-
 .TP
 .BI "\-\-shortcut\-mod " key\fR[+...]][,...]
 Specify the modifiers to use for scrcpy shortcuts. Possible keys are "lctrl", "rctrl", "lalt", "ralt", "lsuper" and "rsuper".
@@ -340,12 +280,6 @@ For example, to use either LCtrl+LAlt or LSuper for scrcpy shortcuts, pass "lctr
 
 Default is "lalt,lsuper" (left-Alt or left-Super).
 
-.TP
-.B \-t, \-\-show\-touches
-Enable "show touches" on start, restore the initial value on exit.
-
-It only shows physical touches (not clicks from scrcpy).
-
 .TP
 .BI "\-\-tcpip\fR[=\fIip\fR[:\fIport\fR]]
 Configure and reconnect the device over TCP/IP.
@@ -355,8 +289,14 @@ If a destination address is provided, then scrcpy connects to this address befor
 If no destination address is provided, then scrcpy attempts to find the IP address and adb port of the current device (typically connected over USB), enables TCP/IP mode if necessary, then connects to this address before starting.
 
 .TP
-.BI "\-\-time\-limit " seconds
+.B \-S, \-\-turn\-screen\-off
-Set the maximum mirroring time, in seconds.
+Turn the device screen off immediately.
+
+.TP
+.B \-t, \-\-show\-touches
+Enable "show touches" on start, restore the initial value on exit.
+
+It only shows physical touches (not clicks from scrcpy).
 
 .TP
 .BI "\-\-tunnel\-host " ip
@@ -370,16 +310,6 @@ Set the TCP port of the adb tunnel to reach the scrcpy server. This option autom
 
 Default is 0 (not forced): the local port used for establishing the tunnel will be used.
 
-.TP
-.B \-v, \-\-version
-Print the version of scrcpy.
-
-.TP
-.BI "\-V, \-\-verbosity " value
-Set the log level ("verbose", "debug", "info", "warn" or "error").
-
-Default is "info" for release builds, "debug" for debug builds.
-
 .TP
 .BI "\-\-v4l2-sink " /dev/videoN
 Output to v4l2loopback device.
@@ -394,6 +324,16 @@ This option is similar to \fB\-\-display\-buffer\fR, but specific to V4L2 sink.
 
 Default is 0 (no buffering).
 
+.TP
+.BI "\-V, \-\-verbosity " value
+Set the log level ("verbose", "debug", "info", "warn" or "error").
+
+Default is "info" for release builds, "debug" for debug builds.
+
+.TP
+.B \-v, \-\-version
+Print the version of scrcpy.
+
 .TP
 .BI "\-\-video\-codec " name
 Select a video codec (h264, h265 or av1).
@@ -609,7 +549,7 @@ Copyright \(co 2018 Genymobile
 Genymobile
 .UE
 
-Copyright \(co 2018\-2023
+Copyright \(co 2018\-2022
 .MT rom@rom1v.com
 Romain Vimont
 .ME

app/src/adb/adb_parser.c

@@ -204,7 +204,6 @@ sc_adb_parse_device_ip(char *str) {
     while (str[idx_line] != '\0') {
         char *line = &str[idx_line];
         size_t len = strcspn(line, "\n");
-        bool is_last_line = line[len] == '\0';
 
         // The same, but without any trailing '\r'
         size_t line_len = sc_str_remove_trailing_cr(line, len);
@@ -216,12 +215,12 @@ sc_adb_parse_device_ip(char *str) {
             return ip;
         }
 
-        if (is_last_line) {
+        idx_line += len;
-            break;
-        }
 
-        // The next line starts after the '\n'
+        if (str[idx_line] != '\0') {
-        idx_line += len + 1;
+            // The next line starts after the '\n'
+            ++idx_line;
+        }
     }
 
     return NULL;

app/src/audio_player.c

@@ -1,127 +1,93 @@
 #include "audio_player.h"
 
-#include <libavcodec/avcodec.h>
 #include <libavutil/opt.h>
 
 #include "util/log.h"
 
 #define SC_AUDIO_PLAYER_NDEBUG // comment to debug
 
-/**
- * Real-time audio player with configurable latency
- *
- * As input, the player regularly receives AVFrames of decoded audio samples.
- * As output, an SDL callback regularly requests audio samples to be played.
- * In the middle, an audio buffer stores the samples produced but not consumed
- * yet.
- *
- * The goal of the player is to feed the audio output with a latency as low as
- * possible while avoiding buffer underrun (i.e. not being able to provide
- * samples when requested).
- *
- * The player aims to feed the audio output with as little latency as possible
- * while avoiding buffer underrun. To achieve this, it attempts to maintain the
- * average buffering (the number of samples present in the buffer) around a
- * target value. If this target buffering is too low, then buffer underrun will
- * occur frequently. If it is too high, then latency will become unacceptable.
- * This target value is configured using the scrcpy option --audio-buffer.
- *
- * The player cannot adjust the sample input rate (it receives samples produced
- * in real-time) or the sample output rate (it must provide samples as
- * requested by the audio output callback). Therefore, it may only apply
- * compensation by resampling (converting _m_ input samples to _n_ output
- * samples).
- *
- * The compensation itself is applied by libswresample (FFmpeg). It is
- * configured using swr_set_compensation(). An important work for the player
- * is to estimate the compensation value regularly and apply it.
- *
- * The estimated buffering level is the result of averaging the "natural"
- * buffering (samples are produced and consumed by blocks, so it must be
- * smoothed), and making instant adjustments resulting of its own actions
- * (explicit compensation and silence insertion on underflow), which are not
- * smoothed.
- *
- * Buffer underflow events can occur when packets arrive too late. In that case,
- * the player inserts silence. Once the packets finally arrive (late), one
- * strategy could be to drop the samples that were replaced by silence, in
- * order to keep a minimal latency. However, dropping samples in case of buffer
- * underflow is inadvisable, as it would temporarily increase the underflow
- * even more and cause very noticeable audio glitches.
- *
- * Therefore, the player doesn't drop any sample on underflow. The compensation
- * mechanism will absorb the delay introduced by the inserted silence.
- */
-
 /** Downcast frame_sink to sc_audio_player */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_audio_player, frame_sink)
 
 #define SC_AV_SAMPLE_FMT AV_SAMPLE_FMT_FLT
 #define SC_SDL_SAMPLE_FMT AUDIO_F32
 
-#define TO_BYTES(SAMPLES) sc_audiobuf_to_bytes(&ap->buf, (SAMPLES))
+#define SC_AUDIO_OUTPUT_BUFFER_SAMPLES 480 // 10ms at 48000Hz
-#define TO_SAMPLES(BYTES) sc_audiobuf_to_samples(&ap->buf, (BYTES))
 
-static void SDLCALL
+// The target number of buffered samples between the producer and the consumer.
+// This value is directly use for compensation.
+#define SC_TARGET_BUFFERED_SAMPLES (3 * SC_AUDIO_OUTPUT_BUFFER_SAMPLES)
+
+// If the consumer is too late, skip samples to keep at most this value
+#define SC_BUFFERED_SAMPLES_THRESHOLD 2400 // 50ms at 48000Hz
+
+// Use a ring-buffer of 1 second (at 48000Hz) between the producer and the
+// consumer. It too big, but it guarantees that the producer and the consumer
+// will be able to access it in parallel without locking.
+#define SC_BYTEBUF_SIZE_IN_SAMPLES 48000
+
+void
 sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
     struct sc_audio_player *ap = userdata;
 
     // This callback is called with the lock used by SDL_AudioDeviceLock(), so
-    // the audiobuf is protected
+    // the bytebuf is protected
 
     assert(len_int > 0);
     size_t len = len_int;
-    uint32_t count = TO_SAMPLES(len);
 
 #ifndef SC_AUDIO_PLAYER_NDEBUG
-    LOGD("[Audio] SDL callback requests %" PRIu32 " samples", count);
+    LOGD("[Audio] SDL callback requests %" SC_PRIsizet " samples",
+         len / (ap->nb_channels * ap->out_bytes_per_sample));
 #endif
 
-    uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
+    size_t read = sc_bytebuf_read_remaining(&ap->buf);
-    if (!ap->played) {
+    size_t max_buffered_bytes = SC_BUFFERED_SAMPLES_THRESHOLD
-        // Part of the buffering is handled by inserting initial silence. The
+                              * ap->nb_channels * ap->out_bytes_per_sample;
-        // remaining (margin) last samples will be handled by compensation.
+    if (read > max_buffered_bytes + len) {
-        uint32_t margin = 30 * ap->sample_rate / 1000; // 30ms
+        size_t skip = read - (max_buffered_bytes + len);
-        if (buffered_samples + margin < ap->target_buffering) {
+#ifndef SC_AUDIO_PLAYER_NDEBUG
-            LOGV("[Audio] Inserting initial buffering silence: %" PRIu32
+        LOGD("[Audio] Buffered samples threshold exceeded: %" SC_PRIsizet
-                 " samples", count);
+             " bytes, skipping %" SC_PRIsizet " bytes", read, skip);
-            // Delay playback starting to reach the target buffering. Fill the
+#endif
-            // whole buffer with silence (len is small compared to the
+        // After this callback, exactly max_buffered_bytes will remain
-            // arbitrary margin value).
+        sc_bytebuf_skip(&ap->buf, skip);
-            memset(stream, 0, len);
+        read = max_buffered_bytes + len;
-            return;
-        }
     }
 
-    uint32_t read = MIN(buffered_samples, count);
+    // Number of buffered samples (may be negative on underflow)
+    float buffered_samples = ((float) read - len_int)
+                           / (ap->nb_channels * ap->out_bytes_per_sample);
+    sc_average_push(&ap->avg_buffered_samples, buffered_samples);
+
     if (read) {
-        sc_audiobuf_read(&ap->buf, stream, read);
+        if (read > len) {
-    }
+            read = len;
-
-    if (read < count) {
-        uint32_t silence = count - read;
-        // Insert silence. In theory, the inserted silent samples replace the
-        // missing real samples, which will arrive later, so they should be
-        // dropped to keep the latency minimal. However, this would cause very
-        // audible glitches, so let the clock compensation restore the target
-        // latency.
-        LOGD("[Audio] Buffer underflow, inserting silence: %" PRIu32 " samples",
-             silence);
-        memset(stream + TO_BYTES(read), 0, TO_BYTES(silence));
-
-        if (ap->received) {
-            // Inserting additional samples immediately increases buffering
-            ap->underflow += silence;
         }
+        sc_bytebuf_read(&ap->buf, stream, read);
     }
 
-    ap->played = true;
+    if (read < len) {
+        // Insert silence
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+        LOGD("[Audio] Buffer underflow, inserting silence: %" SC_PRIsizet
+             " bytes", len - read);
+#endif
+        memset(stream + read, 0, len - read);
+    }
+}
+
+static size_t
+sc_audio_player_get_buf_size(struct sc_audio_player *ap, size_t samples) {
+    assert(ap->nb_channels);
+    assert(ap->out_bytes_per_sample);
+    return samples * ap->nb_channels * ap->out_bytes_per_sample;
 }
 
 static uint8_t *
-sc_audio_player_get_swr_buf(struct sc_audio_player *ap, uint32_t min_samples) {
+sc_audio_player_get_swr_buf(struct sc_audio_player *ap, size_t min_samples) {
-    size_t min_buf_size = TO_BYTES(min_samples);
+    size_t min_buf_size = sc_audio_player_get_buf_size(ap, min_samples);
-    if (min_buf_size > ap->swr_buf_alloc_size) {
+    if (min_buf_size < ap->swr_buf_alloc_size) {
         size_t new_size = min_buf_size + 4096;
         uint8_t *buf = realloc(ap->swr_buf, new_size);
         if (!buf) {
@@ -136,188 +102,6 @@ sc_audio_player_get_swr_buf(struct sc_audio_player *ap, uint32_t min_samples) {
     return ap->swr_buf;
 }
 
-static bool
-sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
-                                const AVFrame *frame) {
-    struct sc_audio_player *ap = DOWNCAST(sink);
-
-    SwrContext *swr_ctx = ap->swr_ctx;
-
-    int64_t swr_delay = swr_get_delay(swr_ctx, ap->sample_rate);
-    // No need to av_rescale_rnd(), input and output sample rates are the same.
-    // Add more space (256) for clock compensation.
-    int dst_nb_samples = swr_delay + frame->nb_samples + 256;
-
-    uint8_t *swr_buf = sc_audio_player_get_swr_buf(ap, dst_nb_samples);
-    if (!swr_buf) {
-        return false;
-    }
-
-    int ret = swr_convert(swr_ctx, &swr_buf, dst_nb_samples,
-                          (const uint8_t **) frame->data, frame->nb_samples);
-    if (ret < 0) {
-        LOGE("Resampling failed: %d", ret);
-        return false;
-    }
-
-    // swr_convert() returns the number of samples which would have been
-    // written if the buffer was big enough.
-    uint32_t samples_written = MIN(ret, dst_nb_samples);
-#ifndef SC_AUDIO_PLAYER_NDEBUG
-    LOGD("[Audio] %" PRIu32 " samples written to buffer", samples_written);
-#endif
-
-    // Since this function is the only writer, the current available space is
-    // at least the previous available space. In practice, it should almost
-    // always be possible to write without lock.
-    bool lockless_write = samples_written <= ap->previous_can_write;
-    if (lockless_write) {
-        sc_audiobuf_prepare_write(&ap->buf, swr_buf, samples_written);
-    }
-
-    SDL_LockAudioDevice(ap->device);
-
-    uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
-
-    if (lockless_write) {
-        sc_audiobuf_commit_write(&ap->buf, samples_written);
-    } else {
-        uint32_t can_write = sc_audiobuf_can_write(&ap->buf);
-        if (samples_written > can_write) {
-            // Entering this branch is very unlikely, the audio buffer is
-            // allocated with a size sufficient to store 1 second more than the
-            // target buffering. If this happens, though, we have to skip old
-            // samples.
-            uint32_t cap = sc_audiobuf_capacity(&ap->buf);
-            if (samples_written > cap) {
-                // Very very unlikely: a single resampled frame should never
-                // exceed the audio buffer size (or something is very wrong).
-                // Ignore the first bytes in swr_buf
-                swr_buf += TO_BYTES(samples_written - cap);
-                // This change in samples_written will impact the
-                // instant_compensation below
-                samples_written = cap;
-            }
-
-            assert(samples_written >= can_write);
-            if (samples_written > can_write) {
-                uint32_t skip_samples = samples_written - can_write;
-                assert(buffered_samples >= skip_samples);
-                sc_audiobuf_skip(&ap->buf, skip_samples);
-                buffered_samples -= skip_samples;
-                if (ap->played) {
-                    // Dropping input samples instantly decreases buffering
-                    ap->avg_buffering.avg -= skip_samples;
-                }
-            }
-
-            // It should remain exactly the expected size to write the new
-            // samples.
-            assert(sc_audiobuf_can_write(&ap->buf) == samples_written);
-        }
-
-        sc_audiobuf_write(&ap->buf, swr_buf, samples_written);
-    }
-
-    buffered_samples += samples_written;
-    assert(buffered_samples == sc_audiobuf_can_read(&ap->buf));
-
-    // Read with lock held, to be used after unlocking
-    bool played = ap->played;
-    uint32_t underflow = ap->underflow;
-
-    if (played) {
-        uint32_t max_buffered_samples = ap->target_buffering
-                                      + 12 * ap->output_buffer
-                                      + ap->target_buffering / 10;
-        if (buffered_samples > max_buffered_samples) {
-            uint32_t skip_samples = buffered_samples - max_buffered_samples;
-            sc_audiobuf_skip(&ap->buf, skip_samples);
-            LOGD("[Audio] Buffering threshold exceeded, skipping %" PRIu32
-                 " samples", skip_samples);
-        }
-
-        // reset (the current value was copied to a local variable)
-        ap->underflow = 0;
-    } else {
-        // SDL playback not started yet, do not accumulate more than
-        // max_initial_buffering samples, this would cause unnecessary delay
-        // (and glitches to compensate) on start.
-        uint32_t max_initial_buffering = ap->target_buffering
-                                       + 2 * ap->output_buffer;
-        if (buffered_samples > max_initial_buffering) {
-            uint32_t skip_samples = buffered_samples - max_initial_buffering;
-            sc_audiobuf_skip(&ap->buf, skip_samples);
-#ifndef SC_AUDIO_PLAYER_NDEBUG
-            LOGD("[Audio] Playback not started, skipping %" PRIu32 " samples",
-                 skip_samples);
-#endif
-        }
-    }
-
-    ap->previous_can_write = sc_audiobuf_can_write(&ap->buf);
-    ap->received = true;
-
-    SDL_UnlockAudioDevice(ap->device);
-
-    if (played) {
-        // Number of samples added (or removed, if negative) for compensation
-        int32_t instant_compensation =
-            (int32_t) samples_written - frame->nb_samples;
-        int32_t inserted_silence = (int32_t) underflow;
-
-        // The compensation must apply instantly, it must not be smoothed
-        ap->avg_buffering.avg += instant_compensation + inserted_silence;
-
-
-        // However, the buffering level must be smoothed
-        sc_average_push(&ap->avg_buffering, buffered_samples);
-
-#ifndef SC_AUDIO_PLAYER_NDEBUG
-        LOGD("[Audio] buffered_samples=%" PRIu32 " avg_buffering=%f",
-             buffered_samples, sc_average_get(&ap->avg_buffering));
-#endif
-
-        ap->samples_since_resync += samples_written;
-        if (ap->samples_since_resync >= ap->sample_rate) {
-            // Recompute compensation every second
-            ap->samples_since_resync = 0;
-
-            float avg = sc_average_get(&ap->avg_buffering);
-            int diff = ap->target_buffering - avg;
-            if (abs(diff) < (int) ap->sample_rate / 1000) {
-                // Do not compensate for less than 1ms, the error is just noise
-                diff = 0;
-            } else if (diff < 0 && buffered_samples < ap->target_buffering) {
-                // Do not accelerate if the instant buffering level is below
-                // the average, this would increase underflow
-                diff = 0;
-            }
-            // Compensate the diff over 4 seconds (but will be recomputed after
-            // 1 second)
-            int distance = 4 * ap->sample_rate;
-            // Limit compensation rate to 2%
-            int abs_max_diff = distance / 50;
-            diff = CLAMP(diff, -abs_max_diff, abs_max_diff);
-            LOGV("[Audio] Buffering: target=%" PRIu32 " avg=%f cur=%" PRIu32
-                 " compensation=%d", ap->target_buffering, avg,
-                 buffered_samples, diff);
-
-            if (diff != ap->compensation) {
-                int ret = swr_set_compensation(swr_ctx, diff, distance);
-                if (ret < 0) {
-                    LOGW("Resampling compensation failed: %d", ret);
-                    // not fatal
-                } else {
-                    ap->compensation = diff;
-                }
-            }
-        }
-    }
-
-    return true;
-}
-
 static bool
 sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
                                 const AVCodecContext *ctx) {
@@ -331,28 +115,11 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
     unsigned nb_channels = tmp;
 #endif
 
-    assert(ctx->sample_rate > 0);
-    assert(!av_sample_fmt_is_planar(SC_AV_SAMPLE_FMT));
-    int out_bytes_per_sample = av_get_bytes_per_sample(SC_AV_SAMPLE_FMT);
-    assert(out_bytes_per_sample > 0);
-
-    ap->sample_rate = ctx->sample_rate;
-    ap->nb_channels = nb_channels;
-    ap->out_bytes_per_sample = out_bytes_per_sample;
-
-    ap->target_buffering = ap->target_buffering_delay * ap->sample_rate
-                                                      / SC_TICK_FREQ;
-
-    uint64_t aout_samples = ap->output_buffer_duration * ap->sample_rate
-                                                       / SC_TICK_FREQ;
-    assert(aout_samples <= 0xFFFF);
-    ap->output_buffer = (uint16_t) aout_samples;
-
     SDL_AudioSpec desired = {
         .freq = ctx->sample_rate,
         .format = SC_SDL_SAMPLE_FMT,
         .channels = nb_channels,
-        .samples = aout_samples,
+        .samples = SC_AUDIO_OUTPUT_BUFFER_SAMPLES,
         .callback = sc_audio_player_sdl_callback,
         .userdata = ap,
     };
@@ -371,6 +138,12 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
     }
     ap->swr_ctx = swr_ctx;
 
+    assert(ctx->sample_rate > 0);
+    assert(!av_sample_fmt_is_planar(SC_AV_SAMPLE_FMT));
+
+    int out_bytes_per_sample = av_get_bytes_per_sample(SC_AV_SAMPLE_FMT);
+    assert(out_bytes_per_sample > 0);
+
 #ifdef SCRCPY_LAVU_HAS_CHLAYOUT
     av_opt_set_chlayout(swr_ctx, "in_chlayout", &ctx->ch_layout, 0);
     av_opt_set_chlayout(swr_ctx, "out_chlayout", &ctx->ch_layout, 0);
@@ -393,52 +166,37 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
         goto error_free_swr_ctx;
     }
 
-    // Use a ring-buffer of the target buffering size plus 1 second between the
+    ap->sample_rate = ctx->sample_rate;
-    // producer and the consumer. It's too big on purpose, to guarantee that
+    ap->nb_channels = nb_channels;
-    // the producer and the consumer will be able to access it in parallel
+    ap->out_bytes_per_sample = out_bytes_per_sample;
-    // without locking.
-    size_t audiobuf_samples = ap->target_buffering + ap->sample_rate;
 
-    size_t sample_size = ap->nb_channels * ap->out_bytes_per_sample;
+    size_t bytebuf_size =
-    bool ok = sc_audiobuf_init(&ap->buf, sample_size, audiobuf_samples);
+        sc_audio_player_get_buf_size(ap, SC_BYTEBUF_SIZE_IN_SAMPLES);
+
+    bool ok = sc_bytebuf_init(&ap->buf, bytebuf_size);
     if (!ok) {
         goto error_free_swr_ctx;
     }
 
-    size_t initial_swr_buf_size = TO_BYTES(4096);
+    ap->safe_empty_buffer = sc_bytebuf_write_remaining(&ap->buf);
+
+    size_t initial_swr_buf_size = sc_audio_player_get_buf_size(ap, 4096);
     ap->swr_buf = malloc(initial_swr_buf_size);
     if (!ap->swr_buf) {
         LOG_OOM();
-        goto error_destroy_audiobuf;
+        goto error_destroy_bytebuf;
     }
     ap->swr_buf_alloc_size = initial_swr_buf_size;
 
-    ap->previous_can_write = sc_audiobuf_can_write(&ap->buf);
+    sc_average_init(&ap->avg_buffered_samples, 32);
-
-    // Samples are produced and consumed by blocks, so the buffering must be
-    // smoothed to get a relatively stable value.
-    sc_average_init(&ap->avg_buffering, 32);
     ap->samples_since_resync = 0;
 
-    ap->received = false;
-    ap->played = false;
-    ap->underflow = 0;
-    ap->compensation = 0;
-
-    // The thread calling open() is the thread calling push(), which fills the
-    // audio buffer consumed by the SDL audio thread.
-    ok = sc_thread_set_priority(SC_THREAD_PRIORITY_TIME_CRITICAL);
-    if (!ok) {
-        ok = sc_thread_set_priority(SC_THREAD_PRIORITY_HIGH);
-        (void) ok; // We don't care if it worked, at least we tried
-    }
-
     SDL_PauseAudioDevice(ap->device, 0);
 
     return true;
 
-error_destroy_audiobuf:
+error_destroy_bytebuf:
-    sc_audiobuf_destroy(&ap->buf);
+    sc_bytebuf_destroy(&ap->buf);
 error_free_swr_ctx:
     swr_free(&ap->swr_ctx);
 error_close_audio_device:
@@ -456,16 +214,86 @@ sc_audio_player_frame_sink_close(struct sc_frame_sink *sink) {
     SDL_CloseAudioDevice(ap->device);
 
     free(ap->swr_buf);
-    sc_audiobuf_destroy(&ap->buf);
+    sc_bytebuf_destroy(&ap->buf);
     swr_free(&ap->swr_ctx);
 }
 
-void
+static bool
-sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering,
+sc_audio_player_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
-                     sc_tick output_buffer_duration) {
+    struct sc_audio_player *ap = DOWNCAST(sink);
-    ap->target_buffering_delay = target_buffering;
-    ap->output_buffer_duration = output_buffer_duration;
 
+    SwrContext *swr_ctx = ap->swr_ctx;
+
+    int64_t delay = swr_get_delay(swr_ctx, ap->sample_rate);
+    // No need to av_rescale_rnd(), input and output sample rates are the same
+    int dst_nb_samples = delay + frame->nb_samples;
+
+    uint8_t *swr_buf = sc_audio_player_get_swr_buf(ap, frame->nb_samples);
+    if (!swr_buf) {
+        return false;
+    }
+
+    int ret = swr_convert(swr_ctx, &swr_buf, dst_nb_samples,
+                          (const uint8_t **) frame->data, frame->nb_samples);
+    if (ret < 0) {
+        LOGE("Resampling failed: %d", ret);
+        return false;
+    }
+
+    size_t samples_written = ret;
+    size_t swr_buf_size = sc_audio_player_get_buf_size(ap, samples_written);
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+    LOGI("[Audio] %" SC_PRIsizet " samples written to buffer", samples_written);
+#endif
+
+    // It should almost always be possible to write without lock
+    bool can_write_without_lock = swr_buf_size <= ap->safe_empty_buffer;
+    if (can_write_without_lock) {
+        sc_bytebuf_prepare_write(&ap->buf, swr_buf, swr_buf_size);
+    }
+
+    SDL_LockAudioDevice(ap->device);
+    if (can_write_without_lock) {
+        sc_bytebuf_commit_write(&ap->buf, swr_buf_size);
+    } else {
+        sc_bytebuf_write(&ap->buf, swr_buf, swr_buf_size);
+    }
+
+    // The next time, it will remain at least the current empty space
+    ap->safe_empty_buffer = sc_bytebuf_write_remaining(&ap->buf);
+
+    // Read the value written by the SDL thread under lock
+    float avg;
+    bool has_avg = sc_average_get(&ap->avg_buffered_samples, &avg);
+
+    SDL_UnlockAudioDevice(ap->device);
+
+    if (has_avg) {
+        ap->samples_since_resync += samples_written;
+        if (ap->samples_since_resync >= ap->sample_rate) {
+            // Resync every second
+            ap->samples_since_resync = 0;
+
+            int diff = SC_TARGET_BUFFERED_SAMPLES - avg;
+#ifndef SC_AUDIO_PLAYER_NDEBUG
+            LOGI("[Audio] Average buffered samples = %f, compensation %d",
+                 avg, diff);
+#endif
+            // Compensate the diff over 3 seconds (but will be recomputed after
+            // 1 second)
+            int ret = swr_set_compensation(swr_ctx, diff, 3 * ap->sample_rate);
+            if (ret < 0) {
+                LOGW("Resampling compensation failed: %d", ret);
+                // not fatal
+            }
+        }
+    }
+
+    return true;
+}
+
+void
+sc_audio_player_init(struct sc_audio_player *ap) {
     static const struct sc_frame_sink_ops ops = {
         .open = sc_audio_player_frame_sink_open,
         .close = sc_audio_player_frame_sink_close,

app/src/audio_player.h

@@ -5,10 +5,9 @@
 
 #include <stdbool.h>
 #include "trait/frame_sink.h"
-#include <util/audiobuf.h>
 #include <util/average.h>
+#include <util/bytebuf.h>
 #include <util/thread.h>
-#include <util/tick.h>
 
 #include <libavformat/avformat.h>
 #include <libswresample/swresample.h>
@@ -19,61 +18,27 @@ struct sc_audio_player {
 
     SDL_AudioDeviceID device;
 
-    // The target buffering between the producer and the consumer. This value
+    // protected by SDL_AudioDeviceLock()
-    // is directly use for compensation.
+    struct sc_bytebuf buf;
-    // Since audio capture and/or encoding on the device typically produce
+    // Number of bytes which could be written without locking
-    // blocks of 960 samples (20ms) or 1024 samples (~21.3ms), this target
+    size_t safe_empty_buffer;
-    // value should be higher.
-    sc_tick target_buffering_delay;
-    uint32_t target_buffering; // in samples
 
-    // SDL audio output buffer size.
-    sc_tick output_buffer_duration;
-    uint16_t output_buffer;
-
-    // Audio buffer to communicate between the receiver and the SDL audio
-    // callback (protected by SDL_AudioDeviceLock())
-    struct sc_audiobuf buf;
-
-    // The previous empty space in the buffer (only used by the receiver
-    // thread)
-    uint32_t previous_can_write;
-
-    // Resampler (only used from the receiver thread)
     struct SwrContext *swr_ctx;
 
     // The sample rate is the same for input and output
     unsigned sample_rate;
     // The number of channels is the same for input and output
     unsigned nb_channels;
-    // The number of bytes per sample for a single channel
+
     unsigned out_bytes_per_sample;
 
-    // Target buffer for resampling (only used by the receiver thread)
+    // Target buffer for resampling
     uint8_t *swr_buf;
     size_t swr_buf_alloc_size;
 
-    // Number of buffered samples (may be negative on underflow) (only used by
+    // Number of buffered samples (may be negative on underflow)
-    // the receiver thread)
+    struct sc_average avg_buffered_samples;
-    struct sc_average avg_buffering;
+    unsigned samples_since_resync;
-    // Count the number of samples to trigger a compensation update regularly
-    // (only used by the receiver thread)
-    uint32_t samples_since_resync;
-
-    // Number of silence samples inserted since the last received packet
-    // (protected by SDL_AudioDeviceLock())
-    uint32_t underflow;
-
-    // Current applied compensation value (only used by the receiver thread)
-    int compensation;
-
-    // Set to true the first time a sample is received (protected by
-    // SDL_AudioDeviceLock())
-    bool received;
-
-    // Set to true the first time the SDL callback is called (protected by
-    // SDL_AudioDeviceLock())
-    bool played;
 
     const struct sc_audio_player_callbacks *cbs;
     void *cbs_userdata;
@@ -84,7 +49,6 @@ struct sc_audio_player_callbacks {
 };
 
 void
-sc_audio_player_init(struct sc_audio_player *ap, sc_tick target_buffering,
+sc_audio_player_init(struct sc_audio_player *ap);
-                     sc_tick audio_output_buffer);
 
 #endif

app/src/cli.c

@@ -18,7 +18,7 @@
 #define STR(x) STR_IMPL_(x)
 
 enum {
-    OPT_BIT_RATE = 1000,
+    OPT_RENDER_EXPIRED_FRAMES = 1000,
     OPT_WINDOW_TITLE,
     OPT_PUSH_TARGET,
     OPT_ALWAYS_ON_TOP,
@@ -69,16 +69,6 @@ enum {
     OPT_AUDIO_ENCODER,
     OPT_LIST_ENCODERS,
     OPT_LIST_DISPLAYS,
-    OPT_REQUIRE_AUDIO,
-    OPT_AUDIO_BUFFER,
-    OPT_AUDIO_OUTPUT_BUFFER,
-    OPT_NO_DISPLAY,
-    OPT_NO_VIDEO,
-    OPT_NO_AUDIO_PLAYBACK,
-    OPT_NO_VIDEO_PLAYBACK,
-    OPT_AUDIO_SOURCE,
-    OPT_KILL_ADB_ON_CLOSE,
-    OPT_TIME_LIMIT,
 };
 
 struct sc_option {
@@ -126,22 +116,13 @@ static const struct sc_option options[] = {
         .argdesc = "value",
         .text = "Encode the audio at the given bit-rate, expressed in bits/s. "
                 "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
-                "Default is 128K (128000).",
+                "Default is 196K (196000).",
-    },
-    {
-        .longopt_id = OPT_AUDIO_BUFFER,
-        .longopt = "audio-buffer",
-        .argdesc = "ms",
-        .text = "Configure the audio buffering delay (in milliseconds).\n"
-                "Lower values decrease the latency, but increase the "
-                "likelyhood of buffer underrun (causing audio glitches).\n"
-                "Default is 50.",
     },
     {
         .longopt_id = OPT_AUDIO_CODEC,
         .longopt = "audio-codec",
         .argdesc = "name",
-        .text = "Select an audio codec (opus, aac or raw).\n"
+        .text = "Select an audio codec (opus or aac).\n"
                 "Default is opus.",
     },
     {
@@ -164,23 +145,6 @@ static const struct sc_option options[] = {
                 "codec provided by --audio-codec).\n"
                 "The available encoders can be listed by --list-encoders.",
     },
-    {
-        .longopt_id = OPT_AUDIO_SOURCE,
-        .longopt = "audio-source",
-        .argdesc = "source",
-        .text = "Select the audio source (output or mic).\n"
-                "Default is output.",
-    },
-    {
-        .longopt_id = OPT_AUDIO_OUTPUT_BUFFER,
-        .longopt = "audio-output-buffer",
-        .argdesc = "ms",
-        .text = "Configure the size of the SDL audio output buffer (in "
-                "milliseconds).\n"
-                "If you get \"robotic\" audio playback, you should test with "
-                "a higher value (10). Do not change this setting otherwise.\n"
-                "Default is 5.",
-    },
     {
         .shortopt = 'b',
         .longopt = "video-bit-rate",
@@ -189,12 +153,6 @@ static const struct sc_option options[] = {
                 "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
                 "Default is 8M (8000000).",
     },
-    {
-        // deprecated
-        .longopt_id = OPT_BIT_RATE,
-        .longopt = "bit-rate",
-        .argdesc = "value",
-    },
     {
         // Not really deprecated (--codec has never been released), but without
         // declaring an explicit --codec option, getopt_long() partial matching
@@ -259,11 +217,6 @@ static const struct sc_option options[] = {
         .longopt = "encoder",
         .argdesc = "name",
     },
-    {
-        .shortopt = 'f',
-        .longopt = "fullscreen",
-        .text = "Start in fullscreen.",
-    },
     {
         .longopt_id = OPT_FORCE_ADB_FORWARD,
         .longopt = "force-adb-forward",
@@ -278,14 +231,9 @@ static const struct sc_option options[] = {
                 "shortcuts and forwards the clicks to the device instead.",
     },
     {
-        .shortopt = 'h',
+        .shortopt = 'f',
-        .longopt = "help",
+        .longopt = "fullscreen",
-        .text = "Print this help.",
+        .text = "Start in fullscreen.",
-    },
-    {
-        .longopt_id = OPT_KILL_ADB_ON_CLOSE,
-        .longopt = "kill-adb-on-close",
-        .text = "Kill adb when scrcpy terminates.",
     },
     {
         .shortopt = 'K',
@@ -304,6 +252,11 @@ static const struct sc_option options[] = {
                 "is enabled (or a physical keyboard is connected).\n"
                 "Also see --hid-mouse.",
     },
+    {
+        .shortopt = 'h',
+        .longopt = "help",
+        .text = "Print this help.",
+    },
     {
         .longopt_id = OPT_LEGACY_PASTE,
         .longopt = "legacy-paste",
@@ -337,13 +290,11 @@ static const struct sc_option options[] = {
                 "\"initial\".",
     },
     {
-        .shortopt = 'm',
+        .longopt_id = OPT_MAX_FPS,
-        .longopt = "max-size",
+        .longopt = "max-fps",
         .argdesc = "value",
-        .text = "Limit both the width and height of the video to value. The "
+        .text = "Limit the frame rate of screen capture (officially supported "
-                "other dimension is computed so that the device aspect-ratio "
+                "since Android 10, but may work on earlier versions).",
-                "is preserved.\n"
-                "Default is 0 (unlimited).",
     },
     {
         .shortopt = 'M',
@@ -357,33 +308,19 @@ static const struct sc_option options[] = {
                 "Also see --hid-keyboard.",
     },
     {
-        .longopt_id = OPT_MAX_FPS,
+        .shortopt = 'm',
-        .longopt = "max-fps",
+        .longopt = "max-size",
         .argdesc = "value",
-        .text = "Limit the frame rate of screen capture (officially supported "
+        .text = "Limit both the width and height of the video to value. The "
-                "since Android 10, but may work on earlier versions).",
+                "other dimension is computed so that the device aspect-ratio "
-    },
+                "is preserved.\n"
-    {
+                "Default is 0 (unlimited).",
-        .shortopt = 'n',
-        .longopt = "no-control",
-        .text = "Disable device control (mirror the device in read-only).",
-    },
-    {
-        .shortopt = 'N',
-        .longopt = "no-playback",
-        .text = "Disable video and audio playback on the computer (equivalent "
-                "to --no-video-playback --no-audio-playback).",
     },
     {
         .longopt_id = OPT_NO_AUDIO,
         .longopt = "no-audio",
         .text = "Disable audio forwarding.",
     },
-    {
-        .longopt_id = OPT_NO_AUDIO_PLAYBACK,
-        .longopt = "no-audio-playback",
-        .text = "Disable audio playback on the computer.",
-    },
     {
         .longopt_id = OPT_NO_CLEANUP,
         .longopt = "no-cleanup",
@@ -409,9 +346,15 @@ static const struct sc_option options[] = {
                 "This option disables this behavior.",
     },
     {
-        // deprecated
+        .shortopt = 'n',
-        .longopt_id = OPT_NO_DISPLAY,
+        .longopt = "no-control",
+        .text = "Disable device control (mirror the device in read-only).",
+    },
+    {
+        .shortopt = 'N',
         .longopt = "no-display",
+        .text = "Do not display device (only when screen recording or V4L2 "
+                "sink is enabled).",
     },
     {
         .longopt_id = OPT_NO_KEY_REPEAT,
@@ -430,16 +373,6 @@ static const struct sc_option options[] = {
         .longopt = "no-power-on",
         .text = "Do not power on the device on start.",
     },
-    {
-        .longopt_id = OPT_NO_VIDEO,
-        .longopt = "no-video",
-        .text = "Disable video forwarding.",
-    },
-    {
-        .longopt_id = OPT_NO_VIDEO_PLAYBACK,
-        .longopt = "no-video-playback",
-        .text = "Disable video playback on the computer.",
-    },
     {
         .longopt_id = OPT_OTG,
         .longopt = "otg",
@@ -491,6 +424,11 @@ static const struct sc_option options[] = {
                 "drag & drop. It is passed as is to \"adb push\".\n"
                 "Default is \"/sdcard/Download/\".",
     },
+    {
+        .longopt_id = OPT_RAW_KEY_EVENTS,
+        .longopt = "raw-key-events",
+        .text = "Inject key events for all input keys, and ignore text events."
+    },
     {
         .shortopt = 'r',
         .longopt = "record",
@@ -499,11 +437,6 @@ static const struct sc_option options[] = {
                 "The format is determined by the --record-format option if "
                 "set, or by the file extension (.mp4 or .mkv).",
     },
-    {
-        .longopt_id = OPT_RAW_KEY_EVENTS,
-        .longopt = "raw-key-events",
-        .text = "Inject key events for all input keys, and ignore text events."
-    },
     {
         .longopt_id = OPT_RECORD_FORMAT,
         .longopt = "record-format",
@@ -521,11 +454,9 @@ static const struct sc_option options[] = {
                 "<https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER>",
     },
     {
-        .longopt_id = OPT_REQUIRE_AUDIO,
+        // deprecated
-        .longopt = "require-audio",
+        .longopt_id = OPT_RENDER_EXPIRED_FRAMES,
-        .text = "By default, scrcpy mirrors only the video when audio capture "
+        .longopt = "render-expired-frames",
-                "fails on the device. This option makes scrcpy fail if audio "
-                "is enabled but does not work."
     },
     {
         .longopt_id = OPT_ROTATION,
@@ -542,11 +473,6 @@ static const struct sc_option options[] = {
         .text = "The device serial number. Mandatory only if several devices "
                 "are connected to adb.",
     },
-    {
-        .shortopt = 'S',
-        .longopt = "turn-screen-off",
-        .text = "Turn the device screen off immediately.",
-    },
     {
         .longopt_id = OPT_SHORTCUT_MOD,
         .longopt = "shortcut-mod",
@@ -560,6 +486,11 @@ static const struct sc_option options[] = {
                 "shortcuts, pass \"lctrl+lalt,lsuper\".\n"
                 "Default is \"lalt,lsuper\" (left-Alt or left-Super).",
     },
+    {
+        .shortopt = 'S',
+        .longopt = "turn-screen-off",
+        .text = "Turn the device screen off immediately.",
+    },
     {
         .shortopt = 't',
         .longopt = "show-touches",
@@ -581,12 +512,6 @@ static const struct sc_option options[] = {
                 "connected over USB), enables TCP/IP mode, then connects to "
                 "this address before starting.",
     },
-    {
-        .longopt_id = OPT_TIME_LIMIT,
-        .longopt = "time-limit",
-        .argdesc = "seconds",
-        .text = "Set the maximum mirroring time, in seconds.",
-    },
     {
         .longopt_id = OPT_TUNNEL_HOST,
         .longopt = "tunnel-host",
@@ -606,22 +531,6 @@ static const struct sc_option options[] = {
                 "Default is 0 (not forced): the local port used for "
                 "establishing the tunnel will be used.",
     },
-    {
-        .shortopt = 'v',
-        .longopt = "version",
-        .text = "Print the version of scrcpy.",
-    },
-    {
-        .shortopt = 'V',
-        .longopt = "verbosity",
-        .argdesc = "value",
-        .text = "Set the log level (verbose, debug, info, warn or error).\n"
-#ifndef NDEBUG
-                "Default is debug.",
-#else
-                "Default is info.",
-#endif
-    },
     {
         .longopt_id = OPT_V4L2_SINK,
         .longopt = "v4l2-sink",
@@ -642,6 +551,22 @@ static const struct sc_option options[] = {
                 "Default is 0 (no buffering).\n"
                 "This option is only available on Linux.",
     },
+    {
+        .shortopt = 'V',
+        .longopt = "verbosity",
+        .argdesc = "value",
+        .text = "Set the log level (verbose, debug, info, warn or error).\n"
+#ifndef NDEBUG
+                "Default is debug.",
+#else
+                "Default is info.",
+#endif
+    },
+    {
+        .shortopt = 'v',
+        .longopt = "version",
+        .text = "Print the version of scrcpy.",
+    },
     {
         .longopt_id = OPT_VIDEO_CODEC,
         .longopt = "video-codec",
@@ -1260,19 +1185,6 @@ parse_buffering_time(const char *s, sc_tick *tick) {
     return true;
 }
 
-static bool
-parse_audio_output_buffer(const char *s, sc_tick *tick) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 1000,
-                                "audio output buffer");
-    if (!ok) {
-        return false;
-    }
-
-    *tick = SC_TICK_FROM_MS(value);
-    return true;
-}
-
 static bool
 parse_lock_video_orientation(const char *s,
                              enum sc_lock_video_orientation *lock_mode) {
@@ -1512,39 +1424,18 @@ sc_parse_shortcut_mods(const char *s, struct sc_shortcut_mods *mods) {
 }
 #endif
 
-static enum sc_record_format
-get_record_format(const char *name) {
-    if (!strcmp(name, "mp4")) {
-        return SC_RECORD_FORMAT_MP4;
-    }
-    if (!strcmp(name, "mkv")) {
-        return SC_RECORD_FORMAT_MKV;
-    }
-    if (!strcmp(name, "m4a")) {
-        return SC_RECORD_FORMAT_M4A;
-    }
-    if (!strcmp(name, "mka")) {
-        return SC_RECORD_FORMAT_MKA;
-    }
-    if (!strcmp(name, "opus")) {
-        return SC_RECORD_FORMAT_OPUS;
-    }
-    if (!strcmp(name, "aac")) {
-        return SC_RECORD_FORMAT_AAC;
-    }
-    return 0;
-}
-
 static bool
 parse_record_format(const char *optarg, enum sc_record_format *format) {
-    enum sc_record_format fmt = get_record_format(optarg);
+    if (!strcmp(optarg, "mp4")) {
-    if (!fmt) {
+        *format = SC_RECORD_FORMAT_MP4;
-        LOGE("Unsupported format: %s (expected mp4 or mkv)", optarg);
+        return true;
-        return false;
     }
-
+    if (!strcmp(optarg, "mkv")) {
-    *format = fmt;
+        *format = SC_RECORD_FORMAT_MKV;
-    return true;
+        return true;
+    }
+    LOGE("Unsupported format: %s (expected mp4 or mkv)", optarg);
+    return false;
 }
 
 static bool
@@ -1564,13 +1455,18 @@ parse_port(const char *optarg, uint16_t *port) {
 
 static enum sc_record_format
 guess_record_format(const char *filename) {
-    const char *dot = strrchr(filename, '.');
+    size_t len = strlen(filename);
-    if (!dot) {
+    if (len < 4) {
         return 0;
     }
-
+    const char *ext = &filename[len - 4];
-    const char *ext = dot + 1;
+    if (!strcmp(ext, ".mp4")) {
-    return get_record_format(ext);
+        return SC_RECORD_FORMAT_MP4;
+    }
+    if (!strcmp(ext, ".mkv")) {
+        return SC_RECORD_FORMAT_MKV;
+    }
+    return 0;
 }
 
 static bool
@@ -1601,42 +1497,10 @@ parse_audio_codec(const char *optarg, enum sc_codec *codec) {
         *codec = SC_CODEC_AAC;
         return true;
     }
-    if (!strcmp(optarg, "raw")) {
+    LOGE("Unsupported audio codec: %s (expected opus)", optarg);
-        *codec = SC_CODEC_RAW;
-        return true;
-    }
-    LOGE("Unsupported audio codec: %s (expected opus, aac or raw)", optarg);
     return false;
 }
 
-static bool
-parse_audio_source(const char *optarg, enum sc_audio_source *source) {
-    if (!strcmp(optarg, "mic")) {
-        *source = SC_AUDIO_SOURCE_MIC;
-        return true;
-    }
-
-    if (!strcmp(optarg, "output")) {
-        *source = SC_AUDIO_SOURCE_OUTPUT;
-        return true;
-    }
-
-    LOGE("Unsupported audio source: %s (expected output or mic)", optarg);
-    return false;
-}
-
-static bool
-parse_time_limit(const char *s, sc_tick *tick) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 0x7FFFFFFF, "time limit");
-    if (!ok) {
-        return false;
-    }
-
-    *tick = SC_TICK_FROM_SEC(value);
-    return true;
-}
-
 static bool
 parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                        const char *optstring, const struct option *longopts) {
@@ -1647,10 +1511,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
     int c;
     while ((c = getopt_long(argc, argv, optstring, longopts, NULL)) != -1) {
         switch (c) {
-            case OPT_BIT_RATE:
-                LOGE("--bit-rate has been removed, "
-                     "use --video-bit-rate or --audio-bit-rate.");
-                return false;
             case 'b':
                 if (!parse_bit_rate(optarg, &opts->video_bit_rate)) {
                     return false;
@@ -1678,6 +1538,9 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             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;
@@ -1731,18 +1594,8 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case 'n':
                 opts->control = false;
                 break;
-            case OPT_NO_DISPLAY:
-                LOGW("--no-display is deprecated, use --no-playback instead.");
-                // fall through
             case 'N':
-                opts->video_playback = false;
+                opts->display = false;
-                opts->audio_playback = false;
-                break;
-            case OPT_NO_VIDEO_PLAYBACK:
-                opts->video_playback = false;
-                break;
-            case OPT_NO_AUDIO_PLAYBACK:
-                opts->audio_playback = false;
                 break;
             case 'p':
                 if (!parse_port_range(optarg, &opts->port_range)) {
@@ -1775,6 +1628,10 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case 'w':
                 opts->stay_awake = true;
                 break;
+            case OPT_RENDER_EXPIRED_FRAMES:
+                LOGW("Option --render-expired-frames has been removed. This "
+                     "flag has been ignored.");
+                break;
             case OPT_WINDOW_TITLE:
                 opts->window_title = optarg;
                 break;
@@ -1833,9 +1690,9 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                 opts->forward_key_repeat = false;
                 break;
             case OPT_CODEC_OPTIONS:
-                LOGE("--codec-options has been removed, "
+                LOGW("--codec-options is deprecated, use --video-codec-options "
-                     "use --video-codec-options or --audio-codec-options.");
+                     "instead.");
-                return false;
+                // fall through
             case OPT_VIDEO_CODEC_OPTIONS:
                 opts->video_codec_options = optarg;
                 break;
@@ -1843,9 +1700,8 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                 opts->audio_codec_options = optarg;
                 break;
             case OPT_ENCODER:
-                LOGE("--encoder has been removed, "
+                LOGW("--encoder is deprecated, use --video-encoder instead.");
-                     "use --video-encoder or --audio-encoder.");
+                // fall through
-                return false;
             case OPT_VIDEO_ENCODER:
                 opts->video_encoder = optarg;
                 break;
@@ -1887,9 +1743,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case OPT_NO_DOWNSIZE_ON_ERROR:
                 opts->downsize_on_error = false;
                 break;
-            case OPT_NO_VIDEO:
-                opts->video = false;
-                break;
             case OPT_NO_AUDIO:
                 opts->audio = false;
                 break;
@@ -1903,9 +1756,8 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                 opts->start_fps_counter = true;
                 break;
             case OPT_CODEC:
-                LOGE("--codec has been removed, "
+                LOGW("--codec is deprecated, use --video-codec instead.");
-                     "use --video-codec or --audio-codec.");
+                // fall through
-                return false;
             case OPT_VIDEO_CODEC:
                 if (!parse_video_codec(optarg, &opts->video_codec)) {
                     return false;
@@ -1940,8 +1792,7 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                 }
                 break;
 #else
-                LOGE("V4L2 (--v4l2-buffer) is disabled (or unsupported on this "
+                LOGE("V4L2 (--v4l2-buffer) is only available on Linux.");
-                     "platform).");
                 return false;
 #endif
             case OPT_LIST_ENCODERS:
@@ -1950,33 +1801,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case OPT_LIST_DISPLAYS:
                 opts->list_displays = true;
                 break;
-            case OPT_REQUIRE_AUDIO:
-                opts->require_audio = true;
-                break;
-            case OPT_AUDIO_BUFFER:
-                if (!parse_buffering_time(optarg, &opts->audio_buffer)) {
-                    return false;
-                }
-                break;
-            case OPT_AUDIO_OUTPUT_BUFFER:
-                if (!parse_audio_output_buffer(optarg,
-                                               &opts->audio_output_buffer)) {
-                    return false;
-                }
-                break;
-            case OPT_AUDIO_SOURCE:
-                if (!parse_audio_source(optarg, &opts->audio_source)) {
-                    return false;
-                }
-                break;
-            case OPT_KILL_ADB_ON_CLOSE:
-                opts->kill_adb_on_close = true;
-                break;
-            case OPT_TIME_LIMIT:
-                if (!parse_time_limit(optarg, &opts->time_limit)) {
-                    return false;
-                }
-                break;
             default:
                 // getopt prints the error message on stderr
                 return false;
@@ -2005,52 +1829,14 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         return false;
     }
 
-    bool otg = false;
-    bool v4l2 = false;
-#ifdef HAVE_USB
-    otg = opts->otg;
-#endif
 #ifdef HAVE_V4L2
-    v4l2 = !!opts->v4l2_device;
+    if (!opts->display && !opts->record_filename && !opts->v4l2_device) {
-#endif
+        LOGE("-N/--no-display requires either screen recording (-r/--record)"
-
+             " or sink to v4l2loopback device (--v4l2-sink)");
-    if (!opts->video) {
-        opts->video_playback = false;
-    }
-
-    if (!opts->audio) {
-        opts->audio_playback = false;
-    }
-
-    if (!opts->video_playback && !otg) {
-        // If video playback is disabled and OTG are disabled, then there is
-        // no way to control the device.
-        opts->control = false;
-    }
-
-    if (opts->video && !opts->video_playback && !opts->record_filename
-            && !v4l2) {
-        LOGI("No video playback, no recording, no V4L2 sink: video disabled");
-        opts->video = false;
-    }
-
-    if (opts->audio && !opts->audio_playback && !opts->record_filename) {
-        LOGI("No audio playback, no recording: audio disabled");
-        opts->audio = false;
-    }
-
-    if (!opts->video && !opts->audio && !otg) {
-        LOGE("No video, no audio, no OTG: nothing to do");
         return false;
     }
 
-    if (!opts->video && !otg) {
+    if (opts->v4l2_device) {
-        // If video is disabled, then scrcpy must exit on audio failure.
-        opts->require_audio = true;
-    }
-
-#ifdef HAVE_V4L2
-    if (v4l2) {
         if (opts->lock_video_orientation ==
                 SC_LOCK_VIDEO_ORIENTATION_UNLOCKED) {
             LOGI("Video orientation is locked for v4l2 sink. "
@@ -2068,6 +1854,11 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         LOGE("V4L2 buffer value without V4L2 sink\n");
         return false;
     }
+#else
+    if (!opts->display && !opts->record_filename) {
+        LOGE("-N/--no-display requires screen recording (-r/--record)");
+        return false;
+    }
 #endif
 
     if ((opts->tunnel_host || opts->tunnel_port) && !opts->force_adb_forward) {
@@ -2081,53 +1872,14 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         return false;
     }
 
-    if (opts->record_filename) {
+    if (opts->record_filename && !opts->record_format) {
+        opts->record_format = guess_record_format(opts->record_filename);
         if (!opts->record_format) {
-            opts->record_format = guess_record_format(opts->record_filename);
+            LOGE("No format specified for \"%s\" "
-            if (!opts->record_format) {
+                 "(try with --record-format=mkv)",
-                LOGE("No format specified for \"%s\" "
+                 opts->record_filename);
-                     "(try with --record-format=mkv)",
-                     opts->record_filename);
-                return false;
-            }
-        }
-
-        if (opts->audio_codec == SC_CODEC_RAW) {
-            LOGW("Recording does not support RAW audio codec");
             return false;
         }
-
-        if (opts->video
-                && sc_record_format_is_audio_only(opts->record_format)) {
-            LOGE("Audio container does not support video stream");
-            return false;
-        }
-
-        if (opts->record_format == SC_RECORD_FORMAT_OPUS
-                && opts->audio_codec != SC_CODEC_OPUS) {
-            LOGE("Recording to OPUS file requires an OPUS audio stream "
-                 "(try with --audio-codec=opus)");
-            return false;
-        }
-
-        if (opts->record_format == SC_RECORD_FORMAT_AAC
-                && opts->audio_codec != SC_CODEC_AAC) {
-            LOGE("Recording to AAC file requires an AAC audio stream "
-                 "(try with --audio-codec=aac)");
-            return false;
-        }
-    }
-
-    if (opts->audio_codec == SC_CODEC_RAW) {
-        if (opts->audio_bit_rate) {
-            LOGW("--audio-bit-rate is ignored for raw audio codec");
-        }
-        if (opts->audio_codec_options) {
-            LOGW("--audio-codec-options is ignored for raw audio codec");
-        }
-        if (opts->audio_encoder) {
-            LOGW("--audio-encoder is ignored for raw audio codec");
-        }
     }
 
     if (!opts->control) {
@@ -2149,9 +1901,11 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         }
     }
 
+#ifdef HAVE_USB
+
 # ifdef _WIN32
-    if (!otg && (opts->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID
+    if (!opts->otg && (opts->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID
-                || opts->mouse_input_mode == SC_MOUSE_INPUT_MODE_HID)) {
+                    || opts->mouse_input_mode == SC_MOUSE_INPUT_MODE_HID)) {
         LOGE("On Windows, it is not possible to open a USB device already open "
              "by another process (like adb).");
         LOGE("Therefore, -K/--hid-keyboard and -M/--hid-mouse may only work in "
@@ -2160,7 +1914,7 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
     }
 # endif
 
-    if (otg) {
+    if (opts->otg) {
         // OTG mode is compatible with only very few options.
         // Only report obvious errors.
         if (opts->record_filename) {
@@ -2187,11 +1941,14 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             LOGE("OTG mode: could not select display");
             return false;
         }
-        if (v4l2) {
+# ifdef HAVE_V4L2
+        if (opts->v4l2_device) {
             LOGE("OTG mode: could not sink to V4L2 device");
             return false;
         }
+# endif
     }
+#endif
 
     return true;
 }

app/src/clock.c

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

app/src/clock.h

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

app/src/common.h

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

app/src/compat.c

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

app/src/compat.h

@@ -25,12 +25,6 @@
 # define SCRCPY_LAVF_REQUIRES_REGISTER_ALL
 #endif
 
-// Not documented in ffmpeg/doc/APIchanges, but AV_CODEC_ID_AV1 has been added
-// by FFmpeg commit d42809f9835a4e9e5c7c63210abb09ad0ef19cfb (included in tag
-// n3.3).
-#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 89, 100)
-# define SCRCPY_LAVC_HAS_AV1
-#endif
 
 // In ffmpeg/doc/APIchanges:
 // 2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
@@ -60,10 +54,6 @@
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
 #endif
 
-#if SDL_VERSION_ATLEAST(2, 0, 16)
-# define SCRCPY_SDL_HAS_THREAD_PRIORITY_TIME_CRITICAL
-#endif
-
 #ifndef HAVE_STRDUP
 char *strdup(const char *s);
 #endif
@@ -84,8 +74,4 @@ long nrand48(unsigned short xsubi[3]);
 long jrand48(unsigned short xsubi[3]);
 #endif
 
-#ifndef HAVE_REALLOCARRAY
-void *reallocarray(void *ptr, size_t nmemb, size_t size);
-#endif
-
 #endif

app/src/controller.c

@@ -4,28 +4,19 @@
 
 #include "util/log.h"
 
-#define SC_CONTROL_MSG_QUEUE_MAX 64
-
 bool
 sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
                    struct sc_acksync *acksync) {
-    sc_vecdeque_init(&controller->queue);
+    cbuf_init(&controller->queue);
 
-    bool ok = sc_vecdeque_reserve(&controller->queue, SC_CONTROL_MSG_QUEUE_MAX);
+    bool ok = sc_receiver_init(&controller->receiver, control_socket, acksync);
     if (!ok) {
         return false;
     }
 
-    ok = sc_receiver_init(&controller->receiver, control_socket, acksync);
-    if (!ok) {
-        sc_vecdeque_destroy(&controller->queue);
-        return false;
-    }
-
     ok = sc_mutex_init(&controller->mutex);
     if (!ok) {
         sc_receiver_destroy(&controller->receiver);
-        sc_vecdeque_destroy(&controller->queue);
         return false;
     }
 
@@ -33,7 +24,6 @@ sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
     if (!ok) {
         sc_receiver_destroy(&controller->receiver);
         sc_mutex_destroy(&controller->mutex);
-        sc_vecdeque_destroy(&controller->queue);
         return false;
     }
 
@@ -48,12 +38,10 @@ sc_controller_destroy(struct sc_controller *controller) {
     sc_cond_destroy(&controller->msg_cond);
     sc_mutex_destroy(&controller->mutex);
 
-    while (!sc_vecdeque_is_empty(&controller->queue)) {
+    struct sc_control_msg msg;
-        struct sc_control_msg *msg = sc_vecdeque_popref(&controller->queue);
+    while (cbuf_take(&controller->queue, &msg)) {
-        assert(msg);
+        sc_control_msg_destroy(&msg);
-        sc_control_msg_destroy(msg);
     }
-    sc_vecdeque_destroy(&controller->queue);
 
     sc_receiver_destroy(&controller->receiver);
 }
@@ -66,19 +54,13 @@ sc_controller_push_msg(struct sc_controller *controller,
     }
 
     sc_mutex_lock(&controller->mutex);
-    bool full = sc_vecdeque_is_full(&controller->queue);
+    bool was_empty = cbuf_is_empty(&controller->queue);
-    if (!full) {
+    bool res = cbuf_push(&controller->queue, *msg);
-        bool was_empty = sc_vecdeque_is_empty(&controller->queue);
+    if (was_empty) {
-        sc_vecdeque_push_noresize(&controller->queue, *msg);
+        sc_cond_signal(&controller->msg_cond);
-        if (was_empty) {
-            sc_cond_signal(&controller->msg_cond);
-        }
     }
-    // Otherwise (if the queue is full), the msg is discarded
-
     sc_mutex_unlock(&controller->mutex);
-
+    return res;
-    return !full;
 }
 
 static bool
@@ -100,8 +82,7 @@ run_controller(void *data) {
 
     for (;;) {
         sc_mutex_lock(&controller->mutex);
-        while (!controller->stopped
+        while (!controller->stopped && cbuf_is_empty(&controller->queue)) {
-                && sc_vecdeque_is_empty(&controller->queue)) {
             sc_cond_wait(&controller->msg_cond, &controller->mutex);
         }
         if (controller->stopped) {
@@ -109,9 +90,10 @@ run_controller(void *data) {
             sc_mutex_unlock(&controller->mutex);
             break;
         }
-
+        struct sc_control_msg msg;
-        assert(!sc_vecdeque_is_empty(&controller->queue));
+        bool non_empty = cbuf_take(&controller->queue, &msg);
-        struct sc_control_msg msg = sc_vecdeque_pop(&controller->queue);
+        assert(non_empty);
+        (void) non_empty;
         sc_mutex_unlock(&controller->mutex);
 
         bool ok = process_msg(controller, &msg);

app/src/controller.h

@@ -8,11 +8,11 @@
 #include "control_msg.h"
 #include "receiver.h"
 #include "util/acksync.h"
+#include "util/cbuf.h"
 #include "util/net.h"
 #include "util/thread.h"
-#include "util/vecdeque.h"
 
-struct sc_control_msg_queue SC_VECDEQUE(struct sc_control_msg);
+struct sc_control_msg_queue CBUF(struct sc_control_msg, 64);
 
 struct sc_controller {
     sc_socket control_socket;

app/src/decoder.c

@@ -5,34 +5,106 @@
 #include <libavutil/channel_layout.h>
 
 #include "events.h"
+#include "video_buffer.h"
 #include "trait/frame_sink.h"
 #include "util/log.h"
 
 /** Downcast packet_sink to decoder */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_decoder, packet_sink)
 
+static void
+sc_decoder_close_first_sinks(struct sc_decoder *decoder, unsigned count) {
+    while (count) {
+        struct sc_frame_sink *sink = decoder->sinks[--count];
+        sink->ops->close(sink);
+    }
+}
+
+static inline void
+sc_decoder_close_sinks(struct sc_decoder *decoder) {
+    sc_decoder_close_first_sinks(decoder, decoder->sink_count);
+}
+
 static bool
-sc_decoder_open(struct sc_decoder *decoder, AVCodecContext *ctx) {
+sc_decoder_open_sinks(struct sc_decoder *decoder, const AVCodecContext *ctx) {
-    decoder->frame = av_frame_alloc();
+    for (unsigned i = 0; i < decoder->sink_count; ++i) {
-    if (!decoder->frame) {
+        struct sc_frame_sink *sink = decoder->sinks[i];
+        if (!sink->ops->open(sink, ctx)) {
+            sc_decoder_close_first_sinks(decoder, i);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool
+sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
+    decoder->codec_ctx = avcodec_alloc_context3(codec);
+    if (!decoder->codec_ctx) {
         LOG_OOM();
         return false;
     }
 
-    if (!sc_frame_source_sinks_open(&decoder->frame_source, ctx)) {
+    decoder->codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;
-        av_frame_free(&decoder->frame);
+
+    if (codec->type == AVMEDIA_TYPE_VIDEO) {
+        // Hardcoded video properties
+        decoder->codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
+    } else {
+        // Hardcoded audio properties
+#ifdef SCRCPY_LAVU_HAS_CHLAYOUT
+        decoder->codec_ctx->ch_layout =
+            (AVChannelLayout) AV_CHANNEL_LAYOUT_STEREO;
+#else
+        decoder->codec_ctx->channel_layout = AV_CH_LAYOUT_STEREO;
+        decoder->codec_ctx->channels = 2;
+#endif
+        decoder->codec_ctx->sample_rate = 48000;
+    }
+
+    if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
+        LOGE("Decoder '%s': could not open codec", decoder->name);
+        avcodec_free_context(&decoder->codec_ctx);
         return false;
     }
 
-    decoder->ctx = ctx;
+    decoder->frame = av_frame_alloc();
+    if (!decoder->frame) {
+        LOG_OOM();
+        avcodec_close(decoder->codec_ctx);
+        avcodec_free_context(&decoder->codec_ctx);
+        return false;
+    }
+
+    if (!sc_decoder_open_sinks(decoder, decoder->codec_ctx)) {
+        av_frame_free(&decoder->frame);
+        avcodec_close(decoder->codec_ctx);
+        avcodec_free_context(&decoder->codec_ctx);
+        return false;
+    }
 
     return true;
 }
 
 static void
 sc_decoder_close(struct sc_decoder *decoder) {
-    sc_frame_source_sinks_close(&decoder->frame_source);
+    sc_decoder_close_sinks(decoder);
     av_frame_free(&decoder->frame);
+    avcodec_close(decoder->codec_ctx);
+    avcodec_free_context(&decoder->codec_ctx);
+}
+
+static bool
+push_frame_to_sinks(struct sc_decoder *decoder, const AVFrame *frame) {
+    for (unsigned i = 0; i < decoder->sink_count; ++i) {
+        struct sc_frame_sink *sink = decoder->sinks[i];
+        if (!sink->ops->push(sink, frame)) {
+            return false;
+        }
+    }
+
+    return true;
 }
 
 static bool
@@ -43,42 +115,33 @@ sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {
         return true;
     }
 
-    int ret = avcodec_send_packet(decoder->ctx, packet);
+    int ret = avcodec_send_packet(decoder->codec_ctx, packet);
     if (ret < 0 && ret != AVERROR(EAGAIN)) {
         LOGE("Decoder '%s': could not send video packet: %d",
              decoder->name, ret);
         return false;
     }
-
+    ret = avcodec_receive_frame(decoder->codec_ctx, decoder->frame);
-    for (;;) {
+    if (!ret) {
-        ret = avcodec_receive_frame(decoder->ctx, decoder->frame);
-        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
-            break;
-        }
-
-        if (ret) {
-            LOGE("Decoder '%s', could not receive video frame: %d",
-                 decoder->name, ret);
-            return false;
-        }
-
         // a frame was received
-        bool ok = sc_frame_source_sinks_push(&decoder->frame_source,
+        bool ok = push_frame_to_sinks(decoder, decoder->frame);
-                                             decoder->frame);
+        // A frame lost should not make the whole pipeline fail. The error, if
-        av_frame_unref(decoder->frame);
+        // any, is already logged.
-        if (!ok) {
+        (void) ok;
-            // Error already logged
-            return false;
-        }
-    }
 
+        av_frame_unref(decoder->frame);
+    } else if (ret != AVERROR(EAGAIN)) {
+        LOGE("Decoder '%s', could not receive video frame: %d",
+             decoder->name, ret);
+        return false;
+    }
     return true;
 }
 
 static bool
-sc_decoder_packet_sink_open(struct sc_packet_sink *sink, AVCodecContext *ctx) {
+sc_decoder_packet_sink_open(struct sc_packet_sink *sink, const AVCodec *codec) {
     struct sc_decoder *decoder = DOWNCAST(sink);
-    return sc_decoder_open(decoder, ctx);
+    return sc_decoder_open(decoder, codec);
 }
 
 static void
@@ -97,7 +160,7 @@ sc_decoder_packet_sink_push(struct sc_packet_sink *sink,
 void
 sc_decoder_init(struct sc_decoder *decoder, const char *name) {
     decoder->name = name; // statically allocated
-    sc_frame_source_init(&decoder->frame_source);
+    decoder->sink_count = 0;
 
     static const struct sc_packet_sink_ops ops = {
         .open = sc_decoder_packet_sink_open,
@@ -107,3 +170,11 @@ sc_decoder_init(struct sc_decoder *decoder, const char *name) {
 
     decoder->packet_sink.ops = &ops;
 }
+
+void
+sc_decoder_add_sink(struct sc_decoder *decoder, struct sc_frame_sink *sink) {
+    assert(decoder->sink_count < SC_DECODER_MAX_SINKS);
+    assert(sink);
+    assert(sink->ops);
+    decoder->sinks[decoder->sink_count++] = sink;
+}

app/src/decoder.h

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

app/src/delay_buffer.c

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

app/src/delay_buffer.h

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

app/src/demuxer.c

@@ -1,7 +1,6 @@
 #include "demuxer.h"
 
 #include <assert.h>
-#include <libavutil/channel_layout.h>
 #include <libavutil/time.h>
 #include <unistd.h>
 
@@ -26,25 +25,17 @@ sc_demuxer_to_avcodec_id(uint32_t codec_id) {
 #define SC_CODEC_ID_AV1 UINT32_C(0x00617631) // "av1" in ASCII
 #define SC_CODEC_ID_OPUS UINT32_C(0x6f707573) // "opus" in ASCII
 #define SC_CODEC_ID_AAC UINT32_C(0x00616163) // "aac in ASCII"
-#define SC_CODEC_ID_RAW UINT32_C(0x00726177) // "raw" in ASCII
     switch (codec_id) {
         case SC_CODEC_ID_H264:
             return AV_CODEC_ID_H264;
         case SC_CODEC_ID_H265:
             return AV_CODEC_ID_HEVC;
         case SC_CODEC_ID_AV1:
-#ifdef SCRCPY_LAVC_HAS_AV1
             return AV_CODEC_ID_AV1;
-#else
-            LOGE("AV1 not supported by this FFmpeg version");
-            return AV_CODEC_ID_NONE;
-#endif
         case SC_CODEC_ID_OPUS:
             return AV_CODEC_ID_OPUS;
         case SC_CODEC_ID_AAC:
             return AV_CODEC_ID_AAC;
-        case SC_CODEC_ID_RAW:
-            return AV_CODEC_ID_PCM_S16LE;
         default:
             LOGE("Unknown codec id 0x%08" PRIx32, codec_id);
             return AV_CODEC_ID_NONE;
@@ -63,24 +54,11 @@ sc_demuxer_recv_codec_id(struct sc_demuxer *demuxer, uint32_t *codec_id) {
     return true;
 }
 
-static bool
-sc_demuxer_recv_video_size(struct sc_demuxer *demuxer, uint32_t *width,
-                           uint32_t *height) {
-    uint8_t data[8];
-    ssize_t r = net_recv_all(demuxer->socket, data, 8);
-    if (r < 8) {
-        return false;
-    }
-
-    *width = sc_read32be(data);
-    *height = sc_read32be(data + 4);
-    return true;
-}
-
 static bool
 sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
-    // The video and audio streams contain a sequence of raw packets (as
+    // The video stream contains raw packets, without time information. When we
-    // provided by MediaCodec), each prefixed with a "meta" header.
+    // 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:
     // [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
@@ -134,26 +112,86 @@ sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
     return true;
 }
 
+static bool
+push_packet_to_sinks(struct sc_demuxer *demuxer, const AVPacket *packet) {
+    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
+        struct sc_packet_sink *sink = demuxer->sinks[i];
+        if (!sink->ops->push(sink, packet)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool
+sc_demuxer_push_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
+    bool ok = push_packet_to_sinks(demuxer, packet);
+    if (!ok) {
+        LOGE("Demuxer '%s': could not process packet", demuxer->name);
+        return false;
+    }
+
+    return true;
+}
+
+static void
+sc_demuxer_close_first_sinks(struct sc_demuxer *demuxer, unsigned count) {
+    while (count) {
+        struct sc_packet_sink *sink = demuxer->sinks[--count];
+        sink->ops->close(sink);
+    }
+}
+
+static inline void
+sc_demuxer_close_sinks(struct sc_demuxer *demuxer) {
+    sc_demuxer_close_first_sinks(demuxer, demuxer->sink_count);
+}
+
+static bool
+sc_demuxer_open_sinks(struct sc_demuxer *demuxer, const AVCodec *codec) {
+    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
+        struct sc_packet_sink *sink = demuxer->sinks[i];
+        if (!sink->ops->open(sink, codec)) {
+            sc_demuxer_close_first_sinks(demuxer, i);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static void
+sc_demuxer_disable_sinks(struct sc_demuxer *demuxer) {
+    for (unsigned i = 0; i < demuxer->sink_count; ++i) {
+        struct sc_packet_sink *sink = demuxer->sinks[i];
+        if (sink->ops->disable) {
+            sink->ops->disable(sink);
+        }
+    }
+}
+
 static int
 run_demuxer(void *data) {
     struct sc_demuxer *demuxer = data;
 
     // Flag to report end-of-stream (i.e. device disconnected)
-    enum sc_demuxer_status status = SC_DEMUXER_STATUS_ERROR;
+    bool eos = false;
 
     uint32_t raw_codec_id;
     bool ok = sc_demuxer_recv_codec_id(demuxer, &raw_codec_id);
     if (!ok) {
         LOGE("Demuxer '%s': stream disabled due to connection error",
              demuxer->name);
+        eos = true;
         goto end;
     }
 
     if (raw_codec_id == 0) {
         LOGW("Demuxer '%s': stream explicitly disabled by the device",
              demuxer->name);
-        sc_packet_source_sinks_disable(&demuxer->packet_source);
+        sc_demuxer_disable_sinks(demuxer);
-        status = SC_DEMUXER_STATUS_DISABLED;
+        eos = true;
         goto end;
     }
 
@@ -167,7 +205,7 @@ run_demuxer(void *data) {
     if (codec_id == AV_CODEC_ID_NONE) {
         LOGE("Demuxer '%s': stream disabled due to unsupported codec",
              demuxer->name);
-        sc_packet_source_sinks_disable(&demuxer->packet_source);
+        sc_demuxer_disable_sinks(demuxer);
         goto end;
     }
 
@@ -175,49 +213,14 @@ run_demuxer(void *data) {
     if (!codec) {
         LOGE("Demuxer '%s': stream disabled due to missing decoder",
              demuxer->name);
-        sc_packet_source_sinks_disable(&demuxer->packet_source);
+        sc_demuxer_disable_sinks(demuxer);
         goto end;
     }
 
-    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
+    if (!sc_demuxer_open_sinks(demuxer, codec)) {
-    if (!codec_ctx) {
-        LOG_OOM();
         goto end;
     }
 
-    codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;
-
-    if (codec->type == AVMEDIA_TYPE_VIDEO) {
-        uint32_t width;
-        uint32_t height;
-        ok = sc_demuxer_recv_video_size(demuxer, &width, &height);
-        if (!ok) {
-            goto finally_free_context;
-        }
-
-        codec_ctx->width = width;
-        codec_ctx->height = height;
-        codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
-    } else {
-        // Hardcoded audio properties
-#ifdef SCRCPY_LAVU_HAS_CHLAYOUT
-        codec_ctx->ch_layout = (AVChannelLayout) AV_CHANNEL_LAYOUT_STEREO;
-#else
-        codec_ctx->channel_layout = AV_CH_LAYOUT_STEREO;
-        codec_ctx->channels = 2;
-#endif
-        codec_ctx->sample_rate = 48000;
-    }
-
-    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
-        LOGE("Demuxer '%s': could not open codec", demuxer->name);
-        goto finally_free_context;
-    }
-
-    if (!sc_packet_source_sinks_open(&demuxer->packet_source, codec_ctx)) {
-        goto finally_free_context;
-    }
-
     // Config packets must be merged with the next non-config packet only for
     // video streams
     bool must_merge_config_packet = codec->type == AVMEDIA_TYPE_VIDEO;
@@ -238,7 +241,7 @@ run_demuxer(void *data) {
         bool ok = sc_demuxer_recv_packet(demuxer, packet);
         if (!ok) {
             // end of stream
-            status = SC_DEMUXER_STATUS_EOS;
+            eos = true;
             break;
         }
 
@@ -251,10 +254,10 @@ run_demuxer(void *data) {
             }
         }
 
-        ok = sc_packet_source_sinks_push(&demuxer->packet_source, packet);
+        ok = sc_demuxer_push_packet(demuxer, packet);
         av_packet_unref(packet);
         if (!ok) {
-            // The sink already logged its concrete error
+            // cannot process packet (error already logged)
             break;
         }
     }
@@ -267,12 +270,9 @@ run_demuxer(void *data) {
 
     av_packet_free(&packet);
 finally_close_sinks:
-    sc_packet_source_sinks_close(&demuxer->packet_source);
+    sc_demuxer_close_sinks(demuxer);
-finally_free_context:
-    // This also calls avcodec_close() internally
-    avcodec_free_context(&codec_ctx);
 end:
-    demuxer->cbs->on_ended(demuxer, status, demuxer->cbs_userdata);
+    demuxer->cbs->on_ended(demuxer, eos, demuxer->cbs_userdata);
 
     return 0;
 }
@@ -284,7 +284,7 @@ sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
 
     demuxer->name = name; // statically allocated
     demuxer->socket = socket;
-    sc_packet_source_init(&demuxer->packet_source);
+    demuxer->sink_count = 0;
 
     assert(cbs && cbs->on_ended);
 
@@ -292,6 +292,14 @@ sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
     demuxer->cbs_userdata = cbs_userdata;
 }
 
+void
+sc_demuxer_add_sink(struct sc_demuxer *demuxer, struct sc_packet_sink *sink) {
+    assert(demuxer->sink_count < SC_DEMUXER_MAX_SINKS);
+    assert(sink);
+    assert(sink->ops);
+    demuxer->sinks[demuxer->sink_count++] = sink;
+}
+
 bool
 sc_demuxer_start(struct sc_demuxer *demuxer) {
     LOGD("Demuxer '%s': starting thread", demuxer->name);

app/src/demuxer.h

@@ -8,32 +8,27 @@
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 
-#include "trait/packet_source.h"
 #include "trait/packet_sink.h"
 #include "util/net.h"
 #include "util/thread.h"
 
-struct sc_demuxer {
+#define SC_DEMUXER_MAX_SINKS 2
-    struct sc_packet_source packet_source; // packet source trait
 
+struct sc_demuxer {
     const char *name; // must be statically allocated (e.g. a string literal)
 
     sc_socket socket;
     sc_thread thread;
 
+    struct sc_packet_sink *sinks[SC_DEMUXER_MAX_SINKS];
+    unsigned sink_count;
+
     const struct sc_demuxer_callbacks *cbs;
     void *cbs_userdata;
 };
 
-enum sc_demuxer_status {
-    SC_DEMUXER_STATUS_EOS,
-    SC_DEMUXER_STATUS_DISABLED,
-    SC_DEMUXER_STATUS_ERROR,
-};
-
 struct sc_demuxer_callbacks {
-    void (*on_ended)(struct sc_demuxer *demuxer, enum sc_demuxer_status,
+    void (*on_ended)(struct sc_demuxer *demuxer, bool eos, void *userdata);
-                     void *userdata);
 };
 
 // The name must be statically allocated (e.g. a string literal)
@@ -41,6 +36,9 @@ void
 sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
                 const struct sc_demuxer_callbacks *cbs, void *cbs_userdata);
 
+void
+sc_demuxer_add_sink(struct sc_demuxer *demuxer, struct sc_packet_sink *sink);
+
 bool
 sc_demuxer_start(struct sc_demuxer *demuxer);
 

app/src/display.c

@@ -1,285 +0,0 @@
-#include "display.h"
-
-#include <assert.h>
-
-#include "util/log.h"
-
-bool
-sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps) {
-    display->renderer =
-        SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
-    if (!display->renderer) {
-        LOGE("Could not create renderer: %s", SDL_GetError());
-        return false;
-    }
-
-    SDL_RendererInfo renderer_info;
-    int r = SDL_GetRendererInfo(display->renderer, &renderer_info);
-    const char *renderer_name = r ? NULL : renderer_info.name;
-    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
-
-    display->mipmaps = false;
-
-    // starts with "opengl"
-    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (use_opengl) {
-
-#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
-        // Persuade macOS to give us something better than OpenGL 2.1.
-        // If we create a Core Profile context, we get the best OpenGL version.
-        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
-                            SDL_GL_CONTEXT_PROFILE_CORE);
-
-        LOGD("Creating OpenGL Core Profile context");
-        display->gl_context = SDL_GL_CreateContext(window);
-        if (!display->gl_context) {
-            LOGE("Could not create OpenGL context: %s", SDL_GetError());
-            SDL_DestroyRenderer(display->renderer);
-            return false;
-        }
-#endif
-
-        struct sc_opengl *gl = &display->gl;
-        sc_opengl_init(gl);
-
-        LOGI("OpenGL version: %s", gl->version);
-
-        if (mipmaps) {
-            bool supports_mipmaps =
-                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
-                                               2, 0  /* OpenGL ES 2.0+ */);
-            if (supports_mipmaps) {
-                LOGI("Trilinear filtering enabled");
-                display->mipmaps = true;
-            } else {
-                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required");
-            }
-        } else {
-            LOGI("Trilinear filtering disabled");
-        }
-    } else if (mipmaps) {
-        LOGD("Trilinear filtering disabled (not an OpenGL renderer");
-    }
-
-    display->pending.flags = 0;
-    display->pending.frame = NULL;
-
-    return true;
-}
-
-void
-sc_display_destroy(struct sc_display *display) {
-    if (display->pending.frame) {
-        av_frame_free(&display->pending.frame);
-    }
-#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
-    SDL_GL_DeleteContext(display->gl_context);
-#endif
-    if (display->texture) {
-        SDL_DestroyTexture(display->texture);
-    }
-    SDL_DestroyRenderer(display->renderer);
-}
-
-static SDL_Texture *
-sc_display_create_texture(struct sc_display *display,
-                          struct sc_size size) {
-    SDL_Renderer *renderer = display->renderer;
-    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
-                                             SDL_TEXTUREACCESS_STREAMING,
-                                             size.width, size.height);
-    if (!texture) {
-        LOGD("Could not create texture: %s", SDL_GetError());
-        return NULL;
-    }
-
-    if (display->mipmaps) {
-        struct sc_opengl *gl = &display->gl;
-
-        SDL_GL_BindTexture(texture, NULL, NULL);
-
-        // Enable trilinear filtering for downscaling
-        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
-
-        SDL_GL_UnbindTexture(texture);
-    }
-
-    return texture;
-}
-
-static inline void
-sc_display_set_pending_size(struct sc_display *display, struct sc_size size) {
-    assert(!display->texture);
-    display->pending.size = size;
-    display->pending.flags |= SC_DISPLAY_PENDING_FLAG_SIZE;
-}
-
-static bool
-sc_display_set_pending_frame(struct sc_display *display, const AVFrame *frame) {
-    if (!display->pending.frame) {
-        display->pending.frame = av_frame_alloc();
-        if (!display->pending.frame) {
-            LOG_OOM();
-            return false;
-        }
-    }
-
-    int r = av_frame_ref(display->pending.frame, frame);
-    if (r) {
-        LOGE("Could not ref frame: %d", r);
-        return false;
-    }
-
-    display->pending.flags |= SC_DISPLAY_PENDING_FLAG_FRAME;
-
-    return true;
-}
-
-static bool
-sc_display_apply_pending(struct sc_display *display) {
-    if (display->pending.flags & SC_DISPLAY_PENDING_FLAG_SIZE) {
-        assert(!display->texture);
-        display->texture =
-            sc_display_create_texture(display, display->pending.size);
-        if (!display->texture) {
-            return false;
-        }
-
-        display->pending.flags &= ~SC_DISPLAY_PENDING_FLAG_SIZE;
-    }
-
-    if (display->pending.flags & SC_DISPLAY_PENDING_FLAG_FRAME) {
-        assert(display->pending.frame);
-        bool ok = sc_display_update_texture(display, display->pending.frame);
-        if (!ok) {
-            return false;
-        }
-
-        av_frame_unref(display->pending.frame);
-        display->pending.flags &= ~SC_DISPLAY_PENDING_FLAG_FRAME;
-    }
-
-    return true;
-}
-
-static bool
-sc_display_set_texture_size_internal(struct sc_display *display,
-                                     struct sc_size size) {
-    assert(size.width && size.height);
-
-    if (display->texture) {
-        SDL_DestroyTexture(display->texture);
-    }
-
-    display->texture = sc_display_create_texture(display, size);
-    if (!display->texture) {
-        return false;
-    }
-
-    LOGI("Texture: %" PRIu16 "x%" PRIu16, size.width, size.height);
-    return true;
-}
-
-enum sc_display_result
-sc_display_set_texture_size(struct sc_display *display, struct sc_size size) {
-    bool ok = sc_display_set_texture_size_internal(display, size);
-    if (!ok) {
-        sc_display_set_pending_size(display, size);
-        return SC_DISPLAY_RESULT_PENDING;
-
-    }
-
-    return SC_DISPLAY_RESULT_OK;
-}
-
-static bool
-sc_display_update_texture_internal(struct sc_display *display,
-                                   const AVFrame *frame) {
-    int ret = SDL_UpdateYUVTexture(display->texture, NULL,
-                                   frame->data[0], frame->linesize[0],
-                                   frame->data[1], frame->linesize[1],
-                                   frame->data[2], frame->linesize[2]);
-    if (ret) {
-        LOGD("Could not update texture: %s", SDL_GetError());
-        return false;
-    }
-
-    if (display->mipmaps) {
-        SDL_GL_BindTexture(display->texture, NULL, NULL);
-        display->gl.GenerateMipmap(GL_TEXTURE_2D);
-        SDL_GL_UnbindTexture(display->texture);
-    }
-
-    return true;
-}
-
-enum sc_display_result
-sc_display_update_texture(struct sc_display *display, const AVFrame *frame) {
-    bool ok = sc_display_update_texture_internal(display, frame);
-    if (!ok) {
-        ok = sc_display_set_pending_frame(display, frame);
-        if (!ok) {
-            LOGE("Could not set pending frame");
-            return SC_DISPLAY_RESULT_ERROR;
-        }
-
-        return SC_DISPLAY_RESULT_PENDING;
-    }
-
-    return SC_DISPLAY_RESULT_OK;
-}
-
-enum sc_display_result
-sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
-                  unsigned rotation) {
-    SDL_RenderClear(display->renderer);
-
-    if (display->pending.flags) {
-        bool ok = sc_display_apply_pending(display);
-        if (!ok) {
-            return SC_DISPLAY_RESULT_PENDING;
-        }
-    }
-
-    SDL_Renderer *renderer = display->renderer;
-    SDL_Texture *texture = display->texture;
-
-    if (rotation == 0) {
-        int ret = SDL_RenderCopy(renderer, texture, NULL, geometry);
-        if (ret) {
-            LOGE("Could not render texture: %s", SDL_GetError());
-            return SC_DISPLAY_RESULT_ERROR;
-        }
-    } else {
-        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
-        // counterclockwise (to be consistent with --lock-video-orientation)
-        int cw_rotation = (4 - rotation) % 4;
-        double angle = 90 * cw_rotation;
-
-        const SDL_Rect *dstrect = NULL;
-        SDL_Rect rect;
-        if (rotation & 1) {
-            rect.x = geometry->x + (geometry->w - geometry->h) / 2;
-            rect.y = geometry->y + (geometry->h - geometry->w) / 2;
-            rect.w = geometry->h;
-            rect.h = geometry->w;
-            dstrect = &rect;
-        } else {
-            assert(rotation == 2);
-            dstrect = geometry;
-        }
-
-        int ret = SDL_RenderCopyEx(renderer, texture, NULL, dstrect, angle,
-                                   NULL, 0);
-        if (ret) {
-            LOGE("Could not render texture: %s", SDL_GetError());
-            return SC_DISPLAY_RESULT_ERROR;
-        }
-    }
-
-    SDL_RenderPresent(display->renderer);
-    return SC_DISPLAY_RESULT_OK;
-}

app/src/display.h

@@ -1,59 +0,0 @@
-#ifndef SC_DISPLAY_H
-#define SC_DISPLAY_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <libavformat/avformat.h>
-#include <SDL2/SDL.h>
-
-#include "coords.h"
-#include "opengl.h"
-
-#ifdef __APPLE__
-# define SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
-#endif
-
-struct sc_display {
-    SDL_Renderer *renderer;
-    SDL_Texture *texture;
-
-    struct sc_opengl gl;
-#ifdef SC_DISPLAY_FORCE_OPENGL_CORE_PROFILE
-    SDL_GLContext *gl_context;
-#endif
-
-    bool mipmaps;
-
-    struct {
-#define SC_DISPLAY_PENDING_FLAG_SIZE 1
-#define SC_DISPLAY_PENDING_FLAG_FRAME 2
-        int8_t flags;
-        struct sc_size size;
-        AVFrame *frame;
-    } pending;
-};
-
-enum sc_display_result {
-    SC_DISPLAY_RESULT_OK,
-    SC_DISPLAY_RESULT_PENDING,
-    SC_DISPLAY_RESULT_ERROR,
-};
-
-bool
-sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps);
-
-void
-sc_display_destroy(struct sc_display *display);
-
-enum sc_display_result
-sc_display_set_texture_size(struct sc_display *display, struct sc_size size);
-
-enum sc_display_result
-sc_display_update_texture(struct sc_display *display, const AVFrame *frame);
-
-enum sc_display_result
-sc_display_render(struct sc_display *display, const SDL_Rect *geometry,
-                  unsigned rotation);
-
-#endif

app/src/events.h

@@ -5,5 +5,3 @@
 #define SC_EVENT_USB_DEVICE_DISCONNECTED  (SDL_USEREVENT + 4)
 #define SC_EVENT_DEMUXER_ERROR            (SDL_USEREVENT + 5)
 #define SC_EVENT_RECORDER_ERROR           (SDL_USEREVENT + 6)
-#define SC_EVENT_SCREEN_INIT_SIZE         (SDL_USEREVENT + 7)
-#define SC_EVENT_TIME_LIMIT_REACHED       (SDL_USEREVENT + 8)

app/src/file_pusher.c

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

app/src/file_pusher.h

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

app/src/fps_counter.c

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

app/src/input_manager.c

@@ -797,8 +797,7 @@ sc_input_manager_process_file(struct sc_input_manager *im,
 }
 
 void
-sc_input_manager_handle_event(struct sc_input_manager *im,
+sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event) {
-                              const SDL_Event *event) {
     bool control = im->controller;
     switch (event->type) {
         case SDL_TEXTINPUT:

app/src/input_manager.h

@@ -61,7 +61,6 @@ sc_input_manager_init(struct sc_input_manager *im,
                       const struct sc_input_manager_params *params);
 
 void
-sc_input_manager_handle_event(struct sc_input_manager *im,
+sc_input_manager_handle_event(struct sc_input_manager *im, SDL_Event *event);
-                              const SDL_Event *event);
 
 #endif

app/src/options.c

@@ -11,10 +11,12 @@ const struct scrcpy_options scrcpy_options_default = {
     .audio_codec_options = NULL,
     .video_encoder = NULL,
     .audio_encoder = NULL,
+#ifdef HAVE_V4L2
+    .v4l2_device = NULL,
+#endif
     .log_level = SC_LOG_LEVEL_INFO,
     .video_codec = SC_CODEC_H264,
     .audio_codec = SC_CODEC_OPUS,
-    .audio_source = SC_AUDIO_SOURCE_OUTPUT,
     .record_format = SC_RECORD_FORMAT_AUTO,
     .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
     .mouse_input_mode = SC_MOUSE_INPUT_MODE_INJECT,
@@ -40,13 +42,7 @@ const struct scrcpy_options scrcpy_options_default = {
     .window_height = 0,
     .display_id = 0,
     .display_buffer = 0,
-    .audio_buffer = SC_TICK_FROM_MS(50),
-    .audio_output_buffer = SC_TICK_FROM_MS(5),
-    .time_limit = 0,
-#ifdef HAVE_V4L2
-    .v4l2_device = NULL,
     .v4l2_buffer = 0,
-#endif
 #ifdef HAVE_USB
     .otg = false,
 #endif
@@ -54,8 +50,7 @@ const struct scrcpy_options scrcpy_options_default = {
     .fullscreen = false,
     .always_on_top = false,
     .control = true,
-    .video_playback = true,
+    .display = true,
-    .audio_playback = true,
     .turn_screen_off = false,
     .key_inject_mode = SC_KEY_INJECT_MODE_MIXED,
     .window_borderless = false,
@@ -76,10 +71,7 @@ const struct scrcpy_options scrcpy_options_default = {
     .cleanup = true,
     .start_fps_counter = false,
     .power_on = true,
-    .video = true,
     .audio = true,
-    .require_audio = false,
     .list_encoders = false,
     .list_displays = false,
-    .kill_adb_on_close = false,
 };

app/src/options.h

@@ -21,32 +21,14 @@ enum sc_record_format {
     SC_RECORD_FORMAT_AUTO,
     SC_RECORD_FORMAT_MP4,
     SC_RECORD_FORMAT_MKV,
-    SC_RECORD_FORMAT_M4A,
-    SC_RECORD_FORMAT_MKA,
-    SC_RECORD_FORMAT_OPUS,
-    SC_RECORD_FORMAT_AAC,
 };
 
-static inline bool
-sc_record_format_is_audio_only(enum sc_record_format fmt) {
-    return fmt == SC_RECORD_FORMAT_M4A
-        || fmt == SC_RECORD_FORMAT_MKA
-        || fmt == SC_RECORD_FORMAT_OPUS
-        || fmt == SC_RECORD_FORMAT_AAC;
-}
-
 enum sc_codec {
     SC_CODEC_H264,
     SC_CODEC_H265,
     SC_CODEC_AV1,
     SC_CODEC_OPUS,
     SC_CODEC_AAC,
-    SC_CODEC_RAW,
-};
-
-enum sc_audio_source {
-    SC_AUDIO_SOURCE_OUTPUT,
-    SC_AUDIO_SOURCE_MIC,
 };
 
 enum sc_lock_video_orientation {
@@ -117,10 +99,12 @@ struct scrcpy_options {
     const char *audio_codec_options;
     const char *video_encoder;
     const char *audio_encoder;
+#ifdef HAVE_V4L2
+    const char *v4l2_device;
+#endif
     enum sc_log_level log_level;
     enum sc_codec video_codec;
     enum sc_codec audio_codec;
-    enum sc_audio_source audio_source;
     enum sc_record_format record_format;
     enum sc_keyboard_input_mode keyboard_input_mode;
     enum sc_mouse_input_mode mouse_input_mode;
@@ -140,13 +124,7 @@ struct scrcpy_options {
     uint16_t window_height;
     uint32_t display_id;
     sc_tick display_buffer;
-    sc_tick audio_buffer;
-    sc_tick audio_output_buffer;
-    sc_tick time_limit;
-#ifdef HAVE_V4L2
-    const char *v4l2_device;
     sc_tick v4l2_buffer;
-#endif
 #ifdef HAVE_USB
     bool otg;
 #endif
@@ -154,8 +132,7 @@ struct scrcpy_options {
     bool fullscreen;
     bool always_on_top;
     bool control;
-    bool video_playback;
+    bool display;
-    bool audio_playback;
     bool turn_screen_off;
     enum sc_key_inject_mode key_inject_mode;
     bool window_borderless;
@@ -176,12 +153,9 @@ struct scrcpy_options {
     bool cleanup;
     bool start_fps_counter;
     bool power_on;
-    bool video;
     bool audio;
-    bool require_audio;
     bool list_encoders;
     bool list_displays;
-    bool kill_adb_on_close;
 };
 
 extern const struct scrcpy_options scrcpy_options_default;

app/src/recorder.c

@@ -33,44 +33,50 @@ find_muxer(const char *name) {
     return oformat;
 }
 
-static AVPacket *
+static struct sc_record_packet *
-sc_recorder_packet_ref(const AVPacket *packet) {
+sc_record_packet_new(const AVPacket *packet) {
-    AVPacket *p = av_packet_alloc();
+    struct sc_record_packet *rec = malloc(sizeof(*rec));
-    if (!p) {
+    if (!rec) {
         LOG_OOM();
         return NULL;
     }
 
-    if (av_packet_ref(p, packet)) {
+    rec->packet = av_packet_alloc();
-        av_packet_free(&p);
+    if (!rec->packet) {
+        LOG_OOM();
+        free(rec);
         return NULL;
     }
 
-    return p;
+    if (av_packet_ref(rec->packet, packet)) {
+        av_packet_free(&rec->packet);
+        free(rec);
+        return NULL;
+    }
+    return rec;
+}
+
+static void
+sc_record_packet_delete(struct sc_record_packet *rec) {
+    av_packet_free(&rec->packet);
+    free(rec);
 }
 
 static void
 sc_recorder_queue_clear(struct sc_recorder_queue *queue) {
-    while (!sc_vecdeque_is_empty(queue)) {
+    while (!sc_queue_is_empty(queue)) {
-        AVPacket *p = sc_vecdeque_pop(queue);
+        struct sc_record_packet *rec;
-        av_packet_free(&p);
+        sc_queue_take(queue, next, &rec);
+        sc_record_packet_delete(rec);
     }
 }
 
 static const char *
 sc_recorder_get_format_name(enum sc_record_format format) {
     switch (format) {
-        case SC_RECORD_FORMAT_MP4:
+        case SC_RECORD_FORMAT_MP4: return "mp4";
-        case SC_RECORD_FORMAT_M4A:
+        case SC_RECORD_FORMAT_MKV: return "matroska";
-        case SC_RECORD_FORMAT_AAC:
+        default: return NULL;
-            return "mp4";
-        case SC_RECORD_FORMAT_MKV:
-        case SC_RECORD_FORMAT_MKA:
-            return "matroska";
-        case SC_RECORD_FORMAT_OPUS:
-            return "opus";
-        default:
-            return NULL;
     }
 }
 
@@ -96,30 +102,23 @@ sc_recorder_rescale_packet(AVStream *stream, AVPacket *packet) {
 }
 
 static bool
-sc_recorder_write_stream(struct sc_recorder *recorder,
+sc_recorder_write_stream(struct sc_recorder *recorder, int stream_index,
-                         struct sc_recorder_stream *st, AVPacket *packet) {
+                         AVPacket *packet) {
-    AVStream *stream = recorder->ctx->streams[st->index];
+    AVStream *stream = recorder->ctx->streams[stream_index];
     sc_recorder_rescale_packet(stream, packet);
-    if (st->last_pts != AV_NOPTS_VALUE && packet->pts <= st->last_pts) {
-        LOGW("Fixing PTS non monotonically increasing in stream %d "
-             "(%" PRIi64 " >= %" PRIi64 ")",
-             st->index, st->last_pts, packet->pts);
-        packet->pts = ++st->last_pts;
-        packet->dts = packet->pts;
-    } else {
-        st->last_pts = packet->pts;
-    }
     return av_interleaved_write_frame(recorder->ctx, packet) >= 0;
 }
 
 static inline bool
 sc_recorder_write_video(struct sc_recorder *recorder, AVPacket *packet) {
-    return sc_recorder_write_stream(recorder, &recorder->video_stream, packet);
+    return sc_recorder_write_stream(recorder, recorder->video_stream_index,
+                                    packet);
 }
 
 static inline bool
 sc_recorder_write_audio(struct sc_recorder *recorder, AVPacket *packet) {
-    return sc_recorder_write_stream(recorder, &recorder->audio_stream, packet);
+    return sc_recorder_write_stream(recorder, recorder->audio_stream_index,
+                                    packet);
 }
 
 static bool
@@ -165,14 +164,80 @@ sc_recorder_close_output_file(struct sc_recorder *recorder) {
     avformat_free_context(recorder->ctx);
 }
 
+static bool
+sc_recorder_wait_video_stream(struct sc_recorder *recorder) {
+    sc_mutex_lock(&recorder->mutex);
+    while (!recorder->video_codec && !recorder->stopped) {
+        sc_cond_wait(&recorder->stream_cond, &recorder->mutex);
+    }
+    const AVCodec *codec = recorder->video_codec;
+    sc_mutex_unlock(&recorder->mutex);
+
+    if (codec) {
+        AVStream *stream = avformat_new_stream(recorder->ctx, codec);
+        if (!stream) {
+            return false;
+        }
+
+        stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
+        stream->codecpar->codec_id = codec->id;
+        stream->codecpar->format = AV_PIX_FMT_YUV420P;
+        stream->codecpar->width = recorder->declared_frame_size.width;
+        stream->codecpar->height = recorder->declared_frame_size.height;
+
+        recorder->video_stream_index = stream->index;
+    }
+
+    return true;
+}
+
+static bool
+sc_recorder_wait_audio_stream(struct sc_recorder *recorder) {
+    sc_mutex_lock(&recorder->mutex);
+    while (!recorder->audio_codec && !recorder->audio_disabled
+            && !recorder->stopped) {
+        sc_cond_wait(&recorder->stream_cond, &recorder->mutex);
+    }
+
+    if (recorder->audio_disabled) {
+        // Reset audio flag. From there, the recorder thread may access this
+        // flag without any mutex.
+        recorder->audio = false;
+    }
+
+    const AVCodec *codec = recorder->audio_codec;
+    sc_mutex_unlock(&recorder->mutex);
+
+    if (codec) {
+        AVStream *stream = avformat_new_stream(recorder->ctx, codec);
+        if (!stream) {
+            return false;
+        }
+
+        stream->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
+        stream->codecpar->codec_id = codec->id;
+#ifdef SCRCPY_LAVU_HAS_CHLAYOUT
+        stream->codecpar->ch_layout.nb_channels = 2;
+#else
+        stream->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
+        stream->codecpar->channels = 2;
+#endif
+        stream->codecpar->sample_rate = 48000;
+
+        recorder->audio_stream_index = stream->index;
+    }
+
+    return true;
+}
+
 static inline bool
 sc_recorder_has_empty_queues(struct sc_recorder *recorder) {
-    if (recorder->video && sc_vecdeque_is_empty(&recorder->video_queue)) {
+    if (sc_queue_is_empty(&recorder->video_queue)) {
         // The video queue is empty
         return true;
     }
 
-    if (recorder->audio && sc_vecdeque_is_empty(&recorder->audio_queue)) {
+    if (recorder->audio && sc_queue_is_empty(&recorder->audio_queue)) {
         // The audio queue is empty (when audio is enabled)
         return true;
     }
@@ -185,68 +250,59 @@ static bool
 sc_recorder_process_header(struct sc_recorder *recorder) {
     sc_mutex_lock(&recorder->mutex);
 
-    while (!recorder->stopped &&
+    while (!recorder->stopped && sc_recorder_has_empty_queues(recorder)) {
-              ((recorder->video && !recorder->video_init)
+        sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
-            || (recorder->audio && !recorder->audio_init)
-            || sc_recorder_has_empty_queues(recorder))) {
-        sc_cond_wait(&recorder->cond, &recorder->mutex);
     }
 
-    if (recorder->video && sc_vecdeque_is_empty(&recorder->video_queue)) {
+    if (recorder->stopped && sc_queue_is_empty(&recorder->video_queue)) {
-        assert(recorder->stopped);
         // If the recorder is stopped, don't process anything if there are not
         // at least video packets
         sc_mutex_unlock(&recorder->mutex);
         return false;
     }
 
-    AVPacket *video_pkt = NULL;
+    struct sc_record_packet *video_pkt;
-    if (!sc_vecdeque_is_empty(&recorder->video_queue)) {
+    sc_queue_take(&recorder->video_queue, next, &video_pkt);
-        assert(recorder->video);
-        video_pkt = sc_vecdeque_pop(&recorder->video_queue);
-    }
 
-    AVPacket *audio_pkt = NULL;
+    struct sc_record_packet *audio_pkt = NULL;
-    if (!sc_vecdeque_is_empty(&recorder->audio_queue)) {
+    if (!sc_queue_is_empty(&recorder->audio_queue)) {
         assert(recorder->audio);
-        audio_pkt = sc_vecdeque_pop(&recorder->audio_queue);
+        sc_queue_take(&recorder->audio_queue, next, &audio_pkt);
     }
 
     sc_mutex_unlock(&recorder->mutex);
 
     int ret = false;
 
-    if (video_pkt) {
+    if (video_pkt->packet->pts != AV_NOPTS_VALUE) {
-        if (video_pkt->pts != AV_NOPTS_VALUE) {
+        LOGE("The first video packet is not a config packet");
-            LOGE("The first video packet is not a config packet");
+        goto end;
-            goto end;
+    }
-        }
 
-        assert(recorder->video_stream.index >= 0);
+    assert(recorder->video_stream_index >= 0);
-        AVStream *video_stream =
+    AVStream *video_stream =
-            recorder->ctx->streams[recorder->video_stream.index];
+        recorder->ctx->streams[recorder->video_stream_index];
-        bool ok = sc_recorder_set_extradata(video_stream, video_pkt);
+    bool ok = sc_recorder_set_extradata(video_stream, video_pkt->packet);
-        if (!ok) {
+    if (!ok) {
-            goto end;
+        goto end;
-        }
     }
 
     if (audio_pkt) {
-        if (audio_pkt->pts != AV_NOPTS_VALUE) {
+        if (audio_pkt->packet->pts != AV_NOPTS_VALUE) {
             LOGE("The first audio packet is not a config packet");
             goto end;
         }
 
-        assert(recorder->audio_stream.index >= 0);
+        assert(recorder->audio_stream_index >= 0);
         AVStream *audio_stream =
-            recorder->ctx->streams[recorder->audio_stream.index];
+            recorder->ctx->streams[recorder->audio_stream_index];
-        bool ok = sc_recorder_set_extradata(audio_stream, audio_pkt);
+        ok = sc_recorder_set_extradata(audio_stream, audio_pkt->packet);
         if (!ok) {
             goto end;
         }
     }
 
-    bool ok = avformat_write_header(recorder->ctx, NULL) >= 0;
+    ok = avformat_write_header(recorder->ctx, NULL) >= 0;
     if (!ok) {
         LOGE("Failed to write header to %s", recorder->filename);
         goto end;
@@ -255,11 +311,9 @@ sc_recorder_process_header(struct sc_recorder *recorder) {
     ret = true;
 
 end:
-    if (video_pkt) {
+    sc_record_packet_delete(video_pkt);
-        av_packet_free(&video_pkt);
-    }
     if (audio_pkt) {
-        av_packet_free(&audio_pkt);
+        sc_record_packet_delete(audio_pkt);
     }
 
     return ret;
@@ -274,12 +328,12 @@ sc_recorder_process_packets(struct sc_recorder *recorder) {
         return false;
     }
 
-    AVPacket *video_pkt = NULL;
+    struct sc_record_packet *video_pkt = NULL;
-    AVPacket *audio_pkt = NULL;
+    struct sc_record_packet *audio_pkt = NULL;
 
     // We can write a video packet only once we received the next one so that
     // we can set its duration (next_pts - current_pts)
-    AVPacket *video_pkt_previous = NULL;
+    struct sc_record_packet *video_pkt_previous = NULL;
 
     bool error = false;
 
@@ -287,43 +341,37 @@ sc_recorder_process_packets(struct sc_recorder *recorder) {
         sc_mutex_lock(&recorder->mutex);
 
         while (!recorder->stopped) {
-            if (recorder->video && !video_pkt &&
+            if (!video_pkt && !sc_queue_is_empty(&recorder->video_queue)) {
-                    !sc_vecdeque_is_empty(&recorder->video_queue)) {
                 // A new packet may be assigned to video_pkt and be processed
                 break;
             }
             if (recorder->audio && !audio_pkt
-                    && !sc_vecdeque_is_empty(&recorder->audio_queue)) {
+                    && !sc_queue_is_empty(&recorder->audio_queue)) {
                 // A new packet may be assigned to audio_pkt and be processed
                 break;
             }
-            sc_cond_wait(&recorder->cond, &recorder->mutex);
+            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
         }
 
         // If stopped is set, continue to process the remaining events (to
         // finish the recording) before actually stopping.
 
-        // If there is no video, then the video_queue will remain empty forever
-        // and video_pkt will always be NULL.
-        assert(recorder->video || (!video_pkt
-                && sc_vecdeque_is_empty(&recorder->video_queue)));
-
         // If there is no audio, then the audio_queue will remain empty forever
         // and audio_pkt will always be NULL.
-        assert(recorder->audio || (!audio_pkt
+        assert(recorder->audio
-                && sc_vecdeque_is_empty(&recorder->audio_queue)));
+                || (!audio_pkt && sc_queue_is_empty(&recorder->audio_queue)));
 
-        if (!video_pkt && !sc_vecdeque_is_empty(&recorder->video_queue)) {
+        if (!video_pkt && !sc_queue_is_empty(&recorder->video_queue)) {
-            video_pkt = sc_vecdeque_pop(&recorder->video_queue);
+            sc_queue_take(&recorder->video_queue, next, &video_pkt);
         }
 
-        if (!audio_pkt && !sc_vecdeque_is_empty(&recorder->audio_queue)) {
+        if (!audio_pkt && !sc_queue_is_empty(&recorder->audio_queue)) {
-            audio_pkt = sc_vecdeque_pop(&recorder->audio_queue);
+            sc_queue_take(&recorder->audio_queue, next, &audio_pkt);
         }
 
         if (recorder->stopped && !video_pkt && !audio_pkt) {
-            assert(sc_vecdeque_is_empty(&recorder->video_queue));
+            assert(sc_queue_is_empty(&recorder->video_queue));
-            assert(sc_vecdeque_is_empty(&recorder->audio_queue));
+            assert(sc_queue_is_empty(&recorder->audio_queue));
             sc_mutex_unlock(&recorder->mutex);
             break;
         }
@@ -335,35 +383,38 @@ sc_recorder_process_packets(struct sc_recorder *recorder) {
         // Ignore further config packets (e.g. on device orientation
         // change). The next non-config packet will have the config packet
         // data prepended.
-        if (video_pkt && video_pkt->pts == AV_NOPTS_VALUE) {
+        if (video_pkt && video_pkt->packet->pts == AV_NOPTS_VALUE) {
-            av_packet_free(&video_pkt);
+            sc_record_packet_delete(video_pkt);
             video_pkt = NULL;
         }
 
-        if (audio_pkt && audio_pkt->pts == AV_NOPTS_VALUE) {
+        if (audio_pkt && audio_pkt->packet->pts == AV_NOPTS_VALUE) {
-            av_packet_free(&audio_pkt);
+            sc_record_packet_delete(audio_pkt);
-            audio_pkt = NULL;
+            audio_pkt= NULL;
         }
 
         if (pts_origin == AV_NOPTS_VALUE) {
             if (!recorder->audio) {
                 assert(video_pkt);
-                pts_origin = video_pkt->pts;
+                pts_origin = video_pkt->packet->pts;
-            } else if (!recorder->video) {
-                assert(audio_pkt);
-                pts_origin = audio_pkt->pts;
             } else if (video_pkt && audio_pkt) {
-                pts_origin = MIN(video_pkt->pts, audio_pkt->pts);
+                pts_origin =
+                    MIN(video_pkt->packet->pts, audio_pkt->packet->pts);
             } else if (recorder->stopped) {
                 if (video_pkt) {
                     // The recorder is stopped without audio, record the video
                     // packets
-                    pts_origin = video_pkt->pts;
+                    pts_origin = video_pkt->packet->pts;
                 } else {
                     // Fail if there is no video
                     error = true;
                     goto end;
                 }
+                // If the recorder is stopped while one of the streams has no
+                // packets, then we must avoid a live-loop and correctly record
+                // the stream having packets.
+                pts_origin = video_pkt ? video_pkt->packet->pts
+                                       : audio_pkt->packet->pts;
             } else {
                 // We need both video and audio packets to initialize pts_origin
                 continue;
@@ -373,16 +424,17 @@ sc_recorder_process_packets(struct sc_recorder *recorder) {
         assert(pts_origin != AV_NOPTS_VALUE);
 
         if (video_pkt) {
-            video_pkt->pts -= pts_origin;
+            video_pkt->packet->pts -= pts_origin;
-            video_pkt->dts = video_pkt->pts;
+            video_pkt->packet->dts = video_pkt->packet->pts;
 
             if (video_pkt_previous) {
                 // we now know the duration of the previous packet
-                video_pkt_previous->duration = video_pkt->pts
+                video_pkt_previous->packet->duration =
-                                             - video_pkt_previous->pts;
+                    video_pkt->packet->pts - video_pkt_previous->packet->pts;
 
-                bool ok = sc_recorder_write_video(recorder, video_pkt_previous);
+                bool ok = sc_recorder_write_video(recorder,
-                av_packet_free(&video_pkt_previous);
+                                                  video_pkt_previous->packet);
+                sc_record_packet_delete(video_pkt_previous);
                 if (!ok) {
                     LOGE("Could not record video packet");
                     error = true;
@@ -395,34 +447,34 @@ sc_recorder_process_packets(struct sc_recorder *recorder) {
         }
 
         if (audio_pkt) {
-            audio_pkt->pts -= pts_origin;
+            audio_pkt->packet->pts -= pts_origin;
-            audio_pkt->dts = audio_pkt->pts;
+            audio_pkt->packet->dts = audio_pkt->packet->pts;
 
-            bool ok = sc_recorder_write_audio(recorder, audio_pkt);
+            bool ok = sc_recorder_write_audio(recorder, audio_pkt->packet);
             if (!ok) {
                 LOGE("Could not record audio packet");
                 error = true;
                 goto end;
             }
 
-            av_packet_free(&audio_pkt);
+            sc_record_packet_delete(audio_pkt);
             audio_pkt = NULL;
         }
     }
 
     // Write the last video packet
-    AVPacket *last = video_pkt_previous;
+    struct sc_record_packet *last = video_pkt_previous;
     if (last) {
         // assign an arbitrary duration to the last packet
-        last->duration = 100000;
+        last->packet->duration = 100000;
-        bool ok = sc_recorder_write_video(recorder, last);
+        bool ok = sc_recorder_write_video(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");
         }
-        av_packet_free(&last);
+        sc_record_packet_delete(last);
     }
 
     int ret = av_write_trailer(recorder->ctx);
@@ -433,10 +485,10 @@ sc_recorder_process_packets(struct sc_recorder *recorder) {
 
 end:
     if (video_pkt) {
-        av_packet_free(&video_pkt);
+        sc_record_packet_delete(video_pkt);
     }
     if (audio_pkt) {
-        av_packet_free(&audio_pkt);
+        sc_record_packet_delete(audio_pkt);
     }
 
     return !error;
@@ -449,6 +501,22 @@ sc_recorder_record(struct sc_recorder *recorder) {
         return false;
     }
 
+    ok = sc_recorder_wait_video_stream(recorder);
+    if (!ok) {
+        sc_recorder_close_output_file(recorder);
+        return false;
+    }
+
+    if (recorder->audio) {
+        ok = sc_recorder_wait_audio_stream(recorder);
+        if (!ok) {
+            sc_recorder_close_output_file(recorder);
+            return false;
+        }
+    }
+
+    // If recorder->stopped, process any queued packet anyway
+
     ok = sc_recorder_process_packets(recorder);
     sc_recorder_close_output_file(recorder);
     return ok;
@@ -458,10 +526,6 @@ static int
 run_recorder(void *data) {
     struct sc_recorder *recorder = data;
 
-    // Recording is a background task
-    bool ok = sc_thread_set_priority(SC_THREAD_PRIORITY_LOW);
-    (void) ok; // We don't care if it worked
-
     bool success = sc_recorder_record(recorder);
 
     sc_mutex_lock(&recorder->mutex);
@@ -469,7 +533,6 @@ run_recorder(void *data) {
     recorder->stopped = true;
     // Discard pending packets
     sc_recorder_queue_clear(&recorder->video_queue);
-    sc_recorder_queue_clear(&recorder->audio_queue);
     sc_mutex_unlock(&recorder->mutex);
 
     if (success) {
@@ -489,10 +552,9 @@ run_recorder(void *data) {
 
 static bool
 sc_recorder_video_packet_sink_open(struct sc_packet_sink *sink,
-                                   AVCodecContext *ctx) {
+                                   const AVCodec *codec) {
     struct sc_recorder *recorder = DOWNCAST_VIDEO(sink);
-    // only written from this thread, no need to lock
+    assert(codec);
-    assert(!recorder->video_init);
 
     sc_mutex_lock(&recorder->mutex);
     if (recorder->stopped) {
@@ -500,22 +562,8 @@ sc_recorder_video_packet_sink_open(struct sc_packet_sink *sink,
         return false;
     }
 
-    AVStream *stream = avformat_new_stream(recorder->ctx, ctx->codec);
+    recorder->video_codec = codec;
-    if (!stream) {
+    sc_cond_signal(&recorder->stream_cond);
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
-    }
-
-    int r = avcodec_parameters_from_context(stream->codecpar, ctx);
-    if (r < 0) {
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
-    }
-
-    recorder->video_stream.index = stream->index;
-
-    recorder->video_init = true;
-    sc_cond_signal(&recorder->cond);
     sc_mutex_unlock(&recorder->mutex);
 
     return true;
@@ -524,13 +572,11 @@ sc_recorder_video_packet_sink_open(struct sc_packet_sink *sink,
 static void
 sc_recorder_video_packet_sink_close(struct sc_packet_sink *sink) {
     struct sc_recorder *recorder = DOWNCAST_VIDEO(sink);
-    // only written from this thread, no need to lock
-    assert(recorder->video_init);
 
     sc_mutex_lock(&recorder->mutex);
     // EOS also stops the recorder
     recorder->stopped = true;
-    sc_cond_signal(&recorder->cond);
+    sc_cond_signal(&recorder->queue_cond);
     sc_mutex_unlock(&recorder->mutex);
 }
 
@@ -538,8 +584,6 @@ static bool
 sc_recorder_video_packet_sink_push(struct sc_packet_sink *sink,
                                    const AVPacket *packet) {
     struct sc_recorder *recorder = DOWNCAST_VIDEO(sink);
-    // only written from this thread, no need to lock
-    assert(recorder->video_init);
 
     sc_mutex_lock(&recorder->mutex);
 
@@ -549,23 +593,17 @@ sc_recorder_video_packet_sink_push(struct sc_packet_sink *sink,
         return false;
     }
 
-    AVPacket *rec = sc_recorder_packet_ref(packet);
+    struct sc_record_packet *rec = sc_record_packet_new(packet);
     if (!rec) {
         LOG_OOM();
         sc_mutex_unlock(&recorder->mutex);
         return false;
     }
 
-    rec->stream_index = recorder->video_stream.index;
+    rec->packet->stream_index = 0;
 
-    bool ok = sc_vecdeque_push(&recorder->video_queue, rec);
+    sc_queue_push(&recorder->video_queue, next, rec);
-    if (!ok) {
+    sc_cond_signal(&recorder->queue_cond);
-        LOG_OOM();
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
-    }
-
-    sc_cond_signal(&recorder->cond);
 
     sc_mutex_unlock(&recorder->mutex);
     return true;
@@ -573,30 +611,16 @@ sc_recorder_video_packet_sink_push(struct sc_packet_sink *sink,
 
 static bool
 sc_recorder_audio_packet_sink_open(struct sc_packet_sink *sink,
-                                   AVCodecContext *ctx) {
+                                   const AVCodec *codec) {
     struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
     assert(recorder->audio);
     // only written from this thread, no need to lock
-    assert(!recorder->audio_init);
+    assert(!recorder->audio_disabled);
+    assert(codec);
 
     sc_mutex_lock(&recorder->mutex);
-
+    recorder->audio_codec = codec;
-    AVStream *stream = avformat_new_stream(recorder->ctx, ctx->codec);
+    sc_cond_signal(&recorder->stream_cond);
-    if (!stream) {
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
-    }
-
-    int r = avcodec_parameters_from_context(stream->codecpar, ctx);
-    if (r < 0) {
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
-    }
-
-    recorder->audio_stream.index = stream->index;
-
-    recorder->audio_init = true;
-    sc_cond_signal(&recorder->cond);
     sc_mutex_unlock(&recorder->mutex);
 
     return true;
@@ -607,12 +631,12 @@ sc_recorder_audio_packet_sink_close(struct sc_packet_sink *sink) {
     struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
     assert(recorder->audio);
     // only written from this thread, no need to lock
-    assert(recorder->audio_init);
+    assert(!recorder->audio_disabled);
 
     sc_mutex_lock(&recorder->mutex);
     // EOS also stops the recorder
     recorder->stopped = true;
-    sc_cond_signal(&recorder->cond);
+    sc_cond_signal(&recorder->queue_cond);
     sc_mutex_unlock(&recorder->mutex);
 }
 
@@ -622,7 +646,7 @@ sc_recorder_audio_packet_sink_push(struct sc_packet_sink *sink,
     struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
     assert(recorder->audio);
     // only written from this thread, no need to lock
-    assert(recorder->audio_init);
+    assert(!recorder->audio_disabled);
 
     sc_mutex_lock(&recorder->mutex);
 
@@ -632,23 +656,17 @@ sc_recorder_audio_packet_sink_push(struct sc_packet_sink *sink,
         return false;
     }
 
-    AVPacket *rec = sc_recorder_packet_ref(packet);
+    struct sc_record_packet *rec = sc_record_packet_new(packet);
     if (!rec) {
         LOG_OOM();
         sc_mutex_unlock(&recorder->mutex);
         return false;
     }
 
-    rec->stream_index = recorder->audio_stream.index;
+    rec->packet->stream_index = 1;
 
-    bool ok = sc_vecdeque_push(&recorder->audio_queue, rec);
+    sc_queue_push(&recorder->audio_queue, next, rec);
-    if (!ok) {
+    sc_cond_signal(&recorder->queue_cond);
-        LOG_OOM();
-        sc_mutex_unlock(&recorder->mutex);
-        return false;
-    }
-
-    sc_cond_signal(&recorder->cond);
 
     sc_mutex_unlock(&recorder->mutex);
     return true;
@@ -659,26 +677,21 @@ sc_recorder_audio_packet_sink_disable(struct sc_packet_sink *sink) {
     struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
     assert(recorder->audio);
     // only written from this thread, no need to lock
-    assert(!recorder->audio_init);
+    assert(!recorder->audio_disabled);
+    assert(!recorder->audio_codec);
 
     LOGW("Audio stream recording disabled");
 
     sc_mutex_lock(&recorder->mutex);
-    recorder->audio = false;
+    recorder->audio_disabled = true;
-    recorder->audio_init = true;
+    sc_cond_signal(&recorder->stream_cond);
-    sc_cond_signal(&recorder->cond);
     sc_mutex_unlock(&recorder->mutex);
 }
 
-static void
-sc_recorder_stream_init(struct sc_recorder_stream *stream) {
-    stream->index = -1;
-    stream->last_pts = AV_NOPTS_VALUE;
-}
-
 bool
 sc_recorder_init(struct sc_recorder *recorder, const char *filename,
-                 enum sc_record_format format, bool video, bool audio,
+                 enum sc_record_format format, bool audio,
+                 struct sc_size declared_frame_size,
                  const struct sc_recorder_callbacks *cbs, void *cbs_userdata) {
     recorder->filename = strdup(filename);
     if (!recorder->filename) {
@@ -691,40 +704,43 @@ sc_recorder_init(struct sc_recorder *recorder, const char *filename,
         goto error_free_filename;
     }
 
-    ok = sc_cond_init(&recorder->cond);
+    ok = sc_cond_init(&recorder->queue_cond);
     if (!ok) {
         goto error_mutex_destroy;
     }
 
-    assert(video || audio);
+    ok = sc_cond_init(&recorder->stream_cond);
-    recorder->video = video;
+    if (!ok) {
+        goto error_queue_cond_destroy;
+    }
+
     recorder->audio = audio;
 
-    sc_vecdeque_init(&recorder->video_queue);
+    sc_queue_init(&recorder->video_queue);
-    sc_vecdeque_init(&recorder->audio_queue);
+    sc_queue_init(&recorder->audio_queue);
     recorder->stopped = false;
 
-    recorder->video_init = false;
+    recorder->video_codec = NULL;
-    recorder->audio_init = false;
+    recorder->audio_codec = NULL;
+    recorder->audio_disabled = false;
 
-    sc_recorder_stream_init(&recorder->video_stream);
+    recorder->video_stream_index = -1;
-    sc_recorder_stream_init(&recorder->audio_stream);
+    recorder->audio_stream_index = -1;
 
     recorder->format = format;
+    recorder->declared_frame_size = declared_frame_size;
 
     assert(cbs && cbs->on_ended);
     recorder->cbs = cbs;
     recorder->cbs_userdata = cbs_userdata;
 
-    if (video) {
+    static const struct sc_packet_sink_ops video_ops = {
-        static const struct sc_packet_sink_ops video_ops = {
+        .open = sc_recorder_video_packet_sink_open,
-            .open = sc_recorder_video_packet_sink_open,
+        .close = sc_recorder_video_packet_sink_close,
-            .close = sc_recorder_video_packet_sink_close,
+        .push = sc_recorder_video_packet_sink_push,
-            .push = sc_recorder_video_packet_sink_push,
+    };
-        };
 
-        recorder->video_packet_sink.ops = &video_ops;
+    recorder->video_packet_sink.ops = &video_ops;
-    }
 
     if (audio) {
         static const struct sc_packet_sink_ops audio_ops = {
@@ -739,6 +755,8 @@ sc_recorder_init(struct sc_recorder *recorder, const char *filename,
 
     return true;
 
+error_queue_cond_destroy:
+    sc_cond_destroy(&recorder->queue_cond);
 error_mutex_destroy:
     sc_mutex_destroy(&recorder->mutex);
 error_free_filename:
@@ -763,7 +781,8 @@ void
 sc_recorder_stop(struct sc_recorder *recorder) {
     sc_mutex_lock(&recorder->mutex);
     recorder->stopped = true;
-    sc_cond_signal(&recorder->cond);
+    sc_cond_signal(&recorder->queue_cond);
+    sc_cond_signal(&recorder->stream_cond);
     sc_mutex_unlock(&recorder->mutex);
 }
 
@@ -774,7 +793,8 @@ sc_recorder_join(struct sc_recorder *recorder) {
 
 void
 sc_recorder_destroy(struct sc_recorder *recorder) {
-    sc_cond_destroy(&recorder->cond);
+    sc_cond_destroy(&recorder->stream_cond);
+    sc_cond_destroy(&recorder->queue_cond);
     sc_mutex_destroy(&recorder->mutex);
     free(recorder->filename);
 }

app/src/recorder.h

@@ -9,16 +9,16 @@
 #include "coords.h"
 #include "options.h"
 #include "trait/packet_sink.h"
+#include "util/queue.h"
 #include "util/thread.h"
-#include "util/vecdeque.h"
 
-struct sc_recorder_queue SC_VECDEQUE(AVPacket *);
+struct sc_record_packet {
-
+    AVPacket *packet;
-struct sc_recorder_stream {
+    struct sc_record_packet *next;
-    int index;
-    int64_t last_pts;
 };
 
+struct sc_recorder_queue SC_QUEUE(struct sc_record_packet);
+
 struct sc_recorder {
     struct sc_packet_sink video_packet_sink;
     struct sc_packet_sink audio_packet_sink;
@@ -32,26 +32,30 @@ struct sc_recorder {
      * may access it without data races.
      */
     bool audio;
-    bool video;
 
     char *filename;
     enum sc_record_format format;
     AVFormatContext *ctx;
+    struct sc_size declared_frame_size;
 
     sc_thread thread;
     sc_mutex mutex;
-    sc_cond cond;
+    sc_cond queue_cond;
     // set on sc_recorder_stop(), packet_sink close or recording failure
     bool stopped;
     struct sc_recorder_queue video_queue;
     struct sc_recorder_queue audio_queue;
 
     // wake up the recorder thread once the video or audio codec is known
-    bool video_init;
+    sc_cond stream_cond;
-    bool audio_init;
+    const AVCodec *video_codec;
+    const AVCodec *audio_codec;
+    // Instead of providing an audio_codec, the demuxer may notify that the
+    // stream is disabled if the device could not capture audio
+    bool audio_disabled;
 
-    struct sc_recorder_stream video_stream;
+    int video_stream_index;
-    struct sc_recorder_stream audio_stream;
+    int audio_stream_index;
 
     const struct sc_recorder_callbacks *cbs;
     void *cbs_userdata;
@@ -64,7 +68,8 @@ struct sc_recorder_callbacks {
 
 bool
 sc_recorder_init(struct sc_recorder *recorder, const char *filename,
-                 enum sc_record_format format, bool video, bool audio,
+                 enum sc_record_format format, bool audio,
+                 struct sc_size declared_frame_size,
                  const struct sc_recorder_callbacks *cbs, void *cbs_userdata);
 
 bool

app/src/scrcpy.c

@@ -16,7 +16,6 @@
 #include "audio_player.h"
 #include "controller.h"
 #include "decoder.h"
-#include "delay_buffer.h"
 #include "demuxer.h"
 #include "events.h"
 #include "file_pusher.h"
@@ -35,7 +34,6 @@
 #include "util/log.h"
 #include "util/net.h"
 #include "util/rand.h"
-#include "util/timeout.h"
 #ifdef HAVE_V4L2
 # include "v4l2_sink.h"
 #endif
@@ -49,10 +47,8 @@ struct scrcpy {
     struct sc_decoder video_decoder;
     struct sc_decoder audio_decoder;
     struct sc_recorder recorder;
-    struct sc_delay_buffer display_buffer;
 #ifdef HAVE_V4L2
     struct sc_v4l2_sink v4l2_sink;
-    struct sc_delay_buffer v4l2_buffer;
 #endif
     struct sc_controller controller;
     struct sc_file_pusher file_pusher;
@@ -74,7 +70,6 @@ struct scrcpy {
         struct sc_hid_mouse mouse_hid;
 #endif
     };
-    struct sc_timeout timeout;
 };
 
 static inline void
@@ -139,7 +134,7 @@ sdl_set_hints(const char *render_driver) {
 }
 
 static void
-sdl_configure(bool video_playback, bool disable_screensaver) {
+sdl_configure(bool display, bool disable_screensaver) {
 #ifdef _WIN32
     // Clean up properly on Ctrl+C on Windows
     bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
@@ -148,7 +143,7 @@ sdl_configure(bool video_playback, bool disable_screensaver) {
     }
 #endif // _WIN32
 
-    if (!video_playback) {
+    if (!display) {
         return;
     }
 
@@ -173,16 +168,11 @@ event_loop(struct scrcpy *s) {
             case SC_EVENT_RECORDER_ERROR:
                 LOGE("Recorder error");
                 return SCRCPY_EXIT_FAILURE;
-            case SC_EVENT_TIME_LIMIT_REACHED:
-                LOGI("Time limit reached");
-                return SCRCPY_EXIT_SUCCESS;
             case SDL_QUIT:
                 LOGD("User requested to quit");
                 return SCRCPY_EXIT_SUCCESS;
             default:
-                if (!sc_screen_handle_event(&s->screen, &event)) {
+                sc_screen_handle_event(&s->screen, &event);
-                    return SCRCPY_EXIT_FAILURE;
-                }
                 break;
         }
     }
@@ -228,15 +218,12 @@ sc_recorder_on_ended(struct sc_recorder *recorder, bool success,
 }
 
 static void
-sc_video_demuxer_on_ended(struct sc_demuxer *demuxer,
+sc_video_demuxer_on_ended(struct sc_demuxer *demuxer, bool eos,
-                          enum sc_demuxer_status status, void *userdata) {
+                          void *userdata) {
     (void) demuxer;
     (void) userdata;
 
-    // The device may not decide to disable the video
+    if (eos) {
-    assert(status != SC_DEMUXER_STATUS_DISABLED);
-
-    if (status == SC_DEMUXER_STATUS_EOS) {
         PUSH_EVENT(SC_EVENT_DEVICE_DISCONNECTED);
     } else {
         PUSH_EVENT(SC_EVENT_DEMUXER_ERROR);
@@ -244,17 +231,20 @@ sc_video_demuxer_on_ended(struct sc_demuxer *demuxer,
 }
 
 static void
-sc_audio_demuxer_on_ended(struct sc_demuxer *demuxer,
+sc_audio_demuxer_on_ended(struct sc_demuxer *demuxer, bool eos,
-                          enum sc_demuxer_status status, void *userdata) {
+                          void *userdata) {
     (void) demuxer;
+    (void) userdata;
 
-    const struct scrcpy_options *options = userdata;
+    // Contrary to the video demuxer, keep mirroring if only the audio fails.
+    // 'eos' is true on end-of-stream, including when audio capture is not
+    // possible on the device (so that scrcpy continue to mirror video without
+    // failing).
+    // However, if an audio configuration failure occurs (for example the user
+    // explicitly selected an unknown audio encoder), 'eos' is false and scrcpy
+    // must exit.
 
-    // Contrary to the video demuxer, keep mirroring if only the audio fails
+    if (!eos) {
-    // (unless --require-audio is set).
-    if (status == SC_DEMUXER_STATUS_ERROR
-            || (status == SC_DEMUXER_STATUS_DISABLED
-                && options->require_audio)) {
         PUSH_EVENT(SC_EVENT_DEMUXER_ERROR);
     }
 }
@@ -285,14 +275,6 @@ sc_server_on_disconnected(struct sc_server *server, void *userdata) {
     // event
 }
 
-static void
-sc_timeout_on_timeout(struct sc_timeout *timeout, void *userdata) {
-    (void) timeout;
-    (void) userdata;
-
-    PUSH_EVENT(SC_EVENT_TIME_LIMIT_REACHED);
-}
-
 // Generate a scrcpy id to differentiate multiple running scrcpy instances
 static uint32_t
 scrcpy_generate_scid() {
@@ -334,8 +316,6 @@ scrcpy(struct scrcpy_options *options) {
     bool controller_initialized = false;
     bool controller_started = false;
     bool screen_initialized = false;
-    bool timeout_initialized = false;
-    bool timeout_started = false;
 
     struct sc_acksync *acksync = NULL;
 
@@ -349,7 +329,6 @@ scrcpy(struct scrcpy_options *options) {
         .log_level = options->log_level,
         .video_codec = options->video_codec,
         .audio_codec = options->audio_codec,
-        .audio_source = options->audio_source,
         .crop = options->crop,
         .port_range = options->port_range,
         .tunnel_host = options->tunnel_host,
@@ -361,7 +340,6 @@ scrcpy(struct scrcpy_options *options) {
         .lock_video_orientation = options->lock_video_orientation,
         .control = options->control,
         .display_id = options->display_id,
-        .video = options->video,
         .audio = options->audio,
         .show_touches = options->show_touches,
         .stay_awake = options->stay_awake,
@@ -379,7 +357,6 @@ scrcpy(struct scrcpy_options *options) {
         .power_on = options->power_on,
         .list_encoders = options->list_encoders,
         .list_displays = options->list_displays,
-        .kill_adb_on_close = options->kill_adb_on_close,
     };
 
     static const struct sc_server_callbacks cbs = {
@@ -403,26 +380,24 @@ scrcpy(struct scrcpy_options *options) {
         goto end;
     }
 
-    // playback implies capture
+    if (options->display) {
-    assert(!options->video_playback || options->video);
-    assert(!options->audio_playback || options->audio);
-
-    if (options->video_playback) {
         sdl_set_hints(options->render_driver);
+    }
+
+    // Initialize SDL video in addition if display is enabled
+    if (options->display) {
         if (SDL_Init(SDL_INIT_VIDEO)) {
             LOGE("Could not initialize SDL video: %s", SDL_GetError());
             goto end;
         }
-    }
 
-    if (options->audio_playback) {
+        if (options->audio && SDL_Init(SDL_INIT_AUDIO)) {
-        if (SDL_Init(SDL_INIT_AUDIO)) {
             LOGE("Could not initialize SDL audio: %s", SDL_GetError());
             goto end;
         }
     }
 
-    sdl_configure(options->video_playback, options->disable_screensaver);
+    sdl_configure(options->display, options->disable_screensaver);
 
     // Await for server without blocking Ctrl+C handling
     bool connected;
@@ -448,9 +423,7 @@ scrcpy(struct scrcpy_options *options) {
 
     struct sc_file_pusher *fp = NULL;
 
-    // control implies video playback
+    if (options->display && options->control) {
-    assert(!options->control || options->video_playback);
-    if (options->control) {
         if (!sc_file_pusher_init(&s->file_pusher, serial,
                                  options->push_target)) {
             goto end;
@@ -459,36 +432,32 @@ scrcpy(struct scrcpy_options *options) {
         file_pusher_initialized = true;
     }
 
-    if (options->video) {
+    static const struct sc_demuxer_callbacks video_demuxer_cbs = {
-        static const struct sc_demuxer_callbacks video_demuxer_cbs = {
+        .on_ended = sc_video_demuxer_on_ended,
-            .on_ended = sc_video_demuxer_on_ended,
+    };
-        };
+    sc_demuxer_init(&s->video_demuxer, "video", s->server.video_socket,
-        sc_demuxer_init(&s->video_demuxer, "video", s->server.video_socket,
+                    &video_demuxer_cbs, NULL);
-                        &video_demuxer_cbs, NULL);
-    }
 
     if (options->audio) {
         static const struct sc_demuxer_callbacks audio_demuxer_cbs = {
             .on_ended = sc_audio_demuxer_on_ended,
         };
         sc_demuxer_init(&s->audio_demuxer, "audio", s->server.audio_socket,
-                        &audio_demuxer_cbs, options);
+                        &audio_demuxer_cbs, NULL);
     }
 
-    bool needs_video_decoder = options->video_playback;
+    bool needs_video_decoder = options->display;
-    bool needs_audio_decoder = options->audio_playback;
+    bool needs_audio_decoder = options->audio && options->display;
 #ifdef HAVE_V4L2
     needs_video_decoder |= !!options->v4l2_device;
 #endif
     if (needs_video_decoder) {
         sc_decoder_init(&s->video_decoder, "video");
-        sc_packet_source_add_sink(&s->video_demuxer.packet_source,
+        sc_demuxer_add_sink(&s->video_demuxer, &s->video_decoder.packet_sink);
-                                  &s->video_decoder.packet_sink);
     }
     if (needs_audio_decoder) {
         sc_decoder_init(&s->audio_decoder, "audio");
-        sc_packet_source_add_sink(&s->audio_demuxer.packet_source,
+        sc_demuxer_add_sink(&s->audio_demuxer, &s->audio_decoder.packet_sink);
-                                  &s->audio_decoder.packet_sink);
     }
 
     if (options->record_filename) {
@@ -496,8 +465,8 @@ scrcpy(struct scrcpy_options *options) {
             .on_ended = sc_recorder_on_ended,
         };
         if (!sc_recorder_init(&s->recorder, options->record_filename,
-                              options->record_format, options->video,
+                              options->record_format, options->audio,
-                              options->audio, &recorder_cbs, NULL)) {
+                              info->frame_size, &recorder_cbs, NULL)) {
             goto end;
         }
         recorder_initialized = true;
@@ -507,13 +476,10 @@ scrcpy(struct scrcpy_options *options) {
         }
         recorder_started = true;
 
-        if (options->video) {
+        sc_demuxer_add_sink(&s->video_demuxer, &s->recorder.video_packet_sink);
-            sc_packet_source_add_sink(&s->video_demuxer.packet_source,
-                                      &s->recorder.video_packet_sink);
-        }
         if (options->audio) {
-            sc_packet_source_add_sink(&s->audio_demuxer.packet_source,
+            sc_demuxer_add_sink(&s->audio_demuxer,
-                                      &s->recorder.audio_packet_sink);
+                                &s->recorder.audio_packet_sink);
         }
     }
 
@@ -656,12 +622,23 @@ aoa_hid_end:
         }
         controller_started = true;
         controller = &s->controller;
+
+        if (options->turn_screen_off) {
+            struct sc_control_msg msg;
+            msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
+            msg.set_screen_power_mode.mode = SC_SCREEN_POWER_MODE_OFF;
+
+            if (!sc_controller_push_msg(&s->controller, &msg)) {
+                LOGW("Could not request 'set screen power mode'");
+            }
+        }
+
     }
 
     // There is a controller if and only if control is enabled
     assert(options->control == !!controller);
 
-    if (options->video_playback) {
+    if (options->display) {
         const char *window_title =
             options->window_title ? options->window_title : info->device_name;
 
@@ -675,6 +652,7 @@ aoa_hid_end:
             .clipboard_autosync = options->clipboard_autosync,
             .shortcut_mods = &options->shortcut_mods,
             .window_title = window_title,
+            .frame_size = info->frame_size,
             .always_on_top = options->always_on_top,
             .window_x = options->window_x,
             .window_y = options->window_y,
@@ -685,59 +663,41 @@ aoa_hid_end:
             .mipmaps = options->mipmaps,
             .fullscreen = options->fullscreen,
             .start_fps_counter = options->start_fps_counter,
+            .buffering_time = options->display_buffer,
         };
 
-        struct sc_frame_source *src = &s->video_decoder.frame_source;
-        if (options->display_buffer) {
-            sc_delay_buffer_init(&s->display_buffer, options->display_buffer,
-                                 true);
-            sc_frame_source_add_sink(src, &s->display_buffer.frame_sink);
-            src = &s->display_buffer.frame_source;
-        }
-
         if (!sc_screen_init(&s->screen, &screen_params)) {
             goto end;
         }
         screen_initialized = true;
 
-        sc_frame_source_add_sink(src, &s->screen.frame_sink);
+        sc_decoder_add_sink(&s->video_decoder, &s->screen.frame_sink);
-    }
 
-    if (options->audio_playback) {
+        if (options->audio) {
-        sc_audio_player_init(&s->audio_player, options->audio_buffer,
+            sc_audio_player_init(&s->audio_player);
-                             options->audio_output_buffer);
+            sc_decoder_add_sink(&s->audio_decoder, &s->audio_player.frame_sink);
-        sc_frame_source_add_sink(&s->audio_decoder.frame_source,
+        }
-                                 &s->audio_player.frame_sink);
     }
 
 #ifdef HAVE_V4L2
     if (options->v4l2_device) {
-        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device)) {
+        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device,
+                               info->frame_size, options->v4l2_buffer)) {
             goto end;
         }
 
-        struct sc_frame_source *src = &s->video_decoder.frame_source;
+        sc_decoder_add_sink(&s->video_decoder, &s->v4l2_sink.frame_sink);
-        if (options->v4l2_buffer) {
-            sc_delay_buffer_init(&s->v4l2_buffer, options->v4l2_buffer, true);
-            sc_frame_source_add_sink(src, &s->v4l2_buffer.frame_sink);
-            src = &s->v4l2_buffer.frame_source;
-        }
-
-        sc_frame_source_add_sink(src, &s->v4l2_sink.frame_sink);
 
         v4l2_sink_initialized = true;
     }
 #endif
 
-    // Now that the header values have been consumed, the socket(s) will
+    // now we consumed the header values, the socket receives the video stream
-    // receive the stream(s). Start the demuxer(s).
+    // start the video demuxer
-
+    if (!sc_demuxer_start(&s->video_demuxer)) {
-    if (options->video) {
+        goto end;
-        if (!sc_demuxer_start(&s->video_demuxer)) {
-            goto end;
-        }
-        video_demuxer_started = true;
     }
+    video_demuxer_started = true;
 
     if (options->audio) {
         if (!sc_demuxer_start(&s->audio_demuxer)) {
@@ -746,39 +706,6 @@ aoa_hid_end:
         audio_demuxer_started = true;
     }
 
-    // If the device screen is to be turned off, send the control message after
-    // everything is set up
-    if (options->control && options->turn_screen_off) {
-        struct sc_control_msg msg;
-        msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
-        msg.set_screen_power_mode.mode = SC_SCREEN_POWER_MODE_OFF;
-
-        if (!sc_controller_push_msg(&s->controller, &msg)) {
-            LOGW("Could not request 'set screen power mode'");
-        }
-    }
-
-    if (options->time_limit) {
-        bool ok = sc_timeout_init(&s->timeout);
-        if (!ok) {
-            goto end;
-        }
-
-        timeout_initialized = true;
-
-        sc_tick deadline = sc_tick_now() + options->time_limit;
-        static const struct sc_timeout_callbacks cbs = {
-            .on_timeout = sc_timeout_on_timeout,
-        };
-
-        ok = sc_timeout_start(&s->timeout, deadline, &cbs, NULL);
-        if (!ok) {
-            goto end;
-        }
-
-        timeout_started = true;
-    }
-
     ret = event_loop(s);
     LOGD("quit...");
 
@@ -787,10 +714,6 @@ aoa_hid_end:
     sc_screen_hide_window(&s->screen);
 
 end:
-    if (timeout_started) {
-        sc_timeout_stop(&s->timeout);
-    }
-
     // The demuxer is not stopped explicitly, because it will stop by itself on
     // end-of-stream
 #ifdef HAVE_USB
@@ -826,13 +749,6 @@ end:
         sc_server_stop(&s->server);
     }
 
-    if (timeout_started) {
-        sc_timeout_join(&s->timeout);
-    }
-    if (timeout_initialized) {
-        sc_timeout_destroy(&s->timeout);
-    }
-
     // now that the sockets are shutdown, the demuxer and controller are
     // interrupted, we can join them
     if (video_demuxer_started) {

app/src/screen.c

@@ -7,6 +7,7 @@
 #include "events.h"
 #include "icon.h"
 #include "options.h"
+#include "video_buffer.h"
 #include "util/log.h"
 
 #define DISPLAY_MARGINS 96
@@ -56,7 +57,6 @@ static void
 set_window_size(struct sc_screen *screen, struct sc_size new_size) {
     assert(!screen->fullscreen);
     assert(!screen->maximized);
-    assert(!screen->minimized);
     SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
 }
 
@@ -240,6 +240,33 @@ sc_screen_update_content_rect(struct sc_screen *screen) {
     }
 }
 
+static inline SDL_Texture *
+create_texture(struct sc_screen *screen) {
+    SDL_Renderer *renderer = screen->renderer;
+    struct sc_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, -1.f);
+
+        SDL_GL_UnbindTexture(texture);
+    }
+
+    return texture;
+}
+
 // render the texture to the renderer
 //
 // Set the update_content_rect flag if the window or content size may have
@@ -250,11 +277,35 @@ sc_screen_render(struct sc_screen *screen, bool update_content_rect) {
         sc_screen_update_content_rect(screen);
     }
 
-    enum sc_display_result res =
+    SDL_RenderClear(screen->renderer);
-        sc_display_render(&screen->display, &screen->rect, screen->rotation);
+    if (screen->rotation == 0) {
-    (void) res; // any error already logged
+        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
+    } 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) {
+            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
+            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
+            rect.w = screen->rect.h;
+            rect.h = screen->rect.w;
+            dstrect = ▭
+        } else {
+            assert(screen->rotation == 2);
+            dstrect = &screen->rect;
+        }
+
+        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
+                         angle, NULL, 0);
+    }
+    SDL_RenderPresent(screen->renderer);
 }
 
+
 #if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif
@@ -285,25 +336,7 @@ sc_screen_frame_sink_open(struct sc_frame_sink *sink,
     (void) ctx;
 
     struct sc_screen *screen = DOWNCAST(sink);
-
+    (void) screen;
-    assert(ctx->width > 0 && ctx->width <= 0xFFFF);
-    assert(ctx->height > 0 && ctx->height <= 0xFFFF);
-    // screen->frame_size is never used before the event is pushed, and the
-    // event acts as a memory barrier so it is safe without mutex
-    screen->frame_size.width = ctx->width;
-    screen->frame_size.height = ctx->height;
-
-    static SDL_Event event = {
-        .type = SC_EVENT_SCREEN_INIT_SIZE,
-    };
-
-    // Post the event on the UI thread (the texture must be created from there)
-    int ret = SDL_PushEvent(&event);
-    if (ret < 0) {
-        LOGW("Could not post init size event: %s", SDL_GetError());
-        return false;
-    }
-
 #ifndef NDEBUG
     screen->open = true;
 #endif
@@ -326,18 +359,30 @@ sc_screen_frame_sink_close(struct sc_frame_sink *sink) {
 static bool
 sc_screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
     struct sc_screen *screen = DOWNCAST(sink);
+    return sc_video_buffer_push(&screen->vb, frame);
+}
 
-    bool previous_skipped;
+static void
-    bool ok = sc_frame_buffer_push(&screen->fb, frame, &previous_skipped);
+sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
-    if (!ok) {
+                             void *userdata) {
-        return false;
+    (void) vb;
-    }
+    struct sc_screen *screen = userdata;
 
+    // event_failed implies previous_skipped (the previous frame may not have
+    // been consumed if the event was not sent)
+    assert(!screen->event_failed || previous_skipped);
+
+    bool need_new_event;
     if (previous_skipped) {
         sc_fps_counter_add_skipped_frame(&screen->fps_counter);
         // The SC_EVENT_NEW_FRAME triggered for the previous frame will consume
-        // this new frame instead
+        // this new frame instead, unless the previous event failed
+        need_new_event = screen->event_failed;
     } else {
+        need_new_event = true;
+    }
+
+    if (need_new_event) {
         static SDL_Event new_frame_event = {
             .type = SC_EVENT_NEW_FRAME,
         };
@@ -346,11 +391,11 @@ sc_screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
         int ret = SDL_PushEvent(&new_frame_event);
         if (ret < 0) {
             LOGW("Could not post new frame event: %s", SDL_GetError());
-            return false;
+            screen->event_failed = true;
+        } else {
+            screen->event_failed = false;
         }
     }
-
-    return true;
 }
 
 bool
@@ -360,7 +405,7 @@ sc_screen_init(struct sc_screen *screen,
     screen->has_frame = false;
     screen->fullscreen = false;
     screen->maximized = false;
-    screen->minimized = false;
+    screen->event_failed = false;
     screen->mouse_capture_key_pressed = 0;
 
     screen->req.x = params->window_x;
@@ -370,19 +415,33 @@ sc_screen_init(struct sc_screen *screen,
     screen->req.fullscreen = params->fullscreen;
     screen->req.start_fps_counter = params->start_fps_counter;
 
-    bool ok = sc_frame_buffer_init(&screen->fb);
+    static const struct sc_video_buffer_callbacks cbs = {
+        .on_new_frame = sc_video_buffer_on_new_frame,
+    };
+
+    bool ok = sc_video_buffer_init(&screen->vb, params->buffering_time, &cbs,
+                                   screen);
     if (!ok) {
         return false;
     }
 
-    if (!sc_fps_counter_init(&screen->fps_counter)) {
+    ok = sc_video_buffer_start(&screen->vb);
-        goto error_destroy_frame_buffer;
+    if (!ok) {
+        goto error_destroy_video_buffer;
     }
 
+    if (!sc_fps_counter_init(&screen->fps_counter)) {
+        goto error_stop_and_join_video_buffer;
+    }
+
+    screen->frame_size = params->frame_size;
     screen->rotation = params->rotation;
     if (screen->rotation) {
         LOGI("Initial display rotation set to %u", screen->rotation);
     }
+    struct sc_size content_size =
+        get_rotated_size(screen->frame_size, screen->rotation);
+    screen->content_size = content_size;
 
     uint32_t window_flags = SDL_WINDOW_HIDDEN
                           | SDL_WINDOW_RESIZABLE
@@ -402,11 +461,46 @@ sc_screen_init(struct sc_screen *screen,
         goto error_destroy_fps_counter;
     }
 
-    ok = sc_display_init(&screen->display, screen->window, params->mipmaps);
+    screen->renderer = SDL_CreateRenderer(screen->window, -1,
-    if (!ok) {
+                                          SDL_RENDERER_ACCELERATED);
+    if (!screen->renderer) {
+        LOGE("Could not create renderer: %s", SDL_GetError());
         goto error_destroy_window;
     }
 
+    SDL_RendererInfo renderer_info;
+    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)");
+
+    screen->mipmaps = false;
+
+    // starts with "opengl"
+    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
+    if (use_opengl) {
+        struct sc_opengl *gl = &screen->gl;
+        sc_opengl_init(gl);
+
+        LOGI("OpenGL version: %s", gl->version);
+
+        if (params->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 if (params->mipmaps) {
+        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
+    }
+
     SDL_Surface *icon = scrcpy_icon_load();
     if (icon) {
         SDL_SetWindowIcon(screen->window, icon);
@@ -415,10 +509,18 @@ sc_screen_init(struct sc_screen *screen,
         LOGW("Could not load icon");
     }
 
+    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, params->frame_size.width,
+                                                  params->frame_size.height);
+    screen->texture = create_texture(screen);
+    if (!screen->texture) {
+        LOGE("Could not create texture: %s", SDL_GetError());
+        goto error_destroy_renderer;
+    }
+
     screen->frame = av_frame_alloc();
     if (!screen->frame) {
         LOG_OOM();
-        goto error_destroy_display;
+        goto error_destroy_texture;
     }
 
     struct sc_input_manager_params im_params = {
@@ -453,14 +555,19 @@ sc_screen_init(struct sc_screen *screen,
 
     return true;
 
-error_destroy_display:
+error_destroy_texture:
-    sc_display_destroy(&screen->display);
+    SDL_DestroyTexture(screen->texture);
+error_destroy_renderer:
+    SDL_DestroyRenderer(screen->renderer);
 error_destroy_window:
     SDL_DestroyWindow(screen->window);
 error_destroy_fps_counter:
     sc_fps_counter_destroy(&screen->fps_counter);
-error_destroy_frame_buffer:
+error_stop_and_join_video_buffer:
-    sc_frame_buffer_destroy(&screen->fb);
+    sc_video_buffer_stop(&screen->vb);
+    sc_video_buffer_join(&screen->vb);
+error_destroy_video_buffer:
+    sc_video_buffer_destroy(&screen->vb);
 
     return false;
 }
@@ -497,11 +604,13 @@ sc_screen_hide_window(struct sc_screen *screen) {
 
 void
 sc_screen_interrupt(struct sc_screen *screen) {
+    sc_video_buffer_stop(&screen->vb);
     sc_fps_counter_interrupt(&screen->fps_counter);
 }
 
 void
 sc_screen_join(struct sc_screen *screen) {
+    sc_video_buffer_join(&screen->vb);
     sc_fps_counter_join(&screen->fps_counter);
 }
 
@@ -510,11 +619,12 @@ sc_screen_destroy(struct sc_screen *screen) {
 #ifndef NDEBUG
     assert(!screen->open);
 #endif
-    sc_display_destroy(&screen->display);
     av_frame_free(&screen->frame);
+    SDL_DestroyTexture(screen->texture);
+    SDL_DestroyRenderer(screen->renderer);
     SDL_DestroyWindow(screen->window);
     sc_fps_counter_destroy(&screen->fps_counter);
-    sc_frame_buffer_destroy(&screen->fb);
+    sc_video_buffer_destroy(&screen->vb);
 }
 
 static void
@@ -533,11 +643,11 @@ resize_for_content(struct sc_screen *screen, struct sc_size old_content_size,
 
 static void
 set_content_size(struct sc_screen *screen, struct sc_size new_content_size) {
-    if (!screen->fullscreen && !screen->maximized && !screen->minimized) {
+    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/maximized/minimized are disabled
+        // fullscreen and maximized are disabled
         screen->windowed_content_size = screen->content_size;
         screen->resize_pending = true;
     }
@@ -549,7 +659,6 @@ static void
 apply_pending_resize(struct sc_screen *screen) {
     assert(!screen->fullscreen);
     assert(!screen->maximized);
-    assert(!screen->minimized);
     if (screen->resize_pending) {
         resize_for_content(screen, screen->windowed_content_size,
                                    screen->content_size);
@@ -575,68 +684,62 @@ sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation) {
     sc_screen_render(screen, true);
 }
 
-static bool
-sc_screen_init_size(struct sc_screen *screen) {
-    // Before first frame
-    assert(!screen->has_frame);
-
-    // The requested size is passed via screen->frame_size
-
-    struct sc_size content_size =
-        get_rotated_size(screen->frame_size, screen->rotation);
-    screen->content_size = content_size;
-
-    enum sc_display_result res =
-        sc_display_set_texture_size(&screen->display, screen->frame_size);
-    return res != SC_DISPLAY_RESULT_ERROR;
-}
-
 // recreate the texture and resize the window if the frame size has changed
-static enum sc_display_result
+static bool
 prepare_for_frame(struct sc_screen *screen, struct sc_size new_frame_size) {
-    if (screen->frame_size.width == new_frame_size.width
+    if (screen->frame_size.width != new_frame_size.width
-            && screen->frame_size.height == new_frame_size.height) {
+            || screen->frame_size.height != new_frame_size.height) {
-        return SC_DISPLAY_RESULT_OK;
+        // frame dimension changed, destroy texture
+        SDL_DestroyTexture(screen->texture);
+
+        screen->frame_size = new_frame_size;
+
+        struct sc_size new_content_size =
+            get_rotated_size(new_frame_size, screen->rotation);
+        set_content_size(screen, new_content_size);
+
+        sc_screen_update_content_rect(screen);
+
+        LOGI("New texture: %" PRIu16 "x%" PRIu16,
+                     screen->frame_size.width, screen->frame_size.height);
+        screen->texture = create_texture(screen);
+        if (!screen->texture) {
+            LOGE("Could not create texture: %s", SDL_GetError());
+            return false;
+        }
     }
 
-    // frame dimension changed
+    return true;
-    screen->frame_size = new_frame_size;
+}
 
-    struct sc_size new_content_size =
+// write the frame into the texture
-        get_rotated_size(new_frame_size, screen->rotation);
+static void
-    set_content_size(screen, new_content_size);
+update_texture(struct sc_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]);
 
-    sc_screen_update_content_rect(screen);
+    if (screen->mipmaps) {
-
+        SDL_GL_BindTexture(screen->texture, NULL, NULL);
-    return sc_display_set_texture_size(&screen->display, screen->frame_size);
+        screen->gl.GenerateMipmap(GL_TEXTURE_2D);
+        SDL_GL_UnbindTexture(screen->texture);
+    }
 }
 
 static bool
 sc_screen_update_frame(struct sc_screen *screen) {
     av_frame_unref(screen->frame);
-    sc_frame_buffer_consume(&screen->fb, screen->frame);
+    sc_video_buffer_consume(&screen->vb, screen->frame);
     AVFrame *frame = screen->frame;
 
     sc_fps_counter_add_rendered_frame(&screen->fps_counter);
 
     struct sc_size new_frame_size = {frame->width, frame->height};
-    enum sc_display_result res = prepare_for_frame(screen, new_frame_size);
+    if (!prepare_for_frame(screen, new_frame_size)) {
-    if (res == SC_DISPLAY_RESULT_ERROR) {
         return false;
     }
-    if (res == SC_DISPLAY_RESULT_PENDING) {
+    update_texture(screen, frame);
-        // Not an error, but do not continue
-        return true;
-    }
-
-    res = sc_display_update_texture(&screen->display, frame);
-    if (res == SC_DISPLAY_RESULT_ERROR) {
-        return false;
-    }
-    if (res == SC_DISPLAY_RESULT_PENDING) {
-        // Not an error, but do not continue
-        return true;
-    }
 
     if (!screen->has_frame) {
         screen->has_frame = true;
@@ -662,7 +765,7 @@ sc_screen_switch_fullscreen(struct sc_screen *screen) {
     }
 
     screen->fullscreen = !screen->fullscreen;
-    if (!screen->fullscreen && !screen->maximized && !screen->minimized) {
+    if (!screen->fullscreen && !screen->maximized) {
         apply_pending_resize(screen);
     }
 
@@ -672,7 +775,7 @@ sc_screen_switch_fullscreen(struct sc_screen *screen) {
 
 void
 sc_screen_resize_to_fit(struct sc_screen *screen) {
-    if (screen->fullscreen || screen->maximized || screen->minimized) {
+    if (screen->fullscreen || screen->maximized) {
         return;
     }
 
@@ -696,7 +799,7 @@ sc_screen_resize_to_fit(struct sc_screen *screen) {
 
 void
 sc_screen_resize_to_pixel_perfect(struct sc_screen *screen) {
-    if (screen->fullscreen || screen->minimized) {
+    if (screen->fullscreen) {
         return;
     }
 
@@ -716,32 +819,22 @@ sc_screen_is_mouse_capture_key(SDL_Keycode key) {
     return key == SDLK_LALT || key == SDLK_LGUI || key == SDLK_RGUI;
 }
 
-bool
+void
-sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
+sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event) {
     bool relative_mode = sc_screen_is_relative_mode(screen);
 
     switch (event->type) {
-        case SC_EVENT_SCREEN_INIT_SIZE: {
-            // The initial size is passed via screen->frame_size
-            bool ok = sc_screen_init_size(screen);
-            if (!ok) {
-                LOGE("Could not initialize screen size");
-                return false;
-            }
-            return true;
-        }
         case SC_EVENT_NEW_FRAME: {
             bool ok = sc_screen_update_frame(screen);
             if (!ok) {
-                LOGE("Frame update failed\n");
+                LOGW("Frame update failed\n");
-                return false;
             }
-            return true;
+            return;
         }
         case SDL_WINDOWEVENT:
             if (!screen->has_frame) {
                 // Do nothing
-                return true;
+                return;
             }
             switch (event->window.event) {
                 case SDL_WINDOWEVENT_EXPOSED:
@@ -753,9 +846,6 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
                 case SDL_WINDOWEVENT_MAXIMIZED:
                     screen->maximized = true;
                     break;
-                case SDL_WINDOWEVENT_MINIMIZED:
-                    screen->minimized = true;
-                    break;
                 case SDL_WINDOWEVENT_RESTORED:
                     if (screen->fullscreen) {
                         // On Windows, in maximized+fullscreen, disabling
@@ -766,7 +856,6 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
                         break;
                     }
                     screen->maximized = false;
-                    screen->minimized = false;
                     apply_pending_resize(screen);
                     sc_screen_render(screen, true);
                     break;
@@ -776,7 +865,7 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
                     }
                     break;
             }
-            return true;
+            return;
         case SDL_KEYDOWN:
             if (relative_mode) {
                 SDL_Keycode key = event->key.keysym.sym;
@@ -789,7 +878,7 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
                         screen->mouse_capture_key_pressed = 0;
                     }
                     // Mouse capture keys are never forwarded to the device
-                    return true;
+                    return;
                 }
             }
             break;
@@ -805,7 +894,7 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
                         sc_screen_toggle_mouse_capture(screen);
                     }
                     // Mouse capture keys are never forwarded to the device
-                    return true;
+                    return;
                 }
             }
             break;
@@ -815,7 +904,7 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
             if (relative_mode && !sc_screen_get_mouse_capture(screen)) {
                 // Do not forward to input manager, the mouse will be captured
                 // on SDL_MOUSEBUTTONUP
-                return true;
+                return;
             }
             break;
         case SDL_FINGERMOTION:
@@ -824,19 +913,18 @@ sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event) {
             if (relative_mode) {
                 // Touch events are not compatible with relative mode
                 // (coordinates are not relative)
-                return true;
+                return;
             }
             break;
         case SDL_MOUSEBUTTONUP:
             if (relative_mode && !sc_screen_get_mouse_capture(screen)) {
                 sc_screen_set_mouse_capture(screen, true);
-                return true;
+                return;
             }
             break;
     }
 
     sc_input_manager_handle_event(&screen->im, event);
-    return true;
 }
 
 struct sc_point

app/src/screen.h

@@ -9,14 +9,13 @@
 
 #include "controller.h"
 #include "coords.h"
-#include "display.h"
 #include "fps_counter.h"
-#include "frame_buffer.h"
 #include "input_manager.h"
 #include "opengl.h"
 #include "trait/key_processor.h"
 #include "trait/frame_sink.h"
 #include "trait/mouse_processor.h"
+#include "video_buffer.h"
 
 struct sc_screen {
     struct sc_frame_sink frame_sink; // frame sink trait
@@ -25,9 +24,8 @@ struct sc_screen {
     bool open; // track the open/close state to assert correct behavior
 #endif
 
-    struct sc_display display;
     struct sc_input_manager im;
-    struct sc_frame_buffer fb;
+    struct sc_video_buffer vb;
     struct sc_fps_counter fps_counter;
 
     // The initial requested window properties
@@ -41,6 +39,9 @@ struct sc_screen {
     } req;
 
     SDL_Window *window;
+    SDL_Renderer *renderer;
+    SDL_Texture *texture;
+    struct sc_opengl gl;
     struct sc_size frame_size;
     struct sc_size content_size; // rotated frame_size
 
@@ -56,7 +57,9 @@ struct sc_screen {
     bool has_frame;
     bool fullscreen;
     bool maximized;
-    bool minimized;
+    bool mipmaps;
+
+    bool event_failed; // in case SDL_PushEvent() returned an error
 
     // To enable/disable mouse capture, a mouse capture key (LALT, LGUI or
     // RGUI) must be pressed. This variable tracks the pressed capture key.
@@ -77,6 +80,7 @@ struct sc_screen_params {
     const struct sc_shortcut_mods *shortcut_mods;
 
     const char *window_title;
+    struct sc_size frame_size;
     bool always_on_top;
 
     int16_t window_x; // accepts SC_WINDOW_POSITION_UNDEFINED
@@ -91,6 +95,8 @@ struct sc_screen_params {
 
     bool fullscreen;
     bool start_fps_counter;
+
+    sc_tick buffering_time;
 };
 
 // initialize screen, create window, renderer and texture (window is hidden)
@@ -134,9 +140,8 @@ void
 sc_screen_set_rotation(struct sc_screen *screen, unsigned rotation);
 
 // react to SDL events
-// If this function returns false, scrcpy must exit with an error.
+void
-bool
+sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event);
-sc_screen_handle_event(struct sc_screen *screen, const SDL_Event *event);
 
 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels

app/src/server.c

@@ -173,8 +173,6 @@ sc_server_get_codec_name(enum sc_codec codec) {
             return "opus";
         case SC_CODEC_AAC:
             return "aac";
-        case SC_CODEC_RAW:
-            return "raw";
         default:
             return NULL;
     }
@@ -216,7 +214,7 @@ execute_server(struct sc_server *server,
 
     unsigned dyn_idx = count; // from there, the strings are allocated
 #define ADD_PARAM(fmt, ...) { \
-        char *p; \
+        char *p = (char *) &cmd[count]; \
         if (asprintf(&p, fmt, ## __VA_ARGS__) == -1) { \
             goto end; \
         } \
@@ -226,16 +224,12 @@ execute_server(struct sc_server *server,
     ADD_PARAM("scid=%08x", params->scid);
     ADD_PARAM("log_level=%s", log_level_to_server_string(params->log_level));
 
-    if (!params->video) {
-        ADD_PARAM("video=false");
-    }
     if (params->video_bit_rate) {
         ADD_PARAM("video_bit_rate=%" PRIu32, params->video_bit_rate);
     }
     if (!params->audio) {
         ADD_PARAM("audio=false");
-    }
+    } else if (params->audio_bit_rate) {
-    if (params->audio_bit_rate) {
         ADD_PARAM("audio_bit_rate=%" PRIu32, params->audio_bit_rate);
     }
     if (params->video_codec != SC_CODEC_H264) {
@@ -246,10 +240,6 @@ execute_server(struct sc_server *server,
         ADD_PARAM("audio_codec=%s",
             sc_server_get_codec_name(params->audio_codec));
     }
-    if (params->audio_source != SC_AUDIO_SOURCE_OUTPUT) {
-        assert(params->audio_source == SC_AUDIO_SOURCE_MIC);
-        ADD_PARAM("audio_source=mic");
-    }
     if (params->max_size) {
         ADD_PARAM("max_size=%" PRIu16, params->max_size);
     }
@@ -449,9 +439,9 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
 static bool
 device_read_info(struct sc_intr *intr, sc_socket device_socket,
                  struct sc_server_info *info) {
-    unsigned char buf[SC_DEVICE_NAME_FIELD_LENGTH];
+    unsigned char buf[SC_DEVICE_NAME_FIELD_LENGTH + 4];
     ssize_t r = net_recv_all_intr(intr, device_socket, buf, sizeof(buf));
-    if (r < SC_DEVICE_NAME_FIELD_LENGTH) {
+    if (r < SC_DEVICE_NAME_FIELD_LENGTH + 4) {
         LOGE("Could not retrieve device information");
         return false;
     }
@@ -459,6 +449,9 @@ device_read_info(struct sc_intr *intr, sc_socket device_socket,
     buf[SC_DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
     memcpy(info->device_name, (char *) buf, sizeof(info->device_name));
 
+    unsigned char *fields = &buf[SC_DEVICE_NAME_FIELD_LENGTH];
+    info->frame_size.width = sc_read16be(fields);
+    info->frame_size.height = sc_read16be(&fields[2]);
     return true;
 }
 
@@ -471,7 +464,6 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
     const char *serial = server->serial;
     assert(serial);
 
-    bool video = server->params.video;
     bool audio = server->params.audio;
     bool control = server->params.control;
 
@@ -479,12 +471,9 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
     sc_socket audio_socket = SC_SOCKET_NONE;
     sc_socket control_socket = SC_SOCKET_NONE;
     if (!tunnel->forward) {
-        if (video) {
+        video_socket = net_accept_intr(&server->intr, tunnel->server_socket);
-            video_socket =
+        if (video_socket == SC_SOCKET_NONE) {
-                net_accept_intr(&server->intr, tunnel->server_socket);
+            goto fail;
-            if (video_socket == SC_SOCKET_NONE) {
-                goto fail;
-            }
         }
 
         if (audio) {
@@ -515,45 +504,35 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
 
         unsigned attempts = 100;
         sc_tick delay = SC_TICK_FROM_MS(100);
-        sc_socket first_socket = connect_to_server(server, attempts, delay,
+        video_socket = connect_to_server(server, attempts, delay, tunnel_host,
-                                                   tunnel_host, tunnel_port);
+                                         tunnel_port);
-        if (first_socket == SC_SOCKET_NONE) {
+        if (video_socket == SC_SOCKET_NONE) {
             goto fail;
         }
 
-        if (video) {
-            video_socket = first_socket;
-        }
-
         if (audio) {
-            if (!video) {
+            audio_socket = net_socket();
-                audio_socket = first_socket;
+            if (audio_socket == SC_SOCKET_NONE) {
-            } else {
+                goto fail;
-                audio_socket = net_socket();
+            }
-                if (audio_socket == SC_SOCKET_NONE) {
+            bool ok = net_connect_intr(&server->intr, audio_socket, tunnel_host,
-                    goto fail;
+                                       tunnel_port);
-                }
+            if (!ok) {
-                bool ok = net_connect_intr(&server->intr, audio_socket, tunnel_host,
+                goto fail;
-                                           tunnel_port);
-                if (!ok) {
-                    goto fail;
-                }
             }
         }
 
         if (control) {
-            if (!video && !audio) {
+            // we know that the device is listening, we don't need several
-                control_socket = first_socket;
+            // attempts
-            } else {
+            control_socket = net_socket();
-                control_socket = net_socket();
+            if (control_socket == SC_SOCKET_NONE) {
-                if (control_socket == SC_SOCKET_NONE) {
+                goto fail;
-                    goto fail;
+            }
-                }
+            bool ok = net_connect_intr(&server->intr, control_socket,
-                bool ok = net_connect_intr(&server->intr, control_socket,
+                                       tunnel_host, tunnel_port);
-                                           tunnel_host, tunnel_port);
+            if (!ok) {
-                if (!ok) {
+                goto fail;
-                    goto fail;
-                }
             }
         }
     }
@@ -562,17 +541,13 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
     sc_adb_tunnel_close(tunnel, &server->intr, serial,
                         server->device_socket_name);
 
-    sc_socket first_socket = video ? video_socket
-                           : audio ? audio_socket
-                                   : control_socket;
-
     // The sockets will be closed on stop if device_read_info() fails
-    bool ok = device_read_info(&server->intr, first_socket, info);
+    bool ok = device_read_info(&server->intr, video_socket, info);
     if (!ok) {
         goto fail;
     }
 
-    assert(!video || video_socket != SC_SOCKET_NONE);
+    assert(video_socket != SC_SOCKET_NONE);
     assert(!audio || audio_socket != SC_SOCKET_NONE);
     assert(!control || control_socket != SC_SOCKET_NONE);
 
@@ -794,15 +769,6 @@ sc_server_configure_tcpip_unknown_address(struct sc_server *server,
     return sc_server_connect_to_tcpip(server, ip_port);
 }
 
-static void
-sc_server_kill_adb_if_requested(struct sc_server *server) {
-    if (server->params.kill_adb_on_close) {
-        LOGI("Killing adb server...");
-        unsigned flags = SC_ADB_NO_STDOUT | SC_ADB_NO_STDERR | SC_ADB_NO_LOGERR;
-        sc_adb_kill_server(&server->intr, flags);
-    }
-}
-
 static int
 run_server(void *data) {
     struct sc_server *server = data;
@@ -814,7 +780,7 @@ run_server(void *data) {
     // is parsed, so it is not output)
     bool ok = sc_adb_start_server(&server->intr, 0);
     if (!ok) {
-        LOGE("Could not start adb server");
+        LOGE("Could not start adb daemon");
         goto error_connection_failed;
     }
 
@@ -965,11 +931,8 @@ run_server(void *data) {
     sc_mutex_unlock(&server->mutex);
 
     // Interrupt sockets to wake up socket blocking calls on the server
-
+    assert(server->video_socket != SC_SOCKET_NONE);
-    if (server->video_socket != SC_SOCKET_NONE) {
+    net_interrupt(server->video_socket);
-        // There is no video_socket if --no-video is set
-        net_interrupt(server->video_socket);
-    }
 
     if (server->audio_socket != SC_SOCKET_NONE) {
         // There is no audio_socket if --no-audio is set
@@ -1002,12 +965,9 @@ run_server(void *data) {
 
     sc_process_close(pid);
 
-    sc_server_kill_adb_if_requested(server);
-
     return 0;
 
 error_connection_failed:
-    sc_server_kill_adb_if_requested(server);
     server->cbs->on_connection_failed(server, server->cbs_userdata);
     return -1;
 }

app/src/server.h

@@ -18,6 +18,7 @@
 #define SC_DEVICE_NAME_FIELD_LENGTH 64
 struct sc_server_info {
     char device_name[SC_DEVICE_NAME_FIELD_LENGTH];
+    struct sc_size frame_size;
 };
 
 struct sc_server_params {
@@ -26,7 +27,6 @@ struct sc_server_params {
     enum sc_log_level log_level;
     enum sc_codec video_codec;
     enum sc_codec audio_codec;
-    enum sc_audio_source audio_source;
     const char *crop;
     const char *video_codec_options;
     const char *audio_codec_options;
@@ -42,7 +42,6 @@ struct sc_server_params {
     int8_t lock_video_orientation;
     bool control;
     uint32_t display_id;
-    bool video;
     bool audio;
     bool show_touches;
     bool stay_awake;
@@ -58,7 +57,6 @@ struct sc_server_params {
     bool power_on;
     bool list_encoders;
     bool list_displays;
-    bool kill_adb_on_close;
 };
 
 struct sc_server {

app/src/trait/frame_sink.h

@@ -7,6 +7,8 @@
 #include <stdbool.h>
 #include <libavcodec/avcodec.h>
 
+typedef struct AVFrame AVFrame;
+
 /**
  * Frame sink trait.
  *
@@ -17,7 +19,6 @@ struct sc_frame_sink {
 };
 
 struct sc_frame_sink_ops {
-    /* The codec context is valid until the sink is closed */
     bool (*open)(struct sc_frame_sink *sink, const AVCodecContext *ctx);
     void (*close)(struct sc_frame_sink *sink);
     bool (*push)(struct sc_frame_sink *sink, const AVFrame *frame);

app/src/trait/frame_source.c

@@ -1,59 +0,0 @@
-#include "frame_source.h"
-
-void
-sc_frame_source_init(struct sc_frame_source *source) {
-    source->sink_count = 0;
-}
-
-void
-sc_frame_source_add_sink(struct sc_frame_source *source,
-                         struct sc_frame_sink *sink) {
-    assert(source->sink_count < SC_FRAME_SOURCE_MAX_SINKS);
-    assert(sink);
-    assert(sink->ops);
-    source->sinks[source->sink_count++] = sink;
-}
-
-static void
-sc_frame_source_sinks_close_firsts(struct sc_frame_source *source,
-                                    unsigned count) {
-    while (count) {
-        struct sc_frame_sink *sink = source->sinks[--count];
-        sink->ops->close(sink);
-    }
-}
-
-bool
-sc_frame_source_sinks_open(struct sc_frame_source *source,
-                           const AVCodecContext *ctx) {
-    assert(source->sink_count);
-    for (unsigned i = 0; i < source->sink_count; ++i) {
-        struct sc_frame_sink *sink = source->sinks[i];
-        if (!sink->ops->open(sink, ctx)) {
-            sc_frame_source_sinks_close_firsts(source, i);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-void
-sc_frame_source_sinks_close(struct sc_frame_source *source) {
-    assert(source->sink_count);
-    sc_frame_source_sinks_close_firsts(source, source->sink_count);
-}
-
-bool
-sc_frame_source_sinks_push(struct sc_frame_source *source,
-                            const AVFrame *frame) {
-    assert(source->sink_count);
-    for (unsigned i = 0; i < source->sink_count; ++i) {
-        struct sc_frame_sink *sink = source->sinks[i];
-        if (!sink->ops->push(sink, frame)) {
-            return false;
-        }
-    }
-
-    return true;
-}

app/src/trait/frame_source.h

@@ -1,38 +0,0 @@
-#ifndef SC_FRAME_SOURCE_H
-#define SC_FRAME_SOURCE_H
-
-#include "common.h"
-
-#include "frame_sink.h"
-
-#define SC_FRAME_SOURCE_MAX_SINKS 2
-
-/**
- * Frame source trait
- *
- * Component able to send AVFrames should implement this trait.
- */
-struct sc_frame_source {
-    struct sc_frame_sink *sinks[SC_FRAME_SOURCE_MAX_SINKS];
-    unsigned sink_count;
-};
-
-void
-sc_frame_source_init(struct sc_frame_source *source);
-
-void
-sc_frame_source_add_sink(struct sc_frame_source *source,
-                         struct sc_frame_sink *sink);
-
-bool
-sc_frame_source_sinks_open(struct sc_frame_source *source,
-                           const AVCodecContext *ctx);
-
-void
-sc_frame_source_sinks_close(struct sc_frame_source *source);
-
-bool
-sc_frame_source_sinks_push(struct sc_frame_source *source,
-                           const AVFrame *frame);
-
-#endif

app/src/trait/packet_sink.h

@@ -5,7 +5,9 @@
 
 #include <assert.h>
 #include <stdbool.h>
-#include <libavcodec/avcodec.h>
+
+typedef struct AVCodec AVCodec;
+typedef struct AVPacket AVPacket;
 
 /**
  * Packet sink trait.
@@ -17,8 +19,8 @@ struct sc_packet_sink {
 };
 
 struct sc_packet_sink_ops {
-    /* The codec context is valid until the sink is closed */
+    /* The codec instance is static, it is valid until the end of the program */
-    bool (*open)(struct sc_packet_sink *sink, AVCodecContext *ctx);
+    bool (*open)(struct sc_packet_sink *sink, const AVCodec *codec);
     void (*close)(struct sc_packet_sink *sink);
     bool (*push)(struct sc_packet_sink *sink, const AVPacket *packet);
 

app/src/trait/packet_source.c

@@ -1,70 +0,0 @@
-#include "packet_source.h"
-
-void
-sc_packet_source_init(struct sc_packet_source *source) {
-    source->sink_count = 0;
-}
-
-void
-sc_packet_source_add_sink(struct sc_packet_source *source,
-                          struct sc_packet_sink *sink) {
-    assert(source->sink_count < SC_PACKET_SOURCE_MAX_SINKS);
-    assert(sink);
-    assert(sink->ops);
-    source->sinks[source->sink_count++] = sink;
-}
-
-static void
-sc_packet_source_sinks_close_firsts(struct sc_packet_source *source,
-                                    unsigned count) {
-    while (count) {
-        struct sc_packet_sink *sink = source->sinks[--count];
-        sink->ops->close(sink);
-    }
-}
-
-bool
-sc_packet_source_sinks_open(struct sc_packet_source *source,
-                            AVCodecContext *ctx) {
-    assert(source->sink_count);
-    for (unsigned i = 0; i < source->sink_count; ++i) {
-        struct sc_packet_sink *sink = source->sinks[i];
-        if (!sink->ops->open(sink, ctx)) {
-            sc_packet_source_sinks_close_firsts(source, i);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-void
-sc_packet_source_sinks_close(struct sc_packet_source *source) {
-    assert(source->sink_count);
-    sc_packet_source_sinks_close_firsts(source, source->sink_count);
-}
-
-bool
-sc_packet_source_sinks_push(struct sc_packet_source *source,
-                            const AVPacket *packet) {
-    assert(source->sink_count);
-    for (unsigned i = 0; i < source->sink_count; ++i) {
-        struct sc_packet_sink *sink = source->sinks[i];
-        if (!sink->ops->push(sink, packet)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-void
-sc_packet_source_sinks_disable(struct sc_packet_source *source) {
-    assert(source->sink_count);
-    for (unsigned i = 0; i < source->sink_count; ++i) {
-        struct sc_packet_sink *sink = source->sinks[i];
-        if (sink->ops->disable) {
-            sink->ops->disable(sink);
-        }
-    }
-}

app/src/trait/packet_source.h

@@ -1,41 +0,0 @@
-#ifndef SC_PACKET_SOURCE_H
-#define SC_PACKET_SOURCE_H
-
-#include "common.h"
-
-#include "packet_sink.h"
-
-#define SC_PACKET_SOURCE_MAX_SINKS 2
-
-/**
- * Packet source trait
- *
- * Component able to send AVPackets should implement this trait.
- */
-struct sc_packet_source {
-    struct sc_packet_sink *sinks[SC_PACKET_SOURCE_MAX_SINKS];
-    unsigned sink_count;
-};
-
-void
-sc_packet_source_init(struct sc_packet_source *source);
-
-void
-sc_packet_source_add_sink(struct sc_packet_source *source,
-                          struct sc_packet_sink *sink);
-
-bool
-sc_packet_source_sinks_open(struct sc_packet_source *source,
-                            AVCodecContext *ctx);
-
-void
-sc_packet_source_sinks_close(struct sc_packet_source *source);
-
-bool
-sc_packet_source_sinks_push(struct sc_packet_source *source,
-                            const AVPacket *packet);
-
-void
-sc_packet_source_sinks_disable(struct sc_packet_source *source);
-
-#endif

app/src/usb/aoa_hid.c

@@ -14,8 +14,6 @@
 
 #define DEFAULT_TIMEOUT 1000
 
-#define SC_HID_EVENT_QUEUE_MAX 64
-
 static void
 sc_hid_event_log(const struct sc_hid_event *event) {
     // HID Event: [00] FF FF FF FF...
@@ -50,20 +48,14 @@ sc_hid_event_destroy(struct sc_hid_event *hid_event) {
 bool
 sc_aoa_init(struct sc_aoa *aoa, struct sc_usb *usb,
             struct sc_acksync *acksync) {
-    sc_vecdeque_init(&aoa->queue);
+    cbuf_init(&aoa->queue);
-
-    if (!sc_vecdeque_reserve(&aoa->queue, SC_HID_EVENT_QUEUE_MAX)) {
-        return false;
-    }
 
     if (!sc_mutex_init(&aoa->mutex)) {
-        sc_vecdeque_destroy(&aoa->queue);
         return false;
     }
 
     if (!sc_cond_init(&aoa->event_cond)) {
         sc_mutex_destroy(&aoa->mutex);
-        sc_vecdeque_destroy(&aoa->queue);
         return false;
     }
 
@@ -77,10 +69,9 @@ sc_aoa_init(struct sc_aoa *aoa, struct sc_usb *usb,
 void
 sc_aoa_destroy(struct sc_aoa *aoa) {
     // Destroy remaining events
-    while (!sc_vecdeque_is_empty(&aoa->queue)) {
+    struct sc_hid_event event;
-        struct sc_hid_event *event = sc_vecdeque_popref(&aoa->queue);
+    while (cbuf_take(&aoa->queue, &event)) {
-        assert(event);
+        sc_hid_event_destroy(&event);
-        sc_hid_event_destroy(event);
     }
 
     sc_cond_destroy(&aoa->event_cond);
@@ -221,19 +212,13 @@ sc_aoa_push_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
     }
 
     sc_mutex_lock(&aoa->mutex);
-    bool full = sc_vecdeque_is_full(&aoa->queue);
+    bool was_empty = cbuf_is_empty(&aoa->queue);
-    if (!full) {
+    bool res = cbuf_push(&aoa->queue, *event);
-        bool was_empty = sc_vecdeque_is_empty(&aoa->queue);
+    if (was_empty) {
-        sc_vecdeque_push_noresize(&aoa->queue, *event);
+        sc_cond_signal(&aoa->event_cond);
-        if (was_empty) {
-            sc_cond_signal(&aoa->event_cond);
-        }
     }
-    // Otherwise (if the queue is full), the event is discarded
-
     sc_mutex_unlock(&aoa->mutex);
-
+    return res;
-    return !full;
 }
 
 static int
@@ -242,7 +227,7 @@ run_aoa_thread(void *data) {
 
     for (;;) {
         sc_mutex_lock(&aoa->mutex);
-        while (!aoa->stopped && sc_vecdeque_is_empty(&aoa->queue)) {
+        while (!aoa->stopped && cbuf_is_empty(&aoa->queue)) {
             sc_cond_wait(&aoa->event_cond, &aoa->mutex);
         }
         if (aoa->stopped) {
@@ -250,9 +235,11 @@ run_aoa_thread(void *data) {
             sc_mutex_unlock(&aoa->mutex);
             break;
         }
+        struct sc_hid_event event;
+        bool non_empty = cbuf_take(&aoa->queue, &event);
+        assert(non_empty);
+        (void) non_empty;
 
-        assert(!sc_vecdeque_is_empty(&aoa->queue));
-        struct sc_hid_event event = sc_vecdeque_pop(&aoa->queue);
         uint64_t ack_to_wait = event.ack_to_wait;
         sc_mutex_unlock(&aoa->mutex);
 

app/src/usb/aoa_hid.h

@@ -8,9 +8,9 @@
 
 #include "usb.h"
 #include "util/acksync.h"
+#include "util/cbuf.h"
 #include "util/thread.h"
 #include "util/tick.h"
-#include "util/vecdeque.h"
 
 struct sc_hid_event {
     uint16_t accessory_id;
@@ -27,7 +27,7 @@ sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
 void
 sc_hid_event_destroy(struct sc_hid_event *hid_event);
 
-struct sc_hid_event_queue SC_VECDEQUE(struct sc_hid_event);
+struct sc_hid_event_queue CBUF(struct sc_hid_event, 64);
 
 struct sc_aoa {
     struct sc_usb *usb;

app/src/usb/scrcpy_otg.c

@@ -83,7 +83,7 @@ scrcpy_otg(struct scrcpy_options *options) {
 #ifdef _WIN32
     // On Windows, only one process could open a USB device
     // <https://github.com/Genymobile/scrcpy/issues/2773>
-    LOGI("Killing adb server (if any)...");
+    LOGI("Killing adb daemon (if any)...");
     unsigned flags = SC_ADB_NO_STDOUT | SC_ADB_NO_STDERR | SC_ADB_NO_LOGERR;
     // uninterruptible (intr == NULL), but in practice it's very quick
     sc_adb_kill_server(NULL, flags);

app/src/util/audiobuf.h

@@ -1,94 +0,0 @@
-#ifndef SC_AUDIOBUF_H
-#define SC_AUDIOBUF_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "util/bytebuf.h"
-
-/**
- * Wrapper around bytebuf to read and write samples
- *
- * Each sample takes sample_size bytes.
- */
-struct sc_audiobuf {
-    struct sc_bytebuf buf;
-    size_t sample_size;
-};
-
-static inline uint32_t
-sc_audiobuf_to_samples(struct sc_audiobuf *buf, size_t bytes) {
-    assert(bytes % buf->sample_size == 0);
-    return bytes / buf->sample_size;
-}
-
-static inline size_t
-sc_audiobuf_to_bytes(struct sc_audiobuf *buf, uint32_t samples) {
-    return samples * buf->sample_size;
-}
-
-static inline bool
-sc_audiobuf_init(struct sc_audiobuf *buf, size_t sample_size,
-                 uint32_t capacity) {
-    buf->sample_size = sample_size;
-    return sc_bytebuf_init(&buf->buf, capacity * sample_size + 1);
-}
-
-static inline void
-sc_audiobuf_read(struct sc_audiobuf *buf, uint8_t *to, uint32_t samples) {
-    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
-    sc_bytebuf_read(&buf->buf, to, bytes);
-}
-
-static inline void
-sc_audiobuf_skip(struct sc_audiobuf *buf, uint32_t samples) {
-    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
-    sc_bytebuf_skip(&buf->buf, bytes);
-}
-
-static inline void
-sc_audiobuf_write(struct sc_audiobuf *buf, const uint8_t *from,
-                  uint32_t samples) {
-    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
-    sc_bytebuf_write(&buf->buf, from, bytes);
-}
-
-static inline void
-sc_audiobuf_prepare_write(struct sc_audiobuf *buf, const uint8_t *from,
-                          uint32_t samples) {
-    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
-    sc_bytebuf_prepare_write(&buf->buf, from, bytes);
-}
-
-static inline void
-sc_audiobuf_commit_write(struct sc_audiobuf *buf, uint32_t samples) {
-    size_t bytes = sc_audiobuf_to_bytes(buf, samples);
-    sc_bytebuf_commit_write(&buf->buf, bytes);
-}
-
-static inline uint32_t
-sc_audiobuf_can_read(struct sc_audiobuf *buf) {
-    size_t bytes = sc_bytebuf_can_read(&buf->buf);
-    return sc_audiobuf_to_samples(buf, bytes);
-}
-
-static inline uint32_t
-sc_audiobuf_can_write(struct sc_audiobuf *buf) {
-    size_t bytes = sc_bytebuf_can_write(&buf->buf);
-    return sc_audiobuf_to_samples(buf, bytes);
-}
-
-static inline uint32_t
-sc_audiobuf_capacity(struct sc_audiobuf *buf) {
-    size_t bytes = sc_bytebuf_capacity(&buf->buf);
-    return sc_audiobuf_to_samples(buf, bytes);
-}
-
-static inline void
-sc_audiobuf_destroy(struct sc_audiobuf *buf) {
-    sc_bytebuf_destroy(&buf->buf);
-}
-
-#endif

app/src/util/average.c

@@ -19,8 +19,8 @@ sc_average_push(struct sc_average *avg, float value) {
     avg->avg = ((avg->count - 1) * avg->avg + value) / avg->count;
 }
 
-float
+bool
-sc_average_get(struct sc_average *avg) {
+sc_average_get(struct sc_average *avg, float *value) {
-    assert(avg->count);
+    *value = avg->avg;
-    return avg->avg;
+    return avg->count;
 }

app/src/util/average.h

@@ -22,19 +22,15 @@ struct sc_average {
 void
 sc_average_init(struct sc_average *avg, unsigned range);
 
-/**
+/* Push a new value to update the "rolling" average */
- * Push a new value to update the "rolling" average
- */
 void
 sc_average_push(struct sc_average *avg, float value);
 
-/**
+/* Get the current average value (if available)
- * Get the current average value
  *
- * It is an error to call this function if sc_average_push() has not been
+ * An average is available if sc_average_push() has been called at least once.
- * called at least once.
  */
-float
+bool
-sc_average_get(struct sc_average *avg);
+sc_average_get(struct sc_average *avg, float *value);
 
 #endif

app/src/util/bytebuf.c

@@ -9,6 +9,7 @@
 bool
 sc_bytebuf_init(struct sc_bytebuf *buf, size_t alloc_size) {
     assert(alloc_size);
+    // sufficient, but use more for alignment.
     buf->data = malloc(alloc_size);
     if (!buf->data) {
         LOG_OOM();
@@ -30,7 +31,7 @@ sc_bytebuf_destroy(struct sc_bytebuf *buf) {
 void
 sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len) {
     assert(len);
-    assert(len <= sc_bytebuf_can_read(buf));
+    assert(sc_bytebuf_read_remaining(buf) >= len);
     assert(buf->tail != buf->head); // the buffer could not be empty
 
     size_t right_limit = buf->tail < buf->head ? buf->head : buf->alloc_size;
@@ -50,40 +51,42 @@ sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len) {
 void
 sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len) {
     assert(len);
-    assert(len <= sc_bytebuf_can_read(buf));
+    assert(sc_bytebuf_read_remaining(buf) >= len);
     assert(buf->tail != buf->head); // the buffer could not be empty
 
     buf->tail = (buf->tail + len) % buf->alloc_size;
 }
 
-static inline void
+void
-sc_bytebuf_write_step0(struct sc_bytebuf *buf, const uint8_t *from,
+sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len) {
-                       size_t len) {
+    assert(len);
-    size_t right_len = buf->alloc_size - buf->head;
+
+    size_t max_len = buf->alloc_size - 1;
+    if (len >= max_len) {
+        // Copy only the right-most bytes
+        memcpy(buf->data, from + len - max_len, max_len);
+        buf->tail = 0;
+        buf->head = max_len;
+        return;
+    }
+
+    size_t right_limit = buf->head < buf->tail ? buf->tail : buf->alloc_size;
+    size_t right_len = right_limit - buf->head;
     if (len < right_len) {
         right_len = len;
     }
     memcpy(buf->data + buf->head, from, right_len);
-
     if (len > right_len) {
         memcpy(buf->data, from + right_len, len - right_len);
     }
-}
 
-static inline void
+    size_t empty_space = sc_bytebuf_write_remaining(buf);
-sc_bytebuf_write_step1(struct sc_bytebuf *buf, size_t len) {
+    if (len > empty_space) {
+        buf->tail = (buf->tail + len - empty_space) % buf->alloc_size;
+    }
     buf->head = (buf->head + len) % buf->alloc_size;
 }
 
-void
-sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len) {
-    assert(len);
-    assert(len <= sc_bytebuf_can_write(buf));
-
-    sc_bytebuf_write_step0(buf, from, len);
-    sc_bytebuf_write_step1(buf, len);
-}
-
 void
 sc_bytebuf_prepare_write(struct sc_bytebuf *buf, const uint8_t *from,
                          size_t len) {
@@ -94,11 +97,20 @@ sc_bytebuf_prepare_write(struct sc_bytebuf *buf, const uint8_t *from,
     // be called with lock held).
 
     assert(len < buf->alloc_size - 1);
-    sc_bytebuf_write_step0(buf, from, len);
+
+    size_t right_len = buf->alloc_size - buf->head;
+    if (len < right_len) {
+        right_len = len;
+    }
+
+    memcpy(buf->data + buf->head, from, right_len);
+    if (len > right_len) {
+        memcpy(buf->data, from + right_len, len - right_len);
+    }
 }
 
 void
 sc_bytebuf_commit_write(struct sc_bytebuf *buf, size_t len) {
-    assert(len <= sc_bytebuf_can_write(buf));
+    assert(len <= sc_bytebuf_write_remaining(buf));
-    sc_bytebuf_write_step1(buf, len);
+    buf->head = (buf->head + len) % buf->alloc_size;
 }

app/src/util/bytebuf.h

@@ -11,10 +11,10 @@ struct sc_bytebuf {
     // The actual capacity is (allocated - 1) so that head == tail is
     // non-ambiguous
     size_t alloc_size;
-    size_t head; // writter cursor
+    size_t head;
-    size_t tail; // reader cursor
+    size_t tail;
     // empty: tail == head
-    // full: ((tail + 1) % alloc_size) == head
+    // full: (tail + 1) % allocated == head
 };
 
 bool
@@ -23,10 +23,10 @@ sc_bytebuf_init(struct sc_bytebuf *buf, size_t alloc_size);
 /**
  * Copy from the bytebuf to a user-provided array
  *
- * The caller must check that len <= sc_bytebuf_read_available() (it is an
+ * The caller must check that len <= buf->len (it is an error to attempt to read
- * error to attempt to read more bytes than available).
+ * more bytes than available).
  *
- * This function is guaranteed not to write to buf->head.
+ * This function is guaranteed to not change the head.
  */
 void
 sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len);
@@ -34,13 +34,13 @@ sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len);
 /**
  * Drop len bytes from the buffer
  *
- * The caller must check that len <= sc_bytebuf_read_available() (it is an
+ * The caller must check that len <= buf->len (it is an error to attempt to skip
- * error to attempt to skip more bytes than available).
+ * more bytes than available).
  *
- * This function is guaranteed not to write to buf->head.
+ * This function is guaranteed to not change the head.
  *
  * It is equivalent to call sc_bytebuf_read() to some array and discard the
- * array (but this function is more efficient since there is no copy).
+ * array (but more efficient since there is no copy).
  */
 void
 sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len);
@@ -48,10 +48,9 @@ sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len);
 /**
  * Copy the user-provided array to the bytebuf
  *
- * The caller must check that len <= sc_bytebuf_write_available() (it is an
+ * The length of the input array is not restricted:
- * error to write more bytes than the remaining available space).
+ * if len >= sc_bytebuf_write_remaining(buf), then the excessive input bytes
- *
+ * will overwrite the oldest bytes in the buffer.
- * This function is guaranteed not to write to buf->tail.
  */
 void
 sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len);
@@ -59,16 +58,14 @@ sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len);
 /**
  * Copy the user-provided array to the bytebuf, but do not advance the cursor
  *
- * The caller must check that len <= sc_bytebuf_write_available() (it is an
+ * The caller must check that len <= buf->len (it is an error to attempt to
- * error to write more bytes than the remaining available space).
+ * write more bytes than available).
  *
  * After this function is called, the write must be committed with
  * sc_bytebuf_commit_write().
  *
  * The purpose of this mechanism is to acquire a lock only to commit the write,
  * but not to perform the actual copy.
- *
- * This function is guaranteed not to access buf->tail.
  */
 void
 sc_bytebuf_prepare_write(struct sc_bytebuf *buf, const uint8_t *from,
@@ -86,28 +83,21 @@ sc_bytebuf_commit_write(struct sc_bytebuf *buf, size_t len);
  * It is an error to read more bytes than available.
  */
 static inline size_t
-sc_bytebuf_can_read(struct sc_bytebuf *buf) {
+sc_bytebuf_read_remaining(struct sc_bytebuf *buf) {
     return (buf->alloc_size + buf->head - buf->tail) % buf->alloc_size;
 }
 
 /**
- * Return the number of bytes which can be written
+ * Return the number of bytes which can be written without overwriting
  *
- * It is an error to write more bytes than available.
+ * It is not an error to write more bytes than the available space, but this
+ * would overwrite the oldest bytes in the buffer.
  */
 static inline size_t
-sc_bytebuf_can_write(struct sc_bytebuf *buf) {
+sc_bytebuf_write_remaining(struct sc_bytebuf *buf) {
     return (buf->alloc_size + buf->tail - buf->head - 1) % buf->alloc_size;
 }
 
-/**
- * Return the actual capacity of the buffer (can_read() + can_write())
- */
-static inline size_t
-sc_bytebuf_capacity(struct sc_bytebuf *buf) {
-    return buf->alloc_size - 1;
-}
-
 void
 sc_bytebuf_destroy(struct sc_bytebuf *buf);
 

app/src/util/cbuf.h

@@ -0,0 +1,52 @@
+// generic circular buffer (bounded queue) implementation
+#ifndef SC_CBUF_H
+#define SC_CBUF_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <unistd.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/log.c

@@ -125,30 +125,8 @@ sc_av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
     free(local_fmt);
 }
 
-static const char *const sc_sdl_log_priority_names[SDL_NUM_LOG_PRIORITIES] = {
-    [SDL_LOG_PRIORITY_VERBOSE] = "VERBOSE",
-    [SDL_LOG_PRIORITY_DEBUG] = "DEBUG",
-    [SDL_LOG_PRIORITY_INFO] = "INFO",
-    [SDL_LOG_PRIORITY_WARN] = "WARN",
-    [SDL_LOG_PRIORITY_ERROR] = "ERROR",
-    [SDL_LOG_PRIORITY_CRITICAL] = "CRITICAL",
-};
-
-static void SDLCALL
-sc_sdl_log_print(void *userdata, int category, SDL_LogPriority priority,
-                 const char *message) {
-    (void) userdata;
-    (void) category;
-
-    FILE *out = priority < SDL_LOG_PRIORITY_WARN ? stdout : stderr;
-    assert(priority < SDL_NUM_LOG_PRIORITIES);
-    const char *prio_name = sc_sdl_log_priority_names[priority];
-    fprintf(out, "%s: %s\n", prio_name, message);
-}
-
 void
 sc_log_configure() {
-    SDL_LogSetOutputFunction(sc_sdl_log_print, NULL);
     // Redirect FFmpeg logs to SDL logs
     av_log_set_callback(sc_av_log_callback);
 }

app/src/util/memory.c

@@ -1,14 +0,0 @@
-#include "memory.h"
-
-#include <stdlib.h>
-#include <errno.h>
-
-void *
-sc_allocarray(size_t nmemb, size_t size) {
-    size_t bytes;
-    if (__builtin_mul_overflow(nmemb, size, &bytes)) {
-      errno = ENOMEM;
-      return NULL;
-    }
-    return malloc(bytes);
-}

app/src/util/memory.h

@@ -1,15 +0,0 @@
-#ifndef SC_MEMORY_H
-#define SC_MEMORY_H
-
-#include <stddef.h>
-
-/**
- * Allocate an array of `nmemb` items of `size` bytes each
- *
- * Like calloc(), but without initialization.
- * Like reallocarray(), but without reallocation.
- */
-void *
-sc_allocarray(size_t nmemb, size_t size);
-
-#endif

app/src/util/queue.h

@@ -0,0 +1,77 @@
+// generic intrusive FIFO queue
+#ifndef SC_QUEUE_H
+#define SC_QUEUE_H
+
+#include "common.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+// To define a queue type of "struct foo":
+//    struct queue_foo QUEUE(struct foo);
+#define SC_QUEUE(TYPE) { \
+    TYPE *first; \
+    TYPE *last; \
+}
+
+#define sc_queue_init(PQ) \
+    (void) ((PQ)->first = (PQ)->last = NULL)
+
+#define sc_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 SC_QUEUE(struct foo);
+//
+//    struct my_queue queue;
+//    sc_queue_init(&queue);
+//
+//    struct foo v1 = { .value = 42 };
+//    struct foo v2 = { .value = 27 };
+//
+//    sc_queue_push(&queue, next, v1);
+//    sc_queue_push(&queue, next, v2);
+//
+//    struct foo *foo;
+//    sc_queue_take(&queue, next, &foo);
+//    assert(foo->value == 42);
+//    sc_queue_take(&queue, next, &foo);
+//    assert(foo->value == 27);
+//    assert(sc_queue_is_empty(&queue));
+//
+
+// push a new item into the queue
+#define sc_queue_push(PQ, NEXTFIELD, ITEM) \
+    (void) ({ \
+        (ITEM)->NEXTFIELD = NULL; \
+        if (sc_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 sc_queue_take(PQ, NEXTFIELD, PITEM) \
+    (void) ({ \
+        assert(!sc_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/thread.c

@@ -23,39 +23,6 @@ sc_thread_create(sc_thread *thread, sc_thread_fn fn, const char *name,
     return true;
 }
 
-static SDL_ThreadPriority
-to_sdl_thread_priority(enum sc_thread_priority priority) {
-    switch (priority) {
-        case SC_THREAD_PRIORITY_TIME_CRITICAL:
-#ifdef SCRCPY_SDL_HAS_THREAD_PRIORITY_TIME_CRITICAL
-            return SDL_THREAD_PRIORITY_TIME_CRITICAL;
-#else
-            // fall through
-#endif
-        case SC_THREAD_PRIORITY_HIGH:
-            return SDL_THREAD_PRIORITY_HIGH;
-        case SC_THREAD_PRIORITY_NORMAL:
-            return SDL_THREAD_PRIORITY_NORMAL;
-        case SC_THREAD_PRIORITY_LOW:
-            return SDL_THREAD_PRIORITY_LOW;
-        default:
-            assert(!"Unknown thread priority");
-            return 0;
-    }
-}
-
-bool
-sc_thread_set_priority(enum sc_thread_priority priority) {
-    SDL_ThreadPriority sdl_priority = to_sdl_thread_priority(priority);
-    int r = SDL_SetThreadPriority(sdl_priority);
-    if (r) {
-        LOGD("Could not set thread priority: %s", SDL_GetError());
-        return false;
-    }
-
-    return true;
-}
-
 void
 sc_thread_join(sc_thread *thread, int *status) {
     SDL_WaitThread(thread->thread, status);

app/src/util/thread.h

@@ -21,13 +21,6 @@ typedef struct sc_thread {
     SDL_Thread *thread;
 } sc_thread;
 
-enum sc_thread_priority {
-    SC_THREAD_PRIORITY_LOW,
-    SC_THREAD_PRIORITY_NORMAL,
-    SC_THREAD_PRIORITY_HIGH,
-    SC_THREAD_PRIORITY_TIME_CRITICAL,
-};
-
 typedef struct sc_mutex {
     SDL_mutex *mutex;
 #ifndef NDEBUG
@@ -46,9 +39,6 @@ sc_thread_create(sc_thread *thread, sc_thread_fn fn, const char *name,
 void
 sc_thread_join(sc_thread *thread, int *status);
 
-bool
-sc_thread_set_priority(enum sc_thread_priority priority);
-
 bool
 sc_mutex_init(sc_mutex *mutex);
 

app/src/util/timeout.c

@@ -1,77 +0,0 @@
-#include "timeout.h"
-
-#include <assert.h>
-
-#include "log.h"
-
-bool
-sc_timeout_init(struct sc_timeout *timeout) {
-    bool ok = sc_mutex_init(&timeout->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&timeout->cond);
-    if (!ok) {
-        return false;
-    }
-
-    timeout->stopped = false;
-
-    return true;
-}
-
-static int
-run_timeout(void *data) {
-    struct sc_timeout *timeout = data;
-    sc_tick deadline = timeout->deadline;
-
-    sc_mutex_lock(&timeout->mutex);
-    bool timed_out = false;
-    while (!timeout->stopped && !timed_out) {
-        timed_out = !sc_cond_timedwait(&timeout->cond, &timeout->mutex,
-                    deadline);
-    }
-    sc_mutex_unlock(&timeout->mutex);
-
-    timeout->cbs->on_timeout(timeout, timeout->cbs_userdata);
-
-    return 0;
-}
-
-bool
-sc_timeout_start(struct sc_timeout *timeout, sc_tick deadline,
-                 const struct sc_timeout_callbacks *cbs, void *cbs_userdata) {
-    bool ok = sc_thread_create(&timeout->thread, run_timeout, "scrcpy-timeout",
-                               timeout);
-    if (!ok) {
-        LOGE("Timeout: could not start thread");
-        return false;
-    }
-
-    timeout->deadline = deadline;
-
-    assert(cbs && cbs->on_timeout);
-    timeout->cbs = cbs;
-    timeout->cbs_userdata = cbs_userdata;
-
-    return true;
-}
-
-void
-sc_timeout_stop(struct sc_timeout *timeout) {
-    sc_mutex_lock(&timeout->mutex);
-    timeout->stopped = true;
-    sc_mutex_unlock(&timeout->mutex);
-}
-
-void
-sc_timeout_join(struct sc_timeout *timeout) {
-    sc_thread_join(&timeout->thread, NULL);
-}
-
-void
-sc_timeout_destroy(struct sc_timeout *timeout) {
-    sc_mutex_destroy(&timeout->mutex);
-    sc_cond_destroy(&timeout->cond);
-}

app/src/util/timeout.h

@@ -1,43 +0,0 @@
-#ifndef SC_TIMEOUT_H
-#define SC_TIMEOUT_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "thread.h"
-#include "tick.h"
-
-struct sc_timeout {
-    sc_thread thread;
-    sc_tick deadline;
-
-    sc_mutex mutex;
-    sc_cond cond;
-    bool stopped;
-
-    const struct sc_timeout_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct sc_timeout_callbacks {
-    void (*on_timeout)(struct sc_timeout *timeout, void *userdata);
-};
-
-bool
-sc_timeout_init(struct sc_timeout *timeout);
-
-void
-sc_timeout_destroy(struct sc_timeout *timeout);
-
-bool
-sc_timeout_start(struct sc_timeout *timeout, sc_tick deadline,
-                 const struct sc_timeout_callbacks *cbs, void *cbs_userdata);
-
-void
-sc_timeout_stop(struct sc_timeout *timeout);
-
-void
-sc_timeout_join(struct sc_timeout *timeout);
-
-#endif

app/src/util/vecdeque.h

@@ -1,379 +0,0 @@
-#ifndef SC_VECDEQUE_H
-#define SC_VECDEQUE_H
-
-#include "common.h"
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "util/memory.h"
-
-/**
- * A double-ended queue implemented with a growable ring buffer.
- *
- * Inspired from the Rust VecDeque type:
- * <https://doc.rust-lang.org/std/collections/struct.VecDeque.html>
- */
-
-/**
- * VecDeque struct body
- *
- * A VecDeque is a dynamic ring-buffer, managed by the sc_vecdeque_* helpers.
- *
- * It is generic over the type of its items, so it is implemented via macros.
- *
- * To use a VecDeque, a new type must be defined:
- *
- *     struct vecdeque_int SC_VECDEQUE(int);
- *
- * The struct may be anonymous:
- *
- *     struct SC_VECDEQUE(const char *) names;
- *
- * Functions and macros having name ending with '_' are private.
- */
-#define SC_VECDEQUE(type) { \
-    size_t cap; \
-    size_t origin; \
-    size_t size; \
-    type *data; \
-}
-
-/**
- * Static initializer for a VecDeque
- */
-#define SC_VECDEQUE_INITIALIZER { 0, 0, 0, NULL }
-
-/**
- * Initialize an empty VecDeque
- */
-#define sc_vecdeque_init(pv) \
-({ \
-    (pv)->cap = 0; \
-    (pv)->origin = 0; \
-    (pv)->size = 0; \
-    (pv)->data = NULL; \
-})
-
-/**
- * Destroy a VecDeque
- */
-#define sc_vecdeque_destroy(pv) \
-    free((pv)->data)
-
-/**
- * Clear a VecDeque
- *
- * Remove all items.
- */
-#define sc_vecdeque_clear(pv) \
-(void) ({ \
-    sc_vecdeque_destroy(pv); \
-    sc_vecdeque_init(pv); \
-})
-
-/**
- * Returns the content size
- */
-#define sc_vecdeque_size(pv) \
-    (pv)->size
-
-/**
- * Return whether the VecDeque is empty (i.e. its size is 0)
- */
-#define sc_vecdeque_is_empty(pv) \
-    ((pv)->size == 0)
-
-/**
- * Return whether the VecDeque is full
- *
- * A VecDeque is full when its size equals its current capacity. However, it
- * does not prevent to push a new item (with sc_vecdeque_push()), since this
- * will increase its capacity.
- */
-#define sc_vecdeque_is_full(pv) \
-    ((pv)->size == (pv)->cap)
-
-/**
- * The minimal allocation size, in number of items
- *
- * Private.
- */
-#define SC_VECDEQUE_MINCAP_ ((size_t) 10)
-
-/**
- * The maximal allocation size, in number of items
- *
- * Use SIZE_MAX/2 to fit in ssize_t, and so that cap*1.5 does not overflow.
- *
- * Private.
- */
-#define sc_vecdeque_max_cap_(pv) (SIZE_MAX / 2 / sizeof(*(pv)->data))
-
-/**
- * Realloc the internal array to a specific capacity
- *
- * On reallocation success, update the VecDeque capacity (`*pcap`) and origin
- * (`*porigin`), and return the reallocated data.
- *
- * On reallocation failure, return NULL without any change.
- *
- * Private.
- *
- * \param ptr the current `data` field of the SC_VECDEQUE to realloc
- * \param newcap the requested capacity, in number of items
- * \param item_size the size of one item (the generic type is unknown from this
- *                  function)
- * \param pcap a pointer to the `cap` field of the SC_VECDEQUE [IN/OUT]
- * \param porigin a pointer to pv->origin [IN/OUT]
- * \param size the `size` field of the SC_VECDEQUE
- * \return the new array to assign to the `data` field of the SC_VECDEQUE (if
- *         not NULL)
- */
-static inline void *
-sc_vecdeque_reallocdata_(void *ptr, size_t newcap, size_t item_size,
-                         size_t *pcap, size_t *porigin, size_t size) {
-
-    size_t oldcap = *pcap;
-    size_t oldorigin = *porigin;
-
-    assert(newcap > oldcap); // Could only grow
-
-    if (oldorigin + size <= oldcap) {
-        // The current content will stay in place, just realloc
-        //
-        // As an example, here is the content of a ring-buffer (oldcap=10)
-        // before the realloc:
-        //
-        //     _ _ 2 3 4 5 6 7 _ _
-        //         ^
-        //         origin
-        //
-        // It is resized (newcap=15), e.g. with sc_vecdeque_reserve():
-        //
-        //     _ _ 2 3 4 5 6 7 _ _ _ _ _ _ _
-        //         ^
-        //         origin
-
-        void *newptr = reallocarray(ptr, newcap, item_size);
-        if (!newptr) {
-            return NULL;
-        }
-
-        *pcap = newcap;
-        return newptr;
-    }
-
-    // Copy the current content to the new array
-    //
-    // As an example, here is the content of a ring-buffer (oldcap=10) before
-    // the realloc:
-    //
-    //     5 6 7 _ _ 0 1 2 3 4
-    //               ^
-    //               origin
-    //
-    // It is resized (newcap=15), e.g. with sc_vecdeque_reserve():
-    //
-    //     0 1 2 3 4 5 6 7 _ _ _ _ _ _ _
-    //     ^
-    //     origin
-
-    assert(size);
-    void *newptr = sc_allocarray(newcap, item_size);
-    if (!newptr) {
-        return NULL;
-    }
-
-    size_t right_len = MIN(size, oldcap - oldorigin);
-    assert(right_len);
-    memcpy(newptr, ptr + (oldorigin * item_size), right_len * item_size);
-
-    if (size > right_len) {
-        memcpy(newptr + (right_len * item_size), ptr,
-               (size - right_len) * item_size);
-    }
-
-    free(ptr);
-
-    *pcap = newcap;
-    *porigin = 0;
-    return newptr;
-}
-
-/**
- * Macro to realloc the internal data to a new capacity
- *
- * Private.
- *
- * \retval true on success
- * \retval false on allocation failure (the VecDeque is left untouched)
- */
-#define sc_vecdeque_realloc_(pv, newcap) \
-({ \
-    void *p = sc_vecdeque_reallocdata_((pv)->data, newcap, \
-                                       sizeof(*(pv)->data), &(pv)->cap, \
-                                       &(pv)->origin, (pv)->size); \
-    if (p) { \
-        (pv)->data = p; \
-    } \
-    (bool) p; \
-});
-
-static inline size_t
-sc_vecdeque_growsize_(size_t value)
-{
-    /* integer multiplication by 1.5 */
-    return value + (value >> 1);
-}
-
-/**
- * Increase the capacity of the VecDeque to at least `mincap`
- *
- * \param pv a pointer to the VecDeque
- * \param mincap (`size_t`) the requested capacity
- * \retval true on success
- * \retval false on allocation failure (the VecDeque is left untouched)
- */
-#define sc_vecdeque_reserve(pv, mincap) \
-({ \
-    assert(mincap <= sc_vecdeque_max_cap_(pv)); \
-    bool ok; \
-    /* avoid to allocate tiny arrays (< SC_VECDEQUE_MINCAP_) */ \
-    size_t mincap_ = MAX(mincap, SC_VECDEQUE_MINCAP_); \
-    if (mincap_ <= (pv)->cap) { \
-        /* nothing to do */ \
-        ok = true; \
-    } else if (mincap_ <= sc_vecdeque_max_cap_(pv)) { \
-        /* not too big */ \
-        size_t newsize = sc_vecdeque_growsize_((pv)->cap); \
-        newsize = CLAMP(newsize, mincap_, sc_vecdeque_max_cap_(pv)); \
-        ok = sc_vecdeque_realloc_(pv, newsize); \
-    } else { \
-        ok = false; \
-    } \
-    ok; \
-})
-
-/**
- * Automatically grow the VecDeque capacity
- *
- * Private.
- *
- * \retval true on success
- * \retval false on allocation failure (the VecDeque is left untouched)
- */
-#define sc_vecdeque_grow_(pv) \
-({ \
-    bool ok; \
-    if ((pv)->cap < sc_vecdeque_max_cap_(pv)) { \
-        size_t newsize = sc_vecdeque_growsize_((pv)->cap); \
-        newsize = CLAMP(newsize, SC_VECDEQUE_MINCAP_, \
-                        sc_vecdeque_max_cap_(pv)); \
-        ok = sc_vecdeque_realloc_(pv, newsize); \
-    } else { \
-        ok = false; \
-    } \
-    ok; \
-})
-
-/**
- * Grow the VecDeque capacity if it is full
- *
- * Private.
- *
- * \retval true on success
- * \retval false on allocation failure (the VecDeque is left untouched)
- */
-#define sc_vecdeque_grow_if_needed_(pv) \
-    (!sc_vecdeque_is_full(pv) || sc_vecdeque_grow_(pv))
-
-/**
- * Push an uninitialized item, and return a pointer to it
- *
- * It does not attempt to resize the VecDeque. It is an error to this function
- * if the VecDeque is full.
- *
- * This function may not fail. It returns a valid non-NULL pointer to the
- * uninitialized item just pushed.
- */
-#define sc_vecdeque_push_hole_noresize(pv) \
-({ \
-    assert(!sc_vecdeque_is_full(pv)); \
-    ++(pv)->size; \
-    &(pv)->data[((pv)->origin + (pv)->size - 1) % (pv)->cap]; \
-})
-
-/**
- * Push an uninitialized item, and return a pointer to it
- *
- * If the VecDeque is full, it is resized.
- *
- * This function returns either a valid non-NULL pointer to the uninitialized
- * item just pushed, or NULL on reallocation failure.
- */
-#define sc_vecdeque_push_hole(pv) \
-    (sc_vecdeque_grow_if_needed_(pv) ? \
-            sc_vecdeque_push_hole_noresize(pv) : NULL)
-
-/**
- * Push an item
- *
- * It does not attempt to resize the VecDeque. It is an error to this function
- * if the VecDeque is full.
- *
- * This function may not fail.
- */
-#define sc_vecdeque_push_noresize(pv, item) \
-(void) ({ \
-    assert(!sc_vecdeque_is_full(pv)); \
-    ++(pv)->size; \
-    (pv)->data[((pv)->origin + (pv)->size - 1) % (pv)->cap] = item; \
-})
-
-/**
- * Push an item
- *
- * If the VecDeque is full, it is resized.
- *
- * \retval true on success
- * \retval false on allocation failure (the VecDeque is left untouched)
- */
-#define sc_vecdeque_push(pv, item) \
-({ \
-    bool ok = sc_vecdeque_grow_if_needed_(pv); \
-    if (ok) { \
-        sc_vecdeque_push_noresize(pv, item); \
-    } \
-    ok; \
-})
-
-/**
- * Pop an item and return a pointer to it (still in the VecDeque)
- *
- * Returning a pointer allows the caller to destroy it in place without copy
- * (especially if the item type is big).
- *
- * It is an error to call this function if the VecDeque is empty.
- */
-#define sc_vecdeque_popref(pv) \
-({ \
-    assert(!sc_vecdeque_is_empty(pv)); \
-    size_t pos = (pv)->origin; \
-    (pv)->origin = ((pv)->origin + 1) % (pv)->cap; \
-    --(pv)->size; \
-    &(pv)->data[pos]; \
-})
-
-/**
- * Pop an item and return it
- *
- * It is an error to call this function if the VecDeque is empty.
- */
-#define sc_vecdeque_pop(pv) \
-    (*sc_vecdeque_popref(pv))
-
-#endif

app/src/util/vector.h

@@ -118,7 +118,7 @@ static inline void *
 sc_vector_reallocdata_(void *ptr, size_t count, size_t size,
                         size_t *restrict pcap, size_t *restrict psize)
 {
-    void *p = reallocarray(ptr, count, size);
+    void *p = realloc(ptr, count * size);
     if (!p) {
         return NULL;
     }

app/src/v4l2_sink.c

@@ -126,7 +126,7 @@ run_v4l2_sink(void *data) {
         vs->has_frame = false;
         sc_mutex_unlock(&vs->mutex);
 
-        sc_frame_buffer_consume(&vs->fb, vs->frame);
+        sc_video_buffer_consume(&vs->vb, vs->frame);
 
         bool ok = encode_and_write_frame(vs, vs->frame);
         av_frame_unref(vs->frame);
@@ -141,19 +141,42 @@ run_v4l2_sink(void *data) {
     return 0;
 }
 
+static void
+sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
+                             void *userdata) {
+    (void) vb;
+    struct sc_v4l2_sink *vs = userdata;
+
+    if (!previous_skipped) {
+        sc_mutex_lock(&vs->mutex);
+        vs->has_frame = true;
+        sc_cond_signal(&vs->cond);
+        sc_mutex_unlock(&vs->mutex);
+    }
+}
+
 static bool
 sc_v4l2_sink_open(struct sc_v4l2_sink *vs, const AVCodecContext *ctx) {
     assert(ctx->pix_fmt == AV_PIX_FMT_YUV420P);
     (void) ctx;
 
-    bool ok = sc_frame_buffer_init(&vs->fb);
+    static const struct sc_video_buffer_callbacks cbs = {
+        .on_new_frame = sc_video_buffer_on_new_frame,
+    };
+
+    bool ok = sc_video_buffer_init(&vs->vb, vs->buffering_time, &cbs, vs);
     if (!ok) {
         return false;
     }
 
+    ok = sc_video_buffer_start(&vs->vb);
+    if (!ok) {
+        goto error_video_buffer_destroy;
+    }
+
     ok = sc_mutex_init(&vs->mutex);
     if (!ok) {
-        goto error_frame_buffer_destroy;
+        goto error_video_buffer_stop_and_join;
     }
 
     ok = sc_cond_init(&vs->cond);
@@ -205,13 +228,11 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs, const AVCodecContext *ctx) {
         goto error_avformat_free_context;
     }
 
-    int r = avcodec_parameters_from_context(ostream->codecpar, ctx);
+    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
-    if (r < 0) {
-        goto error_avformat_free_context;
-    }
-
-    // The codec is from the v4l2 encoder, not from the decoder
     ostream->codecpar->codec_id = encoder->id;
+    ostream->codecpar->format = AV_PIX_FMT_YUV420P;
+    ostream->codecpar->width = vs->frame_size.width;
+    ostream->codecpar->height = vs->frame_size.height;
 
     int ret = avio_open(&vs->format_ctx->pb, vs->device_name, AVIO_FLAG_WRITE);
     if (ret < 0) {
@@ -226,8 +247,8 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs, const AVCodecContext *ctx) {
         goto error_avio_close;
     }
 
-    vs->encoder_ctx->width = ctx->width;
+    vs->encoder_ctx->width = vs->frame_size.width;
-    vs->encoder_ctx->height = ctx->height;
+    vs->encoder_ctx->height = vs->frame_size.height;
     vs->encoder_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
     vs->encoder_ctx->time_base.num = 1;
     vs->encoder_ctx->time_base.den = 1;
@@ -280,8 +301,11 @@ error_cond_destroy:
     sc_cond_destroy(&vs->cond);
 error_mutex_destroy:
     sc_mutex_destroy(&vs->mutex);
-error_frame_buffer_destroy:
+error_video_buffer_stop_and_join:
-    sc_frame_buffer_destroy(&vs->fb);
+    sc_video_buffer_stop(&vs->vb);
+    sc_video_buffer_join(&vs->vb);
+error_video_buffer_destroy:
+    sc_video_buffer_destroy(&vs->vb);
 
     return false;
 }
@@ -293,7 +317,10 @@ sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
     sc_cond_signal(&vs->cond);
     sc_mutex_unlock(&vs->mutex);
 
+    sc_video_buffer_stop(&vs->vb);
+
     sc_thread_join(&vs->thread, NULL);
+    sc_video_buffer_join(&vs->vb);
 
     av_packet_free(&vs->packet);
     av_frame_free(&vs->frame);
@@ -303,25 +330,12 @@ sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
     avformat_free_context(vs->format_ctx);
     sc_cond_destroy(&vs->cond);
     sc_mutex_destroy(&vs->mutex);
-    sc_frame_buffer_destroy(&vs->fb);
+    sc_video_buffer_destroy(&vs->vb);
 }
 
 static bool
 sc_v4l2_sink_push(struct sc_v4l2_sink *vs, const AVFrame *frame) {
-    bool previous_skipped;
+    return sc_video_buffer_push(&vs->vb, frame);
-    bool ok = sc_frame_buffer_push(&vs->fb, frame, &previous_skipped);
-    if (!ok) {
-        return false;
-    }
-
-    if (!previous_skipped) {
-        sc_mutex_lock(&vs->mutex);
-        vs->has_frame = true;
-        sc_cond_signal(&vs->cond);
-        sc_mutex_unlock(&vs->mutex);
-    }
-
-    return true;
 }
 
 static bool
@@ -343,13 +357,17 @@ sc_v4l2_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
 }
 
 bool
-sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name) {
+sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
+                  struct sc_size frame_size, sc_tick buffering_time) {
     vs->device_name = strdup(device_name);
     if (!vs->device_name) {
         LOGE("Could not strdup v4l2 device name");
         return false;
     }
 
+    vs->frame_size = frame_size;
+    vs->buffering_time = buffering_time;
+
     static const struct sc_frame_sink_ops ops = {
         .open = sc_v4l2_frame_sink_open,
         .close = sc_v4l2_frame_sink_close,

app/src/v4l2_sink.h

@@ -8,17 +8,19 @@
 
 #include "coords.h"
 #include "trait/frame_sink.h"
-#include "frame_buffer.h"
+#include "video_buffer.h"
 #include "util/tick.h"
 
 struct sc_v4l2_sink {
     struct sc_frame_sink frame_sink; // frame sink trait
 
-    struct sc_frame_buffer fb;
+    struct sc_video_buffer vb;
     AVFormatContext *format_ctx;
     AVCodecContext *encoder_ctx;
 
     char *device_name;
+    struct sc_size frame_size;
+    sc_tick buffering_time;
 
     sc_thread thread;
     sc_mutex mutex;
@@ -32,7 +34,8 @@ struct sc_v4l2_sink {
 };
 
 bool
-sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name);
+sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
+                  struct sc_size frame_size, sc_tick buffering_time);
 
 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);

app/src/video_buffer.c

@@ -0,0 +1,254 @@
+#include "video_buffer.h"
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include <libavutil/avutil.h>
+#include <libavformat/avformat.h>
+
+#include "util/log.h"
+
+#define SC_BUFFERING_NDEBUG // comment to debug
+
+static struct sc_video_buffer_frame *
+sc_video_buffer_frame_new(const AVFrame *frame) {
+    struct sc_video_buffer_frame *vb_frame = malloc(sizeof(*vb_frame));
+    if (!vb_frame) {
+        LOG_OOM();
+        return NULL;
+    }
+
+    vb_frame->frame = av_frame_alloc();
+    if (!vb_frame->frame) {
+        LOG_OOM();
+        free(vb_frame);
+        return NULL;
+    }
+
+    if (av_frame_ref(vb_frame->frame, frame)) {
+        av_frame_free(&vb_frame->frame);
+        free(vb_frame);
+        return NULL;
+    }
+
+    return vb_frame;
+}
+
+static void
+sc_video_buffer_frame_delete(struct sc_video_buffer_frame *vb_frame) {
+    av_frame_unref(vb_frame->frame);
+    av_frame_free(&vb_frame->frame);
+    free(vb_frame);
+}
+
+static bool
+sc_video_buffer_offer(struct sc_video_buffer *vb, const AVFrame *frame) {
+    bool previous_skipped;
+    bool ok = sc_frame_buffer_push(&vb->fb, frame, &previous_skipped);
+    if (!ok) {
+        return false;
+    }
+
+    vb->cbs->on_new_frame(vb, previous_skipped, vb->cbs_userdata);
+    return true;
+}
+
+static int
+run_buffering(void *data) {
+    struct sc_video_buffer *vb = data;
+
+    assert(vb->buffering_time > 0);
+
+    for (;;) {
+        sc_mutex_lock(&vb->b.mutex);
+
+        while (!vb->b.stopped && sc_queue_is_empty(&vb->b.queue)) {
+            sc_cond_wait(&vb->b.queue_cond, &vb->b.mutex);
+        }
+
+        if (vb->b.stopped) {
+            sc_mutex_unlock(&vb->b.mutex);
+            goto stopped;
+        }
+
+        struct sc_video_buffer_frame *vb_frame;
+        sc_queue_take(&vb->b.queue, next, &vb_frame);
+
+        sc_tick max_deadline = sc_tick_now() + vb->buffering_time;
+        // PTS (written by the server) are expressed in microseconds
+        sc_tick pts = SC_TICK_TO_US(vb_frame->frame->pts);
+
+        bool timed_out = false;
+        while (!vb->b.stopped && !timed_out) {
+            sc_tick deadline = sc_clock_to_system_time(&vb->b.clock, pts)
+                             + vb->buffering_time;
+            if (deadline > max_deadline) {
+                deadline = max_deadline;
+            }
+
+            timed_out =
+                !sc_cond_timedwait(&vb->b.wait_cond, &vb->b.mutex, deadline);
+        }
+
+        if (vb->b.stopped) {
+            sc_video_buffer_frame_delete(vb_frame);
+            sc_mutex_unlock(&vb->b.mutex);
+            goto stopped;
+        }
+
+        sc_mutex_unlock(&vb->b.mutex);
+
+#ifndef SC_BUFFERING_NDEBUG
+        LOGD("Buffering: %" PRItick ";%" PRItick ";%" PRItick,
+             pts, vb_frame->push_date, sc_tick_now());
+#endif
+
+        sc_video_buffer_offer(vb, vb_frame->frame);
+
+        sc_video_buffer_frame_delete(vb_frame);
+    }
+
+stopped:
+    // Flush queue
+    while (!sc_queue_is_empty(&vb->b.queue)) {
+        struct sc_video_buffer_frame *vb_frame;
+        sc_queue_take(&vb->b.queue, next, &vb_frame);
+        sc_video_buffer_frame_delete(vb_frame);
+    }
+
+    LOGD("Buffering thread ended");
+
+    return 0;
+}
+
+bool
+sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
+                     const struct sc_video_buffer_callbacks *cbs,
+                     void *cbs_userdata) {
+    bool ok = sc_frame_buffer_init(&vb->fb);
+    if (!ok) {
+        return false;
+    }
+
+    assert(buffering_time >= 0);
+    if (buffering_time) {
+        ok = sc_mutex_init(&vb->b.mutex);
+        if (!ok) {
+            sc_frame_buffer_destroy(&vb->fb);
+            return false;
+        }
+
+        ok = sc_cond_init(&vb->b.queue_cond);
+        if (!ok) {
+            sc_mutex_destroy(&vb->b.mutex);
+            sc_frame_buffer_destroy(&vb->fb);
+            return false;
+        }
+
+        ok = sc_cond_init(&vb->b.wait_cond);
+        if (!ok) {
+            sc_cond_destroy(&vb->b.queue_cond);
+            sc_mutex_destroy(&vb->b.mutex);
+            sc_frame_buffer_destroy(&vb->fb);
+            return false;
+        }
+
+        sc_clock_init(&vb->b.clock);
+        sc_queue_init(&vb->b.queue);
+    }
+
+    assert(cbs);
+    assert(cbs->on_new_frame);
+
+    vb->buffering_time = buffering_time;
+    vb->cbs = cbs;
+    vb->cbs_userdata = cbs_userdata;
+    return true;
+}
+
+bool
+sc_video_buffer_start(struct sc_video_buffer *vb) {
+    if (vb->buffering_time) {
+        bool ok =
+            sc_thread_create(&vb->b.thread, run_buffering, "scrcpy-vbuf", vb);
+        if (!ok) {
+            LOGE("Could not start buffering thread");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void
+sc_video_buffer_stop(struct sc_video_buffer *vb) {
+    if (vb->buffering_time) {
+        sc_mutex_lock(&vb->b.mutex);
+        vb->b.stopped = true;
+        sc_cond_signal(&vb->b.queue_cond);
+        sc_cond_signal(&vb->b.wait_cond);
+        sc_mutex_unlock(&vb->b.mutex);
+    }
+}
+
+void
+sc_video_buffer_join(struct sc_video_buffer *vb) {
+    if (vb->buffering_time) {
+        sc_thread_join(&vb->b.thread, NULL);
+    }
+}
+
+void
+sc_video_buffer_destroy(struct sc_video_buffer *vb) {
+    sc_frame_buffer_destroy(&vb->fb);
+    if (vb->buffering_time) {
+        sc_cond_destroy(&vb->b.wait_cond);
+        sc_cond_destroy(&vb->b.queue_cond);
+        sc_mutex_destroy(&vb->b.mutex);
+    }
+}
+
+bool
+sc_video_buffer_push(struct sc_video_buffer *vb, const AVFrame *frame) {
+    if (!vb->buffering_time) {
+        // No buffering
+        return sc_video_buffer_offer(vb, frame);
+    }
+
+    sc_mutex_lock(&vb->b.mutex);
+
+    sc_tick pts = SC_TICK_FROM_US(frame->pts);
+    sc_clock_update(&vb->b.clock, sc_tick_now(), pts);
+    sc_cond_signal(&vb->b.wait_cond);
+
+    if (vb->b.clock.count == 1) {
+        sc_mutex_unlock(&vb->b.mutex);
+        // First frame, offer it immediately, for two reasons:
+        //  - not to delay the opening of the scrcpy window
+        //  - the buffering estimation needs at least two clock points, so it
+        //  could not handle the first frame
+        return sc_video_buffer_offer(vb, frame);
+    }
+
+    struct sc_video_buffer_frame *vb_frame = sc_video_buffer_frame_new(frame);
+    if (!vb_frame) {
+        sc_mutex_unlock(&vb->b.mutex);
+        LOG_OOM();
+        return false;
+    }
+
+#ifndef SC_BUFFERING_NDEBUG
+    vb_frame->push_date = sc_tick_now();
+#endif
+    sc_queue_push(&vb->b.queue, next, vb_frame);
+    sc_cond_signal(&vb->b.queue_cond);
+
+    sc_mutex_unlock(&vb->b.mutex);
+
+    return true;
+}
+
+void
+sc_video_buffer_consume(struct sc_video_buffer *vb, AVFrame *dst) {
+    sc_frame_buffer_consume(&vb->fb, dst);
+}

app/src/video_buffer.h

@@ -0,0 +1,76 @@
+#ifndef SC_VIDEO_BUFFER_H
+#define SC_VIDEO_BUFFER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "clock.h"
+#include "frame_buffer.h"
+#include "util/queue.h"
+#include "util/thread.h"
+#include "util/tick.h"
+
+// forward declarations
+typedef struct AVFrame AVFrame;
+
+struct sc_video_buffer_frame {
+    AVFrame *frame;
+    struct sc_video_buffer_frame *next;
+#ifndef NDEBUG
+    sc_tick push_date;
+#endif
+};
+
+struct sc_video_buffer_frame_queue SC_QUEUE(struct sc_video_buffer_frame);
+
+struct sc_video_buffer {
+    struct sc_frame_buffer fb;
+
+    sc_tick buffering_time;
+
+    // only if buffering_time > 0
+    struct {
+        sc_thread thread;
+        sc_mutex mutex;
+        sc_cond queue_cond;
+        sc_cond wait_cond;
+
+        struct sc_clock clock;
+        struct sc_video_buffer_frame_queue queue;
+        bool stopped;
+    } b; // buffering
+
+    const struct sc_video_buffer_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+struct sc_video_buffer_callbacks {
+    void (*on_new_frame)(struct sc_video_buffer *vb, bool previous_skipped,
+                         void *userdata);
+};
+
+bool
+sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
+                     const struct sc_video_buffer_callbacks *cbs,
+                     void *cbs_userdata);
+
+bool
+sc_video_buffer_start(struct sc_video_buffer *vb);
+
+void
+sc_video_buffer_stop(struct sc_video_buffer *vb);
+
+void
+sc_video_buffer_join(struct sc_video_buffer *vb);
+
+void
+sc_video_buffer_destroy(struct sc_video_buffer *vb);
+
+bool
+sc_video_buffer_push(struct sc_video_buffer *vb, const AVFrame *frame);
+
+void
+sc_video_buffer_consume(struct sc_video_buffer *vb, AVFrame *dst);
+
+#endif

app/tests/test_adb_parser.c

@@ -217,18 +217,6 @@ static void test_get_ip_multiline_second_ok(void) {
     free(ip);
 }
 
-static void test_get_ip_multiline_second_ok_without_cr(void) {
-    char ip_route[] = "10.0.0.0/24 dev rmnet  proto kernel  scope link  src "
-                      "10.0.0.3\n"
-                      "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
-                      "192.168.1.3\n";
-
-    char *ip = sc_adb_parse_device_ip(ip_route);
-    assert(ip);
-    assert(!strcmp(ip, "192.168.1.3"));
-    free(ip);
-}
-
 static void test_get_ip_no_wlan(void) {
     char ip_route[] = "192.168.1.0/24 dev rmnet  proto kernel  scope link  src "
                       "192.168.12.34\r\r\n";
@@ -271,7 +259,6 @@ int main(int argc, char *argv[]) {
     test_get_ip_single_line_with_trailing_space();
     test_get_ip_multiline_first_ok();
     test_get_ip_multiline_second_ok();
-    test_get_ip_multiline_second_ok_without_cr();
     test_get_ip_no_wlan();
     test_get_ip_no_wlan_without_eol();
     test_get_ip_truncated();

app/tests/test_bytebuf.c

@@ -13,23 +13,23 @@ void test_bytebuf_simple(void) {
     assert(ok);
 
     sc_bytebuf_write(&buf, (uint8_t *) "hello", sizeof("hello") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 5);
+    assert(sc_bytebuf_read_remaining(&buf) == 5);
 
     sc_bytebuf_read(&buf, data, 4);
     assert(!strncmp((char *) data, "hell", 4));
 
     sc_bytebuf_write(&buf, (uint8_t *) " world", sizeof(" world") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 7);
+    assert(sc_bytebuf_read_remaining(&buf) == 7);
 
     sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
-    assert(sc_bytebuf_can_read(&buf) == 8);
+    assert(sc_bytebuf_read_remaining(&buf) == 8);
 
     sc_bytebuf_read(&buf, &data[4], 8);
-    assert(sc_bytebuf_can_read(&buf) == 0);
+    assert(sc_bytebuf_read_remaining(&buf) == 0);
 
     data[12] = '\0';
     assert(!strcmp((char *) data, "hello world!"));
-    assert(sc_bytebuf_can_read(&buf) == 0);
+    assert(sc_bytebuf_read_remaining(&buf) == 0);
 
     sc_bytebuf_destroy(&buf);
 }
@@ -42,31 +42,58 @@ void test_bytebuf_boundaries(void) {
     assert(ok);
 
     sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 6);
+    assert(sc_bytebuf_read_remaining(&buf) == 6);
 
     sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 12);
+    assert(sc_bytebuf_read_remaining(&buf) == 12);
 
     sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 18);
+    assert(sc_bytebuf_read_remaining(&buf) == 18);
 
     sc_bytebuf_read(&buf, data, 9);
     assert(!strncmp((char *) data, "hello hel", 9));
-    assert(sc_bytebuf_can_read(&buf) == 9);
+    assert(sc_bytebuf_read_remaining(&buf) == 9);
 
     sc_bytebuf_write(&buf, (uint8_t *) "world", sizeof("world") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 14);
+    assert(sc_bytebuf_read_remaining(&buf) == 14);
 
     sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
-    assert(sc_bytebuf_can_read(&buf) == 15);
+    assert(sc_bytebuf_read_remaining(&buf) == 15);
 
     sc_bytebuf_skip(&buf, 3);
-    assert(sc_bytebuf_can_read(&buf) == 12);
+    assert(sc_bytebuf_read_remaining(&buf) == 12);
 
     sc_bytebuf_read(&buf, data, 12);
     data[12] = '\0';
     assert(!strcmp((char *) data, "hello world!"));
-    assert(sc_bytebuf_can_read(&buf) == 0);
+    assert(sc_bytebuf_read_remaining(&buf) == 0);
+
+    sc_bytebuf_destroy(&buf);
+}
+
+void test_bytebuf_overwrite(void) {
+    struct sc_bytebuf buf;
+    uint8_t data[10];
+
+    bool ok = sc_bytebuf_init(&buf, 10); // so actual capacity is 9
+    assert(ok);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 6);
+
+    sc_bytebuf_write(&buf, (uint8_t *) "abcdef", sizeof("abcdef") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 9);
+
+    sc_bytebuf_read(&buf, data, 9);
+    assert(!strncmp((char *) data, "lo abcdef", 9));
+
+    sc_bytebuf_write(&buf, (uint8_t *) "a very big buffer",
+                     sizeof("a very big buffer") - 1);
+    assert(sc_bytebuf_read_remaining(&buf) == 9);
+
+    sc_bytebuf_read(&buf, data, 9);
+    assert(!strncmp((char *) data, "ig buffer", 9));
+    assert(sc_bytebuf_read_remaining(&buf) == 0);
 
     sc_bytebuf_destroy(&buf);
 }
@@ -79,37 +106,37 @@ void test_bytebuf_two_steps_write(void) {
     assert(ok);
 
     sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 6);
+    assert(sc_bytebuf_read_remaining(&buf) == 6);
 
     sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 12);
+    assert(sc_bytebuf_read_remaining(&buf) == 12);
 
     sc_bytebuf_prepare_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 12); // write not committed yet
+    assert(sc_bytebuf_read_remaining(&buf) == 12); // write not committed yet
 
     sc_bytebuf_read(&buf, data, 9);
     assert(!strncmp((char *) data, "hello hel", 3));
-    assert(sc_bytebuf_can_read(&buf) == 3);
+    assert(sc_bytebuf_read_remaining(&buf) == 3);
 
     sc_bytebuf_commit_write(&buf, sizeof("hello ") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 9);
+    assert(sc_bytebuf_read_remaining(&buf) == 9);
 
     sc_bytebuf_prepare_write(&buf, (uint8_t *) "world", sizeof("world") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 9); // write not committed yet
+    assert(sc_bytebuf_read_remaining(&buf) == 9); // write not committed yet
 
     sc_bytebuf_commit_write(&buf, sizeof("world") - 1);
-    assert(sc_bytebuf_can_read(&buf) == 14);
+    assert(sc_bytebuf_read_remaining(&buf) == 14);
 
     sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
-    assert(sc_bytebuf_can_read(&buf) == 15);
+    assert(sc_bytebuf_read_remaining(&buf) == 15);
 
     sc_bytebuf_skip(&buf, 3);
-    assert(sc_bytebuf_can_read(&buf) == 12);
+    assert(sc_bytebuf_read_remaining(&buf) == 12);
 
     sc_bytebuf_read(&buf, data, 12);
     data[12] = '\0';
     assert(!strcmp((char *) data, "hello world!"));
-    assert(sc_bytebuf_can_read(&buf) == 0);
+    assert(sc_bytebuf_read_remaining(&buf) == 0);
 
     sc_bytebuf_destroy(&buf);
 }
@@ -120,6 +147,7 @@ int main(int argc, char *argv[]) {
 
     test_bytebuf_simple();
     test_bytebuf_boundaries();
+    test_bytebuf_overwrite();
     test_bytebuf_two_steps_write();
 
     return 0;

app/tests/test_cbuf.c

@@ -0,0 +1,78 @@
+#include "common.h"
+
+#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(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_cbuf_empty();
+    test_cbuf_full();
+    test_cbuf_push_take();
+    return 0;
+}

app/tests/test_cli.c

@@ -53,7 +53,7 @@ static void test_options(void) {
         "--max-size", "1024",
         "--lock-video-orientation=2", // optional arguments require '='
         // "--no-control" is not compatible with "--turn-screen-off"
-        // "--no-playback" is not compatible with "--fulscreen"
+        // "--no-display" is not compatible with "--fulscreen"
         "--port", "1234:1236",
         "--push-target", "/sdcard/Movies",
         "--record", "file",
@@ -108,8 +108,8 @@ static void test_options2(void) {
     char *argv[] = {
         "scrcpy",
         "--no-control",
-        "--no-playback",
+        "--no-display",
-        "--record", "file.mp4", // cannot enable --no-playback without recording
+        "--record", "file.mp4", // cannot enable --no-display without recording
     };
 
     bool ok = scrcpy_parse_args(&args, ARRAY_LEN(argv), argv);
@@ -117,8 +117,7 @@ static void test_options2(void) {
 
     const struct scrcpy_options *opts = &args.opts;
     assert(!opts->control);
-    assert(!opts->video_playback);
+    assert(!opts->display);
-    assert(!opts->audio_playback);
     assert(!strcmp(opts->record_filename, "file.mp4"));
     assert(opts->record_format == SC_RECORD_FORMAT_MP4);
 }

app/tests/test_clock.c

@@ -0,0 +1,79 @@
+#include "common.h"
+
+#include <assert.h>
+
+#include "clock.h"
+
+void test_small_rolling_sum(void) {
+    struct sc_clock clock;
+    sc_clock_init(&clock);
+
+    assert(clock.count == 0);
+    assert(clock.left_sum.system == 0);
+    assert(clock.left_sum.stream == 0);
+    assert(clock.right_sum.system == 0);
+    assert(clock.right_sum.stream == 0);
+
+    sc_clock_update(&clock, 2, 3);
+    assert(clock.count == 1);
+    assert(clock.left_sum.system == 0);
+    assert(clock.left_sum.stream == 0);
+    assert(clock.right_sum.system == 2);
+    assert(clock.right_sum.stream == 3);
+
+    sc_clock_update(&clock, 10, 20);
+    assert(clock.count == 2);
+    assert(clock.left_sum.system == 2);
+    assert(clock.left_sum.stream == 3);
+    assert(clock.right_sum.system == 10);
+    assert(clock.right_sum.stream == 20);
+
+    sc_clock_update(&clock, 40, 80);
+    assert(clock.count == 3);
+    assert(clock.left_sum.system == 2);
+    assert(clock.left_sum.stream == 3);
+    assert(clock.right_sum.system == 50);
+    assert(clock.right_sum.stream == 100);
+
+    sc_clock_update(&clock, 400, 800);
+    assert(clock.count == 4);
+    assert(clock.left_sum.system == 12);
+    assert(clock.left_sum.stream == 23);
+    assert(clock.right_sum.system == 440);
+    assert(clock.right_sum.stream == 880);
+}
+
+void test_large_rolling_sum(void) {
+    const unsigned half_range = SC_CLOCK_RANGE / 2;
+
+    struct sc_clock clock1;
+    sc_clock_init(&clock1);
+    for (unsigned i = 0; i < 5 * half_range; ++i) {
+        sc_clock_update(&clock1, i, 2 * i + 1);
+    }
+
+    struct sc_clock clock2;
+    sc_clock_init(&clock2);
+    for (unsigned i = 3 * half_range; i < 5 * half_range; ++i) {
+        sc_clock_update(&clock2, i, 2 * i + 1);
+    }
+
+    assert(clock1.count == SC_CLOCK_RANGE);
+    assert(clock2.count == SC_CLOCK_RANGE);
+
+    // The values before the last SC_CLOCK_RANGE points in clock1 should have
+    // no impact
+    assert(clock1.left_sum.system == clock2.left_sum.system);
+    assert(clock1.left_sum.stream == clock2.left_sum.stream);
+    assert(clock1.right_sum.system == clock2.right_sum.system);
+    assert(clock1.right_sum.stream == clock2.right_sum.stream);
+}
+
+int main(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_small_rolling_sum();
+    test_large_rolling_sum();
+    return 0;
+};

app/tests/test_queue.c

@@ -0,0 +1,43 @@
+#include "common.h"
+
+#include <assert.h>
+
+#include "util/queue.h"
+
+struct foo {
+    int value;
+    struct foo *next;
+};
+
+static void test_queue(void) {
+    struct my_queue SC_QUEUE(struct foo) queue;
+    sc_queue_init(&queue);
+
+    assert(sc_queue_is_empty(&queue));
+
+    struct foo v1 = { .value = 42 };
+    struct foo v2 = { .value = 27 };
+
+    sc_queue_push(&queue, next, &v1);
+    sc_queue_push(&queue, next, &v2);
+
+    struct foo *foo;
+
+    assert(!sc_queue_is_empty(&queue));
+    sc_queue_take(&queue, next, &foo);
+    assert(foo->value == 42);
+
+    assert(!sc_queue_is_empty(&queue));
+    sc_queue_take(&queue, next, &foo);
+    assert(foo->value == 27);
+
+    assert(sc_queue_is_empty(&queue));
+}
+
+int main(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_queue();
+    return 0;
+}

app/tests/test_vecdeque.c

@@ -1,197 +0,0 @@
-#include "common.h"
-
-#include <assert.h>
-
-#include "util/vecdeque.h"
-
-#define pr(pv) \
-({ \
-    fprintf(stderr, "cap=%lu origin=%lu size=%lu\n", (pv)->cap, (pv)->origin, (pv)->size); \
-    for (size_t i = 0; i < (pv)->cap; ++i) \
-        fprintf(stderr, "%d ", (pv)->data[i]); \
-    fprintf(stderr, "\n"); \
-})
-
-static void test_vecdeque_push_pop(void) {
-    struct SC_VECDEQUE(int) vdq = SC_VECDEQUE_INITIALIZER;
-
-    assert(sc_vecdeque_is_empty(&vdq));
-    assert(sc_vecdeque_size(&vdq) == 0);
-
-    bool ok = sc_vecdeque_push(&vdq, 5);
-    assert(ok);
-    assert(sc_vecdeque_size(&vdq) == 1);
-
-    ok = sc_vecdeque_push(&vdq, 12);
-    assert(ok);
-    assert(sc_vecdeque_size(&vdq) == 2);
-
-    int v = sc_vecdeque_pop(&vdq);
-    assert(v == 5);
-    assert(sc_vecdeque_size(&vdq) == 1);
-
-    ok = sc_vecdeque_push(&vdq, 7);
-    assert(ok);
-    assert(sc_vecdeque_size(&vdq) == 2);
-
-    int *p = sc_vecdeque_popref(&vdq);
-    assert(p);
-    assert(*p == 12);
-    assert(sc_vecdeque_size(&vdq) == 1);
-
-    v = sc_vecdeque_pop(&vdq);
-    assert(v == 7);
-    assert(sc_vecdeque_size(&vdq) == 0);
-    assert(sc_vecdeque_is_empty(&vdq));
-
-    sc_vecdeque_destroy(&vdq);
-}
-
-static void test_vecdeque_reserve(void) {
-    struct SC_VECDEQUE(int) vdq = SC_VECDEQUE_INITIALIZER;
-
-    bool ok = sc_vecdeque_reserve(&vdq, 20);
-    assert(ok);
-    assert(vdq.cap == 20);
-
-    assert(sc_vecdeque_size(&vdq) == 0);
-
-    for (size_t i = 0; i < 20; ++i) {
-        ok = sc_vecdeque_push(&vdq, i);
-        assert(ok);
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 20);
-
-    // It is now full
-
-    for (int i = 0; i < 5; ++i) {
-        int v = sc_vecdeque_pop(&vdq);
-        assert(v == i);
-    }
-    assert(sc_vecdeque_size(&vdq) == 15);
-
-    for (int i = 20; i < 25; ++i) {
-        ok = sc_vecdeque_push(&vdq, i);
-        assert(ok);
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 20);
-    assert(vdq.cap == 20);
-
-    // Now, the content wraps around the ring buffer:
-    // 20 21 22 23 24  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
-    //                 ^
-    //                 origin
-
-    // It is now full, let's reserve some space
-    ok = sc_vecdeque_reserve(&vdq, 30);
-    assert(ok);
-    assert(vdq.cap == 30);
-
-    assert(sc_vecdeque_size(&vdq) == 20);
-
-    for (int i = 0; i < 20; ++i) {
-        // We should retrieve the items we inserted in order
-        int v = sc_vecdeque_pop(&vdq);
-        assert(v == i + 5);
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 0);
-
-    sc_vecdeque_destroy(&vdq);
-}
-
-static void test_vecdeque_grow() {
-    struct SC_VECDEQUE(int) vdq = SC_VECDEQUE_INITIALIZER;
-
-    bool ok = sc_vecdeque_reserve(&vdq, 20);
-    assert(ok);
-    assert(vdq.cap == 20);
-
-    assert(sc_vecdeque_size(&vdq) == 0);
-
-    for (int i = 0; i < 500; ++i) {
-        ok = sc_vecdeque_push(&vdq, i);
-        assert(ok);
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 500);
-
-    for (int i = 0; i < 100; ++i) {
-        int v = sc_vecdeque_pop(&vdq);
-        assert(v == i);
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 400);
-
-    for (int i = 500; i < 1000; ++i) {
-        ok = sc_vecdeque_push(&vdq, i);
-        assert(ok);
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 900);
-
-    for (int i = 100; i < 1000; ++i) {
-        int v = sc_vecdeque_pop(&vdq);
-        assert(v == i);
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 0);
-
-    sc_vecdeque_destroy(&vdq);
-}
-
-static void test_vecdeque_push_hole() {
-    struct SC_VECDEQUE(int) vdq = SC_VECDEQUE_INITIALIZER;
-
-    bool ok = sc_vecdeque_reserve(&vdq, 20);
-    assert(ok);
-    assert(vdq.cap == 20);
-
-    assert(sc_vecdeque_size(&vdq) == 0);
-
-    for (int i = 0; i < 20; ++i) {
-        int *p = sc_vecdeque_push_hole(&vdq);
-        assert(p);
-        *p = i * 10;
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 20);
-
-    for (int i = 0; i < 10; ++i) {
-        int v = sc_vecdeque_pop(&vdq);
-        assert(v == i * 10);
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 10);
-
-    for (int i = 20; i < 30; ++i) {
-        int *p = sc_vecdeque_push_hole(&vdq);
-        assert(p);
-        *p = i * 10;
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 20);
-
-    for (int i = 10; i < 30; ++i) {
-        int v = sc_vecdeque_pop(&vdq);
-        assert(v == i * 10);
-    }
-
-    assert(sc_vecdeque_size(&vdq) == 0);
-
-    sc_vecdeque_destroy(&vdq);
-}
-
-int main(int argc, char *argv[]) {
-    (void) argc;
-    (void) argv;
-
-    test_vecdeque_push_pop();
-    test_vecdeque_reserve();
-    test_vecdeque_grow();
-    test_vecdeque_push_hole();
-
-    return 0;
-}

cross_win32.txt

@@ -16,6 +16,6 @@ cpu = 'i686'
 endian = 'little'
 
 [properties]
-prebuilt_ffmpeg = 'ffmpeg-6.0-scrcpy-4/win32'
+prebuilt_ffmpeg = 'ffmpeg-6.0-scrcpy/win32'
-prebuilt_sdl2 = 'SDL2-2.28.0/i686-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.26.1/i686-w64-mingw32'
 prebuilt_libusb = 'libusb-1.0.26/libusb-MinGW-Win32'

cross_win64.txt

@@ -16,6 +16,6 @@ cpu = 'x86_64'
 endian = 'little'
 
 [properties]
-prebuilt_ffmpeg = 'ffmpeg-6.0-scrcpy-4/win64'
+prebuilt_ffmpeg = 'ffmpeg-6.0-scrcpy/win64'
-prebuilt_sdl2 = 'SDL2-2.28.0/x86_64-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.26.1/x86_64-w64-mingw32'
 prebuilt_libusb = 'libusb-1.0.26/libusb-MinGW-x64'

doc/audio.md

@@ -1,137 +0,0 @@
-# Audio
-
-Audio forwarding is supported for devices with Android 11 or higher, and it is
-enabled by default:
-
- - For **Android 12 or newer**, it works out-of-the-box.
- - For **Android 11**, you'll need to ensure that the device screen is unlocked
-   when starting scrcpy. A fake popup will briefly appear to make the system
-   think that the shell app is in the foreground. Without this, audio capture
-   will fail.
- - For **Android 10 or earlier**, audio cannot be captured and is automatically
-   disabled.
-
-If audio capture fails, then mirroring continues with video only (since audio is
-enabled by default, it is not acceptable to make scrcpy fail if it is not
-available), unless `--require-audio` is set.
-
-
-## No audio
-
-To disable audio:
-
-```
-scrcpy --no-audio
-```
-
-To disable only the audio playback, see [no playback](video.md#no-playback).
-
-## Audio only
-
-To play audio only, disable the video:
-
-```bash
-scrcpy --no-video
-# interrupt with Ctrl+C
-```
-
-Without video, the audio latency is typically not criticial, so it might be
-interesting to add [buffering](#buffering) to minimize glitches:
-
-```
-scrcpy --no-video --audio-buffer=200
-```
-
-## Source
-
-By default, the device audio output is forwarded.
-
-It is possible to capture the device microphone instead:
-
-```
-scrcpy --audio-source=mic
-```
-
-For example, to use the device as a dictaphone and record a capture directly on
-the computer:
-
-```
-scrcpy --audio-source=mic --no-video --no-playback --record=file.opus
-```
-
-
-## Codec
-
-The audio codec can be selected. The possible values are `opus` (default), `aac`
-and `raw` (uncompressed PCM 16-bit LE):
-
-```bash
-scrcpy --audio-codec=opus  # default
-scrcpy --audio-codec=aac
-scrcpy --audio-codec=raw
-```
-
-Several encoders may be available on the device. They can be listed by:
-
-```bash
-scrcpy --list-encoders
-```
-
-To select a specific encoder:
-
-```
-scrcpy --audio-codec=opus --audio-encoder='c2.android.opus.encoder'
-```
-
-For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
-check `--audio-codec-options` in the manpage or in `scrcpy --help`.
-
-[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
-
-
-## Bit rate
-
-The default video bit-rate is 128Kbps. To change it:
-
-```bash
-scrcpy --audio-bit-rate=64K
-scrcpy --audio-bit-rate=64000  # equivalent
-```
-
-_This parameter does not apply to RAW audio codec (`--audio-codec=raw`)._
-
-
-## Buffering
-
-Audio buffering is unavoidable. It must be kept small enough so that the latency
-is acceptable, but large enough to minimize buffer underrun (causing audio
-glitches).
-
-The default buffer size is set to 50ms. It can be adjusted:
-
-```bash
-scrcpy --audio-buffer=40   # smaller than default
-scrcpy --audio-buffer=100  # higher than default
-```
-
-Note that this option changes the _target_ buffering. It is possible that this
-target buffering might not be reached (on frequent buffer underflow typically).
-
-If you don't interact with the device (to watch a video for example), a higher
-latency (for both [video](video.md#buffering) and audio) might be preferable to
-avoid glitches and smooth the playback:
-
-```
-scrcpy --display-buffer=200 --audio-buffer=200
-```
-
-It is also possible to configure another audio buffer (the audio output buffer),
-by default set to 5ms. Don't change it, unless you get some [robotic and glitchy
-sound][#3793]:
-
-```bash
-# Only if absolutely necessary
-scrcpy --audio-output-buffer=10
-```
-
-[#3793]: https://github.com/Genymobile/scrcpy/issues/3793

doc/control.md

@@ -1,149 +0,0 @@
-# Control
-
-## 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   # short version
-```
-
-
-## Text injection preference
-
-Two kinds of [events][textevents] are 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
-```
-
-(but this will break keyboard behavior in games)
-
-On the contrary, you could force to always inject raw key events:
-
-```bash
-scrcpy --raw-key-events
-```
-
-These options have no effect on HID keyboard (all key events are sent as
-scancodes in this mode).
-
-[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
-[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-
-
-## Copy-paste
-
-Any time the Android clipboard changes, it is automatically synchronized to the
-computer clipboard.
-
-Any <kbd>Ctrl</kbd> shortcut is forwarded to the device. In particular:
- - <kbd>Ctrl</kbd>+<kbd>c</kbd> typically copies
- - <kbd>Ctrl</kbd>+<kbd>x</kbd> typically cuts
- - <kbd>Ctrl</kbd>+<kbd>v</kbd> typically pastes (after computer-to-device
-   clipboard synchronization)
-
-This typically works as you expect.
-
-The actual behavior depends on the active application though. For example,
-_Termux_ sends SIGINT on <kbd>Ctrl</kbd>+<kbd>c</kbd> instead, and _K-9 Mail_
-composes a new message.
-
-To copy, cut and paste in such cases (but only supported on Android >= 7):
- - <kbd>MOD</kbd>+<kbd>c</kbd> injects `COPY`
- - <kbd>MOD</kbd>+<kbd>x</kbd> injects `CUT`
- - <kbd>MOD</kbd>+<kbd>v</kbd> injects `PASTE` (after computer-to-device
-   clipboard synchronization)
-
-In addition, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> injects the computer
-clipboard text as a sequence of key events. This is useful when the component
-does not accept text pasting (for example in _Termux_), but it can break
-non-ASCII content.
-
-**WARNING:** Pasting the computer clipboard to the device (either via
-<kbd>Ctrl</kbd>+<kbd>v</kbd> or <kbd>MOD</kbd>+<kbd>v</kbd>) copies the content
-into the Android clipboard. As a consequence, any Android application could read
-its content. You should avoid pasting sensitive content (like passwords) that
-way.
-
-Some Android devices do not behave as expected when setting the device clipboard
-programmatically. An option `--legacy-paste` is provided to change the behavior
-of <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> so that they
-also inject the computer clipboard text as a sequence of key events (the same
-way as <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
-
-To disable automatic clipboard synchronization, use
-`--no-clipboard-autosync`.
-
-## Pinch-to-zoom
-
-To simulate "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-and-move_.
-
-More precisely, hold down <kbd>Ctrl</kbd> while pressing the left-click button.
-Until the left-click button is released, all mouse movements scale and rotate
-the content (if supported by the app) relative to the center of the screen.
-
-Technically, _scrcpy_ generates additional touch events from a "virtual finger"
-at a location inverted through the center of the screen.
-
-
-## Key repeat
-
-By default, holding a key down generates repeated key events. This can cause
-performance problems in some games, where these events are useless anyway.
-
-To avoid forwarding repeated key events:
-
-```bash
-scrcpy --no-key-repeat
-```
-
-This option has no effect on HID keyboard (key repeat is handled by Android
-directly in this mode).
-
-
-## Right-click and middle-click
-
-By default, right-click triggers BACK (or POWER on) and middle-click triggers
-HOME. To disable these shortcuts and forward the clicks to the device instead:
-
-```bash
-scrcpy --forward-all-clicks
-```
-
-## 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/Download/` 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/Movies/
-```
-
-## Physical keyboard and mouse simulation
-
-See the dedicated [HID/OTG](hid-otg.md) page.

doc/develop.md

@@ -1,488 +0,0 @@
-# scrcpy for developers
-
-## Overview
-
-This application is composed of two parts:
- - the server (`scrcpy-server`), to be executed on the device,
- - the client (the `scrcpy` binary), executed on the host computer.
-
-The client is responsible to push the server to the device and start its
-execution.
-
-The client and the server establish communication using separate sockets for
-video, audio and controls. Any of them may be disabled (but not all), so
-there are 1, 2 or 3 socket(s).
-
-The server initially sends the device name on the first socket (it is used for
-the scrcpy window title), then each socket is used for its own purpose. All
-reads and writes are performed from a dedicated thread for each socket, both on
-the client and on the server.
-
-If video is enabled, then the server sends a raw video stream (H.264 by default)
-of the device screen, with some additional headers for each packet. The client
-decodes the video frames, and displays them as soon as possible, without
-buffering (unless `--display-buffer=delay` is specified) to minimize latency.
-The client is not aware of the device rotation (which is handled by the server),
-it just knows the dimensions of the video frames it receives.
-
-Similarly, if audio is enabled, then the server sends a raw audio stream (OPUS
-by default) of the device audio output (or the microphone if
-`--audio-source=mic` is specified), with some additional headers for each
-packet. The client decodes the stream, attempts to keep a minimal latency by
-maintaining an average buffering. The [blog post][scrcpy2] of the scrcpy v2.0
-release gives more details about the audio feature.
-
-If control is enabled, then the client captures relevant keyboard and mouse
-events, that it transmits to the server, which injects them to the device. This
-is the only socket which is used in both direction: input events are sent from
-the client to the device, and when the device clipboard changes, the new content
-is sent from the device to the client to support seamless copy-paste.
-
-[scrcpy2]: https://blog.rom1v.com/2023/03/scrcpy-2-0-with-audio/
-
-Note that the client-server roles are expressed at the application level:
-
- - the server _serves_ video and audio streams, and handle requests from the
-   client,
- - the client _controls_ the device through the server.
-
-However, by default (when `--force-adb-forward` is not set), the roles are
-reversed at the network level:
-
- - the client opens a server socket and listen on a port before starting the
-   server,
- - the server connects to the client.
-
-This role inversion guarantees that the connection will not fail due to race
-conditions without polling.
-
-
-## Server
-
-
-### Privileges
-
-Capturing the screen requires some privileges, which are granted to `shell`.
-
-The server is a Java application (with a [`public static void main(String...
-args)`][main] method), compiled against the Android framework, and executed as
-`shell` on the Android device.
-
-[main]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Server.java#L193
-
-To run such a Java application, the classes must be [_dexed_][dex] (typically,
-to `classes.dex`). If `my.package.MainClass` is the main class, compiled to
-`classes.dex`, pushed to the device in `/data/local/tmp`, then it can be run
-with:
-
-    adb shell CLASSPATH=/data/local/tmp/classes.dex app_process / my.package.MainClass
-
-_The path `/data/local/tmp` is a good candidate to push the server, since it's
-readable and writable by `shell`, but not world-writable, so a malicious
-application may not replace the server just before the client executes it._
-
-Instead of a raw _dex_ file, `app_process` accepts a _jar_ containing
-`classes.dex` (e.g. an [APK]). For simplicity, and to benefit from the gradle
-build system, the server is built to an (unsigned) APK (renamed to
-`scrcpy-server.jar`).
-
-[dex]: https://en.wikipedia.org/wiki/Dalvik_(software)
-[apk]: https://en.wikipedia.org/wiki/Android_application_package
-
-
-### Hidden methods
-
-Although compiled against the Android framework, [hidden] methods and classes are
-not directly accessible (and they may differ from one Android version to
-another).
-
-They can be called using reflection though. The communication with hidden
-components is provided by [_wrappers_ classes][wrappers] and [aidl].
-
-[hidden]: https://stackoverflow.com/a/31908373/1987178
-[wrappers]: https://github.com/Genymobile/scrcpy/tree/master/server/src/main/java/com/genymobile/scrcpy/wrappers
-[aidl]: https://github.com/Genymobile/scrcpy/tree/master/server/src/main/aidl
-
-
-
-### Execution
-
-The server is started by the client basically by executing the following
-commands:
-
-```bash
-adb push scrcpy-server /data/local/tmp/scrcpy-server.jar
-adb forward tcp:27183 localabstract:scrcpy
-adb shell CLASSPATH=/data/local/tmp/scrcpy-server.jar app_process / com.genymobile.scrcpy.Server 2.1
-```
-
-The first argument (`2.1` in the example) is the client scrcpy version. The
-server fails if the client and the server do not have the exact same version.
-The protocol between the client and the server may change from version to
-version (see [protocol](#protocol) below), and there is no backward or forward
-compatibility (there is no point to use different client and server versions).
-This check allows to detect misconfiguration (running an older or newer server
-by mistake).
-
-It is followed by any number of arguments, in the form of `key=value` pairs.
-Their order is irrelevant. The possible keys and associated value types can be
-found in the [server][server-options] and [client][client-options] code.
-
-[server-options]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Options.java#L181
-[client-options]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/server.c#L226
-
-For example, if we execute `scrcpy -m1920 --no-audio`, then the server
-execution will look like this:
-
-```bash
-# scid is a random number to identify different clients running on the same device
-adb shell CLASSPATH=/data/local/tmp/scrcpy-server.jar app_process / com.genymobile.scrcpy.Server 2.1 scid=12345678 log_level=info audio=false max_size=1920
-```
-
-### Components
-
-When executed, its [`main()`][main] method is executed (on the "main" thread).
-It parses the arguments, establishes the connection with the client and starts
-the other "components":
- - the **video** streamer: it captures the video screen and send encoded video
-   packets on the _video_ socket (from the _video_ thread).
- - the **audio** streamer: it uses several threads to capture raw packets,
-   submits them to encoding and retrieve encoded packets, which it sends on the
-   _audio_ socket.
- - the **controller**: it receives _control messages_ (typically input events)
-   on the _control_ socket from one thread, and sends _device messages_ (e.g. to
-   transmit the device clipboard content to the client) on the same _control
-   socket_ from another thread. Thus, the _control_ socket is used in both
-   directions (contrary to the _video_ and _audio_ sockets).
-
-
-### Screen video encoding
-
-The encoding is managed by [`ScreenEncoder`].
-
-The video is encoded using the [`MediaCodec`] API. The codec encodes the content
-of a `Surface` associated to the display, and writes the encoding packets to the
-client (on the _video_ socket).
-
-[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
-[`MediaCodec`]: https://developer.android.com/reference/android/media/MediaCodec.html
-
-On device rotation (or folding), the encoding session is [reset] and restarted.
-
-New frames are produced only when changes occur on the surface. This avoids to
-send unnecessary frames, but by default there might be drawbacks:
-
- - it does not send any frame on start if the device screen does not change,
- - after fast motion changes, the last frame may have poor quality.
-
-Both problems are [solved][repeat] by the flag
-[`KEY_REPEAT_PREVIOUS_FRAME_AFTER`][repeat-flag].
-
-[reset]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L179
-[rotation]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L90
-[repeat]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L246-L247
-[repeat-flag]: https://developer.android.com/reference/android/media/MediaFormat.html#KEY_REPEAT_PREVIOUS_FRAME_AFTER
-
-
-### Audio encoding
-
-Similarly, the audio is [captured] using an [`AudioRecord`], and [encoded] using
-the [`MediaCodec`] asynchronous API.
-
-More details are available on the [blog post][scrcpy2] introducing the audio feature.
-
-[captured]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/AudioCapture.java
-[encoded]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/AudioEncoder.java
-[`AudioRecord`]: https://developer.android.com/reference/android/media/AudioRecord
-
-
-### Input events injection
-
-_Control messages_ are received from the client by the [`Controller`] (run in a
-separate thread). There are several types of input events:
- - keycode (cf [`KeyEvent`]),
- - text (special characters may not be handled by keycodes directly),
- - mouse motion/click,
- - mouse scroll,
- - other commands (e.g. to switch the screen on or to copy the clipboard).
-
-Some of them need to inject input events to the system. To do so, they use the
-_hidden_ method [`InputManager.injectInputEvent()`] (exposed by the
-[`InputManager` wrapper][inject-wrapper]).
-
-[`Controller`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Controller.java
-[`KeyEvent`]: https://developer.android.com/reference/android/view/KeyEvent.html
-[`MotionEvent`]: https://developer.android.com/reference/android/view/MotionEvent.html
-[`InputManager.injectInputEvent()`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L34
-[inject-wrapper]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27
-
-
-
-## Client
-
-The client relies on [SDL], which provides cross-platform API for UI, input
-events, threading, etc.
-
-The video and audio streams are decoded by [FFmpeg].
-
-[SDL]: https://www.libsdl.org
-[ffmpeg]: https://ffmpeg.org/
-
-
-### Initialization
-
-The client parses the command line arguments, then [runs one of two code
-paths][run]:
- - scrcpy in "normal" mode ([`scrcpy.c`])
- - scrcpy in [OTG mode](hid-otg.md) ([`scrcpy_otg.c`])
-
-[run]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/main.c#L81-L82
-[`scrcpy.c`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/scrcpy.c#L292-L293
-[`scrcpy_otg.c`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/usb/scrcpy_otg.c#L51-L52
-
-In the remaining of this document, we assume that the "normal" mode is used
-(read the code for the OTG mode).
-
-On startup, the client:
- - opens the _video_, _audio_ and _control_ sockets;
- - pushes and starts the server on the device;
- - initializes its components (demuxers, decoders, recorder…).
-
-
-### Video and audio streams
-
-Depending on the arguments passed to `scrcpy`, several components may be used.
-Here is an overview of the video and audio components:
-
-```
-                                                 V4L2 sink
-                                               /
-                                       decoder
-                                     /         \
-        VIDEO -------------> demuxer             display
-                                     \
-                                       recorder
-                                     /
-        AUDIO -------------> demuxer
-                                     \
-                                       decoder --- audio player
-```
-
-The _demuxer_ is responsible to extract video and audio packets (read some
-header, split the video stream into packets at correct boundaries, etc.).
-
-The demuxed packets may be sent to a _decoder_ (one per stream, to produce
-frames) and to a recorder (receiving both video and audio stream to record a
-single file). The packets are encoded on the device (by `MediaCodec`), but when
-recording, they are _muxed_ (asynchronously) into a container (MKV or MP4) on
-the client side.
-
-Video frames are sent to the screen/display to be rendered in the scrcpy window.
-They may also be sent to a [V4L2 sink](v4l2.md).
-
-Audio "frames" (an array of decoded samples) are sent to the audio player.
-
-
-### Controller
-
-The _controller_ is responsible to send _control messages_ to the device. It
-runs in a separate thread, to avoid I/O on the main thread.
-
-On SDL event, received on the main thread, the _input manager_ creates
-appropriate _control messages_. It is responsible to convert SDL events to
-Android events. It then pushes the _control messages_ to a queue hold by the
-controller. On its own thread, the controller takes messages from the queue,
-that it serializes and sends to the client.
-
-
-## Protocol
-
-The protocol between the client and the server must be considered _internal_: it
-may (and will) change at any time for any reason. Everything may change (the
-number of sockets, the order in which the sockets must be opened, the data
-format on the wire…) from version to version. A client must always be run with a
-matching server version.
-
-This section documents the current protocol in scrcpy v2.1.
-
-### Connection
-
-Firstly, the client sets up an adb tunnel:
-
-```bash
-# By default, a reverse redirection: the computer listens, the device connects
-adb reverse localabstract:scrcpy_<SCID> tcp:27183
-
-# As a fallback (or if --force-adb forward is set), a forward redirection:
-# the device listens, the computer connects
-adb forward tcp:27183 localabstract:scrcpy_<SCID>
-```
-
-(`<SCID>` is a 31-bit random number, so that it does not fail when several
-scrcpy instances start "at the same time" for the same device.)
-
-Then, up to 3 sockets are opened, in that order:
- - a _video_ socket
- - an _audio_ socket
- - a _control_ socket
-
-Each one may be disabled (respectively by `--no-video`, `--no-audio` and
-`--no-control`, directly or indirectly). For example, if `--no-audio` is set,
-then the _video_ socket is opened first, then the _control_ socket.
-
-On the _first_ socket opened (whichever it is), if the tunnel is _forward_, then
-a [dummy byte] is sent from the device to the client. This allows to detect a
-connection error (the client connection does not fail as long as there is an adb
-forward redirection, even if nothing is listening on the device side).
-
-Still on this _first_ socket, the device sends some [metadata][device meta] to
-the client (currently only the device name, used as the window title, but there
-might be other fields in the future).
-
-[dummy byte]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java#L93
-[device meta]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java#L151
-
-You can read the [client][client-connection] and [server][server-connection]
-code for more details.
-
-[client-connection]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/server.c#L465-L466
-[server-connection]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java#L63
-
-Then each socket is used for its intended purpose.
-
-### Video and audio
-
-On the _video_ and _audio_ sockets, the device first sends some [codec
-metadata]:
- - On the _video_ socket, 12 bytes:
-   - the codec id (`u32`) (H264, H265 or AV1)
-   - the initial video width (`u32`)
-   - the initial video height (`u32`)
- - On the _audio_ socket, 4 bytes:
-   - the codec id ('u32`) (OPUS, AAC or RAW)
-
-[codec metadata]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Streamer.java#L33-L51
-
-Then each packet produced by `MediaCodec` is sent, prefixed by a 12-byte [frame
-header]:
- - config packet flag (`u1`)
- - key frame flag (`u1`)
- - PTS (`u62`)
- - packet size (`u32`)
-
-Here is a schema describing the frame header:
-
-```
-    [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
-     <-------------> <-----> <-----------------------------...
-           PTS        packet        raw packet
-                       size
-     <--------------------->
-           frame header
-
-The most significant bits of the PTS are used for packet flags:
-
-     byte 7   byte 6   byte 5   byte 4   byte 3   byte 2   byte 1   byte 0
-    CK...... ........ ........ ........ ........ ........ ........ ........
-    ^^<------------------------------------------------------------------->
-    ||                                PTS
-    | `- key frame
-     `-- config packet
-```
-
-[frame header]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Streamer.java#L83
-
-
-### Controls
-
-Controls messages are sent via a custom binary protocol.
-
-The only documentation for this protocol is the set of unit tests on both sides:
- - `ControlMessage` (from client to device): [serialization](https://github.com/Genymobile/scrcpy/blob/master/app/tests/test_control_msg_serialize.c) | [deserialization](https://github.com/Genymobile/scrcpy/blob/master/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java)
- - `DeviceMessage` (from device to client) [serialization](https://github.com/Genymobile/scrcpy/blob/master/server/src/test/java/com/genymobile/scrcpy/DeviceMessageWriterTest.java) | [deserialization](https://github.com/Genymobile/scrcpy/blob/master/app/tests/test_device_msg_deserialize.c)
-
-
-## Standalone server
-
-Although the server is designed to work for the scrcpy client, it can be used
-with any client which uses the same protocol.
-
-For simplicity, some [server-specific options] have been added to produce raw
-streams easily:
- - `send_device_meta=false`: disable the device metata (in practice, the device
-   name) sent on the _first_ socket
- - `send_frame_meta=false`: disable the 12-byte header for each packet
- - `send_dummy_byte`: disable the dummy byte sent on forward connections
- - `send_codec_meta`: disable the codec information (and initial device size for
-   video)
- - `raw_stream`: disable all the above
-
-[server-specific options]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Options.java#L309-L329
-
-Concretely, here is how to expose a raw H.264 stream on a TCP socket:
-
-```bash
-adb push scrcpy-server-v2.1 /data/local/tmp/scrcpy-server-manual.jar
-adb forward tcp:1234 localabstract:scrcpy
-adb shell CLASSPATH=/data/local/tmp/scrcpy-server-manual.jar \
-    app_process / com.genymobile.scrcpy.Server 2.1 \
-    tunnel_forward=true audio=false control=false cleanup=false \
-    raw_stream=true max_size=1920
-```
-
-As soon as a client connects over TCP on port 1234, the device will start
-streaming the video. For example, VLC can play the video (although you will
-experience a very high latency, more details [here][vlc-0latency]):
-
-```
-vlc -Idummy --demux=h264 --network-caching=0 tcp://localhost:1234
-```
-
-[vlc-0latency]: https://code.videolan.org/rom1v/vlc/-/merge_requests/20
-
-
-## Hack
-
-For more details, go read the code!
-
-If you find a bug, or have an awesome idea to implement, please discuss and
-contribute ;-)
-
-
-### Debug the server
-
-The server is pushed to the device by the client on startup.
-
-To debug it, enable the server debugger during configuration:
-
-```bash
-meson setup x -Dserver_debugger=true
-# or, if x is already configured
-meson configure x -Dserver_debugger=true
-```
-
-If your device runs Android 8 or below, set the `server_debugger_method` to
-`old` in addition:
-
-```bash
-meson setup x -Dserver_debugger=true -Dserver_debugger_method=old
-# or, if x is already configured
-meson configure x -Dserver_debugger=true -Dserver_debugger_method=old
-```
-
-Then recompile.
-
-When you start scrcpy, it will start a debugger on port 5005 on the device.
-Redirect that port to the computer:
-
-```bash
-adb forward tcp:5005 tcp:5005
-```
-
-In Android Studio, _Run_ > _Debug_ > _Edit configurations..._ On the left, click on
-`+`, _Remote_, and fill the form:
-
- - Host: `localhost`
- - Port: `5005`
-
-Then click on _Debug_.

doc/device.md

@@ -1,228 +0,0 @@
-# Device
-
-## Selection
-
-If exactly one device is connected (i.e. listed by `adb devices`), then it is
-automatically selected.
-
-However, if there are multiple devices connected, you must specify the one to
-use in one of 4 ways:
- - by its serial:
-   ```bash
-   scrcpy --serial=0123456789abcdef
-   scrcpy -s 0123456789abcdef   # short version
-
-   # the serial is the ip:port if connected over TCP/IP (same behavior as adb)
-   scrcpy --serial=192.168.1.1:5555
-   ```
- - the one connected over USB (if there is exactly one):
-   ```bash
-   scrcpy --select-usb
-   scrcpy -d   # short version
-   ```
- - the one connected over TCP/IP (if there is exactly one):
-   ```bash
-   scrcpy --select-tcpip
-   scrcpy -e   # short version
-   ```
- - a device already listening on TCP/IP (see [below](#tcpip-wireless)):
-   ```bash
-   scrcpy --tcpip=192.168.1.1:5555
-   scrcpy --tcpip=192.168.1.1        # default port is 5555
-   ```
-
-The serial may also be provided via the environment variable `ANDROID_SERIAL`
-(also used by `adb`):
-
-```bash
-# in bash
-export ANDROID_SERIAL=0123456789abcdef
-scrcpy
-```
-
-```cmd
-:: in cmd
-set ANDROID_SERIAL=0123456789abcdef
-scrcpy
-```
-
-```powershell
-# in PowerShell
-$env:ANDROID_SERIAL = '0123456789abcdef'
-scrcpy
-```
-
-
-## TCP/IP (wireless)
-
-_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
-device over TCP/IP. The device must be connected on the same network as the
-computer.
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-### Automatic
-
-An option `--tcpip` allows to configure the connection automatically. There are
-two variants.
-
-If the device (accessible at 192.168.1.1 in this example) already listens on a
-port (typically 5555) for incoming _adb_ connections, then run:
-
-```bash
-scrcpy --tcpip=192.168.1.1       # default port is 5555
-scrcpy --tcpip=192.168.1.1:5555
-```
-
-If _adb_ TCP/IP mode is disabled on the device (or if you don't know the IP
-address), connect the device over USB, then run:
-
-```bash
-scrcpy --tcpip   # without arguments
-```
-
-It will automatically find the device IP address and adb port, enable TCP/IP
-mode if necessary, then connect to the device before starting.
-
-
-### Manual
-
-Alternatively, it is possible to enable the TCP/IP connection manually using
-`adb`:
-
-1. Plug the device into a USB port on your computer.
-2. Connect the device to the same Wi-Fi network as your computer.
-3. Get your device IP address, in Settings → About phone → Status, or by
-   executing this command:
-
-    ```bash
-    adb shell ip route | awk '{print $9}'
-    ```
-
-4. Enable `adb` over TCP/IP on your device: `adb tcpip 5555`.
-5. Unplug your device.
-6. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`
-with the device IP address you found)_.
-7. Run `scrcpy` as usual.
-8. Run `adb disconnect` once you're done.
-
-Since Android 11, a [wireless debugging option][adb-wireless] allows to bypass
-having to physically connect your device directly to your computer.
-
-[adb-wireless]: https://developer.android.com/studio/command-line/adb#wireless-android11-command-line
-
-
-## Autostart
-
-A small tool (by the scrcpy author) allows to run arbitrary commands whenever a
-new Android device is connected: [AutoAdb]. It can be used to start scrcpy:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
-
-
-## Display
-
-If several displays are available on the Android device, it is possible to
-select the display to mirror:
-
-```bash
-scrcpy --display=1
-```
-
-The list of display ids can be retrieved by:
-
-```bash
-scrcpy --list-displays
-```
-
-A secondary display may only be controlled if the device runs at least Android
-10 (otherwise it is mirrored as read-only).
-
-
-## Actions
-
-Some command line arguments perform actions on the device itself while scrcpy is
-running.
-
-
-### Stay awake
-
-To prevent the device from sleeping after a delay **when the device is plugged
-in**:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w
-```
-
-The initial state is restored when _scrcpy_ is closed.
-
-If the device is not plugged in (i.e. only connected over TCP/IP),
-`--stay-awake` has no effect (this is the Android behavior).
-
-
-### 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   # short version
-```
-
-Or by pressing <kbd>MOD</kbd>+<kbd>o</kbd> at any time (see
-[shortcuts](shortcuts.md)).
-
-To turn it back on, press <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
-
-On Android, the `POWER` button always turns the screen on. For convenience, if
-`POWER` is sent via _scrcpy_ (via right-click or <kbd>MOD</kbd>+<kbd>p</kbd>),
-it will force to turn the screen off after a small delay (on a best effort
-basis). The physical `POWER` button will still cause the screen to be turned on.
-
-It can also be useful to prevent the device from sleeping:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw   # short version
-```
-
-
-### Show touches
-
-For presentations, it may be useful to show physical touches (on the physical
-device). Android exposes 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   # short version
-```
-
-Note that it only shows _physical_ touches (by a finger on the device).
-
-
-### Power off on close
-
-To turn the device screen off when closing _scrcpy_:
-
-```bash
-scrcpy --power-off-on-close
-```
-
-### Power on on start
-
-By default, on start, the device is powered on. To prevent this behavior:
-
-```bash
-scrcpy --no-power-on
-```
-

doc/hid-otg.md

@@ -1,108 +0,0 @@
-# HID/OTG
-
-By default, _scrcpy_ injects input events at the Android API level. As an
-alternative, when connected over USB, it is possible to send HID events, so that
-scrcpy behaves as if it was a physical keyboard and/or mouse connected to the
-Android device.
-
-A special [OTG](#otg) mode allows to control the device without mirroring (and
-without USB debugging).
-
-
-## Physical keyboard simulation
-
-By default, _scrcpy_ uses Android key or text injection. It works everywhere,
-but is limited to ASCII.
-
-Instead, it can simulate a physical USB keyboard on Android to provide a better
-input experience (using [USB HID over AOAv2][hid-aoav2]): the virtual keyboard
-is disabled and it works for all characters and IME.
-
-[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
-
-However, it only works if the device is connected via USB.
-
-Note: On Windows, it may only work in [OTG mode](#otg), not while mirroring (it
-is not possible to open a USB device if it is already open by another process
-like the _adb daemon_).
-
-To enable this mode:
-
-```bash
-scrcpy --hid-keyboard
-scrcpy -K   # short version
-```
-
-If it fails for some reason (for example because the device is not connected via
-USB), it automatically fallbacks to the default mode (with a log in the
-console). This allows using the same command line options when connected over
-USB and TCP/IP.
-
-In this mode, raw key events (scancodes) are sent to the device, independently
-of the host key mapping. Therefore, if your keyboard layout does not match, it
-must be configured on the Android device, in Settings → System → Languages and
-input → [Physical keyboard].
-
-This settings page can be started directly:
-
-```bash
-adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
-```
-
-However, the option is only available when the HID keyboard is enabled (or when
-a physical keyboard is connected).
-
-[Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
-
-
-## Physical mouse simulation
-
-By default, _scrcpy_ uses Android mouse events injection with absolute
-coordinates. By simulating a physical mouse, a mouse pointer appears on the
-Android device, and relative mouse motion, clicks and scrolls are injected.
-
-To enable this mode:
-
-```bash
-scrcpy --hid-mouse
-scrcpy -M   # short version
-```
-
-When this mode is enabled, the computer mouse is "captured" (the mouse pointer
-disappears from the computer and appears on the Android device instead).
-
-Special capture keys, either <kbd>Alt</kbd> or <kbd>Super</kbd>, toggle
-(disable or enable) the mouse capture. Use one of them to give the control of
-the mouse back to the computer.
-
-
-## OTG
-
-It is possible to run _scrcpy_ with only physical keyboard and mouse simulation
-(HID), as if the computer keyboard and mouse were plugged directly to the device
-via an OTG cable.
-
-In this mode, `adb` (USB debugging) is not necessary, and mirroring is disabled.
-
-This is similar to `--hid-keyboard --hid-mouse`, but without mirroring.
-
-To enable OTG mode:
-
-```bash
-scrcpy --otg
-# Pass the serial if several USB devices are available
-scrcpy --otg -s 0123456789abcdef
-```
-
-It is possible to enable only HID keyboard or HID mouse:
-
-```bash
-scrcpy --otg --hid-keyboard              # keyboard only
-scrcpy --otg --hid-mouse                 # mouse only
-scrcpy --otg --hid-keyboard --hid-mouse  # keyboard and mouse
-# for convenience, enable both by default
-scrcpy --otg                             # keyboard and mouse
-```
-
-Like `--hid-keyboard` and `--hid-mouse`, it only works if the device is
-connected over USB.

doc/linux.md

@@ -1,81 +0,0 @@
-# On Linux
-
-## Install
-
-<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
-
-Scrcpy is packaged in several distributions and package managers:
-
- - Debian/Ubuntu: `apt install scrcpy`
- - Arch Linux: `pacman -S scrcpy`
- - Fedora: `dnf copr enable zeno/scrcpy && dnf install scrcpy`
- - Gentoo: [ebuild][ebuild-link] file
- - Snap: `snap install scrcpy`
- - … (see [repology](https://repology.org/project/scrcpy/versions))
-
-[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-
-### Latest version
-
-However, the packaged version is not always the latest release. To install the
-latest release from `master`, follow this simplified process.
-
-First, you need to install the required packages:
-
-```bash
-# for Debian/Ubuntu
-sudo apt install ffmpeg libsdl2-2.0-0 adb wget \
-                 gcc git pkg-config meson ninja-build libsdl2-dev \
-                 libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
-                 libswresample-dev libusb-1.0-0 libusb-1.0-0-dev
-```
-
-Then clone the repo and execute the installation script
-([source](/install_release.sh)):
-
-```bash
-git clone https://github.com/Genymobile/scrcpy
-cd scrcpy
-./install_release.sh
-```
-
-When a new release is out, update the repo and reinstall:
-
-```bash
-git pull
-./install_release.sh
-```
-
-To uninstall:
-
-```bash
-sudo ninja -Cbuild-auto uninstall
-```
-
-_Note that this simplified process only works for released versions (it
-downloads a prebuilt server binary), so for example you can't use it for testing
-the development branch (`dev`)._
-
-_See [build.md](build.md) to build and install the app manually._
-
-
-## Run
-
-_Make sure that your device meets the [prerequisites](/README.md#prerequisites)._
-
-Once installed, run from a terminal:
-
-```bash
-scrcpy
-```
-
-or with arguments (here to disable audio and record to `file.mkv`):
-
-```bash
-scrcpy --no-audio --record=file.mkv
-```
-
-Documentation for command line arguments is available:
- - `man scrcpy`
- - `scrcpy --help`
- - on [github](/README.md)

doc/macos.md

@@ -1,49 +0,0 @@
-# On macOS
-
-## Install
-
-Scrcpy is available in [Homebrew]:
-
-```bash
-brew install scrcpy
-```
-
-[Homebrew]: https://brew.sh/
-
-You need `adb`, accessible from your `PATH`. If you don't have it yet:
-
-```bash
-brew install android-platform-tools
-```
-
-Alternatively, Scrcpy is also available in [MacPorts], which sets up `adb` for you:
-
-```bash
-sudo port install scrcpy
-```
-
-[MacPorts]: https://www.macports.org/
-
-_See [build.md](build.md) to build and install the app manually._
-
-
-## Run
-
-_Make sure that your device meets the [prerequisites](/README.md#prerequisites)._
-
-Once installed, run from a terminal:
-
-```bash
-scrcpy
-```
-
-or with arguments (here to disable audio and record to `file.mkv`):
-
-```bash
-scrcpy --no-audio --record=file.mkv
-```
-
-Documentation for command line arguments is available:
- - `man scrcpy`
- - `scrcpy --help`
- - on [github](/README.md)

doc/recording.md

@@ -1,78 +0,0 @@
-# Recording
-
-To record video and audio streams while mirroring:
-
-```bash
-scrcpy --record=file.mp4
-scrcpy -r file.mkv
-```
-
-To record only the video:
-
-```bash
-scrcpy --no-audio --record=file.mp4
-```
-
-To record only the audio:
-
-```bash
-scrcpy --no-video --record=file.opus
-scrcpy --no-video --audio-codec=aac --record=file.aac
-# .m4a/.mp4 and .mka/.mkv are also supported for both opus and aac
-```
-
-Timestamps are captured on the device, so [packet delay variation] does not
-impact the recorded file, which is always clean (only if you use `--record` of
-course, not if you capture your scrcpy window and audio output on the computer).
-
-[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-
-## Format
-
-The video and audio streams are encoded on the device, but are muxed on the
-client side. Two formats (containers) are supported:
- - Matroska (`.mkv`)
- - MP4 (`.mp4`)
-
-The container is automatically selected based on the filename.
-
-It is also possible to explicitly select a container (in that case the filename
-needs not end with `.mkv` or `.mp4`):
-
-```
-scrcpy --record=file --record-format=mkv
-```
-
-
-## No playback
-
-To disable playback while recording:
-
-```bash
-scrcpy --no-playback --record=file.mp4
-scrcpy -Nr file.mkv
-# interrupt recording with Ctrl+C
-```
-
-It is also possible to disable video and audio playback separately:
-
-```bash
-# Record both video and audio, but only play video
-scrcpy --record=file.mkv --no-audio-playback
-```
-
-## Time limit
-
-To limit the recording time:
-
-```bash
-scrcpy --record=file.mkv --time-limit=20  # in seconds
-```
-
-The `--time-limit` option is not limited to recording, it also impacts simple
-mirroring:
-
-```
-scrcpy --time-limit=20
-```

doc/shortcuts.md

@@ -1,68 +0,0 @@
-# Shortcuts
-
-Actions can be performed on the scrcpy window using keyboard and mouse
-shortcuts.
-
-In the following list, <kbd>MOD</kbd> is the shortcut modifier. By default, it's
-(left) <kbd>Alt</kbd> or (left) <kbd>Super</kbd>.
-
-It can be changed using `--shortcut-mod`. Possible keys are `lctrl`, `rctrl`,
-`lalt`, `ralt`, `lsuper` and `rsuper`. For example:
-
-```bash
-# use RCtrl for shortcuts
-scrcpy --shortcut-mod=rctrl
-
-# use either LCtrl+LAlt or LSuper for shortcuts
-scrcpy --shortcut-mod=lctrl+lalt,lsuper
-```
-
-_<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
-
-[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
-
- | Action                                      |   Shortcut
- | ------------------------------------------- |:-----------------------------
- | Switch fullscreen mode                      | <kbd>MOD</kbd>+<kbd>f</kbd>
- | Rotate display left                         | <kbd>MOD</kbd>+<kbd>←</kbd> _(left)_
- | Rotate display right                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(right)_
- | Resize window to 1:1 (pixel-perfect)        | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Resize window to remove black borders       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Double-left-click¹_
- | Click on `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Middle-click_
- | Click on `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Right-click²_
- | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4th-click³_
- | Click on `MENU` (unlock screen)⁴            | <kbd>MOD</kbd>+<kbd>m</kbd>
- | Click on `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(up)_
- | Click on `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(down)_
- | Click on `POWER`                            | <kbd>MOD</kbd>+<kbd>p</kbd>
- | Power on                                    | _Right-click²_
- | Turn device screen off (keep mirroring)     | <kbd>MOD</kbd>+<kbd>o</kbd>
- | Turn device screen on                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
- | Rotate device screen                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5th-click³_
- | Expand settings panel                       | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Double-5th-click³_
- | Collapse panels                             | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copy to clipboard⁵                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Cut to clipboard⁵                           | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Synchronize clipboards and paste⁵           | <kbd>MOD</kbd>+<kbd>v</kbd>
- | Inject computer clipboard text              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
- | Enable/disable FPS counter (on stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Pinch-to-zoom                               | <kbd>Ctrl</kbd>+_click-and-move_
- | Drag & drop APK file                        | Install APK from computer
- | Drag & drop non-APK file                    | [Push file to device](control.md#push-file-to-device)
-
-_¹Double-click on black borders to remove them._  
-_²Right-click turns the screen on if it was off, presses BACK otherwise._  
-_³4th and 5th mouse buttons, if your mouse has them._  
-_⁴For react-native apps in development, `MENU` triggers development menu._  
-_⁵Only on Android >= 7._
-
-Shortcuts with repeated keys are executed by releasing and pressing the key a
-second time. For example, to execute "Expand settings panel":
-
- 1. Press and keep pressing <kbd>MOD</kbd>.
- 2. Then double-press <kbd>n</kbd>.
- 3. Finally, release <kbd>MOD</kbd>.
-
-All <kbd>Ctrl</kbd>+_key_ shortcuts are forwarded to the device, so they are
-handled by the active application.

doc/tunnels.md

@@ -1,123 +0,0 @@
-# Tunnels
-
-Scrcpy is designed to mirror local Android devices. Tunnels allow to connect to
-a remote device (e.g. over the Internet).
-
-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).
-
-
-## Remote ADB server
-
-To connect to a remote _adb server_, make the server listen on all interfaces:
-
-```bash
-adb kill-server
-adb -a nodaemon server start
-# keep this open
-```
-
-**Warning: all communications between clients and the _adb server_ are
-unencrypted.**
-
-Suppose that this server is accessible at 192.168.1.2. Then, from another
-terminal, run `scrcpy`:
-
-```bash
-# in bash
-export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
-scrcpy --tunnel-host=192.168.1.2
-```
-
-```cmd
-:: in cmd
-set ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
-scrcpy --tunnel-host=192.168.1.2
-```
-
-```powershell
-# in PowerShell
-$env:ADB_SERVER_SOCKET = 'tcp:192.168.1.2:5037'
-scrcpy --tunnel-host=192.168.1.2
-```
-
-By default, `scrcpy` uses the local port used for `adb forward` tunnel
-establishment (typically `27183`, see `--port`). It is also possible to force a
-different tunnel port (it may be useful in more complex situations, when more
-redirections are involved):
-
-```
-scrcpy --tunnel-port=1234
-```
-
-
-## SSH tunnel
-
-To communicate with a remote _adb server_ securely, it is preferable to use an
-SSH tunnel.
-
-First, make sure the _adb server_ is running on the remote computer:
-
-```bash
-adb start-server
-```
-
-Then, establish an SSH tunnel:
-
-```bash
-# local  5038 --> remote  5037
-# local 27183 <-- remote 27183
-ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# keep this open
-```
-
-From another terminal, run `scrcpy`:
-
-```bash
-# in bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
-scrcpy
-```
-
-```cmd
-:: in cmd
-set ADB_SERVER_SOCKET=tcp:localhost:5038
-scrcpy
-```
-
-```powershell
-# in PowerShell
-$env:ADB_SERVER_SOCKET = 'tcp:localhost:5038'
-scrcpy
-```
-
-To avoid enabling remote port forwarding, you could force a forward connection
-instead (notice the `-L` instead of `-R`):
-
-```bash
-# local  5038 --> remote  5037
-# local 27183 --> remote 27183
-ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
-# keep this open
-```
-
-From another terminal, run `scrcpy`:
-
-```bash
-# in bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
-scrcpy --force-adb-forward
-```
-
-```cmd
-:: in cmd
-set ADB_SERVER_SOCKET=tcp:localhost:5038
-scrcpy --force-adb-forward
-```
-
-```powershell
-# in PowerShell
-$env:ADB_SERVER_SOCKET = 'tcp:localhost:5038'
-scrcpy --force-adb-forward
-```

doc/v4l2.md

@@ -1,65 +0,0 @@
-# Video4Linux
-
-On Linux, it is possible to send the video stream to a [v4l2] loopback device,
-so that the Android device can be opened like a webcam by any v4l2-capable tool.
-
-[v4l2]: https://en.wikipedia.org/wiki/Video4Linux
-
-The module `v4l2loopback` must be installed:
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-To create a v4l2 device:
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-This will create a new video device in `/dev/videoN`, where `N` is an integer
-(more [options](https://github.com/umlaeute/v4l2loopback#options) are available
-to create several devices or devices with specific IDs).
-
-To list the enabled devices:
-
-```bash
-# requires v4l-utils package
-v4l2-ctl --list-devices
-
-# simple but might be sufficient
-ls /dev/video*
-```
-
-To start `scrcpy` using a v4l2 sink:
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-video-playback  # disable playback window
-```
-
-(replace `N` with the device ID, check with `ls /dev/video*`)
-
-Once enabled, you can open your video stream with a v4l2-capable tool:
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLC might add some buffering delay
-```
-
-For example, you could capture the video within [OBS] or within your video
-conference tool.
-
-[OBS]: https://obsproject.com/
-
-
-## Buffering
-
-By default, there is no video buffering, to get the lowest possible latency.
-
-As for the [video display](video.md#buffering), it is possible to add
-buffering to delay the v4l2 stream:
-
-```bash
-scrcpy --v4l2-buffer=300     # add 300ms buffering for v4l2 sink
-```

doc/video.md

@@ -1,196 +0,0 @@
-# Video
-
-## Size
-
-By default, scrcpy attempts to mirror at the Android device resolution.
-
-It might be useful to mirror at a lower definition to increase performance. To
-limit both width and height to some maximum value (here 1024):
-
-```bash
-scrcpy --max-size=1024
-scrcpy -m 1024   # short version
-```
-
-The other dimension is computed so that the Android device aspect ratio is
-preserved. That way, a device in 1920×1080 will be mirrored at 1024×576.
-
-If encoding fails, scrcpy automatically tries again with a lower definition
-(unless `--no-downsize-on-error` is enabled).
-
-
-## Bit rate
-
-The default video bit-rate is 8 Mbps. To change it:
-
-```bash
-scrcpy --video-bit-rate=2M
-scrcpy --video-bit-rate=2000000  # equivalent
-scrcpy -b 2M                     # short version
-```
-
-
-## Frame rate
-
-The capture frame rate can be limited:
-
-```bash
-scrcpy --max-fps=15
-```
-
-The actual capture frame rate may be printed to the console:
-
-```
-scrcpy --print-fps
-```
-
-It may also be enabled or disabled at anytime with <kbd>MOD</kbd>+<kbd>i</kbd>
-(see [shortcuts](shortcuts.md)).
-
-The frame rate is intrinsically variable: a new frame is produced only when the
-screen content changes. For example, if you play a fullscreen video at 24fps on
-your device, you should not get more than 24 frames per second in scrcpy.
-
-
-## Codec
-
-The video codec can be selected. The possible values are `h264` (default),
-`h265` and `av1`:
-
-```bash
-scrcpy --video-codec=h264  # default
-scrcpy --video-codec=h265
-scrcpy --video-codec=av1
-```
-
-H265 may provide better quality, but H264 should provide lower latency.
-AV1 encoders are not common on current Android devices.
-
-Several encoders may be available on the device. They can be listed by:
-
-```bash
-scrcpy --list-encoders
-```
-
-Sometimes, the default encoder may have issues or even crash, so it is useful to
-try another one:
-
-```bash
-scrcpy --video-codec=h264 --video-encoder='OMX.qcom.video.encoder.avc'
-```
-
-For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
-check `--video-codec-options` in the manpage or in `scrcpy --help`.
-
-[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
-
-
-## Rotation
-
-The rotation may be applied at 3 different levels:
- - The [shortcut](shortcuts.md) <kbd>MOD</kbd>+<kbd>r</kbd> requests the
-   device to switch between portrait and landscape (the current running app may
-   refuse, if it does not 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` rotates only the window content. This only affects the display,
-   not the recording. It may be changed dynamically at any time using the
-   [shortcuts](shortcuts.md) <kbd>MOD</kbd>+<kbd>←</kbd> and
-   <kbd>MOD</kbd>+<kbd>→</kbd>.
-
-To lock the mirroring orientation:
-
-```bash
-scrcpy --lock-video-orientation     # initial (current) orientation
-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
-```
-
-To set an initial window rotation:
-
-```bash
-scrcpy --rotation=0   # no rotation
-scrcpy --rotation=1   # 90 degrees counterclockwise
-scrcpy --rotation=2   # 180 degrees
-scrcpy --rotation=3   # 90 degrees clockwise
-```
-
-## 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)
-```
-
-The values are expressed in the device natural orientation (portrait for a
-phone, landscape for a tablet).
-
-If `--max-size` is also specified, resizing is applied after cropping.
-
-
-## Buffering
-
-By default, there is no video buffering, to get the lowest possible latency.
-
-Buffering can be added to delay the video stream and compensate for jitter to
-get a smoother playback (see [#2464]).
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-The configuration is available independently for the display,
-[v4l2 sinks](video.md#video4linux) and [audio](audio.md#buffering) playback.
-
-```bash
-scrcpy --display-buffer=50   # add 50ms buffering for display
-scrcpy --v4l2-buffer=300     # add 300ms buffering for v4l2 sink
-scrcpy --audio-buffer=200    # set 200ms buffering for audio playback
-```
-
-They can be applied simultaneously:
-
-```bash
-scrcpy --display-buffer=50 --v4l2-buffer=300
-```
-
-
-## No playback
-
-It is possible to capture an Android device without playing video or audio on
-the computer. This option is useful when [recording](recording.md) or when
-[v4l2](#video4linux) is enabled:
-
-```bash
-scrcpy --v4l2-sink=/dev/video2 --no-playback
-scrcpy --record=file.mkv --no-playback
-# interrupt with Ctrl+C
-```
-
-It is also possible to disable video and audio playback separately:
-
-```bash
-# Send video to V4L2 sink without playing it, but keep audio playback
-scrcpy --v4l2-sink=/dev/video2 --no-video-playback
-
-# Record both video and audio, but only play video
-scrcpy --record=file.mkv --no-audio-playback
-```
-
-
-## No video
-
-To disable video forwarding completely, so that only audio is forwarded:
-
-```
-scrcpy --no-video
-```
-
-
-## Video4Linux
-
-See the dedicated [Video4Linux](v4l2.md) page.

doc/window.md

@@ -1,55 +0,0 @@
-# Window
-
-## 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 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 mode can then be toggled dynamically with <kbd>MOD</kbd>+<kbd>f</kbd>
-(see [shortcuts](shortcuts.md)).
-
-
-## Disable screensaver
-
-By default, _scrcpy_ does not prevent the screensaver from running on the
-computer. To disable it:
-
-```bash
-scrcpy --disable-screensaver
-```