@yume-chan/scrcpy 0.0.11

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

@@ -0,0 +1,300 @@
+// cspell: ignore golomb
+// cspell: ignore qpprime
+
+class BitReader {
+    private buffer: Uint8Array;
+
+    private bytePosition = 0;
+
+    private bitPosition = 0;
+
+    public constructor(buffer: Uint8Array) {
+        this.buffer = buffer;
+    }
+
+    public read(length: number): number {
+        let result = 0;
+        for (let i = 0; i < length; i += 1) {
+            result = (result << 1) | this.next();
+        }
+        return result;
+    }
+
+    public next(): number {
+        const value = (this.buffer[this.bytePosition]! >> (7 - this.bitPosition)) & 1;
+        this.bitPosition += 1;
+        if (this.bitPosition === 8) {
+            this.bytePosition += 1;
+            this.bitPosition = 0;
+        }
+        return value;
+    }
+
+    public decodeExponentialGolombNumber(): number {
+        let length = 0;
+        while (this.next() === 0) {
+            length += 1;
+        }
+        if (length === 0) {
+            return 0;
+        }
+        return (1 << length | this.read(length)) - 1;
+    }
+}
+
+function* iterateNalu(buffer: Uint8Array): Generator<Uint8Array> {
+    // -1 means we haven't found the first start code
+    let start = -1;
+    let writeIndex = 0;
+
+    // How many `0x00`s in a row we have counted
+    let zeroCount = 0;
+
+    let inEmulation = false;
+
+    for (const byte of buffer) {
+        buffer[writeIndex] = byte;
+        writeIndex += 1;
+
+        if (inEmulation) {
+            if (byte > 0x03) {
+                // `0x00000304` or larger are invalid
+                throw new Error('Invalid data');
+            }
+
+            inEmulation = false;
+            continue;
+        }
+
+        if (byte == 0x00) {
+            zeroCount += 1;
+            continue;
+        }
+
+        const lastZeroCount = zeroCount;
+        zeroCount = 0;
+
+        if (start === -1) {
+            // 0x000001 is the start code
+            // But it can be preceded by any number of zeros
+            // So 2 is the minimal
+            if (lastZeroCount >= 2 && byte === 0x01) {
+                // Found start of first NAL unit
+                writeIndex = 0;
+                start = 0;
+                continue;
+            }
+
+            // Not begin with start code
+            throw new Error('Invalid data');
+        }
+
+        if (lastZeroCount < 2) {
+            // zero or one `0x00`s are acceptable
+            continue;
+        }
+
+        if (byte === 0x01) {
+            // Remove all leading `0x00`s and this `0x01`
+            writeIndex -= lastZeroCount + 1;
+
+            // Found another NAL unit
+            yield buffer.subarray(start, writeIndex);
+
+            start = writeIndex;
+            continue;
+        }
+
+        if (lastZeroCount > 2) {
+            // Too much `0x00`s
+            throw new Error('Invalid data');
+        }
+
+        switch (byte) {
+            case 0x02:
+                // Didn't find why, but 7.4.1 NAL unit semantics forbids `0x000002` appearing in NAL units
+                throw new Error('Invalid data');
+            case 0x03:
+                // `0x000003` is the "emulation_prevention_three_byte"
+                // `0x00000300`, `0x00000301`, `0x00000302` and `0x00000303` represent
+                // `0x000000`, `0x000001`, `0x000002` and `0x000003` respectively
+
+                // Remove current byte
+                writeIndex -= 1;
+
+                inEmulation = true;
+                break;
+            default:
+                // `0x000004` or larger are ok
+                break;
+        }
+    }
+
+    if (inEmulation || zeroCount !== 0) {
+        throw new Error('Invalid data');
+    }
+
+    yield buffer.subarray(start, writeIndex);
+}
+
+// 7.3.2.1.1 Sequence parameter set data syntax
+export function parse_sequence_parameter_set(buffer: ArrayBuffer) {
+    for (const nalu of iterateNalu(new Uint8Array(buffer))) {
+        const reader = new BitReader(nalu);
+        if (reader.next() !== 0) {
+            throw new Error('Invalid data');
+        }
+
+        const nal_ref_idc = reader.read(2);
+        const nal_unit_type = reader.read(5);
+
+        if (nal_unit_type !== 7) {
+            continue;
+        }
+
+        if (nal_ref_idc === 0) {
+            throw new Error('Invalid data');
+        }
+
+        const profile_idc = reader.read(8);
+        const constraint_set = reader.read(8);
+
+        const constraint_set_reader = new BitReader(new Uint8Array([constraint_set]));
+        const constraint_set0_flag = !!constraint_set_reader.next();
+        const constraint_set1_flag = !!constraint_set_reader.next();
+        const constraint_set2_flag = !!constraint_set_reader.next();
+        const constraint_set3_flag = !!constraint_set_reader.next();
+        const constraint_set4_flag = !!constraint_set_reader.next();
+        const constraint_set5_flag = !!constraint_set_reader.next();
+
+        // reserved_zero_2bits
+        if (constraint_set_reader.read(2) !== 0) {
+            throw new Error('Invalid data');
+        }
+
+        const level_idc = reader.read(8);
+        const seq_parameter_set_id = reader.decodeExponentialGolombNumber();
+
+        if (profile_idc === 100 || profile_idc === 110 ||
+            profile_idc === 122 || profile_idc === 244 || profile_idc === 44 ||
+            profile_idc === 83 || profile_idc === 86 || profile_idc === 118 ||
+            profile_idc === 128 || profile_idc === 138 || profile_idc === 139 ||
+            profile_idc === 134) {
+            const chroma_format_idc = reader.decodeExponentialGolombNumber();
+            if (chroma_format_idc === 3) {
+                // separate_colour_plane_flag
+                reader.next();
+            }
+
+            // bit_depth_luma_minus8
+            reader.decodeExponentialGolombNumber();
+            // bit_depth_chroma_minus8
+            reader.decodeExponentialGolombNumber();
+
+            // qpprime_y_zero_transform_bypass_flag
+            reader.next();
+
+            const seq_scaling_matrix_present_flag = !!reader.next();
+            if (seq_scaling_matrix_present_flag) {
+                const seq_scaling_list_present_flag: boolean[] = [];
+                for (let i = 0; i < ((chroma_format_idc !== 3) ? 8 : 12); i++) {
+                    seq_scaling_list_present_flag[i] = !!reader.next();
+                    if (seq_scaling_list_present_flag[i])
+                        if (i < 6) {
+                            // TODO
+                            // scaling_list( ScalingList4x4[ i ], 16,
+                            //               UseDefaultScalingMatrix4x4Flag[ i ])
+                        } else {
+                            // TODO
+                            // scaling_list( ScalingList8x8[ i − 6 ], 64,
+                            //               UseDefaultScalingMatrix8x8Flag[ i − 6 ] )
+                        }
+                }
+            }
+        }
+
+        // log2_max_frame_num_minus4
+        reader.decodeExponentialGolombNumber();
+        const pic_order_cnt_type = reader.decodeExponentialGolombNumber();
+        if (pic_order_cnt_type === 0) {
+            // log2_max_pic_order_cnt_lsb_minus4
+            reader.decodeExponentialGolombNumber();
+        } else if (pic_order_cnt_type === 1) {
+            // delta_pic_order_always_zero_flag
+            reader.next();
+            // offset_for_non_ref_pic
+            reader.decodeExponentialGolombNumber();
+            // offset_for_top_to_bottom_field
+            reader.decodeExponentialGolombNumber();
+            const num_ref_frames_in_pic_order_cnt_cycle = reader.decodeExponentialGolombNumber();
+            const offset_for_ref_frame: number[] = [];
+            for (let i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++) {
+                offset_for_ref_frame[i] = reader.decodeExponentialGolombNumber();
+            }
+        }
+
+        // max_num_ref_frames
+        reader.decodeExponentialGolombNumber();
+        // gaps_in_frame_num_value_allowed_flag
+        reader.next();
+        const pic_width_in_mbs_minus1 = reader.decodeExponentialGolombNumber();
+        const pic_height_in_map_units_minus1 = reader.decodeExponentialGolombNumber();
+
+        const frame_mbs_only_flag = reader.next();
+        if (!frame_mbs_only_flag) {
+            // mb_adaptive_frame_field_flag
+            reader.next();
+        }
+
+        // direct_8x8_inference_flag
+        reader.next();
+
+        const frame_cropping_flag = !!reader.next();
+        let frame_crop_left_offset: number;
+        let frame_crop_right_offset: number;
+        let frame_crop_top_offset: number;
+        let frame_crop_bottom_offset: number;
+        if (frame_cropping_flag) {
+            frame_crop_left_offset = reader.decodeExponentialGolombNumber();
+            frame_crop_right_offset = reader.decodeExponentialGolombNumber();
+            frame_crop_top_offset = reader.decodeExponentialGolombNumber();
+            frame_crop_bottom_offset = reader.decodeExponentialGolombNumber();
+        } else {
+            frame_crop_left_offset = 0;
+            frame_crop_right_offset = 0;
+            frame_crop_top_offset = 0;
+            frame_crop_bottom_offset = 0;
+        }
+
+        const vui_parameters_present_flag = !!reader.next();
+        if (vui_parameters_present_flag) {
+            // TODO
+            // vui_parameters( )
+        }
+
+        return {
+            profile_idc,
+            constraint_set,
+            constraint_set0_flag,
+            constraint_set1_flag,
+            constraint_set2_flag,
+            constraint_set3_flag,
+            constraint_set4_flag,
+            constraint_set5_flag,
+            level_idc,
+            seq_parameter_set_id,
+            pic_width_in_mbs_minus1,
+            pic_height_in_map_units_minus1,
+            frame_mbs_only_flag,
+            frame_cropping_flag,
+            frame_crop_left_offset,
+            frame_crop_right_offset,
+            frame_crop_top_offset,
+            frame_crop_bottom_offset,
+        };
+    }
+
+    throw new Error('Invalid data');
+}
+
+export type SequenceParameterSet = ReturnType<typeof parse_sequence_parameter_set>;

package/src/options/1_18.ts

@@ -0,0 +1,41 @@
+import Struct, { placeholder } from "@yume-chan/struct";
+import type { AndroidKeyEventAction } from "../message.js";
+import { ScrcpyBackOrScreenOnEvent1_16, ScrcpyOptions1_16, type ScrcpyOptionsInit1_16 } from "./1_16/index.js";
+
+export interface ScrcpyOptionsInit1_18 extends ScrcpyOptionsInit1_16 {
+    powerOffOnClose: boolean;
+}
+
+export const ScrcpyBackOrScreenOnEvent1_18 =
+    new Struct()
+        .fields(ScrcpyBackOrScreenOnEvent1_16)
+        .uint8('action', placeholder<AndroidKeyEventAction>());
+
+export type ScrcpyBackOrScreenOnEvent1_18 = typeof ScrcpyBackOrScreenOnEvent1_18["TInit"];
+
+export class ScrcpyOptions1_18<T extends ScrcpyOptionsInit1_18 = ScrcpyOptionsInit1_18> extends ScrcpyOptions1_16<T> {
+    constructor(value: Partial<ScrcpyOptionsInit1_18>) {
+        super(value);
+    }
+
+    protected override getArgumentOrder(): (keyof T)[] {
+        return super.getArgumentOrder().concat(['powerOffOnClose']);
+    }
+
+    protected override getDefaultValue(): T {
+        return {
+            ...super.getDefaultValue(),
+            powerOffOnClose: false,
+        };
+    }
+
+    public override getOutputEncoderNameRegex(): RegExp {
+        return /\s+scrcpy --encoder '(.*?)'/;
+    }
+
+    public override serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnEvent1_18,
+    ) {
+        return ScrcpyBackOrScreenOnEvent1_18.serialize(message);
+    }
+}

package/src/options/1_21.ts

@@ -0,0 +1,34 @@
+// cspell: ignore autosync
+
+import { ScrcpyOptions1_18, type ScrcpyOptionsInit1_18 } from './1_18.js';
+import { toScrcpyOptionValue } from "./common.js";
+
+export interface ScrcpyOptionsInit1_21 extends ScrcpyOptionsInit1_18 {
+    clipboardAutosync?: boolean;
+}
+
+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> {
+    public constructor(init: Partial<ScrcpyOptionsInit1_21>) {
+        super(init);
+    }
+
+    protected override getDefaultValue(): T {
+        return {
+            ...super.getDefaultValue(),
+            clipboardAutosync: true,
+        };
+    }
+
+    public override formatServerArguments(): string[] {
+        // 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}`);
+    }
+}

package/src/options/1_22.ts

@@ -0,0 +1,80 @@
+import type { Adb } from "@yume-chan/adb";
+import Struct from "@yume-chan/struct";
+import { ScrcpyClientForwardConnection, ScrcpyClientReverseConnection, type ScrcpyClientConnection, type ScrcpyClientConnectionOptions } from "../connection.js";
+import { ScrcpyInjectScrollControlMessage1_16 } from "./1_16/index.js";
+import { ScrcpyOptions1_21, type ScrcpyOptionsInit1_21 } from "./1_21.js";
+
+export interface ScrcpyOptionsInit1_22 extends ScrcpyOptionsInit1_21 {
+    downsizeOnError: boolean;
+
+    /**
+     * Send device name and size
+     *
+     * @default true
+     */
+    sendDeviceMeta: boolean;
+
+    /**
+     * Write a byte on start to detect connection issues
+     *
+     * @default true
+     */
+    sendDummyByte: boolean;
+
+    /**
+     * Implies `sendDeviceMeta: false`, `sendFrameMeta: false` and `sendDummyByte: false`
+     *
+     * @default false
+     */
+    rawVideoStream: boolean;
+}
+
+export const ScrcpyInjectScrollControlMessage1_22 =
+    new Struct()
+        .fields(ScrcpyInjectScrollControlMessage1_16)
+        .int32("buttons");
+
+export type ScrcpyInjectScrollControlMessage1_22 = typeof ScrcpyInjectScrollControlMessage1_22["TInit"];
+
+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
+            init.sendDeviceMeta = false;
+            init.sendFrameMeta = false;
+            init.sendDummyByte = false;
+        }
+
+        super(init);
+    }
+
+    protected override getDefaultValue(): T {
+        return {
+            ...super.getDefaultValue(),
+            downsizeOnError: true,
+            sendDeviceMeta: true,
+            sendDummyByte: true,
+            rawVideoStream: false,
+        };
+    }
+
+    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,
+        };
+        if (this.value.tunnelForward) {
+            return new ScrcpyClientForwardConnection(device, options);
+        } else {
+            return new ScrcpyClientReverseConnection(device, options);
+        }
+    }
+
+    public override serializeInjectScrollControlMessage(
+        message: ScrcpyInjectScrollControlMessage1_22,
+    ): Uint8Array {
+        return ScrcpyInjectScrollControlMessage1_22.serialize(message);
+    }
+}

package/src/options/common.ts

@@ -0,0 +1,61 @@
+import type { Adb, AdbBufferedStream, ReadableStream } from "@yume-chan/adb";
+import type { ScrcpyClientConnection } from "../connection.js";
+import type { H264Configuration } from "../decoder/index.js";
+import type { ScrcpyBackOrScreenOnEvent1_18 } from "./1_18.js";
+import type { ScrcpyInjectScrollControlMessage1_22 } from "./1_22.js";
+
+export const DEFAULT_SERVER_PATH = '/data/local/tmp/scrcpy-server.jar';
+
+export interface ScrcpyOptionValue {
+    toOptionValue(): string | undefined;
+}
+
+export function isScrcpyOptionValue(value: any): value is ScrcpyOptionValue {
+    return typeof value === 'object' &&
+        value !== null &&
+        typeof value.toOptionValue === 'function';
+}
+
+export function toScrcpyOptionValue<T>(value: any, empty: T): string | T {
+    if (isScrcpyOptionValue(value)) {
+        value = value.toOptionValue();
+    }
+
+    if (value === undefined) {
+        return empty;
+    }
+
+    return `${value}`;
+}
+
+export interface VideoStreamConfigurationPacket {
+    type: 'configuration';
+    data: H264Configuration;
+}
+
+export interface VideoStreamFramePacket {
+    type: 'frame';
+    data: Uint8Array;
+}
+
+export type VideoStreamPacket = VideoStreamConfigurationPacket | VideoStreamFramePacket;
+
+export interface ScrcpyOptions<T> {
+    value: Partial<T>;
+
+    formatServerArguments(): string[];
+
+    getOutputEncoderNameRegex(): RegExp;
+
+    createConnection(adb: Adb): ScrcpyClientConnection;
+
+    parseVideoStream(stream: AdbBufferedStream): ReadableStream<VideoStreamPacket>;
+
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnEvent1_18,
+    ): Uint8Array | undefined;
+
+    serializeInjectScrollControlMessage(
+        message: ScrcpyInjectScrollControlMessage1_22,
+    ): Uint8Array;
+}

package/src/options/index.ts

@@ -0,0 +1,5 @@
+export * from './1_16/index.js';
+export * from './1_18.js';
+export * from './1_21.js';
+export * from './1_22.js';
+export * from './common.js';

package/src/push-server.ts

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

package/src/utils.ts

@@ -0,0 +1,16 @@
+export function delay(time: number): Promise<void> {
+    return new Promise(resolve => {
+        (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);
+}