@yume-chan/scrcpy 0.0.13 → 0.0.16

package/src/codec.ts

@@ -1,35 +1,35 @@
-// From https://developer.android.com/reference/android/media/MediaCodecInfo.CodecProfileLevel
-export enum AndroidCodecProfile {
-    Baseline = 0x01,
-    Main = 0x02,
-    Extended = 0x04,
-    High = 0x08,
-    High10 = 0x10,
-    High422 = 0x20,
-    High444 = 0x40,
-    ConstrainedBaseline = 0x10000,
-    ConstrainedHigh = 0x80000,
-}
-
-export enum AndroidCodecLevel {
-    Level1 = 0x01,
-    Level1b = 0x02,
-    Level11 = 0x04,
-    Level12 = 0x08,
-    Level13 = 0x10,
-    Level2 = 0x20,
-    Level21 = 0x40,
-    Level22 = 0x80,
-    Level3 = 0x100,
-    Level31 = 0x200,
-    Level32 = 0x400,
-    Level4 = 0x800,
-    Level41 = 0x1000,
-    Level42 = 0x2000,
-    Level5 = 0x4000,
-    Level51 = 0x8000,
-    Level52 = 0x10000,
-    Level6 = 0x20000,
-    Level61 = 0x40000,
-    Level62 = 0x80000,
-}
+// From https://developer.android.com/reference/android/media/MediaCodecInfo.CodecProfileLevel
+export enum AndroidCodecProfile {
+    Baseline = 0x01,
+    Main = 0x02,
+    Extended = 0x04,
+    High = 0x08,
+    High10 = 0x10,
+    High422 = 0x20,
+    High444 = 0x40,
+    ConstrainedBaseline = 0x10000,
+    ConstrainedHigh = 0x80000,
+}
+
+export enum AndroidCodecLevel {
+    Level1 = 0x01,
+    Level1b = 0x02,
+    Level11 = 0x04,
+    Level12 = 0x08,
+    Level13 = 0x10,
+    Level2 = 0x20,
+    Level21 = 0x40,
+    Level22 = 0x80,
+    Level3 = 0x100,
+    Level31 = 0x200,
+    Level32 = 0x400,
+    Level4 = 0x800,
+    Level41 = 0x1000,
+    Level42 = 0x2000,
+    Level5 = 0x4000,
+    Level51 = 0x8000,
+    Level52 = 0x10000,
+    Level6 = 0x20000,
+    Level61 = 0x40000,
+    Level62 = 0x80000,
+}

package/src/connection.ts

@@ -1,145 +1,148 @@
-import type { Adb, AdbSocket } from "@yume-chan/adb";
-import type { Disposable } from "@yume-chan/event";
-import type { ValueOrPromise } from "@yume-chan/struct";
-import { delay } from "./utils.js";
-
-export interface ScrcpyClientConnectionOptions {
-    control: boolean;
-
-    /**
-     * Write a byte on start to detect connection issues
-     */
-    sendDummyByte: boolean;
-
-    /**
-     * Send device name and size
-     */
-    sendDeviceMeta: boolean;
-}
-
-export abstract class ScrcpyClientConnection implements Disposable {
-    protected device: Adb;
-
-    protected options: ScrcpyClientConnectionOptions;
-
-    public constructor(device: Adb, options: ScrcpyClientConnectionOptions) {
-        this.device = device;
-        this.options = options;
-    }
-
-    public initialize(): ValueOrPromise<void> { }
-
-    public abstract getStreams(): ValueOrPromise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]>;
-
-    public dispose(): void { }
-}
-
-export class ScrcpyClientForwardConnection extends ScrcpyClientConnection {
-    private async connect(): Promise<AdbSocket> {
-        return await this.device.createSocket('localabstract:scrcpy');
-    }
-
-    private async connectAndRetry(): Promise<AdbSocket> {
-        for (let i = 0; i < 100; i++) {
-            try {
-                return await this.connect();
-            } catch (e) {
-                await delay(100);
-            }
-        }
-        throw new Error(`Can't connect to server after 100 retries`);
-    }
-
-    private async connectVideoStream(): Promise<AdbSocket> {
-        const stream = await this.connectAndRetry();
-        if (this.options.sendDummyByte) {
-            const reader = stream.readable.getReader();
-            const { done, value } = await reader.read();
-            // server will write a `0` to signal connection success
-            if (done || value.byteLength !== 1 || value[0] !== 0) {
-                throw new Error('Unexpected response from server');
-            }
-            reader.releaseLock();
-        }
-        return stream;
-    }
-
-    public async getStreams(): Promise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]> {
-        const videoStream = await this.connectVideoStream();
-
-        let controlStream: AdbSocket | undefined;
-        if (this.options.control) {
-            controlStream = await this.connectAndRetry();
-        }
-
-        // Server only writes device meta after control socket is connected (if enabled)
-        if (this.options.sendDeviceMeta) {
-            const reader = videoStream.readable.getReader();
-            const { done, value } = await reader.read();
-            // 64 bytes device name + 2 bytes video width + 2 bytes video height
-            if (done || value.byteLength !== 64 + 2 + 2) {
-                throw new Error('Unexpected response from server');
-            }
-            reader.releaseLock();
-        }
-
-        return [videoStream, controlStream];
-    }
-}
-
-export class ScrcpyClientReverseConnection extends ScrcpyClientConnection {
-    private streams!: ReadableStreamDefaultReader<AdbSocket>;
-
-    private address!: string;
-
-    public override async initialize(): Promise<void> {
-        try {
-            // try to unbind first
-            await this.device.reverse.remove('localabstract:scrcpy');
-        } catch {
-            // ignore error
-        }
-
-        const queue = new TransformStream<AdbSocket>();
-        this.streams = queue.readable.getReader();
-        const writer = queue.writable.getWriter();
-        this.address = await this.device.reverse.add('localabstract:scrcpy', 27183, {
-            onSocket: (packet, stream) => {
-                writer.write(stream);
-            },
-        });
-    }
-
-    private async accept(): Promise<AdbSocket> {
-        return (await this.streams.read()).value!;
-    }
-
-    public async getStreams(): Promise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]> {
-        const videoStream = await this.accept();
-
-        let controlStream: AdbSocket | undefined;
-        if (this.options.control) {
-            controlStream = await this.accept();
-        }
-
-        // Server only writes device meta after control socket is connected (if enabled)
-        if (this.options.sendDeviceMeta) {
-            const reader = videoStream.readable.getReader();
-            const { done, value } = await reader.read();
-            // 64 bytes device name + 2 bytes video width + 2 bytes video height
-            if (done || value.byteLength !== 64 + 2 + 2) {
-                throw new Error('Unexpected response from server');
-            }
-            reader.releaseLock();
-        }
-
-        return [videoStream, controlStream];
-    }
-
-    public override dispose() {
-        // Don't await this!
-        // `reverse.remove`'s response will never arrive
-        // before we read all pending data from `videoStream`
-        this.device.reverse.remove(this.address);
-    }
-}
+import type { Adb, AdbSocket } from "@yume-chan/adb";
+import type { Disposable } from "@yume-chan/event";
+import type { ValueOrPromise } from "@yume-chan/struct";
+import { delay } from "./utils.js";
+
+export interface ScrcpyClientConnectionOptions {
+    control: boolean;
+
+    /**
+     * Write a byte on start to detect connection issues
+     */
+    sendDummyByte: boolean;
+
+    /**
+     * Send device name and size
+     */
+    sendDeviceMeta: boolean;
+}
+
+export abstract class ScrcpyClientConnection implements Disposable {
+    protected device: Adb;
+
+    protected options: ScrcpyClientConnectionOptions;
+
+    public constructor(device: Adb, options: ScrcpyClientConnectionOptions) {
+        this.device = device;
+        this.options = options;
+    }
+
+    public initialize(): ValueOrPromise<void> { }
+
+    public abstract getStreams(): ValueOrPromise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]>;
+
+    public dispose(): void { }
+}
+
+export class ScrcpyClientForwardConnection extends ScrcpyClientConnection {
+    private async connect(): Promise<AdbSocket> {
+        return await this.device.createSocket('localabstract:scrcpy');
+    }
+
+    private async connectAndRetry(): Promise<AdbSocket> {
+        for (let i = 0; i < 100; i++) {
+            try {
+                return await this.connect();
+            } catch (e) {
+                await delay(100);
+            }
+        }
+        throw new Error(`Can't connect to server after 100 retries`);
+    }
+
+    private async connectVideoStream(): Promise<AdbSocket> {
+        const stream = await this.connectAndRetry();
+        if (this.options.sendDummyByte) {
+            const reader = stream.readable.getReader();
+            const { done, value } = await reader.read();
+            // server will write a `0` to signal connection success
+            if (done || value.byteLength !== 1 || value[0] !== 0) {
+                throw new Error('Unexpected response from server');
+            }
+            reader.releaseLock();
+        }
+        return stream;
+    }
+
+    public async getStreams(): Promise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]> {
+        const videoStream = await this.connectVideoStream();
+
+        let controlStream: AdbSocket | undefined;
+        if (this.options.control) {
+            controlStream = await this.connectAndRetry();
+        }
+
+        // Server only writes device meta after control socket is connected (if enabled)
+        if (this.options.sendDeviceMeta) {
+            const reader = videoStream.readable.getReader();
+            const { done, value } = await reader.read();
+            // 64 bytes device name + 2 bytes video width + 2 bytes video height
+            if (done || value.byteLength !== 64 + 2 + 2) {
+                throw new Error('Unexpected response from server');
+            }
+            reader.releaseLock();
+        }
+
+        return [videoStream, controlStream];
+    }
+}
+
+export class ScrcpyClientReverseConnection extends ScrcpyClientConnection {
+    private streams!: ReadableStreamDefaultReader<AdbSocket>;
+
+    private address!: string;
+
+    public override async initialize(): Promise<void> {
+        try {
+            // try to unbind first
+            await this.device.reverse.remove('localabstract:scrcpy');
+        } catch {
+            // ignore error
+        }
+
+        const queue = new TransformStream<AdbSocket>();
+        this.streams = queue.readable.getReader();
+        const writer = queue.writable.getWriter();
+        this.address = await this.device.reverse.add(
+            'localabstract:scrcpy',
+            'tcp:27183',
+            socket => {
+                writer.write(socket);
+                return true;
+            },
+        );
+    }
+
+    private async accept(): Promise<AdbSocket> {
+        return (await this.streams.read()).value!;
+    }
+
+    public async getStreams(): Promise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]> {
+        const videoStream = await this.accept();
+
+        let controlStream: AdbSocket | undefined;
+        if (this.options.control) {
+            controlStream = await this.accept();
+        }
+
+        // Server only writes device meta after control socket is connected (if enabled)
+        if (this.options.sendDeviceMeta) {
+            const reader = videoStream.readable.getReader();
+            const { done, value } = await reader.read();
+            // 64 bytes device name + 2 bytes video width + 2 bytes video height
+            if (done || value.byteLength !== 64 + 2 + 2) {
+                throw new Error('Unexpected response from server');
+            }
+            reader.releaseLock();
+        }
+
+        return [videoStream, controlStream];
+    }
+
+    public override dispose() {
+        // Don't await this!
+        // `reverse.remove`'s response will never arrive
+        // before we read all pending data from `videoStream`
+        this.device.reverse.remove(this.address);
+    }
+}

package/src/decoder/index.ts

@@ -1,3 +1,3 @@
-export * from './types.js';
-export * from './tinyh264/index.js';
-export * from './web-codecs/index.js';
+export * from './types.js';
+export * from './tinyh264/index.js';
+export * from './web-codecs/index.js';

package/src/decoder/tinyh264/index.ts

@@ -1,112 +1,112 @@
-import { WritableStream } from "@yume-chan/adb";
-import { PromiseResolver } from "@yume-chan/async";
-import { AndroidCodecLevel, AndroidCodecProfile } from "../../codec.js";
-import type { VideoStreamPacket } from "../../options/index.js";
-import type { H264Configuration, H264Decoder } from "../types.js";
-import { createTinyH264Wrapper, type TinyH264Wrapper } from "./wrapper.js";
-
-let cachedInitializePromise: Promise<{ YuvBuffer: typeof import('yuv-buffer'), YuvCanvas: typeof import('yuv-canvas').default; }> | undefined;
-function initialize() {
-    if (!cachedInitializePromise) {
-        cachedInitializePromise = Promise.all(
-            [import('yuv-buffer'), import('yuv-canvas')]
-        ).then(([YuvBuffer, { default: YuvCanvas }]) => ({
-            YuvBuffer, YuvCanvas
-        }));
-    }
-
-    return cachedInitializePromise;
-}
-
-export class TinyH264Decoder implements H264Decoder {
-    public readonly maxProfile = AndroidCodecProfile.Baseline;
-
-    public readonly maxLevel = AndroidCodecLevel.Level4;
-
-    private _renderer: HTMLCanvasElement;
-    public get renderer() { return this._renderer; }
-
-    private _frameRendered = 0;
-    public get frameRendered() { return this._frameRendered; }
-
-    private _writable: WritableStream<VideoStreamPacket>;
-    public get writable() { return this._writable; }
-
-    private _yuvCanvas: import('yuv-canvas').default | undefined;
-    private _initializer: PromiseResolver<TinyH264Wrapper> | undefined;
-
-    public constructor() {
-        initialize();
-
-        this._renderer = document.createElement('canvas');
-
-        this._writable = new WritableStream<VideoStreamPacket>({
-            write: async (packet) => {
-                switch (packet.type) {
-                    case 'configuration':
-                        this.configure(packet.data);
-                        break;
-                    case 'frame':
-                        if (!this._initializer) {
-                            throw new Error('Decoder not initialized');
-                        }
-
-                        const wrapper = await this._initializer.promise;
-                        wrapper.feed(packet.data.slice().buffer);
-                        break;
-                }
-            }
-        });
-    }
-
-    private async configure(config: H264Configuration) {
-        this.dispose();
-
-        this._initializer = new PromiseResolver<TinyH264Wrapper>();
-        const { YuvBuffer, YuvCanvas } = await initialize();
-
-        if (!this._yuvCanvas) {
-            this._yuvCanvas = YuvCanvas.attach(this._renderer);;
-        }
-
-        const { encodedWidth, encodedHeight } = config;
-        const chromaWidth = encodedWidth / 2;
-        const chromaHeight = encodedHeight / 2;
-
-        this._renderer.width = config.croppedWidth;
-        this._renderer.height = config.croppedHeight;
-        const format = YuvBuffer.format({
-            width: encodedWidth,
-            height: encodedHeight,
-            chromaWidth,
-            chromaHeight,
-            cropLeft: config.cropLeft,
-            cropTop: config.cropTop,
-            cropWidth: config.croppedWidth,
-            cropHeight: config.croppedHeight,
-            displayWidth: config.croppedWidth,
-            displayHeight: config.croppedHeight,
-        });
-
-        const wrapper = await createTinyH264Wrapper();
-        this._initializer.resolve(wrapper);
-
-        const uPlaneOffset = encodedWidth * encodedHeight;
-        const vPlaneOffset = uPlaneOffset + chromaWidth * chromaHeight;
-        wrapper.onPictureReady(({ data }) => {
-            this._frameRendered += 1;
-            const array = new Uint8Array(data);
-            const frame = YuvBuffer.frame(format,
-                YuvBuffer.lumaPlane(format, array, encodedWidth, 0),
-                YuvBuffer.chromaPlane(format, array, chromaWidth, uPlaneOffset),
-                YuvBuffer.chromaPlane(format, array, chromaWidth, vPlaneOffset)
-            );
-            this._yuvCanvas!.drawFrame(frame);
-        });
-    }
-
-    public dispose(): void {
-        this._initializer?.promise.then(wrapper => wrapper.dispose());
-        this._initializer = undefined;
-    }
-}
+import { WritableStream } from "@yume-chan/adb";
+import { PromiseResolver } from "@yume-chan/async";
+import { AndroidCodecLevel, AndroidCodecProfile } from "../../codec.js";
+import type { VideoStreamPacket } from "../../options/index.js";
+import type { H264Configuration, H264Decoder } from "../types.js";
+import { createTinyH264Wrapper, type TinyH264Wrapper } from "./wrapper.js";
+
+let cachedInitializePromise: Promise<{ YuvBuffer: typeof import('yuv-buffer'), YuvCanvas: typeof import('yuv-canvas').default; }> | undefined;
+function initialize() {
+    if (!cachedInitializePromise) {
+        cachedInitializePromise = Promise.all(
+            [import('yuv-buffer'), import('yuv-canvas')]
+        ).then(([YuvBuffer, { default: YuvCanvas }]) => ({
+            YuvBuffer, YuvCanvas
+        }));
+    }
+
+    return cachedInitializePromise;
+}
+
+export class TinyH264Decoder implements H264Decoder {
+    public readonly maxProfile = AndroidCodecProfile.Baseline;
+
+    public readonly maxLevel = AndroidCodecLevel.Level4;
+
+    private _renderer: HTMLCanvasElement;
+    public get renderer() { return this._renderer; }
+
+    private _frameRendered = 0;
+    public get frameRendered() { return this._frameRendered; }
+
+    private _writable: WritableStream<VideoStreamPacket>;
+    public get writable() { return this._writable; }
+
+    private _yuvCanvas: import('yuv-canvas').default | undefined;
+    private _initializer: PromiseResolver<TinyH264Wrapper> | undefined;
+
+    public constructor() {
+        initialize();
+
+        this._renderer = document.createElement('canvas');
+
+        this._writable = new WritableStream<VideoStreamPacket>({
+            write: async (packet) => {
+                switch (packet.type) {
+                    case 'configuration':
+                        this.configure(packet.data);
+                        break;
+                    case 'frame':
+                        if (!this._initializer) {
+                            throw new Error('Decoder not initialized');
+                        }
+
+                        const wrapper = await this._initializer.promise;
+                        wrapper.feed(packet.data.slice().buffer);
+                        break;
+                }
+            }
+        });
+    }
+
+    private async configure(config: H264Configuration) {
+        this.dispose();
+
+        this._initializer = new PromiseResolver<TinyH264Wrapper>();
+        const { YuvBuffer, YuvCanvas } = await initialize();
+
+        if (!this._yuvCanvas) {
+            this._yuvCanvas = YuvCanvas.attach(this._renderer);;
+        }
+
+        const { encodedWidth, encodedHeight } = config;
+        const chromaWidth = encodedWidth / 2;
+        const chromaHeight = encodedHeight / 2;
+
+        this._renderer.width = config.croppedWidth;
+        this._renderer.height = config.croppedHeight;
+        const format = YuvBuffer.format({
+            width: encodedWidth,
+            height: encodedHeight,
+            chromaWidth,
+            chromaHeight,
+            cropLeft: config.cropLeft,
+            cropTop: config.cropTop,
+            cropWidth: config.croppedWidth,
+            cropHeight: config.croppedHeight,
+            displayWidth: config.croppedWidth,
+            displayHeight: config.croppedHeight,
+        });
+
+        const wrapper = await createTinyH264Wrapper();
+        this._initializer.resolve(wrapper);
+
+        const uPlaneOffset = encodedWidth * encodedHeight;
+        const vPlaneOffset = uPlaneOffset + chromaWidth * chromaHeight;
+        wrapper.onPictureReady(({ data }) => {
+            this._frameRendered += 1;
+            const array = new Uint8Array(data);
+            const frame = YuvBuffer.frame(format,
+                YuvBuffer.lumaPlane(format, array, encodedWidth, 0),
+                YuvBuffer.chromaPlane(format, array, chromaWidth, uPlaneOffset),
+                YuvBuffer.chromaPlane(format, array, chromaWidth, vPlaneOffset)
+            );
+            this._yuvCanvas!.drawFrame(frame);
+        });
+    }
+
+    public dispose(): void {
+        this._initializer?.promise.then(wrapper => wrapper.dispose());
+        this._initializer = undefined;
+    }
+}