@apocaliss92/scrypted-reolink-native 0.1.29 → 0.1.31

package/src/multiFocal.ts

@@ -1,10 +1,12 @@
-import type { DeviceCapabilities, DualLensChannelAnalysis, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import sdk, { Device, DeviceProvider, MediaObject, Reboot, ScryptedDeviceType, Setting, Settings, SettingValue } from "@scrypted/sdk";
+import type { DeviceCapabilities, DualLensChannelAnalysis, ReolinkSimpleEvent, ReolinkSupportedStream } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import sdk, { Device, DeviceProvider, MediaObject, Reboot, RequestMediaStreamOptions, ScryptedDeviceType, Setting, Settings, SettingValue } from "@scrypted/sdk";
 import { type BaichuanConnectionCallbacks } from "./baichuan-base";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
 import { CameraType, CommonCameraMixin } from "./common";
 import ReolinkNativePlugin from "./main";
+import { StreamManager } from "./stream-utils";
+import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces, updateDeviceInfo } from "./utils";
 
 export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements Settings, DeviceProvider, Reboot {
@@ -34,19 +36,6 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
         }
     }
 
-    async reboot(): Promise<void> {
-        const api = await this.ensureBaichuanClient();
-        await api.reboot();
-    }
-
-    takePicture(options?: any): Promise<MediaObject> {
-        throw new Error("Method not implemented.");
-    }
-
-    getPictureOptions(): Promise<any[]> {
-        throw new Error("Method not implemented.");
-    }
-
     protected getConnectionCallbacks(): BaichuanConnectionCallbacks {
         return {
             onError: undefined, // Use default error handling
@@ -73,10 +62,6 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
         await this.unsubscribeFromAllEvents();
     }
 
-    protected isDebugEnabled(): boolean {
-        return this.storageSettings.values.debugEvents || false;
-    }
-
     protected getDeviceName(): string {
         return this.name || 'Multi-Focal Device';
     }
@@ -148,7 +133,8 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
 
     getInterfaces(channel: number) {
         const logger = this.getBaichuanLogger();
-        const { capabilities: caps, multifocalInfo } = this.storageSettings.values;
+        const values = this.storageSettings.values as any;
+        const { capabilities: caps, multifocalInfo } = values;
         const channelInfo = (multifocalInfo as DualLensChannelAnalysis).channels.find(c => c.channel === channel);
 
         const capabilities: DeviceCapabilities = {
@@ -234,6 +220,53 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
         }
 
         await super.reportDevices();
+
+        // Initialize StreamManager with composite options for multifocal device
+        // Use saved settings or defaults
+        const values = this.storageSettings.values as any;
+        const pipPosition = (values.pipPosition || 'bottom-right') as any;
+        const pipSize = values.pipSize ?? 0.25;
+        const pipMargin = values.pipMargin ?? 10;
+        const widerChannel = values.widerChannel ?? 0;
+        const teleChannel = values.teleChannel ?? 1;
+
+        if (!this.streamManager) {
+            this.streamManager = new StreamManager({
+                createStreamClient: () => this.createStreamClient(),
+                getLogger: () => logger,
+                credentials: {
+                    username,
+                    password
+                },
+                sharedConnection: this.isBattery,
+                compositeOptions: {
+                    widerChannel,
+                    teleChannel,
+                    pipPosition: pipPosition as any,
+                    pipSize,
+                    pipMargin,
+                },
+            });
+        } else {
+            // Recreate StreamManager with new settings if they changed
+            // StreamManager doesn't expose opts, so we need to recreate it
+            this.streamManager = new StreamManager({
+                createStreamClient: () => this.createStreamClient(),
+                getLogger: () => logger,
+                credentials: {
+                    username,
+                    password
+                },
+                sharedConnection: this.isBattery,
+                compositeOptions: {
+                    widerChannel,
+                    teleChannel,
+                    pipPosition: pipPosition as any,
+                    pipSize,
+                    pipMargin,
+                },
+            });
+        }
     }
 
     async getDevice(nativeId: string) {

package/src/nvr.ts

@@ -10,7 +10,7 @@ import { getDeviceInterfaces, updateDeviceInfo } from "./utils";
 
 export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Settings, DeviceDiscovery, DeviceProvider, Reboot {
     storageSettings = new StorageSettings(this, {
-        debugEvents: {
+        debugLogs: {
             title: 'Debug Events',
             type: 'boolean',
             immediate: true,
@@ -68,6 +68,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     lastDevicesStatusCheck: number | undefined;
     cameraNativeMap = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
     private channelToNativeIdMap = new Map<number, string>();
+    private discoverDevicesPromise: Promise<DiscoveredDevice[]> | undefined;
     processing = false;
     private initReinitTimeout: NodeJS.Timeout | undefined;
 
@@ -116,7 +117,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
 
     protected isDebugEnabled(): boolean {
-        return this.storageSettings.values.debugEvents || false;
+        return this.storageSettings.values.debugLogs || false;
     }
 
     protected getDeviceName(): string {
@@ -333,11 +334,11 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
     async init() {
         const logger = this.getBaichuanLogger();
-        
+
         // Ensure both APIs are ready before proceeding
         const api = await this.ensureClient();
         await this.ensureBaichuanClient();
-        
+
         await this.updateDeviceInfo();
 
         await this.reinitEventSubscriptions();
@@ -356,7 +357,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 }
 
                 if (!this.lastNvrInfoCheck || now - this.lastNvrInfoCheck > 1000 * 60 * 5) {
-                    logger.log('Starting NVR info data fetch');
                     this.lastNvrInfoCheck = now;
                     const { nvrData } = await api.getNvrInfo();
                     const { devicesData, channelsResponse, response } = await api.getDevicesInfo();
@@ -468,11 +468,11 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
     async syncEntitiesFromRemote() {
         const logger = this.getBaichuanLogger();
-        
+
         // Ensure both APIs are ready before syncing
         const api = await this.ensureClient();
         const baichuanApi = await this.ensureBaichuanClient();
-        
+
         // Wait for Baichuan connection to be fully established
         if (baichuanApi?.client) {
             // Check if already connected
@@ -555,10 +555,28 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     }
 
     async discoverDevices(scan?: boolean): Promise<DiscoveredDevice[]> {
+        // If a discovery is already in progress, return that promise
+        if (this.discoverDevicesPromise) {
+            return await this.discoverDevicesPromise;
+        }
+
+        // If scan is requested, start a new discovery
         if (scan) {
-            await this.syncEntitiesFromRemote();
+            this.discoverDevicesPromise = (async () => {
+                try {
+                    await this.syncEntitiesFromRemote();
+                    return [...this.discoveredDevices.values()].map(d => ({
+                        ...d.device,
+                        description: d.description,
+                    }));
+                } finally {
+                    this.discoverDevicesPromise = undefined;
+                }
+            })();
+            return await this.discoverDevicesPromise;
         }
 
+        // If no scan requested, return cached devices immediately
         return [...this.discoveredDevices.values()].map(d => ({
             ...d.device,
             description: d.description,

package/src/stream-utils.ts

@@ -1,6 +1,7 @@
 import type {
+    CompositeStreamPipOptions,
     ReolinkBaichuanApi,
-    ScryptedRfc4571TcpServer,
+    Rfc4571TcpServer,
     StreamProfile,
     VideoType,
 } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
@@ -29,6 +30,8 @@ export interface StreamManagerOptions {
     };
     /** If true, the stream client is shared with the main connection. Default: false. */
     sharedConnection?: boolean;
+    /** Composite stream options for multifocal cameras */
+    compositeOptions?: CompositeStreamPipOptions;
 }
 
 export function parseStreamProfileFromId(id: string | undefined): StreamProfile | undefined {
@@ -102,6 +105,56 @@ export async function createRfc4571MediaObjectFromStreamManager(params: {
         // ignore
     }
 
+    const { url: _ignoredUrl, ...mso }: any = selected;
+    mso.container = 'rtp';
+    if (audio) {
+        mso.audio ||= {};
+        mso.audio.codec = audio.codec;
+        mso.audio.sampleRate = audio.sampleRate;
+        mso.audio.channels = audio.channels;
+    }
+    const url = new URL(host);
+    url.port = port.toString();
+    url.protocol = 'tcp';
+    url.username = username;
+    url.password = password;
+
+    const rfc = {
+        url,
+        sdp,
+        mediaStreamOptions: mso as ResponseMediaStreamOptions,
+    };
+
+    return await sdk.mediaManager.createMediaObject(Buffer.from(JSON.stringify(rfc)), 'x-scrypted/x-rfc4571', {
+        sourceId,
+    });
+}
+
+export async function createRfc4571CompositeMediaObjectFromStreamManager(params: {
+    streamManager: StreamManager;
+    profile: StreamProfile;
+    streamKey: string;
+    expectedVideoType?: 'H264' | 'H265';
+    selected: UrlMediaStreamOptions;
+    sourceId: string;
+    onDetectedCodec?: (detectedCodec: 'h264' | 'h265') => void;
+}): Promise<MediaObject> {
+    const { streamManager, profile, streamKey, expectedVideoType, selected, sourceId, onDetectedCodec } = params;
+
+    const { host, port, sdp, audio, username, password } = await streamManager.getRfcCompositeStream(profile, streamKey, expectedVideoType);
+
+    // Update cached stream options with the detected codec (helps prebuffer/NVR avoid mismatch).
+    try {
+        const detected = /a=rtpmap:\d+\s+(H26[45])\//.exec(sdp)?.[1];
+        if (detected) {
+            const dc = detected === 'H265' ? 'h265' : 'h264';
+            onDetectedCodec?.(dc);
+        }
+    }
+    catch {
+        // ignore
+    }
+
     const { url: _ignoredUrl, ...mso }: any = selected;
     mso.container = 'rtp';
     if (audio) {
@@ -137,14 +190,14 @@ type RfcServerInfo = {
 };
 
 export class StreamManager {
-    private nativeRfcServers = new Map<string, ScryptedRfc4571TcpServer>();
+    private nativeRfcServers = new Map<string, Rfc4571TcpServer>();
     private nativeRfcServerCreatePromises = new Map<string, Promise<RfcServerInfo>>();
 
     constructor(private opts: StreamManagerOptions) {
     }
 
     private getLogger() {
-        return this.opts.getLogger() as Console;
+        return this.opts.getLogger() ;
     }
 
     private async ensureNativeRfcServer(
@@ -189,7 +242,7 @@ export class StreamManager {
             }
 
             const api = await this.opts.createStreamClient();
-            const { createScryptedRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
+            const { createRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
 
             // Use the same credentials as the main connection
             const { username, password } = this.opts.credentials;
@@ -197,7 +250,7 @@ export class StreamManager {
             // If connection is shared, don't close it when stream teardown happens
             const closeApiOnTeardown = !(this.opts.sharedConnection ?? false);
 
-            const created = await createScryptedRfc4571TcpServer({
+            const created = await createRfc4571TcpServer({
                 api,
                 channel,
                 profile,
@@ -242,6 +295,92 @@ export class StreamManager {
         return await this.ensureNativeRfcServer(streamKey, channel, profile, expectedVideoType);
     }
 
+    async getRfcCompositeStream(
+        profile: StreamProfile,
+        streamKey: string,
+        expectedVideoType?: 'H264' | 'H265',
+    ): Promise<RfcServerInfo> {
+        const existingCreate = this.nativeRfcServerCreatePromises.get(streamKey);
+        if (existingCreate) {
+            return await existingCreate;
+        }
+
+        const createPromise = (async () => {
+            const cached = this.nativeRfcServers.get(streamKey);
+            if (cached?.server?.listening) {
+                if (expectedVideoType && cached.videoType !== expectedVideoType) {
+                    this.getLogger().warn(
+                        `Native RFC composite cache codec mismatch for ${streamKey}: cached=${cached.videoType} expected=${expectedVideoType}; recreating server.`,
+                    );
+                }
+                else {
+                    return {
+                        host: cached.host,
+                        port: cached.port,
+                        sdp: cached.sdp,
+                        audio: cached.audio,
+                        username: (cached as any).username || this.opts.credentials.username,
+                        password: (cached as any).password || this.opts.credentials.password,
+                    };
+                }
+            }
+
+            if (cached) {
+                try {
+                    await cached.close('recreate');
+                }
+                catch {
+                    // ignore
+                }
+                this.nativeRfcServers.delete(streamKey);
+            }
+
+            const api = await this.opts.createStreamClient();
+            const { createRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
+
+            // Use the same credentials as the main connection
+            const { username, password } = this.opts.credentials;
+
+            // If connection is shared, don't close it when stream teardown happens
+            const closeApiOnTeardown = !(this.opts.sharedConnection ?? false);
+
+            const created = await createRfc4571TcpServer({
+                api,
+                channel: undefined, // Undefined channel indicates composite stream
+                profile,
+                logger: this.getLogger(),
+                expectedVideoType: expectedVideoType as VideoType | undefined,
+                closeApiOnTeardown,
+                username,
+                password,
+                compositeOptions: this.opts.compositeOptions,
+            });
+
+            this.nativeRfcServers.set(streamKey, created);
+            created.server.once('close', () => {
+                const current = this.nativeRfcServers.get(streamKey);
+                if (current?.server === created.server) this.nativeRfcServers.delete(streamKey);
+            });
+
+            return {
+                host: created.host,
+                port: created.port,
+                sdp: created.sdp,
+                audio: created.audio,
+                username: (created as any).username || this.opts.credentials.username,
+                password: (created as any).password || this.opts.credentials.password,
+            };
+        })();
+
+        this.nativeRfcServerCreatePromises.set(streamKey, createPromise);
+        try {
+            return await createPromise;
+        }
+        finally {
+            this.nativeRfcServerCreatePromises.delete(streamKey);
+        }
+    }
+
     /**
      * Close all active stream servers.
      * Useful when the main connection is reset and streams need to be recreated.