@apocaliss92/scrypted-reolink-native 0.2.9 → 0.2.11

package/src/debug-options.ts

@@ -10,16 +10,12 @@ export enum DebugLogOption {
     DebugRtsp = 'debugRtsp',
     /** Low-level tracing for recording-related commands */
     TraceRecordings = 'traceRecordings',
-    /** Stream command tracing */
-    TraceStream = 'traceStream',
+    /** Native stream tracing (stream tx/rx + H264/H265 + param sets) */
+    TraceNativeStream = 'traceNativeStream',
     /** Talkback tracing */
     TraceTalk = 'traceTalk',
     /** Event tracing */
     TraceEvents = 'traceEvents',
-    /** H.264 debug logs */
-    DebugH264 = 'debugH264',
-    /** SPS/PPS parameter sets debug logs */
-    DebugParamSets = 'debugParamSets',
 }
 
 /**
@@ -30,11 +26,9 @@ export function mapDebugLogToApiOption(option: DebugLogOption): keyof DebugOptio
         [DebugLogOption.General]: 'general',
         [DebugLogOption.DebugRtsp]: 'debugRtsp',
         [DebugLogOption.TraceRecordings]: 'traceRecordings',
-        [DebugLogOption.TraceStream]: 'traceStream',
+        [DebugLogOption.TraceNativeStream]: 'traceNativeStream',
         [DebugLogOption.TraceTalk]: 'traceTalk',
         [DebugLogOption.TraceEvents]: 'traceEvents',
-        [DebugLogOption.DebugH264]: 'debugH264',
-        [DebugLogOption.DebugParamSets]: 'debugParamSets',
     };
     return mapping[option];
 }
@@ -81,11 +75,9 @@ export const DebugLogDisplayNames: Record<DebugLogOption, string> = {
     [DebugLogOption.General]: 'General',
     [DebugLogOption.DebugRtsp]: 'RTSP',
     [DebugLogOption.TraceRecordings]: 'Trace recordings',
-    [DebugLogOption.TraceStream]: 'Trace stream',
+    [DebugLogOption.TraceNativeStream]: 'Trace native stream',
     [DebugLogOption.TraceTalk]: 'Trace talk',
     [DebugLogOption.TraceEvents]: 'Trace events XML',
-    [DebugLogOption.DebugH264]: 'H264',
-    [DebugLogOption.DebugParamSets]: 'Video param sets',
 };
 
 /**

package/src/intercom.ts

@@ -274,7 +274,7 @@ export class ReolinkBaichuanIntercom {
                 }
             })
             .catch((e) => {
-                logger.warn("Intercom PCM->ADPCM pipeline error", e);
+                logger.warn("Intercom PCM->ADPCM pipeline error", e?.message || String(e));
             });
     }
 

package/src/main.ts

@@ -324,7 +324,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 return;
             }
         } catch (e: any) {
-            logger.error('Error in onRequest', e);
+            logger.error('Error in onRequest', e?.message || String(e));
             response.send(`Error: ${e.message}`, {
                 code: 500,
             });
@@ -374,7 +374,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 logger.log(`[Thumbnail] Download completed: fileId=${request.fileId}`);
                 request.resolve(thumbnail);
             } catch (error) {
-                logger.error(`[Thumbnail] Error: fileId=${request.fileId}`, error);
+                logger.error(`[Thumbnail] Error: fileId=${request.fileId}`, error?.message || String(error));
                 request.reject(error instanceof Error ? error : new Error(String(error)));
             }
 

package/src/multiFocal.ts

@@ -172,12 +172,28 @@ export class ReolinkNativeMultiFocalDevice extends ReolinkCamera implements Sett
                 throw new Error('Missing device credentials');
             }
 
+            const outputPath = this.storageSettings.values.diagnosticsOutputPath || process.env.SCRYPTED_PLUGIN_VOLUME || "";
+            if (!outputPath) {
+                throw new Error('Diagnostics output path is required');
+            }
+
             const api = await this.ensureClient();
 
-            const multifocalDiagnostics = await api.collectMultifocalDiagnostics(logger);
+            const channel = this.storageSettings.values.rtspChannel || 0;
+            const durationSeconds = 8;
+            const result = await api.runMultifocalDiagnosticsConsecutively({
+                logger,
+                outDir: outputPath,
+                channel,
+                durationSeconds,
+                rtmpApps: ["bcs"],
+                probeFull: true,
+                onNvr: !!this.nvrDevice,
+            });
 
-            logger.log(`NVR diagnostics completed successfully.`);
-            logger.debug(JSON.stringify(multifocalDiagnostics));
+            logger.log(`Multifocal diagnostics completed successfully. Output directory: ${result.runDir}`);
+            logger.log(`Results file: ${result.resultsPath}`);
+            logger.log(`Streams directory: ${result.streamsDir}`);
         } catch (e) {
             logger.error('Failed to run NVR diagnostics', e?.message || String(e));
             throw e;

package/src/stream-utils.ts

@@ -17,8 +17,8 @@ export interface StreamManagerOptions {
     /**
      * Creates a dedicated Baichuan session for streaming.
      * Required to support concurrent main+ext streams on firmwares where streamType overlaps.
-     * @param streamKey The unique stream key (e.g., "composite_default_main", "channel_0_main", etc.)
-     *                  Contains all necessary information (profile, variantType, channel) for stream identification.
+    * @param streamKey The unique stream key (e.g., "composite-rtsp-default-sub-sub", "channel_0_main", etc.)
+    *                  Forwarded to the library as `requestedId`.
      */
     createStreamClient: (streamKey: string) => Promise<ReolinkBaichuanApi>;
     logger: Console;
@@ -93,6 +93,14 @@ export function parseStreamProfileFromId(id: string | undefined): StreamProfile
     return;
 }
 
+type ReolinkRfc4571Metadata = {
+    profile: StreamProfile;
+    channel?: number;
+    variant?: NativeVideoStreamVariant;
+    /** Explicitly mark composite (channel-less) streams. If omitted, `channel===undefined` implies composite. */
+    isComposite?: boolean;
+};
+
 /**
  * Extract and normalize variant type from stream ID or URL (e.g., "autotrack" from "native_autotrack_main" or "?variant=autotrack")
  * Returns undefined if no variant is present, or "autotrack"/"telephoto" if present
@@ -163,16 +171,18 @@ export function selectStreamOption(
 
 export async function createRfc4571MediaObjectFromStreamManager(params: {
     streamManager: StreamManager;
-    channel: number;
-    profile: StreamProfile;
     streamKey: string;
-    variant?: NativeVideoStreamVariant;
     selected: UrlMediaStreamOptions;
     sourceId: string;
 }): Promise<MediaObject> {
-    const { streamManager, channel, profile, streamKey, variant, selected, sourceId } = params;
+    const { streamManager, streamKey, selected, sourceId } = params;
+
+    const meta = (selected as any)?.reolinkRfc4571 as ReolinkRfc4571Metadata | undefined;
+    if (!meta?.profile) {
+        throw new Error(`Missing RFC4571 metadata/profile for streamKey='${streamKey}'`);
+    }
 
-    const { host, port, sdp, audio, username, password } = await streamManager.getRfcStream(channel, profile, streamKey, variant);
+    const { host, port, sdp, audio, username, password } = await streamManager.getRfcServer(streamKey, meta);
 
     const { url: _ignoredUrl, ...mso }: any = selected;
     mso.container = 'rtp';
@@ -203,62 +213,6 @@ export async function createRfc4571MediaObjectFromStreamManager(params: {
     });
 }
 
-export async function createRfc4571CompositeMediaObjectFromStreamManager(params: {
-    streamManager: StreamManager;
-    profile: StreamProfile;
-    streamKey: string;
-    selected: UrlMediaStreamOptions;
-    sourceId: string;
-    variantType?: NativeVideoStreamVariant;
-}): Promise<MediaObject> {
-    const { streamManager, profile, streamKey, selected, sourceId, variantType } = params;
-
-    // Extract variantType from streamKey if not provided (format: composite_${variantType}_${profile})
-    let extractedVariantType = variantType;
-    if (!extractedVariantType && streamKey.startsWith('composite_')) {
-        const parts = streamKey.split('_');
-        if (parts.length >= 3) {
-            // Format: composite_${variantType}_${profile}
-            const variantPart = parts[1];
-            if (variantPart === 'default' || variantPart === 'autotrack' || variantPart === 'telephoto') {
-                extractedVariantType = variantPart as NativeVideoStreamVariant;
-            }
-        }
-    }
-
-    const { host, port, sdp, audio, username, password } = await streamManager.getRfcCompositeStream(profile, streamKey, extractedVariantType);
-
-    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;
-    }
-
-    // Build URL with credentials: tcp://username:password@host:port
-    // Keep this consistent with non-composite path (URL object -> JSON string via toJSON()).
-    const urlObj = new URL(`tcp://${host}`);
-    urlObj.port = port.toString();
-    if (username) {
-        urlObj.username = username;
-    }
-    if (password) {
-        urlObj.password = password;
-    }
-
-    const rfc = {
-        url: urlObj,
-        sdp,
-        mediaStreamOptions: mso as ResponseMediaStreamOptions,
-    };
-
-    return await sdk.mediaManager.createMediaObject(Buffer.from(JSON.stringify(rfc)), 'x-scrypted/x-rfc4571', {
-        sourceId,
-    });
-}
-
 type RfcServerInfo = {
     host: string;
     port: number;
@@ -283,6 +237,26 @@ export class StreamManager {
         return this.opts.logger || console;
     }
 
+    /**
+     * Unified RFC4571 server accessor.
+     *
+     * `stream-utils` does not parse `streamKey`. It forwards the `streamKey` as `requestedId`
+     * and relies on explicit metadata from the selected stream option (profile/channel/variant).
+     */
+    async getRfcServer(streamKey: string, meta: ReolinkRfc4571Metadata): Promise<RfcServerInfo> {
+        if (!meta?.profile) {
+            throw new Error(`getRfcServer: missing profile for streamKey='${streamKey}'`);
+        }
+
+        const isComposite = meta.isComposite ?? (meta.channel === undefined);
+
+        return await this.ensureRfcServer(streamKey, meta.profile, {
+            channel: isComposite ? undefined : meta.channel,
+            variant: meta.variant,
+            compositeOptions: isComposite ? this.opts.compositeOptions : undefined,
+        });
+    }
+
     private async ensureRfcServer(
         streamKey: string,
         profile: StreamProfile,
@@ -337,24 +311,16 @@ export class StreamManager {
 
             const isComposite = options.channel === undefined;
 
+            // IMPORTANT: do not parse composite profiles here.
+            // The library/server derives the composite pairing from the requested id.
+
             // 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}`;
+            // Use stable per-request keys; include variant for tele to keep sessions distinct.
+            const compositeWiderStreamKey = `${streamKey}_wider`;
+            const compositeTeleStreamKey = `${streamKey}_tele_${options.variant ?? 'default'}`;
 
             // 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
@@ -387,11 +353,18 @@ export class StreamManager {
                 }
             }
 
-            // For non-composite streams, create a single API client.
+            // For non-composite streams, create/reuse a single API client.
+            // For NVR/Hub (sharedConnection=true), avoid creating one TCP session per profile
+            // (e.g. main+sub would otherwise become two sockets). Group by (channel, variant).
             // For composite streams, base api must be a real lens streamKey (not the composite RFC key).
+            const shared = this.opts.sharedConnection ?? false;
+            const nonCompositeApiKey = (!isComposite && shared && options.channel !== undefined)
+                ? `channel_${options.channel}_${options.variant ?? 'default'}`
+                : streamKey;
+
             const api = isComposite
                 ? (compositeApis?.widerApi ?? await this.opts.createStreamClient(compositeWiderStreamKey))
-                : await this.opts.createStreamClient(streamKey);
+                : await this.opts.createStreamClient(nonCompositeApiKey);
 
             const { createRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
 
@@ -417,6 +390,7 @@ export class StreamManager {
                     closeApiOnTeardown,
                     username,
                     password,
+                    requestedId: streamKey,
                     // Composite can take a bit longer (ffmpeg warmup + first IDR).
                     ...(isComposite ? { keyframeTimeoutMs: 20_000, idleTeardownMs: 20_000 } : {}),
                     ...(compositeOptions ? { compositeOptions } : {}),
@@ -464,10 +438,8 @@ export class StreamManager {
         streamKey: string,
         variant?: NativeVideoStreamVariant,
     ): Promise<RfcServerInfo> {
-        return await this.ensureRfcServer(streamKey, profile, {
-            channel,
-            variant,
-        });
+        // Back-compat wrapper. Prefer getRfcServer(streamKey).
+        return await this.ensureRfcServer(streamKey, profile, { channel, variant });
     }
 
     async getRfcCompositeStream(
@@ -475,24 +447,11 @@ export class StreamManager {
         streamKey: string,
         variantType?: NativeVideoStreamVariant,
     ): Promise<RfcServerInfo> {
-        // Extract variantType from streamKey if not provided (format: composite_${variantType}_${profile})
-        let extractedVariantType = variantType;
-        if (!extractedVariantType && streamKey.startsWith('composite_')) {
-            const parts = streamKey.split('_');
-            if (parts.length >= 3) {
-                // Format: composite_${variantType}_${profile}
-                const variantPart = parts[1];
-                if (variantPart === 'default' || variantPart === 'autotrack' || variantPart === 'telephoto') {
-                    extractedVariantType = variantPart as NativeVideoStreamVariant;
-                }
-            }
-        }
-        
-        // Pass variantType to ensureRfcServer so it can be used when creating the stream client
-        // This ensures each variantType gets its own socket
+        // Back-compat wrapper. Prefer getRfcServer(streamKey).
+        // Pass variantType to ensureRfcServer so it can be used when creating the stream client.
         return await this.ensureRfcServer(streamKey, profile, {
-            channel: undefined, // Undefined channel indicates composite stream
-            variant: extractedVariantType,
+            channel: undefined,
+            variant: variantType,
             compositeOptions: this.opts.compositeOptions,
         });
     }

package/src/utils.ts

@@ -1043,7 +1043,7 @@ export async function vodSearchResultsToVideoClips(
                     videoHref = videoUrl;
                     thumbnailHref = thumbnailUrl;
                 } catch (e) {
-                    logger?.debug('Failed to generate webhook URLs for VOD file', fileName, e);
+                    logger?.debug('Failed to generate webhook URLs for VOD file', fileName, e?.message || String(e));
                 }
 
                 const clip: VideoClip = {
@@ -1060,7 +1060,7 @@ export async function vodSearchResultsToVideoClips(
 
                 clips.push(clip);
             } catch (e) {
-                logger?.warn(`Failed to convert VOD file to clip: ${file.name}`, e);
+                logger?.warn(`Failed to convert VOD file to clip: ${file.name}`, e?.message || String(e));
             }
         }
     }