Merge pull request #1 from ScopeCreep-zip/fix-multicast-issues

Fix multicast issues

Author: southernmagilla

DEEPWIKI.md

@@ -1,6 +1,6 @@
 # DeepWiki Project Badge
 
-[![DeepWiki](https://mcp.deepwiki.com/badge.svg)](https://mcp.deepwiki.com/project?url=https://github.com/your-org/SpiritStream)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/ScopeCreep-zip/SpiritStream)
 
 This badge enables DeepWiki scanning and documentation for this project.
 

src-frontend/lib/tauri.ts

@@ -24,6 +24,8 @@ export const api = {
   stream: {
     start: (group: OutputGroup, incomingUrl: string) =>
       invoke<number>('start_stream', { group, incomingUrl }),
+    startAll: (groups: OutputGroup[], incomingUrl: string) =>
+      invoke<number[]>('start_all_streams', { groups, incomingUrl }),
     stop: (groupId: string) => invoke<void>('stop_stream', { groupId }),
     stopAll: () => invoke<void>('stop_all_streams'),
     getActiveCount: () => invoke<number>('get_active_stream_count'),

src-frontend/stores/streamStore.ts

@@ -71,8 +71,6 @@ const initialStats: StreamStats = {
   targetStats: {},
 };
 
-const lastSamplesByGroup = new Map<string, { size: number; time: number }>();
-
 export const useStreamStore = create<StreamState>((set, get) => ({
   isStreaming: false,
   activeGroups: new Set(),
@@ -95,10 +93,6 @@ export const useStreamStore = create<StreamState>((set, get) => ({
       const activeGroups = new Set(activeGroupIds);
       const isStreaming = activeCount > 0;
 
-      if (!isStreaming) {
-        lastSamplesByGroup.clear();
-      }
-
       set({
         activeStreamCount: activeCount,
         activeGroups,
@@ -163,19 +157,18 @@ export const useStreamStore = create<StreamState>((set, get) => ({
     set({ globalStatus: 'connecting', error: null });
 
     try {
-      for (const group of groups) {
-        // Skip groups with no targets at all
-        if (group.streamTargets.length === 0) {
-          continue;
-        }
+      const eligibleGroups = groups.filter((group) => group.streamTargets.length > 0);
+      if (eligibleGroups.length === 0) {
+        throw new Error('At least one stream target is required');
+      }
 
-        // Send all targets - backend will filter disabled ones
-        await api.stream.start(group, incomingUrl);
+      await api.stream.startAll(eligibleGroups, incomingUrl);
 
-        const activeGroups = new Set(get().activeGroups);
+      const activeGroups = new Set(get().activeGroups);
+      for (const group of eligibleGroups) {
         activeGroups.add(group.id);
-        set({ activeGroups });
       }
+      set({ activeGroups });
 
       set({
         isStreaming: true,
@@ -191,7 +184,6 @@ export const useStreamStore = create<StreamState>((set, get) => ({
   stopAllGroups: async () => {
     try {
       await api.stream.stopAll();
-      lastSamplesByGroup.clear();
       set({
         activeGroups: new Set(),
         isStreaming: false,
@@ -265,23 +257,7 @@ export const useStreamStore = create<StreamState>((set, get) => ({
 
   updateStats: (groupId, ffmpegStats) => {
     const currentGroupStats = get().groupStats;
-    let bitrate = ffmpegStats.bitrate;
-    const lastSample = lastSamplesByGroup.get(groupId);
-
-    if (
-      lastSample &&
-      ffmpegStats.time > lastSample.time &&
-      ffmpegStats.size >= lastSample.size
-    ) {
-      const deltaBytes = ffmpegStats.size - lastSample.size;
-      const deltaSeconds = ffmpegStats.time - lastSample.time;
-      const instantaneousKbps = (deltaBytes * 8) / 1000 / deltaSeconds;
-      if (Number.isFinite(instantaneousKbps)) {
-        bitrate = instantaneousKbps;
-      }
-    }
-
-    lastSamplesByGroup.set(groupId, { size: ffmpegStats.size, time: ffmpegStats.time });
+    const bitrate = ffmpegStats.bitrate;
 
     // Update per-group stats
     const newGroupStats = {
@@ -327,7 +303,6 @@ export const useStreamStore = create<StreamState>((set, get) => ({
   },
 
   setStreamEnded: (groupId) => {
-    lastSamplesByGroup.delete(groupId);
     const activeGroups = new Set(get().activeGroups);
     activeGroups.delete(groupId);
 
@@ -356,7 +331,6 @@ export const useStreamStore = create<StreamState>((set, get) => ({
   },
 
   setStreamError: (groupId, error) => {
-    lastSamplesByGroup.delete(groupId);
     const activeGroups = new Set(get().activeGroups);
     activeGroups.delete(groupId);
 
@@ -394,7 +368,6 @@ export const useStreamStore = create<StreamState>((set, get) => ({
   setError: (error) => set({ error }),
 
   reset: () => {
-    lastSamplesByGroup.clear();
     set({
       isStreaming: false,
       activeGroups: new Set(),

src-frontend/views/Dashboard.tsx

@@ -1,4 +1,4 @@
-import { useState } from 'react';
+import { useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import {
   Radio,
@@ -47,7 +47,8 @@ export function Dashboard({ onNavigate, onOpenProfileModal, onOpenTargetModal }:
     addOutputGroup,
     removeOutputGroup,
   } = useProfileStore();
-  const { isStreaming, stats, uptime, globalStatus, activeStreamCount } = useStreamStore();
+  const { isStreaming, stats, uptime, globalStatus, activeStreamCount, activeGroups, enabledTargets } =
+    useStreamStore();
   const [isTesting, setIsTesting] = useState(false);
 
   // Get output groups from current profile
@@ -152,9 +153,27 @@ export function Dashboard({ onNavigate, onOpenProfileModal, onOpenTargetModal }:
 
   const targets = getAllTargets();
 
+  const activeTargetCount = useMemo(() => {
+    if (!currentProfile) return 0;
+
+    return currentProfile.outputGroups.reduce((total, group) => {
+      if (!activeGroups.has(group.id)) {
+        return total;
+      }
+      const enabledCount = group.streamTargets.filter((t) => enabledTargets.has(t.id)).length;
+      return total + enabledCount;
+    }, 0);
+  }, [currentProfile, activeGroups, enabledTargets]);
+
   // Use backend-verified active stream count, fallback to local calculation
   const displayActiveCount =
-    activeStreamCount > 0 ? activeStreamCount : isStreaming ? targets.length : 0;
+    activeTargetCount > 0
+      ? activeTargetCount
+      : activeStreamCount > 0
+        ? activeStreamCount
+        : isStreaming
+          ? targets.length
+          : 0;
 
   if (loading) {
     return (

src-frontend/views/StreamManager.tsx

@@ -1,10 +1,12 @@
 import { useEffect, useState, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
-import { Play, Square, Settings2, Activity, Gauge, Clock, Upload } from 'lucide-react';
+import { Play, Square, Settings2, Activity, Gauge, Clock, Upload, Radio, AlertTriangle } from 'lucide-react';
 import { Card, CardHeader, CardTitle, CardDescription, CardBody } from '@/components/ui/Card';
 import { Button } from '@/components/ui/Button';
 import { Alert } from '@/components/ui/Alert';
 import { Toggle } from '@/components/ui/Toggle';
+import { StatsRow } from '@/components/dashboard/StatsRow';
+import { StatBox } from '@/components/dashboard/StatBox';
 import { OutputGroup } from '@/components/stream/OutputGroup';
 import { PlatformIcon } from '@/components/stream/PlatformIcon';
 import { useProfileStore } from '@/stores/profileStore';
@@ -29,6 +31,9 @@ export function StreamManager({ onNavigate }: StreamManagerProps) {
     globalStatus,
     groupStats,
     error: streamError,
+    stats,
+    uptime,
+    activeStreamCount,
     startAllGroups,
     stopAllGroups,
     setTargetEnabled,
@@ -99,6 +104,20 @@ export function StreamManager({ onNavigate }: StreamManagerProps) {
   };
 
   const isConnecting = globalStatus === 'connecting';
+  const activeTargetCount = useMemo(() => {
+    if (!current) return 0;
+
+    return current.outputGroups.reduce((total, group) => {
+      if (!activeGroups.has(group.id)) {
+        return total;
+      }
+      const enabledCount = group.streamTargets.filter((t) => enabledTargets.has(t.id)).length;
+      return total + enabledCount;
+    }, 0);
+  }, [current, activeGroups, enabledTargets]);
+
+  const displayActiveCount =
+    activeTargetCount > 0 ? activeTargetCount : activeStreamCount > 0 ? activeStreamCount : activeGroups.size;
 
   // Calculate total bandwidth for enabled groups
   const totalBandwidth = useMemo(() => {
@@ -201,6 +220,35 @@ export function StreamManager({ onNavigate }: StreamManagerProps) {
         </Alert>
       )}
 
+      <StatsRow>
+        <StatBox
+          icon={<Radio className="w-5 h-5" />}
+          label={t('dashboard.activeStreams')}
+          value={displayActiveCount}
+          change={isStreaming ? t('status.streaming') : t('status.readyToStart')}
+          changeType={isStreaming ? 'positive' : 'neutral'}
+        />
+        <StatBox
+          icon={<Activity className="w-5 h-5" />}
+          label={t('dashboard.totalBitrate')}
+          value={stats.totalBitrate > 0 ? formatBitrate(stats.totalBitrate) : '0 kbps'}
+          change={isStreaming ? t('status.active') : t('status.noActiveStreams')}
+        />
+        <StatBox
+          icon={<AlertTriangle className="w-5 h-5" />}
+          label={t('dashboard.droppedFrames')}
+          value={stats.droppedFrames}
+          change={stats.droppedFrames === 0 ? t('status.noIssues') : t('status.checkConnection')}
+          changeType={stats.droppedFrames === 0 ? 'positive' : 'neutral'}
+        />
+        <StatBox
+          icon={<Clock className="w-5 h-5" />}
+          label={t('dashboard.uptime')}
+          value={formatUptime(Math.floor(uptime))}
+          change={isStreaming ? t('status.live') : t('status.notStreaming')}
+        />
+      </StatsRow>
+
       <Card>
         <CardHeader>
           <div>

src-tauri/src/commands/stream.rs

@@ -30,6 +30,34 @@ pub fn start_stream(
     ffmpeg_handler.start(&group, &incoming_url, &app)
 }
 
+/// Start streaming for multiple output groups in one batch
+#[tauri::command]
+pub fn start_all_streams(
+    app: AppHandle,
+    groups: Vec<OutputGroup>,
+    incoming_url: String,
+    ffmpeg_handler: State<'_, FFmpegHandler>,
+) -> Result<Vec<u32>, String> {
+    if incoming_url.is_empty() {
+        return Err("Incoming URL is required".to_string());
+    }
+
+    if groups.is_empty() {
+        return Err("At least one output group is required".to_string());
+    }
+
+    for group in &groups {
+        if group.video.codec.is_empty() {
+            return Err("Video encoder is required".to_string());
+        }
+        if group.audio.codec.is_empty() {
+            return Err("Audio codec is required".to_string());
+        }
+    }
+
+    ffmpeg_handler.start_all(&groups, &incoming_url, &app)
+}
+
 /// Stop streaming for an output group
 #[tauri::command]
 pub fn stop_stream(

src-tauri/src/lib.rs

@@ -105,6 +105,7 @@ pub fn run() {
             commands::validate_input,
             // Stream commands
             commands::start_stream,
+            commands::start_all_streams,
             commands::stop_stream,
             commands::stop_all_streams,
             commands::get_active_stream_count,