@yume-chan/scrcpy 0.0.16 → 0.0.17

package/CHANGELOG.json

@@ -1,6 +1,21 @@
 {
   "name": "@yume-chan/scrcpy",
   "entries": [
+    {
+      "version": "0.0.17",
+      "tag": "@yume-chan/scrcpy_v0.0.17",
+      "date": "Tue, 18 Oct 2022 09:32:30 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Add standalone types for serializing/deserializing Scrcpy packets"
+          },
+          {
+            "comment": "Separate decoders to own packages so they don't need optional peer dependencies."
+          }
+        ]
+      }
+    },
     {
       "version": "0.0.16",
       "tag": "@yume-chan/scrcpy_v0.0.16",

package/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Change Log - @yume-chan/scrcpy
 
-This log was last generated on Sat, 28 May 2022 03:56:37 GMT and should not be manually modified.
+This log was last generated on Tue, 18 Oct 2022 09:32:30 GMT and should not be manually modified.
+
+## 0.0.17
+Tue, 18 Oct 2022 09:32:30 GMT
+
+### Updates
+
+- Add standalone types for serializing/deserializing Scrcpy packets
+- Separate decoders to own packages so they don't need optional peer dependencies.
 
 ## 0.0.16
 Sat, 28 May 2022 03:56:37 GMT

package/README.md

@@ -2,17 +2,48 @@
 
 TypeScript implementation of [Scrcpy](https://github.com/Genymobile/scrcpy) client.
 
-It uses the official Scrcpy server releases.
+It's compatible with the official Scrcpy server binaries.
 
 **WARNING:** The public API is UNSTABLE. If you have any questions, please open an issue.
 
-## Download Server Binary
+- [Transport agnostic](#transport-agnostic)
+- [Prepare server binary](#prepare-server-binary)
+  - [`fetch-scrcpy-server`](#fetch-scrcpy-server)
+  - [Use the server binary](#use-the-server-binary)
+    - [Node.js CommonJS](#nodejs-commonjs)
+    - [Node.js ES module](#nodejs-es-module)
+    - [Webpack 4](#webpack-4)
+    - [Webpack 5](#webpack-5)
+  - [Read the server version](#read-the-server-version)
+- [Option versions](#option-versions)
+- [Use with `@yume-chan/adb`](#use-with-yume-chanadb)
+  - [Push server binary](#push-server-binary)
+  - [Start server on device](#start-server-on-device)
+- [Using other transportation](#using-other-transportation)
+  - [Parsing video packets](#parsing-video-packets)
+  - [Sending control messages](#sending-control-messages)
+  - [Reading device messages](#reading-device-messages)
+- [Consume the streams](#consume-the-streams)
+- [Video stream](#video-stream)
+- [Decode video stream](#decode-video-stream)
 
-This package has a script `fetch-scrcpy-server` to help you download the official server binary.
+## Transport agnostic
+
+It was initially designed to be used with `@yume-chan/adb`, but now it can also to used with any other transportation.
+
+## Prepare server binary
+
+Scrcpy needs a server binary running on the device in order to work. This package doesn't ship with one.
+
+You can download the server binary from official releases (https://github.com/Genymobile/scrcpy/releases), or use the built-in `fetch-scrcpy-server` script to automate the process.
 
 The server binary is subject to [Apache License 2.0](https://github.com/Genymobile/scrcpy/blob/master/LICENSE).
 
-Usage:
+### `fetch-scrcpy-server`
+
+To use the script, first add `gh-release-fetch@3` to `devDependencies` of your `package.json`. It's an optional peer dependency fpr minimized download size.
+
+Then you can invoke it in a terminal:
 
 ```
 $ npx fetch-scrcpy-server <version>
@@ -21,30 +52,86 @@ $ npx fetch-scrcpy-server <version>
 For example:
 
 ```
-$ npx fetch-scrcpy-server 1.21
+$ npx fetch-scrcpy-server 1.24
 ```
 
-You can also add it to the `postinstall` script of your `package.json` so it will run automatically when you do `npm install`:
+You can also add it to the `postinstall` script in your `package.json`. After that, running `npm install` will automatically invoke the script.
 
 ```json
 "scripts": {
-    "postinstall": "fetch-scrcpy-server 1.21",
+    "postinstall": "fetch-scrcpy-server 1.24",
 },
 ```
 
-It will download the binary to `bin/scrcpy` and write the version string to `bin/version.js`. You can import the version string with
+The server binary will be named `bin/scrcpy-server` in this package's installation directory (usually in `node_modules`).
 
-```js
-import SCRCPY_SERVER_VERSION from '@yume-chan/scrcpy/bin/version';
+### Use the server binary
+
+The server binary file needs to be embedded into your application, the exact method depends on the runtime.
+
+To name a few:
+
+#### Node.js CommonJS
+
+```ts
+const fs = require('fs');
+const path: string = require.resolve('@yume-chan/scrcpy/bin/scrcpy-server'); // Or your own server binary path
+const buffer: Buffer = fs.readFileSync(path);
 ```
 
-And import the server binary with [file-loader](https://v4.webpack.js.org/loaders/file-loader/) (Webpack 4) or [Asset Modules](https://webpack.js.org/guides/asset-modules/) (Webpack 5).
+#### Node.js ES module
+
+```ts
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+
+const path: string = createRequire(import.meta.url).resolve('@yume-chan/scrcpy/bin/scrcpy-server'); // Or your own server binary path
+const buffer: Buffer = await fs.readFile(path);
+```
+
+Currently, ES Module doesn't have a `resolve` function like `require.resolve` in CommonJS, so `createRequire` is used to create a CommonJS resolver.
+
+`import.meta.resolve` (https://github.com/whatwg/html/pull/5572) is a proposal that fills this gap. Node.js already has experimental support for it behind a flag. See https://nodejs.org/api/esm.html#importmetaresolvespecifier-parent for more information.
+
+```ts
+const path: string = import.meta.resolve('@yume-chan/scrcpy/bin/scrcpy-server');
+```
+
+#### Webpack 4
+
+Requires installing and configuring file-loader (https://v4.webpack.js.org/loaders/file-loader/)
+
+```ts
+import SCRCPY_SERVER_URL from '@yume-chan/scrcpy/bin/scrcpy-server'; // Or your own server binary path
+const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then(res => res.arrayBuffer());
+```
+
+#### Webpack 5
+
+Requires configuring Asset Modules (https://webpack.js.org/guides/asset-modules/)
+
+```ts
+const SCRCPY_SERVER_URL = new URL('@yume-chan/scrcpy/bin/scrcpy-server', import.meta.url); // Or your own server binary path
+const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then(res => res.arrayBuffer());
+```
+
+### Read the server version
+
+The correct version number is required to launch the server, so `fetch-scrcpy-server` also writes the version number to `bin/version.js`.
+
+```js
+import SCRCPY_SERVER_VERSION from '@yume-chan/scrcpy/bin/version.js';
+
+console.log(SCRCPY_SERVER_VERSION); // "1.24"
+```
 
 ## Option versions
 
-Scrcpy server has no backward compatibility on options input format. Currently the following versions are supported:
+Scrcpy server options changes over time, and some of them are not backwards compatible. This package provides option types for each version (or range). Using wrong option version usually results in errors.
 
-| versions  | type                |
+The latest one may continue to work for future server versions, but there is no guarantee.
+
+| Version   | Type                |
 | --------- | ------------------- |
 | 1.16~1.17 | `ScrcpyOptions1_16` |
 | 1.18~1.20 | `ScrcpyOptions1_18` |
@@ -53,38 +140,188 @@ Scrcpy server has no backward compatibility on options input format. Currently t
 | 1.23      | `ScrcpyOptions1_23` |
 | 1.24      | `ScrcpyOptions1_24` |
 
-You must use the correct type according to the server version.
+When using `AdbScrcpyClient`, there is another `AdbScrcpyOptions` contains `@yume-chan/adb` related logics:
 
-## Video stream
+| Version   | Type                   |
+| --------- | ---------------------- |
+| 1.16~1.21 | `AdbScrcpyOptions1_16` |
+| 1.22~1.24 | `AdbScrcpyOptions1_22` |
+
+## Use with `@yume-chan/adb`
+
+The the server binary needs to be copied to the device and run on it.
+
+### Push server binary
+
+The `Adb#sync()#write()` method can be used to push files to the device. Read more at `@yume-chan/adb`'s documentation (https://github.com/yume-chan/ya-webadb/tree/main/libraries/adb#readme).
+
+This package also provides the `AdbScrcpyClient.pushServer()` static method as a shortcut, plus it will automatically close the `AdbSync` object on completion.
+
+Example using `write()`:
+
+```ts
+import { AdbScrcpyClient } from '@yume-chan/scrcpy';
+
+const stream: WritableStream<Uint8Array> = AdbScrcpyClient.pushServer(adb);
+const writer = stream.getWriter();
+await writer.write(new Uint8Array(buffer));
+await writer.close();
+```
 
-The data from `onVideoData` event is a raw H.264 stream. You can process it as you want, or use the following built-in decoders to render it in browsers:
+Example using `pipeTo()`:
 
-* WebCodecs decoder: Uses the [WebCodecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API). The video stream will be decoded into `VideoFrame`s and drawn on a 2D canvas.
-* TinyH264 decoder: TinyH264 compiles the old Android H.264 software decoder (now deprecated and removed) into WebAssembly, and wrap it in Web Worker to prevent blocking the main thread. The video stream will be decoded into YUV frames, then converted to RGB using a WebGL shader.
+```ts
+import { WrapReadableStream } from '@yume-chan/adb';
+import { AdbScrcpyClient } from '@yume-chan/scrcpy';
+
+await fetch(SCRCPY_SERVER_URL)
+    // `WrapReadableStream` is required because native `ReadableStream` (from `fetch`)
+    // doesn't support `pipeTo()` non-native `WritableStream`s
+    // (`@yume-chan/adb` is using `web-streams-polyfill`)
+    .then(response => new WrapReadableStream(response.body))
+    .then(stream => stream.pipeTo(AdbScrcpyClient.pushServer(adb)));
+```
 
-| Name              | Chrome | Firefox | Safari | Performance                     | Supported H.264 profile/level |
-| ----------------- | ------ | ------- | ------ | ------------------------------- | ----------------------------- |
-| WebCodecs decoder | 94     | No      | No     | High with Hardware acceleration | High level 5                  |
-| TinyH264 decoder  | 57     | 52      | 11     | Poor                            | Baseline level 4              |
+### Start server on device
 
-TinyH264 decoder needs some extra setup:
+To start the server, use the `AdbScrcpyClient.start()` method. It automatically sets up port forwarding, launches the server, and connects to it.
 
-1. `tinyh264`, `yuv-buffer` and `yuv-canvas` packages are peer dependencies. You must install them separately.
-2. The bundler you use must support the `new Worker(new URL('./worker.js', import.meta.url))` syntax. It's known to work with Webpack 5.
+```js
+import { AdbScrcpyClient, AdbScrcpyOptions1_22, DEFAULT_SERVER_PATH, ScrcpyOptions1_24 } from '@yume-chan/scrcpy';
+import SCRCPY_SERVER_VERSION from '@yume-chan/scrcpy/bin/version.js';
 
-Example usage:
+const client: AdbScrcpyClient = await AdbScrcpyClient.start(
+    adb,
+    DEFAULT_SERVER_PATH,
+    SCRCPY_SERVER_VERSION, // Or provide your own version number
+    new AdbScrcpyOptions1_22(ScrcpyOptions1_24({
+        // options
+    }))
+);
+
+const stdout: ReadableStream<string> = client.stdout;
+const videoPacketStream: ReadableStream<ScrcpyVideoStreamPacket> = client.videoStream;
+const controlMessageSerializer: ScrcpyControlMessageSerializer | undefined = client.controlMessageSerializer;
+const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> | undefined = client.deviceMessageStream;
+
+// to stop the server
+client.close();
+```
+
+## Using other transportation
+
+If you push, start and connect to the server yourself, you can still use this package to serialize/deserialize packets.
+
+### Parsing video packets
+
+Requires a `ReadableStream<Uint8Array>` that reads from the video socket, preserving packet boundaries.
 
 ```ts
-const client = new ScrcpyClient(adb);
-const decoder = new WebCodecsDecoder(); // Or `new TinyH264Decoder()`
-client.onSizeChanged(size => decoder.setSize(size));
-client.onVideoData(data => decoder.feed(data));
-client.start(serverPath, serverVersion, new ScrcpyOptionsX_XX({
-    ...options,
-    codecOptions: new CodecOptions({
-        profile: decoder.maxProfile,
-        level: decoder.maxLevel,
-    }),
-}));
-document.body.appendChild(decoder.element);
+import { ScrcpyOptions1_24, ScrcpyVideoStreamPacket } from '@yume-chan/scrcpy';
+
+const videoStream: ReadableStream<Uint8Array>; // get the stream yourself
+
+const options = new ScrcpyOptions1_24({
+    // use the same version and options
+});
+
+const videoPacketStream: ReadableStream<ScrcpyVideoStreamPacket> = videoStream.pipeThrough(options.createVideoStreamTransformer());
+// Read from `videoPacketStream`
+```
+
+### Sending control messages
+
+Requires a `WritableStream<Uint8Array>` that writes to the control socket.
+
+Control socket is optional if control is not enabled. Video socket and control socket can run completely separately.
+
+```ts
+import { ScrcpyControlMessageSerializer, ScrcpyOptions1_24 } from '@yume-chan/scrcpy';
+
+const controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined // get the stream yourself
+
+const options = new ScrcpyOptions1_24({
+    // use the same version and options
+});
+
+const controlMessageSerializer = new ScrcpyControlMessageSerializer(controlStream.writable, options);
+// Call methods on `controlMessageSerializer`
+controlMessageSerializer.injectText("Hello World!");
 ```
+
+### Reading device messages
+
+Requires a `ReadableStream<Uint8Array>` that reads from the control socket.
+
+```ts
+import { ScrcpyDeviceMessageDeserializeStream, ScrcpyOptions1_24 } from '@yume-chan/scrcpy';
+
+const controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined // get the stream yourself
+
+const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> = controlStream.readable.pipeThrough(new ScrcpyDeviceMessageDeserializeStream());
+```
+
+## Consume the streams
+
+Any `ReadableStream` (`stdout` when using `AdbScrcpyClient`, `videoPacketStream` and `deviceMessageStream` when control is enabled) must be continuously read (even if you don't care about the data), otherwise the whole connection will stall.
+
+```ts
+// when using `AdbScrcpyClient`
+stdout
+    .pipeTo(
+        new WritableStream<string>({
+            write: (line) => {
+                // Handle the stdout line
+            },
+        }),
+    )
+    .catch(() => {})
+    .then(() => {
+        // Handle server exit
+    });
+
+videoPacketStream
+    .pipeTo(new WritableStream<ScrcpyVideoStreamPacket>({
+        write: (packet) => {
+            // Handle the video packet
+        },
+    }))
+    .catch(() => {});
+
+deviceMessageStream
+    .pipeTo(new WritableStream<ScrcpyDeviceMessage>({
+        write: (message) => {
+            // Handle the device message
+        },
+    }))
+    .catch(() => {});
+```
+
+## Video stream
+
+The data from `videoPacketStream` has two types: `configuration` and `frame`. Some fields may not be populated depending on the server version and options.
+
+```ts
+export interface ScrcpyVideoStreamConfigurationPacket {
+    type: 'configuration';
+    data: H264Configuration;
+}
+
+export interface ScrcpyVideoStreamFramePacket {
+    type: 'frame';
+    keyframe?: boolean | undefined;
+    pts?: bigint | undefined;
+    data: Uint8Array;
+}
+```
+
+When `sendFrameMeta: false` is set, `videoPacketStream` only contains `frame` packets, and only the `data` field in it is available. It's commonly used when feeding into decoders like FFmpeg that can parse the H.264 stream itself, or saving to disk directly.
+
+Otherwise, both `configuration` and `frame` packets are available.
+
+* `configuration` packets contain the parsed SPS data, and can be used to initialize a video decoder.
+* `pts` (and `keyframe` field from server version 1.23) fields in `frame` packets are available to help decode the video.
+
+## Decode video stream
+
+`@yume-chan/scrcpy-decoder-tinyh264` and `@yume-chan/scrcpy-decoder-webcodecs` can be used to decode and render the video stream in Browser environments. Refer to their README files for compatibility and usage information.

package/esm/adb/client.d.ts

@@ -0,0 +1,40 @@
+import { Adb, AdbSubprocessProtocol } from '@yume-chan/adb';
+import { ReadableStream, WrapWritableStream, type ReadableWritablePair } from '@yume-chan/stream-extra';
+import { ScrcpyControlMessageSerializer } from '../control/index.js';
+import { type ScrcpyVideoStreamPacket } from '../options/index.js';
+import type { AdbScrcpyOptions } from './options/index.js';
+export declare class AdbScrcpyClient {
+    static pushServer(adb: Adb, path?: string): WrapWritableStream<Uint8Array>;
+    static start(adb: Adb, path: string, version: string, options: AdbScrcpyOptions<any>): Promise<AdbScrcpyClient>;
+    /**
+     * This method will modify the given `options`,
+     * so don't reuse it elsewhere.
+     */
+    static getEncoders(adb: Adb, path: string, version: string, options: AdbScrcpyOptions<any>): Promise<string[]>;
+    /**
+     * This method will modify the given `options`,
+     * so don't reuse it elsewhere.
+     */
+    static getDisplays(adb: Adb, path: string, version: string, options: AdbScrcpyOptions<any>): Promise<number[]>;
+    private process;
+    private _stdout;
+    get stdout(): ReadableStream<string>;
+    get exit(): Promise<number>;
+    private _screenWidth;
+    get screenWidth(): number | undefined;
+    private _screenHeight;
+    get screenHeight(): number | undefined;
+    private _videoStream;
+    get videoStream(): ReadableStream<ScrcpyVideoStreamPacket>;
+    private _controlMessageSerializer;
+    get controlMessageSerializer(): ScrcpyControlMessageSerializer | undefined;
+    private _deviceMessageStream;
+    get deviceMessageStream(): ReadableStream<{
+        type: import("../device-message/type.js").ScrcpyDeviceMessageType.Clipboard;
+        length: number;
+        content: string;
+    }> | undefined;
+    constructor(options: AdbScrcpyOptions<any>, process: AdbSubprocessProtocol, stdout: ReadableStream<string>, videoStream: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined);
+    close(): Promise<void>;
+}
+//# sourceMappingURL=client.d.ts.map

package/esm/adb/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/adb/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAA6B,qBAAqB,EAAW,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAoD,cAAc,EAAqB,kBAAkB,EAA0F,KAAK,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAErQ,OAAO,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AAErE,OAAO,EAAuB,KAAK,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AA0D3D,qBAAa,eAAe;WACV,UAAU,CACpB,GAAG,EAAE,GAAG,EACR,IAAI,SAAsB;WAcV,KAAK,CACrB,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,CAAC,GAAG,CAAC;IA4ElC;;;OAGG;WACiB,WAAW,CAC3B,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,CAAC,GAAG,CAAC,GAC/B,OAAO,CAAC,MAAM,EAAE,CAAC;IAgCpB;;;OAGG;WACiB,WAAW,CAC3B,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,CAAC,GAAG,CAAC,GAC/B,OAAO,CAAC,MAAM,EAAE,CAAC;IA8BpB,OAAO,CAAC,OAAO,CAAwB;IAEvC,OAAO,CAAC,OAAO,CAAyB;IACxC,IAAW,MAAM,2BAA2B;IAE5C,IAAW,IAAI,oBAAgC;IAE/C,OAAO,CAAC,YAAY,CAAqB;IACzC,IAAW,WAAW,uBAAgC;IAEtD,OAAO,CAAC,aAAa,CAAqB;IAC1C,IAAW,YAAY,uBAAiC;IAExD,OAAO,CAAC,YAAY,CAA0C;IAC9D,IAAW,WAAW,4CAAgC;IAEtD,OAAO,CAAC,yBAAyB,CAA6C;IAC9E,IAAW,wBAAwB,+CAA6C;IAEhF,OAAO,CAAC,oBAAoB,CAAkD;IAC9E,IAAW,mBAAmB;;;;mBAAwC;gBAGlE,OAAO,EAAE,gBAAgB,CAAC,GAAG,CAAC,EAC9B,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,EAC9B,WAAW,EAAE,cAAc,CAAC,UAAU,CAAC,EACvC,aAAa,EAAE,oBAAoB,CAAC,UAAU,EAAE,UAAU,CAAC,GAAG,SAAS;IAoB9D,KAAK;CAGrB"}

package/esm/adb/client.js

@@ -0,0 +1,218 @@
+import { AdbSubprocessNoneProtocol } from '@yume-chan/adb';
+import { AbortController, DecodeUtf8Stream, InspectStream, ReadableStream, SplitStringStream, WrapWritableStream, WritableStream } from '@yume-chan/stream-extra';
+import { ScrcpyControlMessageSerializer } from '../control/index.js';
+import { ScrcpyDeviceMessageDeserializeStream } from '../device-message/index.js';
+import { DEFAULT_SERVER_PATH } from '../options/index.js';
+class ArrayToStream extends ReadableStream {
+    array;
+    index = 0;
+    constructor(array) {
+        super({
+            start: async () => {
+                await Promise.resolve();
+                this.array = array;
+            },
+            pull: (controller) => {
+                if (this.index < this.array.length) {
+                    controller.enqueue(this.array[this.index]);
+                    this.index += 1;
+                }
+                else {
+                    controller.close();
+                }
+            },
+        });
+    }
+}
+class ConcatStream extends ReadableStream {
+    streams;
+    index = 0;
+    reader;
+    constructor(...streams) {
+        super({
+            start: async (controller) => {
+                await Promise.resolve();
+                this.streams = streams;
+                this.advance(controller);
+            },
+            pull: async (controller) => {
+                const result = await this.reader.read();
+                if (!result.done) {
+                    controller.enqueue(result.value);
+                    return;
+                }
+                this.advance(controller);
+            }
+        });
+    }
+    advance(controller) {
+        if (this.index < this.streams.length) {
+            this.reader = this.streams[this.index].getReader();
+            this.index += 1;
+        }
+        else {
+            controller.close();
+        }
+    }
+}
+export class AdbScrcpyClient {
+    static pushServer(adb, path = DEFAULT_SERVER_PATH) {
+        let sync;
+        return new WrapWritableStream({
+            async start() {
+                sync = await adb.sync();
+                return sync.write(path);
+            },
+            async close() {
+                await sync.dispose();
+            },
+        });
+    }
+    static async start(adb, path, version, options) {
+        const connection = options.createConnection(adb);
+        let process;
+        try {
+            await connection.initialize();
+            process = await adb.subprocess.spawn([
+                // cspell: disable-next-line
+                `CLASSPATH=${path}`,
+                'app_process',
+                /* unused */ '/',
+                'com.genymobile.scrcpy.Server',
+                version,
+                ...options.formatServerArguments(),
+            ], {
+                // Scrcpy server doesn't use stderr,
+                // so disable Shell Protocol to simplify processing
+                protocols: [AdbSubprocessNoneProtocol],
+            });
+            const stdout = process.stdout
+                .pipeThrough(new DecodeUtf8Stream())
+                .pipeThrough(new SplitStringStream('\n'));
+            // Read stdout, otherwise `process.exit` won't resolve.
+            const output = [];
+            const abortController = new AbortController();
+            const pipe = stdout
+                .pipeTo(new WritableStream({
+                write(chunk) {
+                    output.push(chunk);
+                }
+            }), {
+                signal: abortController.signal,
+                preventCancel: true,
+            })
+                .catch(() => { });
+            const result = await Promise.race([
+                process.exit,
+                connection.getStreams(),
+            ]);
+            if (typeof result === 'number') {
+                const error = new Error('scrcpy server exited prematurely');
+                error.output = output;
+                throw error;
+            }
+            abortController.abort();
+            await pipe;
+            const [videoStream, controlStream] = result;
+            return new AdbScrcpyClient(options, process, new ConcatStream(new ArrayToStream(output), stdout), videoStream, controlStream);
+        }
+        catch (e) {
+            await process?.kill();
+            throw e;
+        }
+        finally {
+            connection.dispose();
+        }
+    }
+    /**
+     * This method will modify the given `options`,
+     * so don't reuse it elsewhere.
+     */
+    static async getEncoders(adb, path, version, options) {
+        // Provide an invalid encoder name
+        // So the server will return all available encoders
+        options.value.encoderName = '_';
+        // Disable control for faster connection in 1.22+
+        options.value.control = false;
+        options.value.sendDeviceMeta = false;
+        options.value.sendDummyByte = false;
+        // Scrcpy server will open connections, before initializing encoder
+        // Thus although an invalid encoder name is given, the start process will success
+        const client = await AdbScrcpyClient.start(adb, path, version, options);
+        const encoderNameRegex = options.getOutputEncoderNameRegex();
+        const encoders = [];
+        await client.stdout.pipeTo(new WritableStream({
+            write(line) {
+                const match = line.match(encoderNameRegex);
+                if (match) {
+                    encoders.push(match[1]);
+                }
+            },
+        }));
+        return encoders;
+    }
+    /**
+     * This method will modify the given `options`,
+     * so don't reuse it elsewhere.
+     */
+    static async getDisplays(adb, path, version, options) {
+        // Similar to `getEncoders`, pass an invalid option and parse the output
+        options.value.displayId = -1;
+        options.value.control = false;
+        options.value.sendDeviceMeta = false;
+        options.value.sendDummyByte = false;
+        try {
+            // Server will exit before opening connections when an invalid display id was given.
+            await AdbScrcpyClient.start(adb, path, version, options);
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                const output = e.output;
+                const displayIdRegex = /\s+scrcpy --display (\d+)/;
+                const displays = [];
+                for (const line of output) {
+                    const match = line.match(displayIdRegex);
+                    if (match) {
+                        displays.push(Number.parseInt(match[1], 10));
+                    }
+                }
+                return displays;
+            }
+        }
+        throw new Error('failed to get displays');
+    }
+    process;
+    _stdout;
+    get stdout() { return this._stdout; }
+    get exit() { return this.process.exit; }
+    _screenWidth;
+    get screenWidth() { return this._screenWidth; }
+    _screenHeight;
+    get screenHeight() { return this._screenHeight; }
+    _videoStream;
+    get videoStream() { return this._videoStream; }
+    _controlMessageSerializer;
+    get controlMessageSerializer() { return this._controlMessageSerializer; }
+    _deviceMessageStream;
+    get deviceMessageStream() { return this._deviceMessageStream; }
+    constructor(options, process, stdout, videoStream, controlStream) {
+        this.process = process;
+        this._stdout = stdout;
+        this._videoStream = videoStream
+            .pipeThrough(options.createVideoStreamTransformer())
+            .pipeThrough(new InspectStream(packet => {
+            if (packet.type === 'configuration') {
+                this._screenWidth = packet.data.croppedWidth;
+                this._screenHeight = packet.data.croppedHeight;
+            }
+        }));
+        if (controlStream) {
+            this._controlMessageSerializer = new ScrcpyControlMessageSerializer(controlStream.writable, options);
+            this._deviceMessageStream = controlStream.readable.pipeThrough(new ScrcpyDeviceMessageDeserializeStream());
+        }
+    }
+    async close() {
+        await this.process.kill();
+    }
+}
+//# sourceMappingURL=client.js.map