@yume-chan/scrcpy 0.0.16 → 0.0.17

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

@@ -0,0 +1,294 @@
+import { StructDeserializeStream, TransformStream } from '@yume-chan/stream-extra';
+import Struct from '@yume-chan/struct';
+
+import { AndroidKeyEventAction, ScrcpyControlMessageType } from '../../control/index.js';
+import type { ScrcpyBackOrScreenOnControlMessage1_18 } from '../1_18.js';
+import type { ScrcpyInjectScrollControlMessage1_22 } from '../1_22.js';
+import { toScrcpyOptionValue, type ScrcpyOptions, type ScrcpyVideoStreamPacket } from '../types.js';
+import { CodecOptions } from './codec-options.js';
+import { parse_sequence_parameter_set } from './sps.js';
+
+export enum ScrcpyLogLevel {
+    Verbose = 'verbose',
+    Debug = 'debug',
+    Info = 'info',
+    Warn = 'warn',
+    Error = 'error',
+}
+
+export enum ScrcpyVideoOrientation {
+    Initial = -2,
+    Unlocked = -1,
+    Portrait = 0,
+    Landscape = 1,
+    PortraitFlipped = 2,
+    LandscapeFlipped = 3,
+}
+
+export interface ScrcpyOptionsInit1_16 {
+    logLevel: ScrcpyLogLevel;
+
+    /**
+     * The maximum value of both width and height.
+     */
+    maxSize: number;
+
+    bitRate: number;
+
+    /**
+     * 0 for unlimited.
+     *
+     * @default 0
+     */
+    maxFps: number;
+
+    /**
+     * The orientation of the video stream.
+     *
+     * It will not keep the device screen in specific orientation,
+     * only the captured video will in this orientation.
+     */
+    lockVideoOrientation: ScrcpyVideoOrientation;
+
+    tunnelForward: boolean;
+
+    crop: string;
+
+    /**
+     * Send PTS so that the client may record properly
+     *
+     * Note: When `sendFrameMeta: false` is specified,
+     * `onChangeEncoding` event won't fire and `onVideoData` event doesn't
+     * merge sps/pps frame and first video frame. Which means you can't use
+     * the shipped decoders to render the video
+     * (You can still record the stream into a file).
+     *
+     * @default true
+     */
+    sendFrameMeta: boolean;
+
+    /**
+     * @default true
+     */
+    control: boolean;
+
+    displayId: number;
+
+    showTouches: boolean;
+
+    stayAwake: boolean;
+
+    codecOptions: CodecOptions;
+
+    encoderName: string;
+}
+
+export const VideoPacket =
+    new Struct()
+        .uint64('pts')
+        .uint32('size')
+        .uint8Array('data', { lengthField: 'size' });
+
+export const NO_PTS = BigInt(1) << BigInt(63);
+
+export const ScrcpyBackOrScreenOnControlMessage1_16 =
+    new Struct()
+        .uint8('type', ScrcpyControlMessageType.BackOrScreenOn as const);
+
+export const ScrcpyInjectScrollControlMessage1_16 =
+    new Struct()
+        .uint8('type', ScrcpyControlMessageType.InjectScroll as const)
+        .uint32('pointerX')
+        .uint32('pointerY')
+        .uint16('screenWidth')
+        .uint16('screenHeight')
+        .int32('scrollX')
+        .int32('scrollY');
+
+export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsInit1_16>
+    implements ScrcpyOptions<T> {
+    public value: Partial<T>;
+
+    public constructor(value: Partial<ScrcpyOptionsInit1_16>) {
+        if (new.target === ScrcpyOptions1_16 &&
+            value.logLevel === ScrcpyLogLevel.Verbose) {
+            value.logLevel = ScrcpyLogLevel.Debug;
+        }
+
+        if (new.target === ScrcpyOptions1_16 &&
+            value.lockVideoOrientation === ScrcpyVideoOrientation.Initial) {
+            value.lockVideoOrientation = ScrcpyVideoOrientation.Unlocked;
+        }
+
+        this.value = value as Partial<T>;
+    }
+
+    protected getArgumentOrder(): (keyof T)[] {
+        return [
+            'logLevel',
+            'maxSize',
+            'bitRate',
+            'maxFps',
+            'lockVideoOrientation',
+            'tunnelForward',
+            'crop',
+            'sendFrameMeta',
+            'control',
+            'displayId',
+            'showTouches',
+            'stayAwake',
+            'codecOptions',
+            'encoderName',
+        ];
+    }
+
+    public getDefaultValue(): T {
+        return {
+            logLevel: ScrcpyLogLevel.Debug,
+            maxSize: 0,
+            bitRate: 8_000_000,
+            maxFps: 0,
+            lockVideoOrientation: ScrcpyVideoOrientation.Unlocked,
+            tunnelForward: false,
+            crop: '-',
+            sendFrameMeta: true,
+            control: true,
+            displayId: 0,
+            showTouches: false,
+            stayAwake: false,
+            codecOptions: new CodecOptions({}),
+            encoderName: '-',
+        } as T;
+    }
+
+    public formatServerArguments(): string[] {
+        const defaults = this.getDefaultValue();
+        return this.getArgumentOrder()
+            .map(
+                key =>
+                    toScrcpyOptionValue(this.value[key] || defaults[key], '-')
+            );
+    }
+
+    public getOutputEncoderNameRegex(): RegExp {
+        return /\s+scrcpy --encoder-name '(.*?)'/;
+    }
+
+    public createVideoStreamTransformer(): TransformStream<Uint8Array, ScrcpyVideoStreamPacket> {
+        // Optimized path for video frames only
+        if (this.value.sendFrameMeta === false) {
+            return new TransformStream({
+                transform(chunk, controller) {
+                    controller.enqueue({
+                        type: 'frame',
+                        data: chunk,
+                    });
+                },
+            });
+        }
+
+        let header: Uint8Array | undefined;
+
+        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,
+                            constraint_set: constraintSet,
+                            level_idc: levelIndex,
+                            pic_width_in_mbs_minus1,
+                            pic_height_in_map_units_minus1,
+                            frame_mbs_only_flag,
+                            frame_crop_left_offset,
+                            frame_crop_right_offset,
+                            frame_crop_top_offset,
+                            frame_crop_bottom_offset,
+                        } = sequenceParameterSet;
+
+                        const encodedWidth = (pic_width_in_mbs_minus1 + 1) * 16;
+                        const encodedHeight = (pic_height_in_map_units_minus1 + 1) * (2 - frame_mbs_only_flag) * 16;
+                        const cropLeft = frame_crop_left_offset * 2;
+                        const cropRight = frame_crop_right_offset * 2;
+                        const cropTop = frame_crop_top_offset * 2;
+                        const cropBottom = frame_crop_bottom_offset * 2;
+
+                        const croppedWidth = encodedWidth - cropLeft - cropRight;
+                        const croppedHeight = encodedHeight - cropTop - cropBottom;
+
+                        header = packet.data;
+                        controller.enqueue({
+                            type: 'configuration',
+                            data: {
+                                profileIndex,
+                                constraintSet,
+                                levelIndex,
+                                encodedWidth,
+                                encodedHeight,
+                                cropLeft,
+                                cropRight,
+                                cropTop,
+                                cropBottom,
+                                croppedWidth,
+                                croppedHeight,
+                            }
+                        });
+                        return;
+                    }
+
+                    let frameData: Uint8Array;
+                    if (header) {
+                        frameData = new Uint8Array(header.byteLength + packet.data.byteLength);
+                        frameData.set(header);
+                        frameData.set(packet.data, header.byteLength);
+                        header = undefined;
+                    } else {
+                        frameData = packet.data;
+                    }
+
+                    controller.enqueue({
+                        type: 'frame',
+                        pts: packet.pts,
+                        data: frameData,
+                    });
+                }
+            }))
+        };
+    }
+
+    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(
+        message: ScrcpyBackOrScreenOnControlMessage1_18,
+    ) {
+        if (message.action === AndroidKeyEventAction.Down) {
+            return ScrcpyBackOrScreenOnControlMessage1_16.serialize(message);
+        }
+
+        return undefined;
+    }
+
+    public serializeInjectScrollControlMessage(
+        message: ScrcpyInjectScrollControlMessage1_22,
+    ): Uint8Array {
+        return ScrcpyInjectScrollControlMessage1_16.serialize(message);
+    }
+}

package/src/options/1_18.ts

@@ -1,19 +1,21 @@
-import Struct, { placeholder } from "@yume-chan/struct";
-import { AndroidKeyEventAction, ScrcpyControlMessageType } from "../message.js";
-import { ScrcpyBackOrScreenOnEvent1_16, ScrcpyOptions1_16, type ScrcpyOptionsInit1_16 } from "./1_16/index.js";
+import Struct, { placeholder } from '@yume-chan/struct';
+
+import { AndroidKeyEventAction, ScrcpyControlMessageType } from '../control/index.js';
+import { ScrcpyBackOrScreenOnControlMessage1_16, ScrcpyOptions1_16, type ScrcpyOptionsInit1_16 } from './1_16/options.js';
 
 export interface ScrcpyOptionsInit1_18 extends ScrcpyOptionsInit1_16 {
     powerOffOnClose: boolean;
 }
 
-export const ScrcpyBackOrScreenOnEvent1_18 =
+export const ScrcpyBackOrScreenOnControlMessage1_18 =
     new Struct()
-        .fields(ScrcpyBackOrScreenOnEvent1_16)
+        .fields(ScrcpyBackOrScreenOnControlMessage1_16)
         .uint8('action', placeholder<AndroidKeyEventAction>());
 
-export type ScrcpyBackOrScreenOnEvent1_18 = typeof ScrcpyBackOrScreenOnEvent1_18["TInit"];
+export type ScrcpyBackOrScreenOnControlMessage1_18 = typeof ScrcpyBackOrScreenOnControlMessage1_18['TInit'];
 
-export class ScrcpyOptions1_18<T extends ScrcpyOptionsInit1_18 = ScrcpyOptionsInit1_18> extends ScrcpyOptions1_16<T> {
+export class ScrcpyOptions1_18<T extends ScrcpyOptionsInit1_18 = ScrcpyOptionsInit1_18>
+    extends ScrcpyOptions1_16<T> {
     constructor(value: Partial<ScrcpyOptionsInit1_18>) {
         super(value);
     }
@@ -22,7 +24,7 @@ export class ScrcpyOptions1_18<T extends ScrcpyOptionsInit1_18 = ScrcpyOptionsIn
         return super.getArgumentOrder().concat(['powerOffOnClose']);
     }
 
-    protected override getDefaultValue(): T {
+    public override getDefaultValue(): T {
         return {
             ...super.getDefaultValue(),
             powerOffOnClose: false,
@@ -54,8 +56,8 @@ export class ScrcpyOptions1_18<T extends ScrcpyOptionsInit1_18 = ScrcpyOptionsIn
     }
 
     public override serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnEvent1_18,
+        message: ScrcpyBackOrScreenOnControlMessage1_18,
     ) {
-        return ScrcpyBackOrScreenOnEvent1_18.serialize(message);
+        return ScrcpyBackOrScreenOnControlMessage1_18.serialize(message);
     }
 }

package/src/options/1_21.ts

@@ -1,7 +1,7 @@
 // cspell: ignore autosync
 
 import { ScrcpyOptions1_18, type ScrcpyOptionsInit1_18 } from './1_18.js';
-import { toScrcpyOptionValue } from "./common.js";
+import { toScrcpyOptionValue } from './types.js';
 
 export interface ScrcpyOptionsInit1_21 extends ScrcpyOptionsInit1_18 {
     clipboardAutosync?: boolean;
@@ -11,12 +11,13 @@ function toSnakeCase(input: string): string {
     return input.replace(/([A-Z])/g, '_$1').toLowerCase();
 }
 
-export class ScrcpyOptions1_21<T extends ScrcpyOptionsInit1_21 = ScrcpyOptionsInit1_21> extends ScrcpyOptions1_18<T> {
+export class ScrcpyOptions1_21<T extends ScrcpyOptionsInit1_21 = ScrcpyOptionsInit1_21>
+    extends ScrcpyOptions1_18<T> {
     public constructor(init: Partial<ScrcpyOptionsInit1_21>) {
         super(init);
     }
 
-    protected override getDefaultValue(): T {
+    public override getDefaultValue(): T {
         return {
             ...super.getDefaultValue(),
             clipboardAutosync: true,
@@ -27,8 +28,17 @@ export class ScrcpyOptions1_21<T extends ScrcpyOptionsInit1_21 = ScrcpyOptionsIn
         // 1.21 changed the format of arguments
         // So `getArgumentOrder()` is no longer needed
         return Object.entries(this.value)
-            .map(([key, value]) => [key, toScrcpyOptionValue(value, undefined)] as const)
-            .filter((pair): pair is [string, string] => pair[1] !== undefined)
-            .map(([key, value]) => `${toSnakeCase(key)}=${value}`);
+            .map(
+                ([key, value]) =>
+                    [key, toScrcpyOptionValue(value, undefined)] as const
+            )
+            .filter(
+                (pair): pair is [string, string] =>
+                    pair[1] !== undefined
+            )
+            .map(
+                ([key, value]) =>
+                    `${toSnakeCase(key)}=${value}`
+            );
     }
 }

package/src/options/1_22.ts

@@ -1,8 +1,7 @@
-import type { Adb } from "@yume-chan/adb";
-import Struct from "@yume-chan/struct";
-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";
+import Struct from '@yume-chan/struct';
+
+import { ScrcpyInjectScrollControlMessage1_16 } from './1_16/options.js';
+import { ScrcpyOptions1_21, type ScrcpyOptionsInit1_21 } from './1_21.js';
 
 export interface ScrcpyOptionsInit1_22 extends ScrcpyOptionsInit1_21 {
     downsizeOnError: boolean;
@@ -32,11 +31,13 @@ export interface ScrcpyOptionsInit1_22 extends ScrcpyOptionsInit1_21 {
 export const ScrcpyInjectScrollControlMessage1_22 =
     new Struct()
         .fields(ScrcpyInjectScrollControlMessage1_16)
-        .int32("buttons");
+        .int32('buttons');
 
-export type ScrcpyInjectScrollControlMessage1_22 = typeof ScrcpyInjectScrollControlMessage1_22["TInit"];
+export type ScrcpyInjectScrollControlMessage1_22 =
+    typeof ScrcpyInjectScrollControlMessage1_22['TInit'];
 
-export class ScrcpyOptions1_22<T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsInit1_22> extends ScrcpyOptions1_21<T> {
+export class ScrcpyOptions1_22<T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsInit1_22>
+    extends ScrcpyOptions1_21<T> {
     public constructor(init: Partial<ScrcpyOptionsInit1_22>) {
         if (init.rawVideoStream) {
             // Set implied options for client-side processing
@@ -48,7 +49,7 @@ export class ScrcpyOptions1_22<T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsIn
         super(init);
     }
 
-    protected override getDefaultValue(): T {
+    public override getDefaultValue(): T {
         return {
             ...super.getDefaultValue(),
             downsizeOnError: true,
@@ -58,18 +59,6 @@ export class ScrcpyOptions1_22<T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsIn
         };
     }
 
-    public override createConnection(device: Adb): ScrcpyClientConnection {
-        const options = {
-            ...this.getDefaultValue(),
-            ...this.value,
-        };
-        if (this.value.tunnelForward) {
-            return new ScrcpyClientForwardConnection(device, options);
-        } else {
-            return new ScrcpyClientReverseConnection(device, options);
-        }
-    }
-
     public override serializeInjectScrollControlMessage(
         message: ScrcpyInjectScrollControlMessage1_22,
     ): Uint8Array {

package/src/options/1_23.ts

@@ -1,6 +1,7 @@
-import { TransformStream } from "@yume-chan/adb";
+import { TransformStream } from '@yume-chan/stream-extra';
+
 import { ScrcpyOptions1_22, type ScrcpyOptionsInit1_22 } from './1_22.js';
-import type { VideoStreamPacket } from "./common.js";
+import type { ScrcpyVideoStreamPacket } from './types.js';
 
 export interface ScrcpyOptionsInit1_23 extends ScrcpyOptionsInit1_22 {
     cleanup: boolean;
@@ -8,19 +9,20 @@ export interface ScrcpyOptionsInit1_23 extends ScrcpyOptionsInit1_22 {
 
 const KEYFRAME_PTS = BigInt(1) << BigInt(62);
 
-export class ScrcpyOptions1_23<T extends ScrcpyOptionsInit1_23 = ScrcpyOptionsInit1_23> extends ScrcpyOptions1_22<T> {
+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 {
+    public override getDefaultValue(): T {
         return {
             ...super.getDefaultValue(),
             cleanup: true,
         };
     }
 
-    public override createVideoStreamTransformer(): TransformStream<Uint8Array, VideoStreamPacket> {
+    public override createVideoStreamTransformer(): TransformStream<Uint8Array, ScrcpyVideoStreamPacket> {
         const superStream = super.createVideoStreamTransformer();
         return {
             writable: superStream.writable,

package/src/options/1_24.ts

@@ -4,12 +4,13 @@ export interface ScrcpyOptionsInit1_24 extends ScrcpyOptionsInit1_23 {
     powerOn: boolean;
 }
 
-export class ScrcpyOptions1_24<T extends ScrcpyOptionsInit1_24 = ScrcpyOptionsInit1_24> extends ScrcpyOptions1_23<T> {
+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 {
+    public override getDefaultValue(): T {
         return {
             ...super.getDefaultValue(),
             powerOn: true,

package/src/options/index.ts

@@ -4,4 +4,4 @@ export * from './1_21.js';
 export * from './1_22.js';
 export * from './1_23.js';
 export * from './1_24.js';
-export * from './common.js';
+export * from './types.js';

package/src/options/{common.ts → types.ts}

@@ -1,9 +1,8 @@
-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";
+import type { TransformStream } from '@yume-chan/stream-extra';
+
+import type { ScrcpyControlMessageType } from '../control/index.js';
+import type { ScrcpyBackOrScreenOnControlMessage1_18 } from './1_18.js';
+import type { ScrcpyInjectScrollControlMessage1_22 } from './1_22.js';
 
 export const DEFAULT_SERVER_PATH = '/data/local/tmp/scrcpy-server.jar';
 
@@ -29,35 +28,55 @@ export function toScrcpyOptionValue<T>(value: any, empty: T): string | T {
     return `${value}`;
 }
 
-export interface VideoStreamConfigurationPacket {
+export interface H264Configuration {
+    profileIndex: number;
+    constraintSet: number;
+    levelIndex: number;
+
+    encodedWidth: number;
+    encodedHeight: number;
+
+    cropLeft: number;
+    cropRight: number;
+
+    cropTop: number;
+    cropBottom: number;
+
+    croppedWidth: number;
+    croppedHeight: number;
+}
+
+export interface ScrcpyVideoStreamConfigurationPacket {
     type: 'configuration';
     data: H264Configuration;
 }
 
-export interface VideoStreamFramePacket {
+export interface ScrcpyVideoStreamFramePacket {
     type: 'frame';
     keyframe?: boolean | undefined;
     pts?: bigint | undefined;
     data: Uint8Array;
 }
 
-export type VideoStreamPacket = VideoStreamConfigurationPacket | VideoStreamFramePacket;
+export type ScrcpyVideoStreamPacket =
+    | ScrcpyVideoStreamConfigurationPacket
+    | ScrcpyVideoStreamFramePacket;
 
 export interface ScrcpyOptions<T> {
     value: Partial<T>;
 
+    getDefaultValue(): T;
+
     formatServerArguments(): string[];
 
     getOutputEncoderNameRegex(): RegExp;
 
-    createConnection(adb: Adb): ScrcpyClientConnection;
-
-    createVideoStreamTransformer(): TransformStream<Uint8Array, VideoStreamPacket>;
+    createVideoStreamTransformer(): TransformStream<Uint8Array, ScrcpyVideoStreamPacket>;
 
     getControlMessageTypes(): ScrcpyControlMessageType[];
 
     serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnEvent1_18,
+        message: ScrcpyBackOrScreenOnControlMessage1_18,
     ): Uint8Array | undefined;
 
     serializeInjectScrollControlMessage(

package/tsconfig.build.json

@@ -0,0 +1,3 @@
+{
+    "extends": "./node_modules/@yume-chan/ts-package-builder/tsconfig.base.json"
+}