Add support for AAC audio codec

Add option --audio-codec=aac.

BUILD.md

@@ -260,7 +260,7 @@ set ANDROID_SDK_ROOT=%LOCALAPPDATA%\Android\sdk
 Then, build:
 
 ```bash
-meson x --buildtype=release --strip -Db_lto=true
+meson setup x --buildtype=release --strip -Db_lto=true
 ninja -Cx  # DO NOT RUN AS ROOT
 ```
 
@@ -272,16 +272,16 @@ install` must be run as root)._
 
 #### Option 2: Use prebuilt server
 
- - [`scrcpy-server-v1.24`][direct-scrcpy-server]  
-   <sub>SHA-256: `ae74a81ea79c0dc7250e586627c278c0a9a8c5de46c9fb5c38c167fb1a36f056`</sub>
+ - [`scrcpy-server-v1.25`][direct-scrcpy-server]  
+   <sub>SHA-256: `ce0306c7bbd06ae72f6d06f7ec0ee33774995a65de71e0a83813ecb67aec9bdb`</sub>
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-server-v1.24
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.25/scrcpy-server-v1.25
 
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
 
 ```bash
-meson x --buildtype=release --strip -Db_lto=true \
+meson setup x --buildtype=release --strip -Db_lto=true \
     -Dprebuilt_server=/path/to/scrcpy-server
 ninja -Cx  # DO NOT RUN AS ROOT
 ```

DEVELOP.md

@@ -277,7 +277,7 @@ The server is pushed to the device by the client on startup.
 To debug it, enable the server debugger during configuration:
 
 ```bash
-meson x -Dserver_debugger=true
+meson setup x -Dserver_debugger=true
 # or, if x is already configured
 meson configure x -Dserver_debugger=true
 ```
@@ -286,7 +286,7 @@ If your device runs Android 8 or below, set the `server_debugger_method` to
 `old` in addition:
 
 ```bash
-meson x -Dserver_debugger=true -Dserver_debugger_method=old
+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
 ```

README.md

@@ -1,4 +1,4 @@
-# scrcpy (v1.24)
+# scrcpy (v1.25)
 
 <img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
 
@@ -106,10 +106,10 @@ process][BUILD_simple]).
 For Windows, a prebuilt archive with all the dependencies (including `adb`) is
 available:
 
- - [`scrcpy-win64-v1.24.zip`][direct-win64]  
-   <sub>SHA-256: `6ccb64cba0a3e75715e85a188daeb4f306a1985f8ce123eba92ba74fc9b27367`</sub>
+ - [`scrcpy-win64-v1.25.zip`][direct-win64]  
+   <sub>SHA-256: `db65125e9c65acd00359efb7cea9c05f63cc7ccd5833000cd243cc92f5053028`</sub>
 
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-win64-v1.24.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.25/scrcpy-win64-v1.25.zip
 
 It is also available in [Chocolatey]:
 
@@ -186,7 +186,7 @@ increase performance.
 To limit both the width and height to some value (e.g. 1024):
 
 ```bash
-scrcpy --max-size 1024
+scrcpy --max-size=1024
 scrcpy -m 1024  # short version
 ```
 
@@ -199,7 +199,7 @@ preserved. That way, a device in 1920×1080 will be mirrored at 1024×576.
 The default bit-rate is 8 Mbps. To change the video bitrate (e.g. to 2 Mbps):
 
 ```bash
-scrcpy --bit-rate 2M
+scrcpy --bit-rate=2M
 scrcpy -b 2M  # short version
 ```
 
@@ -208,7 +208,7 @@ scrcpy -b 2M  # short version
 The capture frame rate can be limited:
 
 ```bash
-scrcpy --max-fps 15
+scrcpy --max-fps=15
 ```
 
 This is officially supported since Android 10, but may work on earlier versions.
@@ -229,7 +229,7 @@ The device screen may be cropped to mirror only part of the screen.
 This is useful, for example, to mirror only one eye of the Oculus Go:
 
 ```bash
-scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
+scrcpy --crop=1224:1440:0:0   # 1224x1440 at offset (0,0)
 ```
 
 If `--max-size` is also specified, resizing is applied after cropping.
@@ -252,20 +252,33 @@ This affects recording orientation.
 The [window may also be rotated](#rotation) independently.
 
 
-#### Encoder
+#### Codec
 
-Some devices have more than one encoder, and some of them may cause issues or
-crash. It is possible to select a different encoder:
+The video codec can be selected. The possible values are `h264` (default),
+`h265` and `av1`:
 
 ```bash
-scrcpy --encoder OMX.qcom.video.encoder.avc
+scrcpy --codec=h264  # default
+scrcpy --codec=h265
+scrcpy --codec=av1
+```
+
+
+##### Encoder
+
+Some devices have more than one encoder for a specific codec, and some of them
+may cause issues or crash. It is possible to select a different encoder:
+
+```bash
+scrcpy --encoder=OMX.qcom.video.encoder.avc
 ```
 
 To list the available encoders, you can pass an invalid encoder name; the
 error will give the available encoders:
 
 ```bash
-scrcpy --encoder _
+scrcpy --encoder=_               # for the default codec
+scrcpy --codec=h265 --encoder=_  # for a specific codec
 ```
 
 ### Capture
@@ -275,14 +288,14 @@ scrcpy --encoder _
 It is possible to record the screen while mirroring:
 
 ```bash
-scrcpy --record file.mp4
+scrcpy --record=file.mp4
 scrcpy -r file.mkv
 ```
 
 To disable mirroring while recording:
 
 ```bash
-scrcpy --no-display --record file.mp4
+scrcpy --no-display --record=file.mp4
 scrcpy -Nr file.mkv
 # interrupt recording with Ctrl+C
 ```
@@ -395,8 +408,8 @@ address), connect the device over USB, then run:
 scrcpy --tcpip    # without arguments
 ```
 
-It will automatically find the device IP address, enable TCP/IP mode, then
-connect to the device before starting.
+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
 
@@ -431,7 +444,7 @@ none found, try running `adb disconnect`, and then run those two commands again.
 It may be useful to decrease the bit-rate and the resolution:
 
 ```bash
-scrcpy --bit-rate 2M --max-size 800
+scrcpy --bit-rate=2M --max-size=800
 scrcpy -b2M -m800  # short version
 ```
 
@@ -443,7 +456,7 @@ scrcpy -b2M -m800  # short version
 If several devices are listed in `adb devices`, you can specify the _serial_:
 
 ```bash
-scrcpy --serial 0123456789abcdef
+scrcpy --serial=0123456789abcdef
 scrcpy -s 0123456789abcdef  # short version
 ```
 
@@ -453,7 +466,7 @@ The serial may also be provided via the environment variable `ANDROID_SERIAL`
 If the device is connected over TCP/IP:
 
 ```bash
-scrcpy --serial 192.168.0.1:5555
+scrcpy --serial=192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # short version
 ```
 
@@ -606,7 +619,7 @@ scrcpy --force-adb-forward
 Like for wireless connections, it may be useful to reduce quality:
 
 ```
-scrcpy -b2M -m800 --max-fps 15
+scrcpy -b2M -m800 --max-fps=15
 ```
 
 ### Window configuration
@@ -616,7 +629,7 @@ scrcpy -b2M -m800 --max-fps 15
 By default, the window title is the device model. It can be changed:
 
 ```bash
-scrcpy --window-title 'My device'
+scrcpy --window-title='My device'
 ```
 
 #### Position and size
@@ -624,7 +637,7 @@ scrcpy --window-title 'My device'
 The initial window position and size may be specified:
 
 ```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
+scrcpy --window-x=100 --window-y=100 --window-width=800 --window-height=600
 ```
 
 #### Borderless
@@ -659,7 +672,7 @@ Fullscreen can then be toggled dynamically with <kbd>MOD</kbd>+<kbd>f</kbd>.
 The window may be rotated:
 
 ```bash
-scrcpy --rotation 1
+scrcpy --rotation=1
 ```
 
 Possible values:
@@ -701,7 +714,7 @@ If several displays are available, it is possible to select the display to
 mirror:
 
 ```bash
-scrcpy --display 1
+scrcpy --display=1
 ```
 
 The list of display ids can be retrieved by:

app/data/bash-completion/scrcpy

@@ -93,6 +93,11 @@ _scrcpy() {
             COMPREPLY=($(compgen -W 'verbose debug info warn error' -- "$cur"))
             return
             ;;
+        -s|--serial)
+            # Use 'adb devices' to list serial numbers
+            COMPREPLY=($(compgen -W "$("${ADB:-adb}" devices | awk '$2 == "device" {print $1}')" -- ${cur}))
+            return
+            ;;
         -b|--bitrate \
         |--codec-options \
         |--crop \
@@ -103,7 +108,6 @@ _scrcpy() {
         |-m|--max-size \
         |-p|--port \
         |--push-target \
-        |-s|--serial \
         |--tunnel-host \
         |--tunnel-port \
         |--v4l2-buffer \

app/data/scrcpy-console.desktop

@@ -0,0 +1,13 @@
+[Desktop Entry]
+Name=scrcpy (console)
+GenericName=Android Remote Control
+Comment=Display and control your Android device
+# For some users, the PATH or ADB environment variables are set from the shell
+# startup file, like .bashrc or .zshrc… Run an interactive shell to get
+# environment correctly initialized.
+Exec=/bin/bash --norc --noprofile -i -c '"$SHELL" -i -c scrcpy || read -p "Press any key to quit..."'
+Icon=scrcpy
+Terminal=true
+Type=Application
+Categories=Utility;RemoteAccess;
+StartupNotify=false

app/data/scrcpy.desktop

@@ -0,0 +1,13 @@
+[Desktop Entry]
+Name=scrcpy
+GenericName=Android Remote Control
+Comment=Display and control your Android device
+# For some users, the PATH or ADB environment variables are set from the shell
+# startup file, like .bashrc or .zshrc… Run an interactive shell to get
+# environment correctly initialized.
+Exec=/bin/sh -c '"$SHELL" -i -c scrcpy'
+Icon=scrcpy
+Terminal=false
+Type=Application
+Categories=Utility;RemoteAccess;
+StartupNotify=false

app/data/zsh-completion/_scrcpy

@@ -47,7 +47,7 @@ arguments=(
     '--record-format=[Force recording format]:format:(mp4 mkv)'
     '--render-driver=[Request SDL to use the given render driver]:driver name:(direct3d opengl opengles2 opengles metal software)'
     '--rotation=[Set the initial display rotation]:rotation values:(0 1 2 3)'
-    {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]'
+    {-s,--serial=}'[The device serial number \(mandatory for multiple devices only\)]:serial:($("${ADB-adb}" devices | awk '\''$2 == "device" {print $1}'\''))'
     '--shortcut-mod=[\[key1,key2+key3,...\] Specify the modifiers to use for scrcpy shortcuts]:shortcut mod:(lctrl rctrl lalt ralt lsuper rsuper)'
     {-S,--turn-screen-off}'[Turn the device screen off immediately]'
     {-t,--show-touches}'[Show physical touches]'

app/meson.build

@@ -21,6 +21,7 @@ src = [
     'src/mouse_inject.c',
     'src/opengl.c',
     'src/options.c',
+    'src/packet_merger.c',
     'src/receiver.c',
     'src/recorder.c',
     'src/scrcpy.c',
@@ -37,6 +38,7 @@ src = [
     'src/util/net_intr.c',
     'src/util/process.c',
     'src/util/process_intr.c',
+    'src/util/rand.c',
     'src/util/strbuf.c',
     'src/util/str.c',
     'src/util/term.c',
@@ -170,6 +172,8 @@ check_functions = [
     'strdup',
     'asprintf',
     'vasprintf',
+    'nrand48',
+    'jrand48',
 ]
 
 foreach f : check_functions
@@ -197,10 +201,6 @@ conf.set('PORTABLE', get_option('portable'))
 conf.set('DEFAULT_LOCAL_PORT_RANGE_FIRST', '27183')
 conf.set('DEFAULT_LOCAL_PORT_RANGE_LAST', '27199')
 
-# the default video bitrate, in bits/second
-# overridden by option --bit-rate
-conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
-
 # run a server debugger and wait for a client to be attached
 conf.set('SERVER_DEBUGGER', get_option('server_debugger'))
 
@@ -223,14 +223,26 @@ executable('scrcpy', src,
            install: true,
            c_args: [])
 
+# <https://mesonbuild.com/Builtin-options.html#directories>
+datadir = get_option('datadir') # by default 'share'
+
 install_man('scrcpy.1')
 install_data('data/icon.png',
              rename: 'scrcpy.png',
-             install_dir: 'share/icons/hicolor/256x256/apps')
+             install_dir: join_paths(datadir, 'icons/hicolor/256x256/apps'))
 install_data('data/zsh-completion/_scrcpy',
-             install_dir: 'share/zsh/site-functions')
+             install_dir: join_paths(datadir, 'zsh/site-functions'))
 install_data('data/bash-completion/scrcpy',
-             install_dir: 'share/bash-completion/completions')
+             install_dir: join_paths(datadir, 'bash-completion/completions'))
+
+# Desktop entry file for application launchers
+if host_machine.system() == 'linux'
+    # Install a launcher (ex: /usr/local/share/applications/scrcpy.desktop)
+    install_data('data/scrcpy.desktop',
+                 install_dir: join_paths(datadir, 'applications'))
+    install_data('data/scrcpy-console.desktop',
+                 install_dir: join_paths(datadir, 'applications'))
+endif
 
 
 ### TESTS
@@ -245,8 +257,8 @@ if get_option('buildtype') == 'debug'
             'src/util/str.c',
             'src/util/strbuf.c',
         ]],
-        ['test_buffer_util', [
-            'tests/test_buffer_util.c',
+        ['test_binary', [
+            'tests/test_binary.c',
         ]],
         ['test_cbuf', [
             'tests/test_cbuf.c',
@@ -255,6 +267,7 @@ if get_option('buildtype') == 'debug'
             'tests/test_cli.c',
             'src/cli.c',
             'src/options.c',
+            'src/util/log.c',
             'src/util/net.c',
             'src/util/str.c',
             'src/util/strbuf.c',

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-33.0.1
+DEP_DIR=platform-tools-33.0.3
 
-FILENAME=platform-tools_r33.0.1-windows.zip
-SHA256SUM=c1f02d42ea24ef4ff2a405ae7370e764ef4546f9b3e4520f5571a00ed5012c42
+FILENAME=platform-tools_r33.0.3-windows.zip
+SHA256SUM=1e59afd40a74c5c0eab0a9fad3f0faf8a674267106e0b19921be9f67081808c2
 
 if [[ -d "$DEP_DIR" ]]
 then

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

@@ -6,11 +6,11 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
 
-VERSION=5.0.1
+VERSION=5.1.2
 DEP_DIR=ffmpeg-win64-$VERSION
 
 FILENAME=ffmpeg-$VERSION-full_build-shared.7z
-SHA256SUM=ded28435b6f04b74f5ef5a6a13761233bce9e8e9f8ecb0eabe936fd36a778b0c
+SHA256SUM=d9eb97b72d7cfdae4d0f7eaea59ccffb8c364d67d88018ea715d5e2e193f00e9
 
 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.0.22
+DEP_DIR=SDL2-2.26.1
 
-FILENAME=SDL2-devel-2.0.22-mingw.tar.gz
-SHA256SUM=0e91e35973366aa1e6f81ee368924d9b4f93f9da4d2f2a89ec80b06eadcf23d1
+FILENAME=SDL2-devel-2.26.1-mingw.tar.gz
+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", "1.24"
+      VALUE "ProductVersion", "1.25"
     END
   END
   BLOCK "VarFileInfo"

app/scrcpy.1

@@ -19,14 +19,32 @@ provides display and control of Android devices connected on USB (or over TCP/IP
 .B \-\-always\-on\-top
 Make scrcpy window always on top (above other windows).
 
+.TP
+.BI "\-\-audio\-bit\-rate " value
+Encode the audio at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
+
+Default is 196K (196000).
+
+.TP
+.BI "\-\-audio\-codec " name
+Select an audio codec (opus or aac).
+
+Default is opus.
+
 .TP
 .BI "\-b, \-\-bit\-rate " value
 Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
 
-Default is 8000000.
+Default is 8M (8000000).
 
 .TP
-.BI "\-\-codec\-options " key[:type]=value[,...]
+.BI "\-\-codec " name
+Select a video codec (h264, h265 or av1).
+
+Default is h264.
+
+.TP
+.BI "\-\-codec\-options " key\fR[:\fItype\fR]=\fIvalue\fR[,...]
 Set a list of comma-separated key:type=value options for the device encoder.
 
 The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
@@ -117,7 +135,7 @@ Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+S
 This is a workaround for some devices not behaving as expected when setting the device clipboard programmatically.
 
 .TP
-.BI "\-\-lock\-video\-orientation[=value]
+\fB\-\-lock\-video\-orientation\fR[=\fIvalue\fR]
 Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees rotation counterclockwise.
 
 Default is "unlocked".
@@ -199,7 +217,7 @@ It may only work over USB.
 See \fB\-\-hid\-keyboard\fR and \fB\-\-hid\-mouse\fR.
 
 .TP
-.BI "\-p, \-\-port " port[:port]
+.BI "\-p, \-\-port " port\fR[:\fIport\fR]
 Set the TCP port (range) used by the client to listen.
 
 Default is 27183:27199.
@@ -260,7 +278,7 @@ Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each incre
 The device serial number. Mandatory only if several devices are connected to adb.
 
 .TP
-.BI "\-\-shortcut\-mod " key[+...]][,...]
+.BI "\-\-shortcut\-mod " key\fR[+...]][,...]
 Specify the modifiers to use for scrcpy shortcuts. Possible keys are "lctrl", "rctrl", "lalt", "ralt", "lsuper" and "rsuper".
 
 A shortcut can consist in several keys, separated by '+'. Several shortcuts can be specified, separated by ','.
@@ -270,12 +288,12 @@ For example, to use either LCtrl+LAlt or LSuper for scrcpy shortcuts, pass "lctr
 Default is "lalt,lsuper" (left-Alt or left-Super).
 
 .TP
-.BI "\-\-tcpip[=ip[:port]]
+.BI "\-\-tcpip\fR[=\fIip\fR[:\fIport\fR]]
 Configure and reconnect the device over TCP/IP.
 
 If a destination address is provided, then scrcpy connects to this address before starting. The device must listen on the given TCP port (default is 5555).
 
-If no destination address is provided, then scrcpy attempts to find the IP address of the current device (typically connected over USB), enables TCP/IP mode, then connects to this address before starting.
+If no destination address is provided, then scrcpy attempts to find the IP address and adb port of the current device (typically connected over USB), enables TCP/IP mode if necessary, then connects to this address before starting.
 
 .TP
 .B \-S, \-\-turn\-screen\-off

app/src/adb/adb.c

@@ -401,6 +401,7 @@ sc_adb_list_devices(struct sc_intr *intr, unsigned flags,
 #define BUFSIZE 65536
     char *buf = malloc(BUFSIZE);
     if (!buf) {
+        LOG_OOM();
         return false;
     }
 
@@ -710,5 +711,5 @@ sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
     // It is parsed as a NUL-terminated string
     buf[r] = '\0';
 
-    return sc_adb_parse_device_ip_from_output(buf);
+    return sc_adb_parse_device_ip(buf);
 }

app/src/adb/adb_parser.c

@@ -199,7 +199,7 @@ sc_adb_parse_device_ip_from_line(char *line) {
 }
 
 char *
-sc_adb_parse_device_ip_from_output(char *str) {
+sc_adb_parse_device_ip(char *str) {
     size_t idx_line = 0;
     while (str[idx_line] != '\0') {
         char *line = &str[idx_line];

app/src/adb/adb_parser.h

@@ -25,6 +25,6 @@ sc_adb_parse_devices(char *str, struct sc_vec_adb_devices *out_vec);
  * Warning: this function modifies the buffer for optimization purposes.
  */
 char *
-sc_adb_parse_device_ip_from_output(char *str);
+sc_adb_parse_device_ip(char *str);
 
 #endif

app/src/adb/adb_tunnel.c

@@ -7,8 +7,6 @@
 #include "util/net_intr.h"
 #include "util/process_intr.h"
 
-#define SC_SOCKET_NAME "scrcpy"
-
 static bool
 listen_on_port(struct sc_intr *intr, sc_socket socket, uint16_t port) {
     return net_listen_intr(intr, socket, IPV4_LOCALHOST, port, 1);
@@ -17,10 +15,11 @@ listen_on_port(struct sc_intr *intr, sc_socket socket, uint16_t port) {
 static bool
 enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
                                struct sc_intr *intr, const char *serial,
+                               const char *device_socket_name,
                                struct sc_port_range port_range) {
     uint16_t port = port_range.first;
     for (;;) {
-        if (!sc_adb_reverse(intr, serial, SC_SOCKET_NAME, port,
+        if (!sc_adb_reverse(intr, serial, device_socket_name, port,
                             SC_ADB_NO_STDOUT)) {
             // the command itself failed, it will fail on any port
             return false;
@@ -52,7 +51,7 @@ enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
         }
 
         // failure, disable tunnel and try another port
-        if (!sc_adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+        if (!sc_adb_reverse_remove(intr, serial, device_socket_name,
                                 SC_ADB_NO_STDOUT)) {
             LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
         }
@@ -78,12 +77,13 @@ enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
 static bool
 enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
                                struct sc_intr *intr, const char *serial,
+                               const char *device_socket_name,
                                struct sc_port_range port_range) {
     tunnel->forward = true;
 
     uint16_t port = port_range.first;
     for (;;) {
-        if (sc_adb_forward(intr, serial, port, SC_SOCKET_NAME,
+        if (sc_adb_forward(intr, serial, port, device_socket_name,
                            SC_ADB_NO_STDOUT)) {
             // success
             tunnel->local_port = port;
@@ -123,13 +123,14 @@ sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel) {
 
 bool
 sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                   const char *serial, struct sc_port_range port_range,
-                   bool force_adb_forward) {
+                   const char *serial, const char *device_socket_name,
+                   struct sc_port_range port_range, bool force_adb_forward) {
     assert(!tunnel->enabled);
 
     if (!force_adb_forward) {
         // Attempt to use "adb reverse"
-        if (enable_tunnel_reverse_any_port(tunnel, intr, serial, port_range)) {
+        if (enable_tunnel_reverse_any_port(tunnel, intr, serial,
+                                           device_socket_name, port_range)) {
             return true;
         }
 
@@ -139,12 +140,13 @@ sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
         LOGW("'adb reverse' failed, fallback to 'adb forward'");
     }
 
-    return enable_tunnel_forward_any_port(tunnel, intr, serial, port_range);
+    return enable_tunnel_forward_any_port(tunnel, intr, serial,
+                                          device_socket_name, port_range);
 }
 
 bool
 sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                    const char *serial) {
+                    const char *serial, const char *device_socket_name) {
     assert(tunnel->enabled);
 
     bool ret;
@@ -152,7 +154,7 @@ sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
         ret = sc_adb_forward_remove(intr, serial, tunnel->local_port,
                                     SC_ADB_NO_STDOUT);
     } else {
-        ret = sc_adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
+        ret = sc_adb_reverse_remove(intr, serial, device_socket_name,
                                     SC_ADB_NO_STDOUT);
 
         assert(tunnel->server_socket != SC_SOCKET_NONE);

app/src/adb/adb_tunnel.h

@@ -34,14 +34,14 @@ sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel);
  */
 bool
 sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                   const char *serial, struct sc_port_range port_range,
-                   bool force_adb_forward);
+                   const char *serial, const char *device_socket_name,
+                   struct sc_port_range port_range, bool force_adb_forward);
 
 /**
  * Close the tunnel
  */
 bool
 sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                    const char *serial);
+                    const char *serial, const char *device_socket_name);
 
 #endif

app/src/cli.c

@@ -57,6 +57,10 @@
 #define OPT_NO_CLEANUP             1037
 #define OPT_PRINT_FPS              1038
 #define OPT_NO_POWER_ON            1039
+#define OPT_CODEC                  1040
+#define OPT_NO_AUDIO               1041
+#define OPT_AUDIO_BIT_RATE         1042
+#define OPT_AUDIO_CODEC            1043
 
 struct sc_option {
     char shortopt;
@@ -97,13 +101,35 @@ static const struct sc_option options[] = {
         .longopt = "always-on-top",
         .text = "Make scrcpy window always on top (above other windows).",
     },
+    {
+        .longopt_id = OPT_AUDIO_BIT_RATE,
+        .longopt = "audio-bit-rate",
+        .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 196K (196000).",
+    },
+    {
+        .longopt_id = OPT_AUDIO_CODEC,
+        .longopt = "audio-codec",
+        .argdesc = "name",
+        .text = "Select an audio codec (opus or aac).\n"
+                "Default is opus.",
+    },
     {
         .shortopt = 'b',
         .longopt = "bit-rate",
         .argdesc = "value",
-        .text = "Encode the video at the gitven bit-rate, expressed in bits/s. "
+        .text = "Encode the video at the given bit-rate, expressed in bits/s. "
                 "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
-                "Default is " STR(DEFAULT_BIT_RATE) ".",
+                "Default is 8M (8000000).",
+    },
+    {
+        .longopt_id = OPT_CODEC,
+        .longopt = "codec",
+        .argdesc = "name",
+        .text = "Select a video codec (h264, h265 or av1).\n"
+                "Default is h264.",
     },
     {
         .longopt_id = OPT_CODEC_OPTIONS,
@@ -291,6 +317,11 @@ static const struct sc_option options[] = {
         .text = "Do not display device (only when screen recording or V4L2 "
                 "sink is enabled).",
     },
+    {
+        .longopt_id = OPT_NO_AUDIO,
+        .longopt = "no-audio",
+        .text = "Disable audio forwarding.",
+    },
     {
         .longopt_id = OPT_NO_KEY_REPEAT,
         .longopt = "no-key-repeat",
@@ -1377,6 +1408,38 @@ guess_record_format(const char *filename) {
     return 0;
 }
 
+static bool
+parse_codec(const char *optarg, enum sc_codec *codec) {
+    if (!strcmp(optarg, "h264")) {
+        *codec = SC_CODEC_H264;
+        return true;
+    }
+    if (!strcmp(optarg, "h265")) {
+        *codec = SC_CODEC_H265;
+        return true;
+    }
+    if (!strcmp(optarg, "av1")) {
+        *codec = SC_CODEC_AV1;
+        return true;
+    }
+    LOGE("Unsupported codec: %s (expected h264, h265 or av1)", optarg);
+    return false;
+}
+
+static bool
+parse_audio_codec(const char *optarg, enum sc_codec *codec) {
+    if (!strcmp(optarg, "opus")) {
+        *codec = SC_CODEC_OPUS;
+        return true;
+    }
+    if (!strcmp(optarg, "aac")) {
+        *codec = SC_CODEC_AAC;
+        return true;
+    }
+    LOGE("Unsupported audio codec: %s (expected opus)", optarg);
+    return false;
+}
+
 static bool
 parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                        const char *optstring, const struct option *longopts) {
@@ -1392,6 +1455,11 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                     return false;
                 }
                 break;
+            case OPT_AUDIO_BIT_RATE:
+                if (!parse_bit_rate(optarg, &opts->audio_bit_rate)) {
+                    return false;
+                }
+                break;
             case OPT_CROP:
                 opts->crop = optarg;
                 break;
@@ -1601,6 +1669,9 @@ 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_AUDIO:
+                opts->audio = false;
+                break;
             case OPT_NO_CLEANUP:
                 opts->cleanup = false;
                 break;
@@ -1610,6 +1681,16 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case OPT_PRINT_FPS:
                 opts->start_fps_counter = true;
                 break;
+            case OPT_CODEC:
+                if (!parse_codec(optarg, &opts->codec)) {
+                    return false;
+                }
+                break;
+            case OPT_AUDIO_CODEC:
+                if (!parse_audio_codec(optarg, &opts->audio_codec)) {
+                    return false;
+                }
+                break;
             case OPT_OTG:
 #ifdef HAVE_USB
                 opts->otg = true;
@@ -1718,6 +1799,13 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         }
     }
 
+    if (opts->record_format == SC_RECORD_FORMAT_MP4
+            && opts->codec == SC_CODEC_AV1) {
+        LOGE("Could not mux AV1 stream into MP4 container "
+             "(record to mkv or select another video codec)");
+        return false;
+    }
+
     if (!opts->control) {
         if (opts->turn_screen_off) {
             LOGE("Could not request to turn screen off if control is disabled");

app/src/clock.c

@@ -98,7 +98,7 @@ sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
         sc_clock_estimate(clock, &clock->slope, &clock->offset);
 
 #ifndef SC_CLOCK_NDEBUG
-        LOGD("Clock estimation: %g * pts + %" PRItick,
+        LOGD("Clock estimation: %f * pts + %" PRItick,
              clock->slope, clock->offset);
 #endif
     }

app/src/compat.c

@@ -51,3 +51,47 @@ int vasprintf(char **strp, const char *fmt, va_list ap) {
     return len;
 }
 #endif
+
+#if !defined(HAVE_NRAND48) || !defined(HAVE_JRAND48)
+#define SC_RAND48_MASK UINT64_C(0xFFFFFFFFFFFF) // 48 bits
+#define SC_RAND48_A UINT64_C(0x5DEECE66D)
+#define SC_RAND48_C 0xB
+static inline uint64_t rand_iter48(uint64_t x) {
+    assert((x & ~SC_RAND48_MASK) == 0);
+    return (x * SC_RAND48_A + SC_RAND48_C) & SC_RAND48_MASK;
+}
+
+static uint64_t rand_iter48_xsubi(unsigned short xsubi[3]) {
+    uint64_t x = ((uint64_t) xsubi[0] << 32)
+               | ((uint64_t) xsubi[1] << 16)
+               | xsubi[2];
+
+    x = rand_iter48(x);
+
+    xsubi[0] = (x >> 32) & 0XFFFF;
+    xsubi[1] = (x >> 16) & 0XFFFF;
+    xsubi[2] = x & 0XFFFF;
+
+    return x;
+}
+
+#ifndef HAVE_NRAND48
+long nrand48(unsigned short xsubi[3]) {
+    // range [0, 2^31)
+    return rand_iter48_xsubi(xsubi) >> 17;
+}
+#endif
+
+#ifndef HAVE_JRAND48
+long jrand48(unsigned short xsubi[3]) {
+    // range [-2^31, 2^31)
+    union {
+        uint32_t u;
+        int32_t i;
+    } v;
+    v.u = rand_iter48_xsubi(xsubi) >> 16;
+    return v.i;
+}
+#endif
+
+#endif

app/src/compat.h

@@ -59,4 +59,12 @@ int asprintf(char **strp, const char *fmt, ...);
 int vasprintf(char **strp, const char *fmt, va_list ap);
 #endif
 
+#ifndef HAVE_NRAND48
+long nrand48(unsigned short xsubi[3]);
+#endif
+
+#ifndef HAVE_JRAND48
+long jrand48(unsigned short xsubi[3]);
+#endif
+
 #endif

app/src/control_msg.c

@@ -5,7 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "util/buffer_util.h"
+#include "util/binary.h"
 #include "util/log.h"
 #include "util/str.h"
 
@@ -37,7 +37,7 @@ static const char *const android_motionevent_action_labels[] = {
     "move",
     "cancel",
     "outside",
-    "ponter-down",
+    "pointer-down",
     "pointer-up",
     "hover-move",
     "scroll",
@@ -61,6 +61,22 @@ static const char *const copy_key_labels[] = {
     "cut",
 };
 
+static inline const char *
+get_well_known_pointer_id_name(uint64_t pointer_id) {
+    switch (pointer_id) {
+        case POINTER_ID_MOUSE:
+            return "mouse";
+        case POINTER_ID_GENERIC_FINGER:
+            return "finger";
+        case POINTER_ID_VIRTUAL_MOUSE:
+            return "vmouse";
+        case POINTER_ID_VIRTUAL_FINGER:
+            return "vfinger";
+        default:
+            return NULL;
+    }
+}
+
 static void
 write_position(uint8_t *buf, const struct sc_position *position) {
     sc_write32be(&buf[0], position->point.x);
@@ -78,16 +94,6 @@ write_string(const char *utf8, size_t max_len, unsigned char *buf) {
     return 4 + len;
 }
 
-static uint16_t
-to_fixed_point_16(float f) {
-    assert(f >= 0.0f && f <= 1.0f);
-    uint32_t u = f * 0x1p16f; // 2^16
-    if (u >= 0xffff) {
-        u = 0xffff;
-    }
-    return (uint16_t) u;
-}
-
 size_t
 sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
     buf[0] = msg->type;
@@ -109,18 +115,21 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
             sc_write64be(&buf[2], msg->inject_touch_event.pointer_id);
             write_position(&buf[10], &msg->inject_touch_event.position);
             uint16_t pressure =
-                to_fixed_point_16(msg->inject_touch_event.pressure);
+                sc_float_to_u16fp(msg->inject_touch_event.pressure);
             sc_write16be(&buf[22], pressure);
-            sc_write32be(&buf[24], msg->inject_touch_event.buttons);
-            return 28;
+            sc_write32be(&buf[24], msg->inject_touch_event.action_button);
+            sc_write32be(&buf[28], msg->inject_touch_event.buttons);
+            return 32;
         case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
             write_position(&buf[1], &msg->inject_scroll_event.position);
-            sc_write32be(&buf[13],
-                             (uint32_t) msg->inject_scroll_event.hscroll);
-            sc_write32be(&buf[17],
-                             (uint32_t) msg->inject_scroll_event.vscroll);
-            sc_write32be(&buf[21], msg->inject_scroll_event.buttons);
-            return 25;
+            int16_t hscroll =
+                sc_float_to_i16fp(msg->inject_scroll_event.hscroll);
+            int16_t vscroll =
+                sc_float_to_i16fp(msg->inject_scroll_event.vscroll);
+            sc_write16be(&buf[13], (uint16_t) hscroll);
+            sc_write16be(&buf[15], (uint16_t) vscroll);
+            sc_write32be(&buf[17], msg->inject_scroll_event.buttons);
+            return 21;
         case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
             buf[1] = msg->inject_keycode.action;
             return 2;
@@ -167,32 +176,36 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
             int action = msg->inject_touch_event.action
                        & AMOTION_EVENT_ACTION_MASK;
             uint64_t id = msg->inject_touch_event.pointer_id;
-            if (id == POINTER_ID_MOUSE || id == POINTER_ID_VIRTUAL_FINGER) {
+            const char *pointer_name = get_well_known_pointer_id_name(id);
+            if (pointer_name) {
                 // string pointer id
                 LOG_CMSG("touch [id=%s] %-4s position=%" PRIi32 ",%" PRIi32
-                             " pressure=%g buttons=%06lx",
-                         id == POINTER_ID_MOUSE ? "mouse" : "vfinger",
+                             " pressure=%f action_button=%06lx buttons=%06lx",
+                         pointer_name,
                          MOTIONEVENT_ACTION_LABEL(action),
                          msg->inject_touch_event.position.point.x,
                          msg->inject_touch_event.position.point.y,
                          msg->inject_touch_event.pressure,
+                         (long) msg->inject_touch_event.action_button,
                          (long) msg->inject_touch_event.buttons);
             } else {
                 // numeric pointer id
                 LOG_CMSG("touch [id=%" PRIu64_ "] %-4s position=%" PRIi32 ",%"
-                             PRIi32 " pressure=%g buttons=%06lx",
+                             PRIi32 " pressure=%f action_button=%06lx"
+                             " buttons=%06lx",
                          id,
                          MOTIONEVENT_ACTION_LABEL(action),
                          msg->inject_touch_event.position.point.x,
                          msg->inject_touch_event.position.point.y,
                          msg->inject_touch_event.pressure,
+                         (long) msg->inject_touch_event.action_button,
                          (long) msg->inject_touch_event.buttons);
             }
             break;
         }
         case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
-            LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%" PRIi32
-                         " vscroll=%" PRIi32 " buttons=%06lx",
+            LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%f"
+                         " vscroll=%f buttons=%06lx",
                      msg->inject_scroll_event.position.point.x,
                      msg->inject_scroll_event.position.point.y,
                      msg->inject_scroll_event.hscroll,

app/src/control_msg.h

@@ -18,7 +18,11 @@
 #define SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (SC_CONTROL_MSG_MAX_SIZE - 14)
 
 #define POINTER_ID_MOUSE UINT64_C(-1)
-#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2)
+#define POINTER_ID_GENERIC_FINGER UINT64_C(-2)
+
+// Used for injecting an additional virtual pointer for pinch-to-zoom
+#define POINTER_ID_VIRTUAL_MOUSE UINT64_C(-3)
+#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-4)
 
 enum sc_control_msg_type {
     SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
@@ -61,6 +65,7 @@ struct sc_control_msg {
         } inject_text;
         struct {
             enum android_motionevent_action action;
+            enum android_motionevent_buttons action_button;
             enum android_motionevent_buttons buttons;
             uint64_t pointer_id;
             struct sc_position position;
@@ -68,8 +73,8 @@ struct sc_control_msg {
         } inject_touch_event;
         struct {
             struct sc_position position;
-            int32_t hscroll;
-            int32_t vscroll;
+            float hscroll;
+            float vscroll;
             enum android_motionevent_buttons buttons;
         } inject_scroll_event;
         struct {

app/src/controller.c

@@ -9,20 +9,20 @@ sc_controller_init(struct sc_controller *controller, sc_socket control_socket,
                    struct sc_acksync *acksync) {
     cbuf_init(&controller->queue);
 
-    bool ok = receiver_init(&controller->receiver, control_socket, acksync);
+    bool ok = sc_receiver_init(&controller->receiver, control_socket, acksync);
     if (!ok) {
         return false;
     }
 
     ok = sc_mutex_init(&controller->mutex);
     if (!ok) {
-        receiver_destroy(&controller->receiver);
+        sc_receiver_destroy(&controller->receiver);
         return false;
     }
 
     ok = sc_cond_init(&controller->msg_cond);
     if (!ok) {
-        receiver_destroy(&controller->receiver);
+        sc_receiver_destroy(&controller->receiver);
         sc_mutex_destroy(&controller->mutex);
         return false;
     }
@@ -43,7 +43,7 @@ sc_controller_destroy(struct sc_controller *controller) {
         sc_control_msg_destroy(&msg);
     }
 
-    receiver_destroy(&controller->receiver);
+    sc_receiver_destroy(&controller->receiver);
 }
 
 bool
@@ -117,7 +117,7 @@ sc_controller_start(struct sc_controller *controller) {
         return false;
     }
 
-    if (!receiver_start(&controller->receiver)) {
+    if (!sc_receiver_start(&controller->receiver)) {
         sc_controller_stop(controller);
         sc_thread_join(&controller->thread, NULL);
         return false;
@@ -137,5 +137,5 @@ sc_controller_stop(struct sc_controller *controller) {
 void
 sc_controller_join(struct sc_controller *controller) {
     sc_thread_join(&controller->thread, NULL);
-    receiver_join(&controller->receiver);
+    sc_receiver_join(&controller->receiver);
 }

app/src/controller.h

@@ -21,7 +21,7 @@ struct sc_controller {
     sc_cond msg_cond;
     bool stopped;
     struct sc_control_msg_queue queue;
-    struct receiver receiver;
+    struct sc_receiver receiver;
 };
 
 bool

app/src/decoder.c

@@ -29,7 +29,6 @@ sc_decoder_open_sinks(struct sc_decoder *decoder) {
     for (unsigned i = 0; i < decoder->sink_count; ++i) {
         struct sc_frame_sink *sink = decoder->sinks[i];
         if (!sink->ops->open(sink)) {
-            LOGE("Could not open frame sink %d", i);
             sc_decoder_close_first_sinks(decoder, i);
             return false;
         }
@@ -63,7 +62,6 @@ sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
     }
 
     if (!sc_decoder_open_sinks(decoder)) {
-        LOGE("Could not open decoder sinks");
         av_frame_free(&decoder->frame);
         avcodec_close(decoder->codec_ctx);
         avcodec_free_context(&decoder->codec_ctx);
@@ -86,7 +84,6 @@ push_frame_to_sinks(struct sc_decoder *decoder, const AVFrame *frame) {
     for (unsigned i = 0; i < decoder->sink_count; ++i) {
         struct sc_frame_sink *sink = decoder->sinks[i];
         if (!sink->ops->push(sink, frame)) {
-            LOGE("Could not send frame to sink %d", i);
             return false;
         }
     }

app/src/demuxer.c

@@ -6,8 +6,9 @@
 
 #include "decoder.h"
 #include "events.h"
+#include "packet_merger.h"
 #include "recorder.h"
-#include "util/buffer_util.h"
+#include "util/binary.h"
 #include "util/log.h"
 
 #define SC_PACKET_HEADER_SIZE 12
@@ -17,6 +18,42 @@
 
 #define SC_PACKET_PTS_MASK (SC_PACKET_FLAG_KEY_FRAME - 1)
 
+static enum AVCodecID
+sc_demuxer_to_avcodec_id(uint32_t codec_id) {
+#define SC_CODEC_ID_H264 UINT32_C(0x68323634) // "h264" in ASCII
+#define SC_CODEC_ID_H265 UINT32_C(0x68323635) // "h265" in ASCII
+#define SC_CODEC_ID_AV1 UINT32_C(0x00617631) // "av1" in ASCII
+#define SC_CODEC_ID_OPUS UINT32_C(0x6f707573) // "opus" in ASCII
+#define SC_CODEC_ID_AAC UINT32_C(0x00616163) // "aac in ASCII"
+    switch (codec_id) {
+        case SC_CODEC_ID_H264:
+            return AV_CODEC_ID_H264;
+        case SC_CODEC_ID_H265:
+            return AV_CODEC_ID_HEVC;
+        case SC_CODEC_ID_AV1:
+            return AV_CODEC_ID_AV1;
+        case SC_CODEC_ID_OPUS:
+            return AV_CODEC_ID_OPUS;
+        case SC_CODEC_ID_AAC:
+            return AV_CODEC_ID_AAC;
+        default:
+            LOGE("Unknown codec id 0x%08" PRIx32, codec_id);
+            return AV_CODEC_ID_NONE;
+    }
+}
+
+static bool
+sc_demuxer_recv_codec_id(struct sc_demuxer *demuxer, uint32_t *codec_id) {
+    uint8_t data[4];
+    ssize_t r = net_recv_all(demuxer->socket, data, 4);
+    if (r < 4) {
+        return false;
+    }
+
+    *codec_id = sc_read32be(data);
+    return true;
+}
+
 static bool
 sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
     // The video stream contains raw packets, without time information. When we
@@ -37,8 +74,8 @@ sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
     // CK...... ........ ........ ........ ........ ........ ........ ........
     // ^^<------------------------------------------------------------------->
     // ||                                PTS
-    // | `- config packet
-    //  `-- key frame
+    // | `- key frame
+    //  `-- config packet
 
     uint8_t header[SC_PACKET_HEADER_SIZE];
     ssize_t r = net_recv_all(demuxer->socket, header, SC_PACKET_HEADER_SIZE);
@@ -80,7 +117,6 @@ push_packet_to_sinks(struct sc_demuxer *demuxer, const AVPacket *packet) {
     for (unsigned i = 0; i < demuxer->sink_count; ++i) {
         struct sc_packet_sink *sink = demuxer->sinks[i];
         if (!sink->ops->push(sink, packet)) {
-            LOGE("Could not send config packet to sink %d", i);
             return false;
         }
     }
@@ -90,52 +126,9 @@ push_packet_to_sinks(struct sc_demuxer *demuxer, const AVPacket *packet) {
 
 static bool
 sc_demuxer_push_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
-    bool is_config = packet->pts == AV_NOPTS_VALUE;
-
-    // A config packet must not be decoded immediately (it contains no
-    // frame); instead, it must be concatenated with the future data packet.
-    if (demuxer->pending || is_config) {
-        size_t offset;
-        if (demuxer->pending) {
-            offset = demuxer->pending->size;
-            if (av_grow_packet(demuxer->pending, packet->size)) {
-                LOG_OOM();
-                return false;
-            }
-        } else {
-            offset = 0;
-            demuxer->pending = av_packet_alloc();
-            if (!demuxer->pending) {
-                LOG_OOM();
-                return false;
-            }
-            if (av_new_packet(demuxer->pending, packet->size)) {
-                LOG_OOM();
-                av_packet_free(&demuxer->pending);
-                return false;
-            }
-        }
-
-        memcpy(demuxer->pending->data + offset, packet->data, packet->size);
-
-        if (!is_config) {
-            // prepare the concat packet to send to the decoder
-            demuxer->pending->pts = packet->pts;
-            demuxer->pending->dts = packet->dts;
-            demuxer->pending->flags = packet->flags;
-            packet = demuxer->pending;
-        }
-    }
-
     bool ok = push_packet_to_sinks(demuxer, packet);
-
-    if (!is_config && demuxer->pending) {
-        // the pending packet must be discarded (consumed or error)
-        av_packet_free(&demuxer->pending);
-    }
-
     if (!ok) {
-        LOGE("Could not process packet");
+        LOGE("Demuxer '%s': could not process packet", demuxer->name);
         return false;
     }
 
@@ -160,7 +153,6 @@ sc_demuxer_open_sinks(struct sc_demuxer *demuxer, const AVCodec *codec) {
     for (unsigned i = 0; i < demuxer->sink_count; ++i) {
         struct sc_packet_sink *sink = demuxer->sinks[i];
         if (!sink->ops->open(sink, codec)) {
-            LOGE("Could not open packet sink %d", i);
             sc_demuxer_close_first_sinks(demuxer, i);
             return false;
         }
@@ -169,50 +161,93 @@ sc_demuxer_open_sinks(struct sc_demuxer *demuxer, const AVCodec *codec) {
     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;
 
-    const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
-    if (!codec) {
-        LOGE("H.264 decoder not found");
+    // Flag to report end-of-stream (i.e. device disconnected)
+    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;
     }
 
-    demuxer->codec_ctx = avcodec_alloc_context3(codec);
-    if (!demuxer->codec_ctx) {
-        LOG_OOM();
+    if (raw_codec_id == 0) {
+        LOGW("Demuxer '%s': stream explicitly disabled by the device",
+             demuxer->name);
+        sc_demuxer_disable_sinks(demuxer);
+        eos = true;
+        goto end;
+    }
+
+    enum AVCodecID codec_id = sc_demuxer_to_avcodec_id(raw_codec_id);
+    if (codec_id == AV_CODEC_ID_NONE) {
+        LOGE("Demuxer '%s': stream disabled due to unsupported codec",
+             demuxer->name);
+        sc_demuxer_disable_sinks(demuxer);
+        goto end;
+    }
+
+    const AVCodec *codec = avcodec_find_decoder(codec_id);
+    if (!codec) {
+        LOGE("Demuxer '%s': stream disabled due to missing decoder",
+             demuxer->name);
+        sc_demuxer_disable_sinks(demuxer);
         goto end;
     }
 
     if (!sc_demuxer_open_sinks(demuxer, codec)) {
-        LOGE("Could not open demuxer sinks");
-        goto finally_free_codec_ctx;
+        goto end;
     }
 
-    demuxer->parser = av_parser_init(AV_CODEC_ID_H264);
-    if (!demuxer->parser) {
-        LOGE("Could not initialize parser");
-        goto finally_close_sinks;
-    }
+    // 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;
 
-    // We must only pass complete frames to av_parser_parse2()!
-    // It's more complicated, but this allows to reduce the latency by 1 frame!
-    demuxer->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
+    struct sc_packet_merger merger;
+
+    if (must_merge_config_packet) {
+        sc_packet_merger_init(&merger);
+    }
 
     AVPacket *packet = av_packet_alloc();
     if (!packet) {
         LOG_OOM();
-        goto finally_close_parser;
+        goto finally_close_sinks;
     }
 
     for (;;) {
         bool ok = sc_demuxer_recv_packet(demuxer, packet);
         if (!ok) {
             // end of stream
+            eos = true;
             break;
         }
 
+        if (must_merge_config_packet) {
+            // Prepend any config packet to the next media packet
+            ok = sc_packet_merger_merge(&merger, packet);
+            if (!ok) {
+                av_packet_unref(packet);
+                break;
+            }
+        }
+
         ok = sc_demuxer_push_packet(demuxer, packet);
         av_packet_unref(packet);
         if (!ok) {
@@ -221,33 +256,31 @@ run_demuxer(void *data) {
         }
     }
 
-    LOGD("End of frames");
+    LOGD("Demuxer '%s': end of frames", demuxer->name);
 
-    if (demuxer->pending) {
-        av_packet_free(&demuxer->pending);
+    if (must_merge_config_packet) {
+        sc_packet_merger_destroy(&merger);
     }
 
     av_packet_free(&packet);
-finally_close_parser:
-    av_parser_close(demuxer->parser);
 finally_close_sinks:
     sc_demuxer_close_sinks(demuxer);
-finally_free_codec_ctx:
-    avcodec_free_context(&demuxer->codec_ctx);
 end:
-    demuxer->cbs->on_eos(demuxer, demuxer->cbs_userdata);
+    demuxer->cbs->on_ended(demuxer, eos, demuxer->cbs_userdata);
 
     return 0;
 }
 
 void
-sc_demuxer_init(struct sc_demuxer *demuxer, sc_socket socket,
+sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
                 const struct sc_demuxer_callbacks *cbs, void *cbs_userdata) {
+    assert(socket != SC_SOCKET_NONE);
+
+    demuxer->name = name; // statically allocated
     demuxer->socket = socket;
-    demuxer->pending = NULL;
     demuxer->sink_count = 0;
 
-    assert(cbs && cbs->on_eos);
+    assert(cbs && cbs->on_ended);
 
     demuxer->cbs = cbs;
     demuxer->cbs_userdata = cbs_userdata;
@@ -263,12 +296,12 @@ sc_demuxer_add_sink(struct sc_demuxer *demuxer, struct sc_packet_sink *sink) {
 
 bool
 sc_demuxer_start(struct sc_demuxer *demuxer) {
-    LOGD("Starting demuxer thread");
+    LOGD("Demuxer '%s': starting thread", demuxer->name);
 
     bool ok = sc_thread_create(&demuxer->thread, run_demuxer, "scrcpy-demuxer",
                                demuxer);
     if (!ok) {
-        LOGE("Could not start demuxer thread");
+        LOGE("Demuxer '%s': could not start thread", demuxer->name);
         return false;
     }
     return true;

app/src/demuxer.h

@@ -15,28 +15,25 @@
 #define SC_DEMUXER_MAX_SINKS 2
 
 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;
 
-    AVCodecContext *codec_ctx;
-    AVCodecParserContext *parser;
-    // successive packets may need to be concatenated, until a non-config
-    // packet is available
-    AVPacket *pending;
-
     const struct sc_demuxer_callbacks *cbs;
     void *cbs_userdata;
 };
 
 struct sc_demuxer_callbacks {
-    void (*on_eos)(struct sc_demuxer *demuxer, void *userdata);
+    void (*on_ended)(struct sc_demuxer *demuxer, bool eos, void *userdata);
 };
 
+// The name must be statically allocated (e.g. a string literal)
 void
-sc_demuxer_init(struct sc_demuxer *demuxer, sc_socket socket,
+sc_demuxer_init(struct sc_demuxer *demuxer, const char *name, sc_socket socket,
                 const struct sc_demuxer_callbacks *cbs, void *cbs_userdata);
 
 void

app/src/device_msg.c

@@ -4,7 +4,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "util/buffer_util.h"
+#include "util/binary.h"
 #include "util/log.h"
 
 ssize_t

app/src/events.h

@@ -1,5 +1,7 @@
-#define EVENT_NEW_FRAME                 SDL_USEREVENT
-#define EVENT_STREAM_STOPPED           (SDL_USEREVENT + 1)
-#define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
-#define EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
-#define EVENT_USB_DEVICE_DISCONNECTED  (SDL_USEREVENT + 4)
+#define SC_EVENT_NEW_FRAME                 SDL_USEREVENT
+#define SC_EVENT_DEVICE_DISCONNECTED      (SDL_USEREVENT + 1)
+#define SC_EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
+#define SC_EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 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)

app/src/input_events.h

@@ -353,18 +353,20 @@ struct sc_mouse_click_event {
     struct sc_position position;
     enum sc_action action;
     enum sc_mouse_button button;
+    uint64_t pointer_id;
     uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
 };
 
 struct sc_mouse_scroll_event {
     struct sc_position position;
-    int32_t hscroll;
-    int32_t vscroll;
+    float hscroll;
+    float vscroll;
     uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
 };
 
 struct sc_mouse_motion_event {
     struct sc_position position;
+    uint64_t pointer_id;
     int32_t xrel;
     int32_t yrel;
     uint8_t buttons_state; // bitwise-OR of sc_mouse_button values

app/src/input_manager.c

@@ -335,8 +335,11 @@ simulate_virtual_finger(struct sc_input_manager *im,
     msg.inject_touch_event.action = action;
     msg.inject_touch_event.position.screen_size = im->screen->frame_size;
     msg.inject_touch_event.position.point = point;
-    msg.inject_touch_event.pointer_id = POINTER_ID_VIRTUAL_FINGER;
+    msg.inject_touch_event.pointer_id =
+        im->forward_all_clicks ? POINTER_ID_VIRTUAL_MOUSE
+                               : POINTER_ID_VIRTUAL_FINGER;
     msg.inject_touch_event.pressure = up ? 0.0f : 1.0f;
+    msg.inject_touch_event.action_button = 0;
     msg.inject_touch_event.buttons = 0;
 
     if (!sc_controller_push_msg(im->controller, &msg)) {
@@ -564,6 +567,8 @@ sc_input_manager_process_mouse_motion(struct sc_input_manager *im,
                                                               event->x,
                                                               event->y),
         },
+        .pointer_id = im->forward_all_clicks ? POINTER_ID_MOUSE
+                                             : POINTER_ID_GENERIC_FINGER,
         .xrel = event->xrel,
         .yrel = event->yrel,
         .buttons_state =
@@ -687,6 +692,8 @@ sc_input_manager_process_mouse_button(struct sc_input_manager *im,
         },
         .action = sc_action_from_sdl_mousebutton_type(event->type),
         .button = sc_mouse_button_from_sdl(event->button),
+        .pointer_id = im->forward_all_clicks ? POINTER_ID_MOUSE
+                                             : POINTER_ID_GENERIC_FINGER,
         .buttons_state =
             sc_mouse_buttons_state_from_sdl(sdl_buttons_state,
                                             im->forward_all_clicks),
@@ -747,8 +754,13 @@ sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,
             .point = sc_screen_convert_window_to_frame_coords(im->screen,
                                                               mouse_x, mouse_y),
         },
-        .hscroll = event->x,
-        .vscroll = event->y,
+#if SDL_VERSION_ATLEAST(2, 0, 18)
+        .hscroll = CLAMP(event->preciseX, -1.0f, 1.0f),
+        .vscroll = CLAMP(event->preciseY, -1.0f, 1.0f),
+#else
+        .hscroll = CLAMP(event->x, -1, 1),
+        .vscroll = CLAMP(event->y, -1, 1),
+#endif
         .buttons_state =
             sc_mouse_buttons_state_from_sdl(buttons, im->forward_all_clicks),
     };

app/src/main.c

@@ -4,6 +4,10 @@
 #include <stdbool.h>
 #include <unistd.h>
 #include <libavformat/avformat.h>
+#ifdef _WIN32
+#include <windows.h>
+#include "util/str.h"
+#endif
 #ifdef HAVE_V4L2
 # include <libavdevice/avdevice.h>
 #endif
@@ -18,8 +22,8 @@
 #include "version.h"
 
 int
-main(int argc, char *argv[]) {
-#ifdef __WINDOWS__
+main_scrcpy(int argc, char *argv[]) {
+#ifdef _WIN32
     // disable buffering, we want logs immediately
     // even line buffering (setvbuf() with mode _IOLBF) is not sufficient
     setbuf(stdout, NULL);
@@ -80,3 +84,52 @@ main(int argc, char *argv[]) {
 
     return ret;
 }
+
+int
+main(int argc, char *argv[]) {
+#ifndef _WIN32
+    return main_scrcpy(argc, argv);
+#else
+    (void) argc;
+    (void) argv;
+    int wargc;
+    wchar_t **wargv = CommandLineToArgvW(GetCommandLineW(), &wargc);
+    if (!wargv) {
+        LOG_OOM();
+        return SCRCPY_EXIT_FAILURE;
+    }
+
+    char **argv_utf8 = malloc((wargc + 1) * sizeof(*argv_utf8));
+    if (!argv_utf8) {
+        LOG_OOM();
+        LocalFree(wargv);
+        return SCRCPY_EXIT_FAILURE;
+    }
+
+    argv_utf8[wargc] = NULL;
+
+    for (int i = 0; i < wargc; ++i) {
+        argv_utf8[i] = sc_str_from_wchars(wargv[i]);
+        if (!argv_utf8[i]) {
+            LOG_OOM();
+            for (int j = 0; j < i; ++j) {
+                free(argv_utf8[j]);
+            }
+            LocalFree(wargv);
+            free(argv_utf8);
+            return SCRCPY_EXIT_FAILURE;
+        }
+    }
+
+    LocalFree(wargv);
+
+    int ret = main_scrcpy(wargc, argv_utf8);
+
+    for (int i = 0; i < wargc; ++i) {
+        free(argv_utf8[i]);
+    }
+    free(argv_utf8);
+
+    return ret;
+#endif
+}

app/src/mouse_inject.c

@@ -69,7 +69,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
         .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
             .action = AMOTION_EVENT_ACTION_MOVE,
-            .pointer_id = POINTER_ID_MOUSE,
+            .pointer_id = event->pointer_id,
             .position = event->position,
             .pressure = 1.f,
             .buttons = convert_mouse_buttons(event->buttons_state),
@@ -90,9 +90,10 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
         .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
         .inject_touch_event = {
             .action = convert_mouse_action(event->action),
-            .pointer_id = POINTER_ID_MOUSE,
+            .pointer_id = event->pointer_id,
             .position = event->position,
             .pressure = event->action == SC_ACTION_DOWN ? 1.f : 0.f,
+            .action_button = convert_mouse_buttons(event->button),
             .buttons = convert_mouse_buttons(event->buttons_state),
         },
     };

app/src/options.c

@@ -13,6 +13,8 @@ const struct scrcpy_options scrcpy_options_default = {
     .v4l2_device = NULL,
 #endif
     .log_level = SC_LOG_LEVEL_INFO,
+    .codec = SC_CODEC_H264,
+    .audio_codec = SC_CODEC_OPUS,
     .record_format = SC_RECORD_FORMAT_AUTO,
     .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
     .port_range = {
@@ -26,7 +28,8 @@ const struct scrcpy_options scrcpy_options_default = {
         .count = 2,
     },
     .max_size = 0,
-    .bit_rate = DEFAULT_BIT_RATE,
+    .bit_rate = 0,
+    .audio_bit_rate = 0,
     .max_fps = 0,
     .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
     .rotation = 0,
@@ -65,4 +68,5 @@ const struct scrcpy_options scrcpy_options_default = {
     .cleanup = true,
     .start_fps_counter = false,
     .power_on = true,
+    .audio = true,
 };

app/src/options.h

@@ -23,6 +23,14 @@ enum sc_record_format {
     SC_RECORD_FORMAT_MKV,
 };
 
+enum sc_codec {
+    SC_CODEC_H264,
+    SC_CODEC_H265,
+    SC_CODEC_AV1,
+    SC_CODEC_OPUS,
+    SC_CODEC_AAC,
+};
+
 enum sc_lock_video_orientation {
     SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
     // lock the current orientation when scrcpy starts
@@ -93,6 +101,8 @@ struct scrcpy_options {
     const char *v4l2_device;
 #endif
     enum sc_log_level log_level;
+    enum sc_codec codec;
+    enum sc_codec audio_codec;
     enum sc_record_format record_format;
     enum sc_keyboard_input_mode keyboard_input_mode;
     enum sc_mouse_input_mode mouse_input_mode;
@@ -102,6 +112,7 @@ struct scrcpy_options {
     struct sc_shortcut_mods shortcut_mods;
     uint16_t max_size;
     uint32_t bit_rate;
+    uint32_t audio_bit_rate;
     uint16_t max_fps;
     enum sc_lock_video_orientation lock_video_orientation;
     uint8_t rotation;
@@ -140,6 +151,7 @@ struct scrcpy_options {
     bool cleanup;
     bool start_fps_counter;
     bool power_on;
+    bool audio;
 };
 
 extern const struct scrcpy_options scrcpy_options_default;

app/src/packet_merger.c

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

app/src/packet_merger.h

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

app/src/receiver.c

@@ -7,7 +7,7 @@
 #include "util/log.h"
 
 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
+sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
               struct sc_acksync *acksync) {
     bool ok = sc_mutex_init(&receiver->mutex);
     if (!ok) {
@@ -21,12 +21,12 @@ receiver_init(struct receiver *receiver, sc_socket control_socket,
 }
 
 void
-receiver_destroy(struct receiver *receiver) {
+sc_receiver_destroy(struct sc_receiver *receiver) {
     sc_mutex_destroy(&receiver->mutex);
 }
 
 static void
-process_msg(struct receiver *receiver, struct device_msg *msg) {
+process_msg(struct sc_receiver *receiver, struct device_msg *msg) {
     switch (msg->type) {
         case DEVICE_MSG_TYPE_CLIPBOARD: {
             char *current = SDL_GetClipboardText();
@@ -51,7 +51,7 @@ process_msg(struct receiver *receiver, struct device_msg *msg) {
 }
 
 static ssize_t
-process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
+process_msgs(struct sc_receiver *receiver, const unsigned char *buf, size_t len) {
     size_t head = 0;
     for (;;) {
         struct device_msg msg;
@@ -76,7 +76,7 @@ process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
 
 static int
 run_receiver(void *data) {
-    struct receiver *receiver = data;
+    struct sc_receiver *receiver = data;
 
     static unsigned char buf[DEVICE_MSG_MAX_SIZE];
     size_t head = 0;
@@ -108,7 +108,7 @@ run_receiver(void *data) {
 }
 
 bool
-receiver_start(struct receiver *receiver) {
+sc_receiver_start(struct sc_receiver *receiver) {
     LOGD("Starting receiver thread");
 
     bool ok = sc_thread_create(&receiver->thread, run_receiver,
@@ -122,6 +122,6 @@ receiver_start(struct receiver *receiver) {
 }
 
 void
-receiver_join(struct receiver *receiver) {
+sc_receiver_join(struct sc_receiver *receiver) {
     sc_thread_join(&receiver->thread, NULL);
 }

app/src/receiver.h

@@ -11,7 +11,7 @@
 
 // receive events from the device
 // managed by the controller
-struct receiver {
+struct sc_receiver {
     sc_socket control_socket;
     sc_thread thread;
     sc_mutex mutex;
@@ -20,18 +20,18 @@ struct receiver {
 };
 
 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
+sc_receiver_init(struct sc_receiver *receiver, sc_socket control_socket,
                  struct sc_acksync *acksync);
 
 void
-receiver_destroy(struct receiver *receiver);
+sc_receiver_destroy(struct sc_receiver *receiver);
 
 bool
-receiver_start(struct receiver *receiver);
+sc_receiver_start(struct sc_receiver *receiver);
 
-// no receiver_stop(), it will automatically stop on control_socket shutdown
+// no sc_receiver_stop(), it will automatically stop on control_socket shutdown
 
 void
-receiver_join(struct receiver *receiver);
+sc_receiver_join(struct sc_receiver *receiver);
 
 #endif

app/src/recorder.c

@@ -8,8 +8,11 @@
 #include "util/log.h"
 #include "util/str.h"
 
-/** Downcast packet_sink to recorder */
-#define DOWNCAST(SINK) container_of(SINK, struct sc_recorder, packet_sink)
+/** Downcast packet sinks to recorder */
+#define DOWNCAST_VIDEO(SINK) \
+    container_of(SINK, struct sc_recorder, video_packet_sink)
+#define DOWNCAST_AUDIO(SINK) \
+    container_of(SINK, struct sc_recorder, audio_packet_sink)
 
 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
 
@@ -78,9 +81,7 @@ sc_recorder_get_format_name(enum sc_record_format format) {
 }
 
 static bool
-sc_recorder_write_header(struct sc_recorder *recorder, const AVPacket *packet) {
-    AVStream *ostream = recorder->ctx->streams[0];
-
+sc_recorder_set_extradata(AVStream *ostream, const AVPacket *packet) {
     uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
     if (!extradata) {
         LOG_OOM();
@@ -92,170 +93,56 @@ sc_recorder_write_header(struct sc_recorder *recorder, const AVPacket *packet) {
 
     ostream->codecpar->extradata = extradata;
     ostream->codecpar->extradata_size = packet->size;
-
-    int ret = avformat_write_header(recorder->ctx, NULL);
-    if (ret < 0) {
-        LOGE("Failed to write header to %s", recorder->filename);
-        return false;
-    }
-
     return true;
 }
 
-static void
-sc_recorder_rescale_packet(struct sc_recorder *recorder, AVPacket *packet) {
-    AVStream *ostream = recorder->ctx->streams[0];
-    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base);
+static inline void
+sc_recorder_rescale_packet(AVStream *stream, AVPacket *packet) {
+    av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, stream->time_base);
 }
 
 static bool
-sc_recorder_write(struct sc_recorder *recorder, AVPacket *packet) {
-    if (!recorder->header_written) {
-        if (packet->pts != AV_NOPTS_VALUE) {
-            LOGE("The first packet is not a config packet");
-            return false;
-        }
-        bool ok = sc_recorder_write_header(recorder, packet);
-        if (!ok) {
-            return false;
-        }
-        recorder->header_written = true;
-        return true;
-    }
-
-    if (packet->pts == AV_NOPTS_VALUE) {
-        // ignore config packets
-        return true;
-    }
-
-    sc_recorder_rescale_packet(recorder, packet);
-    return av_write_frame(recorder->ctx, packet) >= 0;
+sc_recorder_write_stream(struct sc_recorder *recorder, int stream_index,
+                         AVPacket *packet) {
+    AVStream *stream = recorder->ctx->streams[stream_index];
+    sc_recorder_rescale_packet(stream, packet);
+    return av_interleaved_write_frame(recorder->ctx, packet) >= 0;
 }
 
-static int
-run_recorder(void *data) {
-    struct sc_recorder *recorder = data;
+static inline bool
+sc_recorder_write_video(struct sc_recorder *recorder, AVPacket *packet) {
+    return sc_recorder_write_stream(recorder, recorder->video_stream_index,
+                                    packet);
+}
 
-    for (;;) {
-        sc_mutex_lock(&recorder->mutex);
-
-        while (!recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
-            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
-        }
-
-        // if stopped is set, continue to process the remaining events (to
-        // finish the recording) before actually stopping
-
-        if (recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
-            sc_mutex_unlock(&recorder->mutex);
-            struct sc_record_packet *last = recorder->previous;
-            if (last) {
-                // assign an arbitrary duration to the last packet
-                last->packet->duration = 100000;
-                bool ok = sc_recorder_write(recorder, last->packet);
-                if (!ok) {
-                    // failing to write the last frame is not very serious, no
-                    // future frame may depend on it, so the resulting file
-                    // will still be valid
-                    LOGW("Could not record last packet");
-                }
-                sc_record_packet_delete(last);
-            }
-            break;
-        }
-
-        struct sc_record_packet *rec;
-        sc_queue_take(&recorder->queue, next, &rec);
-
-        sc_mutex_unlock(&recorder->mutex);
-
-        // recorder->previous is only written from this thread, no need to lock
-        struct sc_record_packet *previous = recorder->previous;
-        recorder->previous = rec;
-
-        if (!previous) {
-            // we just received the first packet
-            continue;
-        }
-
-        // config packets have no PTS, we must ignore them
-        if (rec->packet->pts != AV_NOPTS_VALUE
-            && previous->packet->pts != AV_NOPTS_VALUE) {
-            // we now know the duration of the previous packet
-            previous->packet->duration =
-                rec->packet->pts - previous->packet->pts;
-        }
-
-        bool ok = sc_recorder_write(recorder, previous->packet);
-        sc_record_packet_delete(previous);
-        if (!ok) {
-            LOGE("Could not record packet");
-
-            sc_mutex_lock(&recorder->mutex);
-            recorder->failed = true;
-            // discard pending packets
-            sc_recorder_queue_clear(&recorder->queue);
-            sc_mutex_unlock(&recorder->mutex);
-            break;
-        }
-    }
-
-    if (!recorder->failed) {
-        if (recorder->header_written) {
-            int ret = av_write_trailer(recorder->ctx);
-            if (ret < 0) {
-                LOGE("Failed to write trailer to %s", recorder->filename);
-                recorder->failed = true;
-            }
-        } else {
-            // the recorded file is empty
-            recorder->failed = true;
-        }
-    }
-
-    if (recorder->failed) {
-        LOGE("Recording failed to %s", recorder->filename);
-    } else {
-        const char *format_name = sc_recorder_get_format_name(recorder->format);
-        LOGI("Recording complete to %s file: %s", format_name,
-                                                  recorder->filename);
-    }
-
-    LOGD("Recorder thread ended");
-
-    return 0;
+static inline bool
+sc_recorder_write_audio(struct sc_recorder *recorder, AVPacket *packet) {
+    return sc_recorder_write_stream(recorder, recorder->audio_stream_index,
+                                    packet);
 }
 
 static bool
-sc_recorder_open(struct sc_recorder *recorder, const AVCodec *input_codec) {
-    bool ok = sc_mutex_init(&recorder->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&recorder->queue_cond);
-    if (!ok) {
-        goto error_mutex_destroy;
-    }
-
-    sc_queue_init(&recorder->queue);
-    recorder->stopped = false;
-    recorder->failed = false;
-    recorder->header_written = false;
-    recorder->previous = NULL;
-
+sc_recorder_open_output_file(struct sc_recorder *recorder) {
     const char *format_name = sc_recorder_get_format_name(recorder->format);
     assert(format_name);
     const AVOutputFormat *format = find_muxer(format_name);
     if (!format) {
         LOGE("Could not find muxer");
-        goto error_cond_destroy;
+        return false;
     }
 
     recorder->ctx = avformat_alloc_context();
     if (!recorder->ctx) {
         LOG_OOM();
-        goto error_cond_destroy;
+        return false;
+    }
+
+    int ret = avio_open(&recorder->ctx->pb, recorder->filename,
+                        AVIO_FLAG_WRITE);
+    if (ret < 0) {
+        LOGE("Failed to open output file: %s", recorder->filename);
+        avformat_free_context(recorder->ctx);
+        return false;
     }
 
     // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate()
@@ -267,71 +154,436 @@ sc_recorder_open(struct sc_recorder *recorder, const AVCodec *input_codec) {
     av_dict_set(&recorder->ctx->metadata, "comment",
                 "Recorded by scrcpy " SCRCPY_VERSION, 0);
 
-    AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec);
-    if (!ostream) {
-        goto error_avformat_free_context;
-    }
-
-    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
-    ostream->codecpar->codec_id = input_codec->id;
-    ostream->codecpar->format = AV_PIX_FMT_YUV420P;
-    ostream->codecpar->width = recorder->declared_frame_size.width;
-    ostream->codecpar->height = recorder->declared_frame_size.height;
-
-    int ret = avio_open(&recorder->ctx->pb, recorder->filename,
-                        AVIO_FLAG_WRITE);
-    if (ret < 0) {
-        LOGE("Failed to open output file: %s", recorder->filename);
-        // ostream will be cleaned up during context cleaning
-        goto error_avformat_free_context;
-    }
-
-    LOGD("Starting recorder thread");
-    ok = sc_thread_create(&recorder->thread, run_recorder, "scrcpy-recorder",
-                          recorder);
-    if (!ok) {
-        LOGE("Could not start recorder thread");
-        goto error_avio_close;
-    }
-
     LOGI("Recording started to %s file: %s", format_name, recorder->filename);
-
     return true;
-
-error_avio_close:
-    avio_close(recorder->ctx->pb);
-error_avformat_free_context:
-    avformat_free_context(recorder->ctx);
-error_cond_destroy:
-    sc_cond_destroy(&recorder->queue_cond);
-error_mutex_destroy:
-    sc_mutex_destroy(&recorder->mutex);
-
-    return false;
 }
 
 static void
-sc_recorder_close(struct sc_recorder *recorder) {
-    sc_mutex_lock(&recorder->mutex);
-    recorder->stopped = true;
-    sc_cond_signal(&recorder->queue_cond);
-    sc_mutex_unlock(&recorder->mutex);
-
-    sc_thread_join(&recorder->thread, NULL);
-
+sc_recorder_close_output_file(struct sc_recorder *recorder) {
     avio_close(recorder->ctx->pb);
     avformat_free_context(recorder->ctx);
-    sc_cond_destroy(&recorder->queue_cond);
-    sc_mutex_destroy(&recorder->mutex);
 }
 
 static bool
-sc_recorder_push(struct sc_recorder *recorder, const AVPacket *packet) {
+sc_recorder_wait_video_stream(struct sc_recorder *recorder) {
     sc_mutex_lock(&recorder->mutex);
-    assert(!recorder->stopped);
+    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 (recorder->failed) {
-        // reject any new packet (this will stop the stream)
+    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;
+        stream->codecpar->ch_layout.nb_channels = 2;
+        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 (sc_queue_is_empty(&recorder->video_queue)) {
+        // The video queue is empty
+        return true;
+    }
+
+    if (recorder->audio && sc_queue_is_empty(&recorder->audio_queue)) {
+        // The audio queue is empty (when audio is enabled)
+        return true;
+    }
+
+    // No queue is empty
+    return false;
+}
+
+static bool
+sc_recorder_process_header(struct sc_recorder *recorder) {
+    sc_mutex_lock(&recorder->mutex);
+
+    while (!recorder->stopped && sc_recorder_has_empty_queues(recorder)) {
+        sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
+    }
+
+    if (recorder->stopped && sc_queue_is_empty(&recorder->video_queue)) {
+        // If the recorder is stopped, don't process anything if there are not
+        // at least video packets
+        sc_mutex_unlock(&recorder->mutex);
+        return false;
+    }
+
+    struct sc_record_packet *video_pkt;
+    sc_queue_take(&recorder->video_queue, next, &video_pkt);
+
+    struct sc_record_packet *audio_pkt = NULL;
+    if (!sc_queue_is_empty(&recorder->audio_queue)) {
+        assert(recorder->audio);
+        sc_queue_take(&recorder->audio_queue, next, &audio_pkt);
+    }
+
+    sc_mutex_unlock(&recorder->mutex);
+
+    int ret = false;
+
+    if (video_pkt->packet->pts != AV_NOPTS_VALUE) {
+        LOGE("The first video packet is not a config packet");
+        goto end;
+    }
+
+    assert(recorder->video_stream_index >= 0);
+    AVStream *video_stream =
+        recorder->ctx->streams[recorder->video_stream_index];
+    bool ok = sc_recorder_set_extradata(video_stream, video_pkt->packet);
+    if (!ok) {
+        goto end;
+    }
+
+    if (audio_pkt) {
+        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);
+        AVStream *audio_stream =
+            recorder->ctx->streams[recorder->audio_stream_index];
+        ok = sc_recorder_set_extradata(audio_stream, audio_pkt->packet);
+        if (!ok) {
+            goto end;
+        }
+    }
+
+    ok = avformat_write_header(recorder->ctx, NULL) >= 0;
+    if (!ok) {
+        LOGE("Failed to write header to %s", recorder->filename);
+        goto end;
+    }
+
+    ret = true;
+
+end:
+    sc_record_packet_delete(video_pkt);
+    if (audio_pkt) {
+        sc_record_packet_delete(audio_pkt);
+    }
+
+    return ret;
+}
+
+static bool
+sc_recorder_process_packets(struct sc_recorder *recorder) {
+    int64_t pts_origin = AV_NOPTS_VALUE;
+
+    bool header_written = sc_recorder_process_header(recorder);
+    if (!header_written) {
+        return false;
+    }
+
+    struct sc_record_packet *video_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)
+    struct sc_record_packet *video_pkt_previous = NULL;
+
+    bool error = false;
+
+    for (;;) {
+        sc_mutex_lock(&recorder->mutex);
+
+        while (!recorder->stopped) {
+            if (!video_pkt && !sc_queue_is_empty(&recorder->video_queue)) {
+                // A new packet may be assigned to video_pkt and be processed
+                break;
+            }
+            if (recorder->audio && !audio_pkt
+                    && !sc_queue_is_empty(&recorder->audio_queue)) {
+                // A new packet may be assigned to audio_pkt and be processed
+                break;
+            }
+            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 audio, then the audio_queue will remain empty forever
+        // and audio_pkt will always be NULL.
+        assert(recorder->audio
+                || (!audio_pkt && sc_queue_is_empty(&recorder->audio_queue)));
+
+        if (!video_pkt && !sc_queue_is_empty(&recorder->video_queue)) {
+            sc_queue_take(&recorder->video_queue, next, &video_pkt);
+        }
+
+        if (!audio_pkt && !sc_queue_is_empty(&recorder->audio_queue)) {
+            sc_queue_take(&recorder->audio_queue, next, &audio_pkt);
+        }
+
+        if (recorder->stopped && !video_pkt && !audio_pkt) {
+            assert(sc_queue_is_empty(&recorder->video_queue));
+            assert(sc_queue_is_empty(&recorder->audio_queue));
+            sc_mutex_unlock(&recorder->mutex);
+            break;
+        }
+
+        assert(video_pkt || audio_pkt); // at least one
+
+        sc_mutex_unlock(&recorder->mutex);
+
+        // 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->packet->pts == AV_NOPTS_VALUE) {
+            sc_record_packet_delete(video_pkt);
+            video_pkt = NULL;
+        }
+
+        if (audio_pkt && audio_pkt->packet->pts == AV_NOPTS_VALUE) {
+            sc_record_packet_delete(audio_pkt);
+            audio_pkt= NULL;
+        }
+
+        if (pts_origin == AV_NOPTS_VALUE) {
+            if (!recorder->audio) {
+                assert(video_pkt);
+                pts_origin = video_pkt->packet->pts;
+            } else if (video_pkt && audio_pkt) {
+                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->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;
+            }
+        }
+
+        assert(pts_origin != AV_NOPTS_VALUE);
+
+        if (video_pkt) {
+            video_pkt->packet->pts -= pts_origin;
+            video_pkt->packet->dts = video_pkt->packet->pts;
+
+            if (video_pkt_previous) {
+                // we now know the duration of the previous packet
+                video_pkt_previous->packet->duration =
+                    video_pkt->packet->pts - video_pkt_previous->packet->pts;
+
+                bool ok = sc_recorder_write_video(recorder,
+                                                  video_pkt_previous->packet);
+                sc_record_packet_delete(video_pkt_previous);
+                if (!ok) {
+                    LOGE("Could not record video packet");
+                    error = true;
+                    goto end;
+                }
+            }
+
+            video_pkt_previous = video_pkt;
+            video_pkt = NULL;
+        }
+
+        if (audio_pkt) {
+            audio_pkt->packet->pts -= pts_origin;
+            audio_pkt->packet->dts = audio_pkt->packet->pts;
+
+            bool ok = sc_recorder_write_audio(recorder, audio_pkt->packet);
+            if (!ok) {
+                LOGE("Could not record audio packet");
+                error = true;
+                goto end;
+            }
+
+            sc_record_packet_delete(audio_pkt);
+            audio_pkt = NULL;
+        }
+    }
+
+    // Write the last video packet
+    struct sc_record_packet *last = video_pkt_previous;
+    if (last) {
+        // assign an arbitrary duration to the last packet
+        last->packet->duration = 100000;
+        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");
+        }
+        sc_record_packet_delete(last);
+    }
+
+    int ret = av_write_trailer(recorder->ctx);
+    if (ret < 0) {
+        LOGE("Failed to write trailer to %s", recorder->filename);
+        error = false;
+    }
+
+end:
+    if (video_pkt) {
+        sc_record_packet_delete(video_pkt);
+    }
+    if (audio_pkt) {
+        sc_record_packet_delete(audio_pkt);
+    }
+
+    return !error;
+}
+
+static bool
+sc_recorder_record(struct sc_recorder *recorder) {
+    bool ok = sc_recorder_open_output_file(recorder);
+    if (!ok) {
+        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;
+}
+
+static int
+run_recorder(void *data) {
+    struct sc_recorder *recorder = data;
+
+    bool success = sc_recorder_record(recorder);
+
+    sc_mutex_lock(&recorder->mutex);
+    // Prevent the producer to push any new packet
+    recorder->stopped = true;
+    // Discard pending packets
+    sc_recorder_queue_clear(&recorder->video_queue);
+    sc_mutex_unlock(&recorder->mutex);
+
+    if (success) {
+        const char *format_name = sc_recorder_get_format_name(recorder->format);
+        LOGI("Recording complete to %s file: %s", format_name,
+                                                  recorder->filename);
+    } else {
+        LOGE("Recording failed to %s", recorder->filename);
+    }
+
+    LOGD("Recorder thread ended");
+
+    recorder->cbs->on_ended(recorder, success, recorder->cbs_userdata);
+
+    return 0;
+}
+
+static bool
+sc_recorder_video_packet_sink_open(struct sc_packet_sink *sink,
+                                   const AVCodec *codec) {
+    struct sc_recorder *recorder = DOWNCAST_VIDEO(sink);
+    assert(codec);
+
+    sc_mutex_lock(&recorder->mutex);
+    if (recorder->stopped) {
+        sc_mutex_unlock(&recorder->mutex);
+        return false;
+    }
+
+    recorder->video_codec = codec;
+    sc_cond_signal(&recorder->stream_cond);
+    sc_mutex_unlock(&recorder->mutex);
+
+    return true;
+}
+
+static void
+sc_recorder_video_packet_sink_close(struct sc_packet_sink *sink) {
+    struct sc_recorder *recorder = DOWNCAST_VIDEO(sink);
+
+    sc_mutex_lock(&recorder->mutex);
+    // EOS also stops the recorder
+    recorder->stopped = true;
+    sc_cond_signal(&recorder->queue_cond);
+    sc_mutex_unlock(&recorder->mutex);
+}
+
+static bool
+sc_recorder_video_packet_sink_push(struct sc_packet_sink *sink,
+                                   const AVPacket *packet) {
+    struct sc_recorder *recorder = DOWNCAST_VIDEO(sink);
+
+    sc_mutex_lock(&recorder->mutex);
+
+    if (recorder->stopped) {
+        // reject any new packet
         sc_mutex_unlock(&recorder->mutex);
         return false;
     }
@@ -343,7 +595,9 @@ sc_recorder_push(struct sc_recorder *recorder, const AVPacket *packet) {
         return false;
     }
 
-    sc_queue_push(&recorder->queue, next, rec);
+    rec->packet->stream_index = 0;
+
+    sc_queue_push(&recorder->video_queue, next, rec);
     sc_cond_signal(&recorder->queue_cond);
 
     sc_mutex_unlock(&recorder->mutex);
@@ -351,51 +605,190 @@ sc_recorder_push(struct sc_recorder *recorder, const AVPacket *packet) {
 }
 
 static bool
-sc_recorder_packet_sink_open(struct sc_packet_sink *sink,
+sc_recorder_audio_packet_sink_open(struct sc_packet_sink *sink,
                                    const AVCodec *codec) {
-    struct sc_recorder *recorder = DOWNCAST(sink);
-    return sc_recorder_open(recorder, codec);
+    struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
+    assert(recorder->audio);
+    // only written from this thread, no need to lock
+    assert(!recorder->audio_disabled);
+    assert(codec);
+
+    sc_mutex_lock(&recorder->mutex);
+    recorder->audio_codec = codec;
+    sc_cond_signal(&recorder->stream_cond);
+    sc_mutex_unlock(&recorder->mutex);
+
+    return true;
 }
 
 static void
-sc_recorder_packet_sink_close(struct sc_packet_sink *sink) {
-    struct sc_recorder *recorder = DOWNCAST(sink);
-    sc_recorder_close(recorder);
+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_disabled);
+
+    sc_mutex_lock(&recorder->mutex);
+    // EOS also stops the recorder
+    // TODO must stop only once both video and audio stream are complete
+    recorder->stopped = true;
+    sc_cond_signal(&recorder->queue_cond);
+    sc_mutex_unlock(&recorder->mutex);
 }
 
 static bool
-sc_recorder_packet_sink_push(struct sc_packet_sink *sink,
+sc_recorder_audio_packet_sink_push(struct sc_packet_sink *sink,
                                    const AVPacket *packet) {
-    struct sc_recorder *recorder = DOWNCAST(sink);
-    return sc_recorder_push(recorder, packet);
+    struct sc_recorder *recorder = DOWNCAST_AUDIO(sink);
+    assert(recorder->audio);
+    // only written from this thread, no need to lock
+    assert(!recorder->audio_disabled);
+
+    sc_mutex_lock(&recorder->mutex);
+
+    if (recorder->stopped) {
+        // reject any new packet
+        sc_mutex_unlock(&recorder->mutex);
+        return false;
+    }
+
+    struct sc_record_packet *rec = sc_record_packet_new(packet);
+    if (!rec) {
+        LOG_OOM();
+        sc_mutex_unlock(&recorder->mutex);
+        return false;
+    }
+
+    rec->packet->stream_index = 1;
+
+    sc_queue_push(&recorder->audio_queue, next, rec);
+    sc_cond_signal(&recorder->queue_cond);
+
+    sc_mutex_unlock(&recorder->mutex);
+    return true;
+}
+
+static void
+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_disabled);
+    assert(!recorder->audio_codec);
+
+    LOGW("Audio stream recording disabled");
+
+    sc_mutex_lock(&recorder->mutex);
+    recorder->audio_disabled = true;
+    sc_cond_signal(&recorder->stream_cond);
+    sc_mutex_unlock(&recorder->mutex);
 }
 
 bool
-sc_recorder_init(struct sc_recorder *recorder,
-                 const char *filename,
-                 enum sc_record_format format,
-                 struct sc_size declared_frame_size) {
+sc_recorder_init(struct sc_recorder *recorder, const char *filename,
+                 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) {
         LOG_OOM();
         return false;
     }
 
+    bool ok = sc_mutex_init(&recorder->mutex);
+    if (!ok) {
+        goto error_free_filename;
+    }
+
+    ok = sc_cond_init(&recorder->queue_cond);
+    if (!ok) {
+        goto error_mutex_destroy;
+    }
+
+    ok = sc_cond_init(&recorder->stream_cond);
+    if (!ok) {
+        goto error_queue_cond_destroy;
+    }
+
+    recorder->audio = audio;
+
+    sc_queue_init(&recorder->video_queue);
+    sc_queue_init(&recorder->audio_queue);
+    recorder->stopped = false;
+
+    recorder->video_codec = NULL;
+    recorder->audio_codec = NULL;
+    recorder->audio_disabled = false;
+
+    recorder->video_stream_index = -1;
+    recorder->audio_stream_index = -1;
+
     recorder->format = format;
     recorder->declared_frame_size = declared_frame_size;
 
-    static const struct sc_packet_sink_ops ops = {
-        .open = sc_recorder_packet_sink_open,
-        .close = sc_recorder_packet_sink_close,
-        .push = sc_recorder_packet_sink_push,
+    assert(cbs && cbs->on_ended);
+
+    recorder->cbs = cbs;
+    recorder->cbs_userdata = cbs_userdata;
+
+    static const struct sc_packet_sink_ops video_ops = {
+        .open = sc_recorder_video_packet_sink_open,
+        .close = sc_recorder_video_packet_sink_close,
+        .push = sc_recorder_video_packet_sink_push,
     };
 
-    recorder->packet_sink.ops = &ops;
+    recorder->video_packet_sink.ops = &video_ops;
+
+    if (audio) {
+        static const struct sc_packet_sink_ops audio_ops = {
+            .open = sc_recorder_audio_packet_sink_open,
+            .close = sc_recorder_audio_packet_sink_close,
+            .push = sc_recorder_audio_packet_sink_push,
+            .disable = sc_recorder_audio_packet_sink_disable,
+        };
+
+        recorder->audio_packet_sink.ops = &audio_ops;
+    }
+
+    ok = sc_thread_create(&recorder->thread, run_recorder, "scrcpy-recorder",
+                          recorder);
+    if (!ok) {
+        LOGE("Could not start recorder thread");
+        goto error_stream_cond_destroy;
+    }
 
     return true;
+
+error_stream_cond_destroy:
+    sc_cond_destroy(&recorder->stream_cond);
+error_queue_cond_destroy:
+    sc_cond_destroy(&recorder->queue_cond);
+error_mutex_destroy:
+    sc_mutex_destroy(&recorder->mutex);
+error_free_filename:
+    free(recorder->filename);
+
+    return false;
+}
+
+void
+sc_recorder_stop(struct sc_recorder *recorder) {
+    sc_mutex_lock(&recorder->mutex);
+    recorder->stopped = true;
+    sc_cond_signal(&recorder->queue_cond);
+    sc_cond_signal(&recorder->stream_cond);
+    sc_mutex_unlock(&recorder->mutex);
+}
+
+void
+sc_recorder_join(struct sc_recorder *recorder) {
+    sc_thread_join(&recorder->thread, NULL);
 }
 
 void
 sc_recorder_destroy(struct sc_recorder *recorder) {
+    sc_cond_destroy(&recorder->stream_cond);
+    sc_cond_destroy(&recorder->queue_cond);
+    sc_mutex_destroy(&recorder->mutex);
     free(recorder->filename);
 }

app/src/recorder.h

@@ -20,32 +20,63 @@ struct sc_record_packet {
 struct sc_recorder_queue SC_QUEUE(struct sc_record_packet);
 
 struct sc_recorder {
-    struct sc_packet_sink packet_sink; // packet sink trait
+    struct sc_packet_sink video_packet_sink;
+    struct sc_packet_sink audio_packet_sink;
+
+    /* The audio flag is unprotected:
+     *  - it is initialized from sc_recorder_init() from the main thread;
+     *  - it may be reset once from the recorder thread if the audio is
+     *    disabled dynamically.
+     *
+     * Therefore, once the recorder thread is started, only the recorder thread
+     * may access it without data races.
+     */
+    bool audio;
 
     char *filename;
     enum sc_record_format format;
     AVFormatContext *ctx;
     struct sc_size declared_frame_size;
-    bool header_written;
 
     sc_thread thread;
     sc_mutex mutex;
     sc_cond queue_cond;
-    bool stopped; // set on recorder_close()
-    bool failed; // set on packet write failure
-    struct sc_recorder_queue queue;
+    // 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;
 
-    // we can write a packet only once we received the next one so that we can
-    // set its duration (next_pts - current_pts)
-    // "previous" is only accessed from the recorder thread, so it does not
-    // need to be protected by the mutex
-    struct sc_record_packet *previous;
+    // wake up the recorder thread once the video or audio codec is known
+    sc_cond stream_cond;
+    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;
+
+    int video_stream_index;
+    int audio_stream_index;
+
+    const struct sc_recorder_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+struct sc_recorder_callbacks {
+    void (*on_ended)(struct sc_recorder *recorder, bool success,
+                     void *userdata);
 };
 
 bool
 sc_recorder_init(struct sc_recorder *recorder, const char *filename,
-                 enum sc_record_format format,
-                 struct sc_size declared_frame_size);
+                 enum sc_record_format format, bool audio,
+                 struct sc_size declared_frame_size,
+                 const struct sc_recorder_callbacks *cbs, void *cbs_userdata);
+
+void
+sc_recorder_stop(struct sc_recorder *recorder);
+
+void
+sc_recorder_join(struct sc_recorder *recorder);
 
 void
 sc_recorder_destroy(struct sc_recorder *recorder);

app/src/scrcpy.c

@@ -32,6 +32,7 @@
 #include "util/acksync.h"
 #include "util/log.h"
 #include "util/net.h"
+#include "util/rand.h"
 #ifdef HAVE_V4L2
 # include "v4l2_sink.h"
 #endif
@@ -39,7 +40,8 @@
 struct scrcpy {
     struct sc_server server;
     struct sc_screen screen;
-    struct sc_demuxer demuxer;
+    struct sc_demuxer video_demuxer;
+    struct sc_demuxer audio_demuxer;
     struct sc_decoder decoder;
     struct sc_recorder recorder;
 #ifdef HAVE_V4L2
@@ -154,9 +156,15 @@ event_loop(struct scrcpy *s) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         switch (event.type) {
-            case EVENT_STREAM_STOPPED:
+            case SC_EVENT_DEVICE_DISCONNECTED:
                 LOGW("Device disconnected");
                 return SCRCPY_EXIT_DISCONNECTED;
+            case SC_EVENT_DEMUXER_ERROR:
+                LOGE("Demuxer error");
+                return SCRCPY_EXIT_FAILURE;
+            case SC_EVENT_RECORDER_ERROR:
+                LOGE("Recorder error");
+                return SCRCPY_EXIT_FAILURE;
             case SDL_QUIT:
                 LOGD("User requested to quit");
                 return SCRCPY_EXIT_SUCCESS;
@@ -178,10 +186,10 @@ await_for_server(bool *connected) {
                 LOGD("User requested to quit");
                 *connected = false;
                 return true;
-            case EVENT_SERVER_CONNECTION_FAILED:
+            case SC_EVENT_SERVER_CONNECTION_FAILED:
                 LOGE("Server connection failed");
                 return false;
-            case EVENT_SERVER_CONNECTED:
+            case SC_EVENT_SERVER_CONNECTED:
                 LOGD("Server connected");
                 *connected = true;
                 return true;
@@ -232,11 +240,37 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
 }
 
 static void
-sc_demuxer_on_eos(struct sc_demuxer *demuxer, void *userdata) {
+sc_recorder_on_ended(struct sc_recorder *recorder, bool success,
+                     void *userdata) {
+    (void) recorder;
+    (void) userdata;
+
+    if (!success) {
+        PUSH_EVENT(SC_EVENT_RECORDER_ERROR);
+    }
+}
+
+static void
+sc_video_demuxer_on_ended(struct sc_demuxer *demuxer, bool eos,
+                          void *userdata) {
     (void) demuxer;
     (void) userdata;
 
-    PUSH_EVENT(EVENT_STREAM_STOPPED);
+    if (eos) {
+        PUSH_EVENT(SC_EVENT_DEVICE_DISCONNECTED);
+    } else {
+        PUSH_EVENT(SC_EVENT_DEMUXER_ERROR);
+    }
+}
+
+static void
+sc_audio_demuxer_on_ended(struct sc_demuxer *demuxer, bool eos,
+                          void *userdata) {
+    (void) demuxer;
+    (void) eos;
+    (void) userdata;
+
+    // Contrary to the video demuxer, keep mirroring if only the audio fails
 }
 
 static void
@@ -244,7 +278,7 @@ sc_server_on_connection_failed(struct sc_server *server, void *userdata) {
     (void) server;
     (void) userdata;
 
-    PUSH_EVENT(EVENT_SERVER_CONNECTION_FAILED);
+    PUSH_EVENT(SC_EVENT_SERVER_CONNECTION_FAILED);
 }
 
 static void
@@ -252,7 +286,7 @@ sc_server_on_connected(struct sc_server *server, void *userdata) {
     (void) server;
     (void) userdata;
 
-    PUSH_EVENT(EVENT_SERVER_CONNECTED);
+    PUSH_EVENT(SC_EVENT_SERVER_CONNECTED);
 }
 
 static void
@@ -265,6 +299,15 @@ sc_server_on_disconnected(struct sc_server *server, void *userdata) {
     // event
 }
 
+// Generate a scrcpy id to differentiate multiple running scrcpy instances
+static uint32_t
+scrcpy_generate_scid() {
+    struct sc_rand rand;
+    sc_rand_init(&rand);
+    // Only use 31 bits to avoid issues with signed values on the Java-side
+    return sc_rand_u32(&rand) & 0x7FFFFFFF;
+}
+
 enum scrcpy_exit_code
 scrcpy(struct scrcpy_options *options) {
     static struct scrcpy scrcpy;
@@ -286,7 +329,8 @@ scrcpy(struct scrcpy_options *options) {
 #ifdef HAVE_V4L2
     bool v4l2_sink_initialized = false;
 #endif
-    bool demuxer_started = false;
+    bool video_demuxer_started = false;
+    bool audio_demuxer_started = false;
 #ifdef HAVE_USB
     bool aoa_hid_initialized = false;
     bool hid_keyboard_initialized = false;
@@ -298,21 +342,28 @@ scrcpy(struct scrcpy_options *options) {
 
     struct sc_acksync *acksync = NULL;
 
+    uint32_t scid = scrcpy_generate_scid();
+
     struct sc_server_params params = {
+        .scid = scid,
         .req_serial = options->serial,
         .select_usb = options->select_usb,
         .select_tcpip = options->select_tcpip,
         .log_level = options->log_level,
+        .codec = options->codec,
+        .audio_codec = options->audio_codec,
         .crop = options->crop,
         .port_range = options->port_range,
         .tunnel_host = options->tunnel_host,
         .tunnel_port = options->tunnel_port,
         .max_size = options->max_size,
         .bit_rate = options->bit_rate,
+        .audio_bit_rate = options->audio_bit_rate,
         .max_fps = options->max_fps,
         .lock_video_orientation = options->lock_video_orientation,
         .control = options->control,
         .display_id = options->display_id,
+        .audio = options->audio,
         .show_touches = options->show_touches,
         .stay_awake = options->stay_awake,
         .codec_options = options->codec_options,
@@ -395,10 +446,12 @@ scrcpy(struct scrcpy_options *options) {
 
     struct sc_recorder *rec = NULL;
     if (options->record_filename) {
-        if (!sc_recorder_init(&s->recorder,
-                              options->record_filename,
-                              options->record_format,
-                              info->frame_size)) {
+        static const struct sc_recorder_callbacks recorder_cbs = {
+            .on_ended = sc_recorder_on_ended,
+        };
+        if (!sc_recorder_init(&s->recorder, options->record_filename,
+                              options->record_format, options->audio,
+                              info->frame_size, &recorder_cbs, NULL)) {
             goto end;
         }
         rec = &s->recorder;
@@ -407,17 +460,29 @@ scrcpy(struct scrcpy_options *options) {
 
     av_log_set_callback(av_log_callback);
 
-    static const struct sc_demuxer_callbacks demuxer_cbs = {
-        .on_eos = sc_demuxer_on_eos,
+    static const struct sc_demuxer_callbacks video_demuxer_cbs = {
+        .on_ended = sc_video_demuxer_on_ended,
     };
-    sc_demuxer_init(&s->demuxer, s->server.video_socket, &demuxer_cbs, NULL);
+    sc_demuxer_init(&s->video_demuxer, "video", s->server.video_socket,
+                    &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, NULL);
+    }
 
     if (dec) {
-        sc_demuxer_add_sink(&s->demuxer, &dec->packet_sink);
+        sc_demuxer_add_sink(&s->video_demuxer, &dec->packet_sink);
     }
 
     if (rec) {
-        sc_demuxer_add_sink(&s->demuxer, &rec->packet_sink);
+        sc_demuxer_add_sink(&s->video_demuxer, &rec->video_packet_sink);
+        if (options->audio) {
+            sc_demuxer_add_sink(&s->audio_demuxer, &rec->audio_packet_sink);
+        }
     }
 
     struct sc_controller *controller = NULL;
@@ -625,17 +690,24 @@ aoa_hid_end:
 #endif
 
     // now we consumed the header values, the socket receives the video stream
-    // start the demuxer
-    if (!sc_demuxer_start(&s->demuxer)) {
+    // start the video demuxer
+    if (!sc_demuxer_start(&s->video_demuxer)) {
         goto end;
     }
-    demuxer_started = true;
+    video_demuxer_started = true;
+
+    if (options->audio) {
+        if (!sc_demuxer_start(&s->audio_demuxer)) {
+            goto end;
+        }
+        audio_demuxer_started = true;
+    }
 
     ret = event_loop(s);
     LOGD("quit...");
 
     // Close the window immediately on closing, because screen_destroy() may
-    // only be called once the demuxer thread is joined (it may take time)
+    // only be called once the video demuxer thread is joined (it may take time)
     sc_screen_hide_window(&s->screen);
 
 end:
@@ -662,6 +734,9 @@ end:
     if (file_pusher_initialized) {
         sc_file_pusher_stop(&s->file_pusher);
     }
+    if (recorder_initialized) {
+        sc_recorder_stop(&s->recorder);
+    }
     if (screen_initialized) {
         sc_screen_interrupt(&s->screen);
     }
@@ -673,8 +748,12 @@ end:
 
     // now that the sockets are shutdown, the demuxer and controller are
     // interrupted, we can join them
-    if (demuxer_started) {
-        sc_demuxer_join(&s->demuxer);
+    if (video_demuxer_started) {
+        sc_demuxer_join(&s->video_demuxer);
+    }
+
+    if (audio_demuxer_started) {
+        sc_demuxer_join(&s->audio_demuxer);
     }
 
 #ifdef HAVE_V4L2
@@ -693,8 +772,9 @@ end:
     }
 #endif
 
-    // Destroy the screen only after the demuxer is guaranteed to be finished,
-    // because otherwise the screen could receive new frames after destruction
+    // Destroy the screen only after the video demuxer is guaranteed to be
+    // finished, because otherwise the screen could receive new frames after
+    // destruction
     if (screen_initialized) {
         sc_screen_join(&s->screen);
         sc_screen_destroy(&s->screen);
@@ -708,6 +788,7 @@ end:
     }
 
     if (recorder_initialized) {
+        sc_recorder_join(&s->recorder);
         sc_recorder_destroy(&s->recorder);
     }
 

app/src/screen.c

@@ -371,7 +371,7 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
     bool need_new_event;
     if (previous_skipped) {
         sc_fps_counter_add_skipped_frame(&screen->fps_counter);
-        // The EVENT_NEW_FRAME triggered for the previous frame will consume
+        // The SC_EVENT_NEW_FRAME triggered for the previous frame will consume
         // this new frame instead, unless the previous event failed
         need_new_event = screen->event_failed;
     } else {
@@ -380,7 +380,7 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
 
     if (need_new_event) {
         static SDL_Event new_frame_event = {
-            .type = EVENT_NEW_FRAME,
+            .type = SC_EVENT_NEW_FRAME,
         };
 
         // Post the event on the UI thread
@@ -820,7 +820,7 @@ sc_screen_handle_event(struct sc_screen *screen, SDL_Event *event) {
     bool relative_mode = sc_screen_is_relative_mode(screen);
 
     switch (event->type) {
-        case EVENT_NEW_FRAME: {
+        case SC_EVENT_NEW_FRAME: {
             bool ok = sc_screen_update_frame(screen);
             if (!ok) {
                 LOGW("Frame update failed\n");

app/src/server.c

@@ -8,6 +8,7 @@
 #include <SDL2/SDL_platform.h>
 
 #include "adb/adb.h"
+#include "util/binary.h"
 #include "util/file.h"
 #include "util/log.h"
 #include "util/net_intr.h"
@@ -19,6 +20,9 @@
 #define SC_SERVER_PATH_DEFAULT PREFIX "/share/scrcpy/" SC_SERVER_FILENAME
 #define SC_DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"
 
+#define SC_ADB_PORT_DEFAULT 5555
+#define SC_SOCKET_NAME_PREFIX "scrcpy_"
+
 static char *
 get_server_path(void) {
 #ifdef __WINDOWS__
@@ -152,6 +156,24 @@ sc_server_sleep(struct sc_server *server, sc_tick deadline) {
     return !stopped;
 }
 
+static const char *
+sc_server_get_codec_name(enum sc_codec codec) {
+    switch (codec) {
+        case SC_CODEC_H264:
+            return "h264";
+        case SC_CODEC_H265:
+            return "h265";
+        case SC_CODEC_AV1:
+            return "av1";
+        case SC_CODEC_OPUS:
+            return "opus";
+        case SC_CODEC_AAC:
+            return "aac";
+        default:
+            return NULL;
+    }
+}
+
 static sc_pid
 execute_server(struct sc_server *server,
                const struct sc_server_params *params) {
@@ -195,9 +217,24 @@ execute_server(struct sc_server *server,
         cmd[count++] = p; \
     }
 
+    ADD_PARAM("scid=%08x", params->scid);
     ADD_PARAM("log_level=%s", log_level_to_server_string(params->log_level));
-    ADD_PARAM("bit_rate=%" PRIu32, params->bit_rate);
 
+    if (params->bit_rate) {
+        ADD_PARAM("bit_rate=%" PRIu32, params->bit_rate);
+    }
+    if (!params->audio) {
+        ADD_PARAM("audio=false");
+    } else if (params->audio_bit_rate) {
+        ADD_PARAM("audio_bit_rate=%" PRIu32, params->audio_bit_rate);
+    }
+    if (params->codec != SC_CODEC_H264) {
+        ADD_PARAM("codec=%s", sc_server_get_codec_name(params->codec));
+    }
+    if (params->audio_codec != SC_CODEC_OPUS) {
+        ADD_PARAM("audio_codec=%s",
+            sc_server_get_codec_name(params->audio_codec));
+    }
     if (params->max_size) {
         ADD_PARAM("max_size=%" PRIu16, params->max_size);
     }
@@ -362,9 +399,11 @@ sc_server_init(struct sc_server *server, const struct sc_server_params *params,
     }
 
     server->serial = NULL;
+    server->device_socket_name = NULL;
     server->stopped = false;
 
     server->video_socket = SC_SOCKET_NONE;
+    server->audio_socket = SC_SOCKET_NONE;
     server->control_socket = SC_SOCKET_NONE;
 
     sc_adb_tunnel_init(&server->tunnel);
@@ -393,10 +432,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));
 
-    info->frame_size.width = (buf[SC_DEVICE_NAME_FIELD_LENGTH] << 8)
-                           | buf[SC_DEVICE_NAME_FIELD_LENGTH + 1];
-    info->frame_size.height = (buf[SC_DEVICE_NAME_FIELD_LENGTH + 2] << 8)
-                            | buf[SC_DEVICE_NAME_FIELD_LENGTH + 3];
+    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;
 }
 
@@ -409,9 +447,11 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
     const char *serial = server->serial;
     assert(serial);
 
+    bool audio = server->params.audio;
     bool control = server->params.control;
 
     sc_socket video_socket = SC_SOCKET_NONE;
+    sc_socket audio_socket = SC_SOCKET_NONE;
     sc_socket control_socket = SC_SOCKET_NONE;
     if (!tunnel->forward) {
         video_socket = net_accept_intr(&server->intr, tunnel->server_socket);
@@ -419,6 +459,14 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
             goto fail;
         }
 
+        if (audio) {
+            audio_socket =
+                net_accept_intr(&server->intr, tunnel->server_socket);
+            if (audio_socket == SC_SOCKET_NONE) {
+                goto fail;
+            }
+        }
+
         if (control) {
             control_socket =
                 net_accept_intr(&server->intr, tunnel->server_socket);
@@ -445,6 +493,18 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
             goto fail;
         }
 
+        if (audio) {
+            audio_socket = net_socket();
+            if (audio_socket == SC_SOCKET_NONE) {
+                goto fail;
+            }
+            bool ok = net_connect_intr(&server->intr, audio_socket, tunnel_host,
+                                       tunnel_port);
+            if (!ok) {
+                goto fail;
+            }
+        }
+
         if (control) {
             // we know that the device is listening, we don't need several
             // attempts
@@ -461,7 +521,8 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
     }
 
     // we don't need the adb tunnel anymore
-    sc_adb_tunnel_close(tunnel, &server->intr, serial);
+    sc_adb_tunnel_close(tunnel, &server->intr, serial,
+                        server->device_socket_name);
 
     // The sockets will be closed on stop if device_read_info() fails
     bool ok = device_read_info(&server->intr, video_socket, info);
@@ -470,9 +531,11 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
     }
 
     assert(video_socket != SC_SOCKET_NONE);
+    assert(!audio || audio_socket != SC_SOCKET_NONE);
     assert(!control || control_socket != SC_SOCKET_NONE);
 
     server->video_socket = video_socket;
+    server->audio_socket = audio_socket;
     server->control_socket = control_socket;
 
     return true;
@@ -484,6 +547,12 @@ fail:
         }
     }
 
+    if (audio_socket != SC_SOCKET_NONE) {
+        if (!net_close(audio_socket)) {
+            LOGW("Could not close audio socket");
+        }
+    }
+
     if (control_socket != SC_SOCKET_NONE) {
         if (!net_close(control_socket)) {
             LOGW("Could not close control socket");
@@ -492,7 +561,8 @@ fail:
 
     if (tunnel->enabled) {
         // Always leave this function with tunnel disabled
-        sc_adb_tunnel_close(tunnel, &server->intr, serial);
+        sc_adb_tunnel_close(tunnel, &server->intr, serial,
+                            server->device_socket_name);
     }
 
     return false;
@@ -513,27 +583,36 @@ sc_server_on_terminated(void *userdata) {
     LOGD("Server terminated");
 }
 
-static bool
-is_tcpip_mode_enabled(struct sc_server *server, const char *serial) {
+static uint16_t
+get_adb_tcp_port(struct sc_server *server, const char *serial) {
     struct sc_intr *intr = &server->intr;
 
     char *current_port =
         sc_adb_getprop(intr, serial, "service.adb.tcp.port", SC_ADB_SILENT);
     if (!current_port) {
-        return false;
+        return 0;
     }
 
-    // Is the device is listening on TCP on port 5555?
-    bool enabled = !strcmp("5555", current_port);
+    long value;
+    bool ok = sc_str_parse_integer(current_port, &value);
     free(current_port);
-    return enabled;
+    if (!ok) {
+        return 0;
+    }
+
+    if (value < 0 || value > 0xFFFF) {
+        return 0;
+    }
+
+    return value;
 }
 
 static bool
 wait_tcpip_mode_enabled(struct sc_server *server, const char *serial,
-                        unsigned attempts, sc_tick delay) {
-    if (is_tcpip_mode_enabled(server, serial)) {
-        LOGI("TCP/IP mode enabled");
+                        uint16_t expected_port, unsigned attempts,
+                        sc_tick delay) {
+    uint16_t adb_port = get_adb_tcp_port(server, serial);
+    if (adb_port == expected_port) {
         return true;
     }
 
@@ -547,28 +626,23 @@ wait_tcpip_mode_enabled(struct sc_server *server, const char *serial,
             return false;
         }
 
-        if (is_tcpip_mode_enabled(server, serial)) {
-            LOGI("TCP/IP mode enabled");
+        adb_port = get_adb_tcp_port(server, serial);
+        if (adb_port == expected_port) {
             return true;
         }
     } while (--attempts);
     return false;
 }
 
-char *
-append_port_5555(const char *ip) {
-    size_t len = strlen(ip);
-
-    // sizeof counts the final '\0'
-    char *ip_port = malloc(len + sizeof(":5555"));
-    if (!ip_port) {
+static char *
+append_port(const char *ip, uint16_t port) {
+    char *ip_port;
+    int ret = asprintf(&ip_port, "%s:%" PRIu16, ip, port);
+    if (ret == -1) {
         LOG_OOM();
         return NULL;
     }
 
-    memcpy(ip_port, ip, len);
-    memcpy(ip_port + len, ":5555", sizeof(":5555"));
-
     return ip_port;
 }
 
@@ -586,34 +660,36 @@ sc_server_switch_to_tcpip(struct sc_server *server, const char *serial) {
         return NULL;
     }
 
-    char *ip_port = append_port_5555(ip);
-    free(ip);
-    if (!ip_port) {
-        return NULL;
-    }
+    uint16_t adb_port = get_adb_tcp_port(server, serial);
+    if (adb_port) {
+        LOGI("TCP/IP mode already enabled on port %" PRIu16, adb_port);
+    } else {
+        LOGI("Enabling TCP/IP mode on port " SC_STR(SC_ADB_PORT_DEFAULT) "...");
 
-    bool tcp_mode = is_tcpip_mode_enabled(server, serial);
-
-    if (!tcp_mode) {
-        bool ok = sc_adb_tcpip(intr, serial, 5555, SC_ADB_NO_STDOUT);
+        bool ok = sc_adb_tcpip(intr, serial, SC_ADB_PORT_DEFAULT,
+                               SC_ADB_NO_STDOUT);
         if (!ok) {
             LOGE("Could not restart adbd in TCP/IP mode");
-            goto error;
+            free(ip);
+            return NULL;
         }
 
         unsigned attempts = 40;
         sc_tick delay = SC_TICK_FROM_MS(250);
-        ok = wait_tcpip_mode_enabled(server, serial, attempts, delay);
+        ok = wait_tcpip_mode_enabled(server, serial, SC_ADB_PORT_DEFAULT,
+                                     attempts, delay);
         if (!ok) {
-            goto error;
-        }
-    }
-
-    return ip_port;
-
-error:
-    free(ip_port);
+            free(ip);
             return NULL;
+        }
+
+        adb_port = SC_ADB_PORT_DEFAULT;
+        LOGI("TCP/IP mode enabled on port " SC_STR(SC_ADB_PORT_DEFAULT));
+    }
+
+    char *ip_port = append_port(ip, adb_port);
+    free(ip);
+    return ip_port;
 }
 
 static bool
@@ -640,7 +716,8 @@ sc_server_configure_tcpip_known_address(struct sc_server *server,
                                         const char *addr) {
     // Append ":5555" if no port is present
     bool contains_port = strchr(addr, ':');
-    char *ip_port = contains_port ? strdup(addr) : append_port_5555(addr);
+    char *ip_port = contains_port ? strdup(addr)
+                                  : append_port(addr, SC_ADB_PORT_DEFAULT);
     if (!ip_port) {
         LOG_OOM();
         return false;
@@ -755,13 +832,23 @@ run_server(void *data) {
     assert(serial);
     LOGD("Device serial: %s", serial);
 
+    int r = asprintf(&server->device_socket_name, SC_SOCKET_NAME_PREFIX "%08x",
+                     params->scid);
+    if (r == -1) {
+        LOG_OOM();
+        goto error_connection_failed;
+    }
+    assert(r == sizeof(SC_SOCKET_NAME_PREFIX) - 1 + 8);
+    assert(server->device_socket_name);
+
     ok = push_server(&server->intr, serial);
     if (!ok) {
         goto error_connection_failed;
     }
 
     ok = sc_adb_tunnel_open(&server->tunnel, &server->intr, serial,
-                            params->port_range, params->force_adb_forward);
+                            server->device_socket_name, params->port_range,
+                            params->force_adb_forward);
     if (!ok) {
         goto error_connection_failed;
     }
@@ -769,7 +856,8 @@ run_server(void *data) {
     // server will connect to our server socket
     sc_pid pid = execute_server(server, params);
     if (pid == SC_PROCESS_NONE) {
-        sc_adb_tunnel_close(&server->tunnel, &server->intr, serial);
+        sc_adb_tunnel_close(&server->tunnel, &server->intr, serial,
+                            server->device_socket_name);
         goto error_connection_failed;
     }
 
@@ -781,7 +869,8 @@ run_server(void *data) {
     if (!ok) {
         sc_process_terminate(pid);
         sc_process_wait(pid, true); // ignore exit code
-        sc_adb_tunnel_close(&server->tunnel, &server->intr, serial);
+        sc_adb_tunnel_close(&server->tunnel, &server->intr, serial,
+                            server->device_socket_name);
         goto error_connection_failed;
     }
 
@@ -809,6 +898,11 @@ run_server(void *data) {
     assert(server->video_socket != SC_SOCKET_NONE);
     net_interrupt(server->video_socket);
 
+    if (server->audio_socket != SC_SOCKET_NONE) {
+        // There is no audio_socket if --no-audio is set
+        net_interrupt(server->audio_socket);
+    }
+
     if (server->control_socket != SC_SOCKET_NONE) {
         // There is no control_socket if --no-control is set
         net_interrupt(server->control_socket);
@@ -870,11 +964,15 @@ sc_server_destroy(struct sc_server *server) {
     if (server->video_socket != SC_SOCKET_NONE) {
         net_close(server->video_socket);
     }
+    if (server->audio_socket != SC_SOCKET_NONE) {
+        net_close(server->audio_socket);
+    }
     if (server->control_socket != SC_SOCKET_NONE) {
         net_close(server->control_socket);
     }
 
     free(server->serial);
+    free(server->device_socket_name);
     sc_server_params_destroy(&server->params);
     sc_intr_destroy(&server->intr);
     sc_cond_destroy(&server->cond_stopped);

app/src/server.h

@@ -22,8 +22,11 @@ struct sc_server_info {
 };
 
 struct sc_server_params {
+    uint32_t scid;
     const char *req_serial;
     enum sc_log_level log_level;
+    enum sc_codec codec;
+    enum sc_codec audio_codec;
     const char *crop;
     const char *codec_options;
     const char *encoder_name;
@@ -32,10 +35,12 @@ struct sc_server_params {
     uint16_t tunnel_port;
     uint16_t max_size;
     uint32_t bit_rate;
+    uint32_t audio_bit_rate;
     uint16_t max_fps;
     int8_t lock_video_orientation;
     bool control;
     uint32_t display_id;
+    bool audio;
     bool show_touches;
     bool stay_awake;
     bool force_adb_forward;
@@ -54,6 +59,7 @@ struct sc_server {
     // The internal allocated strings are copies owned by the server
     struct sc_server_params params;
     char *serial;
+    char *device_socket_name;
 
     sc_thread thread;
     struct sc_server_info info; // initialized once connected
@@ -66,6 +72,7 @@ struct sc_server {
     struct sc_adb_tunnel tunnel;
 
     sc_socket video_socket;
+    sc_socket audio_socket;
     sc_socket control_socket;
 
     const struct sc_server_callbacks *cbs;

app/src/stream.h

@@ -1,51 +0,0 @@
-#ifndef STREAM_H
-#define STREAM_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-
-#include "trait/packet_sink.h"
-#include "util/net.h"
-#include "util/thread.h"
-
-#define STREAM_MAX_SINKS 2
-
-struct stream {
-    sc_socket socket;
-    sc_thread thread;
-
-    struct sc_packet_sink *sinks[STREAM_MAX_SINKS];
-    unsigned sink_count;
-
-    AVCodecContext *codec_ctx;
-    AVCodecParserContext *parser;
-    // successive packets may need to be concatenated, until a non-config
-    // packet is available
-    AVPacket *pending;
-
-    const struct stream_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct stream_callbacks {
-    void (*on_eos)(struct stream *stream, void *userdata);
-};
-
-void
-stream_init(struct stream *stream, sc_socket socket,
-            const struct stream_callbacks *cbs, void *cbs_userdata);
-
-void
-stream_add_sink(struct stream *stream, struct sc_packet_sink *sink);
-
-bool
-stream_start(struct stream *stream);
-
-void
-stream_join(struct stream *stream);
-
-#endif

app/src/sys/unix/process.c

@@ -92,8 +92,14 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,
                 close(in[0]);
             }
             close(in[1]);
+        } else {
+            int devnull = open("/dev/null", O_RDONLY | O_CREAT, 0666);
+            if (devnull != -1) {
+                dup2(devnull, STDIN_FILENO);
+            } else {
+                LOGE("Could not open /dev/null for stdin");
+            }
         }
-        // Do not close stdin in the child process, this makes adb fail on Linux
 
         if (pout) {
             if (out[1] != STDOUT_FILENO) {
@@ -102,8 +108,12 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,
             }
             close(out[0]);
         } else if (!inherit_stdout) {
-            // Close stdout in the child process
-            close(STDOUT_FILENO);
+            int devnull = open("/dev/null", O_WRONLY | O_CREAT, 0666);
+            if (devnull != -1) {
+                dup2(devnull, STDOUT_FILENO);
+            } else {
+                LOGE("Could not open /dev/null for stdout");
+            }
         }
 
         if (perr) {
@@ -113,8 +123,12 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,
             }
             close(err[0]);
         } else if (!inherit_stderr) {
-            // Close stderr in the child process
-            close(STDERR_FILENO);
+            int devnull = open("/dev/null", O_WRONLY | O_CREAT, 0666);
+            if (devnull != -1) {
+                dup2(devnull, STDERR_FILENO);
+            } else {
+                LOGE("Could not open /dev/null for stderr");
+            }
         }
 
         close(internal[0]);

app/src/trait/packet_sink.h

@@ -19,9 +19,20 @@ struct sc_packet_sink {
 };
 
 struct sc_packet_sink_ops {
+    /* The codec instance is static, it is valid until the end of the program */
     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);
+
+    /*/
+     * Called when the input stream has been disabled at runtime.
+     *
+     * If it is called, then open(), close() and push() will never be called.
+     *
+     * It is useful to notify the recorder that the requested audio stream has
+     * finally been disabled because the device could not capture it.
+     */
+    void (*disable)(struct sc_packet_sink *sink);
 };
 
 #endif

app/src/usb/scrcpy_otg.c

@@ -22,7 +22,7 @@ sc_usb_on_disconnected(struct sc_usb *usb, void *userdata) {
     (void) userdata;
 
     SDL_Event event;
-    event.type = EVENT_USB_DEVICE_DISCONNECTED;
+    event.type = SC_EVENT_USB_DEVICE_DISCONNECTED;
     int ret = SDL_PushEvent(&event);
     if (ret < 0) {
         LOGE("Could not post USB disconnection event: %s", SDL_GetError());
@@ -34,7 +34,7 @@ event_loop(struct scrcpy_otg *s) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         switch (event.type) {
-            case EVENT_USB_DEVICE_DISCONNECTED:
+            case SC_EVENT_USB_DEVICE_DISCONNECTED:
                 LOGW("Device disconnected");
                 return SCRCPY_EXIT_DISCONNECTED;
             case SDL_QUIT:

app/src/usb/usb.c

@@ -23,6 +23,11 @@ read_string(libusb_device_handle *handle, uint8_t desc_index) {
 
     // When non-negative, 'result' contains the number of bytes written
     char *s = malloc(result + 1);
+    if (!s) {
+        LOG_OOM();
+        return NULL;
+    }
+
     memcpy(s, buffer, result);
     s[result] = '\0';
     return s;

app/src/util/binary.h

@@ -1,8 +1,9 @@
-#ifndef SC_BUFFER_UTIL_H
-#define SC_BUFFER_UTIL_H
+#ifndef SC_BINARY_H
+#define SC_BINARY_H
 
 #include "common.h"
 
+#include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
 
@@ -43,4 +44,33 @@ sc_read64be(const uint8_t *buf) {
     return ((uint64_t) msb << 32) | lsb;
 }
 
+/**
+ * Convert a float between 0 and 1 to an unsigned 16-bit fixed-point value
+ */
+static inline uint16_t
+sc_float_to_u16fp(float f) {
+    assert(f >= 0.0f && f <= 1.0f);
+    uint32_t u = f * 0x1p16f; // 2^16
+    if (u >= 0xffff) {
+        assert(u == 0x10000); // for f == 1.0f
+        u = 0xffff;
+    }
+    return (uint16_t) u;
+}
+
+/**
+ * Convert a float between -1 and 1 to a signed 16-bit fixed-point value
+ */
+static inline int16_t
+sc_float_to_i16fp(float f) {
+    assert(f >= -1.0f && f <= 1.0f);
+    int32_t i = f * 0x1p15f; // 2^15
+    assert(i >= -0x8000);
+    if (i >= 0x7fff) {
+        assert(i == 0x8000); // for f == 1.0f
+        i = 0x7fff;
+    }
+    return (int16_t) i;
+}
+
 #endif

app/src/util/net.c

@@ -3,11 +3,10 @@
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
-#include <SDL2/SDL_platform.h>
 
 #include "log.h"
 
-#ifdef __WINDOWS__
+#ifdef _WIN32
 # include <ws2tcpip.h>
   typedef int socklen_t;
   typedef SOCKET sc_raw_socket;
@@ -29,7 +28,7 @@
 
 bool
 net_init(void) {
-#ifdef __WINDOWS__
+#ifdef _WIN32
     WSADATA wsa;
     int res = WSAStartup(MAKEWORD(2, 2), &wsa) < 0;
     if (res < 0) {
@@ -42,14 +41,14 @@ net_init(void) {
 
 void
 net_cleanup(void) {
-#ifdef __WINDOWS__
+#ifdef _WIN32
     WSACleanup();
 #endif
 }
 
 static inline sc_socket
 wrap(sc_raw_socket sock) {
-#ifdef __WINDOWS__
+#ifdef _WIN32
     if (sock == INVALID_SOCKET) {
         return SC_SOCKET_NONE;
     }
@@ -72,7 +71,7 @@ wrap(sc_raw_socket sock) {
 
 static inline sc_raw_socket
 unwrap(sc_socket socket) {
-#ifdef __WINDOWS__
+#ifdef _WIN32
     if (socket == SC_SOCKET_NONE) {
         return INVALID_SOCKET;
     }
@@ -160,8 +159,8 @@ net_connect(sc_socket socket, uint32_t addr, uint16_t port) {
 }
 
 bool
-net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog) {
-    sc_raw_socket raw_sock = unwrap(socket);
+net_listen(sc_socket server_socket, uint32_t addr, uint16_t port, int backlog) {
+    sc_raw_socket raw_sock = unwrap(server_socket);
 
     int reuse = 1;
     if (setsockopt(raw_sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
@@ -248,7 +247,7 @@ net_interrupt(sc_socket socket) {
 
     sc_raw_socket raw_sock = unwrap(socket);
 
-#ifdef __WINDOWS__
+#ifdef _WIN32
     if (!atomic_flag_test_and_set(&socket->closed)) {
         return !closesocket(raw_sock);
     }
@@ -262,7 +261,7 @@ bool
 net_close(sc_socket socket) {
     sc_raw_socket raw_sock = unwrap(socket);
 
-#ifdef __WINDOWS__
+#ifdef _WIN32
     bool ret = true;
     if (!atomic_flag_test_and_set(&socket->closed)) {
         ret = !closesocket(raw_sock);

app/src/util/net.h

@@ -5,9 +5,8 @@
 
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL2/SDL_platform.h>
 
-#ifdef __WINDOWS__
+#ifdef _WIN32
 
 # include <winsock2.h>
 # include <stdatomic.h>
@@ -17,7 +16,7 @@
       atomic_flag closed;
   } *sc_socket;
 
-#else // not __WINDOWS__
+#else // not _WIN32
 
 # include <sys/socket.h>
 # define SC_SOCKET_NONE -1
@@ -40,7 +39,7 @@ bool
 net_connect(sc_socket socket, uint32_t addr, uint16_t port);
 
 bool
-net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog);
+net_listen(sc_socket server_socket, uint32_t addr, uint16_t port, int backlog);
 
 sc_socket
 net_accept(sc_socket server_socket);

app/src/util/net_intr.c

@@ -15,14 +15,14 @@ net_connect_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
 }
 
 bool
-net_listen_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
+net_listen_intr(struct sc_intr *intr, sc_socket server_socket, uint32_t addr,
                 uint16_t port, int backlog) {
-    if (!sc_intr_set_socket(intr, socket)) {
+    if (!sc_intr_set_socket(intr, server_socket)) {
         // Already interrupted
         return false;
     }
 
-    bool ret = net_listen(socket, addr, port, backlog);
+    bool ret = net_listen(server_socket, addr, port, backlog);
 
     sc_intr_set_socket(intr, SC_SOCKET_NONE);
     return ret;

app/src/util/net_intr.h

@@ -11,7 +11,7 @@ net_connect_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
                  uint16_t port);
 
 bool
-net_listen_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
+net_listen_intr(struct sc_intr *intr, sc_socket server_socket, uint32_t addr,
                 uint16_t port, int backlog);
 
 sc_socket

app/src/util/rand.c

@@ -0,0 +1,24 @@
+#include "rand.h"
+
+#include <stdlib.h>
+
+#include "tick.h"
+
+void sc_rand_init(struct sc_rand *rand) {
+    sc_tick seed = sc_tick_now(); // microsecond precision
+    rand->xsubi[0] = (seed >> 32) & 0xFFFF;
+    rand->xsubi[1] = (seed >> 16) & 0xFFFF;
+    rand->xsubi[2] = seed & 0xFFFF;
+}
+
+uint32_t sc_rand_u32(struct sc_rand *rand) {
+    // jrand returns a value in range [-2^31, 2^31]
+    // conversion from signed to unsigned is well-defined to wrap-around
+    return jrand48(rand->xsubi);
+}
+
+uint64_t sc_rand_u64(struct sc_rand *rand) {
+    uint32_t msb = sc_rand_u32(rand);
+    uint32_t lsb = sc_rand_u32(rand);
+    return ((uint64_t) msb << 32) | lsb;
+}

app/src/util/rand.h

@@ -0,0 +1,16 @@
+#ifndef SC_RAND_H
+#define SC_RAND_H
+
+#include "common.h"
+
+#include <inttypes.h>
+
+struct sc_rand {
+    unsigned short xsubi[3];
+};
+
+void sc_rand_init(struct sc_rand *rand);
+uint32_t sc_rand_u32(struct sc_rand *rand);
+uint64_t sc_rand_u64(struct sc_rand *rand);
+
+#endif

app/src/util/str.h

@@ -6,6 +6,10 @@
 #include <stdbool.h>
 #include <stddef.h>
 
+/* Stringify a numeric value  */
+#define SC_STR(s) SC_XSTR(s)
+#define SC_XSTR(s) #s
+
 /**
  * Like strncpy(), except:
  *  - it copies at most n-1 chars

app/src/util/thread.c

@@ -1,6 +1,7 @@
 #include "thread.h"
 
 #include <assert.h>
+#include <string.h>
 #include <SDL2/SDL_thread.h>
 
 #include "log.h"

app/src/util/vector.h

@@ -6,6 +6,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
+#include <string.h>
 
 // Adapted from vlc_vector:
 // <https://code.videolan.org/videolan/vlc/-/blob/0857947abaed9c89810cd96353aaa1b7e6ba3b0d/include/vlc_vector.h>

app/tests/test_adb_parser.c

@@ -5,7 +5,7 @@
 #include "adb/adb_device.h"
 #include "adb/adb_parser.h"
 
-static void test_adb_devices() {
+static void test_adb_devices(void) {
     char output[] =
         "List of devices attached\n"
         "0123456789abcdef	device usb:2-1 product:MyProduct model:MyModel "
@@ -31,7 +31,7 @@ static void test_adb_devices() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_adb_devices_cr() {
+static void test_adb_devices_cr(void) {
     char output[] =
         "List of devices attached\r\n"
         "0123456789abcdef	device usb:2-1 product:MyProduct model:MyModel "
@@ -57,7 +57,7 @@ static void test_adb_devices_cr() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_adb_devices_daemon_start() {
+static void test_adb_devices_daemon_start(void) {
     char output[] =
         "* daemon not running; starting now at tcp:5037\n"
         "* daemon started successfully\n"
@@ -78,7 +78,7 @@ static void test_adb_devices_daemon_start() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_adb_devices_daemon_start_mixed() {
+static void test_adb_devices_daemon_start_mixed(void) {
     char output[] =
         "List of devices attached\n"
         "adb server version (41) doesn't match this client (39); killing...\n"
@@ -105,7 +105,7 @@ static void test_adb_devices_daemon_start_mixed() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_adb_devices_without_eol() {
+static void test_adb_devices_without_eol(void) {
     char output[] =
         "List of devices attached\n"
         "0123456789abcdef	device usb:2-1 product:MyProduct model:MyModel "
@@ -124,7 +124,7 @@ static void test_adb_devices_without_eol() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_adb_devices_without_header() {
+static void test_adb_devices_without_header(void) {
     char output[] =
         "0123456789abcdef	device usb:2-1 product:MyProduct model:MyModel "
             "device:MyDevice transport_id:1\n";
@@ -134,7 +134,7 @@ static void test_adb_devices_without_header() {
     assert(!ok);
 }
 
-static void test_adb_devices_corrupted() {
+static void test_adb_devices_corrupted(void) {
     char output[] =
         "List of devices attached\n"
         "corrupted_garbage\n";
@@ -145,7 +145,7 @@ static void test_adb_devices_corrupted() {
     assert(vec.size == 0);
 }
 
-static void test_adb_devices_spaces() {
+static void test_adb_devices_spaces(void) {
     char output[] =
         "List of devices attached\n"
         "0123456789abcdef       unauthorized usb:1-4 transport_id:3\n";
@@ -163,81 +163,81 @@ static void test_adb_devices_spaces() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_get_ip_single_line() {
+static void test_get_ip_single_line(void) {
     char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
                       "192.168.12.34\r\r\n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(ip);
     assert(!strcmp(ip, "192.168.12.34"));
     free(ip);
 }
 
-static void test_get_ip_single_line_without_eol() {
+static void test_get_ip_single_line_without_eol(void) {
     char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
                       "192.168.12.34";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(ip);
     assert(!strcmp(ip, "192.168.12.34"));
     free(ip);
 }
 
-static void test_get_ip_single_line_with_trailing_space() {
+static void test_get_ip_single_line_with_trailing_space(void) {
     char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
                       "192.168.12.34 \n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(ip);
     assert(!strcmp(ip, "192.168.12.34"));
     free(ip);
 }
 
-static void test_get_ip_multiline_first_ok() {
+static void test_get_ip_multiline_first_ok(void) {
     char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
                       "192.168.1.2\r\n"
                       "10.0.0.0/24 dev rmnet  proto kernel  scope link  src "
                       "10.0.0.2\r\n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(ip);
     assert(!strcmp(ip, "192.168.1.2"));
     free(ip);
 }
 
-static void test_get_ip_multiline_second_ok() {
+static void test_get_ip_multiline_second_ok(void) {
     char ip_route[] = "10.0.0.0/24 dev rmnet  proto kernel  scope link  src "
                       "10.0.0.3\r\n"
                       "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
                       "192.168.1.3\r\n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    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() {
+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";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(!ip);
 }
 
-static void test_get_ip_no_wlan_without_eol() {
+static void test_get_ip_no_wlan_without_eol(void) {
     char ip_route[] = "192.168.1.0/24 dev rmnet  proto kernel  scope link  src "
                       "192.168.12.34";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(!ip);
 }
 
-static void test_get_ip_truncated() {
+static void test_get_ip_truncated(void) {
     char ip_route[] = "192.168.1.0/24 dev rmnet  proto kernel  scope link  src "
                       "\n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(!ip);
 }
 
@@ -262,4 +262,6 @@ int main(int argc, char *argv[]) {
     test_get_ip_no_wlan();
     test_get_ip_no_wlan_without_eol();
     test_get_ip_truncated();
+
+    return 0;
 }

app/tests/test_binary.c

@@ -0,0 +1,114 @@
+#include "common.h"
+
+#include <assert.h>
+
+#include "util/binary.h"
+
+static void test_write16be(void) {
+    uint16_t val = 0xABCD;
+    uint8_t buf[2];
+
+    sc_write16be(buf, val);
+
+    assert(buf[0] == 0xAB);
+    assert(buf[1] == 0xCD);
+}
+
+static void test_write32be(void) {
+    uint32_t val = 0xABCD1234;
+    uint8_t buf[4];
+
+    sc_write32be(buf, val);
+
+    assert(buf[0] == 0xAB);
+    assert(buf[1] == 0xCD);
+    assert(buf[2] == 0x12);
+    assert(buf[3] == 0x34);
+}
+
+static void test_write64be(void) {
+    uint64_t val = 0xABCD1234567890EF;
+    uint8_t buf[8];
+
+    sc_write64be(buf, val);
+
+    assert(buf[0] == 0xAB);
+    assert(buf[1] == 0xCD);
+    assert(buf[2] == 0x12);
+    assert(buf[3] == 0x34);
+    assert(buf[4] == 0x56);
+    assert(buf[5] == 0x78);
+    assert(buf[6] == 0x90);
+    assert(buf[7] == 0xEF);
+}
+
+static void test_read16be(void) {
+    uint8_t buf[2] = {0xAB, 0xCD};
+
+    uint16_t val = sc_read16be(buf);
+
+    assert(val == 0xABCD);
+}
+
+static void test_read32be(void) {
+    uint8_t buf[4] = {0xAB, 0xCD, 0x12, 0x34};
+
+    uint32_t val = sc_read32be(buf);
+
+    assert(val == 0xABCD1234);
+}
+
+static void test_read64be(void) {
+    uint8_t buf[8] = {0xAB, 0xCD, 0x12, 0x34,
+                      0x56, 0x78, 0x90, 0xEF};
+
+    uint64_t val = sc_read64be(buf);
+
+    assert(val == 0xABCD1234567890EF);
+}
+
+static void test_float_to_u16fp(void) {
+    assert(sc_float_to_u16fp(0.0f) == 0);
+    assert(sc_float_to_u16fp(0.03125f) == 0x800);
+    assert(sc_float_to_u16fp(0.0625f) == 0x1000);
+    assert(sc_float_to_u16fp(0.125f) == 0x2000);
+    assert(sc_float_to_u16fp(0.25f) == 0x4000);
+    assert(sc_float_to_u16fp(0.5f) == 0x8000);
+    assert(sc_float_to_u16fp(0.75f) == 0xc000);
+    assert(sc_float_to_u16fp(1.0f) == 0xffff);
+}
+
+static void test_float_to_i16fp(void) {
+    assert(sc_float_to_i16fp(0.0f) == 0);
+    assert(sc_float_to_i16fp(0.03125f) == 0x400);
+    assert(sc_float_to_i16fp(0.0625f) == 0x800);
+    assert(sc_float_to_i16fp(0.125f) == 0x1000);
+    assert(sc_float_to_i16fp(0.25f) == 0x2000);
+    assert(sc_float_to_i16fp(0.5f) == 0x4000);
+    assert(sc_float_to_i16fp(0.75f) == 0x6000);
+    assert(sc_float_to_i16fp(1.0f) == 0x7fff);
+
+    assert(sc_float_to_i16fp(-0.03125f) == -0x400);
+    assert(sc_float_to_i16fp(-0.0625f) == -0x800);
+    assert(sc_float_to_i16fp(-0.125f) == -0x1000);
+    assert(sc_float_to_i16fp(-0.25f) == -0x2000);
+    assert(sc_float_to_i16fp(-0.5f) == -0x4000);
+    assert(sc_float_to_i16fp(-0.75f) == -0x6000);
+    assert(sc_float_to_i16fp(-1.0f) == -0x8000);
+}
+
+int main(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_write16be();
+    test_write32be();
+    test_write64be();
+    test_read16be();
+    test_read32be();
+    test_read64be();
+
+    test_float_to_u16fp();
+    test_float_to_i16fp();
+    return 0;
+}

app/tests/test_buffer_util.c

@@ -1,81 +0,0 @@
-#include "common.h"
-
-#include <assert.h>
-
-#include "util/buffer_util.h"
-
-static void test_buffer_write16be(void) {
-    uint16_t val = 0xABCD;
-    uint8_t buf[2];
-
-    sc_write16be(buf, val);
-
-    assert(buf[0] == 0xAB);
-    assert(buf[1] == 0xCD);
-}
-
-static void test_buffer_write32be(void) {
-    uint32_t val = 0xABCD1234;
-    uint8_t buf[4];
-
-    sc_write32be(buf, val);
-
-    assert(buf[0] == 0xAB);
-    assert(buf[1] == 0xCD);
-    assert(buf[2] == 0x12);
-    assert(buf[3] == 0x34);
-}
-
-static void test_buffer_write64be(void) {
-    uint64_t val = 0xABCD1234567890EF;
-    uint8_t buf[8];
-
-    sc_write64be(buf, val);
-
-    assert(buf[0] == 0xAB);
-    assert(buf[1] == 0xCD);
-    assert(buf[2] == 0x12);
-    assert(buf[3] == 0x34);
-    assert(buf[4] == 0x56);
-    assert(buf[5] == 0x78);
-    assert(buf[6] == 0x90);
-    assert(buf[7] == 0xEF);
-}
-
-static void test_buffer_read16be(void) {
-    uint8_t buf[2] = {0xAB, 0xCD};
-
-    uint16_t val = sc_read16be(buf);
-
-    assert(val == 0xABCD);
-}
-
-static void test_buffer_read32be(void) {
-    uint8_t buf[4] = {0xAB, 0xCD, 0x12, 0x34};
-
-    uint32_t val = sc_read32be(buf);
-
-    assert(val == 0xABCD1234);
-}
-
-static void test_buffer_read64be(void) {
-    uint8_t buf[8] = {0xAB, 0xCD, 0x12, 0x34,
-                      0x56, 0x78, 0x90, 0xEF};
-
-    uint64_t val = sc_read64be(buf);
-
-    assert(val == 0xABCD1234567890EF);
-}
-
-int main(int argc, char *argv[]) {
-    (void) argc;
-    (void) argv;
-
-    test_buffer_write16be();
-    test_buffer_write32be();
-    test_buffer_write64be();
-    test_buffer_read16be();
-    test_buffer_read32be();
-    test_buffer_read64be();
-    return 0;
-}

app/tests/test_control_msg_serialize.c

@@ -90,13 +90,14 @@ static void test_serialize_inject_touch_event(void) {
                 },
             },
             .pressure = 1.0f,
+            .action_button = AMOTION_EVENT_BUTTON_PRIMARY,
             .buttons = AMOTION_EVENT_BUTTON_PRIMARY,
         },
     };
 
     unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 28);
+    assert(size == 32);
 
     const unsigned char expected[] = {
         SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
@@ -105,7 +106,8 @@ static void test_serialize_inject_touch_event(void) {
         0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0xc8, // 100 200
         0x04, 0x38, 0x07, 0x80, // 1080 1920
         0xff, 0xff, // pressure
-        0x00, 0x00, 0x00, 0x01 // AMOTION_EVENT_BUTTON_PRIMARY
+        0x00, 0x00, 0x00, 0x01, // AMOTION_EVENT_BUTTON_PRIMARY (action button)
+        0x00, 0x00, 0x00, 0x01, // AMOTION_EVENT_BUTTON_PRIMARY (buttons)
     };
     assert(!memcmp(buf, expected, sizeof(expected)));
 }
@@ -132,14 +134,14 @@ static void test_serialize_inject_scroll_event(void) {
 
     unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 25);
+    assert(size == 21);
 
     const unsigned char expected[] = {
         SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
         0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x02, // 260 1026
         0x04, 0x38, 0x07, 0x80, // 1080 1920
-        0x00, 0x00, 0x00, 0x01, // 1
-        0xFF, 0xFF, 0xFF, 0xFF, // -1
+        0x7F, 0xFF, // 1 (float encoded as i16)
+        0x80, 0x00, // -1 (float encoded as i16)
         0x00, 0x00, 0x00, 0x01, // 1
     };
     assert(!memcmp(buf, expected, sizeof(expected)));

build.gradle

@@ -4,10 +4,10 @@ buildscript {
 
     repositories {
         google()
-        jcenter()
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:7.0.3'
+        classpath 'com.android.tools.build:gradle:7.2.2'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -17,7 +17,7 @@ buildscript {
 allprojects {
     repositories {
         google()
-        jcenter()
+        mavenCentral()
     }
     tasks.withType(JavaCompile) {
         options.compilerArgs << "-Xlint:deprecation"

cross_win32.txt

@@ -20,6 +20,6 @@ ffmpeg_avcodec = 'avcodec-58'
 ffmpeg_avformat = 'avformat-58'
 ffmpeg_avutil = 'avutil-56'
 prebuilt_ffmpeg = 'ffmpeg-win32-4.3.1'
-prebuilt_sdl2 = 'SDL2-2.0.22/i686-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.26.1/i686-w64-mingw32'
 prebuilt_libusb_root = 'libusb-1.0.26'
-prebuilt_libusb = prebuilt_libusb_root + '/MinGW-Win32'
+prebuilt_libusb = 'libusb-1.0.26/MinGW-Win32'

cross_win64.txt

@@ -19,7 +19,7 @@ endian = 'little'
 ffmpeg_avcodec = 'avcodec-59'
 ffmpeg_avformat = 'avformat-59'
 ffmpeg_avutil = 'avutil-57'
-prebuilt_ffmpeg = 'ffmpeg-win64-5.0.1'
-prebuilt_sdl2 = 'SDL2-2.0.22/x86_64-w64-mingw32'
+prebuilt_ffmpeg = 'ffmpeg-win64-5.1.2'
+prebuilt_sdl2 = 'SDL2-2.26.1/x86_64-w64-mingw32'
 prebuilt_libusb_root = 'libusb-1.0.26'
-prebuilt_libusb = prebuilt_libusb_root + '/MinGW-x64'
+prebuilt_libusb = 'libusb-1.0.26/MinGW-x64'

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

install_release.sh

@@ -2,8 +2,8 @@
 set -e
 
 BUILDDIR=build-auto
-PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-server-v1.24
-PREBUILT_SERVER_SHA256=ae74a81ea79c0dc7250e586627c278c0a9a8c5de46c9fb5c38c167fb1a36f056
+PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.25/scrcpy-server-v1.25
+PREBUILT_SERVER_SHA256=ce0306c7bbd06ae72f6d06f7ec0ee33774995a65de71e0a83813ecb67aec9bdb
 
 echo "[scrcpy] Downloading prebuilt server..."
 wget "$PREBUILT_SERVER_URL" -O scrcpy-server
@@ -12,7 +12,7 @@ echo "$PREBUILT_SERVER_SHA256  scrcpy-server" | sha256sum --check
 
 echo "[scrcpy] Building client..."
 rm -rf "$BUILDDIR"
-meson "$BUILDDIR" --buildtype=release --strip -Db_lto=true \
+meson setup "$BUILDDIR" --buildtype=release --strip -Db_lto=true \
     -Dprebuilt_server=scrcpy-server
 cd "$BUILDDIR"
 ninja

meson.build

@@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '1.24',
+        version: '1.25',
         meson_version: '>= 0.48',
         default_options: [
             'c_std=c11',

release.mk

@@ -24,13 +24,13 @@ SERVER_BUILD_DIR := build-server
 WIN32_BUILD_DIR := build-win32
 WIN64_BUILD_DIR := build-win64
 
-DIST := dist
-WIN32_TARGET_DIR := scrcpy-win32
-WIN64_TARGET_DIR := scrcpy-win64
-
 VERSION := $(shell git describe --tags --always)
-WIN32_TARGET := $(WIN32_TARGET_DIR)-$(VERSION).zip
-WIN64_TARGET := $(WIN64_TARGET_DIR)-$(VERSION).zip
+
+DIST := dist
+WIN32_TARGET_DIR := scrcpy-win32-$(VERSION)
+WIN64_TARGET_DIR := scrcpy-win64-$(VERSION)
+WIN32_TARGET := $(WIN32_TARGET_DIR).zip
+WIN64_TARGET := $(WIN64_TARGET_DIR).zip
 
 RELEASE_DIR := release-$(VERSION)
 
@@ -53,13 +53,13 @@ clean:
 
 test:
 	[ -d "$(TEST_BUILD_DIR)" ] || ( mkdir "$(TEST_BUILD_DIR)" && \
-		meson "$(TEST_BUILD_DIR)" -Db_sanitize=address )
+		meson setup "$(TEST_BUILD_DIR)" -Db_sanitize=address )
 	ninja -C "$(TEST_BUILD_DIR)"
 	$(GRADLE) -p server check
 
 build-server:
 	[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
-		meson "$(SERVER_BUILD_DIR)" --buildtype release -Dcompile_app=false )
+		meson setup "$(SERVER_BUILD_DIR)" --buildtype release -Dcompile_app=false )
 	ninja -C "$(SERVER_BUILD_DIR)"
 
 prepare-deps-win32:
@@ -76,7 +76,7 @@ prepare-deps-win64:
 
 build-win32: prepare-deps-win32
 	[ -d "$(WIN32_BUILD_DIR)" ] || ( mkdir "$(WIN32_BUILD_DIR)" && \
-		meson "$(WIN32_BUILD_DIR)" \
+		meson setup "$(WIN32_BUILD_DIR)" \
 			--cross-file cross_win32.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcompile_server=false \
@@ -85,7 +85,7 @@ build-win32: prepare-deps-win32
 
 build-win64: prepare-deps-win64
 	[ -d "$(WIN64_BUILD_DIR)" ] || ( mkdir "$(WIN64_BUILD_DIR)" && \
-		meson "$(WIN64_BUILD_DIR)" \
+		meson setup "$(WIN64_BUILD_DIR)" \
 			--cross-file cross_win64.txt \
 			--buildtype release --strip -Db_lto=true \
 			-Dcompile_server=false \
@@ -105,10 +105,10 @@ dist-win32: build-server build-win32
 	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/SDL2-2.0.22/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/SDL2-2.26.1/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/libusb-1.0.26/MinGW-Win32/msys-usb-1.0.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 
 dist-win64: build-server build-win64
@@ -119,21 +119,21 @@ dist-win64: build-server build-win64
 	cp app/data/scrcpy-noconsole.vbs "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp app/data/icon.png "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp app/data/open_a_terminal_here.bat "$(DIST)/$(WIN64_TARGET_DIR)"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/avutil-57.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/avcodec-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/avformat-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/swscale-6.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/SDL2-2.0.22/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/avutil-57.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/avcodec-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/avformat-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.1.2/bin/swscale-6.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.3/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/SDL2-2.26.1/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/libusb-1.0.26/MinGW-x64/msys-usb-1.0.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 
 zip-win32: dist-win32
-	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
-		zip -r "../$(WIN32_TARGET)" .
+	cd "$(DIST)"; \
+		zip -r "$(WIN32_TARGET)" "$(WIN32_TARGET_DIR)"
 
 zip-win64: dist-win64
-	cd "$(DIST)/$(WIN64_TARGET_DIR)"; \
-		zip -r "../$(WIN64_TARGET)" .
+	cd "$(DIST)"; \
+		zip -r "$(WIN64_TARGET)" "$(WIN64_TARGET_DIR)"

server/build.gradle

@@ -1,13 +1,13 @@
 apply plugin: 'com.android.application'
 
 android {
-    compileSdkVersion 31
+    compileSdkVersion 33
     defaultConfig {
         applicationId "com.genymobile.scrcpy"
         minSdkVersion 21
-        targetSdkVersion 31
-        versionCode 12400
-        versionName "1.24"
+        targetSdkVersion 33
+        versionCode 12500
+        versionName "1.25"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
     }
     buildTypes {
@@ -19,8 +19,7 @@ android {
 }
 
 dependencies {
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
-    testImplementation 'junit:junit:4.13.1'
+    testImplementation 'junit:junit:4.13.2'
 }
 
 apply from: "$project.rootDir/config/android-checkstyle.gradle"

server/build_without_gradle.sh

@@ -12,25 +12,29 @@
 set -e
 
 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.24
+SCRCPY_VERSION_NAME=1.25
 
-PLATFORM=${ANDROID_PLATFORM:-31}
-BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-31.0.0}
+PLATFORM=${ANDROID_PLATFORM:-33}
+BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-33.0.0}
+BUILD_TOOLS_DIR="$ANDROID_HOME/build-tools/$BUILD_TOOLS"
 
 BUILD_DIR="$(realpath ${BUILD_DIR:-build_manual})"
 CLASSES_DIR="$BUILD_DIR/classes"
+GEN_DIR="$BUILD_DIR/gen"
 SERVER_DIR=$(dirname "$0")
 SERVER_BINARY=scrcpy-server
 ANDROID_JAR="$ANDROID_HOME/platforms/android-$PLATFORM/android.jar"
+LAMBDA_JAR="$BUILD_TOOLS_DIR/core-lambda-stubs.jar"
 
 echo "Platform: android-$PLATFORM"
 echo "Build-tools: $BUILD_TOOLS"
 echo "Build dir: $BUILD_DIR"
 
-rm -rf "$CLASSES_DIR" "$BUILD_DIR/$SERVER_BINARY" classes.dex
-mkdir -p "$CLASSES_DIR/com/genymobile/scrcpy"
+rm -rf "$CLASSES_DIR" "$GEN_DIR" "$BUILD_DIR/$SERVER_BINARY" classes.dex
+mkdir -p "$CLASSES_DIR"
+mkdir -p "$GEN_DIR/com/genymobile/scrcpy"
 
-<< EOF cat > "$CLASSES_DIR/com/genymobile/scrcpy/BuildConfig.java"
+<< EOF cat > "$GEN_DIR/com/genymobile/scrcpy/BuildConfig.java"
 package com.genymobile.scrcpy;
 
 public final class BuildConfig {
@@ -41,14 +45,15 @@ EOF
 
 echo "Generating java from aidl..."
 cd "$SERVER_DIR/src/main/aidl"
-"$ANDROID_HOME/build-tools/$BUILD_TOOLS/aidl" -o"$CLASSES_DIR" \
-    android/view/IRotationWatcher.aidl
-"$ANDROID_HOME/build-tools/$BUILD_TOOLS/aidl" -o"$CLASSES_DIR" \
+"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" android/view/IRotationWatcher.aidl
+"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" \
     android/content/IOnPrimaryClipChangedListener.aidl
 
 echo "Compiling java sources..."
 cd ../java
-javac -bootclasspath "$ANDROID_JAR" -cp "$CLASSES_DIR" -d "$CLASSES_DIR" \
+javac -bootclasspath "$ANDROID_JAR" \
+    -cp "$LAMBDA_JAR:$GEN_DIR" \
+    -d "$CLASSES_DIR" \
     -source 1.8 -target 1.8 \
     com/genymobile/scrcpy/*.java \
     com/genymobile/scrcpy/wrappers/*.java
@@ -59,8 +64,7 @@ cd "$CLASSES_DIR"
 if [[ $PLATFORM -lt 31 ]]
 then
     # use dx
-    "$ANDROID_HOME/build-tools/$BUILD_TOOLS/dx" --dex \
-        --output "$BUILD_DIR/classes.dex" \
+    "$BUILD_TOOLS_DIR/dx" --dex --output "$BUILD_DIR/classes.dex" \
         android/view/*.class \
         android/content/*.class \
         com/genymobile/scrcpy/*.class \
@@ -69,10 +73,10 @@ then
     echo "Archiving..."
     cd "$BUILD_DIR"
     jar cvf "$SERVER_BINARY" classes.dex
-    rm -rf classes.dex classes
+    rm -rf classes.dex
 else
     # use d8
-    "$ANDROID_HOME/build-tools/$BUILD_TOOLS/d8" --classpath "$ANDROID_JAR" \
+    "$BUILD_TOOLS_DIR/d8" --classpath "$ANDROID_JAR" \
         --output "$BUILD_DIR/classes.zip" \
         android/view/*.class \
         android/content/*.class \
@@ -81,7 +85,8 @@ else
 
     cd "$BUILD_DIR"
     mv classes.zip "$SERVER_BINARY"
-    rm -rf classes
 fi
 
+rm -rf "$GEN_DIR" "$CLASSES_DIR"
+
 echo "Server generated in $BUILD_DIR/$SERVER_BINARY"

server/meson.build

@@ -13,8 +13,8 @@ if prebuilt_server == ''
                   install_dir: 'share/scrcpy')
 else
     if not prebuilt_server.startswith('/')
-        # relative path needs some trick
-        prebuilt_server = meson.source_root() + '/' + prebuilt_server
+        # prebuilt server path is relative to the root scrcpy directory
+        prebuilt_server = '../' + prebuilt_server
     endif
     custom_target('scrcpy-server-prebuilt',
                   input: prebuilt_server,

server/src/main/java/com/genymobile/scrcpy/AudioCodec.java

@@ -0,0 +1,47 @@
+package com.genymobile.scrcpy;
+
+import android.media.MediaFormat;
+
+public enum AudioCodec implements Codec {
+    OPUS(0x6f_70_75_73, "opus", MediaFormat.MIMETYPE_AUDIO_OPUS),
+    AAC(0x00_61_61_63, "aac", MediaFormat.MIMETYPE_AUDIO_AAC);
+
+    private final int id; // 4-byte ASCII representation of the name
+    private final String name;
+    private final String mimeType;
+
+    AudioCodec(int id, String name, String mimeType) {
+        this.id = id;
+        this.name = name;
+        this.mimeType = mimeType;
+    }
+
+    @Override
+    public Type getType() {
+        return Type.AUDIO;
+    }
+
+    @Override
+    public int getId() {
+        return id;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String getMimeType() {
+        return mimeType;
+    }
+
+    public static AudioCodec findByName(String name) {
+        for (AudioCodec codec : values()) {
+            if (codec.name.equals(name)) {
+                return codec;
+            }
+        }
+        return null;
+    }
+}

server/src/main/java/com/genymobile/scrcpy/AudioEncoder.java

@@ -0,0 +1,320 @@
+package com.genymobile.scrcpy;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.media.AudioFormat;
+import android.media.AudioRecord;
+import android.media.AudioTimestamp;
+import android.media.MediaCodec;
+import android.media.MediaFormat;
+import android.media.MediaRecorder;
+import android.os.Build;
+import android.os.Handler;
+import android.os.HandlerThread;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+
+public final class AudioEncoder {
+
+    private static class InputTask {
+        private final int index;
+
+        InputTask(int index) {
+            this.index = index;
+        }
+    }
+
+    private static class OutputTask {
+        private final int index;
+        private final MediaCodec.BufferInfo bufferInfo;
+
+        OutputTask(int index, MediaCodec.BufferInfo bufferInfo) {
+            this.index = index;
+            this.bufferInfo = bufferInfo;
+        }
+    }
+
+    private static final int SAMPLE_RATE = 48000;
+    private static final int CHANNELS = 2;
+
+    private static final int BUFFER_MS = 15; // milliseconds
+    private static final int BUFFER_SIZE = SAMPLE_RATE * CHANNELS * BUFFER_MS / 1000;
+
+    private final Streamer streamer;
+    private final int bitRate;
+
+    private AudioRecord recorder;
+    private MediaCodec mediaCodec;
+
+    // Capacity of 64 is in practice "infinite" (it is limited by the number of available MediaCodec buffers, typically 4).
+    // So many pending tasks would lead to an unacceptable delay anyway.
+    private final BlockingQueue<InputTask> inputTasks = new ArrayBlockingQueue<>(64);
+    private final BlockingQueue<OutputTask> outputTasks = new ArrayBlockingQueue<>(64);
+
+    private Thread thread;
+    private HandlerThread mediaCodecThread;
+
+    private Thread inputThread;
+    private Thread outputThread;
+
+    private boolean ended;
+
+    public AudioEncoder(Streamer streamer, int bitRate) {
+        this.streamer = streamer;
+        this.bitRate = bitRate;
+    }
+
+    private static AudioFormat createAudioFormat() {
+        AudioFormat.Builder builder = new AudioFormat.Builder();
+        builder.setEncoding(AudioFormat.ENCODING_PCM_16BIT);
+        builder.setSampleRate(SAMPLE_RATE);
+        builder.setChannelMask(CHANNELS == 2 ? AudioFormat.CHANNEL_IN_STEREO : AudioFormat.CHANNEL_IN_MONO);
+        return builder.build();
+    }
+
+    @TargetApi(Build.VERSION_CODES.M)
+    @SuppressLint({"WrongConstant", "MissingPermission"})
+    private static AudioRecord createAudioRecord() {
+        AudioRecord.Builder builder = new AudioRecord.Builder();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            // On older APIs, Workarounds.fillAppInfo() must be called beforehand
+            builder.setContext(FakeContext.get());
+        }
+        builder.setAudioSource(MediaRecorder.AudioSource.REMOTE_SUBMIX);
+        builder.setAudioFormat(createAudioFormat());
+        builder.setBufferSizeInBytes(1024 * 1024);
+        return builder.build();
+    }
+
+    private static MediaFormat createFormat(String mimeType, int bitRate) {
+        MediaFormat format = new MediaFormat();
+        format.setString(MediaFormat.KEY_MIME, mimeType);
+        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
+        format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, CHANNELS);
+        format.setInteger(MediaFormat.KEY_SAMPLE_RATE, SAMPLE_RATE);
+        return format;
+    }
+
+    @TargetApi(Build.VERSION_CODES.N)
+    private void inputThread() throws IOException, InterruptedException {
+        final AudioTimestamp timestamp = new AudioTimestamp();
+        long previousPts = 0;
+        long nextPts = 0;
+
+        while (!Thread.currentThread().isInterrupted()) {
+            InputTask task = inputTasks.take();
+            ByteBuffer buffer = mediaCodec.getInputBuffer(task.index);
+            int r = recorder.read(buffer, BUFFER_SIZE);
+            if (r < 0) {
+                throw new IOException("Could not read audio: " + r);
+            }
+
+            long pts;
+
+            int ret = recorder.getTimestamp(timestamp, AudioTimestamp.TIMEBASE_MONOTONIC);
+            if (ret == AudioRecord.SUCCESS) {
+                pts = timestamp.nanoTime / 1000;
+            } else {
+                if (nextPts == 0) {
+                    Ln.w("Could not get any audio timestamp");
+                }
+                // compute from previous timestamp and packet size
+                pts = nextPts;
+            }
+
+            long durationMs = r * 1000 / CHANNELS / SAMPLE_RATE;
+            nextPts = pts + durationMs;
+
+            if (previousPts != 0 && pts < previousPts) {
+                // Audio PTS may come from two sources:
+                //  - recorder.getTimestamp() if the call works;
+                //  - an estimation from the previous PTS and the packet size as a fallback.
+                //
+                // Therefore, the property that PTS are monotonically increasing is no guaranteed in corner cases, so enforce it.
+                pts = previousPts + 1;
+            }
+
+            mediaCodec.queueInputBuffer(task.index, 0, r, pts, 0);
+
+            previousPts = pts;
+        }
+    }
+
+    private void outputThread() throws IOException, InterruptedException {
+        streamer.writeHeader();
+
+        while (!Thread.currentThread().isInterrupted()) {
+            OutputTask task = outputTasks.take();
+            ByteBuffer buffer = mediaCodec.getOutputBuffer(task.index);
+            try {
+                streamer.writePacket(buffer, task.bufferInfo);
+            } finally {
+                mediaCodec.releaseOutputBuffer(task.index, false);
+            }
+        }
+    }
+
+    public void start() {
+        thread = new Thread(() -> {
+            try {
+                encode();
+            } catch (IOException e) {
+                Ln.e("Audio encoding error", e);
+            } finally {
+                Ln.d("Audio encoder stopped");
+            }
+        });
+        thread.start();
+    }
+
+    public void stop() {
+        if (thread != null) {
+            // Just wake up the blocking wait from the thread, so that it properly releases all its resources and terminates
+            end();
+        }
+    }
+
+    public void join() throws InterruptedException {
+        if (thread != null) {
+            thread.join();
+        }
+    }
+
+    private synchronized void end() {
+        ended = true;
+        notify();
+    }
+
+    private synchronized void waitEnded() {
+        try {
+            while (!ended) {
+                wait();
+            }
+        } catch (InterruptedException e) {
+            // ignore
+        }
+    }
+
+    @TargetApi(Build.VERSION_CODES.M)
+    public void encode() throws IOException {
+        try {
+            try {
+                String mimeType = streamer.getCodec().getMimeType();
+
+                mediaCodec = MediaCodec.createEncoderByType(mimeType); // may throw IOException
+                recorder = createAudioRecord();
+
+                mediaCodecThread = new HandlerThread("AudioEncoder");
+                mediaCodecThread.start();
+
+                MediaFormat format = createFormat(mimeType, bitRate);
+                mediaCodec.setCallback(new EncoderCallback(), new Handler(mediaCodecThread.getLooper()));
+                mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+
+                recorder.startRecording();
+            } catch (Throwable e) {
+                // Notify the client that the audio could not be captured
+                streamer.writeDisableStream();
+                throw e;
+            }
+
+            inputThread = new Thread(() -> {
+                try {
+                    inputThread();
+                } catch (IOException | InterruptedException e) {
+                    Ln.e("Audio capture error", e);
+                } finally {
+                    end();
+                }
+            });
+
+            outputThread = new Thread(() -> {
+                try {
+                    outputThread();
+                } catch (InterruptedException e) {
+                    // this is expected on close
+                } catch (IOException e) {
+                    // Broken pipe is expected on close, because the socket is closed by the client
+                    if (!IO.isBrokenPipe(e)) {
+                        Ln.e("Audio encoding error", e);
+                    }
+                } finally {
+                    end();
+                }
+            });
+
+            mediaCodec.start();
+            inputThread.start();
+            outputThread.start();
+        } catch (Throwable e) {
+            if (mediaCodec != null) {
+                mediaCodec.release();
+            }
+            if (recorder != null) {
+                recorder.release();
+            }
+            throw e;
+        }
+
+        try {
+            waitEnded();
+        } finally {
+            cleanUp();
+        }
+    }
+
+    private void cleanUp() {
+        mediaCodecThread.getLooper().quit();
+        inputThread.interrupt();
+        outputThread.interrupt();
+
+        try {
+            mediaCodecThread.join();
+            inputThread.join();
+            outputThread.join();
+        } catch (InterruptedException e) {
+            // Should never happen
+            throw new AssertionError(e);
+        }
+
+        mediaCodec.stop();
+        mediaCodec.release();
+        recorder.stop();
+        recorder.release();
+    }
+
+    private class EncoderCallback extends MediaCodec.Callback {
+        @TargetApi(Build.VERSION_CODES.N)
+        @Override
+        public void onInputBufferAvailable(MediaCodec codec, int index) {
+            try {
+                inputTasks.put(new InputTask(index));
+            } catch (InterruptedException e) {
+                end();
+            }
+        }
+
+        @Override
+        public void onOutputBufferAvailable(MediaCodec codec, int index, MediaCodec.BufferInfo bufferInfo) {
+            try {
+                outputTasks.put(new OutputTask(index, bufferInfo));
+            } catch (InterruptedException e) {
+                end();
+            }
+        }
+
+        @Override
+        public void onError(MediaCodec codec, MediaCodec.CodecException e) {
+            Ln.e("MediaCodec error", e);
+            end();
+        }
+
+        @Override
+        public void onOutputFormatChanged(MediaCodec codec, MediaFormat format) {
+            // ignore
+        }
+    }
+}

server/src/main/java/com/genymobile/scrcpy/Binary.java

@@ -0,0 +1,38 @@
+package com.genymobile.scrcpy;
+
+public final class Binary {
+    private Binary() {
+        // not instantiable
+    }
+
+    public static int toUnsigned(short value) {
+        return value & 0xffff;
+    }
+
+    public static int toUnsigned(byte value) {
+        return value & 0xff;
+    }
+
+    /**
+     * Convert unsigned 16-bit fixed-point to a float between 0 and 1
+     *
+     * @param value encoded value
+     * @return Float value between 0 and 1
+     */
+    public static float u16FixedPointToFloat(short value) {
+        int unsignedShort = Binary.toUnsigned(value);
+        // 0x1p16f is 2^16 as float
+        return unsignedShort == 0xffff ? 1f : (unsignedShort / 0x1p16f);
+    }
+
+    /**
+     * Convert signed 16-bit fixed-point to a float between -1 and 1
+     *
+     * @param value encoded value
+     * @return Float value between -1 and 1
+     */
+    public static float i16FixedPointToFloat(short value) {
+        // 0x1p15f is 2^15 as float
+        return value == 0x7fff ? 1f : (value / 0x1p15f);
+    }
+}

server/src/main/java/com/genymobile/scrcpy/CleanUp.java

@@ -1,7 +1,5 @@
 package com.genymobile.scrcpy;
 
-import com.genymobile.scrcpy.wrappers.ServiceManager;
-
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.util.Base64;
@@ -164,12 +162,10 @@ public final class CleanUp {
         Config config = Config.fromBase64(args[0]);
 
         if (config.disableShowTouches || config.restoreStayOn != -1) {
-            ServiceManager serviceManager = new ServiceManager();
-            Settings settings = new Settings(serviceManager);
             if (config.disableShowTouches) {
                 Ln.i("Disabling \"show touches\"");
                 try {
-                    settings.putValue(Settings.TABLE_SYSTEM, "show_touches", "0");
+                    Settings.putValue(Settings.TABLE_SYSTEM, "show_touches", "0");
                 } catch (SettingsException e) {
                     Ln.e("Could not restore \"show_touches\"", e);
                 }
@@ -177,7 +173,7 @@ public final class CleanUp {
             if (config.restoreStayOn != -1) {
                 Ln.i("Restoring \"stay awake\"");
                 try {
-                    settings.putValue(Settings.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(config.restoreStayOn));
+                    Settings.putValue(Settings.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(config.restoreStayOn));
                 } catch (SettingsException e) {
                     Ln.e("Could not restore \"stay_on_while_plugged_in\"", e);
                 }

server/src/main/java/com/genymobile/scrcpy/Codec.java

@@ -0,0 +1,17 @@
+package com.genymobile.scrcpy;
+
+public interface Codec {
+
+    enum Type {
+        VIDEO,
+        AUDIO,
+    }
+
+    Type getType();
+
+    int getId();
+
+    String getName();
+
+    String getMimeType();
+}

server/src/main/java/com/genymobile/scrcpy/CodecOption.java

@@ -4,8 +4,8 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class CodecOption {
-    private String key;
-    private Object value;
+    private final String key;
+    private final Object value;
 
     public CodecOption(String key, Object value) {
         this.key = key;

server/src/main/java/com/genymobile/scrcpy/Command.java

@@ -30,4 +30,14 @@ public final class Command {
         }
         return result;
     }
+
+    public static String execReadOutput(String... cmd) throws IOException, InterruptedException {
+        Process process = Runtime.getRuntime().exec(cmd);
+        String output = IO.toString(process.getInputStream());
+        int exitCode = process.waitFor();
+        if (exitCode != 0) {
+            throw new IOException("Command " + Arrays.toString(cmd) + " returned with value " + exitCode);
+        }
+        return output;
+    }
 }

server/src/main/java/com/genymobile/scrcpy/ControlMessage.java

@@ -29,12 +29,13 @@ public final class ControlMessage {
     private int metaState; // KeyEvent.META_*
     private int action; // KeyEvent.ACTION_* or MotionEvent.ACTION_* or POWER_MODE_*
     private int keycode; // KeyEvent.KEYCODE_*
+    private int actionButton; // MotionEvent.BUTTON_*
     private int buttons; // MotionEvent.BUTTON_*
     private long pointerId;
     private float pressure;
     private Position position;
-    private int hScroll;
-    private int vScroll;
+    private float hScroll;
+    private float vScroll;
     private int copyKey;
     private boolean paste;
     private int repeat;
@@ -60,18 +61,20 @@ public final class ControlMessage {
         return msg;
     }
 
-    public static ControlMessage createInjectTouchEvent(int action, long pointerId, Position position, float pressure, int buttons) {
+    public static ControlMessage createInjectTouchEvent(int action, long pointerId, Position position, float pressure, int actionButton,
+            int buttons) {
         ControlMessage msg = new ControlMessage();
         msg.type = TYPE_INJECT_TOUCH_EVENT;
         msg.action = action;
         msg.pointerId = pointerId;
         msg.pressure = pressure;
         msg.position = position;
+        msg.actionButton = actionButton;
         msg.buttons = buttons;
         return msg;
     }
 
-    public static ControlMessage createInjectScrollEvent(Position position, int hScroll, int vScroll, int buttons) {
+    public static ControlMessage createInjectScrollEvent(Position position, float hScroll, float vScroll, int buttons) {
         ControlMessage msg = new ControlMessage();
         msg.type = TYPE_INJECT_SCROLL_EVENT;
         msg.position = position;
@@ -140,6 +143,10 @@ public final class ControlMessage {
         return keycode;
     }
 
+    public int getActionButton() {
+        return actionButton;
+    }
+
     public int getButtons() {
         return buttons;
     }
@@ -156,11 +163,11 @@ public final class ControlMessage {
         return position;
     }
 
-    public int getHScroll() {
+    public float getHScroll() {
         return hScroll;
     }
 
-    public int getVScroll() {
+    public float getVScroll() {
         return vScroll;
     }
 

server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java

@@ -9,8 +9,8 @@ import java.nio.charset.StandardCharsets;
 public class ControlMessageReader {
 
     static final int INJECT_KEYCODE_PAYLOAD_LENGTH = 13;
-    static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 27;
-    static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 24;
+    static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 31;
+    static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
     static final int BACK_OR_SCREEN_ON_LENGTH = 1;
     static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
     static final int GET_CLIPBOARD_LENGTH = 1;
@@ -103,7 +103,7 @@ public class ControlMessageReader {
         if (buffer.remaining() < INJECT_KEYCODE_PAYLOAD_LENGTH) {
             return null;
         }
-        int action = toUnsigned(buffer.get());
+        int action = Binary.toUnsigned(buffer.get());
         int keycode = buffer.getInt();
         int repeat = buffer.getInt();
         int metaState = buffer.getInt();
@@ -136,15 +136,13 @@ public class ControlMessageReader {
         if (buffer.remaining() < INJECT_TOUCH_EVENT_PAYLOAD_LENGTH) {
             return null;
         }
-        int action = toUnsigned(buffer.get());
+        int action = Binary.toUnsigned(buffer.get());
         long pointerId = buffer.getLong();
         Position position = readPosition(buffer);
-        // 16 bits fixed-point
-        int pressureInt = toUnsigned(buffer.getShort());
-        // convert it to a float between 0 and 1 (0x1p16f is 2^16 as float)
-        float pressure = pressureInt == 0xffff ? 1f : (pressureInt / 0x1p16f);
+        float pressure = Binary.u16FixedPointToFloat(buffer.getShort());
+        int actionButton = buffer.getInt();
         int buttons = buffer.getInt();
-        return ControlMessage.createInjectTouchEvent(action, pointerId, position, pressure, buttons);
+        return ControlMessage.createInjectTouchEvent(action, pointerId, position, pressure, actionButton, buttons);
     }
 
     private ControlMessage parseInjectScrollEvent() {
@@ -152,8 +150,8 @@ public class ControlMessageReader {
             return null;
         }
         Position position = readPosition(buffer);
-        int hScroll = buffer.getInt();
-        int vScroll = buffer.getInt();
+        float hScroll = Binary.i16FixedPointToFloat(buffer.getShort());
+        float vScroll = Binary.i16FixedPointToFloat(buffer.getShort());
         int buttons = buffer.getInt();
         return ControlMessage.createInjectScrollEvent(position, hScroll, vScroll, buttons);
     }
@@ -162,7 +160,7 @@ public class ControlMessageReader {
         if (buffer.remaining() < BACK_OR_SCREEN_ON_LENGTH) {
             return null;
         }
-        int action = toUnsigned(buffer.get());
+        int action = Binary.toUnsigned(buffer.get());
         return ControlMessage.createBackOrScreenOn(action);
     }
 
@@ -170,7 +168,7 @@ public class ControlMessageReader {
         if (buffer.remaining() < GET_CLIPBOARD_LENGTH) {
             return null;
         }
-        int copyKey = toUnsigned(buffer.get());
+        int copyKey = Binary.toUnsigned(buffer.get());
         return ControlMessage.createGetClipboard(copyKey);
     }
 
@@ -198,16 +196,8 @@ public class ControlMessageReader {
     private static Position readPosition(ByteBuffer buffer) {
         int x = buffer.getInt();
         int y = buffer.getInt();
-        int screenWidth = toUnsigned(buffer.getShort());
-        int screenHeight = toUnsigned(buffer.getShort());
+        int screenWidth = Binary.toUnsigned(buffer.getShort());
+        int screenHeight = Binary.toUnsigned(buffer.getShort());
         return new Position(x, y, screenWidth, screenHeight);
     }
-
-    private static int toUnsigned(short value) {
-        return value & 0xffff;
-    }
-
-    private static int toUnsigned(byte value) {
-        return value & 0xff;
-    }
 }

server/src/main/java/com/genymobile/scrcpy/Controller.java

@@ -1,5 +1,7 @@
 package com.genymobile.scrcpy;
 
+import com.genymobile.scrcpy.wrappers.InputManager;
+
 import android.os.Build;
 import android.os.SystemClock;
 import android.view.InputDevice;
@@ -16,8 +18,14 @@ public class Controller {
 
     private static final int DEFAULT_DEVICE_ID = 0;
 
+    // control_msg.h values of the pointerId field in inject_touch_event message
+    private static final int POINTER_ID_MOUSE = -1;
+    private static final int POINTER_ID_VIRTUAL_MOUSE = -3;
+
     private static final ScheduledExecutorService EXECUTOR = Executors.newSingleThreadScheduledExecutor();
 
+    private Thread thread;
+
     private final Device device;
     private final DesktopConnection connection;
     private final DeviceMessageSender sender;
@@ -56,7 +64,7 @@ public class Controller {
         }
     }
 
-    public void control() throws IOException {
+    private void control() throws IOException {
         // on start, power on the device
         if (powerOn && !Device.isScreenOn()) {
             device.pressReleaseKeycode(KeyEvent.KEYCODE_POWER, Device.INJECT_MODE_ASYNC);
@@ -71,11 +79,39 @@ public class Controller {
             SystemClock.sleep(500);
         }
 
-        while (true) {
+        while (!Thread.currentThread().isInterrupted()) {
             handleEvent();
         }
     }
 
+    public void start() {
+        thread = new Thread(() -> {
+            try {
+                control();
+            } catch (IOException e) {
+                // this is expected on close
+            } finally {
+                Ln.d("Controller stopped");
+            }
+        });
+        thread.start();
+        sender.start();
+    }
+
+    public void stop() {
+        if (thread != null) {
+            thread.interrupt();
+        }
+        sender.stop();
+    }
+
+    public void join() throws InterruptedException {
+        if (thread != null) {
+            thread.join();
+        }
+        sender.join();
+    }
+
     public DeviceMessageSender getSender() {
         return sender;
     }
@@ -95,7 +131,7 @@ public class Controller {
                 break;
             case ControlMessage.TYPE_INJECT_TOUCH_EVENT:
                 if (device.supportsInputEvents()) {
-                    injectTouch(msg.getAction(), msg.getPointerId(), msg.getPosition(), msg.getPressure(), msg.getButtons());
+                    injectTouch(msg.getAction(), msg.getPointerId(), msg.getPosition(), msg.getPressure(), msg.getActionButton(), msg.getButtons());
                 }
                 break;
             case ControlMessage.TYPE_INJECT_SCROLL_EVENT:
@@ -175,7 +211,7 @@ public class Controller {
         return successCount;
     }
 
-    private boolean injectTouch(int action, long pointerId, Position position, float pressure, int buttons) {
+    private boolean injectTouch(int action, long pointerId, Position position, float pressure, int actionButton, int buttons) {
         long now = SystemClock.uptimeMillis();
 
         Point point = device.getPhysicalPoint(position);
@@ -192,10 +228,23 @@ public class Controller {
         Pointer pointer = pointersState.get(pointerIndex);
         pointer.setPoint(point);
         pointer.setPressure(pressure);
+
+        int source;
+        if (pointerId == POINTER_ID_MOUSE || pointerId == POINTER_ID_VIRTUAL_MOUSE) {
+            // real mouse event (forced by the client when --forward-on-click)
+            pointerProperties[pointerIndex].toolType = MotionEvent.TOOL_TYPE_MOUSE;
+            source = InputDevice.SOURCE_MOUSE;
+            pointer.setUp(buttons == 0);
+        } else {
+            // POINTER_ID_GENERIC_FINGER, POINTER_ID_VIRTUAL_FINGER or real touch from device
+            pointerProperties[pointerIndex].toolType = MotionEvent.TOOL_TYPE_FINGER;
+            source = InputDevice.SOURCE_TOUCHSCREEN;
+            // Buttons must not be set for touch events
+            buttons = 0;
             pointer.setUp(action == MotionEvent.ACTION_UP);
+        }
 
         int pointerCount = pointersState.update(pointerProperties, pointerCoords);
-
         if (pointerCount == 1) {
             if (action == MotionEvent.ACTION_DOWN) {
                 lastTouchDown = now;
@@ -209,12 +258,60 @@ public class Controller {
             }
         }
 
-        // Right-click and middle-click only work if the source is a mouse
-        boolean nonPrimaryButtonPressed = (buttons & ~MotionEvent.BUTTON_PRIMARY) != 0;
-        int source = nonPrimaryButtonPressed ? InputDevice.SOURCE_MOUSE : InputDevice.SOURCE_TOUCHSCREEN;
-        if (source != InputDevice.SOURCE_MOUSE) {
-            // Buttons must not be set for touch events
-            buttons = 0;
+        /* If the input device is a mouse (on API >= 23):
+         *   - the first button pressed must first generate ACTION_DOWN;
+         *   - all button pressed (including the first one) must generate ACTION_BUTTON_PRESS;
+         *   - all button released (including the last one) must generate ACTION_BUTTON_RELEASE;
+         *   - the last button released must in addition generate ACTION_UP.
+         *
+         * Otherwise, Chrome does not work properly: <https://github.com/Genymobile/scrcpy/issues/3635>
+         */
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && source == InputDevice.SOURCE_MOUSE) {
+            if (action == MotionEvent.ACTION_DOWN) {
+                if (actionButton == buttons) {
+                    // First button pressed: ACTION_DOWN
+                    MotionEvent downEvent = MotionEvent.obtain(lastTouchDown, now, MotionEvent.ACTION_DOWN, pointerCount, pointerProperties,
+                            pointerCoords, 0, buttons, 1f, 1f, DEFAULT_DEVICE_ID, 0, source, 0);
+                    if (!device.injectEvent(downEvent, Device.INJECT_MODE_ASYNC)) {
+                        return false;
+                    }
+                }
+
+                // Any button pressed: ACTION_BUTTON_PRESS
+                MotionEvent pressEvent = MotionEvent.obtain(lastTouchDown, now, MotionEvent.ACTION_BUTTON_PRESS, pointerCount, pointerProperties,
+                        pointerCoords, 0, buttons, 1f, 1f, DEFAULT_DEVICE_ID, 0, source, 0);
+                if (!InputManager.setActionButton(pressEvent, actionButton)) {
+                    return false;
+                }
+                if (!device.injectEvent(pressEvent, Device.INJECT_MODE_ASYNC)) {
+                    return false;
+                }
+
+                return true;
+            }
+
+            if (action == MotionEvent.ACTION_UP) {
+                // Any button released: ACTION_BUTTON_RELEASE
+                MotionEvent releaseEvent = MotionEvent.obtain(lastTouchDown, now, MotionEvent.ACTION_BUTTON_RELEASE, pointerCount, pointerProperties,
+                        pointerCoords, 0, buttons, 1f, 1f, DEFAULT_DEVICE_ID, 0, source, 0);
+                if (!InputManager.setActionButton(releaseEvent, actionButton)) {
+                    return false;
+                }
+                if (!device.injectEvent(releaseEvent, Device.INJECT_MODE_ASYNC)) {
+                    return false;
+                }
+
+                if (buttons == 0) {
+                    // Last button released: ACTION_UP
+                    MotionEvent upEvent = MotionEvent.obtain(lastTouchDown, now, MotionEvent.ACTION_UP, pointerCount, pointerProperties,
+                            pointerCoords, 0, buttons, 1f, 1f, DEFAULT_DEVICE_ID, 0, source, 0);
+                    if (!device.injectEvent(upEvent, Device.INJECT_MODE_ASYNC)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
         }
 
         MotionEvent event = MotionEvent
@@ -223,7 +320,7 @@ public class Controller {
         return device.injectEvent(event, Device.INJECT_MODE_ASYNC);
     }
 
-    private boolean injectScroll(Position position, int hScroll, int vScroll, int buttons) {
+    private boolean injectScroll(Position position, float hScroll, float vScroll, int buttons) {
         long now = SystemClock.uptimeMillis();
         Point point = device.getPhysicalPoint(position);
         if (point == null) {
@@ -250,12 +347,9 @@ public class Controller {
      * Schedule a call to set power mode to off after a small delay.
      */
     private static void schedulePowerModeOff() {
-        EXECUTOR.schedule(new Runnable() {
-            @Override
-            public void run() {
+        EXECUTOR.schedule(() -> {
             Ln.i("Forcing screen off");
             Device.setScreenPowerMode(Device.POWER_MODE_OFF);
-            }
         }, 200, TimeUnit.MILLISECONDS);
     }
 

server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java

@@ -15,11 +15,14 @@ public final class DesktopConnection implements Closeable {
 
     private static final int DEVICE_NAME_FIELD_LENGTH = 64;
 
-    private static final String SOCKET_NAME = "scrcpy";
+    private static final String SOCKET_NAME_PREFIX = "scrcpy";
 
     private final LocalSocket videoSocket;
     private final FileDescriptor videoFd;
 
+    private final LocalSocket audioSocket;
+    private final FileDescriptor audioFd;
+
     private final LocalSocket controlSocket;
     private final InputStream controlInputStream;
     private final OutputStream controlOutputStream;
@@ -27,9 +30,10 @@ public final class DesktopConnection implements Closeable {
     private final ControlMessageReader reader = new ControlMessageReader();
     private final DeviceMessageWriter writer = new DeviceMessageWriter();
 
-    private DesktopConnection(LocalSocket videoSocket, LocalSocket controlSocket) throws IOException {
+    private DesktopConnection(LocalSocket videoSocket, LocalSocket audioSocket, LocalSocket controlSocket) throws IOException {
         this.videoSocket = videoSocket;
         this.controlSocket = controlSocket;
+        this.audioSocket = audioSocket;
         if (controlSocket != null) {
             controlInputStream = controlSocket.getInputStream();
             controlOutputStream = controlSocket.getOutputStream();
@@ -38,6 +42,7 @@ public final class DesktopConnection implements Closeable {
             controlOutputStream = null;
         }
         videoFd = videoSocket.getFileDescriptor();
+        audioFd = audioSocket != null ? audioSocket.getFileDescriptor() : null;
     }
 
     private static LocalSocket connect(String abstractName) throws IOException {
@@ -46,41 +51,59 @@ public final class DesktopConnection implements Closeable {
         return localSocket;
     }
 
-    public static DesktopConnection open(boolean tunnelForward, boolean control, boolean sendDummyByte) throws IOException {
-        LocalSocket videoSocket;
+    private static String getSocketName(int scid) {
+        if (scid == -1) {
+            // If no SCID is set, use "scrcpy" to simplify using scrcpy-server alone
+            return SOCKET_NAME_PREFIX;
+        }
+
+        return SOCKET_NAME_PREFIX + String.format("_%08x", scid);
+    }
+
+    public static DesktopConnection open(int scid, boolean tunnelForward, boolean audio, boolean control, boolean sendDummyByte) throws IOException {
+        String socketName = getSocketName(scid);
+
+        LocalSocket videoSocket = null;
+        LocalSocket audioSocket = null;
         LocalSocket controlSocket = null;
-        if (tunnelForward) {
-            LocalServerSocket localServerSocket = new LocalServerSocket(SOCKET_NAME);
         try {
+            if (tunnelForward) {
+                try (LocalServerSocket localServerSocket = new LocalServerSocket(socketName)) {
                     videoSocket = localServerSocket.accept();
                     if (sendDummyByte) {
                         // send one byte so the client may read() to detect a connection error
                         videoSocket.getOutputStream().write(0);
                     }
+                    if (audio) {
+                        audioSocket = localServerSocket.accept();
+                    }
                     if (control) {
-                    try {
                         controlSocket = localServerSocket.accept();
-                    } catch (IOException | RuntimeException e) {
-                        videoSocket.close();
-                        throw e;
                     }
                 }
-            } finally {
-                localServerSocket.close();
-            }
             } else {
-            videoSocket = connect(SOCKET_NAME);
+                videoSocket = connect(socketName);
+                if (audio) {
+                    audioSocket = connect(socketName);
+                }
                 if (control) {
-                try {
-                    controlSocket = connect(SOCKET_NAME);
+                    controlSocket = connect(socketName);
+                }
+            }
         } catch (IOException | RuntimeException e) {
+            if (videoSocket != null) {
                 videoSocket.close();
+            }
+            if (audioSocket != null) {
+                audioSocket.close();
+            }
+            if (controlSocket != null) {
+                controlSocket.close();
+            }
             throw e;
         }
-            }
-        }
 
-        return new DesktopConnection(videoSocket, controlSocket);
+        return new DesktopConnection(videoSocket, audioSocket, controlSocket);
     }
 
     public void close() throws IOException {
@@ -113,6 +136,10 @@ public final class DesktopConnection implements Closeable {
         return videoFd;
     }
 
+    public FileDescriptor getAudioFd() {
+        return audioFd;
+    }
+
     public ControlMessage receiveControlMessage() throws IOException {
         ControlMessage msg = reader.next();
         while (msg == null) {

server/src/main/java/com/genymobile/scrcpy/Device.java

@@ -31,9 +31,6 @@ public final class Device {
     public static final int LOCK_VIDEO_ORIENTATION_UNLOCKED = -1;
     public static final int LOCK_VIDEO_ORIENTATION_INITIAL = -2;
 
-    private static final ServiceManager SERVICE_MANAGER = new ServiceManager();
-    private static final Settings SETTINGS = new Settings(SERVICE_MANAGER);
-
     public interface RotationListener {
         void onRotationChanged(int rotation);
     }
@@ -66,9 +63,9 @@ public final class Device {
 
     public Device(Options options) {
         displayId = options.getDisplayId();
-        DisplayInfo displayInfo = SERVICE_MANAGER.getDisplayManager().getDisplayInfo(displayId);
+        DisplayInfo displayInfo = ServiceManager.getDisplayManager().getDisplayInfo(displayId);
         if (displayInfo == null) {
-            int[] displayIds = SERVICE_MANAGER.getDisplayManager().getDisplayIds();
+            int[] displayIds = ServiceManager.getDisplayManager().getDisplayIds();
             throw new InvalidDisplayIdException(displayId, displayIds);
         }
 
@@ -82,7 +79,7 @@ public final class Device {
         screenInfo = ScreenInfo.computeScreenInfo(displayInfo.getRotation(), deviceSize, crop, maxSize, lockVideoOrientation);
         layerStack = displayInfo.getLayerStack();
 
-        SERVICE_MANAGER.getWindowManager().registerRotationWatcher(new IRotationWatcher.Stub() {
+        ServiceManager.getWindowManager().registerRotationWatcher(new IRotationWatcher.Stub() {
             @Override
             public void onRotationChanged(int rotation) {
                 synchronized (Device.this) {
@@ -98,7 +95,7 @@ public final class Device {
 
         if (options.getControl() && options.getClipboardAutosync()) {
             // If control and autosync are enabled, synchronize Android clipboard to the computer automatically
-            ClipboardManager clipboardManager = SERVICE_MANAGER.getClipboardManager();
+            ClipboardManager clipboardManager = ServiceManager.getClipboardManager();
             if (clipboardManager != null) {
                 clipboardManager.addPrimaryClipChangedListener(new IOnPrimaryClipChangedListener.Stub() {
                     @Override
@@ -192,7 +189,7 @@ public final class Device {
             return false;
         }
 
-        return SERVICE_MANAGER.getInputManager().injectInputEvent(inputEvent, injectMode);
+        return ServiceManager.getInputManager().injectInputEvent(inputEvent, injectMode);
     }
 
     public boolean injectEvent(InputEvent event, int injectMode) {
@@ -220,7 +217,7 @@ public final class Device {
     }
 
     public static boolean isScreenOn() {
-        return SERVICE_MANAGER.getPowerManager().isScreenOn();
+        return ServiceManager.getPowerManager().isScreenOn();
     }
 
     public synchronized void setRotationListener(RotationListener rotationListener) {
@@ -232,19 +229,19 @@ public final class Device {
     }
 
     public static void expandNotificationPanel() {
-        SERVICE_MANAGER.getStatusBarManager().expandNotificationsPanel();
+        ServiceManager.getStatusBarManager().expandNotificationsPanel();
     }
 
     public static void expandSettingsPanel() {
-        SERVICE_MANAGER.getStatusBarManager().expandSettingsPanel();
+        ServiceManager.getStatusBarManager().expandSettingsPanel();
     }
 
     public static void collapsePanels() {
-        SERVICE_MANAGER.getStatusBarManager().collapsePanels();
+        ServiceManager.getStatusBarManager().collapsePanels();
     }
 
     public static String getClipboardText() {
-        ClipboardManager clipboardManager = SERVICE_MANAGER.getClipboardManager();
+        ClipboardManager clipboardManager = ServiceManager.getClipboardManager();
         if (clipboardManager == null) {
             return null;
         }
@@ -256,7 +253,7 @@ public final class Device {
     }
 
     public boolean setClipboardText(String text) {
-        ClipboardManager clipboardManager = SERVICE_MANAGER.getClipboardManager();
+        ClipboardManager clipboardManager = ServiceManager.getClipboardManager();
         if (clipboardManager == null) {
             return false;
         }
@@ -280,6 +277,26 @@ public final class Device {
      * @param mode one of the {@code POWER_MODE_*} constants
      */
     public static boolean setScreenPowerMode(int mode) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            // Change the power mode for all physical displays
+            long[] physicalDisplayIds = SurfaceControl.getPhysicalDisplayIds();
+            if (physicalDisplayIds == null) {
+                Ln.e("Could not get physical display ids");
+                return false;
+            }
+
+            boolean allOk = true;
+            for (long physicalDisplayId : physicalDisplayIds) {
+                IBinder binder = SurfaceControl.getPhysicalDisplayToken(physicalDisplayId);
+                boolean ok = SurfaceControl.setDisplayPowerMode(binder, mode);
+                if (!ok) {
+                    allOk = false;
+                }
+            }
+            return allOk;
+        }
+
+        // Older Android versions, only 1 display
         IBinder d = SurfaceControl.getBuiltInDisplay();
         if (d == null) {
             Ln.e("Could not get built-in display");
@@ -299,7 +316,7 @@ public final class Device {
      * Disable auto-rotation (if enabled), set the screen rotation and re-enable auto-rotation (if it was enabled).
      */
     public static void rotateDevice() {
-        WindowManager wm = SERVICE_MANAGER.getWindowManager();
+        WindowManager wm = ServiceManager.getWindowManager();
 
         boolean accelerometerRotation = !wm.isRotationFrozen();
 
@@ -315,8 +332,4 @@ public final class Device {
             wm.thawRotation();
         }
     }
-
-    public static Settings getSettings() {
-        return SETTINGS;
-    }
 }

server/src/main/java/com/genymobile/scrcpy/DeviceMessageSender.java

@@ -6,6 +6,8 @@ public final class DeviceMessageSender {
 
     private final DesktopConnection connection;
 
+    private Thread thread;
+
     private String clipboardText;
 
     private long ack;
@@ -24,8 +26,8 @@ public final class DeviceMessageSender {
         notify();
     }
 
-    public void loop() throws IOException, InterruptedException {
-        while (true) {
+    private void loop() throws IOException, InterruptedException {
+        while (!Thread.currentThread().isInterrupted()) {
             String text;
             long sequence;
             synchronized (this) {
@@ -49,4 +51,28 @@ public final class DeviceMessageSender {
             }
         }
     }
+    public void start() {
+        thread = new Thread(() -> {
+            try {
+                loop();
+            } catch (IOException | InterruptedException e) {
+                // this is expected on close
+            } finally {
+                Ln.d("Device message sender stopped");
+            }
+        });
+        thread.start();
+    }
+
+    public void stop() {
+        if (thread != null) {
+            thread.interrupt();
+        }
+    }
+
+    public void join() throws InterruptedException {
+        if (thread != null) {
+            thread.join();
+        }
+    }
 }

server/src/main/java/com/genymobile/scrcpy/FakeContext.java

@@ -0,0 +1,40 @@
+package com.genymobile.scrcpy;
+
+import android.annotation.TargetApi;
+import android.content.AttributionSource;
+import android.content.ContextWrapper;
+import android.os.Build;
+import android.os.Process;
+
+public final class FakeContext extends ContextWrapper {
+
+    public static final String PACKAGE_NAME = "com.android.shell";
+
+    private static final FakeContext INSTANCE = new FakeContext();
+
+    public static FakeContext get() {
+        return INSTANCE;
+    }
+
+    private FakeContext() {
+        super(null);
+    }
+
+    @Override
+    public String getPackageName() {
+        return PACKAGE_NAME;
+    }
+
+    @Override
+    public String getOpPackageName() {
+        return PACKAGE_NAME;
+    }
+
+    @TargetApi(Build.VERSION_CODES.S)
+    @Override
+    public AttributionSource getAttributionSource() {
+        AttributionSource.Builder builder = new AttributionSource.Builder(Process.SHELL_UID);
+        builder.setPackageName(PACKAGE_NAME);
+        return builder.build();
+    }
+}

server/src/main/java/com/genymobile/scrcpy/IO.java

@@ -6,7 +6,9 @@ import android.system.OsConstants;
 
 import java.io.FileDescriptor;
 import java.io.IOException;
+import java.io.InputStream;
 import java.nio.ByteBuffer;
+import java.util.Scanner;
 
 public final class IO {
     private IO() {
@@ -37,4 +39,18 @@ public final class IO {
     public static void writeFully(FileDescriptor fd, byte[] buffer, int offset, int len) throws IOException {
         writeFully(fd, ByteBuffer.wrap(buffer, offset, len));
     }
+
+    public static String toString(InputStream inputStream) {
+        StringBuilder builder = new StringBuilder();
+        Scanner scanner = new Scanner(inputStream);
+        while (scanner.hasNextLine()) {
+            builder.append(scanner.nextLine()).append('\n');
+        }
+        return builder.toString();
+    }
+
+    public static boolean isBrokenPipe(IOException e) {
+        Throwable cause = e.getCause();
+        return cause instanceof ErrnoException && ((ErrnoException) cause).errno == OsConstants.EPIPE;
+    }
 }

server/src/main/java/com/genymobile/scrcpy/Options.java

@@ -5,9 +5,15 @@ import android.graphics.Rect;
 import java.util.List;
 
 public class Options {
+
     private Ln.Level logLevel = Ln.Level.DEBUG;
+    private int scid = -1; // 31-bit non-negative value, or -1
+    private boolean audio = true;
     private int maxSize;
+    private VideoCodec codec = VideoCodec.H264;
+    private AudioCodec audioCodec = AudioCodec.OPUS;
     private int bitRate = 8000000;
+    private int audioBitRate = 196000;
     private int maxFps;
     private int lockVideoOrientation = -1;
     private boolean tunnelForward;
@@ -28,6 +34,7 @@ public class Options {
     private boolean sendDeviceMeta = true; // send device name and size
     private boolean sendFrameMeta = true; // send PTS so that the client may record properly
     private boolean sendDummyByte = true; // write a byte on start to detect connection issues
+    private boolean sendCodecId = true; // write the codec ID (4 bytes) before the stream
 
     public Ln.Level getLogLevel() {
         return logLevel;
@@ -37,6 +44,22 @@ public class Options {
         this.logLevel = logLevel;
     }
 
+    public int getScid() {
+        return scid;
+    }
+
+    public void setScid(int scid) {
+        this.scid = scid;
+    }
+
+    public boolean getAudio() {
+        return audio;
+    }
+
+    public void setAudio(boolean audio) {
+        this.audio = audio;
+    }
+
     public int getMaxSize() {
         return maxSize;
     }
@@ -45,6 +68,22 @@ public class Options {
         this.maxSize = maxSize;
     }
 
+    public VideoCodec getCodec() {
+        return codec;
+    }
+
+    public void setCodec(VideoCodec codec) {
+        this.codec = codec;
+    }
+
+    public AudioCodec getAudioCodec() {
+        return audioCodec;
+    }
+
+    public void setAudioCodec(AudioCodec audioCodec) {
+        this.audioCodec = audioCodec;
+    }
+
     public int getBitRate() {
         return bitRate;
     }
@@ -53,6 +92,14 @@ public class Options {
         this.bitRate = bitRate;
     }
 
+    public int getAudioBitRate() {
+        return audioBitRate;
+    }
+
+    public void setAudioBitRate(int audioBitRate) {
+        this.audioBitRate = audioBitRate;
+    }
+
     public int getMaxFps() {
         return maxFps;
     }
@@ -196,4 +243,12 @@ public class Options {
     public void setSendDummyByte(boolean sendDummyByte) {
         this.sendDummyByte = sendDummyByte;
     }
+
+    public boolean getSendCodecId() {
+        return sendCodecId;
+    }
+
+    public void setSendCodecId(boolean sendCodecId) {
+        this.sendCodecId = sendCodecId;
+    }
 }

server/src/main/java/com/genymobile/scrcpy/Position.java

@@ -3,8 +3,8 @@ package com.genymobile.scrcpy;
 import java.util.Objects;
 
 public class Position {
-    private Point point;
-    private Size screenSize;
+    private final Point point;
+    private final Size screenSize;
 
     public Position(Point point, Size screenSize) {
         this.point = point;

server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java

@@ -9,9 +9,9 @@ import android.media.MediaCodecList;
 import android.media.MediaFormat;
 import android.os.Build;
 import android.os.IBinder;
+import android.os.SystemClock;
 import android.view.Surface;
 
-import java.io.FileDescriptor;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
@@ -27,26 +27,25 @@ public class ScreenEncoder implements Device.RotationListener {
 
     // Keep the values in descending order
     private static final int[] MAX_SIZE_FALLBACK = {2560, 1920, 1600, 1280, 1024, 800};
-
-    private static final long PACKET_FLAG_CONFIG = 1L << 63;
-    private static final long PACKET_FLAG_KEY_FRAME = 1L << 62;
+    private static final int MAX_CONSECUTIVE_ERRORS = 3;
 
     private final AtomicBoolean rotationChanged = new AtomicBoolean();
-    private final ByteBuffer headerBuffer = ByteBuffer.allocate(12);
 
+    private final Device device;
+    private final Streamer streamer;
     private final String encoderName;
     private final List<CodecOption> codecOptions;
     private final int bitRate;
     private final int maxFps;
-    private final boolean sendFrameMeta;
     private final boolean downsizeOnError;
-    private long ptsOrigin;
 
     private boolean firstFrameSent;
+    private int consecutiveErrors;
 
-    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
+    public ScreenEncoder(Device device, Streamer streamer, int bitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
             boolean downsizeOnError) {
-        this.sendFrameMeta = sendFrameMeta;
+        this.device = device;
+        this.streamer = streamer;
         this.bitRate = bitRate;
         this.maxFps = maxFps;
         this.codecOptions = codecOptions;
@@ -63,75 +62,96 @@ public class ScreenEncoder implements Device.RotationListener {
         return rotationChanged.getAndSet(false);
     }
 
-    public void streamScreen(Device device, FileDescriptor fd) throws IOException {
-        Workarounds.prepareMainLooper();
-        if (Build.BRAND.equalsIgnoreCase("meizu")) {
-            // <https://github.com/Genymobile/scrcpy/issues/240>
-            // <https://github.com/Genymobile/scrcpy/issues/2656>
-            Workarounds.fillAppInfo();
-        }
-
-        internalStreamScreen(device, fd);
-    }
-
-    private void internalStreamScreen(Device device, FileDescriptor fd) throws IOException {
-        MediaFormat format = createFormat(bitRate, maxFps, codecOptions);
+    public void streamScreen() throws IOException {
+        String videoMimeType = streamer.getCodec().getMimeType();
+        MediaCodec codec = createCodec(videoMimeType, encoderName);
+        MediaFormat format = createFormat(videoMimeType, bitRate, maxFps, codecOptions);
+        IBinder display = createDisplay();
         device.setRotationListener(this);
+
+        streamer.writeHeader();
+
         boolean alive;
         try {
             do {
-                MediaCodec codec = createCodec(encoderName);
-                IBinder display = createDisplay();
                 ScreenInfo screenInfo = device.getScreenInfo();
                 Rect contentRect = screenInfo.getContentRect();
+
                 // include the locked video orientation
                 Rect videoRect = screenInfo.getVideoSize().toRect();
+                format.setInteger(MediaFormat.KEY_WIDTH, videoRect.width());
+                format.setInteger(MediaFormat.KEY_HEIGHT, videoRect.height());
+
+                Surface surface = null;
+                try {
+                    codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+                    surface = codec.createInputSurface();
+
                     // does not include the locked video orientation
                     Rect unlockedVideoRect = screenInfo.getUnlockedVideoSize().toRect();
                     int videoRotation = screenInfo.getVideoRotation();
                     int layerStack = device.getLayerStack();
-                setSize(format, videoRect.width(), videoRect.height());
-
-                Surface surface = null;
-                try {
-                    configure(codec, format);
-                    surface = codec.createInputSurface();
                     setDisplaySurface(display, surface, videoRotation, contentRect, unlockedVideoRect, layerStack);
+
                     codec.start();
 
-                    alive = encode(codec, fd);
+                    alive = encode(codec, streamer);
                     // do not call stop() on exception, it would trigger an IllegalStateException
                     codec.stop();
                 } catch (IllegalStateException | IllegalArgumentException e) {
                     Ln.e("Encoding error: " + e.getClass().getName() + ": " + e.getMessage());
-                    if (!downsizeOnError || firstFrameSent) {
-                        // Fail immediately
+                    if (!prepareRetry(device, screenInfo)) {
                         throw e;
                     }
-
-                    int newMaxSize = chooseMaxSizeFallback(screenInfo.getVideoSize());
-                    if (newMaxSize == 0) {
-                        // Definitively fail
-                        throw e;
-                    }
-
-                    // Retry with a smaller device size
-                    Ln.i("Retrying with -m" + newMaxSize + "...");
-                    device.setMaxSize(newMaxSize);
+                    Ln.i("Retrying...");
                     alive = true;
                 } finally {
-                    destroyDisplay(display);
-                    codec.release();
+                    codec.reset();
                     if (surface != null) {
                         surface.release();
                     }
                 }
             } while (alive);
         } finally {
+            codec.release();
             device.setRotationListener(null);
+            SurfaceControl.destroyDisplay(display);
         }
     }
 
+    private boolean prepareRetry(Device device, ScreenInfo screenInfo) {
+        if (firstFrameSent) {
+            ++consecutiveErrors;
+            if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                // Definitively fail
+                return false;
+            }
+
+            // Wait a bit to increase the probability that retrying will fix the problem
+            SystemClock.sleep(50);
+            return true;
+        }
+
+        if (!downsizeOnError) {
+            // Must fail immediately
+            return false;
+        }
+
+        // Downsizing on error is only enabled if an encoding failure occurs before the first frame (downsizing later could be surprising)
+
+        int newMaxSize = chooseMaxSizeFallback(screenInfo.getVideoSize());
+        Ln.i("newMaxSize = " + newMaxSize);
+        if (newMaxSize == 0) {
+            // Must definitively fail
+            return false;
+        }
+
+        // Retry with a smaller device size
+        Ln.i("Retrying with -m" + newMaxSize + "...");
+        device.setMaxSize(newMaxSize);
+        return true;
+    }
+
     private static int chooseMaxSizeFallback(Size failedSize) {
         int currentMaxSize = Math.max(failedSize.getWidth(), failedSize.getHeight());
         for (int value : MAX_SIZE_FALLBACK) {
@@ -144,30 +164,30 @@ public class ScreenEncoder implements Device.RotationListener {
         return 0;
     }
 
-    private boolean encode(MediaCodec codec, FileDescriptor fd) throws IOException {
+    private boolean encode(MediaCodec codec, Streamer streamer) throws IOException {
         boolean eof = false;
         MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
 
         while (!consumeRotationChange() && !eof) {
             int outputBufferId = codec.dequeueOutputBuffer(bufferInfo, -1);
-            eof = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
             try {
                 if (consumeRotationChange()) {
                     // must restart encoding with new size
                     break;
                 }
+
+                eof = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
                 if (outputBufferId >= 0) {
                     ByteBuffer codecBuffer = codec.getOutputBuffer(outputBufferId);
 
-                    if (sendFrameMeta) {
-                        writeFrameMeta(fd, bufferInfo, codecBuffer.remaining());
-                    }
-
-                    IO.writeFully(fd, codecBuffer);
-                    if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
+                    boolean isConfig = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0;
+                    if (!isConfig) {
                         // If this is not a config packet, then it contains a frame
                         firstFrameSent = true;
+                        consecutiveErrors = 0;
                     }
+
+                    streamer.writePacket(codecBuffer, bufferInfo);
                 }
             } finally {
                 if (outputBufferId >= 0) {
@@ -179,50 +199,28 @@ public class ScreenEncoder implements Device.RotationListener {
         return !eof;
     }
 
-    private void writeFrameMeta(FileDescriptor fd, MediaCodec.BufferInfo bufferInfo, int packetSize) throws IOException {
-        headerBuffer.clear();
-
-        long pts;
-        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
-            pts = PACKET_FLAG_CONFIG; // non-media data packet
-        } else {
-            if (ptsOrigin == 0) {
-                ptsOrigin = bufferInfo.presentationTimeUs;
-            }
-            pts = bufferInfo.presentationTimeUs - ptsOrigin;
-            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) != 0) {
-                pts |= PACKET_FLAG_KEY_FRAME;
-            }
-        }
-
-        headerBuffer.putLong(pts);
-        headerBuffer.putInt(packetSize);
-        headerBuffer.flip();
-        IO.writeFully(fd, headerBuffer);
-    }
-
-    private static MediaCodecInfo[] listEncoders() {
+    private static MediaCodecInfo[] listEncoders(String videoMimeType) {
         List<MediaCodecInfo> result = new ArrayList<>();
         MediaCodecList list = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
         for (MediaCodecInfo codecInfo : list.getCodecInfos()) {
-            if (codecInfo.isEncoder() && Arrays.asList(codecInfo.getSupportedTypes()).contains(MediaFormat.MIMETYPE_VIDEO_AVC)) {
+            if (codecInfo.isEncoder() && Arrays.asList(codecInfo.getSupportedTypes()).contains(videoMimeType)) {
                 result.add(codecInfo);
             }
         }
         return result.toArray(new MediaCodecInfo[result.size()]);
     }
 
-    private static MediaCodec createCodec(String encoderName) throws IOException {
+    private static MediaCodec createCodec(String videoMimeType, String encoderName) throws IOException {
         if (encoderName != null) {
             Ln.d("Creating encoder by name: '" + encoderName + "'");
             try {
                 return MediaCodec.createByCodecName(encoderName);
             } catch (IllegalArgumentException e) {
-                MediaCodecInfo[] encoders = listEncoders();
+                MediaCodecInfo[] encoders = listEncoders(videoMimeType);
                 throw new InvalidEncoderException(encoderName, encoders);
             }
         }
-        MediaCodec codec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
+        MediaCodec codec = MediaCodec.createEncoderByType(videoMimeType);
         Ln.d("Using encoder: '" + codec.getName() + "'");
         return codec;
     }
@@ -244,9 +242,9 @@ public class ScreenEncoder implements Device.RotationListener {
         Ln.d("Codec option set: " + key + " (" + value.getClass().getSimpleName() + ") = " + value);
     }
 
-    private static MediaFormat createFormat(int bitRate, int maxFps, List<CodecOption> codecOptions) {
+    private static MediaFormat createFormat(String videoMimeType, int bitRate, int maxFps, List<CodecOption> codecOptions) {
         MediaFormat format = new MediaFormat();
-        format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_AVC);
+        format.setString(MediaFormat.KEY_MIME, videoMimeType);
         format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
         // must be present to configure the encoder, but does not impact the actual frame rate, which is variable
         format.setInteger(MediaFormat.KEY_FRAME_RATE, 60);
@@ -278,15 +276,6 @@ public class ScreenEncoder implements Device.RotationListener {
         return SurfaceControl.createDisplay("scrcpy", secure);
     }
 
-    private static void configure(MediaCodec codec, MediaFormat format) {
-        codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
-    }
-
-    private static void setSize(MediaFormat format, int width, int height) {
-        format.setInteger(MediaFormat.KEY_WIDTH, width);
-        format.setInteger(MediaFormat.KEY_HEIGHT, height);
-    }
-
     private static void setDisplaySurface(IBinder display, Surface surface, int orientation, Rect deviceRect, Rect displayRect, int layerStack) {
         SurfaceControl.openTransaction();
         try {
@@ -297,8 +286,4 @@ public class ScreenEncoder implements Device.RotationListener {
             SurfaceControl.closeTransaction();
         }
     }
-
-    private static void destroyDisplay(IBinder display) {
-        SurfaceControl.destroyDisplay(display);
-    }
 }

server/src/main/java/com/genymobile/scrcpy/Server.java

@@ -20,10 +20,9 @@ public final class Server {
         int restoreStayOn = -1;
         boolean restoreNormalPowerMode = options.getControl(); // only restore power mode if control is enabled
         if (options.getShowTouches() || options.getStayAwake()) {
-            Settings settings = Device.getSettings();
             if (options.getShowTouches()) {
                 try {
-                    String oldValue = settings.getAndPutValue(Settings.TABLE_SYSTEM, "show_touches", "1");
+                    String oldValue = Settings.getAndPutValue(Settings.TABLE_SYSTEM, "show_touches", "1");
                     // If "show touches" was disabled, it must be disabled back on clean up
                     mustDisableShowTouchesOnCleanUp = !"1".equals(oldValue);
                 } catch (SettingsException e) {
@@ -34,7 +33,7 @@ public final class Server {
             if (options.getStayAwake()) {
                 int stayOn = BatteryManager.BATTERY_PLUGGED_AC | BatteryManager.BATTERY_PLUGGED_USB | BatteryManager.BATTERY_PLUGGED_WIRELESS;
                 try {
-                    String oldValue = settings.getAndPutValue(Settings.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(stayOn));
+                    String oldValue = Settings.getAndPutValue(Settings.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(stayOn));
                     try {
                         restoreStayOn = Integer.parseInt(oldValue);
                         if (restoreStayOn == stayOn) {
@@ -67,96 +66,100 @@ public final class Server {
 
         Thread initThread = startInitThread(options);
 
+        int scid = options.getScid();
         boolean tunnelForward = options.isTunnelForward();
         boolean control = options.getControl();
+        boolean audio = options.getAudio();
         boolean sendDummyByte = options.getSendDummyByte();
 
-        try (DesktopConnection connection = DesktopConnection.open(tunnelForward, control, sendDummyByte)) {
+        Workarounds.prepareMainLooper();
+
+        // Workarounds must be applied for Meizu phones:
+        //  - <https://github.com/Genymobile/scrcpy/issues/240>
+        //  - <https://github.com/Genymobile/scrcpy/issues/365>
+        //  - <https://github.com/Genymobile/scrcpy/issues/2656>
+        //
+        // But only apply when strictly necessary, since workarounds can cause other issues:
+        //  - <https://github.com/Genymobile/scrcpy/issues/940>
+        //  - <https://github.com/Genymobile/scrcpy/issues/994>
+        boolean mustFillAppInfo = Build.BRAND.equalsIgnoreCase("meizu");
+
+        // Before Android 11, audio is not supported.
+        // Since Android 12, we can properly set a context on the AudioRecord.
+        // Only on Android 11 we must fill app info for the AudioRecord to work.
+        mustFillAppInfo |= audio && Build.VERSION.SDK_INT == Build.VERSION_CODES.R;
+
+        if (mustFillAppInfo) {
+            Workarounds.fillAppInfo();
+        }
+
+        try (DesktopConnection connection = DesktopConnection.open(scid, tunnelForward, audio, control, sendDummyByte)) {
+            VideoCodec codec = options.getCodec();
             if (options.getSendDeviceMeta()) {
                 Size videoSize = device.getScreenInfo().getVideoSize();
                 connection.sendDeviceMeta(Device.getDeviceName(), videoSize.getWidth(), videoSize.getHeight());
             }
-            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(), codecOptions,
-                    options.getEncoderName(), options.getDownsizeOnError());
 
-            Thread controllerThread = null;
-            Thread deviceMessageSenderThread = null;
+            Controller controller = null;
             if (control) {
-                final Controller controller = new Controller(device, connection, options.getClipboardAutosync(), options.getPowerOn());
+                controller = new Controller(device, connection, options.getClipboardAutosync(), options.getPowerOn());
+                controller.start();
 
-                // asynchronous
-                controllerThread = startController(controller);
-                deviceMessageSenderThread = startDeviceMessageSender(controller.getSender());
-
-                device.setClipboardListener(new Device.ClipboardListener() {
-                    @Override
-                    public void onClipboardTextChanged(String text) {
-                        controller.getSender().pushClipboardText(text);
+                final Controller controllerRef = controller;
+                device.setClipboardListener(text -> controllerRef.getSender().pushClipboardText(text));
             }
-                });
+
+            AudioEncoder audioEncoder = null;
+            if (audio) {
+                Streamer audioStreamer = new Streamer(connection.getAudioFd(), options.getAudioCodec(), options.getSendCodecId(),
+                        options.getSendFrameMeta());
+                audioEncoder = new AudioEncoder(audioStreamer, options.getAudioBitRate());
+                audioEncoder.start();
+            }
+
+            Streamer videoStreamer = new Streamer(connection.getVideoFd(), codec, options.getSendCodecId(), options.getSendFrameMeta());
+            ScreenEncoder screenEncoder = new ScreenEncoder(device, videoStreamer, options.getBitRate(), options.getMaxFps(),
+                    codecOptions, options.getEncoderName(), options.getDownsizeOnError());
+            try {
+                // synchronous
+                screenEncoder.streamScreen();
+            } catch (IOException e) {
+                // Broken pipe is expected on close, because the socket is closed by the client
+                if (!IO.isBrokenPipe(e)) {
+                    Ln.e("Video encoding error", e);
+                }
+            } finally {
+                Ln.d("Screen streaming stopped");
+                initThread.interrupt();
+                if (audioEncoder != null) {
+                    audioEncoder.stop();
+                }
+                if (controller != null) {
+                    controller.stop();
                 }
 
                 try {
-                // synchronous
-                screenEncoder.streamScreen(device, connection.getVideoFd());
-            } catch (IOException e) {
-                // this is expected on close
-                Ln.d("Screen streaming stopped");
-            } finally {
-                initThread.interrupt();
-                if (controllerThread != null) {
-                    controllerThread.interrupt();
+                    initThread.join();
+                    if (audioEncoder != null) {
+                        audioEncoder.join();
                     }
-                if (deviceMessageSenderThread != null) {
-                    deviceMessageSenderThread.interrupt();
+                    if (controller != null) {
+                        controller.join();
+                    }
+                } catch (InterruptedException e) {
+                    // ignore
                 }
             }
         }
     }
 
     private static Thread startInitThread(final Options options) {
-        Thread thread = new Thread(new Runnable() {
-            @Override
-            public void run() {
-                initAndCleanUp(options);
-            }
-        });
-        thread.start();
-        return thread;
-    }
-
-    private static Thread startController(final Controller controller) {
-        Thread thread = new Thread(new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    controller.control();
-                } catch (IOException e) {
-                    // this is expected on close
-                    Ln.d("Controller stopped");
-                }
-            }
-        });
-        thread.start();
-        return thread;
-    }
-
-    private static Thread startDeviceMessageSender(final DeviceMessageSender sender) {
-        Thread thread = new Thread(new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    sender.loop();
-                } catch (IOException | InterruptedException e) {
-                    // this is expected on close
-                    Ln.d("Device message sender stopped");
-                }
-            }
-        });
+        Thread thread = new Thread(() -> initAndCleanUp(options));
         thread.start();
         return thread;
     }
 
+    @SuppressWarnings("MethodLength")
     private static Options createOptions(String... args) {
         if (args.length < 1) {
             throw new IllegalArgumentException("Missing client version");
@@ -179,10 +182,35 @@ public final class Server {
             String key = arg.substring(0, equalIndex);
             String value = arg.substring(equalIndex + 1);
             switch (key) {
+                case "scid":
+                    int scid = Integer.parseInt(value, 0x10);
+                    if (scid < -1) {
+                        throw new IllegalArgumentException("scid may not be negative (except -1 for 'none'): " + scid);
+                    }
+                    options.setScid(scid);
+                    break;
                 case "log_level":
                     Ln.Level level = Ln.Level.valueOf(value.toUpperCase(Locale.ENGLISH));
                     options.setLogLevel(level);
                     break;
+                case "audio":
+                    boolean audio = Boolean.parseBoolean(value);
+                    options.setAudio(audio);
+                    break;
+                case "codec":
+                    VideoCodec codec = VideoCodec.findByName(value);
+                    if (codec == null) {
+                        throw new IllegalArgumentException("Video codec " + value + " not supported");
+                    }
+                    options.setCodec(codec);
+                    break;
+                case "audio_codec":
+                    AudioCodec audioCodec = AudioCodec.findByName(value);
+                    if (audioCodec == null) {
+                        throw new IllegalArgumentException("Audio codec " + value + " not supported");
+                    }
+                    options.setAudioCodec(audioCodec);
+                    break;
                 case "max_size":
                     int maxSize = Integer.parseInt(value) & ~7; // multiple of 8
                     options.setMaxSize(maxSize);
@@ -191,6 +219,10 @@ public final class Server {
                     int bitRate = Integer.parseInt(value);
                     options.setBitRate(bitRate);
                     break;
+                case "audio_bit_rate":
+                    int audioBitRate = Integer.parseInt(value);
+                    options.setAudioBitRate(audioBitRate);
+                    break;
                 case "max_fps":
                     int maxFps = Integer.parseInt(value);
                     options.setMaxFps(maxFps);
@@ -264,12 +296,17 @@ public final class Server {
                     boolean sendDummyByte = Boolean.parseBoolean(value);
                     options.setSendDummyByte(sendDummyByte);
                     break;
+                case "send_codec_id":
+                    boolean sendCodecId = Boolean.parseBoolean(value);
+                    options.setSendCodecId(sendCodecId);
+                    break;
                 case "raw_video_stream":
                     boolean rawVideoStream = Boolean.parseBoolean(value);
                     if (rawVideoStream) {
                         options.setSendDeviceMeta(false);
                         options.setSendFrameMeta(false);
                         options.setSendDummyByte(false);
+                        options.setSendCodecId(false);
                     }
                     break;
                 default:
@@ -320,12 +357,9 @@ public final class Server {
     }
 
     public static void main(String... args) throws Exception {
-        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
-            @Override
-            public void uncaughtException(Thread t, Throwable e) {
+        Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
             Ln.e("Exception on thread " + t, e);
             suggestFix(e);
-            }
         });
 
         Options options = createOptions(args);

server/src/main/java/com/genymobile/scrcpy/Settings.java

@@ -7,16 +7,14 @@ import android.os.Build;
 
 import java.io.IOException;
 
-public class Settings {
+public final class Settings {
 
     public static final String TABLE_SYSTEM = ContentProvider.TABLE_SYSTEM;
     public static final String TABLE_SECURE = ContentProvider.TABLE_SECURE;
     public static final String TABLE_GLOBAL = ContentProvider.TABLE_GLOBAL;
 
-    private final ServiceManager serviceManager;
-
-    public Settings(ServiceManager serviceManager) {
-        this.serviceManager = serviceManager;
+    private Settings() {
+        /* not instantiable */
     }
 
     private static void execSettingsPut(String table, String key, String value) throws SettingsException {
@@ -35,10 +33,10 @@ public class Settings {
         }
     }
 
-    public String getValue(String table, String key) throws SettingsException {
+    public static String getValue(String table, String key) throws SettingsException {
         if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
             // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
-            try (ContentProvider provider = serviceManager.getActivityManager().createSettingsProvider()) {
+            try (ContentProvider provider = ServiceManager.getActivityManager().createSettingsProvider()) {
                 return provider.getValue(table, key);
             } catch (SettingsException e) {
                 Ln.w("Could not get settings value via ContentProvider, fallback to settings process", e);
@@ -48,10 +46,10 @@ public class Settings {
         return execSettingsGet(table, key);
     }
 
-    public void putValue(String table, String key, String value) throws SettingsException {
+    public static void putValue(String table, String key, String value) throws SettingsException {
         if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
             // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
-            try (ContentProvider provider = serviceManager.getActivityManager().createSettingsProvider()) {
+            try (ContentProvider provider = ServiceManager.getActivityManager().createSettingsProvider()) {
                 provider.putValue(table, key, value);
             } catch (SettingsException e) {
                 Ln.w("Could not put settings value via ContentProvider, fallback to settings process", e);
@@ -61,10 +59,10 @@ public class Settings {
         execSettingsPut(table, key, value);
     }
 
-    public String getAndPutValue(String table, String key, String value) throws SettingsException {
+    public static String getAndPutValue(String table, String key, String value) throws SettingsException {
         if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
             // on Android >= 12, it always fails: <https://github.com/Genymobile/scrcpy/issues/2788>
-            try (ContentProvider provider = serviceManager.getActivityManager().createSettingsProvider()) {
+            try (ContentProvider provider = ServiceManager.getActivityManager().createSettingsProvider()) {
                 String oldValue = provider.getValue(table, key);
                 if (!value.equals(oldValue)) {
                     provider.putValue(table, key, value);

server/src/main/java/com/genymobile/scrcpy/Streamer.java

@@ -0,0 +1,121 @@
+package com.genymobile.scrcpy;
+
+import android.media.MediaCodec;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+public final class Streamer {
+
+    private static final long PACKET_FLAG_CONFIG = 1L << 63;
+    private static final long PACKET_FLAG_KEY_FRAME = 1L << 62;
+
+    private static final long AOPUSHDR = 0x5244485355504F41L; // "AOPUSHDR" in ASCII (little-endian)
+
+    private final FileDescriptor fd;
+    private final Codec codec;
+    private final boolean sendCodecId;
+    private final boolean sendFrameMeta;
+
+    private final ByteBuffer headerBuffer = ByteBuffer.allocate(12);
+
+    public Streamer(FileDescriptor fd, Codec codec, boolean sendCodecId, boolean sendFrameMeta) {
+        this.fd = fd;
+        this.codec = codec;
+        this.sendCodecId = sendCodecId;
+        this.sendFrameMeta = sendFrameMeta;
+    }
+
+    public Codec getCodec() {
+        return codec;
+    }
+
+    public void writeHeader() throws IOException {
+        if (sendCodecId) {
+            ByteBuffer buffer = ByteBuffer.allocate(4);
+            buffer.putInt(codec.getId());
+            buffer.flip();
+            IO.writeFully(fd, buffer);
+        }
+    }
+
+    public void writeDisableStream() throws IOException {
+        // Writing 0 (32-bit) as codec-id means that the device disables the stream (because it could not capture)
+        byte[] zeros = new byte[4];
+        IO.writeFully(fd, zeros, 0, zeros.length);
+    }
+
+    public void writePacket(ByteBuffer codecBuffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
+        if (codec == AudioCodec.OPUS) {
+            fixOpusConfigPacket(codecBuffer, bufferInfo);
+        }
+
+        if (sendFrameMeta) {
+            writeFrameMeta(fd, bufferInfo, codecBuffer.remaining());
+        }
+
+        IO.writeFully(fd, codecBuffer);
+    }
+
+    private void writeFrameMeta(FileDescriptor fd, MediaCodec.BufferInfo bufferInfo, int packetSize) throws IOException {
+        headerBuffer.clear();
+
+        long ptsAndFlags;
+        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
+            ptsAndFlags = PACKET_FLAG_CONFIG; // non-media data packet
+        } else {
+            ptsAndFlags = bufferInfo.presentationTimeUs;
+            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_KEY_FRAME) != 0) {
+                ptsAndFlags |= PACKET_FLAG_KEY_FRAME;
+            }
+        }
+
+        headerBuffer.putLong(ptsAndFlags);
+        headerBuffer.putInt(packetSize);
+        headerBuffer.flip();
+        IO.writeFully(fd, headerBuffer);
+    }
+
+    private static void fixOpusConfigPacket(ByteBuffer buffer, MediaCodec.BufferInfo bufferInfo) throws IOException {
+        // Here is an example of the config packet received for an OPUS stream:
+        //
+        // 00000000  41 4f 50 55 53 48 44 52  13 00 00 00 00 00 00 00  |AOPUSHDR........|
+        // -------------- BELOW IS THE PART WE MUST PUT AS EXTRADATA  -------------------
+        // 00000010  4f 70 75 73 48 65 61 64  01 01 38 01 80 bb 00 00  |OpusHead..8.....|
+        // 00000020  00 00 00                                          |...             |
+        // ------------------------------------------------------------------------------
+        // 00000020           41 4f 50 55 53  44 4c 59 08 00 00 00 00  |   AOPUSDLY.....|
+        // 00000030  00 00 00 a0 2e 63 00 00  00 00 00 41 4f 50 55 53  |.....c.....AOPUS|
+        // 00000040  50 52 4c 08 00 00 00 00  00 00 00 00 b4 c4 04 00  |PRL.............|
+        // 00000050  00 00 00                                          |...|
+        //
+        // Each "section" is prefixed by a 64-bit ID and a 64-bit length.
+
+        boolean isConfig = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0;
+        if (!isConfig) {
+            return;
+        }
+
+        while (buffer.remaining() >= 16) {
+            long id = buffer.getLong();
+            long sizeLong = buffer.getLong();
+            if (sizeLong < 0 || sizeLong >= 0x7FFFFFFF) {
+                throw new IOException("Invalid block size in OPUS header: " + sizeLong);
+            }
+            int size = (int) sizeLong;
+            if (id == AOPUSHDR) {
+                if (buffer.remaining() < size) {
+                    throw new IOException("Not enough data in OPUS header (invalid size: " + size + ")");
+                }
+                // Set the buffer to point to the OPUS header slice
+                buffer.limit(buffer.position() + size);
+                return;
+            }
+
+            buffer.position(buffer.position() + size);
+        }
+
+        throw new IOException("OPUS header not found");
+    }
+}

server/src/main/java/com/genymobile/scrcpy/VideoCodec.java

@@ -0,0 +1,48 @@
+package com.genymobile.scrcpy;
+
+import android.media.MediaFormat;
+
+public enum VideoCodec implements Codec {
+    H264(0x68_32_36_34, "h264", MediaFormat.MIMETYPE_VIDEO_AVC),
+    H265(0x68_32_36_35, "h265", MediaFormat.MIMETYPE_VIDEO_HEVC),
+    AV1(0x00_61_76_31, "av1", MediaFormat.MIMETYPE_VIDEO_AV1);
+
+    private final int id; // 4-byte ASCII representation of the name
+    private final String name;
+    private final String mimeType;
+
+    VideoCodec(int id, String name, String mimeType) {
+        this.id = id;
+        this.name = name;
+        this.mimeType = mimeType;
+    }
+
+    @Override
+    public Type getType() {
+        return Type.VIDEO;
+    }
+
+    @Override
+    public int getId() {
+        return id;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String getMimeType() {
+        return mimeType;
+    }
+
+    public static VideoCodec findByName(String name) {
+        for (VideoCodec codec : values()) {
+            if (codec.name.equals(name)) {
+                return codec;
+            }
+        }
+        return null;
+    }
+}

server/src/main/java/com/genymobile/scrcpy/Workarounds.java

@@ -2,14 +2,12 @@ package com.genymobile.scrcpy;
 
 import android.annotation.SuppressLint;
 import android.app.Application;
-import android.app.Instrumentation;
-import android.content.Context;
+import android.content.ContextWrapper;
 import android.content.pm.ApplicationInfo;
 import android.os.Looper;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
-import java.lang.reflect.Method;
 
 public final class Workarounds {
     private Workarounds() {
@@ -50,7 +48,7 @@ public final class Workarounds {
             Object appBindData = appBindDataConstructor.newInstance();
 
             ApplicationInfo applicationInfo = new ApplicationInfo();
-            applicationInfo.packageName = "com.genymobile.scrcpy";
+            applicationInfo.packageName = FakeContext.PACKAGE_NAME;
 
             // appBindData.appInfo = applicationInfo;
             Field appInfoField = appBindDataClass.getDeclaredField("appInfo");
@@ -62,11 +60,10 @@ public final class Workarounds {
             mBoundApplicationField.setAccessible(true);
             mBoundApplicationField.set(activityThread, appBindData);
 
-            // Context ctx = activityThread.getSystemContext();
-            Method getSystemContextMethod = activityThreadClass.getDeclaredMethod("getSystemContext");
-            Context ctx = (Context) getSystemContextMethod.invoke(activityThread);
-
-            Application app = Instrumentation.newApplication(Application.class, ctx);
+            Application app = Application.class.newInstance();
+            Field baseField = ContextWrapper.class.getDeclaredField("mBase");
+            baseField.setAccessible(true);
+            baseField.set(app, FakeContext.get());
 
             // activityThread.mInitialApplication = app;
             Field mInitialApplicationField = activityThreadClass.getDeclaredField("mInitialApplication");

server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java

@@ -5,6 +5,7 @@ import com.genymobile.scrcpy.Ln;
 import android.os.Binder;
 import android.os.IBinder;
 import android.os.IInterface;
+import android.os.Process;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
@@ -48,10 +49,10 @@ public class ActivityManager {
             Object[] args;
             if (getContentProviderExternalMethodNewVersion) {
                 // new version
-                args = new Object[]{name, ServiceManager.USER_ID, token, null};
+                args = new Object[]{name, Process.ROOT_UID, token, null};
             } else {
                 // old version
-                args = new Object[]{name, ServiceManager.USER_ID, token};
+                args = new Object[]{name, Process.ROOT_UID, token};
             }
             // ContentProviderHolder providerHolder = getContentProviderExternal(...);
             Object providerHolder = method.invoke(manager, args);