@apocaliss92/scrypted-reolink-native 0.1.1 → 0.1.3

package/src/camera-battery.ts

@@ -7,7 +7,7 @@ import sdk, {
 import {
     CommonCameraMixin,
 } from "./common";
-import { createBaichuanApi, normalizeUid } from "./connect";
+import { DebugLogOption } from "./debug-options";
 import type ReolinkNativePlugin from "./main";
 
 export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
@@ -25,7 +25,7 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
 
     private isBatteryInfoLoggingEnabled(): boolean {
         const debugLogs = this.storageSettings.values.debugLogs || [];
-        return debugLogs.includes('batteryInfo');
+        return debugLogs.includes(DebugLogOption.BatteryInfo);
     }
 
     constructor(nativeId: string, public plugin: ReolinkNativePlugin) {
@@ -289,6 +289,14 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
     async resetBaichuanClient(reason?: any): Promise<void> {
         try {
             this.unsubscribedToEvents?.();
+            
+            // Close all stream servers before closing the main connection
+            // This ensures streams are properly cleaned up when using shared connection
+            if (this.streamManager) {
+                const reasonStr = reason?.message || reason?.toString?.() || 'connection reset';
+                await this.streamManager.closeAllStreams(reasonStr);
+            }
+            
             await this.baichuanApi?.close();
         }
         catch (e) {
@@ -324,30 +332,8 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
     }
 
     async createStreamClient(): Promise<ReolinkBaichuanApi> {
-        const { ipAddress, username, password, uid } = this.storageSettings.values;
-        if (!ipAddress || !username || !password) {
-            throw new Error('Missing camera credentials');
-        }
-        const normalizedUid = normalizeUid(uid);
-        if (!normalizedUid) throw new Error("UID is required for battery cameras (BCUDP)");
-
-        const debugOptions = this.getBaichuanDebugOptions();
-        const api = await createBaichuanApi(
-            {
-                inputs: {
-                    host: ipAddress,
-                    username,
-                    password,
-                    uid: normalizedUid,
-                    logger: this.console,
-                    ...(debugOptions ? { debugOptions } : {}),
-                },
-                transport: 'udp',
-                logger: this.console,
-            }
-        );
-        await api.login();
-
-        return api;
+        // Reuse the main Baichuan client connection instead of creating a new one
+        // This ensures we use a single session for everything (general + streams)
+        return await this.ensureClient();
     }
 }

package/src/camera.ts

@@ -95,7 +95,6 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
 
     async init() {
         this.startPeriodicTasks();
-        // Align auxiliary devices state on init
         await this.alignAuxDevicesState();
     }
 
@@ -114,7 +113,7 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
                     username,
                     password,
                     logger: this.console,
-                    ...(debugOptions ? { debugOptions } : {}),
+                    debugOptions
                 },
                 transport: 'tcp',
                 logger: this.console,

package/src/common.ts

@@ -1,8 +1,9 @@
 import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent } 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, RequestMediaStreamOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, SettingValue, Settings, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
-import { StorageSettings, StorageSettingsDict } from "@scrypted/sdk/storage-settings";
+import sdk, { BinarySensor, Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, MediaStreamUrl, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, RequestMediaStreamOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, SettingValue, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
+import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import { createBaichuanApi, normalizeUid, type BaichuanTransport } from "./connect";
+import { convertDebugLogsToApiOptions, DebugLogOption, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
 import { ReolinkPtzPresets } from "./presets";
@@ -268,17 +269,36 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             combobox: true,
             immediate: true,
             defaultValue: [],
-            choices: ['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'traceEvents', 'debugH264', 'debugParamSets', 'eventLogs', 'batteryInfo'],
+            choices: getDebugLogChoices(),
             onPut: async (ov, value) => {
-                // Only reconnect if Baichuan-client flags changed; toggling event logs should be immediate.
-                const oldSel = new Set(ov);
-                const newSel = new Set(value);
-                oldSel.delete('eventLogs');
-                newSel.delete('eventLogs');
+                const oldApiOptions = getApiRelevantDebugLogs(ov || []);
+                const newApiOptions = getApiRelevantDebugLogs(value || []);
+
+                const oldSel = new Set(oldApiOptions);
+                const newSel = new Set(newApiOptions);
 
                 const changed = oldSel.size !== newSel.size || Array.from(oldSel).some((k) => !newSel.has(k));
                 if (changed && this.resetBaichuanClient) {
-                    await this.resetBaichuanClient('debugLogs changed');
+                    // Clear any existing timeout
+                    if (this.debugLogsResetTimeout) {
+                        clearTimeout(this.debugLogsResetTimeout);
+                        this.debugLogsResetTimeout = undefined;
+                    }
+
+                    // Defer reset by 2 seconds to allow settings to settle
+                    this.debugLogsResetTimeout = setTimeout(async () => {
+                        this.debugLogsResetTimeout = undefined;
+                        try {
+                            await this.resetBaichuanClient('debugLogs changed');
+                            // Force reconnection with new debug options
+                            this.baichuanApi = undefined;
+                            this.ensureClientPromise = undefined;
+                            // Trigger reconnection
+                            await this.ensureClient();
+                        } catch (e) {
+                            this.getLogger().warn('Failed to reset client after debug logs change', e);
+                        }
+                    }, 2000);
                 }
             },
         },
@@ -461,6 +481,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     protected ensureClientPromise: Promise<ReolinkBaichuanApi> | undefined;
     protected connectionTime: number | undefined;
     protected readonly protocol: BaichuanTransport;
+    private debugLogsResetTimeout: NodeJS.Timeout | undefined;
 
     // Abstract init method that subclasses must implement
     abstract init(): Promise<void>;
@@ -484,6 +505,8 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                 username: this.storageSettings.values.username || '',
                 password: this.storageSettings.values.password || '',
             },
+            // For battery cameras, we use a shared connection
+            sharedConnection: options.type === 'battery',
         });
 
         setTimeout(async () => {
@@ -509,17 +532,8 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     }
 
     getBaichuanDebugOptions(): any | undefined {
-        const sel = new Set<string>(this.storageSettings.values.debugLogs);
-        if (!sel.size) return undefined;
-
-        const debugOptions: any = {};
-        // Only pass through Baichuan client debug flags.
-        const clientKeys = new Set(['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'traceEvents', 'debugH264', 'debugParamSets']);
-        for (const k of sel) {
-            if (!clientKeys.has(k)) continue;
-            debugOptions[k] = true;
-        }
-        return Object.keys(debugOptions).length ? debugOptions : undefined;
+        const debugLogs = this.storageSettings.values.debugLogs || [];
+        return convertDebugLogsToApiOptions(debugLogs);
     }
 
     isRecoverableBaichuanError(e: any): boolean {
@@ -564,12 +578,12 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         try {
             const logger = this.getLogger();
 
-            if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+            if (this.isEventLogsEnabled()) {
                 logger.log(`Baichuan event: ${JSON.stringify(ev)}`);
             }
 
             if (!this.isEventDispatchEnabled()) {
-                if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+                if (this.isEventLogsEnabled()) {
                     logger.debug('Event dispatch is disabled, ignoring event');
                 }
                 return;
@@ -577,7 +591,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
             const channel = this.getRtspChannel();
             if (ev?.channel !== undefined && ev.channel !== channel) {
-                if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+                if (this.isEventLogsEnabled()) {
                     logger.debug(`Event channel ${ev.channel} does not match camera channel ${channel}, ignoring`);
                 }
                 return;
@@ -589,7 +603,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             switch (ev?.type) {
                 case 'motion':
                     motion = true;
-                    if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+                    if (this.isEventLogsEnabled()) {
                         logger.log(`Motion event received (may be PIR or MD)`);
                     }
                     break;
@@ -607,7 +621,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                     motion = true;
                     break;
                 default:
-                    if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+                    if (this.isEventLogsEnabled()) {
                         logger.debug(`Unknown event type: ${ev?.type}`);
                     }
                     return;
@@ -863,6 +877,11 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         }
     }
 
+    isEventLogsEnabled(): boolean {
+        const debugLogs = this.storageSettings.values.debugLogs || [];
+        return debugLogs.includes(DebugLogOption.EventLogs);
+    }
+
     // BinarySensor interface implementation (for doorbell)
     handleDoorbellEvent(): void {
         if (!this.doorbellBinaryTimeout) {
@@ -1394,7 +1413,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                         password,
                         uid: normalizedUid,
                         logger: this.console,
-                        ...(debugOptions ? { debugOptions } : {}),
+                        debugOptions,
                     },
                     transport: this.protocol,
                     logger: this.console,

package/src/connect.ts

@@ -8,7 +8,7 @@ export type BaichuanConnectInputs = {
     password: string;
     uid?: string;
     logger?: Console;
-    debugOptions?: unknown;
+    debugOptions?: BaichuanClientOptions['debugOptions'];
 };
 
 export function normalizeUid(uid?: string): string | undefined {
@@ -52,7 +52,7 @@ export async function createBaichuanApi(props: {
         username: inputs.username,
         password: inputs.password,
         logger: inputs.logger,
-        ...(inputs.debugOptions ? { debugOptions: inputs.debugOptions } : {}),
+        debugOptions: inputs.debugOptions ?? {}
     };
 
     const attachErrorHandler = (api: ReolinkBaichuanApi) => {
@@ -104,6 +104,7 @@ export async function createBaichuanApi(props: {
         ...base,
         transport: "udp",
         uid,
+        idleDisconnect: true,
     });
     attachErrorHandler(api);
     return api;

package/src/debug-options.ts

@@ -0,0 +1,105 @@
+import type { DebugOptions } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+
+/**
+ * User-friendly debug log options enum
+ */
+export enum DebugLogOption {
+    /** General debug logs */
+    General = 'general',
+    /** RTSP proxy/server debug logs */
+    DebugRtsp = 'debugRtsp',
+    /** Stream command tracing */
+    TraceStream = 'traceStream',
+    /** Talkback tracing */
+    TraceTalk = 'traceTalk',
+    /** Event tracing */
+    TraceEvents = 'traceEvents',
+    /** H.264 debug logs */
+    DebugH264 = 'debugH264',
+    /** SPS/PPS parameter sets debug logs */
+    DebugParamSets = 'debugParamSets',
+    /** Event logs (plugin-specific, not passed to API) */
+    EventLogs = 'eventLogs',
+    /** Battery info logs (plugin-specific, not passed to API) */
+    BatteryInfo = 'batteryInfo',
+}
+
+/**
+ * Maps user-friendly enum values to API DebugOptions keys
+ */
+export function mapDebugLogToApiOption(option: DebugLogOption): keyof DebugOptions | null {
+    const mapping: Record<DebugLogOption, keyof DebugOptions | null> = {
+        [DebugLogOption.General]: 'general',
+        [DebugLogOption.DebugRtsp]: 'debugRtsp',
+        [DebugLogOption.TraceStream]: 'traceStream',
+        [DebugLogOption.TraceTalk]: 'traceTalk',
+        [DebugLogOption.TraceEvents]: 'traceEvents',
+        [DebugLogOption.DebugH264]: 'debugH264',
+        [DebugLogOption.DebugParamSets]: 'debugParamSets',
+        [DebugLogOption.EventLogs]: null, // Plugin-specific, not passed to API
+        [DebugLogOption.BatteryInfo]: null, // Plugin-specific, not passed to API
+    };
+    return mapping[option];
+}
+
+/**
+ * Convert array of DebugLogOption enum values to API DebugOptions
+ * Only includes options that are relevant to the API (excludes plugin-specific options)
+ */
+export function convertDebugLogsToApiOptions(debugLogs: string[]): DebugOptions | undefined {
+    const apiOptions: DebugOptions = {};
+    const debugLogsSet = new Set(debugLogs);
+
+    // Iterate over enum values and build API options based on what's selected
+    for (const [key, friendlyName] of Object.entries(DebugLogDisplayNames)) {
+        if (debugLogsSet.has(friendlyName)) {
+            const apiKey = mapDebugLogToApiOption(key as DebugLogOption);
+            if (apiKey) {
+                apiOptions[apiKey] = true;
+            }
+        }
+    }
+
+    console.log(debugLogs, apiOptions);
+    return Object.keys(apiOptions).length > 0 ? apiOptions : undefined;
+}
+
+/**
+ * Get only the API-relevant debug log options (excludes plugin-specific options)
+ * Used to determine if reconnection is needed when debug options change
+ */
+export function getApiRelevantDebugLogs(debugLogs: string[]): string[] {
+    return debugLogs.filter(log => {
+        const option = log as DebugLogOption;
+        const apiKey = mapDebugLogToApiOption(option);
+        // Only include options that map to API keys (exclude plugin-specific options)
+        return apiKey !== null;
+    });
+}
+
+/**
+ * User-friendly display names for debug log options
+ */
+export const DebugLogDisplayNames: Record<DebugLogOption, string> = {
+    [DebugLogOption.General]: 'General',
+    [DebugLogOption.DebugRtsp]: 'RTSP',
+    [DebugLogOption.TraceStream]: 'Trace stream',
+    [DebugLogOption.TraceTalk]: 'Trace talk',
+    [DebugLogOption.TraceEvents]: 'Trace events XML',
+    [DebugLogOption.DebugH264]: 'H264',
+    [DebugLogOption.DebugParamSets]: 'Video param sets',
+    [DebugLogOption.EventLogs]: 'Object detection events',
+    [DebugLogOption.BatteryInfo]: 'Battery info update',
+};
+
+/**
+ * Get debug log choices with user-friendly names
+ * Returns array of strings in format "value=displayName" for Scrypted settings
+ */
+export function getDebugLogChoices(): string[] {
+    return Object.values(DebugLogOption).map(option => {
+        const displayName = DebugLogDisplayNames[option];
+        return `${displayName}`;
+    });
+}
+

package/src/stream-utils.ts

@@ -28,6 +28,8 @@ export interface StreamManagerOptions {
         username: string;
         password: string;
     };
+    /** If true, the stream client is shared with the main connection. Default: false. */
+    sharedConnection?: boolean;
 }
 
 export function parseStreamProfileFromId(id: string | undefined): StreamProfile | undefined {
@@ -321,13 +323,16 @@ export class StreamManager {
             // 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 createScryptedRfc4571TcpServer({
                 api,
                 channel,
                 profile,
                 logger: this.getLogger(),
                 expectedVideoType: expectedVideoType as VideoType | undefined,
-                closeApiOnTeardown: true,
+                closeApiOnTeardown,
                 username,
                 password,
             });
@@ -365,4 +370,23 @@ export class StreamManager {
     ): Promise<RfcServerInfo> {
         return await this.ensureNativeRfcServer(streamKey, channel, profile, expectedVideoType);
     }
+
+    /**
+     * Close all active stream servers.
+     * Useful when the main connection is reset and streams need to be recreated.
+     */
+    async closeAllStreams(reason?: string): Promise<void> {
+        const servers = Array.from(this.nativeRfcServers.values());
+        this.nativeRfcServers.clear();
+        
+        await Promise.allSettled(
+            servers.map(async (server) => {
+                try {
+                    await server.close(reason || 'connection reset');
+                } catch (e) {
+                    this.getLogger().debug('Error closing stream server', e);
+                }
+            })
+        );
+    }
 }

package/pcap/analyze_json.py

@@ -1,248 +0,0 @@
-#!/usr/bin/env python3
-"""
-Analyze Wireshark JSON exports to compare neolink vs scrypted UDP flows.
-"""
-import json
-import sys
-import struct
-from typing import List, Dict, Any
-
-BCUDP_MAGIC_DISCOVERY = 0x3acf872a
-BCUDP_MAGIC_DATA = 0x10cf872a
-BCUDP_MAGIC_ACK = 0x20cf872a
-
-def hex_to_bytes(hex_str: str) -> bytes:
-    """Convert hex string (e.g., '10:cf:87:2a') to bytes."""
-    try:
-        return bytes.fromhex(hex_str.replace(':', '').replace(' ', ''))
-    except:
-        return b''
-
-def parse_bcudp_packet(udp_data_hex: str) -> Dict[str, Any] | None:
-    """Parse BCUDP packet from hex string."""
-    try:
-        data = hex_to_bytes(udp_data_hex)
-        if len(data) < 4:
-            return None
-        
-        # Wireshark exports hex strings in the order they appear in the packet
-        # BCUDP magic numbers are stored as little-endian in the packet
-        # But when we convert hex string to bytes, we get the bytes in order
-        # So 3a:cf:87:2a becomes bytes [0x3a, 0xcf, 0x87, 0x2a]
-        # Reading as little-endian: 0x2a87cf3a (wrong)
-        # Reading as big-endian: 0x3acf872a (correct!)
-        # Actually wait - let me check the actual byte order in the hex string
-        # The hex shows "3a:cf:87:2a" which as bytes is [0x3a, 0xcf, 0x87, 0x2a]
-        # As little-endian uint32: 0x2a87cf3a
-        # As big-endian uint32: 0x3acf872a
-        # So we need big-endian for the magic comparison
-        magic = struct.unpack('>I', data[0:4])[0]
-        
-        if magic == BCUDP_MAGIC_DISCOVERY:
-            return {'type': 'discovery', 'magic': hex(magic), 'payload': udp_data_hex}
-        elif magic == BCUDP_MAGIC_DATA:
-            if len(data) < 20:
-                return None
-            connection_id = int.from_bytes(data[4:8], 'little', signed=True)
-            packet_id = int.from_bytes(data[12:16], 'little')
-            payload_len = int.from_bytes(data[16:20], 'little')
-            return {
-                'type': 'data',
-                'magic': hex(magic),
-                'connection_id': connection_id,
-                'packet_id': packet_id,
-                'payload_len': payload_len,
-                'payload_hex': udp_data_hex[:80]  # First 40 bytes hex
-            }
-        elif magic == BCUDP_MAGIC_ACK:
-            if len(data) < 28:
-                return None
-            connection_id = int.from_bytes(data[4:8], 'little', signed=True)
-            group_id = int.from_bytes(data[12:16], 'little')
-            packet_id = int.from_bytes(data[16:20], 'little')
-            return {
-                'type': 'ack',
-                'magic': hex(magic),
-                'connection_id': connection_id,
-                'group_id': group_id,
-                'packet_id': packet_id,
-                'payload_hex': udp_data_hex[:56]  # First 28 bytes hex
-            }
-    except Exception as e:
-        return None
-    
-    return None
-
-def extract_packets(json_file: str) -> List[Dict[str, Any]]:
-    """Extract BCUDP packets from Wireshark JSON export."""
-    packets = []
-    
-    with open(json_file, 'r') as f:
-        data = json.load(f)
-    
-    for entry in data:
-        source = entry.get('_source', {})
-        layers = source.get('layers', {})
-        
-        # Get frame info
-        frame = layers.get('frame', {})
-        frame_num = int(frame.get('frame.number', '0'))
-        frame_time = float(frame.get('frame.time_relative', '0'))
-        
-        # Get UDP info
-        udp = layers.get('udp', {})
-        if not udp:
-            continue
-        
-        src_port = int(udp.get('udp.srcport', '0'))
-        dst_port = int(udp.get('udp.dstport', '0'))
-        
-        # Get UDP data (from udp.payload field)
-        udp_data_hex = udp.get('udp.payload', '')
-        if not udp_data_hex:
-            continue
-        
-        # Get IP addresses to determine direction
-        ip = layers.get('ip', {})
-        src_ip = ip.get('ip.src', '')
-        dst_ip = ip.get('ip.dst', '')
-        
-        # Parse BCUDP packet
-        bcudp = parse_bcudp_packet(udp_data_hex)
-        if bcudp:
-            packets.append({
-                'frame_num': frame_num,
-                'time': frame_time,
-                'src_ip': src_ip,
-                'dst_ip': dst_ip,
-                'src_port': src_port,
-                'dst_port': dst_port,
-                'bcudp': bcudp
-            })
-    
-    return packets
-
-def print_flow_summary(packets: List[Dict[str, Any]], name: str, limit: int = 100):
-    """Print summary of packet flow."""
-    print(f"\n{'='*100}")
-    print(f"{name}: {len(packets)} BCUDP packets")
-    print(f"{'='*100}")
-    
-    # Count by type
-    discovery_count = sum(1 for p in packets if p['bcudp']['type'] == 'discovery')
-    data_count = sum(1 for p in packets if p['bcudp']['type'] == 'data')
-    ack_count = sum(1 for p in packets if p['bcudp']['type'] == 'ack')
-    
-    print(f"\nCounts: Discovery={discovery_count}, Data={data_count}, ACK={ack_count}")
-    
-    # Show first N packets
-    print(f"\nFirst {min(limit, len(packets))} packets:")
-    for i, pkt in enumerate(packets[:limit]):
-        bcudp = pkt['bcudp']
-        direction = '→' if '192.168' in pkt['dst_ip'] else '←'
-        pkt_type = bcudp['type'].upper()
-        
-        info = [f"#{pkt['frame_num']:4d}", f"{pkt['time']:8.3f}s", direction, pkt_type]
-        
-        if pkt_type == 'DATA':
-            info.append(f"conn={bcudp.get('connection_id', '?')}")
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-            info.append(f"len={bcudp.get('payload_len', '?')}")
-        elif pkt_type == 'ACK':
-            info.append(f"conn={bcudp.get('connection_id', '?')}")
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-            info.append(f"gid={bcudp.get('group_id', '?')}")
-        
-        info.append(f"{pkt['src_port']}→{pkt['dst_port']}")
-        
-        print(' '.join(info))
-        
-        if i < 20:  # Show hex for first 20 packets
-            if 'payload_hex' in bcudp:
-                print(f"      Hex: {bcudp['payload_hex']}")
-
-def compare_initial_sequence(neolink_packets: List[Dict[str, Any]], scrypted_packets: List[Dict[str, Any]]):
-    """Compare the initial sequence after discovery."""
-    print(f"\n{'='*100}")
-    print("INITIAL SEQUENCE COMPARISON (first 50 packets after discovery)")
-    print(f"{'='*100}")
-    
-    # Find first discovery completion (look for D2C_C_R response)
-    nl_discovery_end = None
-    for i, pkt in enumerate(neolink_packets):
-        if pkt['bcudp']['type'] == 'discovery':
-            # Check if it's a response (coming from camera)
-            if '192.168' in pkt['src_ip']:  # From camera
-                nl_discovery_end = i
-                break
-    
-    sc_discovery_end = None
-    for i, pkt in enumerate(scrypted_packets):
-        if pkt['bcudp']['type'] == 'discovery':
-            if '192.168' in pkt['src_ip']:  # From camera
-                sc_discovery_end = i
-                break
-    
-    print(f"\nDiscovery completed at:")
-    print(f"  Neolink:  packet #{nl_discovery_end}" if nl_discovery_end else "  Neolink:  not found")
-    print(f"  Scrypted: packet #{sc_discovery_end}" if sc_discovery_end else "  Scrypted: not found")
-    
-    # Get next 50 packets after discovery
-    nl_next = neolink_packets[nl_discovery_end+1:nl_discovery_end+51] if nl_discovery_end else []
-    sc_next = scrypted_packets[sc_discovery_end+1:sc_discovery_end+51] if sc_discovery_end else []
-    
-    print(f"\nNext 50 packets after discovery:")
-    print(f"  Neolink:  {len(nl_next)} packets")
-    print(f"  Scrypted: {len(sc_next)} packets")
-    
-    print(f"\nNeolink sequence:")
-    for i, pkt in enumerate(nl_next[:30]):
-        bcudp = pkt['bcudp']
-        direction = '→' if '192.168' in pkt['dst_ip'] else '←'
-        pkt_type = bcudp['type'].upper()
-        time_rel = pkt['time'] - (neolink_packets[nl_discovery_end]['time'] if nl_discovery_end else 0)
-        
-        info = [f"{time_rel:6.3f}s", direction, pkt_type]
-        if pkt_type == 'DATA':
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-        elif pkt_type == 'ACK':
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-        
-        print(' '.join(info))
-    
-    print(f"\nScrypted sequence:")
-    for i, pkt in enumerate(sc_next[:30]):
-        bcudp = pkt['bcudp']
-        direction = '→' if '192.168' in pkt['dst_ip'] else '←'
-        pkt_type = bcudp['type'].upper()
-        time_rel = pkt['time'] - (scrypted_packets[sc_discovery_end]['time'] if sc_discovery_end else 0)
-        
-        info = [f"{time_rel:6.3f}s", direction, pkt_type]
-        if pkt_type == 'DATA':
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-        elif pkt_type == 'ACK':
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-        
-        print(' '.join(info))
-
-def main():
-    if len(sys.argv) < 3:
-        print("Usage: python3 analyze_json.py <neolink.json> <scrypted.json>")
-        sys.exit(1)
-    
-    neolink_file = sys.argv[1]
-    scrypted_file = sys.argv[2]
-    
-    print("Loading neolink.json...")
-    neolink_packets = extract_packets(neolink_file)
-    
-    print("Loading scrypted.json...")
-    scrypted_packets = extract_packets(scrypted_file)
-    
-    print_flow_summary(neolink_packets, "NEOLINK", limit=50)
-    print_flow_summary(scrypted_packets, "SCRYPTED", limit=50)
-    compare_initial_sequence(neolink_packets, scrypted_packets)
-
-if __name__ == '__main__':
-    main()
-