@apocaliss92/scrypted-reolink-native 0.2.7 → 0.2.9

package/package.json

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

package/src/camera.ts

@@ -618,15 +618,38 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
         },
         pipMargin: {
             title: 'PIP Margin',
-            description: 'Margin from edge in pixels',
+            description: 'Margin from edge as a fraction of the output size (e.g. 0.01 = 1%). Values > 1 are treated as pixels (legacy).',
             type: 'number',
-            defaultValue: 10,
+            defaultValue: 0.01,
             group: 'Composite stream',
             hide: true,
             onPut: async () => {
                 this.scheduleStreamManagerRestart('pipMargin changed');
             },
         },
+
+        compositeAssumeH264: {
+            title: 'Composite: Assume H.264 Inputs',
+            description: 'Assume both wider+tele inputs are H.264 (skips codec detection). Recommended when using sub+sub on TrackMix. If inputs are actually H.265, the composite may fail to start.',
+            type: 'boolean',
+            defaultValue: true,
+            group: 'Composite stream',
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('compositeAssumeH264 changed');
+            },
+        },
+        compositeDisableTranscode: {
+            title: 'Composite: Disable Codec Transcode (Best-effort)',
+            description: 'Best-effort knob. Overlay requires re-encode in ffmpeg; this option only avoids HEVC->H264 codec assumptions when possible. Leave off unless you know what you are doing.',
+            type: 'boolean',
+            defaultValue: false,
+            group: 'Composite stream',
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('compositeDisableTranscode changed');
+            },
+        },
     });
 
     ptzPresets = new ReolinkPtzPresets(this);
@@ -1478,10 +1501,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);
@@ -1539,20 +1564,52 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
         };
 
         if (this.isMultiFocal) {
-            const { pipPosition, pipSize, pipMargin, rtspChannel } = this.storageSettings.values;
+            const { pipPosition, pipSize, pipMargin, rtspChannel, compositeAssumeH264, compositeDisableTranscode } = this.storageSettings.values;
 
             // On NVR/Hub, TrackMix lenses are selected via stream variant, not via a separate channel.
             // Use rtspChannel for BOTH wide and tele so the library can request tele via streamType/variant.
             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,
                 onNvr: this.isOnNvr,
+                // Prefer H.264 for composite (sub+sub by default) to reduce GOP latency.
+                forceH264: true,
+                assumeH264Inputs: compositeAssumeH264 ?? true,
+                disableTranscode: compositeDisableTranscode ?? false,
             };
         }
 

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,