@apocaliss92/scrypted-reolink-native 0.2.6 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.2.6",
+   "version": "0.2.8",
    "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
    "author": "@apocaliss92",
    "license": "Apache",

package/src/camera.ts

@@ -207,6 +207,7 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
         // Basic connection settings
         ipAddress: {
             title: 'IP Address',
+            hide: true,
             type: 'string',
             onPut: async () => {
                 await this.credentialsChanged();
@@ -214,6 +215,7 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
         },
         username: {
             type: 'string',
+            hide: true,
             title: 'Username',
             onPut: async () => {
                 await this.credentialsChanged();
@@ -221,6 +223,7 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
         },
         password: {
             type: 'password',
+            hide: true,
             title: 'Password',
             onPut: async () => {
                 await this.credentialsChanged();
@@ -1475,10 +1478,12 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
         }
 
         // Case 4: Standalone camera -> create its own socket using base class method
-        // For battery cameras, reuse the main client
-        // if (this.isBattery) {
-        //     return await this.ensureClient();
-        // }
+        // For battery (BCUDP) cameras, streaming must be keyed by streamKey.
+        // Do NOT reuse ensureClient(): composite needs two concurrent streams, and single-lens streams
+        // should reuse the same API that composite already created for that same streamKey.
+        if (this.isBattery) {
+            return await super.createStreamClient(streamKey);
+        }
 
         // For TCP standalone cameras, use base class createStreamClient which manages stream clients per streamKey
         return await super.createStreamClient(streamKey);
@@ -1543,9 +1548,37 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
             const wider = this.isOnNvr ? rtspChannel : undefined;
             const tele = this.isOnNvr ? rtspChannel : undefined;
 
+            // On standalone TrackMix/Duo, lens channels are often separate, but they are not always 0/1.
+            // Prefer using the discovered multifocalInfo mapping when available.
+            let derivedWider: number | undefined = wider;
+            let derivedTele: number | undefined = tele;
+            if (!this.isOnNvr) {
+                try {
+                    const info: any = this.storageSettings.values.multifocalInfo;
+                    const channels: any[] = Array.isArray(info?.channels) ? info.channels : [];
+
+                    const wideCh = channels.find((c) => c?.lensType === 'wide')?.channel
+                        ?? channels.find((c) => c?.variantType === 'default')?.channel;
+                    const teleCh = channels.find((c) => c?.lensType === 'telephoto')?.channel
+                        ?? channels.find((c) => c?.variantType === 'telephoto')?.channel;
+
+                    if (Number.isFinite(wideCh)) derivedWider = wideCh;
+                    if (Number.isFinite(teleCh)) derivedTele = teleCh;
+
+                    // Avoid setting nonsense; leave undefined to fall back to library defaults.
+                    if (derivedWider === derivedTele) {
+                        // Keep undefined behavior (defaults inside the library) unless we are on NVR.
+                        derivedWider = undefined;
+                        derivedTele = undefined;
+                    }
+                } catch {
+                    // ignore and fall back to defaults
+                }
+            }
+
             baseOptions.compositeOptions = {
-                widerChannel: wider,
-                teleChannel: tele,
+                widerChannel: derivedWider,
+                teleChannel: derivedTele,
                 pipPosition,
                 pipSize,
                 pipMargin,
@@ -2538,11 +2571,20 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
         // Extract variant from stream ID or URL if present (e.g., "autotrack" from "native_autotrack_main" or "?variant=autotrack")
         let variant = extractVariantFromStreamId(selected.id, selected.url);
 
-        // Fallback: if no variant found in stream ID/URL, use variantType from device settings
-        // This is important for multi-focal devices where the device has a variantType setting
+        // Fallback: if no variant found in stream ID/URL, use variantType from device settings.
+        // IMPORTANT:
+        // - On NVR/Hub multifocal setups, the tele lens is often selected via a variant (autotrack/telephoto) on the same channel.
+        // - On standalone TrackMix (no NVR), the tele lens is selected via channel=1 (no variant).
+        // Forcing a variant on standalone can result in a started stream with no frames.
         if (!variant && this.storageSettings.values.variantType && this.storageSettings.values.variantType !== 'default') {
-            variant = this.storageSettings.values.variantType as 'autotrack' | 'telephoto';
-            logger.log(`Using variant from device settings: '${variant}' (not found in stream ID/URL)`);
+            if (this.isOnNvr) {
+                variant = this.storageSettings.values.variantType as 'autotrack' | 'telephoto';
+                logger.log(`Using variant from device settings: '${variant}' (not found in stream ID/URL)`);
+            } else {
+                logger.log(
+                    `Ignoring device variantType '${this.storageSettings.values.variantType}' for standalone stream (channel-based lens selection)`
+                );
+            }
         }
 
         logger.log(`Stream selection: id='${selected.id}', profile='${profile}', channel=${channel}, variant='${variant || 'default'}'`);
@@ -2725,8 +2767,9 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
         this.storageSettings.settings.pipSize.hide = !this.isMultiFocal;
         this.storageSettings.settings.pipMargin.hide = !this.isMultiFocal;
 
-        this.storageSettings.settings.uid.hide = !this.isBattery || this.isOnNvr;
-        this.storageSettings.settings.discoveryMethod.hide = !this.isBattery && !this.nvrDevice;
+        const hideUid = !this.isBattery || this.isOnNvr || !!this.multiFocalDevice
+        this.storageSettings.settings.uid.hide = hideUid;
+        this.storageSettings.settings.discoveryMethod.hide = hideUid;
 
         if (this.isBattery && !this.storageSettings.values.mixinsSetup) {
             try {

package/src/multiFocal.ts

@@ -224,6 +224,14 @@ export class ReolinkNativeMultiFocalDevice extends ReolinkCamera implements Sett
             return await this.nvrDevice.createStreamClient(streamKey);
         }
 
+        // For multifocal battery cams (BCUDP), reuse the main client to avoid D2C_DISC storms.
+        if (this.isBattery) {
+            // For battery (BCUDP) cameras, streaming must be keyed by streamKey.
+            // Do NOT reuse ensureClient(): composite needs two concurrent streams, and single-lens streams
+            // should reuse the same API that composite already created for that same streamKey.
+            return await super.createStreamClient(streamKey);
+        }
+
         // Otherwise, use base class createStreamClient which manages stream clients per streamKey
         return await super.createStreamClient(streamKey);
     }

package/src/stream-utils.ts

@@ -337,25 +337,60 @@ export class StreamManager {
 
             const isComposite = options.channel === undefined;
 
-            // For composite streams, MUST use two distinct Baichuan sessions (widerApi and teleApi).
-            // Otherwise cmd_id=3 frames can mix when streamType overlaps (wide/tele alternation/corruption).
-            // Each stream needs its own dedicated socket to avoid frame mixing.
-            // Create separate streamKeys for wider and tele to ensure distinct sockets:
-            // Format: composite_${variantType}_${profile}_wider and composite_${variantType}_${profile}_tele
-            const compositeApis = isComposite
-                ? {
-                    widerApi: await this.opts.createStreamClient(`${streamKey}_wider`),
-                    teleApi: await this.opts.createStreamClient(`${streamKey}_tele`),
-                }
+            // For composite streams, we may want two distinct Baichuan sessions (wider + tele)
+            // to avoid frame mixing on some firmwares. On BCUDP/battery devices, extra sessions
+            // can be harmful; in that case, createStreamClient may return the same underlying client.
+            //
+            // IMPORTANT: Use the same per-lens streamKey format as regular streams so that later
+            // requests for a single lens can reuse these same cached APIs.
+            const compositeWiderChannel = options.compositeOptions?.widerChannel ?? 0;
+            const compositeTeleChannel = options.compositeOptions?.teleChannel ?? 1;
+            const compositeTeleIsVariantOnSameChannel =
+                Boolean(options.compositeOptions?.onNvr) || compositeTeleChannel === compositeWiderChannel;
+
+            const compositeWiderStreamKey = `${compositeWiderChannel}_${profile}`;
+            const compositeTeleVariant = compositeTeleIsVariantOnSameChannel
+                ? (options.variant && options.variant !== 'default' ? options.variant : 'telephoto')
                 : undefined;
+            const compositeTeleStreamKey = compositeTeleVariant
+                ? `${compositeTeleChannel}_${compositeTeleVariant}_${profile}`
+                : `${compositeTeleChannel}_${profile}`;
+
+            // For composite streams, using two distinct Baichuan sessions can avoid frame mixing on some firmwares.
+            // However, for UDP/battery devices extra BCUDP sessions can trigger storms; if we detect the same
+            // underlying client, fall back to single-session composite.
+            let compositeApis:
+                | {
+                    widerApi: ReolinkBaichuanApi;
+                    teleApi: ReolinkBaichuanApi;
+                }
+                | undefined;
+            if (isComposite) {
+                try {
+                    const widerApi = await this.opts.createStreamClient(compositeWiderStreamKey);
+                    const teleApi = await this.opts.createStreamClient(compositeTeleStreamKey);
+
+                    const sameApiObject = widerApi === teleApi;
+                    const sameUnderlyingClient = (widerApi as any)?.client && (teleApi as any)?.client
+                        ? (widerApi as any).client === (teleApi as any).client
+                        : false;
+
+                    if (!sameApiObject && !sameUnderlyingClient) {
+                        compositeApis = { widerApi, teleApi };
+                    } else {
+                        // Likely a shared/battery connection: avoid forcing multi-session behavior.
+                        compositeApis = undefined;
+                    }
+                } catch {
+                    // Best-effort: if creating dedicated sessions fails, fall back to single-session composite.
+                    compositeApis = undefined;
+                }
+            }
 
-            // For non-composite streams, create a single API client
-            // For composite streams, api is still required as baseApi but widerApi and teleApi are used instead
-            // Pass streamKey to createStreamClient - it contains all necessary information (profile, variantType, channel)
-            // For composite streams, streamKey format: composite_${variantType}_${profile}
-            // For regular streams, streamKey format: channel_${channel}_${profile}_${variantType} or similar
+            // For non-composite streams, create a single API client.
+            // For composite streams, base api must be a real lens streamKey (not the composite RFC key).
             const api = isComposite
-                ? compositeApis.widerApi // For composite, use widerApi as baseApi (it will be overridden by compositeApis)
+                ? (compositeApis?.widerApi ?? await this.opts.createStreamClient(compositeWiderStreamKey))
                 : await this.opts.createStreamClient(streamKey);
 
             const { createRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
@@ -364,17 +399,14 @@ export class StreamManager {
 
             // If connection is shared, don't close it when stream teardown happens
             // For composite, we create dedicated APIs even if the device uses a shared main connection.
-            // Ensure they are closed on teardown.
-            const closeApiOnTeardown = isComposite ? true : !(this.opts.sharedConnection ?? false);
+            // On battery/BCUDP (sharedConnection=true), prefer keeping them alive to avoid reconnect storms.
+            const closeApiOnTeardown = isComposite
+                ? (Boolean(compositeApis) && !(this.opts.sharedConnection ?? false))
+                : !(this.opts.sharedConnection ?? false);
 
             let created: any;
             try {
-                const compositeOptions = isComposite
-                    ? {
-                        ...(options.compositeOptions ?? {}),
-                        forceH264: true,
-                    }
-                    : undefined;
+                const compositeOptions = isComposite ? options.compositeOptions : undefined;
 
                 created = await createRfc4571TcpServer({
                     api,