@yume-chan/scrcpy 0.0.17 → 0.0.18

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

@@ -1,19 +1,38 @@
-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';
+import {
+    StructDeserializeStream,
+    TransformStream,
+} from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
+
+import {
+    AndroidKeyEventAction,
+    ScrcpyControlMessageType,
+    type ScrcpyBackOrScreenOnControlMessage,
+    type ScrcpySetClipboardControlMessage,
+} from "../../control/index.js";
+import {
+    toScrcpyOptionValue,
+    type ScrcpyOptions,
+    type ScrcpyVideoStreamPacket,
+} from "../types.js";
+
+import { CodecOptions } from "./codec-options.js";
+import {
+    parseH264Configuration,
+    parseSequenceParameterSet,
+    removeH264Emulation,
+} from "./h264-configuration.js";
+import {
+    ScrcpyScrollController1_16,
+    type ScrcpyScrollController,
+} from "./scroll.js";
 
 export enum ScrcpyLogLevel {
-    Verbose = 'verbose',
-    Debug = 'debug',
-    Info = 'info',
-    Warn = 'warn',
-    Error = 'error',
+    Verbose = "verbose",
+    Debug = "debug",
+    Info = "info",
+    Warn = "warn",
+    Error = "error",
 }
 
 export enum ScrcpyVideoOrientation {
@@ -83,40 +102,44 @@ export interface ScrcpyOptionsInit1_16 {
     encoderName: string;
 }
 
-export const VideoPacket =
-    new Struct()
-        .uint64('pts')
-        .uint32('size')
-        .uint8Array('data', { lengthField: 'size' });
+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> {
+export const ScrcpyBackOrScreenOnControlMessage1_16 = new Struct().uint8(
+    "type",
+    ScrcpyControlMessageType.BackOrScreenOn as const
+);
+
+export const ScrcpySetClipboardControlMessage1_15 = new Struct()
+    .uint8("type", ScrcpyControlMessageType.SetClipboard as const)
+    .uint32("length")
+    .string("content", { lengthField: "length" });
+
+export type ScrcpySetClipboardControlMessage1_15 =
+    typeof ScrcpySetClipboardControlMessage1_15["TInit"];
+
+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) {
+        if (
+            new.target === ScrcpyOptions1_16 &&
+            value.logLevel === ScrcpyLogLevel.Verbose
+        ) {
             value.logLevel = ScrcpyLogLevel.Debug;
         }
 
-        if (new.target === ScrcpyOptions1_16 &&
-            value.lockVideoOrientation === ScrcpyVideoOrientation.Initial) {
+        if (
+            new.target === ScrcpyOptions1_16 &&
+            value.lockVideoOrientation === ScrcpyVideoOrientation.Initial
+        ) {
             value.lockVideoOrientation = ScrcpyVideoOrientation.Unlocked;
         }
 
@@ -125,20 +148,20 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
 
     protected getArgumentOrder(): (keyof T)[] {
         return [
-            'logLevel',
-            'maxSize',
-            'bitRate',
-            'maxFps',
-            'lockVideoOrientation',
-            'tunnelForward',
-            'crop',
-            'sendFrameMeta',
-            'control',
-            'displayId',
-            'showTouches',
-            'stayAwake',
-            'codecOptions',
-            'encoderName',
+            "logLevel",
+            "maxSize",
+            "bitRate",
+            "maxFps",
+            "lockVideoOrientation",
+            "tunnelForward",
+            "crop",
+            "sendFrameMeta",
+            "control",
+            "displayId",
+            "showTouches",
+            "stayAwake",
+            "codecOptions",
+            "encoderName",
         ];
     }
 
@@ -150,37 +173,38 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
             maxFps: 0,
             lockVideoOrientation: ScrcpyVideoOrientation.Unlocked,
             tunnelForward: false,
-            crop: '-',
+            crop: "-",
             sendFrameMeta: true,
             control: true,
             displayId: 0,
             showTouches: false,
             stayAwake: false,
             codecOptions: new CodecOptions({}),
-            encoderName: '-',
+            encoderName: "-",
         } as T;
     }
 
     public formatServerArguments(): string[] {
         const defaults = this.getDefaultValue();
-        return this.getArgumentOrder()
-            .map(
-                key =>
-                    toScrcpyOptionValue(this.value[key] || defaults[key], '-')
-            );
+        return this.getArgumentOrder().map((key) =>
+            toScrcpyOptionValue(this.value[key] || defaults[key], "-")
+        );
     }
 
     public getOutputEncoderNameRegex(): RegExp {
         return /\s+scrcpy --encoder-name '(.*?)'/;
     }
 
-    public createVideoStreamTransformer(): TransformStream<Uint8Array, ScrcpyVideoStreamPacket> {
+    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',
+                        type: "frame",
                         data: chunk,
                     });
                 },
@@ -189,74 +213,91 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
 
         let header: Uint8Array | undefined;
 
-        let deserializeStream = new StructDeserializeStream(VideoPacket);
+        const 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;
+            readable: deserializeStream.readable.pipeThrough(
+                new TransformStream({
+                    transform(packet, controller) {
+                        if (packet.pts === NO_PTS) {
+                            const {
+                                sequenceParameterSet,
+                                pictureParameterSet,
+                            } = parseH264Configuration(packet.data);
+
+                            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,
+                            } = parseSequenceParameterSet(
+                                removeH264Emulation(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",
+                                pictureParameterSet,
+                                sequenceParameterSet,
+                                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: 'configuration',
-                            data: {
-                                profileIndex,
-                                constraintSet,
-                                levelIndex,
-                                encodedWidth,
-                                encodedHeight,
-                                cropLeft,
-                                cropRight,
-                                cropTop,
-                                cropBottom,
-                                croppedWidth,
-                                croppedHeight,
-                            }
+                            type: "frame",
+                            pts: packet.pts,
+                            data: frameData,
                         });
-                        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,
-                    });
-                }
-            }))
+                    },
+                })
+            ),
         };
     }
 
@@ -277,7 +318,7 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
     }
 
     public serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage1_18,
+        message: ScrcpyBackOrScreenOnControlMessage
     ) {
         if (message.action === AndroidKeyEventAction.Down) {
             return ScrcpyBackOrScreenOnControlMessage1_16.serialize(message);
@@ -286,9 +327,13 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
         return undefined;
     }
 
-    public serializeInjectScrollControlMessage(
-        message: ScrcpyInjectScrollControlMessage1_22,
+    public serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage
     ): Uint8Array {
-        return ScrcpyInjectScrollControlMessage1_16.serialize(message);
+        return ScrcpySetClipboardControlMessage1_15.serialize(message);
+    }
+
+    public getScrollController(): ScrcpyScrollController {
+        return new ScrcpyScrollController1_16();
     }
 }

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

@@ -0,0 +1,76 @@
+import Struct from "@yume-chan/struct";
+
+import {
+    ScrcpyControlMessageType,
+    type ScrcpyInjectScrollControlMessage,
+} from "../../control/index.js";
+
+export interface ScrcpyScrollController {
+    serializeScrollMessage(
+        message: ScrcpyInjectScrollControlMessage
+    ): Uint8Array | undefined;
+}
+
+export const ScrcpyInjectScrollControlMessage1_16 = new Struct()
+    .uint8("type", ScrcpyControlMessageType.InjectScroll as const)
+    .uint32("pointerX")
+    .uint32("pointerY")
+    .uint16("screenWidth")
+    .uint16("screenHeight")
+    .int32("scrollX")
+    .int32("scrollY");
+
+/**
+ * Old version of Scrcpy server only supports integer values for scroll.
+ *
+ * Accumulate scroll values and send scroll message when accumulated value
+ * reaches 1 or -1.
+ */
+export class ScrcpyScrollController1_16 implements ScrcpyScrollController {
+    private accumulatedX = 0;
+    private accumulatedY = 0;
+
+    protected processMessage(
+        message: ScrcpyInjectScrollControlMessage
+    ): ScrcpyInjectScrollControlMessage | undefined {
+        this.accumulatedX += message.scrollX;
+        this.accumulatedY += message.scrollY;
+
+        let scrollX = 0;
+        let scrollY = 0;
+        if (this.accumulatedX >= 1) {
+            scrollX = 1;
+            this.accumulatedX = 0;
+        } else if (this.accumulatedX <= -1) {
+            scrollX = -1;
+            this.accumulatedX = 0;
+        }
+
+        if (this.accumulatedY >= 1) {
+            scrollY = 1;
+            this.accumulatedY = 0;
+        } else if (this.accumulatedY <= -1) {
+            scrollY = -1;
+            this.accumulatedY = 0;
+        }
+
+        if (scrollX === 0 && scrollY === 0) {
+            return undefined;
+        }
+
+        message.scrollX = scrollX;
+        message.scrollY = scrollY;
+        return message;
+    }
+
+    public serializeScrollMessage(
+        message: ScrcpyInjectScrollControlMessage
+    ): Uint8Array | undefined {
+        const processed = this.processMessage(message);
+        if (!processed) {
+            return undefined;
+        }
+
+        return ScrcpyInjectScrollControlMessage1_16.serialize(processed);
+    }
+}

package/src/options/1_18.ts

@@ -1,27 +1,37 @@
-import Struct, { placeholder } from '@yume-chan/struct';
+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';
+import {
+    ScrcpyControlMessageType,
+    type AndroidKeyEventAction,
+    type ScrcpyBackOrScreenOnControlMessage,
+} 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 ScrcpyBackOrScreenOnControlMessage1_18 =
-    new Struct()
-        .fields(ScrcpyBackOrScreenOnControlMessage1_16)
-        .uint8('action', placeholder<AndroidKeyEventAction>());
+export const ScrcpyBackOrScreenOnControlMessage1_18 = new Struct()
+    .fields(ScrcpyBackOrScreenOnControlMessage1_16)
+    .uint8("action", placeholder<AndroidKeyEventAction>());
 
-export type ScrcpyBackOrScreenOnControlMessage1_18 = typeof ScrcpyBackOrScreenOnControlMessage1_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);
     }
 
     protected override getArgumentOrder(): (keyof T)[] {
-        return super.getArgumentOrder().concat(['powerOffOnClose']);
+        return super.getArgumentOrder().concat(["powerOffOnClose"]);
     }
 
     public override getDefaultValue(): T {
@@ -56,7 +66,7 @@ export class ScrcpyOptions1_18<T extends ScrcpyOptionsInit1_18 = ScrcpyOptionsIn
     }
 
     public override serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage1_18,
+        message: ScrcpyBackOrScreenOnControlMessage
     ) {
         return ScrcpyBackOrScreenOnControlMessage1_18.serialize(message);
     }

package/src/options/1_21.ts

@@ -1,18 +1,36 @@
 // cspell: ignore autosync
 
-import { ScrcpyOptions1_18, type ScrcpyOptionsInit1_18 } from './1_18.js';
-import { toScrcpyOptionValue } from './types.js';
+import Struct from "@yume-chan/struct";
+
+import {
+    ScrcpyControlMessageType,
+    type ScrcpySetClipboardControlMessage,
+} from "../control/index.js";
+
+import { ScrcpyOptions1_18, type ScrcpyOptionsInit1_18 } from "./1_18.js";
+import { toScrcpyOptionValue } from "./types.js";
 
 export interface ScrcpyOptionsInit1_21 extends ScrcpyOptionsInit1_18 {
     clipboardAutosync?: boolean;
 }
 
 function toSnakeCase(input: string): string {
-    return input.replace(/([A-Z])/g, '_$1').toLowerCase();
+    return input.replace(/([A-Z])/g, "_$1").toLowerCase();
 }
 
-export class ScrcpyOptions1_21<T extends ScrcpyOptionsInit1_21 = ScrcpyOptionsInit1_21>
-    extends ScrcpyOptions1_18<T> {
+export const ScrcpySetClipboardControlMessage1_21 = new Struct()
+    .uint8("type", ScrcpyControlMessageType.SetClipboard as const)
+    .uint64("sequence")
+    .int8("paste")
+    .uint32("length")
+    .string("content", { lengthField: "length" });
+
+export type ScrcpySetClipboardControlMessage1_21 =
+    typeof ScrcpySetClipboardControlMessage1_21["TInit"];
+
+export class ScrcpyOptions1_21<
+    T extends ScrcpyOptionsInit1_21 = ScrcpyOptionsInit1_21
+> extends ScrcpyOptions1_18<T> {
     public constructor(init: Partial<ScrcpyOptionsInit1_21>) {
         super(init);
     }
@@ -32,13 +50,13 @@ export class ScrcpyOptions1_21<T extends ScrcpyOptionsInit1_21 = ScrcpyOptionsIn
                 ([key, value]) =>
                     [key, toScrcpyOptionValue(value, undefined)] as const
             )
-            .filter(
-                (pair): pair is [string, string] =>
-                    pair[1] !== undefined
-            )
-            .map(
-                ([key, value]) =>
-                    `${toSnakeCase(key)}=${value}`
-            );
+            .filter((pair): pair is [string, string] => pair[1] !== undefined)
+            .map(([key, value]) => `${toSnakeCase(key)}=${value}`);
+    }
+
+    public override serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage
+    ): Uint8Array {
+        return ScrcpySetClipboardControlMessage1_21.serialize(message);
     }
 }

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

@@ -0,0 +1,2 @@
+export * from "./options.js";
+export * from "./scroll.js";

package/src/options/{1_22.ts → 1_22/options.ts}

@@ -1,7 +1,7 @@
-import Struct from '@yume-chan/struct';
+import { type ScrcpyScrollController } from "../1_16/index.js";
+import { ScrcpyOptions1_21, type ScrcpyOptionsInit1_21 } from "../1_21.js";
 
-import { ScrcpyInjectScrollControlMessage1_16 } from './1_16/options.js';
-import { ScrcpyOptions1_21, type ScrcpyOptionsInit1_21 } from './1_21.js';
+import { ScrcpyScrollController1_22 } from "./scroll.js";
 
 export interface ScrcpyOptionsInit1_22 extends ScrcpyOptionsInit1_21 {
     downsizeOnError: boolean;
@@ -28,16 +28,9 @@ export interface ScrcpyOptionsInit1_22 extends ScrcpyOptionsInit1_21 {
     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> {
+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
@@ -59,9 +52,7 @@ export class ScrcpyOptions1_22<T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsIn
         };
     }
 
-    public override serializeInjectScrollControlMessage(
-        message: ScrcpyInjectScrollControlMessage1_22,
-    ): Uint8Array {
-        return ScrcpyInjectScrollControlMessage1_22.serialize(message);
+    public override getScrollController(): ScrcpyScrollController {
+        return new ScrcpyScrollController1_22();
     }
 }

package/src/options/1_22/scroll.ts

@@ -0,0 +1,26 @@
+import Struct from "@yume-chan/struct";
+
+import {
+    ScrcpyInjectScrollControlMessage1_16,
+    ScrcpyScrollController1_16,
+} from "../1_16/index.js";
+
+export const ScrcpyInjectScrollControlMessage1_22 = new Struct()
+    .fields(ScrcpyInjectScrollControlMessage1_16)
+    .int32("buttons");
+
+export type ScrcpyInjectScrollControlMessage1_22 =
+    typeof ScrcpyInjectScrollControlMessage1_22["TInit"];
+
+export class ScrcpyScrollController1_22 extends ScrcpyScrollController1_16 {
+    public override serializeScrollMessage(
+        message: ScrcpyInjectScrollControlMessage1_22
+    ): Uint8Array | undefined {
+        const processed = this.processMessage(message);
+        if (!processed) {
+            return undefined;
+        }
+
+        return ScrcpyInjectScrollControlMessage1_22.serialize(processed);
+    }
+}