@yume-chan/scrcpy 0.0.19 → 0.0.20

package/CHANGELOG.json

@@ -1,6 +1,21 @@
 {
   "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",

package/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Change Log - @yume-chan/scrcpy
 
-This log was last generated on Sun, 09 Apr 2023 05:55:33 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

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
 
@@ -91,6 +106,8 @@ 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";
@@ -101,9 +118,7 @@ const path: string = createRequire(import.meta.url).resolve(
 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.
-
-Or with the `--experimental-import-meta-resolve` command line flag, you can use `import.meta.resolve`:
+With `import.meta.resolve` feature (requires `--experimental-import-meta-resolve` command line flag for Node.js 12.6.0+):
 
 ```ts
 import fs from "node:fs/promises";
@@ -139,143 +154,55 @@ const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then((response) =>
 );
 ```
 
-### 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"
-```
-
 ## 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`
+## Reading and writing packets
 
-`@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.
+This packets operates on Web Streams API streams.
 
-### Push server binary
+**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.
 
-The `AdbSync#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).
+### Reading video/audio packets
 
-This package also provides the `AdbScrcpyClient.pushServer()` static method as a shortcut, plus it will automatically close the `AdbSync` object on completion.
-
-Example using a `ReadableStream`:
-
-```ts
-import { WrapReadableStream } from "@yume-chan/adb";
-import { AdbScrcpyClient } from "@yume-chan/scrcpy";
-
-await AdbScrcpyClient.pushServer(
-    adb,
-    await fetch(SCRCPY_SERVER_URL).then(
-        // `WrapReadableStream` is required because native `ReadableStream` (from `fetch`)
-        // doesn't support `pipeTo()` non-native `WritableStream`s
-        // (`@yume-chan/adb` is using `web-streams-polyfill`)
-        (response) => new WrapReadableStream(response.body)
-    )
-);
-```
-
-Example using an `ArrayBuffer`:
+Requires a `ReadableStream<Uint8Array>` that reads from the video socket.
 
 ```ts
-import { AdbScrcpyClient } from "@yume-chan/scrcpy";
-
-await AdbScrcpyClient.pushServer(
-    adb,
-    new ReadableStream({
-        start(controller) {
-            controller.enqueue(new Uint8Array(buffer));
-            controller.end();
-        },
-    })
-);
-```
-
-### 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,
-    // If server binary was downloaded manually, must provide the correct version
-    SCRCPY_SERVER_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;
-
-// to stop the server
-client.close();
-```
+import { ScrcpyOptions1_25, ScrcpyVideoStreamPacket } from "@yume-chan/scrcpy";
 
-## 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.
@@ -284,37 +211,36 @@ Control socket is optional if control is not enabled. Video socket and control s
 
 ```ts
 import {
-    ScrcpyControlMessageSerializer,
-    ScrcpyOptions1_24,
+    ScrcpyControlMessageWriter,
+    ScrcpyOptions1_25,
 } 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 options = new ScrcpyOptions1_25({
+    // use the same version and options when starting the server
 });
 
-const controlMessageSerializer = new ScrcpyControlMessageSerializer(
-    controlStream.writable,
+const controlStream: ReadableWritablePair<Uint8Array, Uint8Array>; // get the stream yourself
+
+const controlMessageWriter = new ScrcpyControlMessageWriter(
+    controlStream.writable.getWriter(),
     options
 );
-// Call methods on `controlMessageSerializer`
-controlMessageSerializer.injectText("Hello World!");
+
+// 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";
 
-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(
@@ -322,11 +248,9 @@ const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> =
     );
 ```
 
-## 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`
@@ -364,31 +288,31 @@ deviceMessageStream
     .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 {
+export interface ScrcpyMediaStreamConfigurationPacket {
     type: "configuration";
-    data: H264Configuration;
+    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/esm/codec/h264.d.ts

@@ -31,27 +31,7 @@ export declare enum AndroidAvcLevel {
     Level61 = 262144,
     Level62 = 524288
 }
-/**
- * Split NAL units from a H.264/H.265 Annex B stream.
- *
- * The input is not modified.
- * The returned NAL units are views of the input (no memory allocation nor copy),
- * and still contains emulation prevention bytes.
- *
- * This methods returns a generator, so it can be stopped immediately
- * after the interested NAL unit is found.
- */
-export declare function naluSplit(buffer: Uint8Array): Generator<Uint8Array>;
-/**
- * Remove emulation prevention bytes from a H.264/H.265 NAL Unit.
- *
- * The input is not modified.
- * If the input doesn't contain any emulation prevention bytes,
- * the input is returned as-is.
- * Otherwise, a new `Uint8Array` is created and returned.
- */
-export declare function naluRemoveEmulation(buffer: Uint8Array): Uint8Array;
-export declare function h264ParseSequenceParameterSet(buffer: Uint8Array): {
+export declare function h264ParseSequenceParameterSet(nalu: Uint8Array): {
     profile_idc: number;
     constraint_set: number;
     constraint_set0_flag: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"h264.d.ts","sourceRoot":"","sources":["../../src/codec/h264.ts"],"names":[],"mappings":"AAKA,oBAAY,iBAAiB;IACzB,QAAQ,IAAS;IACjB,IAAI,IAAS;IACb,QAAQ,IAAS;IACjB,IAAI,IAAS;IACb,MAAM,KAAS;IACf,OAAO,KAAS;IAChB,OAAO,KAAS;IAChB,mBAAmB,QAAU;IAC7B,eAAe,SAAU;CAC5B;AAED,oBAAY,eAAe;IACvB,MAAM,IAAS;IACf,OAAO,IAAS;IAChB,OAAO,IAAS;IAChB,OAAO,IAAS;IAChB,OAAO,KAAS;IAChB,MAAM,KAAS;IACf,OAAO,KAAS;IAChB,OAAO,MAAS;IAChB,MAAM,MAAS;IACf,OAAO,MAAS;IAChB,OAAO,OAAU;IACjB,MAAM,OAAU;IAChB,OAAO,OAAU;IACjB,OAAO,OAAU;IACjB,MAAM,QAAU;IAChB,OAAO,QAAU;IACjB,OAAO,QAAU;IACjB,MAAM,SAAU;IAChB,OAAO,SAAU;IACjB,OAAO,SAAU;CACpB;AAmDD;;;;;;;;;GASG;AACH,wBAAiB,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC,CAiFpE;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU,cA0HrD;AAID,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,UAAU;;;;;;;;;;;;;;;;;;;EAsK/D;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,UAAU;;;EAgCzD;AAED,MAAM,WAAW,iBAAiB;IAC9B,mBAAmB,EAAE,UAAU,CAAC;IAChC,oBAAoB,EAAE,UAAU,CAAC;IAEjC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IAEnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IAEtB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAElB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IAEnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,iBAAiB,CA6C1E"}
+{"version":3,"file":"h264.d.ts","sourceRoot":"","sources":["../../src/codec/h264.ts"],"names":[],"mappings":"AAOA,oBAAY,iBAAiB;IACzB,QAAQ,IAAS;IACjB,IAAI,IAAS;IACb,QAAQ,IAAS;IACjB,IAAI,IAAS;IACb,MAAM,KAAS;IACf,OAAO,KAAS;IAChB,OAAO,KAAS;IAChB,mBAAmB,QAAU;IAC7B,eAAe,SAAU;CAC5B;AAED,oBAAY,eAAe;IACvB,MAAM,IAAS;IACf,OAAO,IAAS;IAChB,OAAO,IAAS;IAChB,OAAO,IAAS;IAChB,OAAO,KAAS;IAChB,MAAM,KAAS;IACf,OAAO,KAAS;IAChB,OAAO,MAAS;IAChB,MAAM,MAAS;IACf,OAAO,MAAS;IAChB,OAAO,OAAU;IACjB,MAAM,OAAU;IAChB,OAAO,OAAU;IACjB,OAAO,OAAU;IACjB,MAAM,QAAU;IAChB,OAAO,QAAU;IACjB,OAAO,QAAU;IACjB,MAAM,SAAU;IAChB,OAAO,SAAU;IACjB,OAAO,SAAU;CACpB;AAWD,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,UAAU;;;;;;;;;;;;;;;;;;;EAmK7D;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,UAAU;;;EAgCzD;AAED,MAAM,WAAW,iBAAiB;IAC9B,mBAAmB,EAAE,UAAU,CAAC;IAChC,oBAAoB,EAAE,UAAU,CAAC;IAEjC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IAEnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IAEtB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,iBAAiB,CA2C1E"}