@apocaliss92/scrypted-reolink-native 0.1.32 → 0.1.35

package/src/common.ts

@@ -1,7 +1,10 @@
-import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, ReolinkSupportedStream, StreamSamplingSelection } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, ReolinkSupportedStream, StreamProfile, StreamSamplingSelection } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import sdk, { BinarySensor, Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, MediaStreamUrl, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, Reboot, RequestMediaStreamOptions, RequestPictureOptions, ResponsePictureOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, SettingValue, VideoCamera, VideoClip, VideoClipOptions, VideoClips, VideoClipThumbnailOptions, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import path from 'path';
+import fs from 'fs';
+import crypto from 'crypto';
+import { spawn } from 'node:child_process';
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import { BaseBaichuanClass, type BaichuanConnectionCallbacks, type BaichuanConnectionConfig } from "./baichuan-base";
 import { createBaichuanApi, normalizeUid, type BaichuanTransport } from "./connect";
@@ -19,7 +22,7 @@ import {
     selectStreamOption,
     StreamManager
 } from "./stream-utils";
-import { floodlightSuffix, getDeviceInterfaces, pirSuffix, sirenSuffix, updateDeviceInfo } from "./utils";
+import { floodlightSuffix, getDeviceInterfaces, getVideoClipWebhookUrls, pirSuffix, recordingFileToVideoClip, sirenSuffix, updateDeviceInfo, vodSearchResultsToVideoClips } from "./utils";
 
 export type CameraType = 'battery' | 'regular' | 'multi-focal' | 'multi-focal-battery';
 
@@ -545,6 +548,57 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             type: "string",
             defaultValue: path.join(process.env.SCRYPTED_PLUGIN_VOLUME, 'diagnostics', this.name),
         },
+        enableVideoclips: {
+            title: "Enable Video Clips",
+            subgroup: 'Videoclips',
+            description: "Enable video clips functionality. If disabled, getVideoClips will return empty and all other videoclip settings are ignored.",
+            type: "boolean",
+            defaultValue: false,
+            immediate: true,
+            onPut: async () => {
+                this.updateVideoClipsAutoLoad();
+            },
+        },
+        clipsSource: {
+            title: "Clips Source",
+            subgroup: 'Videoclips',
+            description: "Source for fetching video clips: NVR (fetch from NVR device) or Device (fetch directly from camera).",
+            type: "string",
+            choices: ["NVR", "Device"],
+            immediate: true,
+        },
+        loadVideoclips: {
+            title: "Auto-load Video Clips",
+            subgroup: 'Videoclips',
+            description: "Automatically fetch today's video clips and download missing thumbnails at regular intervals.",
+            type: "boolean",
+            defaultValue: false,
+            immediate: true,
+            onPut: async () => {
+                this.updateVideoClipsAutoLoad();
+            },
+        },
+        videoclipsRegularChecks: {
+            title: "Video Clips Check Interval (minutes)",
+            subgroup: 'Videoclips',
+            description: "How often to check for new video clips and download thumbnails (default: 30 minutes).",
+            type: "number",
+            defaultValue: 30,
+            onPut: async () => {
+                this.updateVideoClipsAutoLoad();
+            },
+        },
+        downloadVideoclipsLocally: {
+            title: "Download Video Clips Locally",
+            subgroup: 'Videoclips',
+            description: "Automatically download and cache video clips to local filesystem during auto-load.",
+            type: "boolean",
+            defaultValue: false,
+            immediate: true,
+            onPut: async () => {
+                this.updateVideoClipsAutoLoad();
+            },
+        },
         diagnosticsRun: {
             subgroup: 'Diagnostics',
             title: 'Run Diagnostics',
@@ -586,7 +640,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     // Abstract init method that subclasses must implement
     abstract init(): Promise<void>;
 
-    protected withBaichuanClient?<T>(fn: (api: ReolinkBaichuanApi) => Promise<T>): Promise<T>;
     motionTimeout?: NodeJS.Timeout;
     doorbellBinaryTimeout?: NodeJS.Timeout;
     initComplete?: boolean;
@@ -598,6 +651,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     isBattery: boolean;
     isMultiFocal: boolean;
     private streamManagerRestartTimeout: NodeJS.Timeout | undefined;
+    private videoClipsAutoLoadInterval: NodeJS.Timeout | undefined;
+    private videoClipsAutoLoadInProgress: boolean = false;
 
     constructor(
         nativeId: string,
@@ -605,6 +660,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         public options: CommonCameraMixinOptions
     ) {
         super(nativeId);
+        this.plugin.mixinsMap.set(this.id, this);
 
         // Store NVR device reference if provided
         this.nvrDevice = options.nvrDevice;
@@ -620,25 +676,575 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }, 2000);
     }
 
+    protected async withBaichuanClient<T>(fn: (api: ReolinkBaichuanApi) => Promise<T>): Promise<T> {
+        const client = await this.ensureClient();
+        return fn(client);
+    }
+
+    async getVideoClips(options?: VideoClipOptions): Promise<VideoClip[]> {
+        // Check if videoclips are enabled
+        if (!this.storageSettings.values.enableVideoclips) {
+            return [];
+        }
+
+        if (this.isBattery && this.sleeping) {
+            const logger = this.getBaichuanLogger();
+            logger.debug('getVideoClips: disabled for battery devices');
+            return [];
+        }
+
+        const logger = this.getBaichuanLogger();
+
+        // Determine time window
+        const nowMs = Date.now();
+        const defaultWindowMs = 60 * 60 * 1000; // last 60 minutes
+
+        const startMs = options?.startTime ?? (nowMs - defaultWindowMs);
+        let endMs = options?.endTime ?? nowMs;
+        const count = options?.count;
+
+        if (endMs > nowMs) {
+            endMs = nowMs;
+        }
+
+        if (endMs <= startMs) {
+            logger.warn('getVideoClips: invalid time window, endTime <= startTime', {
+                startTime: startMs,
+                endTime: endMs,
+            });
+            return [];
+        }
+
+        const start = new Date(startMs);
+        const end = new Date(endMs);
+        // Use UTC to match API's dateToReolinkTime conversion
+        start.setUTCHours(0, 0, 0, 0);
+
+        try {
+            const { clipsSource } = this.storageSettings.values;
+            const useNvr = clipsSource === "NVR" && this.nvrDevice;
+
+            if (useNvr) {
+                // Fetch from NVR using listEnrichedVodFiles (library handles parsing correctly)
+                const channel = this.storageSettings.values.rtspChannel ?? 0;
+                logger.debug(`Fetching video clips from NVR for channel ${channel}`);
+
+                // Use listEnrichedVodFiles which properly parses filenames and extracts detection info
+                logger.log(`[NVR VOD] Searching for video clips: channel=${channel}, start=${start.toISOString()}, end=${end.toISOString()}`);
+                // Filter to only include recordings within the requested time window
+                const enrichedRecordings = await this.nvrDevice.listEnrichedVodFiles({
+                    channel,
+                    start,
+                    end,
+                    streamType: "main",
+                    autoSearchByDay: false, // Disable autoSearchByDay to avoid searching past days
+                    bypassCache: false,
+                });
+
+                logger.log(`[NVR VOD] Found ${enrichedRecordings.length} enriched recordings from NVR`);
+
+                // Log sample of enriched recordings to see what the library returned
+                if (enrichedRecordings.length > 0) {
+                    const sampleSize = Math.min(3, enrichedRecordings.length);
+                    for (let i = 0; i < sampleSize; i++) {
+                        const rec = enrichedRecordings[i];
+                        logger.log(`[NVR VOD] Sample enriched recording ${i + 1}/${enrichedRecordings.length}:`, {
+                            fileName: rec.fileName,
+                            startTimeMs: rec.startTimeMs,
+                            endTimeMs: rec.endTimeMs,
+                            durationMs: rec.durationMs,
+                            hasPerson: rec.hasPerson,
+                            hasVehicle: rec.hasVehicle,
+                            hasAnimal: rec.hasAnimal,
+                            hasFace: rec.hasFace,
+                            hasMotion: rec.hasMotion,
+                            hasDoorbell: rec.hasDoorbell,
+                            hasPackage: rec.hasPackage,
+                            recordType: rec.recordType,
+                            parsedFileName: rec.parsedFileName ? {
+                                start: rec.parsedFileName.start?.toISOString(),
+                                end: rec.parsedFileName.end?.toISOString(),
+                                flags: rec.parsedFileName.flags,
+                            } : null,
+                        });
+                    }
+                }
+
+                // Convert enriched recordings to VideoClip array
+                const clips: VideoClip[] = [];
+
+                for (const rec of enrichedRecordings) {
+                    // Log detection flags before conversion
+                    const flags = {
+                        hasPerson: 'hasPerson' in rec ? rec.hasPerson : false,
+                        hasVehicle: 'hasVehicle' in rec ? rec.hasVehicle : false,
+                        hasAnimal: 'hasAnimal' in rec ? rec.hasAnimal : false,
+                        hasFace: 'hasFace' in rec ? rec.hasFace : false,
+                        hasMotion: 'hasMotion' in rec ? rec.hasMotion : false,
+                        hasDoorbell: 'hasDoorbell' in rec ? rec.hasDoorbell : false,
+                        hasPackage: 'hasPackage' in rec ? rec.hasPackage : false,
+                        recordType: rec.recordType || 'none',
+                    };
+                    logger.debug(`[NVR VOD] Processing recording: fileName=${rec.fileName}, flags=${JSON.stringify(flags)}`);
+
+                    const clip = await recordingFileToVideoClip(rec, {
+                        fallbackStart: start,
+                        logger,
+                        plugin: this,
+                        deviceId: this.id,
+                        useWebhook: true,
+                    });
+                    
+                    // Log detection classes in the final clip
+                    logger.debug(`[NVR VOD] Generated clip: id=${clip.id}, detectionClasses=${clip.detectionClasses?.join(',') || 'none'}`);
+                    clips.push(clip);
+                }
+
+                // Apply count limit if specified
+                const finalClips = count ? clips.slice(0, count) : clips;
+                logger.log(`[NVR VOD] Converted ${finalClips.length} video clips (limit: ${count || 'none'})`);
+
+                return finalClips;
+            } else {
+                // Fetch directly from device using Baichuan API
+                const api = await this.ensureClient();
+
+                const recordings = await api.listEnrichedRecordingsByTime({
+                    start,
+                    end,
+                    count,
+                    channel: this.storageSettings.values.rtspChannel,
+                    streamType: 'mainStream',
+                    httpFallback: false,
+                    fetchRtmpUrls: true
+                });
+
+                const clips: VideoClip[] = [];
+
+                for (const rec of recordings) {
+                    const clip = await recordingFileToVideoClip(rec, {
+                        fallbackStart: start,
+                        api,
+                        logger,
+                        plugin: this,
+                        deviceId: this.id,
+                        useWebhook: true,
+                    });
+                    clips.push(clip);
+                }
+
+                logger.debug(`Videoclips found: ${clips.length}`);
+
+                return clips;
+            }
+        } catch (e: any) {
+            const message = e instanceof Error ? e.message : String(e);
+
+            if (message?.includes('UID is required to access recordings')) {
+                logger.log('getVideoClips: recordings not available or UID not resolvable for this device', {
+                    error: message,
+                });
+            } else {
+                logger.warn('getVideoClips: failed to list recordings', {
+                    error: message,
+                });
+            }
+            return [];
+        }
+    }
+
     /**
-     * TODO: Implement video clip fetching using Baichuan/NVR recordings API.
+     * Get the cache directory for video clips and thumbnails
      */
-    async getVideoClips(options?: VideoClipOptions): Promise<VideoClip[]> {
-        throw new Error("getVideoClips is not implemented yet.");
+    private getVideoClipCacheDir(): string {
+        const pluginVolume = process.env.SCRYPTED_PLUGIN_VOLUME || '';
+        const cameraId = this.id;
+        return path.join(pluginVolume, 'videoclips', cameraId);
+    }
+
+    /**
+     * Get cache file path for a video clip
+     */
+    getVideoClipCachePath(videoId: string): string {
+        // Create a safe filename from videoId using hash
+        const hash = crypto.createHash('md5').update(videoId).digest('hex');
+        // Keep original extension if present, otherwise use .mp4
+        const ext = videoId.includes('.') ? path.extname(videoId) : '.mp4';
+        const cacheDir = this.getVideoClipCacheDir();
+        return path.join(cacheDir, `${hash}${ext}`);
+    }
+
+    async getVideoClip(videoId: string): Promise<MediaObject> {
+        const logger = this.getBaichuanLogger();
+        try {
+            const cacheEnabled = this.storageSettings.values.downloadVideoclipsLocally
+
+            // Always check cache first, even if caching is disabled (in case user enabled it before)
+            const cachePath = this.getVideoClipCachePath(videoId);
+            const cacheDir = this.getVideoClipCacheDir();
+
+            // Check if cached file exists
+            try {
+                await fs.promises.access(cachePath, fs.constants.F_OK);
+                const stats = await fs.promises.stat(cachePath);
+                logger.debug(`[VideoClip] Using cached file: fileId=${videoId}, size=${stats.size} bytes`);
+                // Return cached file as MediaObject
+                const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
+                return mo;
+            } catch (e) {
+                // File doesn't exist or error accessing it
+                logger.debug(`[VideoClip] Cache miss: fileId=${videoId}, error=${e instanceof Error ? e.message : String(e)}`);
+                if (cacheEnabled) {
+                    logger.debug(`[VideoClip] Will download and cache: fileId=${videoId}`);
+                }
+            }
+
+            // If caching is enabled, ensure cache directory exists
+            if (cacheEnabled) {
+                await fs.promises.mkdir(cacheDir, { recursive: true });
+            }
+
+            const api = await this.ensureClient();
+
+            // videoId is the fileId (fileName or id from the recording)
+            const { rtmpVodUrl } = await api.getRecordingPlaybackUrls({
+                fileName: videoId,
+            });
+
+            if (!rtmpVodUrl) {
+                throw new Error(`No playback URL found for video ${videoId}`);
+            }
+
+            // If caching is enabled, download and cache the video
+            if (cacheEnabled) {
+                const cachePath = this.getVideoClipCachePath(videoId);
+
+                // Download and convert RTMP to MP4 using ffmpeg
+                const ffmpegPath = await sdk.mediaManager.getFFmpegPath();
+                const ffmpegArgs = [
+                    '-i', rtmpVodUrl,
+                    '-c', 'copy', // Copy codecs without re-encoding
+                    '-f', 'mp4',
+                    '-movflags', 'frag_keyframe+empty_moov', // Enable streaming
+                    cachePath,
+                ];
+
+                logger.log(`Downloading video clip to cache: ${cachePath}`);
+
+                await new Promise<void>((resolve, reject) => {
+                    const ffmpeg = spawn(ffmpegPath, ffmpegArgs, {
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                    });
+
+                    let errorOutput = '';
+
+                    ffmpeg.stderr.on('data', (chunk: Buffer) => {
+                        errorOutput += chunk.toString();
+                    });
+
+                    ffmpeg.on('close', (code) => {
+                        if (code !== 0) {
+                            logger.error(`ffmpeg failed to download video clip: ${errorOutput}`);
+                            reject(new Error(`ffmpeg failed with code ${code}: ${errorOutput}`));
+                            return;
+                        }
+
+                        logger.log(`Video clip cached successfully: ${cachePath}`);
+                        resolve();
+                    });
+
+                    ffmpeg.on('error', (error) => {
+                        logger.error(`ffmpeg spawn error for video clip ${videoId}`, error);
+                        reject(error);
+                    });
+
+                    // Timeout after 5 minutes
+                    const timeout = setTimeout(() => {
+                        ffmpeg.kill('SIGKILL');
+                        reject(new Error('Video clip download timeout'));
+                    }, 5 * 60 * 1000);
+
+                    ffmpeg.on('close', () => {
+                        clearTimeout(timeout);
+                    });
+                });
+
+                // Return cached file as MediaObject
+                const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
+                return mo;
+            } else {
+                // Caching disabled, return RTMP URL directly
+                const mo = await sdk.mediaManager.createMediaObjectFromUrl(rtmpVodUrl);
+                return mo;
+            }
+        } catch (e) {
+            logger.error(`getVideoClip: failed to get video clip ${videoId}`, e);
+            throw e;
+        }
+    }
+
+    /**
+     * Get the cache directory for thumbnails (same as video clips)
+     */
+    private getThumbnailCacheDir(): string {
+        // Use the same directory as video clips
+        return this.getVideoClipCacheDir();
     }
 
-    getVideoClip(videoId: string): Promise<MediaObject> {
-        throw new Error("getVideoClip is not implemented yet.");
+    /**
+     * Get cache file path for a thumbnail
+     */
+    private getThumbnailCachePath(fileId: string): string {
+        // Use the same hash and base name as video clips, but with .jpg extension
+        const hash = crypto.createHash('md5').update(fileId).digest('hex');
+        const cacheDir = this.getThumbnailCacheDir();
+        return path.join(cacheDir, `${hash}.jpg`);
+    }
+
+    async getVideoClipThumbnail(thumbnailId: string, options?: VideoClipThumbnailOptions): Promise<MediaObject> {
+        const logger = this.getBaichuanLogger();
+
+        try {
+            // Check cache first
+            const cachePath = this.getThumbnailCachePath(thumbnailId);
+            const cacheDir = this.getThumbnailCacheDir();
+
+            try {
+                await fs.promises.access(cachePath, fs.constants.F_OK);
+                const stats = await fs.promises.stat(cachePath);
+                logger.debug(`[Thumbnail] Using cached: fileId=${thumbnailId}, size=${stats.size} bytes`);
+                // Return cached thumbnail as MediaObject
+                const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
+                return mo;
+            } catch {
+                // File doesn't exist, need to generate it
+                logger.debug(`[Thumbnail] Cache miss: fileId=${thumbnailId}`);
+            }
+
+            // Ensure cache directory exists
+            await fs.promises.mkdir(cacheDir, { recursive: true });
+
+            // Check if video clip is already cached locally - use it instead of calling camera
+            const videoCachePath = this.getVideoClipCachePath(thumbnailId);
+            let useLocalVideo = false;
+            try {
+                await fs.promises.access(videoCachePath, fs.constants.F_OK);
+                useLocalVideo = true;
+                logger.debug(`[Thumbnail] Using local video file for thumbnail extraction: fileId=${thumbnailId}`);
+            } catch {
+                // Video not cached locally, will use RTMP URL
+            }
+
+            let thumbnail: MediaObject;
+
+            if (useLocalVideo) {
+                // Extract thumbnail from local video file
+                thumbnail = await this.plugin.generateThumbnail({
+                    deviceId: this.id,
+                    fileId: thumbnailId,
+                    filePath: videoCachePath,
+                    logger: this.getBaichuanLogger(),
+                });
+            } else {
+                // Get RTMP URL using the appropriate API (NVR or Baichuan)
+                // Use forThumbnail=true to prefer Download over Playback (better for ffmpeg)
+                const rtmpVodUrl = await this.getVideoClipRtmpUrl(thumbnailId, true);
+
+                // Use the plugin's thumbnail generation queue with RTMP URL
+                thumbnail = await this.plugin.generateThumbnail({
+                    deviceId: this.id,
+                    fileId: thumbnailId,
+                    rtmpUrl: rtmpVodUrl,
+                    logger: this.getBaichuanLogger(),
+                });
+            }
+
+            // Cache the thumbnail
+            try {
+                const buffer = await sdk.mediaManager.convertMediaObjectToBuffer(thumbnail, 'image/jpeg');
+                await fs.promises.writeFile(cachePath, buffer);
+                logger.debug(`[Thumbnail] Cached: fileId=${thumbnailId}, size=${buffer.length} bytes`);
+            } catch (e) {
+                logger.warn(`[Thumbnail] Failed to cache: fileId=${thumbnailId}`, e);
+                // Continue even if caching fails
+            }
+
+            return thumbnail;
+        } catch (e) {
+            logger.error(`[Thumbnail] Error: fileId=${thumbnailId}`, e);
+            throw e;
+        }
     }
 
-    getVideoClipThumbnail(thumbnailId: string, options?: VideoClipThumbnailOptions): Promise<MediaObject> {
-        throw new Error("getVideoClipThumbnail is not implemented yet.");
+    /**
+     * Get RTMP URL for a video clip file
+     * Handles both NVR source (full path) and Device source (filename only)
+     * @param fileId - The file ID or full path
+     * @param forThumbnail - If true, prefer Download over Playback (better for ffmpeg thumbnail extraction)
+     */
+    async getVideoClipRtmpUrl(fileId: string, forThumbnail: boolean = false): Promise<string> {
+        const logger = this.getBaichuanLogger();
+        const { clipsSource } = this.storageSettings.values;
+        const useNvr = clipsSource === "NVR" && this.nvrDevice && fileId.includes('/');
+
+        if (useNvr) {
+            logger.log(`[getVideoClipRtmpUrl] Using NVR API for fileId="${fileId}", forThumbnail=${forThumbnail}`);
+            const nvrApi = await this.nvrDevice.ensureClient();
+            const channel = this.storageSettings.values.rtspChannel ?? 0;
+            
+            // For both thumbnails and video streaming, try Download first
+            // Download might return MP4 format which is better supported than FLV from Playback
+            const requestTypes = ["Download", "Playback"];
+            
+            for (const requestType of requestTypes) {
+                try {
+                    logger.log(`[getVideoClipRtmpUrl] Trying getVodUrl with ${requestType} requestType...`);
+                    const url = await nvrApi.getVodUrl(fileId, channel, {
+                        requestType: requestType as "Playback" | "Download",
+                        streamType: "main",
+                    });
+                    logger.log(`[getVideoClipRtmpUrl] NVR getVodUrl ${requestType} URL received: url="${url || 'none'}"`);
+                    if (url) return url;
+                } catch (e: any) {
+                    logger.debug(`[getVideoClipRtmpUrl] getVodUrl ${requestType} failed: ${e.message}`);
+                }
+            }
+            
+            throw new Error(`No streaming URL found from NVR for file ${fileId} after trying Playback and Download methods`);
+        } else {
+            // Camera standalone: DEVE usare RTMP da Baichuan API
+            logger.log(`[getVideoClipRtmpUrl] Getting RTMP URL from Baichuan API for fileId="${fileId}" (camera standalone)`);
+            const api = await this.ensureClient();
+            const result = await api.getRecordingPlaybackUrls({
+                fileName: fileId,
+            });
+            logger.log(`[getVideoClipRtmpUrl] Baichuan RTMP URL received: rtmpVodUrl="${result.rtmpVodUrl || 'none'}"`);
+            if (!result.rtmpVodUrl) {
+                throw new Error(`No RTMP URL found from Baichuan API for file ${fileId}`);
+            }
+            return result.rtmpVodUrl;
+        }
     }
 
     removeVideoClips(...videoClipIds: string[]): Promise<void> {
         throw new Error("removeVideoClips is not implemented yet.");
     }
 
+    /**
+     * Update video clips auto-load timer based on settings
+     */
+    private updateVideoClipsAutoLoad(): void {
+        // Clear existing interval if any
+        if (this.videoClipsAutoLoadInterval) {
+            clearInterval(this.videoClipsAutoLoadInterval);
+            this.videoClipsAutoLoadInterval = undefined;
+        }
+
+        // Check if videoclips are enabled at all
+        const { enableVideoclips, loadVideoclips, videoclipsRegularChecks } = this.storageSettings.values;
+        if (!enableVideoclips) {
+            return;
+        }
+
+
+        if (!loadVideoclips) {
+            return;
+        }
+
+        const logger = this.getBaichuanLogger();
+        const intervalMs = videoclipsRegularChecks * 60 * 1000;
+
+        logger.log(`Starting video clips auto-load: checking every ${videoclipsRegularChecks} minutes`);
+
+        // Run immediately on start
+        this.loadTodayVideoClipsAndThumbnails();
+
+        // Then run at regular intervals
+        this.videoClipsAutoLoadInterval = setInterval(() => {
+            this.loadTodayVideoClipsAndThumbnails();
+        }, intervalMs);
+    }
+
+    /**
+     * Load today's video clips and download missing thumbnails
+     */
+    private async loadTodayVideoClipsAndThumbnails(): Promise<void> {
+        // Prevent concurrent executions
+        if (this.videoClipsAutoLoadInProgress) {
+            const logger = this.getBaichuanLogger();
+            logger.debug('Video clips auto-load already in progress, skipping...');
+            return;
+        }
+
+        const logger = this.getBaichuanLogger();
+
+        this.videoClipsAutoLoadInProgress = true;
+
+        try {
+            logger.log('Auto-loading today\'s video clips and thumbnails...');
+
+            // Get today's date range (start of today to now)
+            const now = new Date();
+            const startOfToday = new Date(now);
+            startOfToday.setUTCHours(0, 0, 0, 0);
+            startOfToday.setUTCMinutes(0, 0, 0);
+
+            // Fetch today's video clips
+            const clips = await this.getVideoClips({
+                startTime: startOfToday.getTime(),
+                endTime: now.getTime(),
+            });
+
+            logger.log(`Found ${clips.length} video clips for today`);
+
+            const downloadVideoclipsLocally = this.storageSettings.values.downloadVideoclipsLocally ?? false;
+
+            // Track processed clips to avoid duplicate calls to the camera
+            const processedClips = new Set<string>();
+
+            // Download videos first (if enabled), then thumbnails for each clip
+            for (const clip of clips) {
+                // Skip if already processed (avoid duplicate calls)
+                if (processedClips.has(clip.id)) {
+                    logger.debug(`Skipping already processed clip: ${clip.id}`);
+                    continue;
+                }
+                processedClips.add(clip.id);
+
+                try {
+                    // If downloadVideoclipsLocally is enabled, download the video clip first
+                    // This allows the thumbnail to use the local file instead of calling the camera
+                    if (downloadVideoclipsLocally) {
+                        try {
+                            // Call getVideoClip to trigger download and caching
+                            await this.getVideoClip(clip.id);
+                            logger.debug(`Downloaded video clip: ${clip.id}`);
+                        } catch (e) {
+                            logger.warn(`Failed to download video clip ${clip.id}:`, e instanceof Error ? e.message : String(e));
+                        }
+                    }
+
+                    // Then get the thumbnail - this will use the local video file if available
+                    // or call the camera if the video wasn't downloaded
+                    try {
+                        await this.getVideoClipThumbnail(clip.id);
+                        logger.debug(`Downloaded thumbnail for clip: ${clip.id}`);
+                    } catch (e) {
+                        logger.warn(`Failed to load thumbnail for clip ${clip.id}:`, e instanceof Error ? e.message : String(e));
+                    }
+                } catch (e) {
+                    logger.warn(`Error processing clip ${clip.id}:`, e instanceof Error ? e.message : String(e));
+                }
+            }
+
+            logger.log(`Completed auto-loading video clips and thumbnails`);
+        } catch (e) {
+            logger.error('Error during auto-loading video clips:', e);
+        } finally {
+            this.videoClipsAutoLoadInProgress = false;
+        }
+    }
+
     async reboot(): Promise<void> {
         const api = await this.ensureBaichuanClient();
         await api.reboot();
@@ -654,13 +1260,14 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             throw new Error('UID is required for battery cameras (BCUDP)');
         }
 
+        const logger = this.getBaichuanLogger();
         return {
             host: ipAddress,
             username,
             password,
             uid: normalizedUid,
             transport: this.protocol,
-            logger: this.console,
+            logger,
             debugOptions,
         };
     }
@@ -700,6 +1307,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     async withBaichuanRetry<T>(fn: () => Promise<T>): Promise<T> {
+        return await fn();
+
         if (this.isBattery) {
             return await fn();
         } else {
@@ -777,13 +1386,19 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
      * - For TCP devices (regular + multifocal), this creates a new TCP session with its own client.
      * - For UDP/battery devices, this reuses the existing client via ensureClient().
      */
-    async createStreamClient(): Promise<ReolinkBaichuanApi> {
+    async createStreamClient(profile?: StreamProfile): Promise<ReolinkBaichuanApi> {
         // Battery / BCUDP path: reuse the main client to avoid extra wake-ups and sockets.
         if (this.isBattery) {
             return await this.ensureClient();
         }
 
-        // TCP path: create a separate session for streaming (RFC4571/composite/NVR-friendly).
+        // For TCP path: create a new client ONLY for "ext" profile
+        // For other profiles (main, sub), reuse the main client
+        if (profile !== 'ext') {
+            return await this.ensureClient();
+        }
+
+        // TCP path with ext profile: create a separate session for streaming (RFC4571/composite/NVR-friendly).
         const { ipAddress, username, password } = this.storageSettings.values;
         const logger = this.getBaichuanLogger();
 
@@ -825,7 +1440,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         const { username, password } = this.storageSettings.values;
 
         const baseOptions: any = {
-            createStreamClient: () => this.createStreamClient(),
+            createStreamClient: (profile?: StreamProfile) => this.createStreamClient(profile),
             getLogger: () => logger,
             credentials: {
                 username,
@@ -876,6 +1491,13 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 restartLogger.log('Restarting StreamManager due to PIP/composite settings change');
                 this.initStreamManager(restartLogger, true);
 
+                // Invalidate snapshot cache for battery/multifocal-battery so that
+                // the next snapshot reflects the new PIP/composite configuration.
+                if (this.isBattery) {
+                    this.forceNewSnapshot = true;
+                    this.lastPicture = undefined;
+                }
+
                 // Notify consumers (e.g. prebuffer) that stream configuration changed.
                 try {
                     this.onDeviceEvent(ScryptedInterface.VideoCamera, undefined);
@@ -1410,6 +2032,10 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
     }
 
+    async release() {
+        this.plugin.mixinsMap.delete(this.id);
+    }
+
     async releaseDevice(id: string, nativeId: string): Promise<void> {
         if (nativeId.endsWith(sirenSuffix)) {
             this.siren = undefined;
@@ -1798,10 +2424,11 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 logger.warn('Failed to connect/refresh during init', e);
             }
         }
+        this.storageSettings.settings.clipsSource.hide = !this.nvrDevice;
+        this.storageSettings.settings.clipsSource.defaultValue = this.nvrDevice ? "NVR" : "Device";
 
-        const { username, password } = this.storageSettings.values;
+        this.storageSettings.settings.videoclipsRegularChecks.defaultValue = this.isBattery ? 120 : 30;
 
-        this.storageSettings.settings.uid.hide = !this.isBattery;
         this.storageSettings.settings.batteryUpdateIntervalMinutes.hide = !this.isBattery;
         this.storageSettings.settings.lowThresholdBatteryRecording.hide = !this.isBattery;
         this.storageSettings.settings.highThresholdBatteryRecording.hide = !this.isBattery;
@@ -1865,7 +2492,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             this.storageSettings.settings.username.hide = true;
             this.storageSettings.settings.password.hide = true;
             this.storageSettings.settings.ipAddress.hide = true;
-            this.storageSettings.settings.uid.hide = true;
 
             this.storageSettings.settings.username.defaultValue = this.nvrDevice.storageSettings.values.username;
             this.storageSettings.settings.password.defaultValue = this.nvrDevice.storageSettings.values.password;
@@ -1875,6 +2501,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         await this.init();
 
         this.initComplete = true;
+
+        // Initialize video clips auto-load if enabled
+        this.updateVideoClipsAutoLoad();
     }
 }