@apocaliss92/scrypted-reolink-native 0.1.1 → 0.1.3

package/pcap/analyze_pcap.py

@@ -1,135 +0,0 @@
-#!/usr/bin/env python3
-"""Simple PCAP analyzer to compare neolink vs scrypted UDP flows"""
-import sys
-import struct
-
-def read_pcap_header(f):
-    """Read PCAP file header (24 bytes)"""
-    magic = f.read(4)
-    if magic != b'\xd4\xc3\xb2\xa1':  # pcap magic number (little endian)
-        return None
-    version_major, version_minor = struct.unpack('<HH', f.read(4))
-    thiszone, sigfigs = struct.unpack('<II', f.read(8))
-    snaplen, network = struct.unpack('<II', f.read(8))
-    return {
-        'version_major': version_major,
-        'version_minor': version_minor,
-        'snaplen': snaplen,
-        'network': network
-    }
-
-def read_packet_header(f):
-    """Read PCAP packet header (16 bytes)"""
-    data = f.read(16)
-    if len(data) < 16:
-        return None
-    ts_sec, ts_usec, incl_len, orig_len = struct.unpack('<IIII', data)
-    return {
-        'ts_sec': ts_sec,
-        'ts_usec': ts_usec,
-        'incl_len': incl_len,
-        'orig_len': orig_len
-    }
-
-def analyze_pcap(filename):
-    """Basic analysis of UDP packets in PCAP"""
-    with open(filename, 'rb') as f:
-        header = read_pcap_header(f)
-        if not header:
-            print(f"Error: {filename} is not a valid PCAP file")
-            return
-        
-        packets = []
-        packet_num = 0
-        
-        while True:
-            pkt_header = read_packet_header(f)
-            if not pkt_header:
-                break
-            
-            packet_data = f.read(pkt_header['incl_len'])
-            if len(packet_data) < pkt_header['incl_len']:
-                break
-            
-            # Check if this is an Ethernet frame with IPv4 UDP
-            if len(packet_data) >= 42:  # Min Ethernet + IP + UDP headers
-                # Skip Ethernet header (14 bytes), check IP
-                ip_header = packet_data[14:34]
-                if ip_header[0] == 0x45:  # IPv4
-                    protocol = ip_header[9]
-                    if protocol == 17:  # UDP
-                        src_port = struct.unpack('>H', ip_header[20:22])[0]
-                        dst_port = struct.unpack('>H', ip_header[22:24])[0]
-                        udp_data = packet_data[42:]
-                        
-                        # Check for BCUDP magic numbers
-                        if len(udp_data) >= 4:
-                            magic = udp_data[:4]
-                            if magic == b'\x3a\xcf\x87\x2a':  # Discovery
-                                packets.append({
-                                    'num': packet_num,
-                                    'ts': pkt_header['ts_sec'] + pkt_header['ts_usec'] / 1000000,
-                                    'src_port': src_port,
-                                    'dst_port': dst_port,
-                                    'type': 'discovery',
-                                    'data': udp_data[:100]  # First 100 bytes
-                                })
-                            elif magic == b'\x20\xcf\x87\x2a':  # ACK
-                                packets.append({
-                                    'num': packet_num,
-                                    'ts': pkt_header['ts_sec'] + pkt_header['ts_usec'] / 1000000,
-                                    'src_port': src_port,
-                                    'dst_port': dst_port,
-                                    'type': 'ack',
-                                    'data': udp_data[:50]
-                                })
-                            elif magic == b'\x10\xcf\x87\x2a':  # DATA
-                                packets.append({
-                                    'num': packet_num,
-                                    'ts': pkt_header['ts_sec'] + pkt_header['ts_usec'] / 1000000,
-                                    'src_port': src_port,
-                                    'dst_port': dst_port,
-                                    'type': 'data',
-                                    'data': udp_data[:50]
-                                })
-            
-            packet_num += 1
-        
-        print(f"\n=== {filename} ===")
-        print(f"Total packets analyzed: {packet_num}")
-        print(f"BCUDP packets found: {len(packets)}")
-        
-        # Group by type
-        by_type = {}
-        for pkt in packets:
-            by_type.setdefault(pkt['type'], []).append(pkt)
-        
-        for pkt_type, pkts in by_type.items():
-            print(f"\n{pkt_type.upper()}: {len(pkts)} packets")
-            if pkts:
-                print(f"  First at {pkts[0]['ts']:.3f}s, last at {pkts[-1]['ts']:.3f}s")
-                print(f"  Ports: src={set(p['src_port'] for p in pkts)}, dst={set(p['dst_port'] for p in pkts)}")
-        
-        # Show first few discovery packets in detail
-        discovery_pkts = [p for p in packets if p['type'] == 'discovery']
-        if discovery_pkts:
-            print(f"\nFirst 5 discovery packets:")
-            for pkt in discovery_pkts[:5]:
-                print(f"  #{pkt['num']} at {pkt['ts']:.3f}s: {pkt['src_port']} -> {pkt['dst_port']}")
-                # Look for XML-like content
-                data_str = pkt['data'].decode('latin1', errors='ignore')
-                if 'C2D' in data_str or 'D2C' in data_str:
-                    # Try to extract XML tag
-                    start = data_str.find('<')
-                    if start >= 0:
-                        end = data_str.find('>', start)
-                        if end > start:
-                            tag = data_str[start:end+1]
-                            print(f"    Tag: {tag}")
-        
-        return packets
-
-if __name__ == '__main__':
-    neolink_packets = analyze_pcap('neolink.pcapng')
-    print("\n" + "="*60)
-    scrypted_packets = analyze_pcap('scrypted.pcapng')

package/pcap/compare_pcaps.py

@@ -1,274 +0,0 @@
-#!/usr/bin/env python3
-"""
-Compare neolink.pcapng vs scrypted.pcapng to find differences in UDP flow.
-This script parses pcapng files and extracts BCUDP packets for comparison.
-"""
-import struct
-import sys
-from typing import List, Dict, Any
-
-BCUDP_MAGIC_DISCOVERY = 0x3acf872a
-BCUDP_MAGIC_DATA = 0x10cf872a
-BCUDP_MAGIC_ACK = 0x20cf872a
-
-def read_pcapng_block(f) -> tuple[bytes, int] | None:
-    """Read a pcapng block. Returns (block_type, block_data) or None if EOF."""
-    # Read block type (4 bytes)
-    block_type_data = f.read(4)
-    if len(block_type_data) < 4:
-        return None
-    block_type = struct.unpack('<I', block_type_data)[0]
-    
-    # Read block length (4 bytes)
-    block_length_data = f.read(4)
-    if len(block_length_data) < 4:
-        return None
-    block_length = struct.unpack('<I', block_length_data)[0]
-    
-    if block_length < 12:  # Minimum block size (type + len + len)
-        return None
-    
-    # Read block body (length - 8, since we already read type and length)
-    block_body = f.read(block_length - 8)
-    if len(block_body) < block_length - 8:
-        return None
-    
-    # Read trailing length (should match)
-    trailing_length_data = f.read(4)
-    if len(trailing_length_data) < 4:
-        return None
-    trailing_length = struct.unpack('<I', trailing_length_data)[0]
-    
-    if trailing_length != block_length:
-        print(f"Warning: block length mismatch: {block_length} != {trailing_length}")
-    
-    return (block_type, block_body)
-
-def parse_enhanced_packet_block(block_body: bytes) -> Dict[str, Any] | None:
-    """Parse an Enhanced Packet Block (type 6) from pcapng."""
-    if len(block_body) < 16:
-        return None
-    
-    # Read interface ID, timestamp, and packet data length
-    interface_id = struct.unpack('<I', block_body[0:4])[0]
-    timestamp_high = struct.unpack('<I', block_body[4:8])[0]
-    timestamp_low = struct.unpack('<I', block_body[8:12])[0]
-    captured_len = struct.unpack('<I', block_body[12:16])[0]
-    
-    # Packet data starts at offset 16
-    packet_data = block_body[16:16+captured_len]
-    
-    return {
-        'interface_id': interface_id,
-        'timestamp': (timestamp_high << 32) | timestamp_low,
-        'packet_data': packet_data
-    }
-
-def extract_udp_packet(packet_data: bytes) -> Dict[str, Any] | None:
-    """Extract UDP packet from Ethernet frame. Returns None if not UDP."""
-    # Skip Ethernet header (14 bytes)
-    if len(packet_data) < 42:  # Min: 14 (Ethernet) + 20 (IP) + 8 (UDP)
-        return None
-    
-    # Check for IPv4 (0x45 at offset 14)
-    if packet_data[14] != 0x45:
-        return None
-    
-    # Extract IP header fields
-    ip_header = packet_data[14:34]
-    src_ip = '.'.join(str(b) for b in ip_header[12:16])
-    dst_ip = '.'.join(str(b) for b in ip_header[16:20])
-    protocol = ip_header[9]
-    
-    if protocol != 17:  # UDP
-        return None
-    
-    # Extract UDP header
-    udp_header = packet_data[34:42]
-    src_port = struct.unpack('>H', udp_header[0:2])[0]
-    dst_port = struct.unpack('>H', udp_header[2:4])[0]
-    udp_length = struct.unpack('>H', udp_header[4:6])[0]
-    
-    # UDP payload
-    udp_payload = packet_data[42:42+udp_length-8]
-    
-    return {
-        'src_ip': src_ip,
-        'dst_ip': dst_ip,
-        'src_port': src_port,
-        'dst_port': dst_port,
-        'payload': udp_payload
-    }
-
-def parse_bcudp_packet(udp_payload: bytes) -> Dict[str, Any] | None:
-    """Parse BCUDP packet from UDP payload."""
-    if len(udp_payload) < 4:
-        return None
-    
-    magic = struct.unpack('<I', udp_payload[0:4])[0]
-    
-    if magic == BCUDP_MAGIC_DISCOVERY:
-        return {
-            'type': 'discovery',
-            'magic': hex(magic),
-            'payload': udp_payload
-        }
-    elif magic == BCUDP_MAGIC_DATA:
-        if len(udp_payload) < 20:
-            return None
-        connection_id = struct.unpack('<i', udp_payload[4:8])[0]
-        packet_id = struct.unpack('<I', udp_payload[12:16])[0]
-        payload_len = struct.unpack('<I', udp_payload[16:20])[0]
-        return {
-            'type': 'data',
-            'magic': hex(magic),
-            'connection_id': connection_id,
-            'packet_id': packet_id,
-            'payload_len': payload_len,
-            'payload': udp_payload
-        }
-    elif magic == BCUDP_MAGIC_ACK:
-        if len(udp_payload) < 28:
-            return None
-        connection_id = struct.unpack('<i', udp_payload[4:8])[0]
-        group_id = struct.unpack('<I', udp_payload[12:16])[0]
-        packet_id = struct.unpack('<I', udp_payload[16:20])[0]
-        return {
-            'type': 'ack',
-            'magic': hex(magic),
-            'connection_id': connection_id,
-            'group_id': group_id,
-            'packet_id': packet_id,
-            'payload': udp_payload
-        }
-    
-    return None
-
-def analyze_pcapng(filename: str) -> List[Dict[str, Any]]:
-    """Analyze pcapng file and extract BCUDP packets."""
-    packets = []
-    
-    with open(filename, 'rb') as f:
-        # Read Section Header Block (first block, type 0x0A0D0D0A)
-        first_block = read_pcapng_block(f)
-        if not first_block or first_block[0] != 0x0A0D0D0A:
-            print(f"Error: {filename} is not a valid pcapng file")
-            return packets
-        
-        packet_num = 0
-        while True:
-            block = read_pcapng_block(f)
-            if not block:
-                break
-            
-            block_type, block_body = block
-            
-            # Enhanced Packet Block (type 6)
-            if block_type == 6:
-                epb = parse_enhanced_packet_block(block_body)
-                if epb:
-                    udp_pkt = extract_udp_packet(epb['packet_data'])
-                    if udp_pkt:
-                        bcudp_pkt = parse_bcudp_packet(udp_pkt['payload'])
-                        if bcudp_pkt:
-                            packets.append({
-                                'num': packet_num,
-                                'timestamp': epb['timestamp'],
-                                'src_ip': udp_pkt['src_ip'],
-                                'dst_ip': udp_pkt['dst_ip'],
-                                'src_port': udp_pkt['src_port'],
-                                'dst_port': udp_pkt['dst_port'],
-                                'bcudp': bcudp_pkt,
-                                'raw_payload': udp_pkt['payload'].hex()[:100]  # First 50 bytes hex
-                            })
-                            packet_num += 1
-    
-    return packets
-
-def print_packet_summary(packets: List[Dict[str, Any]], name: str):
-    """Print summary of packets."""
-    print(f"\n{'='*80}")
-    print(f"{name}: {len(packets)} BCUDP packets")
-    print(f"{'='*80}")
-    
-    for i, pkt in enumerate(packets[:50]):  # Show first 50 packets
-        bcudp = pkt['bcudp']
-        direction = '→' if '192.168' in pkt['dst_ip'] else '←'
-        pkt_type = bcudp['type'].upper()
-        
-        info_parts = [f"#{pkt['num']}", direction, pkt_type]
-        
-        if pkt_type == 'DATA':
-            info_parts.append(f"conn={bcudp.get('connection_id', '?')}")
-            info_parts.append(f"pid={bcudp.get('packet_id', '?')}")
-            info_parts.append(f"len={bcudp.get('payload_len', '?')}")
-        elif pkt_type == 'ACK':
-            info_parts.append(f"conn={bcudp.get('connection_id', '?')}")
-            info_parts.append(f"pid={bcudp.get('packet_id', '?')}")
-            info_parts.append(f"gid={bcudp.get('group_id', '?')}")
-        
-        info_parts.append(f"{pkt['src_port']}→{pkt['dst_port']}")
-        
-        print(f"{' '.join(info_parts)}")
-        if i < 10:  # Show hex for first 10 packets
-            print(f"  Hex: {pkt['raw_payload']}...")
-    
-    if len(packets) > 50:
-        print(f"... and {len(packets) - 50} more packets")
-
-def compare_flows(neolink_packets: List[Dict[str, Any]], scrypted_packets: List[Dict[str, Any]]):
-    """Compare the two flows and highlight differences."""
-    print(f"\n{'='*80}")
-    print("COMPARISON")
-    print(f"{'='*80}")
-    
-    print(f"\nNeolink: {len(neolink_packets)} BCUDP packets")
-    print(f"Scrypted: {len(scrypted_packets)} BCUDP packets")
-    
-    # Find first DATA packets
-    neolink_first_data = next((p for p in neolink_packets if p['bcudp']['type'] == 'data'), None)
-    scrypted_first_data = next((p for p in scrypted_packets if p['bcudp']['type'] == 'data'), None)
-    
-    if neolink_first_data and scrypted_first_data:
-        print(f"\nFirst DATA packet:")
-        print(f"  Neolink:  conn={neolink_first_data['bcudp'].get('connection_id')}, pid={neolink_first_data['bcudp'].get('packet_id')}, {neolink_first_data['src_port']}→{neolink_first_data['dst_port']}")
-        print(f"  Scrypted: conn={scrypted_first_data['bcudp'].get('connection_id')}, pid={scrypted_first_data['bcudp'].get('packet_id')}, {scrypted_first_data['src_port']}→{scrypted_first_data['dst_port']}")
-        print(f"  Hex Neolink:  {neolink_first_data['raw_payload']}")
-        print(f"  Hex Scrypted: {scrypted_first_data['raw_payload']}")
-        
-        if neolink_first_data['raw_payload'] != scrypted_first_data['raw_payload']:
-            print(f"  ⚠️  DIFFERENT HEX!")
-        else:
-            print(f"  ✓ Same hex")
-    
-    # Count DATA/ACK packets after discovery
-    neolink_data_count = sum(1 for p in neolink_packets if p['bcudp']['type'] == 'data')
-    neolink_ack_count = sum(1 for p in neolink_packets if p['bcudp']['type'] == 'ack')
-    scrypted_data_count = sum(1 for p in scrypted_packets if p['bcudp']['type'] == 'data')
-    scrypted_ack_count = sum(1 for p in scrypted_packets if p['bcudp']['type'] == 'ack')
-    
-    print(f"\nPacket counts:")
-    print(f"  Neolink:  {neolink_data_count} DATA, {neolink_ack_count} ACK")
-    print(f"  Scrypted: {scrypted_data_count} DATA, {scrypted_ack_count} ACK")
-
-def main():
-    if len(sys.argv) < 3:
-        print("Usage: python3 compare_pcaps.py <neolink.pcapng> <scrypted.pcapng>")
-        sys.exit(1)
-    
-    neolink_file = sys.argv[1]
-    scrypted_file = sys.argv[2]
-    
-    print("Analyzing neolink.pcapng...")
-    neolink_packets = analyze_pcapng(neolink_file)
-    
-    print("Analyzing scrypted.pcapng...")
-    scrypted_packets = analyze_pcapng(scrypted_file)
-    
-    print_packet_summary(neolink_packets, "NEOLINK")
-    print_packet_summary(scrypted_packets, "SCRYPTED")
-    compare_flows(neolink_packets, scrypted_packets)
-
-if __name__ == '__main__':
-    main()
-

package/pcap/compare_stream_flow.py

@@ -1,222 +0,0 @@
-#!/usr/bin/env python3
-"""
-Compare stream flow between neolink and scrypted after discovery/nonce request.
-Focus on DATA/ACK packets to identify why stream might stall.
-"""
-import json
-import sys
-import struct
-
-BCUDP_MAGIC_DATA = 0x10cf872a
-BCUDP_MAGIC_ACK = 0x20cf872a
-
-def hex_to_bytes(hex_str: str) -> bytes:
-    try:
-        return bytes.fromhex(hex_str.replace(':', '').replace(' ', ''))
-    except:
-        return b''
-
-def parse_bcudp_data(data: bytes):
-    """Parse BCUDP DATA packet."""
-    if len(data) < 20:
-        return None
-    magic = struct.unpack('>I', data[0:4])[0]
-    if magic != BCUDP_MAGIC_DATA:
-        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', 'connection_id': connection_id, 'packet_id': packet_id, 'payload_len': payload_len}
-
-def parse_bcudp_ack(data: bytes):
-    """Parse BCUDP ACK packet."""
-    if len(data) < 28:
-        return None
-    magic = struct.unpack('>I', data[0:4])[0]
-    if magic != BCUDP_MAGIC_ACK:
-        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', 'connection_id': connection_id, 'group_id': group_id, 'packet_id': packet_id}
-
-def extract_stream_packets(json_file: str):
-    """Extract DATA and ACK packets from stream."""
-    packets = []
-    
-    with open(json_file, 'r') as f:
-        data = json.load(f)
-    
-    for entry in data:
-        source = entry.get('_source', {})
-        layers = source.get('layers', {})
-        frame = layers.get('frame', {})
-        frame_num = int(frame.get('frame.number', '0'))
-        frame_time = float(frame.get('frame.time_relative', '0'))
-        udp = layers.get('udp', {})
-        if not udp:
-            continue
-        src_port = int(udp.get('udp.srcport', '0'))
-        dst_port = int(udp.get('udp.dstport', '0'))
-        ip = layers.get('ip', {})
-        src_ip = ip.get('ip.src', '')
-        payload_hex = udp.get('udp.payload', '')
-        if not payload_hex:
-            continue
-        
-        bytes_data = hex_to_bytes(payload_hex)
-        if len(bytes_data) < 4:
-            continue
-        
-        # Try to parse as DATA or ACK
-        pkt_data = parse_bcudp_data(bytes_data)
-        if pkt_data:
-            packets.append({
-                'frame_num': frame_num,
-                'time': frame_time,
-                'src_ip': src_ip,
-                'src_port': src_port,
-                'dst_port': dst_port,
-                **pkt_data
-            })
-            continue
-        
-        pkt_ack = parse_bcudp_ack(bytes_data)
-        if pkt_ack:
-            packets.append({
-                'frame_num': frame_num,
-                'time': frame_time,
-                'src_ip': src_ip,
-                'src_port': src_port,
-                'dst_port': dst_port,
-                **pkt_ack
-            })
-    
-    return packets
-
-def analyze_stream_flow(packets, name: str):
-    """Analyze stream flow statistics."""
-    print(f"\n{'='*100}")
-    print(f"{name}: Stream Flow Analysis")
-    print(f"{'='*100}")
-    
-    data_packets = [p for p in packets if p['type'] == 'data']
-    ack_packets = [p for p in packets if p['type'] == 'ack']
-    
-    print(f"\nTotal packets: {len(packets)} (DATA: {len(data_packets)}, ACK: {len(ack_packets)})")
-    
-    if not data_packets:
-        print("  No DATA packets found!")
-        return
-    
-    # Find direction: camera->client (DATA) vs client->camera (ACK)
-    # Assuming camera IP is 192.168.x.x
-    camera_data = [p for p in data_packets if '192.168' in p['src_ip']]
-    client_data = [p for p in data_packets if '192.168' not in p['src_ip']]
-    
-    camera_ack = [p for p in ack_packets if '192.168' in p['src_ip']]
-    client_ack = [p for p in ack_packets if '192.168' not in p['src_ip']]
-    
-    print(f"\nDirection breakdown:")
-    print(f"  Camera→Client DATA: {len(camera_data)}")
-    print(f"  Client→Camera DATA: {len(client_data)}")
-    print(f"  Camera→Client ACK:  {len(camera_ack)}")
-    print(f"  Client→Camera ACK:  {len(client_ack)}")
-    
-    if camera_data:
-        print(f"\nCamera→Client DATA packets:")
-        print(f"  First: frame #{camera_data[0]['frame_num']}, time {camera_data[0]['time']:.3f}s, pid={camera_data[0]['packet_id']}")
-        print(f"  Last:  frame #{camera_data[-1]['frame_num']}, time {camera_data[-1]['time']:.3f}s, pid={camera_data[-1]['packet_id']}")
-        print(f"  Duration: {camera_data[-1]['time'] - camera_data[0]['time']:.3f}s")
-        print(f"  Packet ID range: {camera_data[0]['packet_id']} → {camera_data[-1]['packet_id']}")
-        
-        # Check for gaps
-        pids = sorted([p['packet_id'] for p in camera_data])
-        gaps = []
-        for i in range(len(pids) - 1):
-            gap = pids[i+1] - pids[i]
-            if gap > 1:
-                gaps.append((pids[i], pids[i+1], gap))
-        if gaps:
-            print(f"  ⚠️  Found {len(gaps)} gaps in packet IDs:")
-            for start, end, gap in gaps[:10]:
-                print(f"     Missing: {start+1} to {end-1} (gap={gap-1})")
-        else:
-            print(f"  ✓ No gaps in packet IDs")
-        
-        # Check packet rate
-        if len(camera_data) > 1:
-            duration = camera_data[-1]['time'] - camera_data[0]['time']
-            rate = len(camera_data) / duration if duration > 0 else 0
-            print(f"  Packet rate: {rate:.2f} packets/sec")
-    
-    # Check ACK frequency from client
-    if client_ack:
-        print(f"\nClient→Camera ACK packets:")
-        print(f"  Total: {len(client_ack)}")
-        if len(client_ack) > 1:
-            duration = client_ack[-1]['time'] - client_ack[0]['time']
-            rate = len(client_ack) / duration if duration > 0 else 0
-            print(f"  ACK rate: {rate:.2f} ACKs/sec")
-            print(f"  First ACK: time {client_ack[0]['time']:.3f}s, pid={client_ack[0]['packet_id']}")
-            print(f"  Last ACK:  time {client_ack[-1]['time']:.3f}s, pid={client_ack[-1]['packet_id']}")
-
-def compare_streams(nl_packets, sc_packets):
-    """Compare stream flows."""
-    print(f"\n{'='*100}")
-    print("COMPARISON")
-    print(f"{'='*100}")
-    
-    nl_camera_data = [p for p in nl_packets if p['type'] == 'data' and '192.168' in p['src_ip']]
-    sc_camera_data = [p for p in sc_packets if p['type'] == 'data' and '192.168' in p['src_ip']]
-    
-    nl_client_ack = [p for p in nl_packets if p['type'] == 'ack' and '192.168' not in p['src_ip']]
-    sc_client_ack = [p for p in sc_packets if p['type'] == 'ack' and '192.168' not in p['src_ip']]
-    
-    print(f"\nCamera→Client DATA packets:")
-    print(f"  Neolink:  {len(nl_camera_data)} packets")
-    print(f"  Scrypted: {len(sc_camera_data)} packets")
-    print(f"  Ratio:    {len(sc_camera_data) / len(nl_camera_data) * 100 if nl_camera_data else 0:.1f}%")
-    
-    print(f"\nClient→Camera ACK packets:")
-    print(f"  Neolink:  {len(nl_client_ack)} packets")
-    print(f"  Scrypted: {len(sc_client_ack)} packets")
-    print(f"  Ratio:    {len(sc_client_ack) / len(nl_client_ack) * 100 if nl_client_ack else 0:.1f}%")
-    
-    if nl_camera_data and sc_camera_data:
-        nl_duration = nl_camera_data[-1]['time'] - nl_camera_data[0]['time']
-        sc_duration = sc_camera_data[-1]['time'] - sc_camera_data[0]['time']
-        print(f"\nStream duration:")
-        print(f"  Neolink:  {nl_duration:.2f}s")
-        print(f"  Scrypted: {sc_duration:.2f}s")
-        
-        nl_rate = len(nl_camera_data) / nl_duration if nl_duration > 0 else 0
-        sc_rate = len(sc_camera_data) / sc_duration if sc_duration > 0 else 0
-        print(f"\nPacket rate:")
-        print(f"  Neolink:  {nl_rate:.2f} packets/sec")
-        print(f"  Scrypted: {sc_rate:.2f} packets/sec")
-        
-        if sc_rate < nl_rate * 0.5:
-            print(f"  ⚠️  Scrypted has much lower packet rate!")
-
-def main():
-    if len(sys.argv) < 3:
-        print("Usage: python3 compare_stream_flow.py <neolink.json> <scrypted.json>")
-        sys.exit(1)
-    
-    neolink_file = sys.argv[1]
-    scrypted_file = sys.argv[2]
-    
-    print("Loading neolink.json...")
-    nl_packets = extract_stream_packets(neolink_file)
-    
-    print("Loading scrypted.json...")
-    sc_packets = extract_stream_packets(scrypted_file)
-    
-    analyze_stream_flow(nl_packets, "NEOLINK")
-    analyze_stream_flow(sc_packets, "SCRYPTED")
-    compare_streams(nl_packets, sc_packets)
-
-if __name__ == '__main__':
-    main()
-