@yume-chan/scrcpy 0.0.12 → 0.0.15

package/src/connection.ts

@@ -1,4 +1,4 @@
-import { Adb, AdbBufferedStream, AdbSocket } from "@yume-chan/adb";
+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";
@@ -29,7 +29,7 @@ export abstract class ScrcpyClientConnection implements Disposable {
 
     public initialize(): ValueOrPromise<void> { }
 
-    public abstract getStreams(): ValueOrPromise<[videoSteam: AdbBufferedStream, controlStream: AdbSocket | undefined]>;
+    public abstract getStreams(): ValueOrPromise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]>;
 
     public dispose(): void { }
 }
@@ -50,26 +50,39 @@ export class ScrcpyClientForwardConnection extends ScrcpyClientConnection {
         throw new Error(`Can't connect to server after 100 retries`);
     }
 
-    private async connectVideoStream(): Promise<AdbBufferedStream> {
-        const socket = await this.connectAndRetry();
-        const stream = new AdbBufferedStream(socket);
+    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
-            await stream.read(1);
+            if (done || value.byteLength !== 1 || value[0] !== 0) {
+                throw new Error('Unexpected response from server');
+            }
+            reader.releaseLock();
         }
         return stream;
     }
 
-    public async getStreams(): Promise<[videoSteam: AdbBufferedStream, controlStream: AdbSocket | undefined]> {
+    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
-            await videoStream.read(64 + 2 + 2);
+            if (done || value.byteLength !== 64 + 2 + 2) {
+                throw new Error('Unexpected response from server');
+            }
+            reader.releaseLock();
         }
+
         return [videoStream, controlStream];
     }
 }
@@ -90,27 +103,39 @@ export class ScrcpyClientReverseConnection extends ScrcpyClientConnection {
         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);
+        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: AdbBufferedStream, controlStream: AdbSocket | undefined]> {
-        const videoStream = new AdbBufferedStream(await this.accept());
+    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
-            await videoStream.read(64 + 2 + 2);
+            if (done || value.byteLength !== 64 + 2 + 2) {
+                throw new Error('Unexpected response from server');
+            }
+            reader.releaseLock();
         }
+
         return [videoStream, controlStream];
     }
 

package/src/decoder/web-codecs/index.ts

@@ -55,7 +55,8 @@ export class WebCodecsDecoder implements H264Decoder {
                         break;
                     case 'frame':
                         this.decoder.decode(new EncodedVideoChunk({
-                            type: 'key',
+                            // Treat `undefined` as `key`, otherwise won't decode.
+                            type: packet.keyframe === false ? 'delta' : 'key',
                             timestamp: 0,
                             data: packet.data,
                         }));

package/src/message.ts

@@ -1,5 +1,7 @@
 import Struct, { placeholder } from '@yume-chan/struct';
 
+// https://github.com/Genymobile/scrcpy/blob/fa5b2a29e983a46b49531def9cf3d80c40c3de37/app/src/control_msg.h#L23
+// For their message bodies, see https://github.com/Genymobile/scrcpy/blob/5c62f3419d252d10cd8c9cbb7c918b358b81f2d0/app/src/control_msg.c#L92
 export enum ScrcpyControlMessageType {
     InjectKeycode,
     InjectText,
@@ -7,6 +9,7 @@ export enum ScrcpyControlMessageType {
     InjectScroll,
     BackOrScreenOn,
     ExpandNotificationPanel,
+    ExpandSettingPanel,
     CollapseNotificationPanel,
     GetClipboard,
     SetClipboard,
@@ -31,9 +34,13 @@ export enum AndroidMotionEventAction {
     ButtonRelease,
 }
 
+export const ScrcpySimpleControlMessage =
+    new Struct()
+        .uint8('type');
+
 export const ScrcpyInjectTouchControlMessage =
     new Struct()
-        .uint8('type', ScrcpyControlMessageType.InjectTouch as const)
+        .fields(ScrcpySimpleControlMessage)
         .uint8('action', placeholder<AndroidMotionEventAction>())
         .uint64('pointerId')
         .uint32('pointerX')
@@ -47,7 +54,7 @@ export type ScrcpyInjectTouchControlMessage = typeof ScrcpyInjectTouchControlMes
 
 export const ScrcpyInjectTextControlMessage =
     new Struct()
-        .uint8('type', ScrcpyControlMessageType.InjectText as const)
+        .fields(ScrcpySimpleControlMessage)
         .uint32('length')
         .string('text', { lengthField: 'length' });
 
@@ -95,7 +102,7 @@ export enum AndroidKeyCode {
 
 export const ScrcpyInjectKeyCodeControlMessage =
     new Struct()
-        .uint8('type', ScrcpyControlMessageType.InjectKeycode as const)
+        .fields(ScrcpySimpleControlMessage)
         .uint8('action', placeholder<AndroidKeyEventAction>())
         .uint32('keyCode')
         .uint32('repeat')

package/src/options/1_16/index.ts

@@ -1,8 +1,8 @@
-import { BufferedStreamEndedError, ReadableStream, TransformStream, type Adb, type AdbBufferedStream } from "@yume-chan/adb";
-import Struct, { placeholder } from "@yume-chan/struct";
+import { StructDeserializeStream, TransformStream, type Adb } from "@yume-chan/adb";
+import Struct from "@yume-chan/struct";
 import type { AndroidCodecLevel, AndroidCodecProfile } from "../../codec.js";
 import { ScrcpyClientConnection, ScrcpyClientForwardConnection, ScrcpyClientReverseConnection, type ScrcpyClientConnectionOptions } from "../../connection.js";
-import { AndroidKeyEventAction, ScrcpyControlMessageType } from "../../message.js";
+import { AndroidKeyEventAction, ScrcpyControlMessageType, ScrcpySimpleControlMessage } from "../../message.js";
 import type { ScrcpyBackOrScreenOnEvent1_18 } from "../1_18.js";
 import type { ScrcpyInjectScrollControlMessage1_22 } from "../1_22.js";
 import { toScrcpyOptionValue, type ScrcpyOptions, type ScrcpyOptionValue, type VideoStreamPacket } from "../common.js";
@@ -16,7 +16,7 @@ export enum ScrcpyLogLevel {
     Error = 'error',
 }
 
-export enum ScrcpyScreenOrientation {
+export enum ScrcpyVideoOrientation {
     Initial = -2,
     Unlocked = -1,
     Portrait = 0,
@@ -75,7 +75,7 @@ export interface ScrcpyOptionsInit1_16 {
      * It will not keep the device screen in specific orientation,
      * only the captured video will in this orientation.
      */
-    lockVideoOrientation: ScrcpyScreenOrientation;
+    lockVideoOrientation: ScrcpyVideoOrientation;
 
     tunnelForward: boolean;
 
@@ -112,19 +112,18 @@ export interface ScrcpyOptionsInit1_16 {
 
 export const VideoPacket =
     new Struct()
-        .int64('pts')
+        .uint64('pts')
         .uint32('size')
         .uint8Array('data', { lengthField: 'size' });
 
-export const NoPts = BigInt(-1);
+export const NO_PTS = BigInt(1) << BigInt(63);
 
 export const ScrcpyBackOrScreenOnEvent1_16 =
-    new Struct()
-        .uint8('type', placeholder<ScrcpyControlMessageType.BackOrScreenOn>());
+    ScrcpySimpleControlMessage;
 
 export const ScrcpyInjectScrollControlMessage1_16 =
     new Struct()
-        .uint8('type', ScrcpyControlMessageType.InjectScroll as const)
+        .fields(ScrcpySimpleControlMessage)
         .uint32('pointerX')
         .uint32('pointerY')
         .uint16('screenWidth')
@@ -142,8 +141,8 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
         }
 
         if (new.target === ScrcpyOptions1_16 &&
-            value.lockVideoOrientation === ScrcpyScreenOrientation.Initial) {
-            value.lockVideoOrientation = ScrcpyScreenOrientation.Unlocked;
+            value.lockVideoOrientation === ScrcpyVideoOrientation.Initial) {
+            value.lockVideoOrientation = ScrcpyVideoOrientation.Unlocked;
         }
 
         this.value = value as Partial<T>;
@@ -174,7 +173,7 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
             maxSize: 0,
             bitRate: 8_000_000,
             maxFps: 0,
-            lockVideoOrientation: ScrcpyScreenOrientation.Unlocked,
+            lockVideoOrientation: ScrcpyVideoOrientation.Unlocked,
             tunnelForward: false,
             crop: '-',
             sendFrameMeta: true,
@@ -211,29 +210,28 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
         return /\s+scrcpy --encoder-name '(.*?)'/;
     }
 
-    public parseVideoStream(stream: AdbBufferedStream): ReadableStream<VideoStreamPacket> {
+    public createVideoStreamTransformer(): TransformStream<Uint8Array, VideoStreamPacket> {
         // Optimized path for video frames only
         if (this.value.sendFrameMeta === false) {
-            return stream
-                .release()
-                .pipeThrough(new TransformStream<Uint8Array, VideoStreamPacket>({
-                    transform(chunk, controller) {
-                        controller.enqueue({
-                            type: 'frame',
-                            data: chunk,
-                        });
-                    },
-                }));
+            return new TransformStream({
+                transform(chunk, controller) {
+                    controller.enqueue({
+                        type: 'frame',
+                        data: chunk,
+                    });
+                },
+            });
         }
 
         let header: Uint8Array | undefined;
 
-        return new ReadableStream<VideoStreamPacket>({
-            async pull(controller) {
-                try {
-                    const { pts, data } = await VideoPacket.deserialize(stream);
-                    if (pts === NoPts) {
-                        const sequenceParameterSet = parse_sequence_parameter_set(data.slice().buffer);
+        let deserializeStream = new StructDeserializeStream(VideoPacket);
+        return {
+            writable: deserializeStream.writable,
+            readable: deserializeStream.readable.pipeThrough(new TransformStream({
+                transform(packet, controller) {
+                    if (packet.pts === NO_PTS) {
+                        const sequenceParameterSet = parse_sequence_parameter_set(packet.data.slice().buffer);
 
                         const {
                             profile_idc: profileIndex,
@@ -258,7 +256,7 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
                         const croppedWidth = encodedWidth - cropLeft - cropRight;
                         const croppedHeight = encodedHeight - cropTop - cropBottom;
 
-                        header = data;
+                        header = packet.data;
                         controller.enqueue({
                             type: 'configuration',
                             data: {
@@ -280,28 +278,38 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
 
                     let frameData: Uint8Array;
                     if (header) {
-                        frameData = new Uint8Array(header.byteLength + data.byteLength);
+                        frameData = new Uint8Array(header.byteLength + packet.data.byteLength);
                         frameData.set(header);
-                        frameData.set(data!, header.byteLength);
+                        frameData.set(packet.data, header.byteLength);
                         header = undefined;
                     } else {
-                        frameData = data;
+                        frameData = packet.data;
                     }
 
                     controller.enqueue({
                         type: 'frame',
+                        pts: packet.pts,
                         data: frameData,
                     });
-                } catch (e) {
-                    if (e instanceof BufferedStreamEndedError) {
-                        controller.close();
-                        return;
-                    }
-
-                    throw e;
                 }
-            }
-        });
+            }))
+        };
+    }
+
+    public getControlMessageTypes(): ScrcpyControlMessageType[] {
+        return [
+            /*  0 */ ScrcpyControlMessageType.InjectKeycode,
+            /*  1 */ ScrcpyControlMessageType.InjectText,
+            /*  2 */ ScrcpyControlMessageType.InjectTouch,
+            /*  3 */ ScrcpyControlMessageType.InjectScroll,
+            /*  4 */ ScrcpyControlMessageType.BackOrScreenOn,
+            /*  5 */ ScrcpyControlMessageType.ExpandNotificationPanel,
+            /*  6 */ ScrcpyControlMessageType.CollapseNotificationPanel,
+            /*  7 */ ScrcpyControlMessageType.GetClipboard,
+            /*  8 */ ScrcpyControlMessageType.SetClipboard,
+            /*  9 */ ScrcpyControlMessageType.SetScreenPowerMode,
+            /* 10 */ ScrcpyControlMessageType.RotateDevice,
+        ];
     }
 
     public serializeBackOrScreenOnControlMessage(

package/src/options/1_18.ts

@@ -1,5 +1,5 @@
 import Struct, { placeholder } from "@yume-chan/struct";
-import type { AndroidKeyEventAction } from "../message.js";
+import { AndroidKeyEventAction, ScrcpyControlMessageType } from "../message.js";
 import { ScrcpyBackOrScreenOnEvent1_16, ScrcpyOptions1_16, type ScrcpyOptionsInit1_16 } from "./1_16/index.js";
 
 export interface ScrcpyOptionsInit1_18 extends ScrcpyOptionsInit1_16 {
@@ -33,6 +33,26 @@ export class ScrcpyOptions1_18<T extends ScrcpyOptionsInit1_18 = ScrcpyOptionsIn
         return /\s+scrcpy --encoder '(.*?)'/;
     }
 
+    public override getControlMessageTypes(): ScrcpyControlMessageType[] {
+        /**
+         *  0 InjectKeycode
+         *  1 InjectText
+         *  2 InjectTouch
+         *  3 InjectScroll
+         *  4 BackOrScreenOn
+         *  5 ExpandNotificationPanel
+         *  6 ExpandSettingsPanel
+         *  7 CollapseNotificationPanel
+         *  8 GetClipboard
+         *  9 SetClipboard
+         * 10 SetScreenPowerMode
+         * 11 RotateDevice
+         */
+        const types = super.getControlMessageTypes();
+        types.splice(6, 0, ScrcpyControlMessageType.ExpandSettingPanel);
+        return types;
+    }
+
     public override serializeBackOrScreenOnControlMessage(
         message: ScrcpyBackOrScreenOnEvent1_18,
     ) {

package/src/options/1_22.ts

@@ -1,6 +1,6 @@
 import type { Adb } from "@yume-chan/adb";
 import Struct from "@yume-chan/struct";
-import { ScrcpyClientForwardConnection, ScrcpyClientReverseConnection, type ScrcpyClientConnection, type ScrcpyClientConnectionOptions } from "../connection.js";
+import { ScrcpyClientForwardConnection, ScrcpyClientReverseConnection, type ScrcpyClientConnection } from "../connection.js";
 import { ScrcpyInjectScrollControlMessage1_16 } from "./1_16/index.js";
 import { ScrcpyOptions1_21, type ScrcpyOptionsInit1_21 } from "./1_21.js";
 
@@ -8,14 +8,14 @@ export interface ScrcpyOptionsInit1_22 extends ScrcpyOptionsInit1_21 {
     downsizeOnError: boolean;
 
     /**
-     * Send device name and size
+     * Send device name and size at start of video stream.
      *
      * @default true
      */
     sendDeviceMeta: boolean;
 
     /**
-     * Write a byte on start to detect connection issues
+     * Send a `0` byte on start of video stream to detect connection issues
      *
      * @default true
      */
@@ -59,11 +59,9 @@ export class ScrcpyOptions1_22<T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsIn
     }
 
     public override createConnection(device: Adb): ScrcpyClientConnection {
-        const defaultValue = this.getDefaultValue();
-        const options: ScrcpyClientConnectionOptions = {
-            control: this.value.control ?? defaultValue.control,
-            sendDummyByte: this.value.sendDummyByte ?? defaultValue.sendDummyByte,
-            sendDeviceMeta: this.value.sendDeviceMeta ?? defaultValue.sendDeviceMeta,
+        const options = {
+            ...this.getDefaultValue(),
+            ...this.value,
         };
         if (this.value.tunnelForward) {
             return new ScrcpyClientForwardConnection(device, options);

package/src/options/1_23.ts

@@ -0,0 +1,44 @@
+import { TransformStream } from "@yume-chan/adb";
+import { ScrcpyOptions1_22, type ScrcpyOptionsInit1_22 } from './1_22.js';
+import type { VideoStreamPacket } from "./common.js";
+
+export interface ScrcpyOptionsInit1_23 extends ScrcpyOptionsInit1_22 {
+    cleanup: boolean;
+}
+
+const KEYFRAME_PTS = BigInt(1) << BigInt(62);
+
+export class ScrcpyOptions1_23<T extends ScrcpyOptionsInit1_23 = ScrcpyOptionsInit1_23> extends ScrcpyOptions1_22<T> {
+    public constructor(init: Partial<ScrcpyOptionsInit1_23>) {
+        super(init);
+    }
+
+    protected override getDefaultValue(): T {
+        return {
+            ...super.getDefaultValue(),
+            cleanup: true,
+        };
+    }
+
+    public override createVideoStreamTransformer(): TransformStream<Uint8Array, VideoStreamPacket> {
+        const superStream = super.createVideoStreamTransformer();
+        return {
+            writable: superStream.writable,
+            readable: superStream.readable.pipeThrough(new TransformStream({
+                transform(packet, controller): void {
+                    if (packet.type !== 'frame') {
+                        controller.enqueue(packet);
+                        return;
+                    }
+
+                    if (packet.pts !== undefined && packet.pts & KEYFRAME_PTS) {
+                        packet.keyframe = true;
+                        packet.pts &= ~KEYFRAME_PTS;
+                    }
+
+                    controller.enqueue(packet);
+                }
+            }))
+        };
+    }
+}

package/src/options/1_24.ts

@@ -0,0 +1,18 @@
+import { ScrcpyOptions1_23, type ScrcpyOptionsInit1_23 } from './1_23.js';
+
+export interface ScrcpyOptionsInit1_24 extends ScrcpyOptionsInit1_23 {
+    powerOn: boolean;
+}
+
+export class ScrcpyOptions1_24<T extends ScrcpyOptionsInit1_24 = ScrcpyOptionsInit1_24> extends ScrcpyOptions1_23<T> {
+    public constructor(init: Partial<ScrcpyOptionsInit1_24>) {
+        super(init);
+    }
+
+    protected override getDefaultValue(): T {
+        return {
+            ...super.getDefaultValue(),
+            powerOn: true,
+        };
+    }
+}

package/src/options/common.ts

@@ -1,6 +1,7 @@
-import type { Adb, AdbBufferedStream, ReadableStream } from "@yume-chan/adb";
+import type { Adb, TransformStream } from "@yume-chan/adb";
 import type { ScrcpyClientConnection } from "../connection.js";
 import type { H264Configuration } from "../decoder/index.js";
+import type { ScrcpyControlMessageType } from "../message.js";
 import type { ScrcpyBackOrScreenOnEvent1_18 } from "./1_18.js";
 import type { ScrcpyInjectScrollControlMessage1_22 } from "./1_22.js";
 
@@ -35,6 +36,8 @@ export interface VideoStreamConfigurationPacket {
 
 export interface VideoStreamFramePacket {
     type: 'frame';
+    keyframe?: boolean | undefined;
+    pts?: bigint | undefined;
     data: Uint8Array;
 }
 
@@ -49,7 +52,9 @@ export interface ScrcpyOptions<T> {
 
     createConnection(adb: Adb): ScrcpyClientConnection;
 
-    parseVideoStream(stream: AdbBufferedStream): ReadableStream<VideoStreamPacket>;
+    createVideoStreamTransformer(): TransformStream<Uint8Array, VideoStreamPacket>;
+
+    getControlMessageTypes(): ScrcpyControlMessageType[];
 
     serializeBackOrScreenOnControlMessage(
         message: ScrcpyBackOrScreenOnEvent1_18,

package/src/options/index.ts

@@ -2,4 +2,6 @@ export * from './1_16/index.js';
 export * from './1_18.js';
 export * from './1_21.js';
 export * from './1_22.js';
+export * from './1_23.js';
+export * from './1_24.js';
 export * from './common.js';

package/src/push-server.ts

@@ -1,4 +1,4 @@
-import { Adb, AdbSync, WrapWritableStream, WritableStream } from "@yume-chan/adb";
+import { WrapWritableStream, type Adb, type AdbSync } from "@yume-chan/adb";
 import { DEFAULT_SERVER_PATH } from "./options/index.js";
 
 export interface PushServerOptions {
@@ -11,15 +11,13 @@ export function pushServer(
 ) {
     const { path = DEFAULT_SERVER_PATH } = options;
 
-    return new WrapWritableStream<Uint8Array, WritableStream<Uint8Array>, AdbSync>({
+    let sync!: AdbSync;
+    return new WrapWritableStream<Uint8Array>({
         async start() {
-            const sync = await device.sync();
-            return {
-                writable: sync.write(path),
-                state: sync,
-            };
+            sync = await device.sync();
+            return sync.write(path);
         },
-        async close(sync) {
+        async close() {
             await sync.dispose();
         },
     });

package/src/utils.ts

@@ -3,14 +3,3 @@ export function delay(time: number): Promise<void> {
         (globalThis as any).setTimeout(resolve, time);
     });
 }
-
-const Utf8Encoder = new TextEncoder();
-const Utf8Decoder = new TextDecoder();
-
-export function encodeUtf8(input: string): ArrayBuffer {
-    return Utf8Encoder.encode(input).buffer;
-}
-
-export function decodeUtf8(buffer: ArrayBuffer): string {
-    return Utf8Decoder.decode(buffer);
-}