Stream Management

class StreamProfile:
    name = CharField()  # Profile identifier
    command = CharField()  # Executable path
    parameters = TextField()  # Command-line arguments
    is_active = BooleanField()
    user_agent = ForeignKey(UserAgent)
    locked = BooleanField()  # Prevent deletion/modification

class UserAgent:
    name = CharField()  # Friendly name
    user_agent = CharField()  # Full UA string
    description = CharField()
    is_active = BooleanField()

# VLC Media Player
user_agent = "VLC/3.0.16 LibVLC/3.0.16"

# Safari on macOS
user_agent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15"

# iOS Safari  
user_agent = "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15"

# FFmpeg
user_agent = "Lavf/58.76.100"

class StreamProfile:  # M3U account profile
    max_streams = PositiveIntegerField()  # 0 = unlimited
    is_default = BooleanField()
    is_active = BooleanField()

# Track active streams
redis.set(f"channel_stream:{channel_id}", stream_id)
redis.set(f"stream_profile:{stream_id}", profile_id)

# Track profile connections
redis.incr(f"profile_connections:{profile_id}")

# Check limits
current = int(redis.get(f"profile_connections:{profile_id}") or 0)
if max_streams > 0 and current >= max_streams:
    # Try next profile or stream

Channel: ESPN
├── Stream 1: Provider A
│   ├── Profile A (max: 2 connections) → FULL (2/2)
│   └── Profile B (max: 5 connections) → Available (3/5)
└── Stream 2: Provider B
    └── Profile C (unlimited) → Available

New viewer connects:
1. Try Stream 1 / Profile A → Full, skip
2. Try Stream 1 / Profile B → Assign ✓

class Stream:
    stream_hash = CharField(unique=True, db_index=True)
    
    @classmethod
    def generate_hash_key(cls, name, url, tvg_id, keys=None, 
                         m3u_id=None, group=None, stream_id=None):
        # Configurable hash keys
        keys = keys or ['name', 'url', 'tvg_id']
        
        # For XtreamCodes, use stream_id instead of URL
        if account_type == 'XC' and stream_id:
            effective_url = stream_id  # Stable across credential changes
        
        # Build hash from selected fields
        hash_parts = {key: values[key] for key in keys}
        serialized = json.dumps(hash_parts, sort_keys=True)
        return hashlib.sha256(serialized.encode()).hexdigest()

# From CoreSettings
M3U_HASH_KEYS = "name,url,tvg_id"  # Comma-separated

# Examples:
"name,url"        # Hash by name + URL
"tvg_id"          # Hash by TVG ID only
"name,group"      # Hash by name + group
"url,m3u_id"      # Hash by URL + M3U account

class Stream:
    current_viewers = PositiveIntegerField()
    stream_stats = JSONField()  # Video codec, resolution, etc.
    stream_stats_updated_at = DateTimeField()

{
  "video_codec": "h264",
  "resolution": "1920x1080",
  "bitrate_kbps": 5000,
  "fps": 29.97,
  "audio_codec": "aac",
  "audio_channels": 2
}

def get_total_viewers(channel_id):
    """Get viewer count from Redis"""
    redis_client = RedisClient.get_client()
    return int(redis_client.get(f"channel:{channel_id}:viewers") or 0)

# From channels/models.py
def get_stream_profile(self):
    """Get stream profile with priority:
    1. Channel-specific profile
    2. Stream-specific profile  
    3. Default system profile
    """
    if self.stream_profile:
        return self.stream_profile
    
    if self.stream and self.stream.stream_profile:
        return self.stream.stream_profile
        
    return StreamProfile.objects.get(
        id=CoreSettings.get_default_stream_profile_id()
    )

def update_stream_profile(self, new_profile_id):
    """Switch profile for active stream"""
    redis_client = RedisClient.get_client()
    
    # Get current stream and profile
    stream_id = redis_client.get(f"channel_stream:{self.id}")
    current_profile_id = redis_client.get(f"stream_profile:{stream_id}")
    
    # Update profile mapping
    redis_client.set(f"stream_profile:{stream_id}", new_profile_id)
    
    # Adjust connection counters
    redis_client.decr(f"profile_connections:{current_profile_id}")
    redis_client.incr(f"profile_connections:{new_profile_id}")

class Stream:
    custom_properties = JSONField(default=dict)

{
  "provider_id": "12345",
  "quality_tags": ["HD", "50fps", "H.265"],
  "language_tracks": ["eng", "spa", "fra"],
  "subtitle_langs": ["eng", "spa"],
  "drm_protected": false
}

class Stream:
    stream_chno = FloatField()  # Provider channel number

Provider Channel 2.1 → Dispatcharr Channel 102
├── Original: stream_chno = 2.1
└── Remapped: channel_number = 102.0

Channel Setup:
├── Profile A: Direct Proxy (Priority users)
├── Profile B: 1080p Transcode (Standard users)
└── Profile C: 720p Transcode (Mobile users)

Connection Distribution:
├── 10 Priority users → Direct streams
├── 50 Standard users → 1080p (max CPU load)
└── 100+ Mobile users → 720p (low bandwidth)

Setup: VPN-routed Dispatcharr
├── Server: Netherlands (geo-unrestricted)
├── Provider: UK IPTV (geo-locked)
└── Clients: Worldwide

Result:
- All streams route through VPN
- Clients access geo-locked content
- Single VPN connection, multiple clients
- Bandwidth optimization via transcoding

Channel: Premium Sports
├── Stream 1: Primary Provider
│   ├── Profile 1 (3 connections) → Active
│   └── Profile 2 (5 connections) → Backup
├── Stream 2: Secondary Provider  
│   └── Profile 3 (unlimited) → Backup
└── Stream 3: Tertiary Provider
    └── Profile 4 (unlimited) → Last resort

Failover Logic:
1. 3 viewers → Stream 1 / Profile 1
2. 4th viewer → Stream 1 / Profile 2 (Profile 1 full)
3. 9th viewer → Stream 2 / Profile 3 (Stream 1 exhausted)
4. Provider 1 & 2 down → Stream 3 / Profile 4

Server Configuration:
├── 4x NVIDIA GPUs
├── 8x Transcoding profiles (2 per GPU)
└── Load balanced across GPUs

Capacity:
├── 32 concurrent 1080p transcodes
├── 64 concurrent 720p transcodes  
└── Automatic fallback to CPU if GPU full