@yume-chan/scrcpy 0.0.18 → 0.0.20

package/CHANGELOG.json

@@ -1,6 +1,39 @@
 {
   "name": "@yume-chan/scrcpy",
   "entries": [
+    {
+      "version": "0.0.20",
+      "tag": "@yume-chan/scrcpy_v0.0.20",
+      "date": "Mon, 05 Jun 2023 02:51:41 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Add support for Scrcpy 2.0. New features including audio forwarding (supports PCM, AAC and OPUS encoding) and other video codecs (supports H.264 and H.265, AV1 not supported). Read the PR for new options and breaking changes. ([#495](https://github.com/yume-chan/ya-webadb/pull/495))"
+          },
+          {
+            "comment": "Move ADB related code to `@yume-chan/adb-scrcpy` package. This package now only implements the Scrcpy protocol."
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.19",
+      "tag": "@yume-chan/scrcpy_v0.0.19",
+      "date": "Sun, 09 Apr 2023 05:55:33 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Change `AdbScrcpyClient#pushServer` to take a `ReadableStream<Uint8Array>` instead of returning a `WritableStream<Uint8Array>`"
+          },
+          {
+            "comment": "Add `AdbReverseNotSupportedError` handling and automatically switch to forward tunnel in `AdbScrcpyClient`."
+          },
+          {
+            "comment": "Update `AndroidKeyCode` enum to align with Web `KeyboardEvent.code`"
+          }
+        ]
+      }
+    },
     {
       "version": "0.0.18",
       "tag": "@yume-chan/scrcpy_v0.0.18",

package/CHANGELOG.md

@@ -1,6 +1,23 @@
 # Change Log - @yume-chan/scrcpy
 
-This log was last generated on Wed, 25 Jan 2023 21:33:49 GMT and should not be manually modified.
+This log was last generated on Mon, 05 Jun 2023 02:51:41 GMT and should not be manually modified.
+
+## 0.0.20
+Mon, 05 Jun 2023 02:51:41 GMT
+
+### Updates
+
+- Add support for Scrcpy 2.0. New features including audio forwarding (supports PCM, AAC and OPUS encoding) and other video codecs (supports H.264 and H.265, AV1 not supported). Read the PR for new options and breaking changes. ([#495](https://github.com/yume-chan/ya-webadb/pull/495))
+- Move ADB related code to `@yume-chan/adb-scrcpy` package. This package now only implements the Scrcpy protocol.
+
+## 0.0.19
+Sun, 09 Apr 2023 05:55:33 GMT
+
+### Updates
+
+- Change `AdbScrcpyClient#pushServer` to take a `ReadableStream<Uint8Array>` instead of returning a `WritableStream<Uint8Array>`
+- Add `AdbReverseNotSupportedError` handling and automatically switch to forward tunnel in `AdbScrcpyClient`.
+- Update `AndroidKeyCode` enum to align with Web `KeyboardEvent.code`
 
 ## 0.0.18
 Wed, 25 Jan 2023 21:33:49 GMT

package/README.md

@@ -1,79 +1,94 @@
 # @yume-chan/scrcpy
 
-TypeScript implementation of [Scrcpy](https://github.com/Genymobile/scrcpy) client.
+TypeScript library to communicate with [Scrcpy](https://github.com/Genymobile/scrcpy) server.
 
 It's compatible with the official Scrcpy server binaries.
 
-**WARNING:** The public API is UNSTABLE. If you have any questions, please open an issue.
+**WARNING:** The public API is UNSTABLE. Open a GitHub discussion if you have any questions.
 
-- [Basic information](#basic-information)
-- [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)
-- [Server versions](#server-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)
-- [Always read the streams](#always-read-the-streams)
-- [Video stream](#video-stream)
-- [Decode video stream](#decode-video-stream)
+-   [How does Scrcpy work](#how-does-scrcpy-work)
+-   [What does this package do](#what-does-this-package-do)
+-   [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)
+-   [Server versions](#server-versions)
+-   [Reading and writing packets](#reading-and-writing-packets)
+    -   [Reading video/audio packets](#reading-videoaudio-packets)
+    -   [Sending control messages](#sending-control-messages)
+    -   [Reading device messages](#reading-device-messages)
+-   [Always read all streams](#always-read-all-streams)
+-   [Video/audio stream](#videoaudio-stream)
+-   [Decode video stream](#decode-video-stream)
 
-## Basic information
+## How does Scrcpy work
 
-Although Scrcpy doesn't install any App on the device, it does have a server binary executable to be run on the device.
+Scrcpy has two parts: a client and a server.
 
-With the official Scrcpy client and server, the client uses ADB to transfer the server binary file to the device, run it, and communicate with it via ADB tunnel (the bootstrap process).
+The server is a Java application (but not an Android app) that runs on the device to capture the video and audio, and send them to the client.
 
-This package provides types that can serialize and deserialize Scrcpy protocol messages, but it generally requires you to do the bootstrapping and provide the data stream to the server.
+The client receives captured video and audio data, and renders them on computer.
 
-If you are also using `@yume-chan/adb`, this package has a helper class that can complete the bootstrap process using it, doing what the official client does.
+The official Scrcpy client also spawns Google ADB executable to set up the reverse tunnel, push the server binary to the device, and start the server.
 
-**NOTE:** `@yume-chan/adb` is a peer dependency, you need to install it yourself. Only those types whose names begin with `Adb` requires `@yume-chan/adb`.
+## What does this package do
+
+This package can't push nor start the server, nor render the video and audio. It only provides APIs to communicate with the server.
+
+`@yume-chan/adb-scrcpy` package is a wrapper of this package, provides integration with `@yume-chan/adb` package, and can push, start, and stop the server.
 
 ## Prepare server binary
 
-This package doesn't include the server binary. It's compatible with many versions of the official server binary, but may not work with future versions due to protocol changes.
+This package is compatible with many versions of the official server binary, but it doesn't include the server binary itself.
 
-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.
+You can download the server binary from official releases (https://github.com/Genymobile/scrcpy/releases), or use the included `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).
 
 ### `fetch-scrcpy-server`
 
-This package includes a script that downloads the server binary from official releases for you.
+This script downloads the server binary from official releases for you.
 
-The `gh-release-fetch@3` package is a peer dependency for this script, thus requires separated installation.
+Before using this script, install `gh-release-fetch@3` package separately:
+
+```sh
+npm install --save-dev gh-release-fetch@3
+```
 
 Usage:
 
 ```
-$ npx fetch-scrcpy-server <version>
+npx fetch-scrcpy-server <version>
 ```
 
 For example:
 
 ```
-$ npx fetch-scrcpy-server 1.25
+npx fetch-scrcpy-server 1.25
 ```
 
-It can also be added to the `postinstall` script in `package.json`, so running `npm install` will automatically invoke the script:
+Add it to `scripts.postinstall` in your `package.json`, so running `npm install` automatically invokes the script:
 
 ```json
-"scripts": {
-    "postinstall": "fetch-scrcpy-server 1.25",
-},
+{
+    "scripts": {
+        "postinstall": "fetch-scrcpy-server 1.25"
+    }
+}
 ```
 
-The server binary will be named `bin/scrcpy-server` in this package's installation directory (usually in `node_modules`).
+The server binary will be saved to `bin/scrcpy-server` in this package's installation directory (usually in `node_modules`).
+
+It will also save 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.25"
+```
 
 ### Use the server binary
 
@@ -84,27 +99,34 @@ 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 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);
 ```
 
 #### Node.js ES module
 
+Without the `import.meta.resolve` feature:
+
 ```ts
-import fs from 'node:fs/promises';
-import { createRequire } from 'node:module';
+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 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.
+With `import.meta.resolve` feature (requires `--experimental-import-meta-resolve` command line flag for Node.js 12.6.0+):
 
 ```ts
-const path: string = import.meta.resolve('@yume-chan/scrcpy/bin/scrcpy-server');
+import fs from "node:fs/promises";
+
+const path: string = await import.meta.resolve(
+    "@yume-chan/scrcpy/bin/scrcpy-server"
+);
+const buffer: Buffer = await fs.readFile(path);
 ```
 
 #### Webpack 4
@@ -112,8 +134,10 @@ const path: string = import.meta.resolve('@yume-chan/scrcpy/bin/scrcpy-server');
 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());
+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((response) =>
+    response.arrayBuffer()
+);
 ```
 
 #### Webpack 5
@@ -121,127 +145,64 @@ const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then(res => res.array
 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.25"
+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((response) =>
+    response.arrayBuffer()
+);
 ```
 
 ## Server versions
 
-Scrcpy protocol change over time, and are usually not backwards compatible. This package supports multiple server versions (or ranges), and uses different option types to choose different behaviors. Using incorrect option version usually results in errors.
+Scrcpy protocol changes over time, and are usually not backwards compatible. This package supports multiple server versions (ranges), and uses different option types to choose different behaviors. Using incorrect option version usually results in errors.
 
 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.16      | `ScrcpyOptions1_16` |
+| 1.17      | `ScrcpyOptions1_17` |
 | 1.18~1.20 | `ScrcpyOptions1_18` |
 | 1.21      | `ScrcpyOptions1_21` |
 | 1.22      | `ScrcpyOptions1_22` |
 | 1.23      | `ScrcpyOptions1_23` |
 | 1.24      | `ScrcpyOptions1_24` |
 | 1.25      | `ScrcpyOptions1_25` |
+| 2.0       | `ScrcpyOptions2_0`  |
 
-When using `AdbScrcpyClient`, there are `AdbScrcpyOptions` containing `@yume-chan/adb` specific options:
-
-| Version   | Type                   |
-| --------- | ---------------------- |
-| 1.16~1.21 | `AdbScrcpyOptions1_16` |
-| 1.22~1.25 | `AdbScrcpyOptions1_22` |
-
-## Use with `@yume-chan/adb`
-
-`@yume-chan/adb` is a TypeScript ADB implementation that can run on Web browser. It can be used to bootstrap the server on a device.
+## Reading and writing packets
 
-### Push server binary
+This packets operates on Web Streams API streams.
 
-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';
+**NOTE:** Web Streams API streams usually can't pipe between different implementations. This package by default uses the native implementation on `globalThis`, and `web-streams-polyfill` otherwise. If you are using another implementation, or simply not sure, wrap your streams using the `WrapReadableStream` and `WrapWritableStream` types from `@yume-chan/stream-extra` package.
 
-const stream: WritableStream<Uint8Array> = AdbScrcpyClient.pushServer(adb);
-const writer = stream.getWriter();
-await writer.write(new Uint8Array(buffer));
-await writer.close();
-```
+### Reading video/audio packets
 
-Example using `pipeTo()`:
+Requires a `ReadableStream<Uint8Array>` that reads from the video socket.
 
 ```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)));
-```
-
-### Start server on device
-
-To start the server, use the `AdbScrcpyClient.start()` method. It automatically sets up port forwarding, launches the server, and connects to it.
-
-```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';
-
-const client: AdbScrcpyClient = await AdbScrcpyClient.start(
-    adb,
-    DEFAULT_SERVER_PATH,
-    SCRCPY_SERVER_VERSION, // If server binary was downloaded manually, must provide the correct version
-    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;
+import { ScrcpyOptions1_25, ScrcpyVideoStreamPacket } from "@yume-chan/scrcpy";
 
-// 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.
-
-**NOTE:** Because this package uses `web-streams-polyfill` NPM package's Web Streams API implementation, the provided `ReadableStream` must also be from `web-streams-polyfill` (or another polyfill that doesn't check object prototype when piping).
-
-```ts
-import { ScrcpyOptions1_24, ScrcpyVideoStreamPacket } from '@yume-chan/scrcpy';
+const options = new ScrcpyOptions1_25({
+    // use the same version and options when starting the server
+});
 
 const videoStream: ReadableStream<Uint8Array>; // get the stream yourself
 
-const options = new ScrcpyOptions1_24({
-    // use the same version and options
-});
+// Parse video socket metadata
+// Use `videoStream2` instead of `videoStream` from now on
+const { metadata, stream: videoStream2 } =
+    await options.parseVideoStreamMetadata(videoStream);
 
-const videoPacketStream: ReadableStream<ScrcpyVideoStreamPacket> = videoStream.pipeThrough(options.createVideoStreamTransformer());
+const videoPacketStream: ReadableStream<ScrcpyMediaStreamPacket> =
+    videoStream2.pipeThrough(options.createMediaStreamTransformer());
 // Read from `videoPacketStream`
 ```
 
+Read audio stream is similar, but uses `parseVideoStreamMetadata` instead.
+
 ### Sending control messages
 
 Requires a `WritableStream<Uint8Array>` that writes to the control socket.
@@ -249,38 +210,47 @@ 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
+import {
+    ScrcpyControlMessageWriter,
+    ScrcpyOptions1_25,
+} from "@yume-chan/scrcpy";
 
-const options = new ScrcpyOptions1_24({
-    // use the same version and options
+const options = new ScrcpyOptions1_25({
+    // use the same version and options when starting the server
 });
 
-const controlMessageSerializer = new ScrcpyControlMessageSerializer(controlStream.writable, options);
-// Call methods on `controlMessageSerializer`
-controlMessageSerializer.injectText("Hello World!");
+const controlStream: ReadableWritablePair<Uint8Array, Uint8Array>; // get the stream yourself
+
+const controlMessageWriter = new ScrcpyControlMessageWriter(
+    controlStream.writable.getWriter(),
+    options
+);
+
+// Call methods on `controlMessageWriter`
+controlMessageWriter.injectText("Hello World!");
 ```
 
 ### Reading device messages
 
 Requires a `ReadableStream<Uint8Array>` that reads from the control socket.
 
-**NOTE:** Because this package uses `web-streams-polyfill` NPM package's Web Streams API implementation, the provided `ReadableStream` must also be from `web-streams-polyfill` (or another polyfill that doesn't check object prototype when piping).
-
 ```ts
-import { ScrcpyDeviceMessageDeserializeStream, ScrcpyOptions1_24 } from '@yume-chan/scrcpy';
+import {
+    ScrcpyDeviceMessageDeserializeStream,
+    ScrcpyOptions1_24,
+} from "@yume-chan/scrcpy";
 
-const controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined // get the stream yourself
+const controlStream: ReadableWritablePair<Uint8Array, Uint8Array>; // get the stream yourself
 
-const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> = controlStream.readable.pipeThrough(new ScrcpyDeviceMessageDeserializeStream());
+const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> =
+    controlStream.readable.pipeThrough(
+        new ScrcpyDeviceMessageDeserializeStream()
+    );
 ```
 
-## Always read the streams
+## Always read all streams
 
-In Web Streams API, `ReadableStream` will block its upstream when too many chunks are kept not read. If multiple streams are from the same upstream source, block one stream means blocking all of them.
-
-For Scrcpy, usually all streams are originated from the same ADB connection (either USB or TCP), so it's important to always read from all streams, even if you don't care about their data.
+In Web Streams API, pipes will block its upstream when downstream's queue is full (back-pressure mechanism). If multiple streams are separated from the same source (for example, all Scrcpy streams are from the same USB or TCP connection), blocking one stream means blocking all of them, so it's important to always read from all streams, even if you don't care about their data.
 
 ```ts
 // when using `AdbScrcpyClient`
@@ -290,7 +260,7 @@ stdout
             write: (line) => {
                 // Handle or ignore the stdout line
             },
-        }),
+        })
     )
     .catch(() => {})
     .then(() => {
@@ -298,47 +268,51 @@ stdout
     });
 
 videoPacketStream
-    .pipeTo(new WritableStream<ScrcpyVideoStreamPacket>({
-        write: (packet) => {
-            // Handle or ignore the video packet
-        },
-    }))
+    .pipeTo(
+        new WritableStream<ScrcpyVideoStreamPacket>({
+            write: (packet) => {
+                // Handle or ignore the video packet
+            },
+        })
+    )
     .catch(() => {});
 
 deviceMessageStream
-    .pipeTo(new WritableStream<ScrcpyDeviceMessage>({
-        write: (message) => {
-            // Handle or ignore the device message
-        },
-    }))
+    .pipeTo(
+        new WritableStream<ScrcpyDeviceMessage>({
+            write: (message) => {
+                // Handle or ignore the device message
+            },
+        })
+    )
     .catch(() => {});
 ```
 
-## Video stream
+## Video/audio stream
 
-The data from `videoPacketStream` has two types: `configuration` and `frame`. Some fields may not be populated depending on the server version and options.
+The data from `createMediaStreamTransformer()` has two types: `configuration` and `data`.
 
 ```ts
-export interface ScrcpyVideoStreamConfigurationPacket {
-    type: 'configuration';
-    data: H264Configuration;
+export interface ScrcpyMediaStreamConfigurationPacket {
+    type: "configuration";
+    data: Uint8Array;
 }
 
-export interface ScrcpyVideoStreamFramePacket {
-    type: 'frame';
-    keyframe?: boolean | undefined;
-    pts?: bigint | undefined;
+export interface ScrcpyMediaStreamDataPacket {
+    type: "data";
+    keyframe?: boolean;
+    pts?: bigint;
     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.
+When `sendFrameMeta: false` is set, there will be no `configuration` packets, and no `keyframe` and `pts` fields in `data` packets. It's commonly used with decoders that can parse the media stream itself like FFmpeg, or saved unprocessed.
 
-Otherwise, both `configuration` and `frame` packets are available.
+Otherwise, both `configuration` and `data` 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.
+-   `configuration` packet will be the first packet, and contains codec information. It will occasionally be sent again if the stream configuration changes.
+-   `pts` (and `keyframe` field from server version 1.23) fields in `data` packets are available to help decode the stream.
 
 ## 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.
+`@yume-chan/scrcpy-decoder-tinyh264` and `@yume-chan/scrcpy-decoder-webcodecs` can be used to decode and render the video stream in browsers. Refer to their README files for compatibility and usage information.

package/bin/version.d.ts

@@ -1 +1 @@
-export default '1.25';
+export default '2.0';

package/bin/version.js

@@ -1 +1 @@
-export default '1.25';
+export default '2.0';

package/esm/codec/av1.d.ts

@@ -0,0 +1,33 @@
+export declare enum AndroidAv1Profile {
+    Main8 = 1,
+    Main10 = 2,
+    Main10Hdr10 = 4096,
+    Main10Hdr10Plus = 8192
+}
+export declare enum AndroidAv1Level {
+    Level2 = 1,
+    Level21 = 2,
+    Level22 = 4,
+    Level23 = 8,
+    Level3 = 16,
+    Level31 = 32,
+    Level32 = 64,
+    Level33 = 128,
+    Level4 = 256,
+    Level41 = 512,
+    Level42 = 1024,
+    Level43 = 2048,
+    Level5 = 4096,
+    Level51 = 8192,
+    Level52 = 16384,
+    Level53 = 32768,
+    Level6 = 65536,
+    Level61 = 131072,
+    Level62 = 262144,
+    Level63 = 524288,
+    Level7 = 1048576,
+    Level71 = 2097152,
+    Level72 = 4194304,
+    Level73 = 8388608
+}
+//# sourceMappingURL=av1.d.ts.map

package/esm/codec/av1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"av1.d.ts","sourceRoot":"","sources":["../../src/codec/av1.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB;IACzB,KAAK,IAAS;IACd,MAAM,IAAS;IACf,WAAW,OAAU;IACrB,eAAe,OAAU;CAC5B;AAED,oBAAY,eAAe;IACvB,MAAM,IAAS;IACf,OAAO,IAAS;IAChB,OAAO,IAAS;IAChB,OAAO,IAAS;IAChB,MAAM,KAAS;IACf,OAAO,KAAS;IAChB,OAAO,KAAS;IAChB,OAAO,MAAS;IAChB,MAAM,MAAS;IACf,OAAO,MAAS;IAChB,OAAO,OAAU;IACjB,OAAO,OAAU;IACjB,MAAM,OAAU;IAChB,OAAO,OAAU;IACjB,OAAO,QAAU;IACjB,OAAO,QAAU;IACjB,MAAM,QAAU;IAChB,OAAO,SAAU;IACjB,OAAO,SAAU;IACjB,OAAO,SAAU;IACjB,MAAM,UAAU;IAChB,OAAO,UAAU;IACjB,OAAO,UAAU;IACjB,OAAO,UAAU;CACpB"}