Apply workaround on "honor" devices

This makes audio work on those devices. Fixes #4015 <https://github.com/Genymobile/scrcpy/issues/4015>
Use system context as base context
2023-06-17 00:25:10 +02:00 · 2023-06-17 00:25:10 +02:00 · 2023-06-17 00:25:10 +02:00
55 changed files with 569 additions and 1174 deletions
--- a/FAQ.md
+++ b/FAQ.md
@ -159,8 +159,6 @@ In developer options, enable:
 > **USB debugging (Security settings)**  
 > _Allow granting permissions and simulating input via USB debugging_

-Rebooting the device is necessary once this option is set.
-
 [simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323


@ -170,12 +168,12 @@ The default text injection method is [limited to ASCII characters][text-input].
 A trick allows to also inject some [accented characters][accented-characters],
 but that's all. See [#37].

-It is also possible to simulate a [physical keyboard][hid] (HID).
+Since scrcpy v1.20, it is possible to simulate a [physical keyboard][hid] (HID).

 [text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
 [accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
 [#37]: https://github.com/Genymobile/scrcpy/issues/37
-[hid]: doc/hid-otg.md
+[hid]: README.md#physical-keyboard-simulation-hid


 ## Client issues
@ -231,4 +229,4 @@ Translations of this FAQ in other languages are available in the [wiki].

 [wiki]: https://github.com/Genymobile/scrcpy/wiki

-Only this FAQ file is guaranteed to be up-to-date.
+Only this README file is guaranteed to be up-to-date.
--- a/README.md
+++ b/README.md
@ -1,11 +1,11 @@
-# scrcpy (v2.1.1)
+# scrcpy (v2.0)

 <img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />

 _pronounced "**scr**een **c**o**py**"_

 This application mirrors Android devices (video and audio) connected via
-USB or [over TCP/IP](doc/connection.md#tcpip-wireless), and allows to control the
+USB or [over TCP/IP](doc/device.md#tcpip-wireless), and allows to control the
 device with the keyboard and the mouse of the computer. It does not require any
 _root_ access. It works on _Linux_, _Windows_ and _macOS_.

@ -30,7 +30,7 @@ Its features include:
 - mirroring with [Android device screen off](doc/device.md#turn-screen-off)
 - [copy-paste](doc/control.md#copy-paste) in both directions
 - [configurable quality](doc/video.md)
- - Android device screen [as a webcam (V4L2)](doc/v4l2.md) (Linux-only)
+ - Android device [as a webcam (V4L2)](doc/v4l2.md) (Linux-only)
 - [physical keyboard/mouse simulation (HID)](doc/hid-otg.md)
 - [OTG mode](doc/hid-otg.md#otg)
 - and more…
@ -39,7 +39,7 @@ Its features include:

 The Android device requires at least API 21 (Android 5.0).

-[Audio forwarding](doc/audio.md) is supported for API >= 30 (Android 11+).
+[Audio forwarding](doc/audio.md) is supported from API 30 (Android 11).

 Make sure you [enabled USB debugging][enable-adb] on your device(s).

@ -47,14 +47,10 @@ Make sure you [enabled USB debugging][enable-adb] on your device(s).

 On some devices, you also need to enable [an additional option][control] `USB
 debugging (Security Settings)` (this is an item different from `USB debugging`)
-to control it using a keyboard and mouse. Rebooting the device is necessary once
-this option is set.
+to control it using a keyboard and mouse.

 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323

-Note that USB debugging is not required to run scrcpy in [OTG
-mode](doc/hid-otg.md#otg).
-

 ## Get the app

@ -68,11 +64,10 @@ mode](doc/hid-otg.md#otg).
 The application provides a lot of features and configuration options. They are
 documented in the following pages:

- - [Connection](doc/connection.md)
+ - [Device](doc/device.md)
 - [Video](doc/video.md)
 - [Audio](doc/audio.md)
 - [Control](doc/control.md)
- - [Device](doc/device.md)
 - [Window](doc/window.md)
 - [Recording](doc/recording.md)
 - [Tunnels](doc/tunnels.md)
@ -118,10 +113,7 @@ For general questions or discussions, you can also use:
 I'm [@rom1v](https://github.com/rom1v), the author and maintainer of _scrcpy_.

 If you appreciate this application, you can [support my open source
-work][donate]:
- - [GitHub Sponsors](https://github.com/sponsors/rom1v)
- - [Liberapay](https://liberapay.com/rom1v/)
- - [PayPal](https://paypal.me/rom2v)
+work][donate].

 [donate]: https://blog.rom1v.com/about/#support-my-open-source-work

--- a/app/data/bash-completion/scrcpy
+++ b/app/data/bash-completion/scrcpy
@ -23,7 +23,6 @@ _scrcpy() {
        --kill-adb-on-close
        -K --hid-keyboard
        --legacy-paste
-        --list-cameras
        --list-displays
        --list-encoders
        --lock-video-orientation
--- a/app/data/zsh-completion/_scrcpy
+++ b/app/data/zsh-completion/_scrcpy
@ -30,7 +30,6 @@ arguments=(
    '--kill-adb-on-close[Kill adb when scrcpy terminates]'
    {-K,--hid-keyboard}'[Simulate a physical keyboard by using HID over AOAv2]'
    '--legacy-paste[Inject computer clipboard text as a sequence of key events on Ctrl+v]'
-    '--list-cameras[List cameras available on the device]'
    '--list-displays[List displays available on the device]'
    '--list-encoders[List video and audio encoders available on the device]'
    '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 1 2 3)'
--- a/app/prebuilt-deps/prepare-adb.sh
+++ b/app/prebuilt-deps/prepare-adb.sh
@ -6,10 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"

-DEP_DIR=platform-tools-34.0.3
+DEP_DIR=platform-tools-34.0.1

-FILENAME=platform-tools_r34.0.3-windows.zip
-SHA256SUM=fce992e93eb786fc9f47df93d83a7b912c46742d45c39d712c02e06d05b72e2b
+FILENAME=platform-tools_r34.0.1-windows.zip
+SHA256SUM=5dd9c2be744c224fa3a7cbe30ba02d2cb378c763bd0f797a7e47e9f3156a5daa

 if [[ -d "$DEP_DIR" ]]
 then
--- a/app/prebuilt-deps/prepare-sdl.sh
+++ b/app/prebuilt-deps/prepare-sdl.sh
@ -6,10 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"

-DEP_DIR=SDL2-2.28.0
+DEP_DIR=SDL2-2.26.4

-FILENAME=SDL2-devel-2.28.0-mingw.tar.gz
-SHA256SUM=b91ce59eeacd4a9db403f976fd2337d9360b21ada374124417d716065c380e20
+FILENAME=SDL2-devel-2.26.4-mingw.tar.gz
+SHA256SUM=fe899c8642caac2f180b1ee6f786857ddcaa0adc1fa82474312b09dd47d74712

 if [[ -d "$DEP_DIR" ]]
 then
--- a/app/scrcpy-windows.rc
+++ b/app/scrcpy-windows.rc
@ -13,7 +13,7 @@ BEGIN
      VALUE "LegalCopyright", "Romain Vimont, Genymobile"
      VALUE "OriginalFilename", "scrcpy.exe"
      VALUE "ProductName", "scrcpy"
-      VALUE "ProductVersion", "2.1.1"
+      VALUE "ProductVersion", "2.0"
    END
  END
  BLOCK "VarFileInfo"
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -21,7 +21,7 @@ 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).
+Encode the audio at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).

 Default is 128K (128000).

@ -71,7 +71,7 @@ Default is 5.

 .TP
 .BI "\-b, \-\-video\-bit\-rate " value
-Encode the video at the given bit rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).
+Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are supported: '\fBK\fR' (x1000) and '\fBM\fR' (x1000000).

 Default is 8M (8000000).

@ -155,9 +155,6 @@ 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.

-.B \-\-list\-cameras
-List cameras available on the device.
-
 .TP
 .B \-\-list\-encoders
 List video and audio encoders available on the device.
--- a/app/src/adb/adb.c
+++ b/app/src/adb/adb.c
@ -628,8 +628,8 @@ sc_adb_select_device(struct sc_intr *intr,
        return false;
    }

-    LOGI("ADB device found:");
-    sc_adb_devices_log(SC_LOG_LEVEL_INFO, vec.data, vec.size);
+    LOGD("ADB device found:");
+    sc_adb_devices_log(SC_LOG_LEVEL_DEBUG, vec.data, vec.size);

    // Move devics into out_device (do not destroy device)
    sc_adb_device_move(out_device, device);
--- a/app/src/cli.c
+++ b/app/src/cli.c
@ -79,7 +79,6 @@ enum {
    OPT_AUDIO_SOURCE,
    OPT_KILL_ADB_ON_CLOSE,
    OPT_TIME_LIMIT,
-    OPT_LIST_CAMERAS,
 };

 struct sc_option {
@ -125,7 +124,7 @@ static const struct sc_option options[] = {
        .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. "
+        .text = "Encode the audio at the given bit-rate, expressed in bits/s. "
                "Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
                "Default is 128K (128000).",
    },
@ -186,7 +185,7 @@ static const struct sc_option options[] = {
        .shortopt = 'b',
        .longopt = "video-bit-rate",
        .argdesc = "value",
-        .text = "Encode the video at the given 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 8M (8000000).",
    },
@ -313,11 +312,6 @@ static const struct sc_option options[] = {
                "This is a workaround for some devices not behaving as "
                "expected when setting the device clipboard programmatically.",
    },
-    {
-        .longopt_id = OPT_LIST_CAMERAS,
-        .longopt = "list-cameras",
-        .text = "List device cameras.",
-    },
    {
        .longopt_id = OPT_LIST_DISPLAYS,
        .longopt = "list-displays",
@ -1950,9 +1944,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                     "platform).");
                return false;
 #endif
-            case OPT_LIST_CAMERAS:
-                opts->list_cameras = true;
-                break;
            case OPT_LIST_ENCODERS:
                opts->list_encoders = true;
                break;
@ -2031,6 +2022,12 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
        opts->audio_playback = false;
    }

+    if (!opts->video_playback && !otg) {
+        // If video playback is disabled and OTG are disabled, then there is
+        // no way to control the device.
+        opts->control = false;
+    }
+
    if (opts->video && !opts->video_playback && !opts->record_filename
            && !v4l2) {
        LOGI("No video playback, no recording, no V4L2 sink: video disabled");
--- a/app/src/display.c
+++ b/app/src/display.c
@ -53,7 +53,7 @@ sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps) {
                display->mipmaps = true;
            } else {
                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required)");
+                     "(OpenGL 3.0+ or ES 2.0+ required");
            }
        } else {
            LOGI("Trilinear filtering disabled");
--- a/app/src/options.c
+++ b/app/src/options.c
@ -81,6 +81,5 @@ const struct scrcpy_options scrcpy_options_default = {
    .require_audio = false,
    .list_encoders = false,
    .list_displays = false,
-    .list_cameras = false,
    .kill_adb_on_close = false,
 };
--- a/app/src/options.h
+++ b/app/src/options.h
@ -181,7 +181,6 @@ struct scrcpy_options {
    bool require_audio;
    bool list_encoders;
    bool list_displays;
-    bool list_cameras;
    bool kill_adb_on_close;
 };

--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -252,9 +252,7 @@ sc_audio_demuxer_on_ended(struct sc_demuxer *demuxer,

    // Contrary to the video demuxer, keep mirroring if only the audio fails
    // (unless --require-audio is set).
-    if (status == SC_DEMUXER_STATUS_EOS) {
-        PUSH_EVENT(SC_EVENT_DEVICE_DISCONNECTED);
-    } else if (status == SC_DEMUXER_STATUS_ERROR
+    if (status == SC_DEMUXER_STATUS_ERROR
            || (status == SC_DEMUXER_STATUS_DISABLED
                && options->require_audio)) {
        PUSH_EVENT(SC_EVENT_DEMUXER_ERROR);
@ -381,7 +379,6 @@ scrcpy(struct scrcpy_options *options) {
        .power_on = options->power_on,
        .list_encoders = options->list_encoders,
        .list_displays = options->list_displays,
-        .list_cameras = options->list_cameras,
        .kill_adb_on_close = options->kill_adb_on_close,
    };

@ -400,8 +397,7 @@ scrcpy(struct scrcpy_options *options) {

    server_started = true;

-    if (options->list_encoders || options->list_displays
-            || options->list_cameras) {
+    if (options->list_encoders || options->list_displays) {
        bool ok = await_for_server(NULL);
        ret = ok ? SCRCPY_EXIT_SUCCESS : SCRCPY_EXIT_FAILURE;
        goto end;
@ -452,7 +448,9 @@ scrcpy(struct scrcpy_options *options) {

    struct sc_file_pusher *fp = NULL;

-    if (options->video_playback && options->control) {
+    // control implies video playback
+    assert(!options->control || options->video_playback);
+    if (options->control) {
        if (!sc_file_pusher_init(&s->file_pusher, serial,
                                 options->push_target)) {
            goto end;
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -488,7 +488,6 @@ sc_screen_show_initial_window(struct sc_screen *screen) {
    }

    SDL_ShowWindow(screen->window);
-    sc_screen_update_content_rect(screen);
 }

 void
@ -849,8 +848,6 @@ sc_screen_convert_drawable_to_frame_coords(struct sc_screen *screen,
    int32_t w = screen->content_size.width;
    int32_t h = screen->content_size.height;

-    // screen->rect must be initialized to avoid a division by zero
-    assert(screen->rect.w && screen->rect.h);

    x = (int64_t) (x - screen->rect.x) * w / screen->rect.w;
    y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;
--- a/app/src/server.c
+++ b/app/src/server.c
@ -316,9 +316,6 @@ execute_server(struct sc_server *server,
    if (params->list_displays) {
        ADD_PARAM("list_displays=true");
    }
-    if (params->list_cameras) {
-        ADD_PARAM("list_cameras=true");
-    }

 #undef ADD_PARAM

@ -536,8 +533,8 @@ sc_server_connect_to(struct sc_server *server, struct sc_server_info *info) {
                if (audio_socket == SC_SOCKET_NONE) {
                    goto fail;
                }
-                bool ok = net_connect_intr(&server->intr, audio_socket,
-                                           tunnel_host, tunnel_port);
+                bool ok = net_connect_intr(&server->intr, audio_socket, tunnel_host,
+                                           tunnel_port);
                if (!ok) {
                    goto fail;
                }
@ -898,8 +895,7 @@ run_server(void *data) {

    // If --list-* is passed, then the server just prints the requested data
    // then exits.
-    if (params->list_encoders || params->list_displays
-            || params->list_cameras) {
+    if (params->list_encoders || params->list_displays) {
        sc_pid pid = execute_server(server, params);
        if (pid == SC_PROCESS_NONE) {
            goto error_connection_failed;
--- a/app/src/server.h
+++ b/app/src/server.h
@ -58,7 +58,6 @@ struct sc_server_params {
    bool power_on;
    bool list_encoders;
    bool list_displays;
-    bool list_cameras;
    bool kill_adb_on_close;
 };

--- a/app/src/usb/scrcpy_otg.c
+++ b/app/src/usb/scrcpy_otg.c
@ -105,6 +105,10 @@ scrcpy_otg(struct scrcpy_options *options) {

    usb_device_initialized = true;

+    LOGI("USB device: %s (%04x:%04x) %s %s", usb_device.serial,
+         (unsigned) usb_device.vid, (unsigned) usb_device.pid,
+         usb_device.manufacturer, usb_device.product);
+
    ok = sc_usb_connect(&s->usb, usb_device.device, &cbs, NULL);
    if (!ok) {
        goto end;
--- a/app/src/usb/usb.c
+++ b/app/src/usb/usb.c
@ -213,8 +213,8 @@ sc_usb_select_device(struct sc_usb *usb, const char *serial,
    assert(sel_count == 1); // sel_idx is valid only if sel_count == 1
    struct sc_usb_device *device = &vec.data[sel_idx];

-    LOGI("USB device found:");
-    sc_usb_devices_log(SC_LOG_LEVEL_INFO, vec.data, vec.size);
+    LOGD("USB device found:");
+    sc_usb_devices_log(SC_LOG_LEVEL_DEBUG, vec.data, vec.size);

    // Move device into out_device (do not destroy device)
    sc_usb_device_move(out_device, device);
--- a/cross_win32.txt
+++ b/cross_win32.txt
@ -17,5 +17,5 @@ endian = 'little'

 [properties]
 prebuilt_ffmpeg = 'ffmpeg-6.0-scrcpy-4/win32'
-prebuilt_sdl2 = 'SDL2-2.28.0/i686-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.26.4/i686-w64-mingw32'
 prebuilt_libusb = 'libusb-1.0.26/libusb-MinGW-Win32'
--- a/cross_win64.txt
+++ b/cross_win64.txt
@ -17,5 +17,5 @@ endian = 'little'

 [properties]
 prebuilt_ffmpeg = 'ffmpeg-6.0-scrcpy-4/win64'
-prebuilt_sdl2 = 'SDL2-2.28.0/x86_64-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.26.4/x86_64-w64-mingw32'
 prebuilt_libusb = 'libusb-1.0.26/libusb-MinGW-x64'
--- a/doc/audio.md
+++ b/doc/audio.md
@ -71,20 +71,6 @@ scrcpy --audio-codec=aac
 scrcpy --audio-codec=raw
 ```

-In particular, if you get the following error:
-
-> Failed to initialize audio/opus, error 0xfffffffe
-
-then your device has no Opus encoder: try `scrcpy --audio-codec=aac`.
-
-For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
-check `--audio-codec-options` in the manpage or in `scrcpy --help`.
-
-[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
-
-
-## Encoder
-
 Several encoders may be available on the device. They can be listed by:

 ```bash
@ -93,14 +79,19 @@ scrcpy --list-encoders

 To select a specific encoder:

-```bash
+```
 scrcpy --audio-codec=opus --audio-encoder='c2.android.opus.encoder'
 ```

+For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
+check `--audio-codec-options` in the manpage or in `scrcpy --help`.
+
+[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
+

 ## Bit rate

-The default audio bit rate is 128Kbps. To change it:
+The default video bit-rate is 128Kbps. To change it:

 ```bash
 scrcpy --audio-bit-rate=64K
--- a/doc/build.md
+++ b/doc/build.md
@ -77,7 +77,7 @@ pip3 install meson
 sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm

 # client build dependencies
-sudo dnf install SDL2-devel ffms2-devel libusb1-devel meson gcc make
+sudo dnf install SDL2-devel ffms2-devel libusb-devel meson gcc make

 # server build dependencies
 sudo dnf install java-devel
@ -233,10 +233,10 @@ install` must be run as root)._

 #### Option 2: Use prebuilt server

- - [`scrcpy-server-v2.1.1`][direct-scrcpy-server]  
-   <sub>SHA-256: `9558db6c56743a1dc03b38f59801fb40e91cc891f8fc0c89e5b0b067761f148e`</sub>
+ - [`scrcpy-server-v2.0`][direct-scrcpy-server]  
+   <sub>SHA-256: `9e241615f578cd690bb43311000debdecf6a9c50a7082b001952f18f6f21ddc2`</sub>

-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v2.1.1/scrcpy-server-v2.1.1
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v2.0/scrcpy-server-v2.0

 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/doc/connection.md
+++ b/doc/connection.md
@ -1,125 +0,0 @@
-# Connection
-
-## Selection
-
-If exactly one device is connected (i.e. listed by `adb devices`), then it is
-automatically selected.
-
-However, if there are multiple devices connected, you must specify the one to
-use in one of 4 ways:
- - by its serial:
-   ```bash
-   scrcpy --serial=0123456789abcdef
-   scrcpy -s 0123456789abcdef   # short version
-
-   # the serial is the ip:port if connected over TCP/IP (same behavior as adb)
-   scrcpy --serial=192.168.1.1:5555
-   ```
- - the one connected over USB (if there is exactly one):
-   ```bash
-   scrcpy --select-usb
-   scrcpy -d   # short version
-   ```
- - the one connected over TCP/IP (if there is exactly one):
-   ```bash
-   scrcpy --select-tcpip
-   scrcpy -e   # short version
-   ```
- - a device already listening on TCP/IP (see [below](#tcpip-wireless)):
-   ```bash
-   scrcpy --tcpip=192.168.1.1:5555
-   scrcpy --tcpip=192.168.1.1        # default port is 5555
-   ```
-
-The serial may also be provided via the environment variable `ANDROID_SERIAL`
-(also used by `adb`):
-
-```bash
-# in bash
-export ANDROID_SERIAL=0123456789abcdef
-scrcpy
-```
-
-```cmd
-:: in cmd
-set ANDROID_SERIAL=0123456789abcdef
-scrcpy
-```
-
-```powershell
-# in PowerShell
-$env:ANDROID_SERIAL = '0123456789abcdef'
-scrcpy
-```
-
-
-## TCP/IP (wireless)
-
-_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
-device over TCP/IP. The device must be connected on the same network as the
-computer.
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-### Automatic
-
-An option `--tcpip` allows to configure the connection automatically. There are
-two variants.
-
-If the device (accessible at 192.168.1.1 in this example) already listens on a
-port (typically 5555) for incoming _adb_ connections, then run:
-
-```bash
-scrcpy --tcpip=192.168.1.1       # default port is 5555
-scrcpy --tcpip=192.168.1.1:5555
-```
-
-If _adb_ TCP/IP mode is disabled on the device (or if you don't know the IP
-address), connect the device over USB, then run:
-
-```bash
-scrcpy --tcpip   # without arguments
-```
-
-It will automatically find the device IP address and adb port, enable TCP/IP
-mode if necessary, then connect to the device before starting.
-
-
-### Manual
-
-Alternatively, it is possible to enable the TCP/IP connection manually using
-`adb`:
-
-1. Plug the device into a USB port on your computer.
-2. Connect the device to the same Wi-Fi network as your computer.
-3. Get your device IP address, in Settings → About phone → Status, or by
-   executing this command:
-
-    ```bash
-    adb shell ip route | awk '{print $9}'
-    ```
-
-4. Enable `adb` over TCP/IP on your device: `adb tcpip 5555`.
-5. Unplug your device.
-6. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`
-with the device IP address you found)_.
-7. Run `scrcpy` as usual.
-8. Run `adb disconnect` once you're done.
-
-Since Android 11, a [wireless debugging option][adb-wireless] allows to bypass
-having to physically connect your device directly to your computer.
-
-[adb-wireless]: https://developer.android.com/studio/command-line/adb#wireless-android11-command-line
-
-
-## Autostart
-
-A small tool (by the scrcpy author) allows to run arbitrary commands whenever a
-new Android device is connected: [AutoAdb]. It can be used to start scrcpy:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
--- a/doc/develop.md
+++ b/doc/develop.md
@ -9,52 +9,16 @@ This application is composed of two parts:
 The client is responsible to push the server to the device and start its
 execution.

-The client and the server establish communication using separate sockets for
-video, audio and controls. Any of them may be disabled (but not all), so
-there are 1, 2 or 3 socket(s).
+Once the client and the server are connected to each other, the server initially
+sends device information (name and initial screen dimensions), then starts to
+send a raw H.264 video stream of the device screen. The client decodes the video
+frames, and display them as soon as possible, without buffering, to minimize
+latency. The client is not aware of the device rotation (which is handled by the
+server), it just knows the dimensions of the video frames.

-The server initially sends the device name on the first socket (it is used for
-the scrcpy window title), then each socket is used for its own purpose. All
-reads and writes are performed from a dedicated thread for each socket, both on
-the client and on the server.
+The client captures relevant keyboard and mouse events, that it transmits to the
+server, which injects them to the device.

-If video is enabled, then the server sends a raw video stream (H.264 by default)
-of the device screen, with some additional headers for each packet. The client
-decodes the video frames, and displays them as soon as possible, without
-buffering (unless `--display-buffer=delay` is specified) to minimize latency.
-The client is not aware of the device rotation (which is handled by the server),
-it just knows the dimensions of the video frames it receives.
-
-Similarly, if audio is enabled, then the server sends a raw audio stream (OPUS
-by default) of the device audio output (or the microphone if
-`--audio-source=mic` is specified), with some additional headers for each
-packet. The client decodes the stream, attempts to keep a minimal latency by
-maintaining an average buffering. The [blog post][scrcpy2] of the scrcpy v2.0
-release gives more details about the audio feature.
-
-If control is enabled, then the client captures relevant keyboard and mouse
-events, that it transmits to the server, which injects them to the device. This
-is the only socket which is used in both direction: input events are sent from
-the client to the device, and when the device clipboard changes, the new content
-is sent from the device to the client to support seamless copy-paste.
-
-[scrcpy2]: https://blog.rom1v.com/2023/03/scrcpy-2-0-with-audio/
-
-Note that the client-server roles are expressed at the application level:
-
- - the server _serves_ video and audio streams, and handle requests from the
-   client,
- - the client _controls_ the device through the server.
-
-However, by default (when `--force-adb-forward` is not set), the roles are
-reversed at the network level:
-
- - the client opens a server socket and listen on a port before starting the
-   server,
- - the server connects to the client.
-
-This role inversion guarantees that the connection will not fail due to race
-conditions without polling.


 ## Server
@ -68,14 +32,15 @@ The server is a Java application (with a [`public static void main(String...
 args)`][main] method), compiled against the Android framework, and executed as
 `shell` on the Android device.

-[main]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Server.java#L193
+[main]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/Server.java#L123

 To run such a Java application, the classes must be [_dexed_][dex] (typically,
 to `classes.dex`). If `my.package.MainClass` is the main class, compiled to
 `classes.dex`, pushed to the device in `/data/local/tmp`, then it can be run
 with:

-    adb shell CLASSPATH=/data/local/tmp/classes.dex app_process / my.package.MainClass
+    adb shell CLASSPATH=/data/local/tmp/classes.dex \
+        app_process / my.package.MainClass

 _The path `/data/local/tmp` is a good candidate to push the server, since it's
 readable and writable by `shell`, but not world-writable, so a malicious
@ -84,7 +49,7 @@ application may not replace the server just before the client executes it._
 Instead of a raw _dex_ file, `app_process` accepts a _jar_ containing
 `classes.dex` (e.g. an [APK]). For simplicity, and to benefit from the gradle
 build system, the server is built to an (unsigned) APK (renamed to
-`scrcpy-server.jar`).
+`scrcpy-server`).

 [dex]: https://en.wikipedia.org/wiki/Dalvik_(software)
 [apk]: https://en.wikipedia.org/wiki/Android_application_package
@ -100,77 +65,42 @@ They can be called using reflection though. The communication with hidden
 components is provided by [_wrappers_ classes][wrappers] and [aidl].

 [hidden]: https://stackoverflow.com/a/31908373/1987178
-[wrappers]: https://github.com/Genymobile/scrcpy/tree/master/server/src/main/java/com/genymobile/scrcpy/wrappers
-[aidl]: https://github.com/Genymobile/scrcpy/tree/master/server/src/main/aidl
+[wrappers]: https://github.com/Genymobile/scrcpy/tree/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/wrappers
+[aidl]: https://github.com/Genymobile/scrcpy/tree/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/aidl/android/view


+### Threading

-### Execution
+The server uses 3 threads:

-The server is started by the client basically by executing the following
-commands:
+ - the **main** thread, encoding and streaming the video to the client;
+ - the **controller** thread, listening for _control messages_ (typically,
+   keyboard and mouse events) from the client;
+ - the **receiver** thread (managed by the controller), sending _device messages_
+   to the clients (currently, it is only used to send the device clipboard
+   content).

-```bash
-adb push scrcpy-server /data/local/tmp/scrcpy-server.jar
-adb forward tcp:27183 localabstract:scrcpy
-adb shell CLASSPATH=/data/local/tmp/scrcpy-server.jar app_process / com.genymobile.scrcpy.Server 2.1
-```
-
-The first argument (`2.1` in the example) is the client scrcpy version. The
-server fails if the client and the server do not have the exact same version.
-The protocol between the client and the server may change from version to
-version (see [protocol](#protocol) below), and there is no backward or forward
-compatibility (there is no point to use different client and server versions).
-This check allows to detect misconfiguration (running an older or newer server
-by mistake).
-
-It is followed by any number of arguments, in the form of `key=value` pairs.
-Their order is irrelevant. The possible keys and associated value types can be
-found in the [server][server-options] and [client][client-options] code.
-
-[server-options]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Options.java#L181
-[client-options]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/server.c#L226
-
-For example, if we execute `scrcpy -m1920 --no-audio`, then the server
-execution will look like this:
-
-```bash
-# scid is a random number to identify different clients running on the same device
-adb shell CLASSPATH=/data/local/tmp/scrcpy-server.jar app_process / com.genymobile.scrcpy.Server 2.1 scid=12345678 log_level=info audio=false max_size=1920
-```
-
-### Components
-
-When executed, its [`main()`][main] method is executed (on the "main" thread).
-It parses the arguments, establishes the connection with the client and starts
-the other "components":
- - the **video** streamer: it captures the video screen and send encoded video
-   packets on the _video_ socket (from the _video_ thread).
- - the **audio** streamer: it uses several threads to capture raw packets,
-   submits them to encoding and retrieve encoded packets, which it sends on the
-   _audio_ socket.
- - the **controller**: it receives _control messages_ (typically input events)
-   on the _control_ socket from one thread, and sends _device messages_ (e.g. to
-   transmit the device clipboard content to the client) on the same _control
-   socket_ from another thread. Thus, the _control_ socket is used in both
-   directions (contrary to the _video_ and _audio_ sockets).
+Since the video encoding is typically hardware, there would be no benefit in
+encoding and streaming in two different threads.


 ### Screen video encoding

 The encoding is managed by [`ScreenEncoder`].

-The video is encoded using the [`MediaCodec`] API. The codec encodes the content
-of a `Surface` associated to the display, and writes the encoding packets to the
-client (on the _video_ socket).
+The video is encoded using the [`MediaCodec`] API. The codec takes its input
+from a [surface] associated to the display, and writes the resulting H.264
+stream to the provided output stream (the socket connected to the client).

-[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
 [`MediaCodec`]: https://developer.android.com/reference/android/media/MediaCodec.html
+[surface]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L68-L69

-On device rotation (or folding), the encoding session is [reset] and restarted.
+On device [rotation], the codec, surface and display are reinitialized, and a
+new video stream is produced.

-New frames are produced only when changes occur on the surface. This avoids to
-send unnecessary frames, but by default there might be drawbacks:
+New frames are produced only when changes occur on the surface. This is good
+because it avoids to send unnecessary frames, but there are drawbacks:

 - it does not send any frame on start if the device screen does not change,
 - after fast motion changes, the last frame may have poor quality.
@ -178,24 +108,11 @@ send unnecessary frames, but by default there might be drawbacks:
 Both problems are [solved][repeat] by the flag
 [`KEY_REPEAT_PREVIOUS_FRAME_AFTER`][repeat-flag].

-[reset]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L179
 [rotation]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L90
-[repeat]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L246-L247
+[repeat]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L147-L148
 [repeat-flag]: https://developer.android.com/reference/android/media/MediaFormat.html#KEY_REPEAT_PREVIOUS_FRAME_AFTER


-### Audio encoding
-
-Similarly, the audio is [captured] using an [`AudioRecord`], and [encoded] using
-the [`MediaCodec`] asynchronous API.
-
-More details are available on the [blog post][scrcpy2] introducing the audio feature.
-
-[captured]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/AudioCapture.java
-[encoded]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/AudioEncoder.java
-[`AudioRecord`]: https://developer.android.com/reference/android/media/AudioRecord
-
-
 ### Input events injection

 _Control messages_ are received from the client by the [`Controller`] (run in a
@ -207,13 +124,13 @@ separate thread). There are several types of input events:
 - other commands (e.g. to switch the screen on or to copy the clipboard).

 Some of them need to inject input events to the system. To do so, they use the
-_hidden_ method [`InputManager.injectInputEvent()`] (exposed by the
+_hidden_ method [`InputManager.injectInputEvent`] (exposed by our
 [`InputManager` wrapper][inject-wrapper]).

-[`Controller`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Controller.java
+[`Controller`]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/Controller.java#L81
 [`KeyEvent`]: https://developer.android.com/reference/android/view/KeyEvent.html
 [`MotionEvent`]: https://developer.android.com/reference/android/view/MotionEvent.html
-[`InputManager.injectInputEvent()`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L34
+[`InputManager.injectInputEvent`]: https://android.googlesource.com/platform/frameworks/base/+/oreo-release/core/java/android/hardware/input/InputManager.java#857
 [inject-wrapper]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27


@ -223,222 +140,126 @@ _hidden_ method [`InputManager.injectInputEvent()`] (exposed by the
 The client relies on [SDL], which provides cross-platform API for UI, input
 events, threading, etc.

-The video and audio streams are decoded by [FFmpeg].
+The video stream is decoded by [libav] (FFmpeg).

 [SDL]: https://www.libsdl.org
-[ffmpeg]: https://ffmpeg.org/
-
+[libav]: https://www.libav.org/

 ### Initialization

-The client parses the command line arguments, then [runs one of two code
-paths][run]:
- - scrcpy in "normal" mode ([`scrcpy.c`])
- - scrcpy in [OTG mode](hid-otg.md) ([`scrcpy_otg.c`])
+On startup, in addition to _libav_ and _SDL_ initialization, the client must
+push and start the server on the device, and open two sockets (one for the video
+stream, one for control) so that they may communicate.

-[run]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/main.c#L81-L82
-[`scrcpy.c`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/scrcpy.c#L292-L293
-[`scrcpy_otg.c`]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/usb/scrcpy_otg.c#L51-L52
+Note that the client-server roles are expressed at the application level:

-In the remaining of this document, we assume that the "normal" mode is used
-(read the code for the OTG mode).
+ - the server _serves_ video stream and handle requests from the client,
+ - the client _controls_ the device through the server.

-On startup, the client:
- - opens the _video_, _audio_ and _control_ sockets;
- - pushes and starts the server on the device;
- - initializes its components (demuxers, decoders, recorder…).
+However, the roles are reversed at the network level:
+
+ - the client opens a server socket and listen on a port before starting the
+   server,
+ - the server connects to the client.
+
+This role inversion guarantees that the connection will not fail due to race
+conditions, and avoids polling.
+
+_(Note that over TCP/IP, the roles are not reversed, due to a bug in `adb
+reverse`. See commit [1038bad] and [issue #5].)_
+
+Once the server is connected, it sends the device information (name and initial
+screen dimensions). Thus, the client may init the window and renderer, before
+the first frame is available.
+
+To minimize startup time, SDL initialization is performed while listening for
+the connection from the server (see commit [90a46b4]).
+
+[1038bad]: https://github.com/Genymobile/scrcpy/commit/1038bad3850f18717a048a4d5c0f8110e54ee172
+[issue #5]: https://github.com/Genymobile/scrcpy/issues/5
+[90a46b4]: https://github.com/Genymobile/scrcpy/commit/90a46b4c45637d083e877020d85ade52a9a5fa8e


-### Video and audio streams
+### Threading

-Depending on the arguments passed to `scrcpy`, several components may be used.
-Here is an overview of the video and audio components:
+The client uses 4 threads:
+
+ - the **main** thread, executing the SDL event loop,
+ - the **stream** thread, receiving the video and used for decoding and
+   recording,
+ - the **controller** thread, sending _control messages_ to the server,
+ - the **receiver** thread (managed by the controller), receiving _device
+   messages_ from the server.
+
+In addition, another thread can be started if necessary to handle APK
+installation or file push requests (via drag&drop on the main window) or to
+print the framerate regularly in the console.
+
+
+
+### Stream
+
+The video [stream] is received from the socket (connected to the server on the
+device) in a separate thread.
+
+If a [decoder] is present (i.e. `--no-display` is not set), then it uses _libav_
+to decode the H.264 stream from the socket, and notifies the main thread when a
+new frame is available.
+
+There are two [frames][video_buffer] simultaneously in memory:
+ - the **decoding** frame, written by the decoder from the decoder thread,
+ - the **rendering** frame, rendered in a texture from the main thread.
+
+When a new decoded frame is available, the decoder _swaps_ the decoding and
+rendering frame (with proper synchronization). Thus, it immediately starts
+to decode a new frame while the main thread renders the last one.
+
+If a [recorder] is present (i.e. `--record` is enabled), then it muxes the raw
+H.264 packet to the output video file.
+
+[stream]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/stream.h
+[decoder]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/decoder.h
+[video_buffer]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/video_buffer.h
+[recorder]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/recorder.h

 ```
-                                                 V4L2 sink
-                                               /
-                                       decoder
-                                     /         \
-        VIDEO -------------> demuxer             display
-                                     \
-                                       recorder
-                                     /
-        AUDIO -------------> demuxer
-                                     \
-                                       decoder --- audio player
+                                   +----------+      +----------+
+                              ---> | decoder  | ---> |  screen  |
+             +---------+     /     +----------+      +----------+
+ socket ---> | stream  | ----
+             +---------+     \     +----------+
+                              ---> | recorder |
+                                   +----------+
 ```

-The _demuxer_ is responsible to extract video and audio packets (read some
-header, split the video stream into packets at correct boundaries, etc.).
-
-The demuxed packets may be sent to a _decoder_ (one per stream, to produce
-frames) and to a recorder (receiving both video and audio stream to record a
-single file). The packets are encoded on the device (by `MediaCodec`), but when
-recording, they are _muxed_ (asynchronously) into a container (MKV or MP4) on
-the client side.
-
-Video frames are sent to the screen/display to be rendered in the scrcpy window.
-They may also be sent to a [V4L2 sink](v4l2.md).
-
-Audio "frames" (an array of decoded samples) are sent to the audio player.
-
-
 ### Controller

-The _controller_ is responsible to send _control messages_ to the device. It
+The [controller] is responsible to send _control messages_ to the device. It
 runs in a separate thread, to avoid I/O on the main thread.

-On SDL event, received on the main thread, the _input manager_ creates
-appropriate _control messages_. It is responsible to convert SDL events to
-Android events. It then pushes the _control messages_ to a queue hold by the
-controller. On its own thread, the controller takes messages from the queue,
-that it serializes and sends to the client.
+On SDL event, received on the main thread, the [input manager][inputmanager]
+creates appropriate [_control messages_][controlmsg]. It is responsible to
+convert SDL events to Android events (using [convert]). It pushes the _control
+messages_ to a queue hold by the controller. On its own thread, the controller
+takes messages from the queue, that it serializes and sends to the client.
+
+[controller]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/controller.h
+[controlmsg]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/control_msg.h
+[inputmanager]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/input_manager.h
+[convert]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/convert.h


-## Protocol
+### UI and event loop

-The protocol between the client and the server must be considered _internal_: it
-may (and will) change at any time for any reason. Everything may change (the
-number of sockets, the order in which the sockets must be opened, the data
-format on the wire…) from version to version. A client must always be run with a
-matching server version.
+Initialization, input events and rendering are all [managed][scrcpy] in the main
+thread.

-This section documents the current protocol in scrcpy v2.1.
+Events are handled in the [event loop], which either updates the [screen] or
+delegates to the [input manager][inputmanager].

-### Connection
-
-Firstly, the client sets up an adb tunnel:
-
-```bash
-# By default, a reverse redirection: the computer listens, the device connects
-adb reverse localabstract:scrcpy_<SCID> tcp:27183
-
-# As a fallback (or if --force-adb forward is set), a forward redirection:
-# the device listens, the computer connects
-adb forward tcp:27183 localabstract:scrcpy_<SCID>
-```
-
-(`<SCID>` is a 31-bit random number, so that it does not fail when several
-scrcpy instances start "at the same time" for the same device.)
-
-Then, up to 3 sockets are opened, in that order:
- - a _video_ socket
- - an _audio_ socket
- - a _control_ socket
-
-Each one may be disabled (respectively by `--no-video`, `--no-audio` and
-`--no-control`, directly or indirectly). For example, if `--no-audio` is set,
-then the _video_ socket is opened first, then the _control_ socket.
-
-On the _first_ socket opened (whichever it is), if the tunnel is _forward_, then
-a [dummy byte] is sent from the device to the client. This allows to detect a
-connection error (the client connection does not fail as long as there is an adb
-forward redirection, even if nothing is listening on the device side).
-
-Still on this _first_ socket, the device sends some [metadata][device meta] to
-the client (currently only the device name, used as the window title, but there
-might be other fields in the future).
-
-[dummy byte]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java#L93
-[device meta]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java#L151
-
-You can read the [client][client-connection] and [server][server-connection]
-code for more details.
-
-[client-connection]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/app/src/server.c#L465-L466
-[server-connection]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java#L63
-
-Then each socket is used for its intended purpose.
-
-### Video and audio
-
-On the _video_ and _audio_ sockets, the device first sends some [codec
-metadata]:
- - On the _video_ socket, 12 bytes:
-   - the codec id (`u32`) (H264, H265 or AV1)
-   - the initial video width (`u32`)
-   - the initial video height (`u32`)
- - On the _audio_ socket, 4 bytes:
-   - the codec id (`u32`) (OPUS, AAC or RAW)
-
-[codec metadata]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Streamer.java#L33-L51
-
-Then each packet produced by `MediaCodec` is sent, prefixed by a 12-byte [frame
-header]:
- - config packet flag (`u1`)
- - key frame flag (`u1`)
- - PTS (`u62`)
- - packet size (`u32`)
-
-Here is a schema describing the frame header:
-
-```
-    [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
-     <-------------> <-----> <-----------------------------...
-           PTS        packet        raw packet
-                       size
-     <--------------------->
-           frame header
-
-The most significant bits of the PTS are used for packet flags:
-
-     byte 7   byte 6   byte 5   byte 4   byte 3   byte 2   byte 1   byte 0
-    CK...... ........ ........ ........ ........ ........ ........ ........
-    ^^<------------------------------------------------------------------->
-    ||                                PTS
-    | `- key frame
-     `-- config packet
-```
-
-[frame header]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Streamer.java#L83
-
-
-### Controls
-
-Controls messages are sent via a custom binary protocol.
-
-The only documentation for this protocol is the set of unit tests on both sides:
- - `ControlMessage` (from client to device): [serialization](https://github.com/Genymobile/scrcpy/blob/master/app/tests/test_control_msg_serialize.c) | [deserialization](https://github.com/Genymobile/scrcpy/blob/master/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java)
- - `DeviceMessage` (from device to client) [serialization](https://github.com/Genymobile/scrcpy/blob/master/server/src/test/java/com/genymobile/scrcpy/DeviceMessageWriterTest.java) | [deserialization](https://github.com/Genymobile/scrcpy/blob/master/app/tests/test_device_msg_deserialize.c)
-
-
-## Standalone server
-
-Although the server is designed to work for the scrcpy client, it can be used
-with any client which uses the same protocol.
-
-For simplicity, some [server-specific options] have been added to produce raw
-streams easily:
- - `send_device_meta=false`: disable the device metata (in practice, the device
-   name) sent on the _first_ socket
- - `send_frame_meta=false`: disable the 12-byte header for each packet
- - `send_dummy_byte`: disable the dummy byte sent on forward connections
- - `send_codec_meta`: disable the codec information (and initial device size for
-   video)
- - `raw_stream`: disable all the above
-
-[server-specific options]: https://github.com/Genymobile/scrcpy/blob/a3cdf1a6b86ea22786e1f7d09b9c202feabc6949/server/src/main/java/com/genymobile/scrcpy/Options.java#L309-L329
-
-Concretely, here is how to expose a raw H.264 stream on a TCP socket:
-
-```bash
-adb push scrcpy-server-v2.1 /data/local/tmp/scrcpy-server-manual.jar
-adb forward tcp:1234 localabstract:scrcpy
-adb shell CLASSPATH=/data/local/tmp/scrcpy-server-manual.jar \
-    app_process / com.genymobile.scrcpy.Server 2.1 \
-    tunnel_forward=true audio=false control=false cleanup=false \
-    raw_stream=true max_size=1920
-```
-
-As soon as a client connects over TCP on port 1234, the device will start
-streaming the video. For example, VLC can play the video (although you will
-experience a very high latency, more details [here][vlc-0latency]):
-
-```
-vlc -Idummy --demux=h264 --network-caching=0 tcp://localhost:1234
-```
-
-[vlc-0latency]: https://code.videolan.org/rom1v/vlc/-/merge_requests/20
+[scrcpy]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/scrcpy.c
+[event loop]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/scrcpy.c#L201
+[screen]: https://github.com/Genymobile/scrcpy/blob/ffe0417228fb78ab45b7ee4e202fc06fc8875bf3/app/src/screen.h


 ## Hack
--- a/doc/device.md
+++ b/doc/device.md
@ -1,9 +1,156 @@
 # Device

+## Selection
+
+If exactly one device is connected (i.e. listed by `adb devices`), then it is
+automatically selected.
+
+However, if there are multiple devices connected, you must specify the one to
+use in one of 4 ways:
+ - by its serial:
+   ```bash
+   scrcpy --serial=0123456789abcdef
+   scrcpy -s 0123456789abcdef   # short version
+
+   # the serial is the ip:port if connected over TCP/IP (same behavior as adb)
+   scrcpy --serial=192.168.1.1:5555
+   ```
+ - the one connected over USB (if there is exactly one):
+   ```bash
+   scrcpy --select-usb
+   scrcpy -d   # short version
+   ```
+ - the one connected over TCP/IP (if there is exactly one):
+   ```bash
+   scrcpy --select-tcpip
+   scrcpy -e   # short version
+   ```
+ - a device already listening on TCP/IP (see [below](#tcpip-wireless)):
+   ```bash
+   scrcpy --tcpip=192.168.1.1:5555
+   scrcpy --tcpip=192.168.1.1        # default port is 5555
+   ```
+
+The serial may also be provided via the environment variable `ANDROID_SERIAL`
+(also used by `adb`):
+
+```bash
+# in bash
+export ANDROID_SERIAL=0123456789abcdef
+scrcpy
+```
+
+```cmd
+:: in cmd
+set ANDROID_SERIAL=0123456789abcdef
+scrcpy
+```
+
+```powershell
+# in PowerShell
+$env:ANDROID_SERIAL = '0123456789abcdef'
+scrcpy
+```
+
+
+## TCP/IP (wireless)
+
+_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
+device over TCP/IP. The device must be connected on the same network as the
+computer.
+
+[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
+
+
+### Automatic
+
+An option `--tcpip` allows to configure the connection automatically. There are
+two variants.
+
+If the device (accessible at 192.168.1.1 in this example) already listens on a
+port (typically 5555) for incoming _adb_ connections, then run:
+
+```bash
+scrcpy --tcpip=192.168.1.1       # default port is 5555
+scrcpy --tcpip=192.168.1.1:5555
+```
+
+If _adb_ TCP/IP mode is disabled on the device (or if you don't know the IP
+address), connect the device over USB, then run:
+
+```bash
+scrcpy --tcpip   # without arguments
+```
+
+It will automatically find the device IP address and adb port, enable TCP/IP
+mode if necessary, then connect to the device before starting.
+
+
+### Manual
+
+Alternatively, it is possible to enable the TCP/IP connection manually using
+`adb`:
+
+1. Plug the device into a USB port on your computer.
+2. Connect the device to the same Wi-Fi network as your computer.
+3. Get your device IP address, in Settings → About phone → Status, or by
+   executing this command:
+
+    ```bash
+    adb shell ip route | awk '{print $9}'
+    ```
+
+4. Enable `adb` over TCP/IP on your device: `adb tcpip 5555`.
+5. Unplug your device.
+6. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`
+with the device IP address you found)_.
+7. Run `scrcpy` as usual.
+8. Run `adb disconnect` once you're done.
+
+Since Android 11, a [wireless debugging option][adb-wireless] allows to bypass
+having to physically connect your device directly to your computer.
+
+[adb-wireless]: https://developer.android.com/studio/command-line/adb#wireless-android11-command-line
+
+
+## Autostart
+
+A small tool (by the scrcpy author) allows to run arbitrary commands whenever a
+new Android device is connected: [AutoAdb]. It can be used to start scrcpy:
+
+```bash
+autoadb scrcpy -s '{}'
+```
+
+[AutoAdb]: https://github.com/rom1v/autoadb
+
+
+## Display
+
+If several displays are available on the Android device, it is possible to
+select the display to mirror:
+
+```bash
+scrcpy --display=1
+```
+
+The list of display ids can be retrieved by:
+
+```bash
+scrcpy --list-displays
+```
+
+A secondary display may only be controlled if the device runs at least Android
+10 (otherwise it is mirrored as read-only).
+
+
+## Actions
+
 Some command line arguments perform actions on the device itself while scrcpy is
 running.

-## Stay awake
+
+### Stay awake

 To prevent the device from sleeping after a delay **when the device is plugged
 in**:
@ -19,7 +166,7 @@ If the device is not plugged in (i.e. only connected over TCP/IP),
 `--stay-awake` has no effect (this is the Android behavior).


-## Turn screen off
+### Turn screen off

 It is possible to turn the device screen off while mirroring on start with a
 command-line option:
@ -47,7 +194,7 @@ scrcpy -Sw   # short version
 ```


-## Show touches
+### Show touches

 For presentations, it may be useful to show physical touches (on the physical
 device). Android exposes this feature in _Developers options_.
@ -63,7 +210,7 @@ scrcpy -t   # short version
 Note that it only shows _physical_ touches (by a finger on the device).


-## Power off on close
+### Power off on close

 To turn the device screen off when closing _scrcpy_:

@ -71,10 +218,11 @@ To turn the device screen off when closing _scrcpy_:
 scrcpy --power-off-on-close
 ```

-## Power on on start
+### Power on on start

 By default, on start, the device is powered on. To prevent this behavior:

 ```bash
 scrcpy --no-power-on
 ```
+
--- a/doc/hid-otg.md
+++ b/doc/hid-otg.md
@ -106,7 +106,3 @@ scrcpy --otg                             # keyboard and mouse

 Like `--hid-keyboard` and `--hid-mouse`, it only works if the device is
 connected over USB.
-
-## HID/OTG issues on Windows
-
-See [FAQ](/FAQ.md#hidotg-issues-on-windows).
--- a/doc/linux.md
+++ b/doc/linux.md
@ -9,10 +9,12 @@ Scrcpy is packaged in several distributions and package managers:
 - Debian/Ubuntu: `apt install scrcpy`
 - Arch Linux: `pacman -S scrcpy`
 - Fedora: `dnf copr enable zeno/scrcpy && dnf install scrcpy`
- - Gentoo: `emerge scrcpy`
+ - Gentoo: [ebuild][ebuild-link] file
 - Snap: `snap install scrcpy`
 - … (see [repology](https://repology.org/project/scrcpy/versions))

+[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
+
 ### Latest version

 However, the packaged version is not always the latest release. To install the
--- a/doc/shortcuts.md
+++ b/doc/shortcuts.md
@ -29,7 +29,7 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
 | Resize window to 1:1 (pixel-perfect)        | <kbd>MOD</kbd>+<kbd>g</kbd>
 | Resize window to remove black borders       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Double-left-click¹_
 | Click on `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Middle-click_
- | Click on `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| <kbd>MOD</kbd>+<kbd>Backspace</kbd> \| _Right-click²_
+ | Click on `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Right-click²_
 | Click on `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4th-click³_
 | Click on `MENU` (unlock screen)⁴            | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Click on `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(up)_
--- a/doc/video.md
+++ b/doc/video.md
@ -21,7 +21,7 @@ If encoding fails, scrcpy automatically tries again with a lower definition

 ## Bit rate

-The default video bit rate is 8 Mbps. To change it:
+The default video bit-rate is 8 Mbps. To change it:

 ```bash
 scrcpy --video-bit-rate=2M
@ -66,14 +66,6 @@ scrcpy --video-codec=av1
 H265 may provide better quality, but H264 should provide lower latency.
 AV1 encoders are not common on current Android devices.

-For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
-check `--video-codec-options` in the manpage or in `scrcpy --help`.
-
-[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
-
-
-## Encoder
-
 Several encoders may be available on the device. They can be listed by:

 ```bash
@ -87,6 +79,11 @@ try another one:
 scrcpy --video-codec=h264 --video-encoder='OMX.qcom.video.encoder.avc'
 ```

+For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
+check `--video-codec-options` in the manpage or in `scrcpy --help`.
+
+[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
+

 ## Rotation

@ -137,25 +134,6 @@ phone, landscape for a tablet).
 If `--max-size` is also specified, resizing is applied after cropping.


-## Display
-
-If several displays are available on the Android device, it is possible to
-select the display to mirror:
-
-```bash
-scrcpy --display=1
-```
-
-The list of display ids can be retrieved by:
-
-```bash
-scrcpy --list-displays
-```
-
-A secondary display may only be controlled if the device runs at least Android
-10 (otherwise it is mirrored as read-only).
-
-
 ## Buffering

 By default, there is no video buffering, to get the lowest possible latency.
--- a/doc/windows.md
+++ b/doc/windows.md
@ -4,24 +4,18 @@

 Download the [latest release]:

- - [`scrcpy-win64-v2.1.1.zip`][direct-win64] (64-bit)  
-   <sub>SHA-256: `f77281e1bce2f9934617699c581f063d5b327f012eff602ee98fb2ef550c25c2`</sub>
- - [`scrcpy-win32-v2.1.1.zip`][direct-win32] (32-bit)  
-   <sub>SHA-256: `ef7ae7fbe9449f2643febdc2244fb186d1a746a3c736394150cfd14f06d3c943`</sub>
+ - [`scrcpy-win64-v2.0.zip`][direct-win64] (64-bit)  
+   <sub>SHA-256: `ae4c8d37a496b43f8974ba8f07f708e22a9570ba0cddc3dc3a36edbccd4d2a20`</sub>
+ - [`scrcpy-win32-v2.0.zip`][direct-win32] (32-bit)  
+   <sub>SHA-256: `15d98c02cb0e0bbd84f8b5d54991e0f6925569b1286a86a40743944fcb1c2d8c`</sub>

 [latest release]: https://github.com/Genymobile/scrcpy/releases/latest
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v2.1.1/scrcpy-win64-v2.1.1.zip
-[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v2.1.1/scrcpy-win32-v2.1.1.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v2.0/scrcpy-win64-v2.0.zip
+[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v2.0/scrcpy-win32-v2.0.zip

 and extract it.

-Alternatively, you could install it from packages manager, like [Winget]:
-
-```bash
-winget install scrcpy
-```
-
-or [Chocolatey]:
+Alternatively, you could install it from packages manager, like [Chocolatey]:

 ```bash
 choco install scrcpy
@ -36,7 +30,6 @@ scoop install scrcpy
 scoop install adb    # if you don't have it yet
 ```

-[Winget]: https://github.com/microsoft/winget-cli
 [Chocolatey]: https://chocolatey.org/
 [Scoop]: https://scoop.sh

--- a/install_release.sh
+++ b/install_release.sh
@ -2,8 +2,8 @@
 set -e

 BUILDDIR=build-auto
-PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v2.1.1/scrcpy-server-v2.1.1
-PREBUILT_SERVER_SHA256=9558db6c56743a1dc03b38f59801fb40e91cc891f8fc0c89e5b0b067761f148e
+PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v2.0/scrcpy-server-v2.0
+PREBUILT_SERVER_SHA256=9e241615f578cd690bb43311000debdecf6a9c50a7082b001952f18f6f21ddc2

 echo "[scrcpy] Downloading prebuilt server..."
 wget "$PREBUILT_SERVER_URL" -O scrcpy-server
--- a/meson.build
+++ b/meson.build
@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '2.1.1',
+        version: '2.0',
        meson_version: '>= 0.48',
        default_options: [
            'c_std=c11',
--- a/release.mk
+++ b/release.mk
@ -98,10 +98,10 @@ dist-win32: build-server build-win32
 	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-4/win32/bin/avcodec-60.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-4/win32/bin/avformat-60.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-4/win32/bin/swresample-4.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-34.0.3/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-34.0.3/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-34.0.3/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/SDL2-2.28.0/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-34.0.1/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-34.0.1/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-34.0.1/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/SDL2-2.26.4/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/libusb-1.0.26/libusb-MinGW-Win32/bin/msys-usb-1.0.dll "$(DIST)/$(WIN32_TARGET_DIR)/"

 dist-win64: build-server build-win64
@ -116,10 +116,10 @@ dist-win64: build-server build-win64
 	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-4/win64/bin/avcodec-60.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-4/win64/bin/avformat-60.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/ffmpeg-6.0-scrcpy-4/win64/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-34.0.3/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-34.0.3/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-34.0.3/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/SDL2-2.28.0/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-34.0.1/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-34.0.1/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-34.0.1/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/SDL2-2.26.4/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/libusb-1.0.26/libusb-MinGW-x64/bin/msys-usb-1.0.dll "$(DIST)/$(WIN64_TARGET_DIR)/"

 zip-win32: dist-win32
--- a/server/build.gradle
+++ b/server/build.gradle
@ -7,8 +7,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 33
-        versionCode 20101
-        versionName "2.1.1"
+        versionCode 20000
+        versionName "2.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
--- a/server/build_without_gradle.sh
+++ b/server/build_without_gradle.sh
@ -12,7 +12,7 @@
 set -e

 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=2.1.1
+SCRCPY_VERSION_NAME=2.0

 PLATFORM=${ANDROID_PLATFORM:-33}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-33.0.0}
@ -48,7 +48,6 @@ cd "$SERVER_DIR/src/main/aidl"
 "$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" android/view/IRotationWatcher.aidl
 "$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" \
    android/content/IOnPrimaryClipChangedListener.aidl
-"$BUILD_TOOLS_DIR/aidl" -o"$GEN_DIR" android/view/IDisplayFoldListener.aidl

 echo "Compiling java sources..."
 cd ../java
--- a/server/src/main/java/com/genymobile/scrcpy/AudioCapture.java
+++ b/server/src/main/java/com/genymobile/scrcpy/AudioCapture.java
@ -118,7 +118,7 @@ public final class AudioCapture {
        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
            startWorkaroundAndroid11();
            try {
-                tryStartRecording(5, 100);
+                tryStartRecording(3, 100);
            } finally {
                stopWorkaroundAndroid11();
            }
--- a/server/src/main/java/com/genymobile/scrcpy/CameraCapture.java
+++ b/server/src/main/java/com/genymobile/scrcpy/CameraCapture.java
@ -1,197 +0,0 @@
-package com.genymobile.scrcpy;
-
-import com.genymobile.scrcpy.wrappers.ServiceManager;
-
-import android.annotation.SuppressLint;
-import android.annotation.TargetApi;
-import android.graphics.Rect;
-import android.hardware.camera2.CameraAccessException;
-import android.hardware.camera2.CameraCaptureSession;
-import android.hardware.camera2.CameraCharacteristics;
-import android.hardware.camera2.CameraDevice;
-import android.hardware.camera2.CaptureFailure;
-import android.hardware.camera2.CaptureRequest;
-import android.hardware.camera2.params.OutputConfiguration;
-import android.hardware.camera2.params.SessionConfiguration;
-import android.hardware.camera2.params.StreamConfigurationMap;
-import android.media.MediaCodec;
-import android.os.Build;
-import android.os.Handler;
-import android.os.HandlerThread;
-import android.util.Log;
-import android.view.Surface;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executor;
-import java.util.concurrent.Executors;
-
-public class CameraCapture extends SurfaceCapture {
-
-    private static final Executor EXECUTOR = Executors.newSingleThreadExecutor();
-
-    private final String cameraId;
-
-    private HandlerThread cameraThread;
-    private Handler cameraHandler;
-    private CameraDevice cameraDevice;
-    private int maxSize;
-
-    public CameraCapture(String cameraId, int maxSize) {
-        this.cameraId = cameraId;
-        this.maxSize = maxSize;
-    }
-
-    @Override
-    public void init() throws IOException {
-        cameraThread = new HandlerThread("camera");
-        cameraThread.start();
-        cameraHandler = new Handler(cameraThread.getLooper());
-
-        try {
-            cameraDevice = openCamera(cameraId);
-        } catch (CameraAccessException | InterruptedException e) {
-            throw new IOException(e);
-        }
-    }
-
-    @Override
-    public void start(Surface surface) throws IOException {
-        try {
-            CameraCaptureSession session = createCaptureSession(cameraDevice, surface);
-            CaptureRequest.Builder requestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
-            requestBuilder.addTarget(surface);
-            CaptureRequest request = requestBuilder.build();
-            setRepeatingRequest(session, request);
-        } catch (CameraAccessException | InterruptedException e) {
-            throw new IOException(e);
-        }
-    }
-
-    @Override
-    public void release() {
-        if (cameraDevice != null) {
-            cameraDevice.close();
-        }
-        if (cameraThread != null) {
-            cameraThread.quitSafely();
-        }
-    }
-
-    @Override
-    public Size getSize() {
-        return new Size(1920, 1080);
-    }
-
-    @Override
-    public void setMaxSize(int size) {
-        maxSize = size;
-    }
-
-    @SuppressLint("MissingPermission")
-    @TargetApi(Build.VERSION_CODES.S)
-    private CameraDevice openCamera(String id) throws CameraAccessException, InterruptedException {
-        Ln.v("Open Camera: " + id);
-
-        CompletableFuture<CameraDevice> future = new CompletableFuture<>();
-        ServiceManager.getCameraManager().openCamera(id, new CameraDevice.StateCallback() {
-            @Override
-            public void onOpened(CameraDevice camera) {
-                Ln.v("Open Camera Success");
-                future.complete(camera);
-            }
-
-            @Override
-            public void onDisconnected(CameraDevice camera) {
-                Ln.w("Camera disconnected");
-                // TODO
-            }
-
-            @Override
-            public void onError(CameraDevice camera, int error) {
-                int cameraAccessExceptionErrorCode;
-                switch (error) {
-                    case CameraDevice.StateCallback.ERROR_CAMERA_IN_USE:
-                        cameraAccessExceptionErrorCode = CameraAccessException.CAMERA_IN_USE;
-                        break;
-                    case CameraDevice.StateCallback.ERROR_MAX_CAMERAS_IN_USE:
-                        cameraAccessExceptionErrorCode = CameraAccessException.MAX_CAMERAS_IN_USE;
-                        break;
-                    case CameraDevice.StateCallback.ERROR_CAMERA_DISABLED:
-                        cameraAccessExceptionErrorCode = CameraAccessException.CAMERA_DISABLED;
-                        break;
-                    case CameraDevice.StateCallback.ERROR_CAMERA_DEVICE:
-                    case CameraDevice.StateCallback.ERROR_CAMERA_SERVICE:
-                    default:
-                        cameraAccessExceptionErrorCode = CameraAccessException.CAMERA_ERROR;
-                        break;
-                }
-                future.completeExceptionally(new CameraAccessException(cameraAccessExceptionErrorCode));
-            }
-        }, cameraHandler);
-
-        try {
-            return future.get();
-        } catch (ExecutionException e) {
-            throw (CameraAccessException) e.getCause();
-        }
-    }
-
-    @TargetApi(Build.VERSION_CODES.S)
-    private CameraCaptureSession createCaptureSession(CameraDevice camera, Surface surface) throws CameraAccessException, InterruptedException {
-        Ln.d("Create Capture Session");
-
-        CompletableFuture<CameraCaptureSession> future = new CompletableFuture<>();
-        // replace by createCaptureSession(SessionConfiguration)
-        OutputConfiguration outputConfig = new OutputConfiguration(surface);
-        List<OutputConfiguration> outputs = Arrays.asList(outputConfig);
-        SessionConfiguration sessionConfig = new SessionConfiguration(SessionConfiguration.SESSION_REGULAR, outputs, EXECUTOR,
-                new CameraCaptureSession.StateCallback() {
-                    @Override
-                    public void onConfigured(CameraCaptureSession session) {
-                        Ln.d("Create Capture Session Success");
-                        future.complete(session);
-                    }
-
-                    @Override
-                    public void onConfigureFailed(CameraCaptureSession session) {
-                        future.completeExceptionally(new CameraAccessException(CameraAccessException.CAMERA_ERROR));
-                    }
-                });
-
-        camera.createCaptureSession(sessionConfig);
-
-        try {
-            return future.get();
-        } catch (ExecutionException e) {
-            throw (CameraAccessException) e.getCause();
-        }
-    }
-
-    @TargetApi(Build.VERSION_CODES.S)
-    private void setRepeatingRequest(CameraCaptureSession session, CaptureRequest request) throws CameraAccessException, InterruptedException {
-        CompletableFuture<Void> future = new CompletableFuture<>();
-        session.setRepeatingRequest(request, new CameraCaptureSession.CaptureCallback() {
-            @Override
-            public void onCaptureStarted(CameraCaptureSession session, CaptureRequest request, long timestamp, long frameNumber) {
-                future.complete(null);
-            }
-
-            @Override
-            public void onCaptureFailed(CameraCaptureSession session, CaptureRequest request, CaptureFailure failure) {
-                future.completeExceptionally(new CameraAccessException(CameraAccessException.CAMERA_ERROR));
-            }
-        }, cameraHandler);
-
-        try {
-            future.get();
-        } catch (ExecutionException e) {
-            throw (CameraAccessException) e.getCause();
-        }
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
@ -64,6 +64,8 @@ public final class DesktopConnection implements Closeable {
            throws IOException {
        String socketName = getSocketName(scid);

+        LocalSocket firstSocket = null;
+
        LocalSocket videoSocket = null;
        LocalSocket audioSocket = null;
        LocalSocket controlSocket = null;
@ -72,28 +74,24 @@ public final class DesktopConnection implements Closeable {
                try (LocalServerSocket localServerSocket = new LocalServerSocket(socketName)) {
                    if (video) {
                        videoSocket = localServerSocket.accept();
-                        if (sendDummyByte) {
-                            // send one byte so the client may read() to detect a connection error
-                            videoSocket.getOutputStream().write(0);
-                            sendDummyByte = false;
-                        }
+                        firstSocket = videoSocket;
                    }
                    if (audio) {
                        audioSocket = localServerSocket.accept();
-                        if (sendDummyByte) {
-                            // send one byte so the client may read() to detect a connection error
-                            audioSocket.getOutputStream().write(0);
-                            sendDummyByte = false;
+                        if (firstSocket == null) {
+                            firstSocket = audioSocket;
                        }
                    }
                    if (control) {
                        controlSocket = localServerSocket.accept();
-                        if (sendDummyByte) {
-                            // send one byte so the client may read() to detect a connection error
-                            controlSocket.getOutputStream().write(0);
-                            sendDummyByte = false;
+                        if (firstSocket == null) {
+                            firstSocket = controlSocket;
                        }
                    }
+                    if (sendDummyByte) {
+                        // send one byte so the client may read() to detect a connection error
+                        firstSocket.getOutputStream().write(0);
+                    }
                }
            } else {
                if (video) {
--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@ -99,32 +99,25 @@ public final class Device {
            }
        }, displayId);

-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            ServiceManager.getWindowManager().registerDisplayFoldListener(new IDisplayFoldListener.Stub() {
-                @Override
-                public void onDisplayFoldChanged(int displayId, boolean folded) {
-                    if (Device.this.displayId != displayId) {
-                        // Ignore events related to other display ids
+        ServiceManager.getWindowManager().registerDisplayFoldListener(new IDisplayFoldListener.Stub() {
+            @Override
+            public void onDisplayFoldChanged(int displayId, boolean folded) {
+                synchronized (Device.this) {
+                    DisplayInfo displayInfo = ServiceManager.getDisplayManager().getDisplayInfo(displayId);
+                    if (displayInfo == null) {
+                        Ln.e("Display " + displayId + " not found\n" + LogUtils.buildDisplayListMessage());
                        return;
                    }

-                    synchronized (Device.this) {
-                        DisplayInfo displayInfo = ServiceManager.getDisplayManager().getDisplayInfo(displayId);
-                        if (displayInfo == null) {
-                            Ln.e("Display " + displayId + " not found\n" + LogUtils.buildDisplayListMessage());
-                            return;
-                        }
-
-                        screenInfo = ScreenInfo.computeScreenInfo(displayInfo.getRotation(), displayInfo.getSize(), options.getCrop(),
-                                options.getMaxSize(), options.getLockVideoOrientation());
-                        // notify
-                        if (foldListener != null) {
-                            foldListener.onFoldChanged(displayId, folded);
-                        }
+                    screenInfo = ScreenInfo.computeScreenInfo(displayInfo.getRotation(), displayInfo.getSize(), options.getCrop(),
+                            options.getMaxSize(), options.getLockVideoOrientation());
+                    // notify
+                    if (foldListener != null) {
+                        foldListener.onFoldChanged(displayId, folded);
                    }
                }
-            });
-        }
+            }
+        });

        if (options.getControl() && options.getClipboardAutosync()) {
            // If control and autosync are enabled, synchronize Android clipboard to the computer automatically
--- a/server/src/main/java/com/genymobile/scrcpy/FakeContext.java
+++ b/server/src/main/java/com/genymobile/scrcpy/FakeContext.java
@ -1,24 +1,42 @@
 package com.genymobile.scrcpy;

+import com.genymobile.scrcpy.wrappers.ActivityThread;
+
 import android.annotation.TargetApi;
 import android.content.AttributionSource;
-import android.content.MutableContextWrapper;
+import android.content.Context;
+import android.content.ContextWrapper;
 import android.os.Build;
 import android.os.Process;

-public final class FakeContext extends MutableContextWrapper {
+import java.lang.reflect.Method;
+
+public final class FakeContext extends ContextWrapper {

    public static final String PACKAGE_NAME = "com.android.shell";
    public static final int ROOT_UID = 0; // Like android.os.Process.ROOT_UID, but before API 29

    private static final FakeContext INSTANCE = new FakeContext();

+    private static Context retrieveSystemContext() {
+        try {
+            Class<?> activityThreadClass = ActivityThread.getActivityThreadClass();
+            Object activityThread = ActivityThread.getActivityThread();
+
+            Method getSystemContextMethod = activityThreadClass.getDeclaredMethod("getSystemContext");
+            return (Context) getSystemContextMethod.invoke(activityThread);
+        } catch (Exception e) {
+            Ln.e("Cannot retrieve system context", e);
+            return null;
+        }
+    }
+
    public static FakeContext get() {
        return INSTANCE;
    }

    private FakeContext() {
-        super(null);
+        super(retrieveSystemContext());
    }

    @Override
--- a/server/src/main/java/com/genymobile/scrcpy/LogUtils.java
+++ b/server/src/main/java/com/genymobile/scrcpy/LogUtils.java
@ -3,12 +3,6 @@ package com.genymobile.scrcpy;
 import com.genymobile.scrcpy.wrappers.DisplayManager;
 import com.genymobile.scrcpy.wrappers.ServiceManager;

-import android.hardware.camera2.CameraAccessException;
-import android.hardware.camera2.CameraCharacteristics;
-import android.hardware.camera2.CameraManager;
-import android.hardware.camera2.params.StreamConfigurationMap;
-import android.media.MediaCodec;
-
 import java.util.List;

 public final class LogUtils {
@ -66,48 +60,4 @@ public final class LogUtils {
        }
        return builder.toString();
    }
-
-    private static String getCameraFacingName(int facing) {
-        switch (facing) {
-            case CameraCharacteristics.LENS_FACING_FRONT:
-                return "front";
-            case CameraCharacteristics.LENS_FACING_BACK:
-                return "back";
-            case CameraCharacteristics.LENS_FACING_EXTERNAL:
-                return "external";
-            default:
-                return "unknown";
-        }
-    }
-
-    public static String buildCameraListMessage() {
-        StringBuilder builder = new StringBuilder("List of cameras:");
-        CameraManager cameraManager = ServiceManager.getCameraManager();
-        try {
-            String[] cameraIds = cameraManager.getCameraIdList();
-            if (cameraIds == null || cameraIds.length == 0) {
-                builder.append("\n    (none)");
-            } else {
-                for (String id : cameraIds) {
-                    builder.append("\n    --video-source=camera --camera=").append(id);
-                    CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(id);
-                    Integer facingInteger = characteristics.get(CameraCharacteristics.LENS_FACING);
-                    if (facingInteger != null) {
-                        int facing = facingInteger;
-                        builder.append("    (").append(getCameraFacingName(facing)).append(')');
-                    }
-
-                    StreamConfigurationMap configs = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
-                    android.util.Size[] sizes = configs.getOutputSizes(MediaCodec.class);
-                    for (android.util.Size size : sizes) {
-                        // TODO remove (just for testing)
-                        builder.append("\n        - " + size.getWidth() + "x" + size.getHeight());
-                    }
-                }
-            }
-        } catch (CameraAccessException e) {
-            builder.append("\n    (access denied)");
-        }
-        return builder.toString();
-    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@ -38,7 +38,6 @@ public class Options {

    private boolean listEncoders;
    private boolean listDisplays;
-    private boolean listCameras;

    // Options not used by the scrcpy client, but useful to use scrcpy-server directly
    private boolean sendDeviceMeta = true; // send device name and size
@ -162,10 +161,6 @@ public class Options {
        return listDisplays;
    }

-    public boolean getListCameras() {
-        return listCameras;
-    }
-
    public boolean getSendDeviceMeta() {
        return sendDeviceMeta;
    }
@ -311,9 +306,6 @@ public class Options {
                case "list_displays":
                    options.listDisplays = Boolean.parseBoolean(value);
                    break;
-                case "list_cameras":
-                    options.listCameras = Boolean.parseBoolean(value);
-                    break;
                case "send_device_meta":
                    options.sendDeviceMeta = Boolean.parseBoolean(value);
                    break;
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenCapture.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenCapture.java
@ -1,83 +0,0 @@
-package com.genymobile.scrcpy;
-
-import com.genymobile.scrcpy.wrappers.SurfaceControl;
-
-import android.graphics.Rect;
-import android.os.Build;
-import android.os.IBinder;
-import android.view.Surface;
-
-public class ScreenCapture extends SurfaceCapture implements Device.RotationListener, Device.FoldListener {
-
-    private final Device device;
-    private IBinder display;
-
-    public ScreenCapture(Device device) {
-        this.device = device;
-    }
-
-    @Override
-    public void init() {
-        display = createDisplay();
-        device.setRotationListener(this);
-        device.setFoldListener(this);
-    }
-
-    @Override
-    public void start(Surface surface) {
-        ScreenInfo screenInfo = device.getScreenInfo();
-        Rect contentRect = screenInfo.getContentRect();
-
-        // does not include the locked video orientation
-        Rect unlockedVideoRect = screenInfo.getUnlockedVideoSize().toRect();
-        int videoRotation = screenInfo.getVideoRotation();
-        int layerStack = device.getLayerStack();
-        setDisplaySurface(display, surface, videoRotation, contentRect, unlockedVideoRect, layerStack);
-    }
-
-    @Override
-    public void release() {
-        device.setRotationListener(null);
-        device.setFoldListener(null);
-        SurfaceControl.destroyDisplay(display);
-    }
-
-    @Override
-    public Size getSize() {
-        return device.getScreenInfo().getVideoSize();
-    }
-
-    @Override
-    public void setMaxSize(int size) {
-        device.setMaxSize(size);
-    }
-
-    @Override
-    public void onFoldChanged(int displayId, boolean folded) {
-        requestReset();
-    }
-
-    @Override
-    public void onRotationChanged(int rotation) {
-        requestReset();
-    }
-
-    private static IBinder createDisplay() {
-        // Since Android 12 (preview), secure displays could not be created with shell permissions anymore.
-        // On Android 12 preview, SDK_INT is still R (not S), but CODENAME is "S".
-        boolean secure = Build.VERSION.SDK_INT < Build.VERSION_CODES.R || (Build.VERSION.SDK_INT == Build.VERSION_CODES.R && !"S".equals(
-                Build.VERSION.CODENAME));
-        return SurfaceControl.createDisplay("scrcpy", secure);
-    }
-
-    private static void setDisplaySurface(IBinder display, Surface surface, int orientation, Rect deviceRect, Rect displayRect, int layerStack) {
-        SurfaceControl.openTransaction();
-        try {
-            SurfaceControl.setDisplaySurface(display, surface);
-            SurfaceControl.setDisplayProjection(display, orientation, deviceRect, displayRect);
-            SurfaceControl.setDisplayLayerStack(display, layerStack);
-        } finally {
-            SurfaceControl.closeTransaction();
-        }
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/SurfaceEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/SurfaceEncoder.java
@ -1,9 +1,13 @@
 package com.genymobile.scrcpy;

+import com.genymobile.scrcpy.wrappers.SurfaceControl;
+
+import android.graphics.Rect;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaFormat;
-import android.os.Looper;
+import android.os.Build;
+import android.os.IBinder;
 import android.os.SystemClock;
 import android.view.Surface;

@ -12,7 +16,7 @@ import java.nio.ByteBuffer;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;

-public class SurfaceEncoder implements AsyncProcessor {
+public class ScreenEncoder implements Device.RotationListener, Device.FoldListener, AsyncProcessor {

    private static final int DEFAULT_I_FRAME_INTERVAL = 10; // seconds
    private static final int REPEAT_FRAME_DELAY_US = 100_000; // repeat after 100ms
@ -22,7 +26,9 @@ public class SurfaceEncoder implements AsyncProcessor {
    private static final int[] MAX_SIZE_FALLBACK = {2560, 1920, 1600, 1280, 1024, 800};
    private static final int MAX_CONSECUTIVE_ERRORS = 3;

-    private final SurfaceCapture capture;
+    private final AtomicBoolean resetCapture = new AtomicBoolean();
+
+    private final Device device;
    private final Streamer streamer;
    private final String encoderName;
    private final List<CodecOption> codecOptions;
@ -36,9 +42,9 @@ public class SurfaceEncoder implements AsyncProcessor {
    private Thread thread;
    private final AtomicBoolean stopped = new AtomicBoolean();

-    public SurfaceEncoder(SurfaceCapture capture, Streamer streamer, int videoBitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
+    public ScreenEncoder(Device device, Streamer streamer, int videoBitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
            boolean downsizeOnError) {
-        this.capture = capture;
+        this.device = device;
        this.streamer = streamer;
        this.videoBitRate = videoBitRate;
        this.maxFps = maxFps;
@ -47,29 +53,51 @@ public class SurfaceEncoder implements AsyncProcessor {
        this.downsizeOnError = downsizeOnError;
    }

+    @Override
+    public void onFoldChanged(int displayId, boolean folded) {
+        resetCapture.set(true);
+    }
+
+    @Override
+    public void onRotationChanged(int rotation) {
+        resetCapture.set(true);
+    }
+
+    private boolean consumeResetCapture() {
+        return resetCapture.getAndSet(false);
+    }
+
    private void streamScreen() throws IOException, ConfigurationException {
        Codec codec = streamer.getCodec();
        MediaCodec mediaCodec = createMediaCodec(codec, encoderName);
        MediaFormat format = createFormat(codec.getMimeType(), videoBitRate, maxFps, codecOptions);
+        IBinder display = createDisplay();
+        device.setRotationListener(this);
+        device.setFoldListener(this);

-        capture.init();
+        streamer.writeVideoHeader(device.getScreenInfo().getVideoSize());

+        boolean alive;
        try {
-            streamer.writeVideoHeader(capture.getSize());
-
-            boolean alive;
-
            do {
-                Size size = capture.getSize();
-                format.setInteger(MediaFormat.KEY_WIDTH, size.getWidth());
-                format.setInteger(MediaFormat.KEY_HEIGHT, size.getHeight());
+                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 {
                    mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
                    surface = mediaCodec.createInputSurface();

-                    capture.start(surface);
+                    // does not include the locked video orientation
+                    Rect unlockedVideoRect = screenInfo.getUnlockedVideoSize().toRect();
+                    int videoRotation = screenInfo.getVideoRotation();
+                    int layerStack = device.getLayerStack();
+                    setDisplaySurface(display, surface, videoRotation, contentRect, unlockedVideoRect, layerStack);

                    mediaCodec.start();

@ -78,7 +106,7 @@ public class SurfaceEncoder implements AsyncProcessor {
                    mediaCodec.stop();
                } catch (IllegalStateException | IllegalArgumentException e) {
                    Ln.e("Encoding error: " + e.getClass().getName() + ": " + e.getMessage());
-                    if (!prepareRetry(size)) {
+                    if (!prepareRetry(device, screenInfo)) {
                        throw e;
                    }
                    Ln.i("Retrying...");
@ -92,11 +120,13 @@ public class SurfaceEncoder implements AsyncProcessor {
            } while (alive);
        } finally {
            mediaCodec.release();
-            capture.release();
+            device.setRotationListener(null);
+            device.setFoldListener(null);
+            SurfaceControl.destroyDisplay(display);
        }
    }

-    private boolean prepareRetry(Size currentSize) {
+    private boolean prepareRetry(Device device, ScreenInfo screenInfo) {
        if (firstFrameSent) {
            ++consecutiveErrors;
            if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
@ -116,7 +146,8 @@ public class SurfaceEncoder implements AsyncProcessor {

        // Downsizing on error is only enabled if an encoding failure occurs before the first frame (downsizing later could be surprising)

-        int newMaxSize = chooseMaxSizeFallback(currentSize);
+        int newMaxSize = chooseMaxSizeFallback(screenInfo.getVideoSize());
+        Ln.i("newMaxSize = " + newMaxSize);
        if (newMaxSize == 0) {
            // Must definitively fail
            return false;
@ -124,7 +155,7 @@ public class SurfaceEncoder implements AsyncProcessor {

        // Retry with a smaller device size
        Ln.i("Retrying with -m" + newMaxSize + "...");
-        capture.setMaxSize(newMaxSize);
+        device.setMaxSize(newMaxSize);
        return true;
    }

@ -145,14 +176,14 @@ public class SurfaceEncoder implements AsyncProcessor {
        boolean alive = true;
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();

-        while (!capture.consumeReset() && !eof) {
+        while (!consumeResetCapture() && !eof) {
            if (stopped.get()) {
                alive = false;
                break;
            }
            int outputBufferId = codec.dequeueOutputBuffer(bufferInfo, -1);
            try {
-                if (capture.consumeReset()) {
+                if (consumeResetCapture()) {
                    // must restart encoding with new size
                    break;
                }
@ -233,13 +264,28 @@ public class SurfaceEncoder implements AsyncProcessor {
        return format;
    }

+    private static IBinder createDisplay() {
+        // Since Android 12 (preview), secure displays could not be created with shell permissions anymore.
+        // On Android 12 preview, SDK_INT is still R (not S), but CODENAME is "S".
+        boolean secure = Build.VERSION.SDK_INT < Build.VERSION_CODES.R || (Build.VERSION.SDK_INT == Build.VERSION_CODES.R && !"S"
+                .equals(Build.VERSION.CODENAME));
+        return SurfaceControl.createDisplay("scrcpy", secure);
+    }
+
+    private static void setDisplaySurface(IBinder display, Surface surface, int orientation, Rect deviceRect, Rect displayRect, int layerStack) {
+        SurfaceControl.openTransaction();
+        try {
+            SurfaceControl.setDisplaySurface(display, surface);
+            SurfaceControl.setDisplayProjection(display, orientation, deviceRect, displayRect);
+            SurfaceControl.setDisplayLayerStack(display, layerStack);
+        } finally {
+            SurfaceControl.closeTransaction();
+        }
+    }
+
    @Override
    public void start(TerminationListener listener) {
        thread = new Thread(() -> {
-            // Some devices (Meizu) deadlock if the video encoding thread has no Looper
-            // <https://github.com/Genymobile/scrcpy/issues/4143>
-            Looper.prepare();
-
            try {
                streamScreen();
            } catch (ConfigurationException e) {
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -2,7 +2,6 @@ package com.genymobile.scrcpy;

 import android.os.BatteryManager;
 import android.os.Build;
-import android.os.Looper;

 import java.io.IOException;
 import java.util.ArrayList;
@ -100,8 +99,26 @@ public final class Server {
        boolean audio = options.getAudio();
        boolean sendDummyByte = options.getSendDummyByte();

-        boolean camera = true;
-        Workarounds.apply(audio, camera);
+        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>
+        if (Build.BRAND.equalsIgnoreCase("meizu") || Build.BRAND.equalsIgnoreCase("honor")) {
+            Workarounds.fillAppInfo();
+        }
+
+        // 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 the application context for the AudioRecord to work.
+        if (audio && Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
+            Workarounds.fillAppContext();
+        }

        List<AsyncProcessor> asyncProcessors = new ArrayList<>();

@ -134,9 +151,7 @@ public final class Server {
            if (video) {
                Streamer videoStreamer = new Streamer(connection.getVideoFd(), options.getVideoCodec(), options.getSendCodecMeta(),
                        options.getSendFrameMeta());
-                CameraCapture capture = new CameraCapture("0", 1920);
-                //ScreenCapture screenCapture = new ScreenCapture(device);
-                SurfaceEncoder screenEncoder = new SurfaceEncoder(capture, videoStreamer, options.getVideoBitRate(), options.getMaxFps(),
+                ScreenEncoder screenEncoder = new ScreenEncoder(device, videoStreamer, options.getVideoBitRate(), options.getMaxFps(),
                        options.getVideoCodecOptions(), options.getVideoEncoder(), options.getDownsizeOnError());
                asyncProcessors.add(screenEncoder);
            }
@ -183,7 +198,7 @@ public final class Server {

        Ln.initLogLevel(options.getLogLevel());

-        if (options.getListEncoders() || options.getListDisplays() || options.getListCameras()) {
+        if (options.getListEncoders() || options.getListDisplays()) {
            if (options.getCleanup()) {
                CleanUp.unlinkSelf();
            }
@ -195,10 +210,6 @@ public final class Server {
            if (options.getListDisplays()) {
                Ln.i(LogUtils.buildDisplayListMessage());
            }
-            if (options.getListCameras()) {
-                Workarounds.apply(false, true);
-                Ln.i(LogUtils.buildCameraListMessage());
-            }
            // Just print the requested data, do not mirror
            return;
        }
--- a/server/src/main/java/com/genymobile/scrcpy/SurfaceCapture.java
+++ b/server/src/main/java/com/genymobile/scrcpy/SurfaceCapture.java
@ -1,62 +0,0 @@
-package com.genymobile.scrcpy;
-
-import android.view.Surface;
-
-import java.io.IOException;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * A video source which can be rendered on a Surface for encoding.
- */
-public abstract class SurfaceCapture {
-
-    private final AtomicBoolean resetCapture = new AtomicBoolean();
-
-    /**
-     * Request the encoding session to be restarted, for example if the capture implementation detects that the video source size has changed (on
-     * device rotation for example).
-     */
-    protected void requestReset() {
-        resetCapture.set(true);
-    }
-
-    /**
-     * Consume the reset request (intended to be called by the encoder).
-     *
-     * @return {@code true} if a reset request was pending, {@code false} otherwise.
-     */
-    public boolean consumeReset() {
-        return resetCapture.getAndSet(false);
-    }
-
-    /**
-     * Called once before the capture starts.
-     */
-    public abstract void init() throws IOException;
-
-    /**
-     * Called after the capture ends (if and only if {@link #init()} has been called).
-     */
-    public abstract void release();
-
-    /**
-     * Start the capture to the target surface.
-     *
-     * @param surface the surface which will be encoded
-     */
-    public abstract void start(Surface surface) throws IOException;
-
-    /**
-     * Return the video size
-     *
-     * @return the video size
-     */
-    public abstract Size getSize();
-
-    /**
-     * Set the maximum capture size (set by the encoder if it does not support the current size).
-     *
-     * @param size Maximum size
-     */
-    public abstract void setMaxSize(int size);
-}
--- a/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
@ -1,10 +1,11 @@
 package com.genymobile.scrcpy;

+import com.genymobile.scrcpy.wrappers.ActivityThread;
+
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.app.Application;
 import android.content.AttributionSource;
-import android.content.Context;
 import android.content.ContextWrapper;
 import android.content.pm.ApplicationInfo;
 import android.media.AudioAttributes;
@ -21,66 +22,14 @@ import java.lang.reflect.Method;

 public final class Workarounds {

-    private static Class<?> activityThreadClass;
-    private static Object activityThread;
+    private static boolean activityThreadFilled;

    private Workarounds() {
        // not instantiable
    }

-    public static void apply(boolean audio, boolean camera) {
-        Workarounds.prepareMainLooper();
-
-        boolean mustFillAppInfo = false;
-        boolean mustFillBaseContext = true;
-        boolean mustFillAppContext = false;
-
-        if (Build.BRAND.equalsIgnoreCase("meizu")) {
-            // 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>
-            mustFillAppInfo = true;
-        } else if (Build.BRAND.equalsIgnoreCase("honor")) {
-            // More workarounds must be applied for Honor devices:
-            //  - <https://github.com/Genymobile/scrcpy/issues/4015>
-            //
-            // The system context must not be set for all devices, because it would cause other problems:
-            //  - <https://github.com/Genymobile/scrcpy/issues/4015#issuecomment-1595382142>
-            //  - <https://github.com/Genymobile/scrcpy/issues/3805#issuecomment-1596148031>
-            mustFillAppInfo = true;
-            mustFillBaseContext = true;
-            mustFillAppContext = true;
-        }
-
-        if (audio && Build.VERSION.SDK_INT == Build.VERSION_CODES.R) {
-            // 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 the application context for the AudioRecord to work.
-            mustFillAppContext = true;
-        }
-
-        if (camera) {
-            mustFillAppInfo = true;
-        }
-
-        if (mustFillAppInfo) {
-            Workarounds.fillAppInfo();
-        }
-        if (mustFillBaseContext) {
-            Workarounds.fillBaseContext();
-        }
-        if (mustFillAppContext) {
-            Workarounds.fillAppContext();
-        }
-    }
-
    @SuppressWarnings("deprecation")
-    private static void prepareMainLooper() {
+    public static void prepareMainLooper() {
        // Some devices internally create a Handler when creating an input Surface, causing an exception:
        //   "Can't create handler inside thread that has not called Looper.prepare()"
        // <https://github.com/Genymobile/scrcpy/issues/240>
@ -94,22 +43,21 @@ public final class Workarounds {

    @SuppressLint("PrivateApi,DiscouragedPrivateApi")
    private static void fillActivityThread() throws Exception {
-        if (activityThread == null) {
-            // ActivityThread activityThread = new ActivityThread();
-            activityThreadClass = Class.forName("android.app.ActivityThread");
-            Constructor<?> activityThreadConstructor = activityThreadClass.getDeclaredConstructor();
-            activityThreadConstructor.setAccessible(true);
-            activityThread = activityThreadConstructor.newInstance();
+        if (!activityThreadFilled) {
+            Class<?> activityThreadClass = ActivityThread.getActivityThreadClass();
+            Object activityThread = ActivityThread.getActivityThread();

            // ActivityThread.sCurrentActivityThread = activityThread;
            Field sCurrentActivityThreadField = activityThreadClass.getDeclaredField("sCurrentActivityThread");
            sCurrentActivityThreadField.setAccessible(true);
            sCurrentActivityThreadField.set(null, activityThread);
+
+            activityThreadFilled = true;
        }
    }

    @SuppressLint("PrivateApi,DiscouragedPrivateApi")
-    private static void fillAppInfo() {
+    public static void fillAppInfo() {
        try {
            fillActivityThread();

@ -127,6 +75,9 @@ public final class Workarounds {
            appInfoField.setAccessible(true);
            appInfoField.set(appBindData, applicationInfo);

+            Class<?> activityThreadClass = ActivityThread.getActivityThreadClass();
+            Object activityThread = ActivityThread.getActivityThread();
+
            // activityThread.mBoundApplication = appBindData;
            Field mBoundApplicationField = activityThreadClass.getDeclaredField("mBoundApplication");
            mBoundApplicationField.setAccessible(true);
@ -138,7 +89,7 @@ public final class Workarounds {
    }

    @SuppressLint("PrivateApi,DiscouragedPrivateApi")
-    private static void fillAppContext() {
+    public static void fillAppContext() {
        try {
            fillActivityThread();

@ -147,6 +98,9 @@ public final class Workarounds {
            baseField.setAccessible(true);
            baseField.set(app, FakeContext.get());

+            Class<?> activityThreadClass = ActivityThread.getActivityThreadClass();
+            Object activityThread = ActivityThread.getActivityThread();
+
            // activityThread.mInitialApplication = app;
            Field mInitialApplicationField = activityThreadClass.getDeclaredField("mInitialApplication");
            mInitialApplicationField.setAccessible(true);
@ -157,19 +111,6 @@ public final class Workarounds {
        }
    }

-    private static void fillBaseContext() {
-        try {
-            fillActivityThread();
-
-            Method getSystemContextMethod = activityThreadClass.getDeclaredMethod("getSystemContext");
-            Context context = (Context) getSystemContextMethod.invoke(activityThread);
-            FakeContext.get().setBaseContext(context);
-        } catch (Throwable throwable) {
-            // this is a workaround, so failing is not an error
-            Ln.d("Could not fill base context: " + throwable.getMessage());
-        }
-    }
-
    @TargetApi(Build.VERSION_CODES.R)
    @SuppressLint("WrongConstant,MissingPermission,BlockedPrivateApi,SoonBlockedPrivateApi,DiscouragedPrivateApi")
    public static AudioRecord createAudioRecord(int source, int sampleRate, int channelConfig, int channels, int channelMask, int encoding) {
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java
@ -17,7 +17,7 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

@SuppressLint("PrivateApi,DiscouragedPrivateApi")
-public final class ActivityManager {
+public class ActivityManager {

    private final IInterface manager;
    private Method getContentProviderExternalMethod;
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityThread.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityThread.java
@ -0,0 +1,32 @@
+package com.genymobile.scrcpy.wrappers;
+
+import java.lang.reflect.Constructor;
+
+public class ActivityThread {
+
+    private static final Class<?> activityThreadClass;
+    private static final Object activityThread;
+
+    static {
+        try {
+            activityThreadClass = Class.forName("android.app.ActivityThread");
+            Constructor<?> activityThreadConstructor = activityThreadClass.getDeclaredConstructor();
+            activityThreadConstructor.setAccessible(true);
+            activityThread = activityThreadConstructor.newInstance();
+        } catch (Exception e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    private ActivityThread() {
+        // only static methods
+    }
+
+    public static Object getActivityThread() {
+        return activityThread;
+    }
+
+    public static Class<?> getActivityThreadClass() {
+        return activityThreadClass;
+    }
+}
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
@ -11,7 +11,7 @@ import android.os.IInterface;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

-public final class ClipboardManager {
+public class ClipboardManager {
    private final IInterface manager;
    private Method getPrimaryClipMethod;
    private Method setPrimaryClipMethod;
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ContentProvider.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ContentProvider.java
@ -14,7 +14,7 @@ import java.io.Closeable;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

-public final class ContentProvider implements Closeable {
+public class ContentProvider implements Closeable {

    public static final String TABLE_SYSTEM = "system";
    public static final String TABLE_SECURE = "secure";
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java
@ -1,15 +1,9 @@
 package com.genymobile.scrcpy.wrappers;

-import com.genymobile.scrcpy.FakeContext;
-import com.genymobile.scrcpy.Workarounds;
-
 import android.annotation.SuppressLint;
-import android.content.Context;
-import android.hardware.camera2.CameraManager;
 import android.os.IBinder;
 import android.os.IInterface;

-import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

@ -32,7 +26,6 @@ public final class ServiceManager {
    private static StatusBarManager statusBarManager;
    private static ClipboardManager clipboardManager;
    private static ActivityManager activityManager;
-    private static CameraManager cameraManager;

    private ServiceManager() {
        /* not instantiable */
@ -136,16 +129,4 @@ public final class ServiceManager {

        return activityManager;
    }
-
-    public static CameraManager getCameraManager() {
-        if (cameraManager == null) {
-            try {
-                Constructor<CameraManager> ctor = CameraManager.class.getDeclaredConstructor(Context.class);
-                cameraManager = ctor.newInstance(FakeContext.get());
-            } catch (Exception e) {
-                throw new AssertionError(e);
-            }
-        }
-        return cameraManager;
-    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java
@ -7,7 +7,7 @@ import android.os.IInterface;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

-public final class StatusBarManager {
+public class StatusBarManager {

    private final IInterface manager;
    private Method expandNotificationsPanelMethod;
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java
@ -2,7 +2,6 @@ package com.genymobile.scrcpy.wrappers;

 import com.genymobile.scrcpy.Ln;

-import android.annotation.TargetApi;
 import android.os.IInterface;
 import android.view.IRotationWatcher;
 import android.view.IDisplayFoldListener;
@ -107,17 +106,16 @@ public final class WindowManager {
                cls.getMethod("watchRotation", IRotationWatcher.class).invoke(manager, rotationWatcher);
            }
        } catch (Exception e) {
-            Ln.e("Could not register rotation watcher", e);
+            throw new AssertionError(e);
        }
    }

-    @TargetApi(29)
    public void registerDisplayFoldListener(IDisplayFoldListener foldListener) {
        try {
            Class<?> cls = manager.getClass();
            cls.getMethod("registerDisplayFoldListener", IDisplayFoldListener.class).invoke(manager, foldListener);
        } catch (Exception e) {
-            Ln.e("Could not register display fold listener", e);
+            throw new AssertionError(e);
        }
    }
 }